use criterion::{    BatchSize, BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main,};use rand::{Rng as _, SeedableRng as _, rngs::StdRng};use streaming_diff::StreamingDiff; const SEED: u64 = 0x5EED_5EED;const CHUNK_SIZE: usize = 512; #[derive(Clone)]struct EditFixture {    name: &'static str,    old_text: String,    new_text: String,} fn streaming_diff_push_new(criterion: &mut Criterion) {    let fixtures = fixtures();    let mut group = criterion.benchmark_group("streaming_diff_push_new");    group.sample_size(10);     for fixture in fixtures {        group.throughput(Throughput::Bytes(fixture.new_text.len() as u64));        group.bench_with_input(            BenchmarkId::new(fixture.name, fixture.old_text.len()),            &fixture,            |bench, fixture| {                bench.iter_batched(                    || StreamingDiff::new(fixture.old_text.clone()),                    |mut diff| {                        let mut operation_count = 0;                        for chunk in chunk_text(&fixture.new_text, CHUNK_SIZE) {                            operation_count += black_box(diff.push_new(chunk)).len();                        }                        black_box(operation_count);                    },                    BatchSize::SmallInput,                );            },        );    }     group.finish();} fn streaming_diff_finish(criterion: &mut Criterion) {    let fixtures = fixtures();    let mut group = criterion.benchmark_group("streaming_diff_finish");    group.sample_size(10);     for fixture in fixtures {        group.throughput(Throughput::Bytes(fixture.new_text.len() as u64));        group.bench_with_input(            BenchmarkId::new(fixture.name, fixture.old_text.len()),            &fixture,            |bench, fixture| {                bench.iter_batched(                    || {                        let mut diff = StreamingDiff::new(fixture.old_text.clone());                        for chunk in chunk_text(&fixture.new_text, CHUNK_SIZE) {                            black_box(diff.push_new(chunk));                        }                        diff                    },                    |diff| {                        black_box(diff.finish());                    },                    BatchSize::SmallInput,                );            },        );    }     group.finish();} fn fixtures() -> Vec<EditFixture> {    // Keep fixtures modest because `StreamingDiff` is intentionally stressed here and    // can become very slow on tens of kilobytes of replacement text. These sizes still    // represent realistic `edit_file` old/new text blocks and are large enough to cross    // frame-budget-sized CPU work.    vec![        make_fixture(            "tiny_function_rewrite",            2,            EditPattern::LocalizedRewrite {                start_line: 12,                line_count: 6,            },            SEED,        ),        make_fixture(            "small_function_rewrite",            5,            EditPattern::LocalizedRewrite {                start_line: 22,                line_count: 12,            },            SEED + 1,        ),        make_fixture(            "medium_many_small_changes",            8,            EditPattern::ManySmallChanges { every_nth_line: 7 },            SEED + 2,        ),        make_fixture(            "medium_insertions",            8,            EditPattern::InsertHelperBlocks { every_nth_line: 9 },            SEED + 3,        ),    ]} enum EditPattern {    LocalizedRewrite {        start_line: usize,        line_count: usize,    },    ManySmallChanges {        every_nth_line: usize,    },    InsertHelperBlocks {        every_nth_line: usize,    },} fn make_fixture(    name: &'static str,    function_count: usize,    pattern: EditPattern,    seed: u64,) -> EditFixture {    let mut rng = StdRng::seed_from_u64(seed);    let mut lines = random_rust_module(&mut rng, function_count);    let old_text = lines.join("\n");     match pattern {        EditPattern::LocalizedRewrite {            start_line,            line_count,        } => rewrite_local_block(&mut lines, start_line, line_count, &mut rng),        EditPattern::ManySmallChanges { every_nth_line } => {            rewrite_many_small_lines(&mut lines, every_nth_line, &mut rng)        }        EditPattern::InsertHelperBlocks { every_nth_line } => {            insert_helper_blocks(&mut lines, every_nth_line, &mut rng)        }    }     EditFixture {        name,        old_text,        new_text: lines.join("\n"),    }} fn random_rust_module(rng: &mut StdRng, function_count: usize) -> Vec<String> {    let mut lines = vec![        "use anyhow::{Context as _, Result};".to_string(),        "use collections::HashMap;".to_string(),        "".to_string(),        "#[derive(Clone, Debug)]".to_string(),        "pub struct WorkspaceSnapshot {".to_string(),        "    buffers: HashMap<String, usize>,".to_string(),        "    version: usize,".to_string(),        "}".to_string(),        "".to_string(),        "impl WorkspaceSnapshot {".to_string(),    ];     for function_index in 0..function_count {        let function_name = identifier(rng, function_index);        let argument_name = identifier(rng, function_index + 1_000);        let local_name = identifier(rng, function_index + 2_000);        let branch_name = identifier(rng, function_index + 3_000);        let multiplier = rng.random_range(2..17);        let offset = rng.random_range(1..128);         lines.extend([            format!(                "    pub fn {function_name}(&mut self, {argument_name}: usize) -> Result<usize> {{"            ),            format!("        let mut {local_name} = {argument_name}.saturating_mul({multiplier});"),            format!("        if {local_name} % 2 == 0 {{"),            format!(                "            {local_name} = {local_name}.saturating_add(self.version + {offset});"            ),            "        } else {".to_string(),            format!("            {local_name} = {local_name}.saturating_sub({offset});"),            "        }".to_string(),            format!("        let {branch_name} = self.buffers.len().saturating_add({local_name});"),            format!("        self.version = self.version.saturating_add({branch_name});"),            format!("        Ok({branch_name})"),            "    }".to_string(),            "".to_string(),        ]);    }     lines.push("}".to_string());    lines.push("".to_string());    lines.push("pub fn normalize_path(path: &str) -> String {".to_string());    lines.push("    path.replace('\\\\', \"/\")".to_string());    lines.push("}".to_string());    lines} fn rewrite_local_block(    lines: &mut [String],    start_line: usize,    line_count: usize,    rng: &mut StdRng,) {    let end_line = (start_line + line_count).min(lines.len());    for (relative_index, line) in lines[start_line..end_line].iter_mut().enumerate() {        let suffix = identifier(rng, relative_index + 10_000);        if line.contains("saturating_add") {            *line = format!(                "        let {suffix} = self.version.checked_add({relative_index}).context(\"version overflow\")?;"            );        } else if line.contains("saturating_sub") {            *line = format!(                "            {suffix}.saturating_sub({});",                rng.random_range(8..256)            );        } else if line.trim().is_empty() {            *line = format!(                "        tracing::trace!(target: \"agent_bench\", value = {relative_index});"            );        } else {            *line = format!("{line} // updated {suffix}");        }    }} fn rewrite_many_small_lines(lines: &mut [String], every_nth_line: usize, rng: &mut StdRng) {    for (line_index, line) in lines.iter_mut().enumerate() {        if line_index % every_nth_line != 0 || line.trim().is_empty() {            continue;        }         if line.contains("let mut") {            *line = line.replace("let mut", "let mut updated");        } else if line.contains("Ok(") {            *line = line.replace("Ok(", "Ok(black_box_value(");        } else if line.ends_with('{') {            *line = format!("{line} // scenario {}", identifier(rng, line_index));        } else {            *line = format!("{line} // touched {}", identifier(rng, line_index));        }    }} fn insert_helper_blocks(lines: &mut Vec<String>, every_nth_line: usize, rng: &mut StdRng) {    let mut line_index = every_nth_line;    while line_index < lines.len() {        if lines[line_index].trim() == "}" {            let helper_name = identifier(rng, line_index + 20_000);            lines.splice(                line_index..line_index,                [                    format!("        let {helper_name} = self.buffers.len();"),                    format!("        tracing::trace!(target: \"agent_bench\", {helper_name});"),                ],            );            line_index += 2;        }        line_index += every_nth_line;    }} fn identifier(rng: &mut StdRng, salt: usize) -> String {    const WORDS: &[&str] = &[        "buffer",        "workspace",        "snapshot",        "version",        "project",        "entry",        "path",        "cursor",        "anchor",        "edit",        "thread",        "message",        "context",        "store",        "diff",        "range",        "token",        "parser",        "semantic",        "format",        "completion",        "diagnostic",        "terminal",        "channel",    ];     let first = WORDS[(rng.random_range(0..WORDS.len()) + salt) % WORDS.len()];    let second = WORDS[(rng.random_range(0..WORDS.len()) + salt / 3) % WORDS.len()];    format!("{first}_{second}_{salt}")} fn chunk_text(text: &str, max_chunk_size: usize) -> Vec<&str> {    let mut chunks = Vec::new();    let mut start = 0;    while start < text.len() {        let mut end = (start + max_chunk_size).min(text.len());        while end < text.len() && !text.is_char_boundary(end) {            end += 1;        }        chunks.push(&text[start..end]);        start = end;    }    chunks} criterion_group!(benches, streaming_diff_push_new, streaming_diff_finish);criterion_main!(benches);