test(e2e): let a step redact its output with its own patterns

Some steps remove several inputs at once, and vt reports whichever
mismatch its parallel validation finds first, so the step's "cache miss"
line changes from run to run. A new `redact` step key maps regexes to
replacements; the harness applies them in key order to that step's
output after the global redactions, and an invalid regex fails when the
fixtures load.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: wan9chi

crates/vt_bin/tests/e2e_snapshots/README.md

@@ -36,7 +36,8 @@ steps = [
 Notes:
 
 - An array step is shorthand for `{ argv = [...] }`. A string step such as `"vt run build"` doesn't parse, and the test binary panics while loading the fixtures, before any case runs.
-- A table step takes `argv` (required), `cwd` (relative to the fixture root, defaulting to the case's `cwd`), `comment` (shown under the step's heading in the snapshot), `envs` (`[name, value]` pairs), `interactions`, and `formatted-snapshot` (keep colors and styles in the snapshot). Other keys are an error.
+- A table step takes `argv` (required), `cwd` (relative to the fixture root, defaulting to the case's `cwd`), `comment` (shown under the step's heading in the snapshot), `envs` (`[name, value]` pairs), `interactions`, `formatted-snapshot` (keep colors and styles in the snapshot), and `redact`. Other keys are an error.
+- `redact` maps regexes to replacements for output that varies between runs, such as `redact = { 'cache miss: .*' = 'cache miss: <changed input>' }`. They rewrite the step's output in key order, after the built-in redactions, and a replacement can refer to capture groups as `$1`. TOML literal strings (`'…'`) keep regex backslashes unescaped. An invalid regex, like an unknown key, makes the test binary panic while loading the fixtures.
 - A case takes `name` (ASCII letters, digits, and `_` only; it also names the snapshot file), `steps`, and optionally `comment`, `cwd`, `cfg` (a Rust cfg expression such as `'target_os = "linux"'`; the case runs only where it matches), and `ignore` (the case runs only with `-- --ignored`).
 - `vt` and `vtt` are the binaries built for the test. Other programs are looked up in `PATH`, with `packages/tools/node_modules/.bin` (when installed) ahead of the inherited entries.
 - `write-key` accepts `up`, `down`, `enter`, `escape`, `backspace`, and `ctrl-c`.

crates/vt_bin/tests/e2e_snapshots/fixtures/step_redact/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "step-redact",
+  "private": true
+}

crates/vt_bin/tests/e2e_snapshots/fixtures/step_redact/snapshots.toml

@@ -0,0 +1,19 @@
+[[e2e]]
+name = "step_redact_rewrites_only_its_own_output"
+comment = """
+A step's `redact` table rewrites regex matches in that step's output and leaves other steps' output alone.
+"""
+steps = [
+  { argv = [
+    "vtt",
+    "print",
+    "value:",
+    "8f3a1c",
+  ], comment = "`redact` replaces the value", redact = { 'value: \w+' = 'value: <value>' } },
+  { argv = [
+    "vtt",
+    "print",
+    "value:",
+    "8f3a1c",
+  ], comment = "no `redact`, so the value stays" },
+]

crates/vt_bin/tests/e2e_snapshots/fixtures/step_redact/snapshots/step_redact_rewrites_only_its_own_output.md

@@ -0,0 +1,19 @@
+# step_redact_rewrites_only_its_own_output
+
+A step's `redact` table rewrites regex matches in that step's output and leaves other steps' output alone.
+
+## `vtt print value: 8f3a1c`
+
+`redact` replaces the value
+
+```
+value: <value>
+```
+
+## `vtt print value: 8f3a1c`
+
+no `redact`, so the value stays
+
+```
+value: 8f3a1c
+```

crates/vt_bin/tests/e2e_snapshots/main.rs

