mixdog 0.7.1

package/scripts/mutation-bench.mjs

@@ -0,0 +1,564 @@
+#!/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 });
+  }
+}