@fairyhunter13/opentui-core 0.1.113 → 0.1.114

package/src/benchmark/markdown-benchmark.ts

@@ -0,0 +1,1796 @@
+#!/usr/bin/env bun
+
+import { MarkdownRenderable, SyntaxStyle, createCliRenderer, parseColor } from "../index.js"
+import { resolveRenderLib } from "../zig.js"
+import { Command } from "commander"
+import path from "node:path"
+import { existsSync } from "node:fs"
+import { mkdir, mkdtemp, readFile, unlink } from "node:fs/promises"
+import { tmpdir } from "node:os"
+
+const realStdoutWrite = process.stdout.write.bind(process.stdout)
+const nativeLib = resolveRenderLib()
+const nativeBuildOptions = nativeLib.getBuildOptions()
+
+const WORDS = [
+  "alpha",
+  "bravo",
+  "charlie",
+  "delta",
+  "echo",
+  "foxtrot",
+  "golf",
+  "hotel",
+  "india",
+  "juliet",
+  "kilo",
+  "lima",
+  "mango",
+  "nectar",
+  "oscar",
+  "papa",
+  "quartz",
+  "romeo",
+  "sierra",
+  "tango",
+  "uniform",
+  "vector",
+  "whiskey",
+  "xray",
+  "yankee",
+  "zulu",
+  "matrix",
+  "signal",
+  "tensor",
+  "render",
+  "schema",
+  "buffer",
+  "layout",
+  "stream",
+  "parser",
+  "syntax",
+  "viewport",
+  "cursor",
+]
+
+const CODE_WORDS = [
+  "buffer",
+  "column",
+  "row",
+  "token",
+  "state",
+  "table",
+  "stream",
+  "render",
+  "result",
+  "index",
+  "value",
+  "output",
+  "content",
+]
+
+type MemorySample = {
+  rss: number
+  heapTotal: number
+  heapUsed: number
+  external: number
+  arrayBuffers: number
+}
+
+type MemoryFieldStats = {
+  min: number
+  max: number
+  avg: number
+  median: number
+}
+
+type MemoryStats = {
+  samples: number
+  start: MemorySample
+  end: MemorySample
+  delta: MemorySample
+  peak: MemorySample
+  fields: {
+    rss: MemoryFieldStats
+    heapTotal: MemoryFieldStats
+    heapUsed: MemoryFieldStats
+    external: MemoryFieldStats
+    arrayBuffers: MemoryFieldStats
+  }
+}
+
+type NativeMemorySample = {
+  totalRequestedBytes: number
+  activeAllocations: number
+  smallAllocations: number
+  largeAllocations: number
+  requestedBytesValid: boolean
+}
+
+type NativeMemoryStats = {
+  samples: number
+  start: NativeMemorySample
+  end: NativeMemorySample
+  delta: NativeMemorySample
+  peak: NativeMemorySample
+  requestedBytesReliable: boolean
+  fields: {
+    totalRequestedBytes: MemoryFieldStats
+    activeAllocations: MemoryFieldStats
+    smallAllocations: MemoryFieldStats
+    largeAllocations: MemoryFieldStats
+  }
+}
+
+type TimingStats = {
+  count: number
+  averageMs: number
+  medianMs: number
+  p95Ms: number
+  minMs: number
+  maxMs: number
+  stdDevMs: number
+}
+
+type ScenarioResult = {
+  name: string
+  description: string
+  iterations: number
+  warmupIterations: number
+  elapsedMs: number
+  category: "parse" | "incremental" | "style"
+  timingMode: "content-set" | "style-refresh"
+  updateStats: TimingStats
+  memoryStats?: MemoryStats
+  nativeMemoryStats?: NativeMemoryStats
+  contentStats: {
+    initialChars: number
+    finalChars: number
+    maxChars: number
+    updates: number
+    appendedChars: number
+  }
+  settings: Record<string, unknown>
+}
+
+type StaticScenarioPlan = {
+  kind: "static"
+  name: string
+  description: string
+  iterations: number
+  warmupIterations: number
+  content: string
+  contentStats: Record<string, number>
+}
+
+type StreamingScenarioPlan = {
+  kind: "streaming"
+  name: string
+  description: string
+  iterations: number
+  warmupIterations: number
+  baseContent: string
+  chunks: string[]
+  repeat: boolean
+  contentStats: Record<string, number>
+}
+
+type StyleScenarioPlan = {
+  kind: "style"
+  name: string
+  description: string
+  iterations: number
+  warmupIterations: number
+  content: string
+  contentStats: Record<string, number>
+}
+
+type ScenarioPlan = StaticScenarioPlan | StreamingScenarioPlan | StyleScenarioPlan
+
+type StreamState = {
+  content: string
+  chunks: string[]
+  cursor: number
+  repeat: boolean
+  maxChars: number
+  maxContentChars: number
+  done: boolean
+}
+
+type RunContext = {
+  renderer: Awaited<ReturnType<typeof createCliRenderer>>
+  markdown: MarkdownRenderable
+  syntaxStyleA: SyntaxStyle
+  syntaxStyleB: SyntaxStyle
+  streamIntervalMs: number
+  chunkLines: number
+  maxChars: number
+  memInterval: number
+  memSampleEvery: number
+}
+
+type SuiteConfig = {
+  iterations: number
+  warmupIterations: number
+  longIterations: number
+  scale: number
+}
+
+type MemorySampler = {
+  jsSamples: MemorySample[]
+  nativeSamples: NativeMemorySample[]
+  recordIteration: (iteration: number) => void
+  stop: () => void
+}
+
+type StaticScenarioConfig = {
+  title: string
+  sections: number
+  paragraphsPerSection: number
+  sentencesPerParagraph: number
+  lists: number
+  listItems: number
+  tables: number
+  tableRows: number
+  tableCols: number
+  codeBlocks: number
+  codeLines: number
+}
+
+type StreamingScenarioConfig = StaticScenarioConfig & {
+  repeat: boolean
+}
+
+type OutputMeta = {
+  suiteName: string
+  targetFps: number
+  maxFps: number
+  iterations: number
+  warmupIterations: number
+  longIterations: number
+  streamIntervalMs: number
+  chunkLines: number
+  maxChars: number
+  scale: number
+  seed: number
+  memInterval: number
+  memSampleEvery: number
+  gpaSafeStats: boolean
+  gpaMemoryLimitTracking: boolean
+}
+
+const program = new Command()
+program
+  .name("markdown-benchmark")
+  .description("MarkdownRenderable benchmark scenarios (frame-independent)")
+  .option("-s, --suite <name>", "benchmark suite: quick, default, long", "default")
+  .option("-i, --iterations <count>", "iterations per scenario", "1000")
+  .option("--warmup-iterations <count>", "warmup iterations per scenario", "50")
+  .option("--long-iterations <count>", "iterations for long streaming scenario", "3000")
+  .option("--target-fps <fps>", "renderer target fps", "60")
+  .option("--max-fps <fps>", "renderer max fps", "60")
+  .option("--mem-interval <ms>", "time-based memory sampling in ms (0 disables)", "0")
+  .option("--mem-sample-every <count>", "sample memory every N iterations (0 disables)", "10")
+  .option("--stream-interval <ms>", "stream update interval in ms", "0")
+  .option("--chunk-lines <count>", "lines appended per stream tick", "4")
+  .option("--max-chars <count>", "max streaming content size before stopping growth", "5000000")
+  .option("--scale <n>", "scale content size", "1")
+  .option("--seed <n>", "seed for deterministic content", "1337")
+  .option("--json [path]", "write JSON results to file")
+  .option("--no-testing", "use production renderer (outputs to terminal)")
+  .option("--scenario <name>", "run a single scenario")
+  .option("--no-spawn-per-scenario", "run all scenarios in a single process")
+  .option("--no-output", "suppress stdout output")
+  .parse(process.argv)
+
+const options = program.opts()
+
+const suiteName = String(options.suite)
+const iterations = Math.max(1, Math.floor(toNumber(options.iterations, 1000)))
+const warmupIterations = Math.max(0, Math.floor(toNumber(options.warmupIterations, 50)))
+const longIterations = Math.max(iterations, Math.floor(toNumber(options.longIterations, 3000)))
+const targetFps = toNumber(options.targetFps, 60)
+const maxFps = toNumber(options.maxFps, 60)
+const memInterval = Math.max(0, Math.floor(toNumber(options.memInterval, 0)))
+const memSampleEvery = Math.max(0, Math.floor(toNumber(options.memSampleEvery, 10)))
+const streamIntervalMs = Math.max(0, Math.floor(toNumber(options.streamInterval, 0)))
+const chunkLines = Math.max(1, Math.floor(toNumber(options.chunkLines, 4)))
+const maxChars = Math.max(0, Math.floor(toNumber(options.maxChars, 5000000)))
+const scale = Math.max(0.25, toNumber(options.scale, 1))
+const seed = Math.max(1, Math.floor(toNumber(options.seed, 1337)))
+const testing = options.testing !== false
+const outputEnabled = options.output !== false
+const scenarioFilter = options.scenario ? String(options.scenario) : null
+const spawnPerScenario = options.spawnPerScenario !== false
+
+const jsonArg = options.json
+const jsonPath =
+  typeof jsonArg === "string"
+    ? path.resolve(process.cwd(), jsonArg)
+    : jsonArg
+      ? path.resolve(process.cwd(), "latest-markdown-bench-run.json")
+      : null
+
+if (jsonPath) {
+  const dir = path.dirname(jsonPath)
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true })
+  }
+  if (existsSync(jsonPath)) {
+    console.error(`Error: output file already exists: ${jsonPath}`)
+    process.exit(1)
+  }
+}
+
+const scenarios = createScenarios(
+  suiteName,
+  {
+    iterations,
+    warmupIterations,
+    longIterations,
+    scale,
+  },
+  seed,
+)
+
+const filteredScenarios = scenarioFilter ? scenarios.filter((scenario) => scenario.name === scenarioFilter) : scenarios
+
+if (scenarioFilter && filteredScenarios.length === 0) {
+  writeLine(`Unknown scenario: ${scenarioFilter}`)
+  process.exit(1)
+}
+
+if (filteredScenarios.length === 0) {
+  console.error(`Unknown suite: ${suiteName}`)
+  process.exit(1)
+}
+
+if (spawnPerScenario && !scenarioFilter) {
+  await runSpawnedScenarios(filteredScenarios)
+  process.exit(0)
+}
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true,
+  targetFps,
+  maxFps,
+  testing,
+  screenMode: "main-screen",
+  externalOutputMode: "passthrough",
+  consoleMode: "disabled",
+  useMouse: false,
+})
+
+renderer.requestRender = () => {}
+
+const syntaxStyleA = SyntaxStyle.fromStyles({
+  default: { fg: parseColor("#E6EDF3") },
+  "markup.heading": { fg: parseColor("#88C0D0"), bold: true },
+  "markup.heading.1": { fg: parseColor("#8FBCBB"), bold: true },
+  "markup.heading.2": { fg: parseColor("#81A1C1"), bold: true },
+  "markup.heading.3": { fg: parseColor("#5E81AC"), bold: true },
+  "markup.bold": { fg: parseColor("#ECEFF4"), bold: true },
+  "markup.strong": { fg: parseColor("#ECEFF4"), bold: true },
+  "markup.italic": { fg: parseColor("#E5E9F0"), italic: true },
+  "markup.list": { fg: parseColor("#B48EAD") },
+  "markup.raw": { fg: parseColor("#A3BE8C") },
+  "markup.raw.block": { fg: parseColor("#A3BE8C") },
+  "markup.raw.inline": { fg: parseColor("#A3BE8C") },
+  "markup.link": { fg: parseColor("#81A1C1"), underline: true },
+  "markup.link.label": { fg: parseColor("#88C0D0"), underline: true },
+  "markup.link.url": { fg: parseColor("#88C0D0"), underline: true },
+  "punctuation.special": { fg: parseColor("#616E88") },
+  conceal: { fg: parseColor("#4C566A") },
+})
+
+const syntaxStyleB = SyntaxStyle.fromStyles({
+  default: { fg: parseColor("#F8F8F2") },
+  "markup.heading": { fg: parseColor("#A6E22E"), bold: true },
+  "markup.heading.1": { fg: parseColor("#F92672"), bold: true },
+  "markup.heading.2": { fg: parseColor("#66D9EF"), bold: true },
+  "markup.heading.3": { fg: parseColor("#E6DB74") },
+  "markup.bold": { fg: parseColor("#F8F8F2"), bold: true },
+  "markup.strong": { fg: parseColor("#F8F8F2"), bold: true },
+  "markup.italic": { fg: parseColor("#F8F8F2"), italic: true },
+  "markup.list": { fg: parseColor("#F92672") },
+  "markup.raw": { fg: parseColor("#E6DB74") },
+  "markup.raw.block": { fg: parseColor("#E6DB74") },
+  "markup.raw.inline": { fg: parseColor("#E6DB74") },
+  "markup.link": { fg: parseColor("#66D9EF"), underline: true },
+  "markup.link.label": { fg: parseColor("#E6DB74"), underline: true },
+  "markup.link.url": { fg: parseColor("#66D9EF"), underline: true },
+  "punctuation.special": { fg: parseColor("#75715E") },
+  conceal: { fg: parseColor("#75715E") },
+})
+
+const markdown = new MarkdownRenderable(renderer, {
+  id: "markdown-bench",
+  content: "",
+  syntaxStyle: syntaxStyleA,
+  conceal: true,
+})
+
+const ctx: RunContext = {
+  renderer,
+  markdown,
+  syntaxStyleA,
+  syntaxStyleB,
+  streamIntervalMs,
+  chunkLines,
+  maxChars,
+  memInterval,
+  memSampleEvery,
+}
+
+const results: ScenarioResult[] = []
+const scenarioLines: string[] = []
+
+try {
+  for (let i = 0; i < filteredScenarios.length; i += 1) {
+    const plan = filteredScenarios[i]
+    const result = await runScenario(plan, ctx)
+    scenarioLines.push(formatScenarioResult(result))
+    results.push(result)
+  }
+} finally {
+  renderer.destroy()
+}
+
+await outputResults(
+  {
+    suiteName,
+    targetFps,
+    maxFps,
+    iterations,
+    warmupIterations,
+    longIterations,
+    streamIntervalMs,
+    chunkLines,
+    maxChars,
+    scale,
+    seed,
+    memInterval,
+    memSampleEvery,
+    gpaSafeStats: nativeBuildOptions.gpaSafeStats,
+    gpaMemoryLimitTracking: nativeBuildOptions.gpaMemoryLimitTracking,
+  },
+  results,
+  scenarioLines,
+  outputEnabled,
+  jsonPath,
+)
+
+function createScenarios(suite: string, config: SuiteConfig, runSeed: number): ScenarioPlan[] {
+  const rng = createRng(runSeed)
+  const baseIterations = config.iterations
+  const baseWarmup = config.warmupIterations
+  const longIterations = config.longIterations
+
+  const staticSmallDoc = buildMarkdownDocument(rng, {
+    title: "Markdown Static Small",
+    sections: scaled(3, config.scale),
+    paragraphsPerSection: scaled(2, config.scale),
+    sentencesPerParagraph: 3,
+    lists: scaled(2, config.scale),
+    listItems: 6,
+    tables: scaled(2, config.scale),
+    tableRows: scaled(12, config.scale),
+    tableCols: 4,
+    codeBlocks: scaled(2, config.scale),
+    codeLines: 8,
+  })
+
+  const staticLargeDoc = buildMarkdownDocument(rng, {
+    title: "Markdown Static Large",
+    sections: scaled(6, config.scale),
+    paragraphsPerSection: scaled(3, config.scale),
+    sentencesPerParagraph: 4,
+    lists: scaled(3, config.scale),
+    listItems: 8,
+    tables: scaled(6, config.scale),
+    tableRows: scaled(40, config.scale),
+    tableCols: 6,
+    codeBlocks: scaled(4, config.scale),
+    codeLines: 14,
+  })
+
+  const tableOnlySmallDoc = buildTableOnlyDocument(rng, {
+    title: "Markdown Tables Only Small",
+    tables: scaled(3, config.scale),
+    rows: scaled(24, config.scale),
+    cols: 4,
+  })
+
+  const tableOnlyLargeDoc = buildTableOnlyDocument(rng, {
+    title: "Markdown Tables Only Large",
+    tables: scaled(8, config.scale),
+    rows: scaled(60, config.scale),
+    cols: 6,
+  })
+
+  const codeOnlySmallDoc = buildCodeOnlyDocument(rng, {
+    title: "Markdown Code Only Small",
+    blocks: scaled(8, config.scale),
+    lines: scaled(10, config.scale),
+  })
+
+  const codeOnlyLargeDoc = buildCodeOnlyDocument(rng, {
+    title: "Markdown Code Only Large",
+    blocks: scaled(24, config.scale),
+    lines: scaled(16, config.scale),
+  })
+
+  const headingsOnlyDoc = buildHeadingsOnlyDocument(rng, {
+    title: "Markdown Headings Only",
+    headings: scaled(200, config.scale),
+    depthMin: 2,
+    depthMax: 4,
+    wordsPerHeading: 4,
+  })
+
+  const streamMixedConfig = {
+    title: "Markdown Stream Mixed",
+    sections: scaled(5, config.scale),
+    paragraphsPerSection: scaled(2, config.scale),
+    sentencesPerParagraph: 3,
+    lists: scaled(2, config.scale),
+    listItems: 6,
+    tables: scaled(4, config.scale),
+    tableRows: scaled(18, config.scale),
+    tableCols: 5,
+    codeBlocks: scaled(3, config.scale),
+    codeLines: 10,
+    repeat: true,
+  }
+
+  const streamTablesConfig = {
+    title: "Markdown Stream Tables Long",
+    sections: scaled(4, config.scale),
+    paragraphsPerSection: scaled(1, config.scale),
+    sentencesPerParagraph: 2,
+    lists: scaled(1, config.scale),
+    listItems: 4,
+    tables: scaled(8, config.scale),
+    tableRows: scaled(50, config.scale),
+    tableCols: 6,
+    codeBlocks: scaled(2, config.scale),
+    codeLines: 8,
+    repeat: true,
+  }
+
+  const streamMixedBase = buildMarkdownDocument(rng, {
+    ...streamMixedConfig,
+    tables: Math.max(1, Math.floor(streamMixedConfig.tables / 2)),
+    tableRows: Math.max(6, Math.floor(streamMixedConfig.tableRows / 2)),
+    codeBlocks: Math.max(1, Math.floor(streamMixedConfig.codeBlocks / 2)),
+  })
+
+  const streamTablesBase = buildMarkdownDocument(rng, {
+    ...streamTablesConfig,
+    tables: Math.max(1, Math.floor(streamTablesConfig.tables / 2)),
+    tableRows: Math.max(6, Math.floor(streamTablesConfig.tableRows / 2)),
+    codeBlocks: Math.max(1, Math.floor(streamTablesConfig.codeBlocks / 2)),
+  })
+
+  const streamMixedChunks = buildStreamingChunks(rng, streamMixedConfig)
+  const streamTablesChunks = buildStreamingChunks(rng, streamTablesConfig)
+
+  const tableRowStreamCols = Math.max(3, scaled(6, config.scale))
+  const tableRowStreamBaseRows = 1
+  const tableRowStreamRows = Math.max(200, scaled(400, config.scale))
+  const tableRowStreamBaseLines = makeTableLines(rng, tableRowStreamCols, tableRowStreamBaseRows)
+  const tableRowStreamBaseContent = `# Stream Table Rows\n\n${tableRowStreamBaseLines.join("\n")}\n`
+  const tableRowStreamChunks = buildTableRowChunks(rng, {
+    rows: tableRowStreamRows,
+    cols: tableRowStreamCols,
+  })
+
+  const codeBlockStreamBlocks = Math.max(40, scaled(80, config.scale))
+  const codeBlockStreamLines = Math.max(6, scaled(10, config.scale))
+  const codeBlockStreamBaseContent = "# Stream Code Blocks\n\n"
+  const codeBlockStreamChunks = buildCodeBlockChunks(rng, {
+    blocks: codeBlockStreamBlocks,
+    lines: codeBlockStreamLines,
+  })
+
+  const headingStreamCount = Math.max(200, scaled(400, config.scale))
+  const headingStreamBaseContent = "# Stream Headings\n\n"
+  const headingStreamChunks = buildHeadingChunks(rng, {
+    headings: headingStreamCount,
+    depthMin: 2,
+    depthMax: 4,
+    wordsPerHeading: 4,
+  })
+
+  const staticSmall: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_small",
+    description: "Full parse/build on a small static document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: staticSmallDoc.content,
+    contentStats: staticSmallDoc.stats,
+  }
+
+  const staticLarge: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_large_tables",
+    description: "Full parse/build on a large, table-heavy document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: staticLargeDoc.content,
+    contentStats: staticLargeDoc.stats,
+  }
+
+  const tableOnlySmall: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_tables_only_small",
+    description: "Full parse/build on tables-only small document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: tableOnlySmallDoc.content,
+    contentStats: tableOnlySmallDoc.stats,
+  }
+
+  const tableOnlyLarge: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_tables_only_large",
+    description: "Full parse/build on tables-only large document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: tableOnlyLargeDoc.content,
+    contentStats: tableOnlyLargeDoc.stats,
+  }
+
+  const codeOnlySmall: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_code_only_small",
+    description: "Full parse/build on code-only document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: codeOnlySmallDoc.content,
+    contentStats: codeOnlySmallDoc.stats,
+  }
+
+  const codeOnlyLarge: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_code_only_large",
+    description: "Full parse/build on large code-only document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: codeOnlyLargeDoc.content,
+    contentStats: codeOnlyLargeDoc.stats,
+  }
+
+  const headingsOnly: StaticScenarioPlan = {
+    kind: "static",
+    name: "parse_headings_only",
+    description: "Full parse/build on headings-only document",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: headingsOnlyDoc.content,
+    contentStats: headingsOnlyDoc.stats,
+  }
+
+  const streamMixed: StreamingScenarioPlan = {
+    kind: "streaming",
+    name: "incremental_mixed",
+    description: "Incremental parsing with mixed streamed content",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    baseContent: streamMixedBase.content,
+    chunks: streamMixedChunks,
+    repeat: true,
+    contentStats: {
+      ...streamMixedBase.stats,
+      streamTables: streamMixedConfig.tables,
+      streamTableRows: streamMixedConfig.tableRows,
+      streamTableCols: streamMixedConfig.tableCols,
+      streamLists: streamMixedConfig.lists,
+      streamListItems: streamMixedConfig.listItems,
+      streamCodeBlocks: streamMixedConfig.codeBlocks,
+      streamCodeLines: streamMixedConfig.codeLines,
+    },
+  }
+
+  const streamTablesLong: StreamingScenarioPlan = {
+    kind: "streaming",
+    name: "incremental_tables_long",
+    description: "Long incremental run with large tables",
+    iterations: longIterations,
+    warmupIterations: baseWarmup,
+    baseContent: streamTablesBase.content,
+    chunks: streamTablesChunks,
+    repeat: true,
+    contentStats: {
+      ...streamTablesBase.stats,
+      streamTables: streamTablesConfig.tables,
+      streamTableRows: streamTablesConfig.tableRows,
+      streamTableCols: streamTablesConfig.tableCols,
+      streamLists: streamTablesConfig.lists,
+      streamListItems: streamTablesConfig.listItems,
+      streamCodeBlocks: streamTablesConfig.codeBlocks,
+      streamCodeLines: streamTablesConfig.codeLines,
+    },
+  }
+
+  const streamTableRows: StreamingScenarioPlan = {
+    kind: "streaming",
+    name: "incremental_table_rows",
+    description: "Incremental parsing on growing single table rows",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    baseContent: tableRowStreamBaseContent,
+    chunks: tableRowStreamChunks,
+    repeat: true,
+    contentStats: {
+      tableCols: tableRowStreamCols,
+      baseRows: tableRowStreamBaseRows,
+      streamRows: tableRowStreamRows,
+    },
+  }
+
+  const streamCodeBlocks: StreamingScenarioPlan = {
+    kind: "streaming",
+    name: "incremental_code_blocks",
+    description: "Incremental parsing with appended code blocks",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    baseContent: codeBlockStreamBaseContent,
+    chunks: codeBlockStreamChunks,
+    repeat: true,
+    contentStats: {
+      codeBlocks: codeBlockStreamBlocks,
+      codeLines: codeBlockStreamLines,
+    },
+  }
+
+  const streamHeadings: StreamingScenarioPlan = {
+    kind: "streaming",
+    name: "incremental_headings",
+    description: "Incremental parsing with appended headings",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    baseContent: headingStreamBaseContent,
+    chunks: headingStreamChunks,
+    repeat: true,
+    contentStats: {
+      headings: headingStreamCount,
+      depthMin: 2,
+      depthMax: 4,
+      wordsPerHeading: 4,
+    },
+  }
+
+  const styleSmall: StyleScenarioPlan = {
+    kind: "style",
+    name: "style_rerender_small",
+    description: "Rerender blocks on style changes (small document)",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: staticSmallDoc.content,
+    contentStats: staticSmallDoc.stats,
+  }
+
+  const styleLarge: StyleScenarioPlan = {
+    kind: "style",
+    name: "style_rerender_large",
+    description: "Rerender blocks on style changes (large document)",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: staticLargeDoc.content,
+    contentStats: staticLargeDoc.stats,
+  }
+
+  const styleTableSmall: StyleScenarioPlan = {
+    kind: "style",
+    name: "style_rerender_tables_only",
+    description: "Rerender blocks on style changes (tables-only)",
+    iterations: baseIterations,
+    warmupIterations: baseWarmup,
+    content: tableOnlySmallDoc.content,
+    contentStats: tableOnlySmallDoc.stats,
+  }
+
+  if (suite === "quick") return [staticSmall, tableOnlySmall, streamMixed, streamTableRows, styleSmall]
+  if (suite === "long")
+    return [
+      staticLarge,
+      tableOnlyLarge,
+      codeOnlyLarge,
+      streamMixed,
+      streamTableRows,
+      streamCodeBlocks,
+      streamHeadings,
+      streamTablesLong,
+      styleLarge,
+    ]
+  if (suite === "default")
+    return [
+      staticSmall,
+      tableOnlySmall,
+      codeOnlySmall,
+      headingsOnly,
+      staticLarge,
+      streamMixed,
+      streamTableRows,
+      streamCodeBlocks,
+      streamHeadings,
+      styleSmall,
+      styleTableSmall,
+      styleLarge,
+      streamTablesLong,
+    ]
+  return []
+}
+
+async function runScenario(plan: ScenarioPlan, ctx: RunContext): Promise<ScenarioResult> {
+  if (plan.kind === "static") {
+    return runStaticScenario(plan, ctx)
+  }
+  if (plan.kind === "style") {
+    return runStyleScenario(plan, ctx)
+  }
+  return runStreamingScenario(plan, ctx)
+}
+
+async function runStaticScenario(plan: StaticScenarioPlan, ctx: RunContext): Promise<ScenarioResult> {
+  ctx.markdown.streaming = false
+  ctx.markdown.content = ""
+  ctx.markdown.clearCache()
+
+  for (let i = 0; i < plan.warmupIterations; i += 1) {
+    ctx.markdown.content = ""
+    ctx.markdown.clearCache()
+    ctx.markdown.content = plan.content
+  }
+
+  const durations: number[] = []
+  const measurementStart = Date.now()
+  const memStart = shouldSampleMemory(ctx) ? readMemorySample() : null
+  const nativeMemStart = shouldSampleMemory(ctx) ? readNativeMemorySample() : null
+  const sampler = createMemorySampler(ctx)
+
+  for (let i = 0; i < plan.iterations; i += 1) {
+    ctx.markdown.content = ""
+    ctx.markdown.clearCache()
+    const start = performance.now()
+    ctx.markdown.content = plan.content
+    const elapsed = performance.now() - start
+    durations.push(elapsed)
+    sampler.recordIteration(i + 1)
+  }
+
+  const elapsedMs = Date.now() - measurementStart
+  const memEnd = shouldSampleMemory(ctx) ? readMemorySample() : null
+  const nativeMemEnd = shouldSampleMemory(ctx) ? readNativeMemorySample() : null
+  sampler.stop()
+
+  return {
+    name: plan.name,
+    description: plan.description,
+    iterations: plan.iterations,
+    warmupIterations: plan.warmupIterations,
+    elapsedMs,
+    category: "parse",
+    timingMode: "content-set",
+    updateStats: computeTimingStats(durations),
+    memoryStats: memStart && memEnd ? computeMemoryStats(sampler.jsSamples, memStart, memEnd) : undefined,
+    nativeMemoryStats:
+      nativeMemStart && nativeMemEnd
+        ? computeNativeMemoryStats(sampler.nativeSamples, nativeMemStart, nativeMemEnd)
+        : undefined,
+    contentStats: {
+      initialChars: plan.content.length,
+      finalChars: plan.content.length,
+      maxChars: plan.content.length,
+      updates: plan.iterations,
+      appendedChars: 0,
+    },
+    settings: {
+      ...plan.contentStats,
+      mode: "static",
+    },
+  }
+}
+
+async function runStreamingScenario(plan: StreamingScenarioPlan, ctx: RunContext): Promise<ScenarioResult> {
+  ctx.markdown.streaming = true
+  const state = createStreamState({
+    content: plan.baseContent,
+    chunks: plan.chunks,
+    repeat: plan.repeat,
+    maxChars: ctx.maxChars,
+  })
+
+  ctx.markdown.content = state.content
+
+  if (plan.warmupIterations > 0) {
+    await runStreamingIterations(state, ctx, plan.warmupIterations, false)
+  }
+
+  const measurementStart = Date.now()
+  const memStart = shouldSampleMemory(ctx) ? readMemorySample() : null
+  const nativeMemStart = shouldSampleMemory(ctx) ? readNativeMemorySample() : null
+  const sampler = createMemorySampler(ctx)
+
+  const measured = await runStreamingIterations(state, ctx, plan.iterations, true, sampler)
+  if (measured.durations.length < plan.iterations) {
+    throw new Error(
+      `streaming scenario '${plan.name}' ended early (updates=${measured.durations.length}/${plan.iterations}). Increase --max-chars or reduce --iterations.`,
+    )
+  }
+
+  const elapsedMs = Date.now() - measurementStart
+  const memEnd = shouldSampleMemory(ctx) ? readMemorySample() : null
+  const nativeMemEnd = shouldSampleMemory(ctx) ? readNativeMemorySample() : null
+  sampler.stop()
+
+  return {
+    name: plan.name,
+    description: plan.description,
+    iterations: plan.iterations,
+    warmupIterations: plan.warmupIterations,
+    elapsedMs,
+    category: "incremental",
+    timingMode: "content-set",
+    updateStats: computeTimingStats(measured.durations),
+    memoryStats: memStart && memEnd ? computeMemoryStats(sampler.jsSamples, memStart, memEnd) : undefined,
+    nativeMemoryStats:
+      nativeMemStart && nativeMemEnd
+        ? computeNativeMemoryStats(sampler.nativeSamples, nativeMemStart, nativeMemEnd)
+        : undefined,
+    contentStats: {
+      initialChars: plan.baseContent.length,
+      finalChars: state.content.length,
+      maxChars: state.maxContentChars,
+      updates: measured.durations.length,
+      appendedChars: measured.appendedChars,
+    },
+    settings: {
+      ...plan.contentStats,
+      mode: "streaming",
+      streamIntervalMs: ctx.streamIntervalMs,
+      appendLinesPerTick: ctx.chunkLines,
+      maxChars: ctx.maxChars,
+      repeat: plan.repeat,
+    },
+  }
+}
+
+async function runStyleScenario(plan: StyleScenarioPlan, ctx: RunContext): Promise<ScenarioResult> {
+  ctx.markdown.streaming = false
+  ctx.markdown.syntaxStyle = ctx.syntaxStyleA
+  ctx.markdown.conceal = true
+  ctx.markdown.content = plan.content
+
+  for (let i = 0; i < plan.warmupIterations; i += 1) {
+    ctx.markdown.conceal = !ctx.markdown.conceal
+    ctx.markdown.refreshStyles()
+  }
+
+  const durations: number[] = []
+  const measurementStart = Date.now()
+  const memStart = shouldSampleMemory(ctx) ? readMemorySample() : null
+  const nativeMemStart = shouldSampleMemory(ctx) ? readNativeMemorySample() : null
+  const sampler = createMemorySampler(ctx)
+
+  for (let i = 0; i < plan.iterations; i += 1) {
+    ctx.markdown.conceal = !ctx.markdown.conceal
+    ctx.markdown.syntaxStyle = i % 2 === 0 ? ctx.syntaxStyleA : ctx.syntaxStyleB
+    const start = performance.now()
+    ctx.markdown.refreshStyles()
+    const elapsed = performance.now() - start
+    durations.push(elapsed)
+    sampler.recordIteration(i + 1)
+  }
+
+  const elapsedMs = Date.now() - measurementStart
+  const memEnd = shouldSampleMemory(ctx) ? readMemorySample() : null
+  const nativeMemEnd = shouldSampleMemory(ctx) ? readNativeMemorySample() : null
+  sampler.stop()
+
+  return {
+    name: plan.name,
+    description: plan.description,
+    iterations: plan.iterations,
+    warmupIterations: plan.warmupIterations,
+    elapsedMs,
+    category: "style",
+    timingMode: "style-refresh",
+    updateStats: computeTimingStats(durations),
+    memoryStats: memStart && memEnd ? computeMemoryStats(sampler.jsSamples, memStart, memEnd) : undefined,
+    nativeMemoryStats:
+      nativeMemStart && nativeMemEnd
+        ? computeNativeMemoryStats(sampler.nativeSamples, nativeMemStart, nativeMemEnd)
+        : undefined,
+    contentStats: {
+      initialChars: plan.content.length,
+      finalChars: plan.content.length,
+      maxChars: plan.content.length,
+      updates: plan.iterations,
+      appendedChars: 0,
+    },
+    settings: {
+      ...plan.contentStats,
+      mode: "style",
+    },
+  }
+}
+
+async function runStreamingIterations(
+  state: StreamState,
+  ctx: RunContext,
+  iterations: number,
+  record: boolean,
+  sampler?: MemorySampler,
+): Promise<{ durations: number[]; appendedChars: number }> {
+  const durations: number[] = []
+  let appendedChars = 0
+
+  for (let i = 0; i < iterations; i += 1) {
+    const update = appendStream(state, ctx.chunkLines)
+    if (!update.updated) break
+
+    const start = performance.now()
+    ctx.markdown.content = state.content
+    const elapsed = performance.now() - start
+
+    if (record) {
+      durations.push(elapsed)
+      appendedChars += update.appendedChars
+      sampler?.recordIteration(durations.length)
+    }
+
+    if (ctx.streamIntervalMs > 0) {
+      await Bun.sleep(ctx.streamIntervalMs)
+    }
+  }
+
+  return { durations, appendedChars }
+}
+
+function createStreamState(input: {
+  content: string
+  chunks: string[]
+  repeat: boolean
+  maxChars: number
+}): StreamState {
+  return {
+    content: input.content,
+    chunks: input.chunks,
+    cursor: 0,
+    repeat: input.repeat,
+    maxChars: input.maxChars,
+    maxContentChars: input.content.length,
+    done: false,
+  }
+}
+
+function appendStream(state: StreamState, linesPerTick: number): { updated: boolean; appendedChars: number } {
+  if (state.done) return { updated: false, appendedChars: 0 }
+  let appended = ""
+
+  for (let i = 0; i < linesPerTick; i += 1) {
+    if (state.cursor >= state.chunks.length) {
+      if (state.repeat) {
+        state.cursor = 0
+      } else {
+        state.done = true
+        break
+      }
+    }
+    appended += state.chunks[state.cursor]
+    state.cursor += 1
+  }
+
+  if (!appended) return { updated: false, appendedChars: 0 }
+
+  if (state.maxChars > 0 && state.content.length + appended.length > state.maxChars) {
+    state.done = true
+    return { updated: false, appendedChars: 0 }
+  }
+
+  state.content += appended
+  state.maxContentChars = Math.max(state.maxContentChars, state.content.length)
+
+  return { updated: true, appendedChars: appended.length }
+}
+
+function buildMarkdownDocument(rng: () => number, config: StaticScenarioConfig): { content: string; stats: any } {
+  const parts: string[] = []
+  parts.push(`# ${config.title}`)
+
+  for (let section = 0; section < config.sections; section += 1) {
+    parts.push(`## Section ${section + 1}`)
+
+    for (let p = 0; p < config.paragraphsPerSection; p += 1) {
+      parts.push(makeParagraph(rng, config.sentencesPerParagraph))
+    }
+
+    if (config.lists > 0) {
+      for (let l = 0; l < config.lists; l += 1) {
+        parts.push(makeList(rng, config.listItems))
+      }
+    }
+
+    if (config.tables > 0) {
+      for (let t = 0; t < config.tables; t += 1) {
+        const tableLines = makeTableLines(rng, config.tableCols, config.tableRows)
+        parts.push(tableLines.join("\n"))
+      }
+    }
+
+    if (config.codeBlocks > 0) {
+      for (let c = 0; c < config.codeBlocks; c += 1) {
+        parts.push(makeCodeBlock(rng, config.codeLines))
+      }
+    }
+  }
+
+  return {
+    content: parts.join("\n\n") + "\n",
+    stats: {
+      sections: config.sections,
+      paragraphsPerSection: config.paragraphsPerSection,
+      sentencesPerParagraph: config.sentencesPerParagraph,
+      listsPerSection: config.lists,
+      totalLists: config.sections * config.lists,
+      listItems: config.listItems,
+      tablesPerSection: config.tables,
+      totalTables: config.sections * config.tables,
+      tableRows: config.tableRows,
+      tableCols: config.tableCols,
+      codeBlocksPerSection: config.codeBlocks,
+      totalCodeBlocks: config.sections * config.codeBlocks,
+      codeLines: config.codeLines,
+      totalParagraphs: config.sections * config.paragraphsPerSection,
+    },
+  }
+}
+
+function buildTableOnlyDocument(
+  rng: () => number,
+  config: { title: string; tables: number; rows: number; cols: number },
+): { content: string; stats: any } {
+  const parts: string[] = []
+  parts.push(`# ${config.title}`)
+  for (let t = 0; t < config.tables; t += 1) {
+    const tableLines = makeTableLines(rng, config.cols, config.rows)
+    parts.push(tableLines.join("\n"))
+  }
+
+  return {
+    content: parts.join("\n\n") + "\n",
+    stats: {
+      tables: config.tables,
+      tableRows: config.rows,
+      tableCols: config.cols,
+    },
+  }
+}
+
+function buildCodeOnlyDocument(
+  rng: () => number,
+  config: { title: string; blocks: number; lines: number },
+): { content: string; stats: any } {
+  const parts: string[] = []
+  parts.push(`# ${config.title}`)
+  for (let b = 0; b < config.blocks; b += 1) {
+    parts.push(makeCodeBlock(rng, config.lines))
+  }
+
+  return {
+    content: parts.join("\n\n") + "\n",
+    stats: {
+      codeBlocks: config.blocks,
+      codeLines: config.lines,
+    },
+  }
+}
+
+function buildHeadingsOnlyDocument(
+  rng: () => number,
+  config: { title: string; headings: number; depthMin: number; depthMax: number; wordsPerHeading: number },
+): { content: string; stats: any } {
+  const parts: string[] = []
+  parts.push(`# ${config.title}`)
+  for (let i = 0; i < config.headings; i += 1) {
+    parts.push(makeHeadingLine(rng, config.depthMin, config.depthMax, config.wordsPerHeading))
+  }
+
+  return {
+    content: parts.join("\n") + "\n",
+    stats: {
+      headings: config.headings,
+      depthMin: config.depthMin,
+      depthMax: config.depthMax,
+      wordsPerHeading: config.wordsPerHeading,
+    },
+  }
+}
+
+function buildHeadingChunks(
+  rng: () => number,
+  config: { headings: number; depthMin: number; depthMax: number; wordsPerHeading: number },
+): string[] {
+  const chunks: string[] = []
+  for (let i = 0; i < config.headings; i += 1) {
+    chunks.push(makeHeadingLine(rng, config.depthMin, config.depthMax, config.wordsPerHeading) + "\n")
+  }
+  return chunks
+}
+
+function buildCodeBlockChunks(rng: () => number, config: { blocks: number; lines: number }): string[] {
+  const chunks: string[] = []
+  for (let b = 0; b < config.blocks; b += 1) {
+    const lines = makeCodeBlockLines(rng, config.lines)
+    for (const line of lines) {
+      chunks.push(`${line}\n`)
+    }
+    chunks.push("\n")
+  }
+  return chunks
+}
+
+function buildTableRowChunks(rng: () => number, config: { rows: number; cols: number }): string[] {
+  const chunks: string[] = []
+  for (let r = 0; r < config.rows; r += 1) {
+    chunks.push(makeTableRowLine(rng, r, config.cols) + "\n")
+  }
+  return chunks
+}
+
+function buildStreamingChunks(rng: () => number, config: StreamingScenarioConfig): string[] {
+  const chunks: string[] = []
+  for (let section = 0; section < config.sections; section += 1) {
+    pushLine(chunks, `### Stream Section ${section + 1}`)
+    pushLine(chunks, "")
+
+    for (let p = 0; p < config.paragraphsPerSection; p += 1) {
+      pushLine(chunks, makeParagraph(rng, config.sentencesPerParagraph))
+      pushLine(chunks, "")
+    }
+
+    for (let l = 0; l < config.lists; l += 1) {
+      const listLines = makeListLines(rng, config.listItems)
+      for (const line of listLines) {
+        pushLine(chunks, line)
+      }
+      pushLine(chunks, "")
+    }
+
+    for (let t = 0; t < config.tables; t += 1) {
+      const tableLines = makeTableLines(rng, config.tableCols, config.tableRows)
+      for (const line of tableLines) {
+        pushLine(chunks, line)
+      }
+      pushLine(chunks, "")
+    }
+
+    for (let c = 0; c < config.codeBlocks; c += 1) {
+      const codeLines = makeCodeBlockLines(rng, config.codeLines)
+      for (const line of codeLines) {
+        pushLine(chunks, line)
+      }
+      pushLine(chunks, "")
+    }
+  }
+
+  return chunks
+}
+
+function pushLine(chunks: string[], line: string): void {
+  chunks.push(`${line}\n`)
+}
+
+function makeParagraph(rng: () => number, sentences: number): string {
+  const parts: string[] = []
+  for (let i = 0; i < sentences; i += 1) {
+    parts.push(makeSentence(rng, 6, 12))
+  }
+  return parts.join(" ")
+}
+
+function makeSentence(rng: () => number, minWords: number, maxWords: number): string {
+  const count = minWords + Math.floor(rng() * (maxWords - minWords + 1))
+  const words: string[] = []
+  for (let i = 0; i < count; i += 1) {
+    let word = pick(rng, WORDS)
+    if (rng() < 0.25) {
+      word = wrapInline(rng, word)
+    }
+    words.push(word)
+  }
+  const sentence = words.join(" ")
+  return sentence.charAt(0).toUpperCase() + sentence.slice(1) + "."
+}
+
+function wrapInline(rng: () => number, word: string): string {
+  const roll = rng()
+  if (roll < 0.08) return `**${word}**`
+  if (roll < 0.16) return `*${word}*`
+  if (roll < 0.22) return `\`${word}\``
+  if (roll < 0.26) return `[${word}](https://example.com/${word})`
+  return word
+}
+
+function makeList(rng: () => number, items: number): string {
+  return makeListLines(rng, items).join("\n")
+}
+
+function makeListLines(rng: () => number, items: number): string[] {
+  const lines: string[] = []
+  for (let i = 0; i < items; i += 1) {
+    lines.push(`- ${makeSentence(rng, 4, 9)}`)
+  }
+  return lines
+}
+
+function makeCodeBlock(rng: () => number, lines: number): string {
+  return makeCodeBlockLines(rng, lines).join("\n")
+}
+
+function makeCodeBlockLines(rng: () => number, lines: number): string[] {
+  const variable = pick(rng, CODE_WORDS)
+  const iterations = Math.max(2, Math.floor(lines / 2))
+  const targetLines = Math.max(6, lines)
+  const body: string[] = []
+  body.push(`const ${variable} = ${Math.floor(rng() * 1000)}`)
+  body.push(`let result = ${Math.floor(rng() * 10)}`)
+  body.push(`for (let i = 0; i < ${iterations}; i += 1) {`)
+  body.push(`  result += (${variable} + i) % 5`)
+  body.push("}")
+  body.push("return result")
+
+  let fillerIndex = 0
+  while (body.length < targetLines) {
+    body.splice(body.length - 1, 0, `result += ${Math.floor(rng() * 10)} + ${fillerIndex}`)
+    fillerIndex += 1
+  }
+
+  return ["```typescript", ...body, "```"]
+}
+
+function makeTableLines(rng: () => number, columns: number, rows: number): string[] {
+  const header: string[] = []
+  const align: string[] = []
+
+  for (let c = 0; c < columns; c += 1) {
+    header.push(`Column ${c + 1}`)
+    if (c % 3 === 0) align.push(":---")
+    else if (c % 3 === 1) align.push(":---:")
+    else align.push("---:")
+  }
+
+  const lines: string[] = []
+  lines.push(`| ${header.join(" | ")} |`)
+  lines.push(`| ${align.join(" | ")} |`)
+
+  for (let r = 0; r < rows; r += 1) {
+    const cells: string[] = []
+    for (let c = 0; c < columns; c += 1) {
+      cells.push(makeCellText(rng, r, c))
+    }
+    lines.push(`| ${cells.join(" | ")} |`)
+  }
+
+  return lines
+}
+
+function makeTableRowLine(rng: () => number, row: number, columns: number): string {
+  const cells: string[] = []
+  for (let c = 0; c < columns; c += 1) {
+    cells.push(makeCellText(rng, row, c))
+  }
+  return `| ${cells.join(" | ")} |`
+}
+
+function makeHeadingLine(rng: () => number, depthMin: number, depthMax: number, words: number): string {
+  const depth = depthMin + Math.floor(rng() * Math.max(1, depthMax - depthMin + 1))
+  const tokens: string[] = []
+  for (let i = 0; i < words; i += 1) {
+    tokens.push(pick(rng, WORDS))
+  }
+  return `${"#".repeat(depth)} ${tokens.join(" ")}`
+}
+
+function makeCellText(rng: () => number, row: number, col: number): string {
+  const base = `${pick(rng, WORDS)} ${pick(rng, WORDS)}`
+  const roll = rng()
+  if (roll < 0.2) return `**${base}**`
+  if (roll < 0.35) return `*${base}*`
+  if (roll < 0.45) return `\`${base}\``
+  if (roll < 0.55) return `${base} ${Math.floor(rng() * 100)}`
+  if (roll < 0.6) return `[${base}](https://example.com/r${row}c${col})`
+  return base
+}
+
+function pick<T>(rng: () => number, list: T[]): T {
+  return list[Math.floor(rng() * list.length)]
+}
+
+function scaled(value: number, scaleValue: number): number {
+  return Math.max(1, Math.round(value * scaleValue))
+}
+
+function createRng(initialSeed: number): () => number {
+  let state = initialSeed >>> 0
+  return () => {
+    state = (state * 1664525 + 1013904223) >>> 0
+    return state / 0x100000000
+  }
+}
+
+function toNumber(value: unknown, fallback: number): number {
+  if (typeof value === "number" && Number.isFinite(value)) return value
+  if (typeof value === "string") {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return fallback
+}
+
+function shouldSampleMemory(ctx: RunContext): boolean {
+  return ctx.memInterval > 0 || ctx.memSampleEvery > 0
+}
+
+function readMemorySample(): MemorySample {
+  const usage = process.memoryUsage()
+  return {
+    rss: usage.rss ?? 0,
+    heapTotal: usage.heapTotal ?? 0,
+    heapUsed: usage.heapUsed ?? 0,
+    external: usage.external ?? 0,
+    arrayBuffers: usage.arrayBuffers ?? 0,
+  }
+}
+
+function readNativeMemorySample(): NativeMemorySample {
+  const stats = nativeLib.getAllocatorStats()
+  return {
+    totalRequestedBytes: stats.totalRequestedBytes,
+    activeAllocations: stats.activeAllocations,
+    smallAllocations: stats.smallAllocations,
+    largeAllocations: stats.largeAllocations,
+    requestedBytesValid: stats.requestedBytesValid,
+  }
+}
+
+function createMemorySampler(ctx: RunContext): MemorySampler {
+  const jsSamples: MemorySample[] = []
+  const nativeSamples: NativeMemorySample[] = []
+
+  const pushSample = (): void => {
+    jsSamples.push(readMemorySample())
+    nativeSamples.push(readNativeMemorySample())
+  }
+
+  if (ctx.memInterval > 0) {
+    const timer = setInterval(() => {
+      pushSample()
+    }, ctx.memInterval)
+    return {
+      jsSamples,
+      nativeSamples,
+      recordIteration: () => {},
+      stop: () => clearInterval(timer),
+    }
+  }
+
+  if (ctx.memSampleEvery > 0) {
+    return {
+      jsSamples,
+      nativeSamples,
+      recordIteration: (iteration: number) => {
+        if (iteration % ctx.memSampleEvery === 0) {
+          pushSample()
+        }
+      },
+      stop: () => {},
+    }
+  }
+
+  return {
+    jsSamples,
+    nativeSamples,
+    recordIteration: () => {},
+    stop: () => {},
+  }
+}
+
+function computeMemoryStats(samples: MemorySample[], start: MemorySample, end: MemorySample): MemoryStats {
+  const all = [start, ...samples, end]
+  const peak = { ...start }
+  for (const sample of all) {
+    updatePeak(sample, peak)
+  }
+
+  return {
+    samples: all.length,
+    start,
+    end,
+    delta: diffMemory(start, end),
+    peak,
+    fields: {
+      rss: computeFieldStats(all.map((s) => s.rss)),
+      heapTotal: computeFieldStats(all.map((s) => s.heapTotal)),
+      heapUsed: computeFieldStats(all.map((s) => s.heapUsed)),
+      external: computeFieldStats(all.map((s) => s.external)),
+      arrayBuffers: computeFieldStats(all.map((s) => s.arrayBuffers)),
+    },
+  }
+}
+
+function computeNativeMemoryStats(
+  samples: NativeMemorySample[],
+  start: NativeMemorySample,
+  end: NativeMemorySample,
+): NativeMemoryStats {
+  const all = [start, ...samples, end]
+  const requestedBytesReliable = all.every((sample) => sample.requestedBytesValid)
+  const peak = { ...start }
+  for (const sample of all) {
+    updateNativePeak(sample, peak)
+  }
+
+  return {
+    samples: all.length,
+    start,
+    end,
+    delta: diffNativeMemory(start, end),
+    peak,
+    requestedBytesReliable,
+    fields: {
+      totalRequestedBytes: computeFieldStats(all.map((s) => s.totalRequestedBytes)),
+      activeAllocations: computeFieldStats(all.map((s) => s.activeAllocations)),
+      smallAllocations: computeFieldStats(all.map((s) => s.smallAllocations)),
+      largeAllocations: computeFieldStats(all.map((s) => s.largeAllocations)),
+    },
+  }
+}
+
+function updatePeak(sample: MemorySample, peak: MemorySample): void {
+  peak.rss = Math.max(peak.rss, sample.rss)
+  peak.heapTotal = Math.max(peak.heapTotal, sample.heapTotal)
+  peak.heapUsed = Math.max(peak.heapUsed, sample.heapUsed)
+  peak.external = Math.max(peak.external, sample.external)
+  peak.arrayBuffers = Math.max(peak.arrayBuffers, sample.arrayBuffers)
+}
+
+function updateNativePeak(sample: NativeMemorySample, peak: NativeMemorySample): void {
+  peak.totalRequestedBytes = Math.max(peak.totalRequestedBytes, sample.totalRequestedBytes)
+  peak.activeAllocations = Math.max(peak.activeAllocations, sample.activeAllocations)
+  peak.smallAllocations = Math.max(peak.smallAllocations, sample.smallAllocations)
+  peak.largeAllocations = Math.max(peak.largeAllocations, sample.largeAllocations)
+  peak.requestedBytesValid = peak.requestedBytesValid && sample.requestedBytesValid
+}
+
+function diffMemory(start: MemorySample, end: MemorySample): MemorySample {
+  return {
+    rss: end.rss - start.rss,
+    heapTotal: end.heapTotal - start.heapTotal,
+    heapUsed: end.heapUsed - start.heapUsed,
+    external: end.external - start.external,
+    arrayBuffers: end.arrayBuffers - start.arrayBuffers,
+  }
+}
+
+function diffNativeMemory(start: NativeMemorySample, end: NativeMemorySample): NativeMemorySample {
+  return {
+    totalRequestedBytes: end.totalRequestedBytes - start.totalRequestedBytes,
+    activeAllocations: end.activeAllocations - start.activeAllocations,
+    smallAllocations: end.smallAllocations - start.smallAllocations,
+    largeAllocations: end.largeAllocations - start.largeAllocations,
+    requestedBytesValid: start.requestedBytesValid && end.requestedBytesValid,
+  }
+}
+
+function computeFieldStats(values: number[]): MemoryFieldStats {
+  const sorted = [...values].sort((a, b) => a - b)
+  const min = sorted[0] ?? 0
+  const max = sorted[sorted.length - 1] ?? 0
+  const avg = sorted.length > 0 ? sorted.reduce((sum, v) => sum + v, 0) / sorted.length : 0
+  const median = sorted.length > 0 ? (sorted[Math.floor(sorted.length / 2)] ?? 0) : 0
+  return { min, max, avg, median }
+}
+
+function computeTimingStats(durations: number[]): TimingStats {
+  const sorted = [...durations].sort((a, b) => a - b)
+  const count = sorted.length
+  const sum = sorted.reduce((acc, value) => acc + value, 0)
+  const average = count > 0 ? sum / count : 0
+  const min = sorted[0] ?? 0
+  const max = sorted[count - 1] ?? 0
+  const median = count > 0 ? (sorted[Math.floor(count / 2)] ?? 0) : 0
+  const p95 = count > 0 ? (sorted[Math.floor(count * 0.95)] ?? 0) : 0
+  const stdDev = count > 0 ? Math.sqrt(sorted.reduce((acc, v) => acc + Math.pow(v - average, 2), 0) / count) : 0
+
+  return {
+    count,
+    averageMs: average,
+    medianMs: median,
+    p95Ms: p95,
+    minMs: min,
+    maxMs: max,
+    stdDevMs: stdDev,
+  }
+}
+
+async function outputResults(
+  meta: OutputMeta,
+  resultsList: ScenarioResult[],
+  scenarioLines: string[],
+  outputEnabled: boolean,
+  outputPath: string | null,
+): Promise<void> {
+  const runId = new Date().toISOString()
+  const payload = {
+    runId,
+    suite: meta.suiteName,
+    renderer: {
+      targetFps: meta.targetFps,
+      maxFps: meta.maxFps,
+    },
+    config: {
+      iterations: meta.iterations,
+      warmupIterations: meta.warmupIterations,
+      longIterations: meta.longIterations,
+      streamIntervalMs: meta.streamIntervalMs,
+      chunkLines: meta.chunkLines,
+      maxChars: meta.maxChars,
+      scale: meta.scale,
+      seed: meta.seed,
+      memInterval: meta.memInterval,
+      memSampleEvery: meta.memSampleEvery,
+      gpaSafeStats: meta.gpaSafeStats,
+      gpaMemoryLimitTracking: meta.gpaMemoryLimitTracking,
+    },
+    results: resultsList,
+  }
+
+  if (outputEnabled) {
+    writeLine(
+      `markdown-benchmark suite=${meta.suiteName} timing=frame-independent iters=${meta.iterations} warmup=${meta.warmupIterations}`,
+    )
+    writeLine(`native-build gpaSafeStats=${meta.gpaSafeStats} gpaMemoryLimitTracking=${meta.gpaMemoryLimitTracking}`)
+    for (const line of scenarioLines) {
+      writeLine(line)
+    }
+  }
+
+  if (outputPath) {
+    try {
+      const json = JSON.stringify(payload, null, 2)
+      await Bun.write(outputPath, json)
+    } catch (error: any) {
+      writeLine(`Error writing results to ${outputPath}: ${error.message}`)
+    }
+  }
+}
+
+function formatBytes(value: number): string {
+  const units = ["B", "KB", "MB", "GB", "TB", "PB"]
+  const abs = Math.abs(value)
+
+  if (abs < 1024) {
+    return `${Math.trunc(value)}B`
+  }
+
+  let unitIndex = 0
+  let scaled = abs
+  while (scaled >= 1024 && unitIndex < units.length - 1) {
+    scaled /= 1024
+    unitIndex += 1
+  }
+
+  const sign = value < 0 ? "-" : ""
+  return `${sign}${scaled.toFixed(2)}${units[unitIndex]}`
+}
+
+function formatAllocs(value: number): string {
+  const intValue = Math.trunc(value)
+  const sign = intValue > 0 ? "+" : ""
+  return `${sign}${intValue.toLocaleString("en-US")} allocs`
+}
+
+function formatScenarioResult(result: ScenarioResult): string {
+  const jsMem = result.memoryStats
+  const nativeMem = result.nativeMemoryStats
+
+  const jsMemSummary = jsMem
+    ? ` jsMemDeltaRss=${formatBytes(jsMem.delta.rss)}` +
+      ` jsMemDeltaHeap=${formatBytes(jsMem.delta.heapUsed)}` +
+      ` jsMemDeltaExt=${formatBytes(jsMem.delta.external)}` +
+      ` jsMemDeltaAB=${formatBytes(jsMem.delta.arrayBuffers)}` +
+      ` jsMemPeakRss=${formatBytes(jsMem.peak.rss)}`
+    : ""
+
+  const nativeMemSummary = nativeMem
+    ? ` nativeMemDeltaReq=${nativeMem.requestedBytesReliable ? formatBytes(nativeMem.delta.totalRequestedBytes) : "invalid"}` +
+      ` nativeMemDeltaReqBytes=${nativeMem.requestedBytesReliable ? `${Math.trunc(nativeMem.delta.totalRequestedBytes)}B` : "invalid"}` +
+      ` nativeMemDeltaActive=${formatAllocs(nativeMem.delta.activeAllocations)}` +
+      ` nativeMemDeltaSmall=${formatAllocs(nativeMem.delta.smallAllocations)}` +
+      ` nativeMemDeltaLarge=${formatAllocs(nativeMem.delta.largeAllocations)}` +
+      ` nativeMemPeakReq=${nativeMem.requestedBytesReliable ? formatBytes(nativeMem.peak.totalRequestedBytes) : "invalid"}` +
+      ` nativeMemPeakReqBytes=${nativeMem.requestedBytesReliable ? `${Math.trunc(nativeMem.peak.totalRequestedBytes)}B` : "invalid"}` +
+      ` nativeMemPeakActive=${formatAllocs(nativeMem.peak.activeAllocations)}` +
+      ` nativeMemReqReliable=${nativeMem.requestedBytesReliable}`
+    : ""
+
+  return `scenario=${result.name} category=${result.category} mode=${result.timingMode} iters=${result.updateStats.count} elapsedMs=${result.elapsedMs} avgMs=${result.updateStats.averageMs.toFixed(3)} medianMs=${result.updateStats.medianMs.toFixed(3)} p95Ms=${result.updateStats.p95Ms.toFixed(3)} minMs=${result.updateStats.minMs.toFixed(3)} maxMs=${result.updateStats.maxMs.toFixed(3)} chars=${result.contentStats.finalChars}${jsMemSummary}${nativeMemSummary}`
+}
+
+function writeLine(line: string): void {
+  realStdoutWrite(`${line}\n`)
+}
+
+async function runSpawnedScenarios(plans: ScenarioPlan[]): Promise<void> {
+  const tempDir = await mkdtemp(path.join(tmpdir(), "opentui-markdown-bench-"))
+  const scenarioLines: string[] = []
+  const results: ScenarioResult[] = []
+
+  for (const plan of plans) {
+    const jsonPath = path.join(tempDir, `scenario-${plan.name}.json`)
+    const args = buildChildArgs(process.argv.slice(2), plan.name, jsonPath)
+    const child = Bun.spawn([process.execPath, new URL(import.meta.url).pathname, ...args], {
+      stdout: "inherit",
+      stderr: "inherit",
+      env: process.env,
+    })
+    const exitCode = await child.exited
+    if (exitCode !== 0) {
+      throw new Error(`Scenario ${plan.name} failed with exit code ${exitCode}`)
+    }
+
+    const json = await readFile(jsonPath, "utf8")
+    await unlink(jsonPath)
+    const payload = JSON.parse(json)
+    const result = payload.results?.[0] as ScenarioResult | undefined
+    if (!result) {
+      throw new Error(`Scenario ${plan.name} did not produce a result`)
+    }
+    results.push(result)
+    scenarioLines.push(formatScenarioResult(result))
+  }
+
+  await outputResults(
+    {
+      suiteName,
+      targetFps,
+      maxFps,
+      iterations,
+      warmupIterations,
+      longIterations,
+      streamIntervalMs,
+      chunkLines,
+      maxChars,
+      scale,
+      seed,
+      memInterval,
+      memSampleEvery,
+      gpaSafeStats: nativeBuildOptions.gpaSafeStats,
+      gpaMemoryLimitTracking: nativeBuildOptions.gpaMemoryLimitTracking,
+    },
+    results,
+    scenarioLines,
+    outputEnabled,
+    jsonPath,
+  )
+}
+
+function buildChildArgs(args: string[], scenarioName: string, jsonPath: string): string[] {
+  const filtered: string[] = []
+  for (const arg of args) {
+    if (arg === "--no-spawn-per-scenario") continue
+    if (arg.startsWith("--scenario")) continue
+    if (arg === "--json" || arg.startsWith("--json=")) continue
+    if (arg === "--output" || arg === "--no-output") continue
+    filtered.push(arg)
+  }
+  filtered.push(`--scenario=${scenarioName}`)
+  filtered.push(`--json=${jsonPath}`)
+  filtered.push("--no-output")
+  filtered.push("--no-spawn-per-scenario")
+  return filtered
+}