vitest.config.ts

import { defineConfig } from 'vitest/config';
import { validationTestReporter } from './scripts/check-affected/test-report.ts';
import { resolveVitestMaxWorkers } from './scripts/lib/vitest-concurrency.ts';
import coverageRunStampReporter from './scripts/vitest-coverage-run-stamp-reporter.ts';
import slowTestGateReporter from './scripts/vitest-slow-test-reporter.ts';

const validationReport = process.env.AGENT_DEVICE_VALIDATION_REPORT;
delete process.env.AGENT_DEVICE_VALIDATION_REPORT;

// A real per-case spawn is timeout noise under thousands of mutant reruns, so the
// mutation lane excludes these tests even though the unit lane runs them normally.
const MUTATION_EXCLUDED_SUBPROCESS_TESTS: readonly string[] = [
  // Stubs npx plus the package managers and spawns a real Metro dev server per case.
  'packages/react-native/src/index-metro.test.ts',
  'src/agent-device-client-metro.test.ts',
  // The SUT is the subprocess watchdog: a node subprocess per case, one hangs on purpose (#1414).
  'scripts/fuzz/harness.test.ts',
  // The daemon takeover test launches a branch-named daemon per case to prove
  // that worktree identity does not strand the predecessor (#1545).
  'packages/daemon-contracts/src/daemon-process-takeover.test.ts',
];

// The fuzz corpus replay, which must not run under V8 coverage instrumentation.
//
// #1824 found two causes behind `Worker exited unexpectedly`. Shape (A) — a test signalling
// a fabricated pid that landed on a sibling fork — was fixed at the source in #1854. Shape
// (B) was left open: one fork dies mid-file, alone, with no test attributed. Scanning every
// failed Coverage job across the 120 CI runs after #1854 merged found the signature five
// times, and the vanished file was this one all five (plus #1866's, so six for six) — 23% of
// Coverage failures in that window. The uninstrumented unit lane has never lost it.
//
// So the coverage run skips this project and a second, uninstrumented Vitest invocation owns
// it — see `test:coverage:ci`. That costs no coverage at all, which is measured rather than
// assumed: the cases execute out of process, which the fork's inspector session never
// instruments, so this file reports the same lines with or without it.
//
// Membership is by demonstrated failure, not by a property of the code. In particular it is
// NOT "constructs a `node:worker_threads` Worker": `session-replay-runtime-maestro-run-script.test.ts`
// does exactly that and stays in `unit-core`, instrumented and green. The proximate cause was
// never reproduced — what these entries share is an observed record of vanishing from the
// Coverage lane, and that record is the only thing that admits a file here. A new entry needs
// its own run URLs; a theory about workers is not enough.
//
// #2053: the split did not stop it — the uninstrumented second leg lost the same file six more
// times in three days. Calibrating each mechanism against this project (see the issue) showed
// that every death Node can report is reported, leaving an uncatchable signal; and the only
// thing this file did that no other file does was run adversarial parser cases inside the fork,
// on worker threads it created and terminated. They now run in a worker process
// (`scripts/fuzz/execute.ts`), where such a fault is a `crash` failure named against its input.
// This entry and the second leg it forces are the mitigation: remove both — file back to
// `unit-core`, `test:coverage:ci` back to one invocation — after 30 consecutive Coverage runs
// with no `Worker exited unexpectedly`, and reopen #2053 with the run URL if one appears first.
const FUZZ_WORKER_TESTS: readonly string[] = [
  // Replays the fuzz corpus through the worker watchdog, waiting its per-case budget (#1414).
  'scripts/fuzz/corpus-replay.test.ts',
];

/**
 * The projects `test:coverage` keeps out of the instrumented invocation, which the stamp reporter has to
 * expect: without it, the lane's own `--project=!fuzz-worker` is indistinguishable from someone narrowing
 * the run, and every coverage pass would stamp itself partial. This config owns the split, so it hands the
 * list to the reporter directly; the guard test compares it against the declared projects below and the
 * `--project=!x` flags in the script, which are the two ways it can go stale.
 */
export const COVERAGE_UNINSTRUMENTED_PROJECTS: readonly string[] = ['fuzz-worker'];
/**
 * Every test the mutation lane must not collect. The two lists above stay
 * module-local: this union is the whole cross-file surface, and the mutation lane
 * wants exactly it.
 */
