mixdog 0.7.17 → 0.8.0

package/scripts/mutation-bench.mjs

@@ -1,564 +0,0 @@
-#!/usr/bin/env node
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { performance } from 'node:perf_hooks';
-import { spawn, spawnSync } from 'node:child_process';
-import { createInterface } from 'node:readline';
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const PLUGIN_ROOT = dirname(SCRIPT_DIR);
-process.env.CLAUDE_PLUGIN_ROOT ||= PLUGIN_ROOT;
-// SAFETY: own an isolated temp data dir; never `||=` the LIVE CLAUDE_PLUGIN_DATA,
-// which the finally below would then rm.
-const BENCH_PLUGIN_DATA = join(tmpdir(), `mixdog-bench-data-${process.pid}`);
-process.env.CLAUDE_PLUGIN_DATA = BENCH_PLUGIN_DATA;
-
-const { executeBuiltinTool } = await import(pathToFileURL(join(PLUGIN_ROOT, 'src/agent/orchestrator/tools/builtin.mjs')).href);
-const { executePatchTool, closeNativePatchServerForTests } = await import(pathToFileURL(join(PLUGIN_ROOT, 'src/agent/orchestrator/tools/patch.mjs')).href);
-
-const sizesMb = (process.env.MIXDOG_BENCH_SIZES_MB || '1,10,50')
-  .split(',')
-  .map((v) => Number(v.trim()))
-  .filter((v) => Number.isFinite(v) && v > 0);
-const iterations = Math.max(1, Number(process.env.MIXDOG_BENCH_ITERS || 3));
-const nativeBenchMode = String(process.env.MIXDOG_BENCH_NATIVE || '').toLowerCase();
-const nativePatchServerEnabled = /^(server|persistent)$/i.test(nativeBenchMode)
-  || /^(1|true|yes)$/i.test(process.env.MIXDOG_BENCH_NATIVE_SERVER || '');
-const nativePatchEnabled = nativePatchServerEnabled || /^(1|true|yes|cli)$/i.test(nativeBenchMode);
-const nativeCasePrefix = nativePatchServerEnabled ? 'native-server' : 'native';
-const nativePatchBin = join(
-  PLUGIN_ROOT,
-  'native/mixdog-patch/target/release',
-  process.platform === 'win32' ? 'mixdog-patch.exe' : 'mixdog-patch',
-);
-let nativePatchServer = null;
-
-function makeContent(bytes, markers = []) {
-  const line = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n';
-  const headBytes = Math.max(0, Math.floor((bytes - markers.join('').length) / 2));
-  const tailBytes = Math.max(0, bytes - headBytes - markers.join('').length);
-  const repeatTo = (n) => line.repeat(Math.ceil(n / line.length)).slice(0, n);
-  return repeatTo(headBytes) + markers.join('\n') + repeatTo(tailBytes);
-}
-
-async function timeCase(label, sizeMb, setup, action) {
-  const samples = [];
-  for (let i = 0; i < iterations; i++) {
-    const dir = await mkdtemp(join(tmpdir(), `mixdog-mut-${label}-${sizeMb}m-`));
-    try {
-      await setup(dir, i);
-      const t0 = performance.now();
-      await action(dir, i);
-      samples.push(performance.now() - t0);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  }
-  samples.sort((a, b) => a - b);
-  const sum = samples.reduce((a, b) => a + b, 0);
-  return {
-    case: label,
-    size_mb: sizeMb,
-    min_ms: Number(samples[0].toFixed(2)),
-    median_ms: Number(samples[Math.floor(samples.length / 2)].toFixed(2)),
-    avg_ms: Number((sum / samples.length).toFixed(2)),
-    max_ms: Number(samples[samples.length - 1].toFixed(2)),
-  };
-}
-
-async function writeCaseFile(dir, sizeMb, name, markers) {
-  const bytes = Math.floor(sizeMb * 1024 * 1024);
-  const file = join(dir, name);
-  await writeFile(file, makeContent(bytes, markers), 'utf8');
-}
-
-async function writeHeadMarkerFile(dir, sizeMb, name, markers) {
-  const bytes = Math.floor(sizeMb * 1024 * 1024);
-  const prefix = markers.join('\n') + '\n';
-  const file = join(dir, name);
-  await writeFile(file, prefix + makeContent(Math.max(0, bytes - prefix.length)), 'utf8');
-}
-
-function approxLineCountForSizeMb(sizeMb) {
-  const lineBytes = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n'.length;
-  return Math.max(1, Math.floor((sizeMb * 1024 * 1024) / lineBytes));
-}
-
-// The builtin `read` tool rejects offset > 100000. On large files (10/50 MB ->
-// 160k+ lines) the bench's deep/tail reads must clamp to the deepest supported
-// offset, otherwise the case errors and aborts the whole 10/50 MB run.
-const READ_OFFSET_CAP = 100_000;
-const clampReadOffset = (n) => Math.min(READ_OFFSET_CAP, Math.max(0, n));
-
-function makeLineContent(bytes, markerByLine = new Map()) {
-  const line = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-  const totalLines = Math.max(1, Math.ceil(bytes / (line.length + 1)));
-  const out = [];
-  for (let lineNo = 1; lineNo <= totalLines; lineNo++) {
-    out.push(markerByLine.get(lineNo) || line);
-  }
-  return out.join('\n') + '\n';
-}
-
-function assertToolOk(label, out) {
-  const text = String(out ?? '');
-  if (/^Error(\s|\[|:)/.test(text)) {
-    throw new Error(`${label} failed: ${text.split('\n')[0]}`);
-  }
-  return out;
-}
-
-function ensureNativePatch() {
-  if (!nativePatchEnabled) return;
-  const result = spawnSync('cargo', ['build', '--release', '--manifest-path', join(PLUGIN_ROOT, 'native/mixdog-patch/Cargo.toml')], {
-    encoding: 'utf8',
-    stdio: 'pipe',
-  });
-  if (result.status !== 0) {
-    throw new Error(`native patch build failed:\n${result.stdout || ''}\n${result.stderr || ''}`);
-  }
-}
-
-class NativePatchServer {
-  constructor() {
-    this.child = spawn(nativePatchBin, ['--server'], { stdio: ['pipe', 'pipe', 'pipe'] });
-    this.stderr = '';
-    this.lines = [];
-    this.waiters = [];
-    this.exited = false;
-    this.child.stderr.setEncoding('utf8');
-    this.child.stderr.on('data', (chunk) => { this.stderr += chunk; });
-    this.rl = createInterface({ input: this.child.stdout });
-    this.rl.on('line', (line) => {
-      const waiter = this.waiters.shift();
-      if (waiter) waiter(line);
-      else this.lines.push(line);
-    });
-    this.child.on('exit', (code, signal) => {
-      this.exited = true;
-      const err = new Error(`native patch server exited code=${code} signal=${signal} stderr=${this.stderr}`);
-      for (const waiter of this.waiters.splice(0)) waiter(null, err);
-    });
-  }
-
-  nextLine() {
-    if (this.lines.length > 0) return Promise.resolve(this.lines.shift());
-    if (this.exited) return Promise.reject(new Error(`native patch server already exited: ${this.stderr}`));
-    return new Promise((resolve, reject) => {
-      this.waiters.push((line, err) => err ? reject(err) : resolve(line));
-    });
-  }
-
-  async apply(dir, patch, label) {
-    const baseBuf = Buffer.from(dir, 'utf8');
-    const patchBuf = Buffer.from(patch, 'utf8');
-    const linePromise = this.nextLine();
-    this.child.stdin.write(`APPLY ${baseBuf.length} ${patchBuf.length} 1 0\n`);
-    this.child.stdin.write(baseBuf);
-    this.child.stdin.write(patchBuf);
-    const line = await linePromise;
-    if (!line || !line.startsWith('OK\t')) {
-      throw new Error(`${label} failed: ${line || '(no response)'}\nstderr=${this.stderr}`);
-    }
-  }
-
-  async close() {
-    if (this.exited) return;
-    this.child.stdin.end('QUIT\n');
-    await new Promise((resolve) => this.child.once('exit', resolve));
-    this.rl.close();
-  }
-}
-
-async function runNativePatch(dir, patch, label = 'native-apply-patch') {
-  if (nativePatchServerEnabled) {
-    if (!nativePatchServer) throw new Error('native patch server is not running');
-    await nativePatchServer.apply(dir, patch, label);
-    return;
-  }
-  const result = spawnSync(nativePatchBin, ['--base', dir], {
-    input: patch,
-    encoding: 'utf8',
-    stdio: 'pipe',
-    maxBuffer: 1024 * 1024,
-  });
-  if (result.status !== 0) {
-    throw new Error(`${label} failed:\nstdout=${result.stdout || ''}\nstderr=${result.stderr || ''}`);
-  }
-}
-
-async function warmHeadRead(dir, path, scope, n = 200) {
-  assertToolOk(`read ${path}`, await executeBuiltinTool('read', { path, mode: 'head', n }, dir, { readStateScope: scope }));
-}
-
-async function run() {
-  await mkdir(process.env.CLAUDE_PLUGIN_DATA, { recursive: true });
-  ensureNativePatch();
-  if (nativePatchServerEnabled) nativePatchServer = new NativePatchServer();
-  const rows = [];
-  try {
-    for (const sizeMb of sizesMb) {
-    rows.push(await timeCase('edit-single', sizeMb, async (dir, i) => {
-      const scope = `bench-single-${sizeMb}-${i}`;
-      await writeHeadMarkerFile(dir, sizeMb, 'single.txt', [`__TARGET_${i}__`]);
-      await warmHeadRead(dir, 'single.txt', scope);
-    }, async (dir, i) => {
-      assertToolOk('edit-single', await executeBuiltinTool('edit', {
-        path: 'single.txt',
-        old_string: `__TARGET_${i}__`,
-        new_string: `__REPLACED_${i}__`,
-      }, dir, { readStateScope: `bench-single-${sizeMb}-${i}` }));
-    }));
-
-    if (sizeMb <= 32) {
-      rows.push(await timeCase('write-edit-chain', sizeMb, async () => {}, async (dir, i) => {
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        const marker = `__WRITE_EDIT_${i}__`;
-        const content = `${marker}\n${makeContent(Math.max(0, bytes - marker.length - 1))}`;
-        const scope = `bench-write-edit-chain-${sizeMb}-${i}`;
-        assertToolOk('write-edit-chain write', await executeBuiltinTool('write', {
-          path: 'write-edit-chain.txt',
-          content,
-        }, dir, { readStateScope: scope }));
-        assertToolOk('write-edit-chain edit', await executeBuiltinTool('edit', {
-          path: 'write-edit-chain.txt',
-          old_string: marker,
-          new_string: `__WRITE_EDIT_DONE_${i}__`,
-        }, dir, { readStateScope: scope }));
-      }));
-    }
-
-    rows.push(await timeCase('edit-multi', sizeMb, async (dir, i) => {
-      const scope = `bench-multi-${sizeMb}-${i}`;
-      await writeHeadMarkerFile(dir, sizeMb, 'multi.txt', [`__LEFT_${i}__`, `__RIGHT_${i}__`]);
-      await warmHeadRead(dir, 'multi.txt', scope);
-    }, async (dir, i) => {
-      assertToolOk('edit-multi', await executeBuiltinTool('edit', {
-        path: 'multi.txt',
-        edits: [
-          { old_string: `__LEFT_${i}__`, new_string: `__LEFT_DONE_${i}__` },
-          { old_string: `__RIGHT_${i}__`, new_string: `__RIGHT_DONE_${i}__` },
-        ],
-      }, dir, { readStateScope: `bench-multi-${sizeMb}-${i}` }));
-    }));
-
-    rows.push(await timeCase('edit-replace-all', sizeMb, async (dir, i) => {
-      const scope = `bench-replace-${sizeMb}-${i}`;
-      const marker = `__ALL_${i}__`;
-      const markers = Array.from({ length: 128 }, () => marker);
-      await writeHeadMarkerFile(dir, sizeMb, 'replace-all.txt', markers);
-      await warmHeadRead(dir, 'replace-all.txt', scope, 256);
-    }, async (dir, i) => {
-      const marker = `__ALL_${i}__`;
-      assertToolOk('edit-replace-all', await executeBuiltinTool('edit', {
-        path: 'replace-all.txt',
-        old_string: marker,
-        new_string: `__ALL_DONE_${i}__`,
-        replace_all: true,
-      }, dir, { readStateScope: `bench-replace-${sizeMb}-${i}` }));
-    }));
-
-    rows.push(await timeCase('apply-patch', sizeMb, async (dir, i) => {
-      const before = `__PATCH_${i}__`;
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      await writeFile(join(dir, 'patch.txt'), before + '\n' + makeContent(Math.max(0, bytes - before.length - 1)), 'utf8');
-    }, async (dir, i) => {
-      const before = `__PATCH_${i}__`;
-      const after = `__PATCH_DONE_${i}__`;
-      const patch = [
-        '--- a/patch.txt',
-        '+++ b/patch.txt',
-        '@@ -1,1 +1,1 @@',
-        `-${before}`,
-        `+${after}`,
-        '',
-      ].join('\n');
-      assertToolOk('apply-patch', await executePatchTool('apply_patch', { patch, base_path: dir }, dir, { readStateScope: `bench-patch-${sizeMb}-${i}` }));
-    }));
-
-    rows.push(await timeCase('apply-patch-insert', sizeMb, async (dir, i) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      const midLine = Math.max(2, Math.floor(lineCount / 2));
-      await writeFile(join(dir, 'insert.txt'), makeLineContent(bytes, new Map([
-        [midLine, `__INSERT_AFTER_${i}__`],
-      ])), 'utf8');
-    }, async (dir, i) => {
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      const midLine = Math.max(2, Math.floor(lineCount / 2));
-      const patch = [
-        '--- a/insert.txt',
-        '+++ b/insert.txt',
-        `@@ -${midLine - 1},0 +${midLine},1 @@`,
-        `+__INSERTED_${i}__`,
-        '',
-      ].join('\n');
-      assertToolOk('apply-patch-insert', await executePatchTool('apply_patch', { patch, base_path: dir }, dir, { readStateScope: `bench-patch-insert-${sizeMb}-${i}` }));
-    }));
-
-    for (const [label, offset] of [
-      ['read-range-head', 10],
-      ['read-range-mid', clampReadOffset(Math.floor(approxLineCountForSizeMb(sizeMb) / 2))],
-      ['read-range-tail', clampReadOffset(approxLineCountForSizeMb(sizeMb) - 100)],
-    ]) {
-      rows.push(await timeCase(label, sizeMb, async (dir) => {
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        await writeFile(join(dir, 'range.txt'), makeContent(bytes), 'utf8');
-      }, async (dir) => {
-        assertToolOk(label, await executeBuiltinTool('read', {
-          path: 'range.txt',
-          offset,
-          limit: 20,
-        }, dir, { readStateScope: `bench-${label}-${sizeMb}` }));
-      }));
-    }
-
-    rows.push(await timeCase('read-mode-head', sizeMb, async (dir) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      await writeFile(join(dir, 'mode-head.txt'), makeContent(bytes), 'utf8');
-    }, async (dir) => {
-      assertToolOk('read-mode-head', await executeBuiltinTool('read', {
-        path: 'mode-head.txt',
-        mode: 'head',
-        n: 20,
-      }, dir, { readStateScope: `bench-read-mode-head-${sizeMb}` }));
-    }));
-
-    rows.push(await timeCase('read-mode-tail', sizeMb, async (dir) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      await writeFile(join(dir, 'mode-tail.txt'), makeContent(bytes), 'utf8');
-    }, async (dir) => {
-      assertToolOk('read-mode-tail', await executeBuiltinTool('read', {
-        path: 'mode-tail.txt',
-        mode: 'tail',
-        n: 20,
-      }, dir, { readStateScope: `bench-read-mode-tail-${sizeMb}` }));
-    }));
-
-    if (sizeMb <= 10) {
-      rows.push(await timeCase('read-default-smart', sizeMb, async (dir) => {
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        await writeFile(join(dir, 'default-smart.txt'), makeContent(bytes), 'utf8');
-      }, async (dir) => {
-        const out = assertToolOk('read-default-smart', await executeBuiltinTool('read', {
-          path: 'default-smart.txt',
-        }, dir, { readStateScope: `bench-read-default-smart-${sizeMb}` }));
-        if (!String(out).includes('TRUNCATED')) {
-          throw new Error('read-default-smart did not use the smart summary path');
-        }
-      }));
-    }
-
-    rows.push(await timeCase('read-mode-count', sizeMb, async (dir) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      await writeFile(join(dir, 'mode-count.txt'), makeContent(bytes), 'utf8');
-    }, async (dir) => {
-      assertToolOk('read-mode-count', await executeBuiltinTool('read', {
-        path: 'mode-count.txt',
-        mode: 'count',
-      }, dir, { readStateScope: `bench-read-mode-count-${sizeMb}` }));
-    }));
-
-    rows.push(await timeCase('read-range-tail-cached', sizeMb, async (dir) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      await writeFile(join(dir, 'range-cached.txt'), makeContent(bytes), 'utf8');
-      assertToolOk('read-range-tail-cached-warm', await executeBuiltinTool('read', {
-        path: 'range-cached.txt',
-        offset: clampReadOffset(lineCount - 200),
-        limit: 20,
-      }, dir, { readStateScope: `bench-read-range-tail-cached-warm-${sizeMb}` }));
-    }, async (dir) => {
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      assertToolOk('read-range-tail-cached', await executeBuiltinTool('read', {
-        path: 'range-cached.txt',
-        offset: clampReadOffset(lineCount - 100),
-        limit: 20,
-      }, dir, { readStateScope: `bench-read-range-tail-cached-${sizeMb}` }));
-    }));
-
-    rows.push(await timeCase('read-batch-far-ranges', sizeMb, async (dir) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      await writeFile(join(dir, 'batch-far.txt'), makeContent(bytes), 'utf8');
-    }, async (dir) => {
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      assertToolOk('read-batch-far-ranges', await executeBuiltinTool('read', {
-        path: [
-          { path: 'batch-far.txt', offset: 10, limit: 20 },
-          { path: 'batch-far.txt', offset: clampReadOffset(lineCount - 100), limit: 20 },
-        ],
-      }, dir, { readStateScope: `bench-read-batch-far-${sizeMb}` }));
-    }));
-
-    rows.push(await timeCase('apply-patch-multihunk', sizeMb, async (dir, i) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      const head = `__MH_HEAD_${i}__`;
-      const mid = `__MH_MID_${i}__`;
-      const tail = `__MH_TAIL_${i}__`;
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      const midLine = Math.max(2, Math.floor(lineCount / 2));
-      const tailLine = Math.max(midLine + 1, lineCount - 1);
-      await writeFile(join(dir, 'multi-hunk.txt'), makeLineContent(bytes, new Map([
-        [1, head],
-        [midLine, mid],
-        [tailLine, tail],
-      ])), 'utf8');
-    }, async (dir, i) => {
-      const beforeHead = `__MH_HEAD_${i}__`;
-      const beforeMid = `__MH_MID_${i}__`;
-      const beforeTail = `__MH_TAIL_${i}__`;
-      const lineCount = approxLineCountForSizeMb(sizeMb);
-      const midLine = Math.max(2, Math.floor(lineCount / 2));
-      const tailLine = Math.max(midLine + 1, lineCount - 1);
-      const patch = [
-        '--- a/multi-hunk.txt',
-        '+++ b/multi-hunk.txt',
-        '@@ -1,1 +1,1 @@',
-        `-${beforeHead}`,
-        `+__MH_HEAD_DONE_${i}__`,
-        `@@ -${midLine},1 +${midLine},1 @@`,
-        `-${beforeMid}`,
-        `+__MH_MID_DONE_${i}__`,
-        `@@ -${tailLine},1 +${tailLine},1 @@`,
-        `-${beforeTail}`,
-        `+__MH_TAIL_DONE_${i}__`,
-        '',
-      ].join('\n');
-      assertToolOk('apply-patch-multihunk', await executePatchTool('apply_patch', { patch, base_path: dir }, dir, { readStateScope: `bench-patch-mh-${sizeMb}-${i}` }));
-    }));
-
-    rows.push(await timeCase('apply-patch-multifile', sizeMb, async (dir, i) => {
-      const bytes = Math.floor(sizeMb * 1024 * 1024);
-      await writeFile(join(dir, 'file-a.txt'), `__MF_A_${i}__\n` + makeContent(bytes), 'utf8');
-      await writeFile(join(dir, 'file-b.txt'), `__MF_B_${i}__\n` + makeContent(bytes), 'utf8');
-    }, async (dir, i) => {
-      const patch = [
-        '--- a/file-a.txt',
-        '+++ b/file-a.txt',
-        '@@ -1,1 +1,1 @@',
-        `-__MF_A_${i}__`,
-        `+__MF_A_DONE_${i}__`,
-        '--- a/file-b.txt',
-        '+++ b/file-b.txt',
-        '@@ -1,1 +1,1 @@',
-        `-__MF_B_${i}__`,
-        `+__MF_B_DONE_${i}__`,
-        '',
-      ].join('\n');
-      assertToolOk('apply-patch-multifile', await executePatchTool('apply_patch', { patch, base_path: dir }, dir, { readStateScope: `bench-patch-mf-${sizeMb}-${i}` }));
-    }));
-
-    if (nativePatchEnabled) {
-      rows.push(await timeCase(`${nativeCasePrefix}-apply-patch`, sizeMb, async (dir, i) => {
-        const before = `__PATCH_${i}__`;
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        await writeFile(join(dir, 'patch.txt'), before + '\n' + makeContent(Math.max(0, bytes - before.length - 1)), 'utf8');
-      }, async (dir, i) => {
-        const before = `__PATCH_${i}__`;
-        const after = `__PATCH_DONE_${i}__`;
-        const patch = [
-          '--- a/patch.txt',
-          '+++ b/patch.txt',
-          '@@ -1,1 +1,1 @@',
-          `-${before}`,
-          `+${after}`,
-          '',
-        ].join('\n');
-        await runNativePatch(dir, patch, `${nativeCasePrefix}-apply-patch`);
-      }));
-
-      rows.push(await timeCase(`${nativeCasePrefix}-apply-patch-insert`, sizeMb, async (dir, i) => {
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        const lineCount = approxLineCountForSizeMb(sizeMb);
-        const midLine = Math.max(2, Math.floor(lineCount / 2));
-        await writeFile(join(dir, 'insert.txt'), makeLineContent(bytes, new Map([
-          [midLine, `__INSERT_AFTER_${i}__`],
-        ])), 'utf8');
-      }, async (dir, i) => {
-        const lineCount = approxLineCountForSizeMb(sizeMb);
-        const midLine = Math.max(2, Math.floor(lineCount / 2));
-        const patch = [
-          '--- a/insert.txt',
-          '+++ b/insert.txt',
-          `@@ -${midLine - 1},0 +${midLine},1 @@`,
-          `+__INSERTED_${i}__`,
-          '',
-        ].join('\n');
-        await runNativePatch(dir, patch, `${nativeCasePrefix}-apply-patch-insert`);
-      }));
-
-      rows.push(await timeCase(`${nativeCasePrefix}-apply-patch-multihunk`, sizeMb, async (dir, i) => {
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        const head = `__MH_HEAD_${i}__`;
-        const mid = `__MH_MID_${i}__`;
-        const tail = `__MH_TAIL_${i}__`;
-        const lineCount = approxLineCountForSizeMb(sizeMb);
-        const midLine = Math.max(2, Math.floor(lineCount / 2));
-        const tailLine = Math.max(midLine + 1, lineCount - 1);
-        await writeFile(join(dir, 'multi-hunk.txt'), makeLineContent(bytes, new Map([
-          [1, head],
-          [midLine, mid],
-          [tailLine, tail],
-        ])), 'utf8');
-      }, async (dir, i) => {
-        const lineCount = approxLineCountForSizeMb(sizeMb);
-        const midLine = Math.max(2, Math.floor(lineCount / 2));
-        const tailLine = Math.max(midLine + 1, lineCount - 1);
-        const patch = [
-          '--- a/multi-hunk.txt',
-          '+++ b/multi-hunk.txt',
-          '@@ -1,1 +1,1 @@',
-          `-__MH_HEAD_${i}__`,
-          `+__MH_HEAD_DONE_${i}__`,
-          `@@ -${midLine},1 +${midLine},1 @@`,
-          `-__MH_MID_${i}__`,
-          `+__MH_MID_DONE_${i}__`,
-          `@@ -${tailLine},1 +${tailLine},1 @@`,
-          `-__MH_TAIL_${i}__`,
-          `+__MH_TAIL_DONE_${i}__`,
-          '',
-        ].join('\n');
-        await runNativePatch(dir, patch, `${nativeCasePrefix}-apply-patch-multihunk`);
-      }));
-
-      rows.push(await timeCase(`${nativeCasePrefix}-apply-patch-multifile`, sizeMb, async (dir, i) => {
-        const bytes = Math.floor(sizeMb * 1024 * 1024);
-        await writeFile(join(dir, 'file-a.txt'), `__MF_A_${i}__\n` + makeContent(bytes), 'utf8');
-        await writeFile(join(dir, 'file-b.txt'), `__MF_B_${i}__\n` + makeContent(bytes), 'utf8');
-      }, async (dir, i) => {
-        const patch = [
-          '--- a/file-a.txt',
-          '+++ b/file-a.txt',
-          '@@ -1,1 +1,1 @@',
-          `-__MF_A_${i}__`,
-          `+__MF_A_DONE_${i}__`,
-          '--- a/file-b.txt',
-          '+++ b/file-b.txt',
-          '@@ -1,1 +1,1 @@',
-          `-__MF_B_${i}__`,
-          `+__MF_B_DONE_${i}__`,
-          '',
-        ].join('\n');
-        await runNativePatch(dir, patch, `${nativeCasePrefix}-apply-patch-multifile`);
-      }));
-    }
-  }
-
-  console.table(rows);
-  console.log(JSON.stringify({ iterations, sizes_mb: sizesMb, rows }, null, 2));
-  } finally {
-    await nativePatchServer?.close();
-    nativePatchServer = null;
-    await closeNativePatchServerForTests();
-  }
-}
-
-try {
-  await run();
-} finally {
-  if (!process.env.MIXDOG_BENCH_KEEP_DATA) {
-    await rm(BENCH_PLUGIN_DATA, { recursive: true, force: true });
-  }
-}