@@ -1,6 +1,7 @@
 mod redact;
 
 use std::{
+    collections::BTreeMap,
     env::{self, join_paths, split_paths},
     ffi::OsStr,
     io::Write,
@@ -59,6 +60,10 @@ struct StepConfig {
     /// assertion. Default `false` keeps the plain-text behaviour.
     #[serde(default, rename = "formatted-snapshot")]
     formatted_snapshot: bool,
+    /// Regex → replacement pairs for output that varies between runs, applied
+    /// in key order after the global redactions.
+    #[serde(default, deserialize_with = "deserialize_redactions")]
+    redact: Vec<(regex::Regex, Str)>,
 }
 
 impl Step {
@@ -148,6 +153,13 @@ impl Step {
             Self::Simple(_) => false,
         }
     }
+
+    fn redactions(&self) -> &[(regex::Regex, Str)] {
+        match self {
+            Self::Detailed(config) => &config.redact,
+            Self::Simple(_) => &[],
+        }
+    }
 }
 
 #[derive(serde::Deserialize, Debug, Clone)]
@@ -221,6 +233,22 @@ impl WriteKey {
     }
 }
 
+/// Compiles a step's `redact` table in key order, so an invalid regex fails
+/// when the fixtures load.
+fn deserialize_redactions<'de, D>(deserializer: D) -> Result<Vec<(regex::Regex, Str)>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let table = <BTreeMap<Str, Str> as serde::Deserialize>::deserialize(deserializer)?;
+    table
+        .into_iter()
+        .map(|(pattern, replacement)| {
+            let regex = regex::Regex::new(pattern.as_str()).map_err(serde::de::Error::custom)?;
+            Ok((regex, replacement))
+        })
+        .collect()
+}
+
 fn deserialize_cfg_expr<'de, D>(
     deserializer: D,
 ) -> Result<Option<cargo_platform::CfgExpr>, D::Error>
@@ -652,7 +680,7 @@ fn run_case(
                 }
             }
 
-            e2e_outputs.push_str(&redact_e2e_output(output, e2e_stage_path_str));
+            e2e_outputs.push_str(&redact_e2e_output(output, e2e_stage_path_str, step.redactions()));
 
             // Skip remaining steps if timed out
             if matches!(termination_state, TerminationState::TimedOut) {

crates/vt_bin/tests/e2e_snapshots/redact.rs

@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+use vt_str::Str;
+
 #[expect(
     clippy::disallowed_types,
     reason = "String mutation required by regex replace and cow_replace APIs"
@@ -26,7 +28,11 @@ fn redact_string(s: &mut String, redactions: &[(&str, &str)]) {
     clippy::disallowed_types,
     reason = "String required by regex replace_all and cow_replace APIs; Path required for CARGO_MANIFEST_DIR path manipulation"
 )]
-pub fn redact_e2e_output(mut output: String, workspace_root: &str) -> String {
+pub fn redact_e2e_output(
+    mut output: String,
+    workspace_root: &str,
+    step_redactions: &[(regex::Regex, Str)],
+) -> String {
     let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
 
     // On Windows, canonicalize() may produce verbatim paths (\\?\C:\...) while
@@ -124,6 +130,13 @@ pub fn redact_e2e_output(mut output: String, workspace_root: &str) -> String {
     let mise_warning_regex = regex::Regex::new(r"(?m)^mise WARN\s+.*\n?").unwrap();
     output = mise_warning_regex.replace_all(&output, "").into_owned();
 
+    // Apply the step's own `redact` patterns after the global redactions, so
+    // they match the text the snapshot would otherwise show, and before
+    // sorting, so diagnostic blocks they normalize sort the same every run.
+    for (regex, replacement) in step_redactions {
+        output = regex.replace_all(&output, replacement.as_str()).into_owned();
+    }
+
     // Sort consecutive diagnostic blocks to handle non-deterministic tool output
     // (e.g., oxlint reports warnings in arbitrary order due to multi-threading).
     // Each block starts with "  ! " and ends at the next empty line.