export const MUTATION_EXCLUDED_TESTS: readonly string[] = [
  ...MUTATION_EXCLUDED_SUBPROCESS_TESTS,
  ...FUZZ_WORKER_TESTS,
];

// Env stubs never outlive the test that made them. Applied to every project below and imported by
// vitest.mutation.config.ts, so no lane can leave it out.
export const TEST_ISOLATION = { unstubEnvs: true } as const;

// Imported by vitest.mutation.config.ts so the two lanes cannot drift: a guard
// added here must reach the Stryker sandbox too.
export const SETUP_FILES = [
  'src/__tests__/hermetic-env-setup.ts',
  'src/__tests__/hermetic-signal-setup.ts',
  'src/__tests__/process-memo-setup.ts',
];

export default defineConfig({
  test: {
    // Redirects TMPDIR to one per-run directory for the whole invocation (all
    // projects, every worker) and removes it once at the end — see the file
    // for why a single global hook beats per-file cleanup here.
    globalSetup: ['scripts/vitest-tmpdir-global-setup.ts'],
    // Wall-clock discipline: unit tests must not wait real time. Measured
    // 2026-07-04: the suite's duration was bounded by files sleeping through
    // production timeout budgets. slowTestThreshold surfaces creep in local
    // output; the slow-test reporter enforces the ratchet (pinned offenders
    // only shrink). Isolation stays ON and pool stays forks: measured
    // --no-isolate = 205s wall vs 48s (module state thrashes across files),
    // threads = no change.
    slowTestThreshold: 500,
    // Four workers gave a worthwhile solo-run speedup without approaching
    // Vitest's 11-worker default on a 12-core host. CI stays uncapped so Vitest
    // derives the runner-appropriate worker count from its available CPU pool.
    maxWorkers: resolveVitestMaxWorkers(),
    // hermetic-env-setup clears worker-scoped device claims after every case.
    // Capping explicit `test.concurrent` work at one enforces that teardown
    // assumption without reducing ordinary file-level parallelism.
    maxConcurrency: 1,
    // Gate reporters for every lane; a `--reporter` flag would replace them, so no lane passes one.
    // The stamp reporter only acts on a lane that ran coverage — see its module.
    reporters: [
      'dot',
      validationTestReporter(
        validationReport ? `${validationReport}.${process.pid}.json` : undefined,
      ),
      slowTestGateReporter(),
      coverageRunStampReporter(COVERAGE_UNINSTRUMENTED_PROJECTS),
    ],
    projects: [
      {
        test: {
          name: 'unit-core',
          // Explicit script entries keep maintained conformance guards in the
          // unit suite without waking every ad-hoc *.test.ts under scripts/.
          include: [
            'src/**/*.test.ts',
            'packages/*/src/**/*.test.ts',
            // The maestro conformance projection is test-tree code beside its harness; its own
            // test stays in the fast lane rather than the node:test conformance script.
            'packages/maestro/test/conformance/conformance-selector-projection.test.ts',
            // The subprocess watchdog self-check: spawns a real node subprocess per case,
            // and one hangs on purpose (#1414).
            'scripts/fuzz/harness.test.ts',
            'scripts/replays/android-manual.test.ts',
            // The validation fuzz generators' expectation gates (#1781 B2): in-process, no
            // subprocess or worker, so they ride the fast lane unlike their serialized siblings.
            'scripts/fuzz/validation-arbitraries.test.ts',
            'scripts/fuzz/validation-arbitraries-cli.test.ts',
            'scripts/fuzz/validation-arbitraries-maestro.test.ts',
            'scripts/fuzz/validation-case.test.ts',
            'scripts/fuzz/envelope.test.ts',
            'scripts/__tests__/vitest-slow-test-reporter.test.ts',
            // Artifact guards assert on Swift sources, package.json, workflows, docs and examples rather
            // than on a module under src.
            'test/repo-guards/*.test.ts',
            'scripts/__tests__/help-conformance-bench.test.ts',
            'scripts/__tests__/help-conformance-error-recovery-coverage.test.ts',
            'scripts/__tests__/help-conformance-expectation-falsification.test.ts',
            'scripts/__tests__/help-conformance-sample-outputs.test.ts',
            'scripts/__tests__/help-conformance-topic-coverage.test.ts',
            'scripts/__tests__/eager-closure-budgets.test.ts',
            'scripts/__tests__/closure-growth-rule.test.ts',
            'scripts/__tests__/agent-setup-startup-contract.test.ts',
            'scripts/__tests__/npm-skills-exclusion.test.ts',
            'scripts/__tests__/simulator-skills-contract.test.ts',
            // Parse Swift guards and declarations before deriving the simulator selection.
            'scripts/__tests__/swift-conditional-compilation.test.ts',
            'scripts/__tests__/xctest-declarations.test.ts',
            'scripts/__tests__/xctest-selection.test.ts',
            'scripts/__tests__/apple-ci-impact.test.ts',
            'scripts/__tests__/device-lane-impact.test.ts',
            // The nightly XCTest lane's reporter/liveness check, which otherwise only ever
            // executes on a macOS runner at 04:30.
            'scripts/__tests__/xctest-run-summary.test.ts',
            // The Fallow fixture policy is executable configuration: unused exports are exempt,
            // but fixture modules remain visible to the other analysis families.
            'scripts/__tests__/fallow-fixture-policy.test.ts',
            // The publishing gate's closure audit against fixture packages: parse-only, and the
            // only place the gate's failure direction is exercised at all (the gate itself needs a
            // real `npm pack`, so CI can only watch a healthy package pass).
            'scripts/__tests__/package-closure-audit.test.ts',
            // The Bundle Size lane's PR-comment path: spawns the real script against a
            // stubbed fetch, so it needs no network; pins retry/reconcile/fatal outcomes.
            'scripts/__tests__/size-report-post-comment.test.ts',
            // Package attribution models npm-pack output. Keep it in the fast lane so every new
            // package path remains accounted for.
            'scripts/__tests__/size-report-package.test.ts',
            // Publish preparation spawns only fixture-owned scripts and proves both Android
            // helper families are rebuilt through the shared release/size-report owner.
            'scripts/__tests__/prepare-publish-assets.test.ts',
            'scripts/__tests__/build-package-xcuitest.test.ts',
            // The packager's Swift comment scanner: pure string transform, and the only place a
            // literal that looks like a comment (a URL, a raw or multi-line literal) is proven
            // to survive packaging before the npm package ships unbuildable Swift.
            'scripts/__tests__/strip-swift-comments.test.ts',
            // The line-parity comparison behind `pnpm check:packaged-runner-swift`. Pure text
            // over two strings; the gate itself is what runs the packager and the Swift parse.
            'scripts/__tests__/packaged-runner-swift.test.ts',
            // The runner build's actor-isolation log scan, over synthetic logs and a fake
            // `xcodebuild` on PATH.
            'scripts/__tests__/runner-isolation-diagnostics.test.ts',
            // Parse-only guard on the checked-in registry entry: the npm package must declare
            // the fixed mcp subcommand, or registry-format launchers run the bare CLI.
            'scripts/__tests__/mcp-metadata.test.ts',
            // Release channel versions: nightly naming, promotion lookup, and main's -dev advance.
            'scripts/__tests__/release-version.test.ts',
            'scripts/__tests__/release-plan.test.ts',
            'scripts/ios-snapshot-benchmark/*.test.ts',
            // The perf suite's pure logic, without a device.
            'scripts/perf/*.test.ts',
            // Parses CI configuration only, so this action guard needs no device or subprocess lane.
            'test/ci/upload-agent-device-artifacts.test.ts',
            'test/ci/upload-artifact-hidden-paths.test.ts',
            // npm trusts release.yml, so its token boundary is asserted on the parsed workflow.
            'test/ci/release-workflow.test.ts',
            // The size reporter is preserved across a base checkout; its entrypoint and imported
            // modules must move as one directory or the Bundle Size lane fails before measuring.
            'test/ci/size-workflow.test.ts',
            // #1781 A9: pins the root-doc paths-ignore entries directly against the
            // real workflow YAML, parse-only like its sibling above.
            'test/ci/root-docs-paths-ignore.test.ts',
            // The daemon leak oracle's lifecycle/residue rules (#1781 B1): pure
            // decisions over fixture state-dir listings, so they need no daemon,
            // device, or subprocess.
            'test/integration/support/daemon-leak-model.test.ts',
            // Cleanup uses real detached registration owners and process-exit proof; no device is needed.
            'test/integration/support/daemon-test-cleanup.test.ts',
            // The Android failed-step evidence reader: it replays adb output through the probe
            // seam, so the crash/process/activity selectors need no emulator to be pinned.
            'test/integration/android-emulator-e2e/device-evidence.test.ts',
            // The frozen replay-compat corpus (#1417): parse-only, no device or
            // subprocess work, so it belongs in the fast lane next to the
            // grammar it guards.
            'test/replay-compat/corpus.test.ts',
            // The daemon RPC wire ledger (#1432): parses source and hashes
            // declarations, so it needs no history, network, or device — the
            // released-tag half runs in its own full-history job.
            'test/wire-compat/wire-compat.test.ts',
            'test/wire-compat/wire-mutations.test.ts',
            // The Maestro conformance oracle runs via `node --test` in its own CI
            // job (scripts/maestro-conformance), like the layering guard.
          ],
          exclude: [...FUZZ_WORKER_TESTS, 'packages/platform-apple/src/runner/**/*.test.ts'],
          setupFiles: SETUP_FILES,
        },
      },
      {
        test: {
          // The apple-runner package's own suites: same lane semantics as
          // unit-core, plus a setup that installs the real root host
          // capabilities behind the package's test-host seam (R11 keeps the
          // package from importing root utilities directly).
          name: 'apple-runner',
          include: ['packages/platform-apple/src/runner/**/*.test.ts'],
          setupFiles: [
            ...SETUP_FILES,
            'scripts/vitest-apple-runner-home-setup.ts',
            'packages/platform-apple/src/runner/__tests__/host-setup.ts',
          ],
        },
      },
      {
        test: {
          // Serialized because the per-case watchdog budget is real wall clock. The project exists so the
          // coverage run can leave it out (see the comment above), not to run it differently.
          name: 'fuzz-worker',
          include: [...FUZZ_WORKER_TESTS],
          setupFiles: SETUP_FILES,
          fileParallelism: false,
          isolate: true,
          maxWorkers: 1,
        },
      },
      {
        test: {
          name: 'provider-integration',
          include: ['test/integration/provider-scenarios/**/*.test.ts'],
          setupFiles: SETUP_FILES,
        },
      },
      {
        test: {
          name: 'interaction-contract',
          include: ['test/integration/interaction-contract/**/*.test.ts'],
          setupFiles: SETUP_FILES,
        },
      },
      {
        test: {
          name: 'output-economy',
          include: ['test/output-economy/**/*.test.ts'],
          setupFiles: SETUP_FILES,
        },
      },
    ].map((project) => ({ ...project, test: { ...project.test, ...TEST_ISOLATION } })),
    coverage: {
      provider: 'v8',
      reporter: [
        'text',
        'html',
        'lcov',
        'json-summary',
        ['json', { file: 'coverage-istanbul.json' }],
      ],
      thresholds: {
        statements: 78,
        lines: 80,
      },
      include: ['src/**/*.ts', 'packages/*/src/**/*.ts'],
      // Vitest 5 matches these against the path relative to the repo root without picomatch's
      // `contains`, so a pattern reaches only the tree its anchor names: `src/**` no longer covers
      // `packages/*/src/**` the way 4.1.11's did. The four that name a kind of file rather than a
      // location are root-free. Written as `src/**` instead, package-side type modules and
      // `__tests__` helpers join the coverage denominator and dilute it with test material.
      exclude: [
        '**/*.test.ts',
        '**/__tests__/**',
        '**/*.fixtures.ts',
        // Test helpers are test material, not product surface: they sat under `__tests__/` roots
        // before @agent-device/test-kit existed and must stay out of the coverage denominator.
        'packages/test-kit/**',
        '**/*-types.ts',
        '**/types.ts',
        'src/sdk/**',
        'src/bin.ts',
        'src/client/client-types.ts',
        'src/core/interactor-types.ts',
        'packages/remote/src/remote-config.ts',
      ],
    },
  },
});