test(e2e): add IPC client e2e tests for every method

New fixture `ipc_client_test` exercises each IPC method through the JS
wrapper (@voidzero-dev/vite-task-client) inside a real cached task:

- ignoreInput → the ignored dir can mutate without invalidating cache
- ignoreOutput → read-write overlap under an ignored dir still caches
- disableCache → forces re-execution on next run
- fetchEnv(tracked: true) → env change invalidates cache; same value hits

The e2e harness now copies packages/vite-task-client into each staging
node_modules so fixtures can `import { ... } from "@voidzero-dev/vite-task-client"`
without pnpm install.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: wan9chi

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "ipc-client-test",
+  "private": true,
+  "type": "module"
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/disable_cache.mjs

@@ -0,0 +1,8 @@
+import { disableCache } from "@voidzero-dev/vite-task-client";
+import { writeFileSync, mkdirSync } from "node:fs";
+
+// Produce an output, then ask the runner not to cache this execution — the
+// next `vt run` should re-execute the task.
+mkdirSync("dist", { recursive: true });
+writeFileSync("dist/out.txt", "ok\n");
+disableCache();

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/fetch_env.mjs

@@ -0,0 +1,11 @@
+import { fetchEnv } from "@voidzero-dev/vite-task-client";
+import { writeFileSync, mkdirSync } from "node:fs";
+
+// fetchEnv populates process.env from the runner and — with tracked: true —
+// adds the env to the post-run fingerprint, so a change between runs
+// invalidates the cache.
+fetchEnv("PROBE_ENV", { tracked: true });
+const value = process.env.PROBE_ENV ?? "(unset)";
+
+mkdirSync("dist", { recursive: true });
+writeFileSync("dist/out.txt", "PROBE_ENV=" + value + "\n");

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/ignore_input.mjs

