mixdog 0.9.54 → 0.9.55

package/scripts/tui-runtime-load-bench-entry.jsx

@@ -0,0 +1,608 @@
+import React from 'react';
+import { Writable } from 'node:stream';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
+import { Box, render } from 'ink';
+
+import { Item } from '../src/tui/components/TranscriptItem.jsx';
+import { useTranscriptWindow } from '../src/tui/app/use-transcript-window.mjs';
+import { createTranscriptWriter } from '../src/runtime/shared/transcript-writer.mjs';
+import {
+  drainPathSync,
+  getBufferedAppenderStats,
+  hasInFlightWrite,
+} from '../src/runtime/shared/buffered-appender.mjs';
+
+/**
+ * Headless TUI/runtime load-regression bench.
+ *
+ * Each measured frame covers producer state updates, React reconciliation,
+ * production transcript windowing, TranscriptItem rendering, Yoga layout,
+ * measured-height harvest/re-render, Ink serialization, and the final write
+ * callback on a capture TTY. Producer records go through the production
+ * transcript writer/appender and the same text is appended to rendered state.
+ *
+ * Gate precedence is explicit CLI/env override, then the checked-in baseline
+ * p95 times a fixed margin, then the 16.67 ms absolute fallback. Warm-up
+ * calibration is informational only: a render regression cannot raise its own
+ * threshold. Re-record the baseline intentionally with --update-baseline after
+ * a hardware/runner change, never as part of an ordinary regression run.
+ */
+const DEFAULTS = Object.freeze({
+  items: 10_000,
+  frames: 120,
+  producers: 8,
+  burst: 12,
+  columns: 120,
+  viewportRows: 40,
+  thresholdFloorMs: 16.67,
+  calibrationFrames: 8,
+  baselineRegressionMargin: 1.5,
+});
+const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const BASELINE_PATH = join(PROJECT_ROOT, 'bench-results', 'tui-runtime-load-baseline.json');
+const identity = (value) => value;
+const noop = () => {};
+
+function argValue(name, fallback) {
+  const index = process.argv.indexOf(name);
+  if (index >= 0 && index + 1 < process.argv.length) return process.argv[index + 1];
+  const prefix = `${name}=`;
+  const entry = process.argv.find((value) => value.startsWith(prefix));
+  return entry ? entry.slice(prefix.length) : fallback;
+}
+
+function positiveInt(name, fallback) {
+  const value = Number.parseInt(argValue(name, String(fallback)), 10);
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be a positive integer`);
+  return value;
+}
+
+function optionalPositiveNumber(name, envName) {
+  const cli = argValue(name, null);
+  const raw = cli ?? process.env[envName] ?? null;
+  if (raw == null || raw === '') return null;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${name}/${envName} must be a positive number`);
+  }
+  return { value, source: cli != null ? name : envName };
+}
+
+function percentile(sorted, fraction) {
+  if (sorted.length === 0) return 0;
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * fraction) - 1));
+  return sorted[index];
+}
+
+function round(value, digits = 3) {
+  const scale = 10 ** digits;
+  return Math.round(value * scale) / scale;
+}
+
+function readPinnedBaselineP95(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    const value = Number(parsed?.frame_time?.p95_ms);
+    return Number.isFinite(value) && value > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function makeTranscriptItems(count) {
+  const items = new Array(count);
+  for (let index = 0; index < count; index += 1) {
+    const id = `history-${index}`;
+    switch (index % 10) {
+      case 0:
+      case 5:
+        items[index] = { id, kind: 'user', text: `Investigate session ${index} and preserve behavior.` };
+        break;
+      case 1:
+      case 4:
+      case 7:
+        items[index] = {
+          id,
+          kind: 'assistant',
+          text: `Completed transcript item ${index}.\n\n- checked runtime state\n- retained ordering`,
+          streaming: false,
+        };
+        break;
+      case 2:
+      case 6:
+      case 8:
+        items[index] = {
+          id,
+          kind: 'tool',
+          name: index % 2 ? 'agent' : 'shell',
+          args: JSON.stringify({ task_id: `task-${index}`, status: 'completed', path: `src/file-${index % 31}.mjs` }),
+          result: `result ${index}: ok`,
+          completedCount: 1,
+          count: 1,
+        };
+        break;
+      case 3:
+        items[index] = { id, kind: 'notice', tone: 'plain', text: `agent session ${index} completed` };
+        break;
+      default:
+        items[index] = { id, kind: 'turndone', elapsedMs: 100 + index };
+        break;
+    }
+  }
+  return items;
+}
+
+function makeProducer({ writer, lane, burst }) {
+  return async function produce(frame) {
+    await Promise.resolve();
+    const chunks = [];
+    let recordCount = 0;
+    for (let entry = 0; entry < burst; entry += 1) {
+      const text = `lane=${lane} frame=${frame} chunk=${entry} ${'stream '.repeat(6)}\n`;
+      writer.appendAssistant(text);
+      chunks.push(text);
+      recordCount += 1;
+    }
+    const stateItems = [{
+      id: `producer-${lane}-frame-${frame}`,
+      kind: 'assistant',
+      text: chunks.join(''),
+      streaming: false,
+    }];
+    if (frame % 6 === lane % 6) {
+      const command = `producer-${lane}-frame-${frame}`;
+      const result = `producer ${lane} frame ${frame} complete`;
+      writer.appendToolUse('shell', { command });
+      writer.appendToolResult({ stdout: result, exitCode: 0 });
+      recordCount += 2;
+      stateItems.push({
+        id: `producer-tool-${lane}-frame-${frame}`,
+        kind: 'tool',
+        name: 'shell',
+        args: JSON.stringify({ command }),
+        result,
+        count: 1,
+        completedCount: 1,
+      });
+    }
+    return { lane, chunks, recordCount, stateItems };
+  };
+}
+
+function captureTty(columns, rows) {
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      stream.capturedBytes += Buffer.byteLength(chunk);
+      stream.writeCalls += 1;
+      callback();
+    },
+  });
+  stream.columns = columns;
+  stream.rows = rows;
+  stream.isTTY = true;
+  stream.capturedBytes = 0;
+  stream.writeCalls = 0;
+  stream.getColorDepth = () => 1;
+  stream.hasColors = () => false;
+  stream.setRawMode = () => stream;
+  return stream;
+}
+
+function TranscriptHarness({ settledItems, streamingTail, structureRevision, columns, viewportRows }) {
+  const [scrollOffset, setScrollOffset] = React.useState(0);
+  const [measuredRowsVersion, setMeasuredRowsVersion] = React.useState(0);
+  const transcriptAnchorRef = React.useRef(null);
+  const transcriptAnchorDirtyRef = React.useRef(false);
+  const scrollTargetRef = React.useRef(0);
+  const scrollPositionRef = React.useRef(0);
+  const maxScrollRowsRef = React.useRef(0);
+  const transcriptGeomRef = React.useRef({});
+  const followingRef = React.useRef(true);
+  const dragRef = React.useRef({ active: false, rect: null });
+  const transcriptViewportRef = React.useRef({ top: 0 });
+  const selectionLayoutRef = React.useRef(null);
+
+  const {
+    transcriptWindow,
+    renderedTranscriptItems,
+    transcriptTailPinned,
+    transcriptMeasureRef,
+  } = useTranscriptWindow({
+    items: settledItems,
+    structureRevision,
+    streamingTail,
+    themeEpoch: 0,
+    frameColumns: columns,
+    toolOutputExpanded: false,
+    transcriptContentHeight: viewportRows,
+    transcriptBottomSlackRows: 1,
+    transcriptGuardRows: 1,
+    floatingPanelRows: 0,
+    overlayHintRequested: false,
+    scrollOffset,
+    setScrollOffset,
+    transcriptAnchorRef,
+    transcriptAnchorDirtyRef,
+    scrollTargetRef,
+    scrollPositionRef,
+    maxScrollRowsRef,
+    transcriptGeomRef,
+    followingRef,
+    dragRef,
+    transcriptViewportRef,
+    selectionLayoutRef,
+    withSelectionClip: identity,
+    paintSelectionRect: noop,
+    stopSmoothScroll: noop,
+    measuredRowsVersion,
+    setMeasuredRowsVersion,
+  });
+
+  return (
+    <Box flexDirection="column" width={columns} height={viewportRows} overflow="hidden" justifyContent="flex-end">
+      <Box
+        flexDirection="column"
+        width="100%"
+        flexShrink={0}
+        marginBottom={-transcriptWindow.effectiveScrollOffset}
+      >
+        {renderedTranscriptItems.map((item, index, all) => {
+          const measureRef = transcriptMeasureRef(item);
+          const itemNode = (
+            <Item
+              item={item}
+              prevKind={index > 0 ? all[index - 1].kind : null}
+              columns={columns}
+              toolOutputExpanded={false}
+              streamingWindowRows={transcriptTailPinned && item.id === streamingTail?.id
+                ? viewportRows + 4
+                : 0}
+            />
+          );
+          return measureRef ? (
+            <Box key={item.id} ref={measureRef} flexDirection="column" flexShrink={0}>
+              {itemNode}
+            </Box>
+          ) : <React.Fragment key={item.id}>{itemNode}</React.Fragment>;
+        })}
+        {transcriptWindow.bottomSpacerRows > 0
+          ? <Box height={transcriptWindow.bottomSpacerRows} flexShrink={0} />
+          : null}
+      </Box>
+    </Box>
+  );
+}
+
+async function flushFrame(instance) {
+  // The first wait covers the requested React/Ink commit and terminal callback;
+  // the second covers a measured-height harvest update scheduled by layout
+  // effects, matching the production two-commit correction path when it fires.
+  await instance.waitUntilRenderFlush();
+  await instance.waitUntilRenderFlush();
+}
+
+async function waitForAppender(paths, timeoutMs = 5_000) {
+  const deadline = performance.now() + timeoutMs;
+  for (;;) {
+    const stats = paths.map((path) => ({
+      path,
+      inFlight: hasInFlightWrite(path),
+      ...getBufferedAppenderStats(path),
+    }));
+    if (stats.every((entry) => !entry.inFlight && entry.bufferedBytes === 0)) {
+      return { settled: true, stats };
+    }
+    if (performance.now() >= deadline) return { settled: false, stats };
+    await new Promise((resolveWait) => setTimeout(resolveWait, 10));
+  }
+}
+
+function readPersistedRecords(paths) {
+  let records = 0;
+  let malformed = 0;
+  let bytes = 0;
+  for (const path of paths) {
+    const content = readFileSync(path, 'utf8');
+    bytes += Buffer.byteLength(content);
+    for (const line of content.split(/\r?\n/)) {
+      if (!line) continue;
+      try {
+        JSON.parse(line);
+        records += 1;
+      } catch {
+        malformed += 1;
+      }
+    }
+  }
+  return { records, malformed, bytes };
+}
+
+function usage() {
+  process.stdout.write(`tui-runtime-load-bench
+
+Headless production React/Ink + transcript-writer stress bench. Gate precedence:
+--threshold-ms / MIXDOG_TUI_LOAD_THRESHOLD_MS, then checked-in baseline p95 *
+${DEFAULTS.baselineRegressionMargin}, then ${DEFAULTS.thresholdFloorMs}ms. Warm-up calibration is informational
+only. Run --update-baseline intentionally after changing hardware/runner; normal
+runs never rewrite the checked-in baseline.
+
+Options:
+  --items N          settled transcript items (default ${DEFAULTS.items})
+  --frames N         measured frames (default ${DEFAULTS.frames})
+  --producers N      concurrent session-like writers (default ${DEFAULTS.producers})
+  --burst N          assistant records per producer/frame (default ${DEFAULTS.burst})
+  --threshold-ms N   explicit p95 gate (env MIXDOG_TUI_LOAD_THRESHOLD_MS)
+  --update-baseline  replace bench-results/tui-runtime-load-baseline.json on PASS
+  --json             print JSON only
+  --output PATH      also save the JSON result
+`);
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  usage();
+  process.exit(0);
+}
+
+const thresholdOverride = optionalPositiveNumber('--threshold-ms', 'MIXDOG_TUI_LOAD_THRESHOLD_MS');
+const pinnedBaselineP95 = readPinnedBaselineP95(BASELINE_PATH);
+const updateBaseline = process.argv.includes('--update-baseline');
+const config = {
+  items: positiveInt('--items', DEFAULTS.items),
+  frames: positiveInt('--frames', DEFAULTS.frames),
+  producers: positiveInt('--producers', DEFAULTS.producers),
+  burst: positiveInt('--burst', DEFAULTS.burst),
+  columns: positiveInt('--columns', DEFAULTS.columns),
+  viewportRows: positiveInt('--viewport-rows', DEFAULTS.viewportRows),
+  thresholdFloorMs: DEFAULTS.thresholdFloorMs,
+  calibrationFrames: DEFAULTS.calibrationFrames,
+  baselineRegressionMargin: DEFAULTS.baselineRegressionMargin,
+};
+const jsonOnly = process.argv.includes('--json');
+const outputPath = argValue('--output', updateBaseline ? BASELINE_PATH : null);
+const root = mkdtempSync(join(tmpdir(), 'mixdog-tui-load-bench-'));
+const mixdogHome = join(root, 'home');
+const cwd = join(root, 'project');
+mkdirSync(cwd, { recursive: true });
+
+let result;
+let exitCode = 1;
+let instance = null;
+let rssTimer = null;
+const pathsToDrain = [];
+const startedAt = performance.now();
+try {
+  let settledItems = makeTranscriptItems(config.items);
+  const writers = Array.from({ length: config.producers }, (_, lane) => {
+    const writer = createTranscriptWriter({
+      mixdogHome,
+      sessionId: `bench-agent-${lane}`,
+      cwd,
+      pid: process.pid * 100 + lane,
+    });
+    writer.ensureTranscriptFile();
+    pathsToDrain.push(writer.transcriptPath);
+    return writer;
+  });
+  const producers = writers.map((writer, lane) => makeProducer({ writer, lane, burst: config.burst }));
+  const droppedBytesAtStart = getBufferedAppenderStats(pathsToDrain[0]).totalDroppedBytes;
+
+  let peakRss = process.memoryUsage().rss;
+  const sampleRss = () => {
+    peakRss = Math.max(peakRss, process.memoryUsage().rss);
+  };
+  rssTimer = setInterval(sampleRss, 5);
+  rssTimer.unref?.();
+
+  const stdout = captureTty(config.columns, config.viewportRows);
+  const stderr = captureTty(config.columns, config.viewportRows);
+  const stdin = captureTty(config.columns, config.viewportRows);
+  let inkRenderCalls = 0;
+  let streamingText = 'Synthetic live response\n';
+  let streamingTail = { id: 'bench-live-tail', kind: 'assistant', text: streamingText, streaming: true };
+  let structureRevision = 1;
+
+  instance = render(
+    <TranscriptHarness
+      settledItems={settledItems}
+      streamingTail={streamingTail}
+      structureRevision={structureRevision}
+      columns={config.columns}
+      viewportRows={config.viewportRows}
+    />,
+    {
+      stdout,
+      stderr,
+      stdin,
+      interactive: true,
+      patchConsole: false,
+      exitOnCtrlC: false,
+      incrementalRendering: true,
+      maxFps: 1000,
+      onRender: () => { inkRenderCalls += 1; },
+    },
+  );
+  await flushFrame(instance);
+
+  const calibrationTimes = [];
+  for (let index = 0; index < config.calibrationFrames; index += 1) {
+    const begin = performance.now();
+    streamingTail = { ...streamingTail, text: `${streamingText}calibration ${index}\n` };
+    instance.rerender(
+      <TranscriptHarness
+        settledItems={settledItems}
+        streamingTail={streamingTail}
+        structureRevision={structureRevision}
+        columns={config.columns}
+        viewportRows={config.viewportRows}
+      />,
+    );
+    await flushFrame(instance);
+    calibrationTimes.push(performance.now() - begin);
+  }
+  const rawCalibrationP95 = percentile([...calibrationTimes].sort((a, b) => a - b), 0.95);
+  const effectiveThresholdMs = thresholdOverride?.value
+    ?? (pinnedBaselineP95 != null
+      ? pinnedBaselineP95 * config.baselineRegressionMargin
+      : config.thresholdFloorMs);
+  const thresholdSource = thresholdOverride?.source
+    || (pinnedBaselineP95 != null
+      ? `checked-in baseline p95 * ${config.baselineRegressionMargin}`
+      : 'absolute fallback (checked-in baseline unavailable)');
+
+  const frameTimes = [];
+  let expectedRecords = 0;
+  let producerItemsRendered = 0;
+  let framesWithoutInkRender = 0;
+  let framesWithoutTerminalWrite = 0;
+  for (let frame = 0; frame < config.frames; frame += 1) {
+    const frameStarted = performance.now();
+    const priorRenderCalls = inkRenderCalls;
+    const priorTerminalBytes = stdout.capturedBytes;
+    const produced = await Promise.all(producers.map((produce) => produce(frame)));
+    const newItems = produced.flatMap((lane) => lane.stateItems);
+    const frameText = produced.flatMap((lane) => lane.chunks).join('');
+    expectedRecords += produced.reduce((sum, lane) => sum + lane.recordCount, 0);
+    producerItemsRendered += newItems.length;
+    settledItems = [...settledItems, ...newItems];
+    structureRevision += 1;
+    streamingText += frameText;
+    streamingTail = { ...streamingTail, text: streamingText };
+
+    instance.rerender(
+      <TranscriptHarness
+        settledItems={settledItems}
+        streamingTail={streamingTail}
+        structureRevision={structureRevision}
+        columns={config.columns}
+        viewportRows={config.viewportRows}
+      />,
+    );
+    await flushFrame(instance);
+    const elapsed = performance.now() - frameStarted;
+    frameTimes.push(elapsed);
+    if (inkRenderCalls === priorRenderCalls) framesWithoutInkRender += 1;
+    if (stdout.capturedBytes === priorTerminalBytes) framesWithoutTerminalWrite += 1;
+    sampleRss();
+  }
+
+  instance.unmount();
+  await instance.waitUntilExit();
+  instance.cleanup();
+  instance = null;
+
+  const appender = await waitForAppender(pathsToDrain);
+  const persisted = readPersistedRecords(pathsToDrain);
+  const endAppenderStats = getBufferedAppenderStats(pathsToDrain[0]);
+  const droppedBytes = endAppenderStats.totalDroppedBytes - droppedBytesAtStart;
+  const bufferedBytes = appender.stats.reduce((sum, entry) => sum + entry.bufferedBytes, 0);
+  sampleRss();
+
+  const sorted = [...frameTimes].sort((a, b) => a - b);
+  const rawP50 = percentile(sorted, 0.50);
+  const rawP95 = percentile(sorted, 0.95);
+  const rawMax = sorted.at(-1) || 0;
+  const stats = {
+    p50_ms: round(rawP50),
+    p95_ms: round(rawP95),
+    max_ms: round(rawMax),
+    over_threshold_frames: frameTimes.filter((ms) => ms > effectiveThresholdMs).length,
+  };
+  const failures = [];
+  // Compare the unrounded percentile; rounded values are reporting only.
+  if (rawP95 > effectiveThresholdMs) {
+    failures.push(`raw p95 ${rawP95}ms exceeds ${effectiveThresholdMs}ms threshold`);
+  }
+  if (!appender.settled) failures.push('buffered appender did not settle within 5s');
+  if (persisted.records !== expectedRecords) {
+    failures.push(`persisted record count ${persisted.records} != expected ${expectedRecords}`);
+  }
+  if (persisted.malformed !== 0) failures.push(`${persisted.malformed} malformed transcript records`);
+  if (droppedBytes !== 0) failures.push(`buffered appender dropped ${droppedBytes} bytes`);
+  if (bufferedBytes !== 0) failures.push(`buffered appender retained ${bufferedBytes} bytes`);
+  if (framesWithoutInkRender !== 0) failures.push(`${framesWithoutInkRender} frames skipped Ink rendering`);
+  if (framesWithoutTerminalWrite !== 0) failures.push(`${framesWithoutTerminalWrite} frames skipped terminal flush`);
+
+  result = {
+    bench: 'tui-runtime-load',
+    status: failures.length === 0 ? 'PASS' : 'FAIL',
+    threshold: {
+      metric: 'raw_p95_ms',
+      max_ms: round(effectiveThresholdMs),
+      source: thresholdSource,
+      host_dependent: true,
+      baseline_path: 'bench-results/tui-runtime-load-baseline.json',
+      baseline_p95_ms: pinnedBaselineP95,
+      baseline_regression_margin: config.baselineRegressionMargin,
+      calibration_p95_ms: round(rawCalibrationP95),
+      calibration_role: 'informational only',
+    },
+    config,
+    load: {
+      transcript_items: settledItems.length + 1,
+      producer_state_items: producerItemsRendered,
+      expected_records: expectedRecords,
+      persisted_records: persisted.records,
+      malformed_records: persisted.malformed,
+      persisted_bytes: persisted.bytes,
+      dropped_buffer_bytes: droppedBytes,
+      buffered_bytes_after_settle: bufferedBytes,
+      ink_render_calls: inkRenderCalls,
+      terminal_write_calls: stdout.writeCalls,
+      terminal_bytes: stdout.capturedBytes,
+    },
+    frame_time: stats,
+    peak_rss_mb: round(peakRss / (1024 * 1024), 1),
+    wall_ms: round(performance.now() - startedAt, 1),
+    runtime: { node: process.version, platform: process.platform, arch: process.arch },
+    failures,
+  };
+  exitCode = failures.length === 0 ? 0 : 1;
+} catch (error) {
+  result = {
+    bench: 'tui-runtime-load',
+    status: 'FAIL',
+    config,
+    wall_ms: round(performance.now() - startedAt, 1),
+    failures: [error?.stack || String(error)],
+  };
+  exitCode = 1;
+} finally {
+  if (rssTimer) clearInterval(rssTimer);
+  if (instance) {
+    try { instance.unmount(); } catch {}
+    try { instance.cleanup(); } catch {}
+  }
+  for (const path of pathsToDrain) {
+    try { drainPathSync(path); } catch {}
+  }
+  rmSync(root, { recursive: true, force: true });
+}
+
+const serialized = `${JSON.stringify(result, null, 2)}\n`;
+if (outputPath && (!updateBaseline || exitCode === 0)) {
+  const destination = resolve(outputPath);
+  mkdirSync(dirname(destination), { recursive: true });
+  writeFileSync(destination, serialized);
+} else if (updateBaseline && exitCode !== 0) {
+  process.stderr.write('FAIL: refusing to replace baseline with a failed run\n');
+}
+if (jsonOnly) {
+  process.stdout.write(serialized);
+} else {
+  const frame = result.frame_time || {};
+  process.stdout.write(
+    `tui-runtime-load: ${result.status} items=${result.load?.transcript_items ?? config.items} `
+    + `frames=${config.frames} producers=${config.producers}\n`
+    + `frame ms: p50=${frame.p50_ms ?? '-'} p95=${frame.p95_ms ?? '-'} max=${frame.max_ms ?? '-'} `
+    + `(p95 threshold=${result.threshold?.max_ms ?? '-'}ms, over=${frame.over_threshold_frames ?? '-'})\n`
+    + `peak RSS=${result.peak_rss_mb ?? '-'} MB records=${result.load?.persisted_records ?? 0}/`
+    + `${result.load?.expected_records ?? 0} dropped=${result.load?.dropped_buffer_bytes ?? '-'} `
+    + `wall=${result.wall_ms}ms\n`,
+  );
+  for (const failure of result.failures || []) process.stderr.write(`FAIL: ${failure}\n`);
+}
+process.exitCode = exitCode;

