@eduardbar/drift 1.4.0 → 1.5.0

package/src/guard.ts

@@ -1,27 +1,24 @@
-import { existsSync, readFileSync } from 'node:fs'
 import { relative, resolve } from 'node:path'
 import { analyzeProject } from './analyzer.js'
 import { loadConfig } from './config.js'
 import { computeDiff } from './diff.js'
 import { cleanupTempDir, extractFilesAtRef } from './git.js'
+import { normalizeBaseline, readBaselineFromFile } from './guard-baseline.js'
+import { buildMetricsFromBaseline, buildMetricsFromDiff } from './guard-metrics.js'
+import { OUTPUT_SCHEMA, withOutputMetadata } from './output-metadata.js'
 import { buildReport } from './reporter.js'
-import type { DriftDiff, DriftReport } from './types.js'
+import type { DriftReport } from './types.js'
 import type {
-  GuardBaseline,
   GuardCheck,
   GuardEvaluation,
   GuardMetrics,
   GuardOptions,
   GuardResult,
+  GuardResultJson,
   GuardThresholds,
   IssueSeverity,
 } from './guard-types.js'
-
-interface NormalizedBaseline {
-  score?: number
-  totalIssues?: number
-  bySeverity: Partial<Record<IssueSeverity, number>>
-}
+import type { NormalizedBaseline } from './guard-baseline.js'
 
 interface GuardEvalInput {
   metrics: GuardMetrics
@@ -56,49 +53,6 @@ interface BaselineGuardResultInput {
   baselinePath?: string
 }
 
-function parseNumber(value: unknown): number | undefined {
-  return typeof value === 'number' && !Number.isNaN(value) ? value : undefined
-}
-
-function normalizeBaseline(baseline: GuardBaseline): NormalizedBaseline {
-  const bySeverityFromRoot = baseline.bySeverity
-  const bySeverity = {
-    error: parseNumber(bySeverityFromRoot?.error) ?? parseNumber(baseline.errors) ?? parseNumber(baseline.summary?.errors),
-    warning: parseNumber(bySeverityFromRoot?.warning) ?? parseNumber(baseline.warnings) ?? parseNumber(baseline.summary?.warnings),
-    info: parseNumber(bySeverityFromRoot?.info) ?? parseNumber(baseline.infos) ?? parseNumber(baseline.summary?.infos),
-  }
-
-  const normalized: NormalizedBaseline = {
-    score: parseNumber(baseline.score),
-    totalIssues: parseNumber(baseline.totalIssues),
-    bySeverity,
-  }
-
-  const hasAnyAnchor =
-    normalized.score !== undefined ||
-    normalized.totalIssues !== undefined ||
-    normalized.bySeverity.error !== undefined ||
-    normalized.bySeverity.warning !== undefined ||
-    normalized.bySeverity.info !== undefined
-
-  if (!hasAnyAnchor) {
-    throw new Error('Invalid guard baseline: expected score, totalIssues, or severity counters (error/warning/info).')
-  }
-
-  return normalized
-}
-
-function readBaselineFromFile(projectPath: string, baselinePath?: string): { baseline: NormalizedBaseline; path: string } | undefined {
-  const resolvedBaselinePath = resolve(projectPath, baselinePath ?? 'drift-baseline.json')
-  if (!existsSync(resolvedBaselinePath)) return undefined
-
-  const raw = JSON.parse(readFileSync(resolvedBaselinePath, 'utf8')) as GuardBaseline
-  return {
-    baseline: normalizeBaseline(raw),
-    path: resolvedBaselinePath,
-  }
-}
-
 function remapBaseReportPaths(baseReport: DriftReport, tempDir: string, projectPath: string): DriftReport {
   return {
     ...baseReport,
@@ -109,44 +63,6 @@ function remapBaseReportPaths(baseReport: DriftReport, tempDir: string, projectP
   }
 }
 
-function countSeverityDeltaFromDiff(diff: DriftDiff): Record<IssueSeverity, number> {
-  const severityDelta: Record<IssueSeverity, number> = {
-    error: 0,
-    warning: 0,
-    info: 0,
-  }
-
-  for (const file of diff.files) {
-    for (const issue of file.newIssues) {
-      severityDelta[issue.severity] += 1
-    }
-    for (const issue of file.resolvedIssues) {
-      severityDelta[issue.severity] -= 1
-    }
-  }
-
-  return severityDelta
-}
-
-function buildMetricsFromDiff(diff: DriftDiff): GuardMetrics {
-  return {
-    scoreDelta: diff.totalDelta,
-    totalIssuesDelta: diff.newIssuesCount - diff.resolvedIssuesCount,
-    severityDelta: countSeverityDeltaFromDiff(diff),
-  }
-}
-
-function buildMetricsFromBaseline(current: DriftReport, baseline: NormalizedBaseline): GuardMetrics {
-  return {
-    scoreDelta: current.totalScore - (baseline.score ?? current.totalScore),
-    totalIssuesDelta: current.totalIssues - (baseline.totalIssues ?? current.totalIssues),
-    severityDelta: {
-      error: current.summary.errors - (baseline.bySeverity.error ?? current.summary.errors),
-      warning: current.summary.warnings - (baseline.bySeverity.warning ?? current.summary.warnings),
-      info: current.summary.infos - (baseline.bySeverity.info ?? current.summary.infos),
-    },
-  }
-}
 
 interface GuardCheckInput {
   id: string
@@ -216,6 +132,14 @@ export function evaluateGuard(input: GuardEvalInput): GuardEvaluation {
   }
 }
 
+export function formatGuardJsonObject(result: GuardResult): GuardResultJson {
+  return withOutputMetadata(result, OUTPUT_SCHEMA.guard)
+}
+
+export function formatGuardJson(result: GuardResult): string {
+  return JSON.stringify(formatGuardJsonObject(result), null, 2)
+}
+
 export async function runGuard(targetPath: string, options: GuardOptions = {}): Promise<GuardResult> {
   const runtimeState = await initializeGuardRuntime(targetPath, options)
   const { projectPath, config, currentReport } = runtimeState

package/src/index.ts

@@ -18,6 +18,7 @@ export {
   buildTrustReport,
   formatTrustConsole,
   formatTrustMarkdown,
+  formatTrustJsonObject,
   formatTrustJson,
   resolveTrustGatePolicy,
   evaluateTrustGate,

package/src/init.ts

@@ -142,7 +142,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
 
       - name: Install drift
         run: npm install -g @eduardbar/drift

package/src/output-metadata.ts

@@ -9,6 +9,8 @@ export const OUTPUT_SCHEMA = {
   report: 'schemas/drift-report.v1.json',
   trust: 'schemas/drift-trust.v1.json',
   ai: 'schemas/drift-ai-output.v1.json',
+  doctor: 'schemas/drift-doctor.v1.json',
+  guard: 'schemas/drift-guard.v1.json',
 } as const
 
 type OutputMetadata = {

package/src/trust.ts

@@ -193,7 +193,7 @@ export function formatTrustMarkdown(trust: DriftTrustReport): string {
   return sections.join('\n')
 }
 
-function formatTrustJsonObject(trust: DriftTrustReport): DriftTrustReportJson {
+export function formatTrustJsonObject(trust: DriftTrustReport): DriftTrustReportJson {
   return withOutputMetadata(trust, OUTPUT_SCHEMA.trust)
 }
 

package/src/types.ts

@@ -67,6 +67,7 @@ export type {
   GuardCheck,
   GuardEvaluation,
   GuardResult,
+  GuardResultJson,
 } from './guard-types.js'
 
 export type {

package/tests/ci-quality-matrix.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const repoRoot = process.cwd()
+
+function readRepoFile(path: string): string {
+  return readFileSync(join(repoRoot, path), 'utf8')
+}
+
+describe('CI quality matrix contract', () => {
+  it('requires Node 20/22 in reusable and entry workflows', () => {
+    const reusable = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+    const quality = readRepoFile('.github/workflows/quality.yml')
+
+    expect(reusable).toContain("default: '[\"20\", \"22\"]'")
+    expect(quality).toContain("node_versions: '[\"20\", \"22\"]'")
+    expect(quality).toContain('pull_request:')
+    expect(quality).toContain('branches: [main, master]')
+    expect(quality).toContain('uses: ./.github/workflows/reusable-quality-checks.yml')
+  })
+
+  it('includes required quality commands in reusable checks', () => {
+    const reusable = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+
+    expect(reusable).toContain('run: npm ci')
+    expect(reusable).toContain('run: npm run check:runtime-policy')
+    expect(reusable).toContain('run: npm run check:docs-drift')
+    expect(reusable).toContain("if: matrix.node == '20'")
+    expect(reusable).toContain('run: npm run check:perf-budget -- --out .drift-perf/ci-node-${{ matrix.node }}/benchmark-latest.json')
+    expect(reusable).toContain('run: npm test')
+    expect(reusable).toContain('run: npm run test:coverage')
+    expect(reusable).toContain('run: npm run build')
+    expect(reusable).toContain('name: Upload perf gate artifacts')
+    expect(reusable).toContain('path: .drift-perf/ci-node-${{ matrix.node }}/')
+  })
+})

package/tests/ci-smoke-gate.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const repoRoot = process.cwd()
+
+function readRepoFile(path: string): string {
+  return readFileSync(join(repoRoot, path), 'utf8')
+}
+
+describe('CI smoke E2E gate', () => {
+  it('runs smoke:repo in reusable quality checks', () => {
+    const workflow = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+
+    expect(workflow).toContain('name: Run CLI smoke E2E')
+    expect(workflow).toContain('run: npm run smoke:repo -- --base HEAD --out .drift-smoke/ci-node-${{ matrix.node }}')
+  })
+
+  it('uploads smoke artifacts even when smoke fails', () => {
+    const workflow = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+
+    expect(workflow).toContain('name: Upload smoke E2E artifacts')
+    expect(workflow).toContain('if: always()')
+    expect(workflow).toContain('path: .drift-smoke/ci-node-${{ matrix.node }}/')
+  })
+})

package/tests/ci-version-alignment.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const repoRoot = process.cwd()
+
+function readRepoFile(path: string): string {
+  return readFileSync(join(repoRoot, path), 'utf8')
+}
+
+function getPackageVersion(): string {
+  const pkg = JSON.parse(readRepoFile('package.json')) as { version?: unknown }
+  if (typeof pkg.version !== 'string' || pkg.version.length === 0) {
+    throw new Error('package.json is missing a valid version field')
+  }
+  return pkg.version
+}
+
+function extractVersionDefaultFromAction(content: string): string | undefined {
+  const lines = content.split(/\r?\n/)
+  const versionLine = lines.findIndex((line) => line.trim() === 'version:')
+  if (versionLine === -1) {
+    return undefined
+  }
+
+  for (let index = versionLine + 1; index < lines.length; index += 1) {
+    const trimmed = lines[index].trim()
+    if (trimmed.endsWith(':') && !trimmed.startsWith('default:')) {
+      break
+    }
+    const match = trimmed.match(/^default:\s*['"](\d+\.\d+\.\d+)['"]$/)
+    if (match) {
+      return match[1]
+    }
+  }
+
+  return undefined
+}
+
+describe('CI drift version alignment', () => {
+  it('keeps action version defaults aligned with package version', () => {
+    const packageVersion = getPackageVersion()
+    const actionFiles = ['.github/actions/drift-scan/action.yml', '.github/actions/drift-review/action.yml']
+
+    for (const actionFile of actionFiles) {
+      const content = readRepoFile(actionFile)
+      const actionVersion = extractVersionDefaultFromAction(content)
+      expect(actionVersion, `${actionFile} version default must match package.json`).toBe(packageVersion)
+    }
+  })
+
+  it('keeps documented action versions aligned with package version', () => {
+    const packageVersion = getPackageVersion()
+    const docs = ['.github/actions/drift-scan/README.md', '.github/actions/drift-review/README.md']
+    const versionRegex = /\b(\d+\.\d+\.\d+)\b/g
+
+    for (const doc of docs) {
+      const content = readRepoFile(doc)
+      const versions = Array.from(content.matchAll(versionRegex), (match) => match[1])
+
+      expect(versions.length, `${doc} should include at least one semver literal`).toBeGreaterThan(0)
+      expect(new Set(versions), `${doc} semver literals must match package.json`).toEqual(new Set([packageVersion]))
+    }
+  })
+
+  it('rejects hardcoded drift package semvers that diverge in CI yaml files', () => {
+    const packageVersion = getPackageVersion()
+    const yamlFiles = [
+      '.github/actions/drift-scan/action.yml',
+      '.github/actions/drift-review/action.yml',
+      '.github/workflows/quality.yml',
+      '.github/workflows/reusable-quality-checks.yml',
+      '.github/workflows/review-pr.yml',
+      '.github/workflows/publish.yml',
+      '.github/workflows/publish-vscode.yml',
+    ]
+
+    const mismatches: string[] = []
+    const packageRefRegex = /@eduardbar\/drift@(\d+\.\d+\.\d+)/g
+
+    for (const yamlFile of yamlFiles) {
+      const content = readRepoFile(yamlFile)
+      for (const match of content.matchAll(packageRefRegex)) {
+        const version = match[1]
+        if (version !== packageVersion) {
+          mismatches.push(`${yamlFile}: ${version}`)
+        }
+      }
+    }
+
+    expect(mismatches).toEqual([])
+  })
+})

package/tests/docs-drift-check.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const repoRoot = process.cwd()
+const checkScriptPath = join(repoRoot, 'scripts/check-docs-drift.mjs')
+const tempDirs: string[] = []
+
+function runCheck(cwd: string) {
+  return spawnSync(process.execPath, [checkScriptPath], {
+    cwd,
+    encoding: 'utf8',
+  })
+}
+
+function writeFixtureFile(root: string, relativePath: string, content: string) {
+  const filePath = join(root, relativePath)
+  const directory = dirname(filePath)
+  mkdirSync(directory, { recursive: true })
+  writeFileSync(filePath, content, 'utf8')
+}
+
+function createFixture(options?: { agentsVersion?: string; catalogMissingRule?: boolean; readmeCount?: number }) {
+  const fixtureRoot = mkdtempSync(join(tmpdir(), 'drift-docs-check-'))
+  tempDirs.push(fixtureRoot)
+
+  const agentsVersion = options?.agentsVersion ?? '1.4.0'
+  const catalogMissingRule = options?.catalogMissingRule ?? false
+  const readmeCount = options?.readmeCount ?? 2
+
+  writeFixtureFile(fixtureRoot, 'package.json', JSON.stringify({ version: '1.4.0' }, null, 2))
+  writeFixtureFile(
+    fixtureRoot,
+    'src/analyzer.ts',
+    `export const RULE_WEIGHTS = {\n  'large-file': { severity: 'error', weight: 20 },\n  'dead-code': { severity: 'warning', weight: 8 },\n}\n`,
+  )
+
+  const catalogTableRows = catalogMissingRule
+    ? "| `large-file` | error | 20 | phase0-basic | sample |"
+    : [
+      '| `large-file` | error | 20 | phase0-basic | sample |',
+      '| `dead-code` | warning | 8 | phase0-basic | sample |',
+    ].join('\n')
+
+  const catalogTotal = catalogMissingRule ? 1 : 2
+  writeFixtureFile(
+    fixtureRoot,
+    'docs/rules-catalog.md',
+    [
+      '# drift rules catalog (current)',
+      '',
+      'Source of truth: `RULE_WEIGHTS` in `src/analyzer.ts`.',
+      '',
+      '| id | severity | weight | phase/origin | note |',
+      '|---|---|---:|---|---|',
+      catalogTableRows,
+      '',
+      `- Total rule IDs currently defined: **${catalogTotal}**.`,
+      '',
+    ].join('\n'),
+  )
+
+  writeFixtureFile(fixtureRoot, 'README.md', `drift currently defines **${readmeCount} rule IDs** in RULE_WEIGHTS.`)
+  writeFixtureFile(
+    fixtureRoot,
+    'AGENTS.md',
+    [
+      '# AGENTS.md — drift',
+      `- Versión del paquete: \`${agentsVersion}\` (\`package.json\`)`,
+      '- Estado actual: **2 rule IDs** (sample).',
+      '',
+    ].join('\n'),
+  )
+
+  return fixtureRoot
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop()
+    if (!dir) continue
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('docs drift checker', () => {
+  it('passes against the real repository contract', () => {
+    const result = runCheck(repoRoot)
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Docs drift check passed')
+    expect(result.stderr).toBe('')
+  })
+
+  it('fails when AGENTS package version diverges from package.json', () => {
+    const fixtureRoot = createFixture({ agentsVersion: '9.9.9' })
+
+    const result = runCheck(fixtureRoot)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Docs drift check failed:')
+    expect(result.stderr).toContain('AGENTS.md package version (9.9.9) does not match package.json (1.4.0)')
+  })
+
+  it('fails when catalog rule IDs diverge from RULE_WEIGHTS', () => {
+    const fixtureRoot = createFixture({ catalogMissingRule: true, readmeCount: 1 })
+
+    const result = runCheck(fixtureRoot)
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('rules missing in docs/rules-catalog.md: dead-code')
+    expect(result.stderr).toContain('README.md rule ID count (1) does not match RULE_WEIGHTS (2)')
+  })
+})

package/tests/new-features.test.ts

@@ -118,7 +118,7 @@ describe('new feature MVP', () => {
     expect(rules).toContain('controller-no-db')
     expect(rules).toContain('service-no-http')
     expect(rules).toContain('max-function-lines')
-  })
+  }, 15000)
 
   it('generates architecture SVG map', () => {
     tmpDir = mkdtempSync(join(tmpdir(), 'drift-map-'))
@@ -199,7 +199,7 @@ describe('new feature MVP', () => {
 
     expect(fullRules.has('circular-dependency')).toBe(true)
     expect(lowMemoryRules.has('circular-dependency')).toBe(true)
-  }, 15000)
+  }, 30000)
 
   it('adds diagnostics when max file size guardrail skips files', () => {
     tmpDir = mkdtempSync(join(tmpdir(), 'drift-max-file-size-'))

package/tests/perf-budget-check.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const repoRoot = process.cwd()
+const checkScriptPath = join(repoRoot, 'scripts/check-performance-budget.mjs')
+const tempDirs: string[] = []
+
+function runCheck(cwd: string, args: string[]) {
+  return spawnSync(process.execPath, [checkScriptPath, ...args], {
+    cwd,
+    encoding: 'utf8',
+  })
+}
+
+function writeFixtureFile(root: string, relativePath: string, content: string) {
+  const filePath = join(root, relativePath)
+  mkdirSync(dirname(filePath), { recursive: true })
+  writeFileSync(filePath, content, 'utf8')
+}
+
+function createFixture(options?: {
+  schemaVersion?: string
+  scanMedianMs?: number
+  reviewMedianMs?: number
+  trustMedianMs?: number
+  measuredRuns?: number
+  includeTrustResult?: boolean
+}) {
+  const fixtureRoot = mkdtempSync(join(tmpdir(), 'drift-perf-check-'))
+  tempDirs.push(fixtureRoot)
+
+  const budget = {
+    schemaVersion: options?.schemaVersion ?? 'drift-perf-budget/v1',
+    budgetVersion: 'test-budget',
+    benchmark: {
+      scanPath: 'benchmarks/fixtures/critical',
+      reviewPath: 'benchmarks/fixtures/critical',
+      trustPath: 'benchmarks/fixtures/critical',
+      baseRef: 'HEAD',
+      warmupRuns: 1,
+      measuredRuns: options?.measuredRuns ?? 5,
+    },
+    tolerance: {
+      runtimePct: 10,
+      memoryPct: 10,
+    },
+    tasks: {
+      scan: { maxMedianMs: 1000, maxRssMb: 400 },
+      review: { maxMedianMs: 1200, maxRssMb: 450 },
+      trust: { maxMedianMs: 1400, maxRssMb: 500 },
+    },
+  }
+
+  const benchmarkResult = {
+    meta: {
+      scannedAt: new Date().toISOString(),
+      node: process.version,
+      platform: process.platform,
+      cwd: fixtureRoot,
+    },
+    options: budget.benchmark,
+    results: [
+      {
+        name: 'scan',
+        medianMs: options?.scanMedianMs ?? 800,
+        maxRssMb: 320,
+      },
+      {
+        name: 'review',
+        medianMs: options?.reviewMedianMs ?? 900,
+        maxRssMb: 360,
+      },
+      ...(options?.includeTrustResult === false
+        ? []
+        : [{
+          name: 'trust',
+          medianMs: options?.trustMedianMs ?? 1100,
+          maxRssMb: 390,
+        }]),
+    ],
+  }
+
+  writeFixtureFile(fixtureRoot, 'benchmarks/perf-budget.v1.json', `${JSON.stringify(budget, null, 2)}\n`)
+  writeFixtureFile(fixtureRoot, '.drift-perf/benchmark-sample.json', `${JSON.stringify(benchmarkResult, null, 2)}\n`)
+
+  return fixtureRoot
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop()
+    if (!dir) continue
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('performance budget checker', () => {
+  it('passes when benchmark result stays within budget and tolerance', () => {
+    const fixtureRoot = createFixture()
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Performance budget check passed.')
+  })
+
+  it('fails when runtime budget is exceeded', () => {
+    const fixtureRoot = createFixture({ scanMedianMs: 1300 })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Performance budget check failed:')
+    expect(result.stderr).toContain('scan: median runtime')
+  })
+
+  it('fails when budget schema version is invalid', () => {
+    const fixtureRoot = createFixture({ schemaVersion: 'drift-perf-budget/v0' })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('Unsupported budget schemaVersion')
+  })
+
+  it('fails when benchmark output does not include all required tasks', () => {
+    const fixtureRoot = createFixture({ includeTrustResult: false })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain("Benchmark output is missing task 'trust'")
+  })
+
+  it('fails when benchmark measuredRuns is invalid', () => {
+    const fixtureRoot = createFixture({ measuredRuns: 0 })
+
+    const result = runCheck(fixtureRoot, ['--result', '.drift-perf/benchmark-sample.json'])
+
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('benchmark.measuredRuns must be at least 1')
+  })
+})