@@ -0,0 +1,15 @@
+import { ignoreInput } from "@voidzero-dev/vite-task-client";
+import { writeFileSync, readFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
+
+// The task reads from `cache_like/` (which we want the runner to IGNORE as
+// an input), and writes to `dist/`. Without the ignore, the auto-input
+// fingerprint would fluctuate with cache_like/ contents even though they're
+// not semantic inputs.
+mkdirSync("cache_like", { recursive: true });
+writeFileSync("cache_like/stale.txt", "stale-" + Date.now() + "\n");
+ignoreInput("cache_like");
+readFileSync("cache_like/stale.txt", "utf8");
+
+mkdirSync("dist", { recursive: true });
+writeFileSync("dist/out.txt", "ok\n");

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/ignore_output.mjs

@@ -0,0 +1,14 @@
+import { ignoreOutput } from "@voidzero-dev/vite-task-client";
+import { writeFileSync, readFileSync, mkdirSync } from "node:fs";
+
+// The task both reads and writes `sidecar/tmp.txt`. If the runner didn't
+// treat `sidecar/` as an ignored output, the read-write overlap check would
+// refuse to cache the task. `dist/out.txt` is the real output.
+mkdirSync("sidecar", { recursive: true });
+writeFileSync("sidecar/tmp.txt", "initial\n");
+readFileSync("sidecar/tmp.txt", "utf8");
+writeFileSync("sidecar/tmp.txt", "final\n");
+ignoreOutput("sidecar");
+
+mkdirSync("dist", { recursive: true });
+writeFileSync("dist/out.txt", "ok\n");

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots.toml

@@ -0,0 +1,56 @@
+# E2E tests for @voidzero-dev/vite-task-client. Each case exercises one IPC
+# method by running a Node script inside a real cached task and observing the
+# runner's cache behaviour.
+
+# ignoreInput: the runner treats cache_like/ as non-input, so mutations to it
+# between runs do not invalidate the cache.
+[[e2e]]
+name = "ignore_input_keeps_cache_valid"
+ignore = true
+steps = [
+  # First run populates the cache.
+  ["vt", "run", "ignore-input"],
+  # Mutate the ignored directory between runs; this would invalidate the cache
+  # if the runner had tracked it as an input.
+  ["vtt", "write-file", "cache_like/other.txt", "after"],
+  # Second run must still be a cache hit.
+  { argv = ["vt", "run", "ignore-input"], comment = "cache hit: cache_like/ was ignored via ignoreInput" },
+]
+
+# ignoreOutput: the task reads and writes sidecar/tmp.txt. If the runner
+# didn't honour ignoreOutput, the read-write overlap check would refuse to
+# cache the run ("read and wrote 'sidecar/tmp.txt'").
+[[e2e]]
+name = "ignore_output_allows_read_write_overlap"
+ignore = true
+steps = [
+  ["vt", "run", "ignore-output"],
+  ["vtt", "rm", "dist/out.txt"],
+  # Cache hit proves ignoreOutput suppressed the overlap error.
+  { argv = ["vt", "run", "ignore-output"], comment = "cache hit: sidecar/ writes were ignored" },
+  ["vtt", "print-file", "dist/out.txt"],
+]
+
+# disableCache: the tool asks the runner not to cache this run, so the next
+# invocation re-executes.
+[[e2e]]
+name = "disable_cache_forces_reexecution"
+ignore = true
+steps = [
+  ["vt", "run", "disable-cache"],
+  # Second run is a cache miss (NotFound) because nothing was cached.
+  { argv = ["vt", "run", "disable-cache"], comment = "cache miss: tool called disableCache" },
+]
+
+# fetchEnv (tracked: true) — the env value becomes part of the post-run
+# fingerprint. Same value → cache hit; different value → cache miss.
+[[e2e]]
+name = "fetch_env_tracked_invalidates_on_change"
+ignore = true
+steps = [
+  { argv = ["vt", "run", "fetch-env"], envs = [["PROBE_ENV", "first"]] },
+  # Same value → cache hit.
+  { argv = ["vt", "run", "fetch-env"], envs = [["PROBE_ENV", "first"]], comment = "cache hit: PROBE_ENV unchanged" },
+  # Different value → cache miss (tracked env changed).
+  { argv = ["vt", "run", "fetch-env"], envs = [["PROBE_ENV", "second"]], comment = "cache miss: tracked env changed" },
+]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/disable_cache_forces_reexecution.md

@@ -0,0 +1,15 @@
+# disable_cache_forces_reexecution
+
+## `vt run disable-cache`
+
+```
+$ node scripts/disable_cache.mjs
+```
+
+## `vt run disable-cache`
+
+cache miss: tool called disableCache
+
+```
+$ node scripts/disable_cache.mjs
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/fetch_env_tracked_invalidates_on_change.md

@@ -0,0 +1,26 @@
+# fetch_env_tracked_invalidates_on_change
+
+## `PROBE_ENV=first vt run fetch-env`
+
+```
+$ node scripts/fetch_env.mjs
+```
+
+## `PROBE_ENV=first vt run fetch-env`
+
+cache hit: PROBE_ENV unchanged
+
+```
+$ node scripts/fetch_env.mjs ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```
+
+## `PROBE_ENV=second vt run fetch-env`
+
+cache miss: tracked env changed
+
+```
+$ node scripts/fetch_env.mjs ○ cache miss: tracked env 'PROBE_ENV' changed, executing
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/ignore_input_keeps_cache_valid.md

@@ -0,0 +1,23 @@
+# ignore_input_keeps_cache_valid
+
+## `vt run ignore-input`
+
+```
+$ node scripts/ignore_input.mjs
+```
+
+## `vtt write-file cache_like/other.txt after`
+
+```
+```
+
+## `vt run ignore-input`
+
+cache hit: cache_like/ was ignored via ignoreInput
+
+```
+$ node scripts/ignore_input.mjs ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/ignore_output_allows_read_write_overlap.md

@@ -0,0 +1,29 @@
+# ignore_output_allows_read_write_overlap
+
+## `vt run ignore-output`
+
+```
+$ node scripts/ignore_output.mjs
+```
+
+## `vtt rm dist/out.txt`
+
+```
+```
+
+## `vt run ignore-output`
+
+cache hit: sidecar/ writes were ignored
+
+```
+$ node scripts/ignore_output.mjs ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```
+
+## `vtt print-file dist/out.txt`
+
+```
+ok
+```