package/scripts/tui-runtime-load-bench.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * Builds the JSX bench entry and runs it in-process. Keeping this public
+ * launcher as .mjs matches the other scripts/ benches while the entry can mount
+ * the production JSX transcript components without relying on the TUI bundle.
+ */
+import { build } from 'esbuild';
+import { rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const entry = join(ROOT, 'scripts', 'tui-runtime-load-bench-entry.jsx');
+const outfile = join(ROOT, 'scripts', '.tui-runtime-load-bench.tmp.mjs');
+
+const inkAlias = {
+  name: 'mixdog-ink-alias',
+  setup(ctx) {
+    ctx.onResolve({ filter: /^ink$/ }, () => ({
+      path: '../vendor/ink/build/index.js',
+      external: true,
+    }));
+  },
+};
+
+try {
+  await build({
+    entryPoints: [entry],
+    outfile,
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node22',
+    jsx: 'automatic',
+    packages: 'external',
+    plugins: [inkAlias],
+    banner: {
+      js: "import { createRequire as __mixdogCreateRequire } from 'node:module';\nconst require = __mixdogCreateRequire(import.meta.url);",
+    },
+    logLevel: 'silent',
+  });
+  await import(`${pathToFileURL(outfile).href}?run=${Date.now()}`);
+} finally {
+  await rm(outfile, { force: true });
+}