@smthrs/evals 0.0.0-stage → 1.0.0-rc.4

package/docs/installation.md

@@ -0,0 +1,46 @@
+---
+title: "Installation"
+description: "Add @smthrs/evals to a workspace package, plus its runtime requirements and entry points."
+---
+
+The package is at 1.0.0-rc.0 and is not on the npm registry yet. It is a
+workspace package of https://github.com/smithersai/smithers, so use it from a
+package in a clone of that repository:
+
+```bash
+git clone https://github.com/smithersai/smithers
+cd smithers
+pnpm install
+```
+
+Then depend on it through the workspace protocol in your package's
+`package.json` and run `pnpm install` again:
+
+```json
+{
+  "dependencies": {
+    "@smthrs/evals": "workspace:*"
+  }
+}
+```
+
+## Runtime requirements
+
+- Node.js 26.4.0 or later, from the package's `engines` field.
+- `effect` 4.0.0-rc.115. Suites, runs, baselines, and gates are all `Effect`
+  values, so every program composes with the `effect` library directly.
+- `@smthrs/core` supplies `Flow` values. `@smthrs/scorers` supplies scorers,
+  bindings, and the pure `@smthrs/scorers/ScoreGate` grading contract, including
+  `ScoreGateError`. The evaluation runtime does not load `@smthrs/testing`;
+  that package supplies a test facade for development consumers. To run the
+  agent behind a case, add [@smthrs/agent](/api/agent) as well.
+
+## Entry points
+
+- `@smthrs/evals` exports the nine namespaces: `EvalError`, `Suite`,
+  `CaseExecutor`, `Runner`, `Baseline`, `Regression`, `Report`, `Gate`, and
+  `Trials`.
+- `@smthrs/evals/<Module>` imports one namespace directly, for example
+  `@smthrs/evals/Suite`.
+- `@smthrs/evals/package.json` is exported. The `internal/*` modules and
+  nested `*/index` subpaths are not public.

package/docs/quickstart.md

@@ -0,0 +1,238 @@
+---
+title: "Quickstart"
+description: "Declare a fixed suite, run it, record a baseline, and gate the next run against it."
+---
+
+This tutorial walks one complete evaluation loop. You declare a suite for a
+greeting flow, run it, record the scores as a baseline, and gate a later run
+against that baseline. By the end you have a script that exits 0 while the
+flow behaves and 1 when a score drops.
+
+You need a workspace package with `@smthrs/evals` installed. For setup, see
+[Installation](./installation.md).
+
+## 1. Declare a target and a scorer
+
+A target is the flow the suite exercises. A scorer grades one execution and
+returns a number in [0, 1]. Both come from packages the pipeline composes:
+`Flow` from [@smthrs/core](/api/core) and `Scorer` from
+[@smthrs/scorers](/api/scorers).
+
+```ts
+import { Scorer } from "@smthrs/scorers"
+import { Effect } from "effect"
+
+const greet = { name: "greet" }
+
+const polite = Scorer.make({
+  id: "quickstart/polite",
+  version: "1",
+  name: "polite",
+  score: ({ output }) => Effect.succeed({ score: String(output).startsWith("Hello") ? 1 : 0 })
+})
+```
+
+## 2. Declare the suite
+
+A suite is the fixed half of the evaluation: named cases, the scorer bindings
+that grade them, and the concurrency the runner is allowed. `Suite.make`
+validates the declaration and snapshots it, so the suite cannot change after
+validation.
+
+```ts
+import { Suite } from "@smthrs/evals"
+import { Binding } from "@smthrs/scorers"
+
+Effect.gen(function*() {
+  const suite = yield* Suite.make({
+    name: "greetings",
+    cases: [
+      { name: "ada", input: { name: "Ada" }, expected: "Hello, Ada" },
+      { name: "grace", input: { name: "Grace" }, expected: "Hello, Grace" }
+    ],
+    bindings: [Binding.make({ scorer: polite, appliesTo: greet })],
+    concurrency: 2
+  })
+})
+```
+
+`Binding.make` attaches the `polite` scorer to the `greet` flow. The match is
+by reference identity: only an execution that reports the `greet` value itself
+as its target is graded by this binding.
+
+## 3. Execute cases through an injected boundary
+
+The `CaseExecutor` service says how one case runs against the target. Each
+execution reports its output, a step key identifying the work, a latency, and
+the target flow value itself.
+
+```ts
+import { CaseExecutor } from "@smthrs/evals"
+
+const executor = CaseExecutor.make((suiteCase) =>
+  Effect.succeed({
+    output: `Hello, ${(suiteCase.input as { readonly name: string }).name}`,
+    stepKey: suiteCase.name,
+    latencyMs: 0,
+    target: greet
+  })
+)
+```
+
+Keep the step key fixed per case. The comparison reads a changed key as
+different work and a moved score under an unchanged key as nondeterminism, and
+both readings need the key stated, not derived from the run. For the full
+rule, see [Step keys and comparison](./concepts/step-keys.md).
+
+## 4. Run the suite
+
+`Runner.run` executes the cases at the suite's concurrency and scores every
+execution whose target matches a binding. It takes `runId` and `at` from you,
+so a re-run over the same inputs produces identical observations.
+
+```ts
+import { Runner } from "@smthrs/evals"
+
+Effect.gen(function*() {
+  const run = yield* Runner.run(suite, {
+    runId: "quickstart-1",
+    at: "2026-01-01T00:00:00.000Z"
+  })
+})
+```
+
+The `at` value must be a canonical UTC timestamp with millisecond precision,
+such as `2026-01-01T00:00:00.000Z`. `new Date().toISOString()` satisfies the
+format.
+
+## 5. Record the baseline
+
+`Baseline.fromRun` keeps the run's successful scores, and `Baseline.write`
+serializes them as canonical JSON to commit beside the suite.
+
+```ts
+import { Baseline, EvalError } from "@smthrs/evals"
+import { writeFile } from "node:fs/promises"
+
+Effect.gen(function*() {
+  const failures = run.cases.filter((result) => result.error !== undefined)
+  if (failures.length > 0) {
+    return yield* Effect.fail(
+      new EvalError.EvalError({
+        code: "executor",
+        message: `Refusing to record a baseline: ${failures.length} case(s) did not finish`
+      })
+    )
+  }
+  const baseline = yield* Baseline.fromRun(run)
+  yield* Effect.promise(() => writeFile("baseline.json", Baseline.write(baseline)))
+})
+```
+
+Inconclusive observations are dropped: a baseline records what was measured,
+and an inconclusive observation measured nothing.
+
+## 6. Gate the next run against the baseline
+
+On the next run, load the committed artifact, compare it against the run,
+render the report, and grade the comparison.
+
+```ts
+import { Gate, Regression, Report } from "@smthrs/evals"
+import { readFile } from "node:fs/promises"
+
+Effect.gen(function*() {
+  const committed = yield* Baseline.load(
+    yield* Effect.promise(() => readFile("baseline.json", "utf8"))
+  )
+  const comparison = yield* Regression.compare(committed, run)
+  yield* Effect.sync(() => process.stdout.write(Report.markdown(comparison)))
+  const verdict = yield* Gate.check(comparison, { mean: 1 })
+  const grade = Gate.ciGrade(verdict)
+})
+```
+
+## 7. Put it together
+
+The complete script, `quickstart.ts`:
+
+```ts
+import { Baseline, CaseExecutor, EvalError, Gate, Regression, Report, Runner, Suite } from "@smthrs/evals"
+import { Binding, Scorer } from "@smthrs/scorers"
+import { Effect, Layer } from "effect"
+import { readFile, writeFile } from "node:fs/promises"
+
+const greet = { name: "greet" }
+
+const polite = Scorer.make({
+  id: "quickstart/polite",
+  version: "1",
+  name: "polite",
+  score: ({ output }) => Effect.succeed({ score: String(output).startsWith("Hello") ? 1 : 0 })
+})
+
+const executor = CaseExecutor.make((suiteCase) =>
+  Effect.succeed({
+    output: `Hello, ${(suiteCase.input as { readonly name: string }).name}`,
+    stepKey: suiteCase.name,
+    latencyMs: 0,
+    target: greet
+  })
+)
+
+const program = Effect.gen(function*() {
+  const suite = yield* Suite.make({
+    name: "greetings",
+    cases: [
+      { name: "ada", input: { name: "Ada" }, expected: "Hello, Ada" },
+      { name: "grace", input: { name: "Grace" }, expected: "Hello, Grace" }
+    ],
+    bindings: [Binding.make({ scorer: polite, appliesTo: greet })],
+    concurrency: 2
+  })
+  const run = yield* Runner.run(suite, {
+    runId: "quickstart-1",
+    at: "2026-01-01T00:00:00.000Z"
+  })
+
+  if (process.argv.includes("--update")) {
+    const failures = run.cases.filter((result) => result.error !== undefined)
+    if (failures.length > 0) {
+      return yield* Effect.fail(
+        new EvalError.EvalError({
+          code: "executor",
+          message: `Refusing to record a baseline: ${failures.length} case(s) did not finish`
+        })
+      )
+    }
+    const baseline = yield* Baseline.fromRun(run)
+    yield* Effect.promise(() => writeFile("baseline.json", Baseline.write(baseline)))
+    yield* Effect.sync(() => process.stdout.write("baseline recorded\n"))
+    return 0
+  }
+
+  const committed = yield* Baseline.load(
+    yield* Effect.promise(() => readFile("baseline.json", "utf8"))
+  )
+  const comparison = yield* Regression.compare(committed, run)
+  yield* Effect.sync(() => process.stdout.write(Report.markdown(comparison)))
+  const verdict = yield* Gate.check(comparison, { mean: 1 })
+  const { exitCode, summary } = Gate.ciGrade(verdict)
+  yield* Effect.sync(() => process.stdout.write(`${summary}\n`))
+  return exitCode
+}).pipe(Effect.provide(Layer.succeed(CaseExecutor.CaseExecutor)(executor)))
+
+process.exitCode = await Effect.runPromise(program)
+```
+
+1. Record the baseline with `node quickstart.ts --update`. The script prints
+   `baseline recorded` and exits 0. If any case failed, it refuses to record
+   and fails with an `executor` `EvalError` instead.
+2. Gate against it with `node quickstart.ts`. The script prints the Markdown
+   report, then `passed`, and exits 0.
+3. Change the executor to answer `Hi` instead of `Hello` and gate again. Both
+   cases score 0 at their unchanged step keys, the comparison reports
+   nondeterminism, and the script exits 1.
+
+From here: [author a larger suite](./guides/author-a-suite.md), or read how
+[step keys decide what a comparison reports](./concepts/step-keys.md).

package/docs/troubleshooting.md

@@ -0,0 +1,148 @@
+---
+title: "Troubleshooting"
+description: "Every failure code @smthrs/evals raises, what it means, and who fixes it."
+---
+
+Failures arrive as `EvalError` values with a stable `code`, a `message`
+written for a CI log, and usually a `path` locating the offending value. The
+`code` is the branch point, and each code names one owner for the fix.
+
+## invalid_suite
+
+The suite declaration is wrong. The suite author fixes it.
+
+| Symptom in the message                                            | Path                                                                                                            | Cause                                                                                    |
+| ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `Suite name must not be empty`, or names a control character      | `name`                                                                                                          | The suite name is blank or holds a control character                                     |
+| `Suite must contain at least one case`                            | `cases`                                                                                                         | The `cases` array is empty                                                               |
+| `Suite must contain at most 10000 cases`                          | `cases`                                                                                                         | The suite exceeds `Suite.limits.cases`                                                   |
+| `Suite concurrency must be a positive safe integer`               | `concurrency`                                                                                                   | Zero, negative, fractional, or `NaN` concurrency                                         |
+| `Suite concurrency must be at most 1024`                          | `concurrency`                                                                                                   | The suite exceeds `Suite.limits.concurrency`                                             |
+| `Suite case name must not be empty`, or names a control character | `cases[N].name`                                                                                                 | A case name is blank or holds a control character                                        |
+| `Duplicate suite case`                                            | `cases[N].name`                                                                                                 | Two cases share a name                                                                   |
+| `Suite data must be structured-cloneable`                         | `cases[N].input`, `cases[N].expected`, `bindings[N].sampling`, `bindings[N].groundTruth`, `bindings[N].context` | The value holds a function, a class instance, or anything else `structuredClone` rejects |
+| `JSON Lines fixture must be at most 8388608 characters`           | `text`                                                                                                          | The fixture exceeds `Suite.limits.fixtureLength`; it was rejected before parsing         |
+| `Invalid JSON on line N`                                          | `line[N]`                                                                                                       | The 1-based fixture line is not JSON                                                     |
+| `Invalid suite case on line N`                                    | `line[N]`                                                                                                       | The fixture line is not a `{ name, input, expected? }` case                              |
+| `Invalid sampling policy for scorer`                              | `bindings[N].sampling`                                                                                          | The scorers package cannot decide the policy; see the [scorers API](/api/scorers)        |
+
+## invalid_run_options
+
+`Runner.run`'s own options are wrong, not the suite. The caller fixes them.
+
+- `Deterministic runs require a non-empty runId`, at `options.runId`: pass a
+  run identity.
+- `Deterministic runs require a canonical UTC timestamp such as
+  2026-01-01T00:00:00.000Z`, at `options.at`: the value must carry millisecond
+  precision and round-trip through parse and re-render.
+  `new Date().toISOString()` satisfies the format.
+
+## invalid_baseline
+
+The committed baseline is unreadable or belongs to another suite. Check the
+artifact and its ownership before regenerating it from a green run.
+
+- `Baseline is not valid JSON` or `Baseline must be an object`: the file is
+  not a baseline artifact. These two carry no `path`.
+- `Baseline version must be 1`, at `version`: the artifact was written by a
+  different version of the format.
+- `Baseline must be at most 16777216 characters`, at `text`: the file exceeds
+  `Baseline.limits.length` and was rejected before parsing.
+- `Baseline field 'suite' must be a string`, at `suite`: a present top-level
+  `suite` has the wrong type.
+- `Baseline field 'suite' must not contain the control character U+XXXX`, at
+  `suite`: the top-level `suite` holds a control character.
+- `Cannot infer baseline suite: legacy artifact has no records`, at `suite`:
+  the version-1 artifact has neither a top-level `suite` nor records. Add the
+  known owning suite explicitly, or regenerate it from that suite's green run.
+- `Cannot infer baseline suite: legacy records name multiple suites`, at
+  `suite`: records disagree on ownership. Recover a baseline for the intended
+  suite; do not choose the first record's suite for a mixed artifact.
+- `Baseline records must be an array`, at `records`.
+- A record that is not an object, an identity field that is not a string or
+  holds a control character, or a score outside [0, 1]: the record index and
+  field are in `path`, as in `records[3].score`.
+- `Baseline belongs to suite '<name>', but the run is suite '<name>'`, at
+  `baseline.suite` or `baseline.records`: comparison loaded the wrong file.
+  Check the path CI reads.
+
+A suite-less version-1 artifact loads when its records are nonempty and all
+name the same suite. `Baseline.write` of that loaded value adds the inferred
+top-level `suite` and retains the existing scores.
+
+## invalid_tolerance
+
+A comparison tolerance is not a finite non-negative number, at
+`tolerances.absolute` or `tolerances.relative`. Fix the call, not the
+baseline.
+
+## invalid_trials
+
+A `Trials` call received counts outside their bounds: a run count that is not
+a positive integer, a pass count outside `0..n`, or a `k` outside `1..n`. The
+`path` names the argument (`n`, `c`, `k`, or `cases['<name>']` for a case with
+no runs). Fix the call; `Trials.aggregate` already clamps `k` for a short case.
+
+## executor
+
+The target flow failed for a case, or no executor was available.
+
+- `Target failed for case '<name>': ...`: the executor failed. The run keeps
+  the typed error, locates it with the executor's own `path` or with
+  `cases['<name>']`, and produces no observations for the case. The rest of
+  the suite still ran. Read the retained `cause`.
+- `No executor is available for case '<name>'`: the run was provided
+  `CaseExecutor.makeNoop()` or `CaseExecutor.layerNoop`. Wire a real executor.
+
+## ambiguous_score_job
+
+Two score jobs share a step key and a scorer, so an order-only batch runner
+cannot attribute their results to a case. Give each case its own step key, or
+provide a batch runner that implements `runBatchCorrelated`.
+
+## scorer_protocol
+
+A batch runner broke the `runBatch` or `runBatchCorrelated` contract: the
+wrong number of results, a duplicate identity, an unknown identity, or an
+observation that does not echo its job's `targetStepKey` and `scorerKey`.
+Nothing it returned can be trusted. The message names the offending call, as
+in `runBatchCorrelated[0]`. Compare the adapter against `Runner.makeInline()`,
+the reference implementation of the protocol.
+
+## scorer_unavailable
+
+No batch runner was available to score with. This is `Runner.layerNoop`
+working as declared: every bound score becomes an inconclusive observation,
+and a gate grades the run undecidable rather than red. When the suite should
+score, provide `Runner.layerInline` or a real adapter.
+
+## Failures that are not EvalError
+
+Two wiring mistakes fail outside the `EvalError` channel:
+
+- `CaseExecutor.make` with no callback throws a `TypeError` synchronously.
+  Pass a function, or an object with a `run` or `execute` callback.
+- `Gate.check` with a threshold outside [0, 1] fails with a `ScoreGateError`,
+  code `invalid_threshold`, from [@smthrs/scorers/ScoreGate](/api/scorers). Catch it in
+  the error channel and report it.
+
+## Symptoms
+
+- Every score is inconclusive. Read the observation's `reason`. A
+  `Scorer execution was inconclusive: ...` reason names a scorer or batch
+  runner that failed. `<uncoercible cause>` means its failure could not be
+  converted to text. Failure reasons use the scorers package's 1024-byte limit.
+  A reason about a score outside [0, 1] or an unusable observation kind names a
+  scorer that returned a bad result. A suite provided `Runner.layerNoop` also
+  lands here.
+- A binding graded nothing. The execution's `target` is not the exact flow
+  value the binding's `appliesTo` holds (reference identity, not structure),
+  the case failed before scoring, or the sampling policy decided against the
+  execution.
+- The gate exits 5. The gate could not decide, or it passed with unresolved
+  observations. The Markdown report's Case failures, Missing observations, and
+  Inconclusive sections name what is missing. Exit 5 is an unusable harness to
+  repair, not a result to read.
+- The report printed a secret. `Report.json` embeds each case's raw
+  `execution.output` and redacts nothing. Keep the report out of readable logs
+  when cases carry secrets.

package/package.json

@@ -1,6 +1,201 @@
 {
   "name": "@smthrs/evals",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "1.0.0-rc.4",
+  "license": "MIT",
+  "smthrs": {
+    "group": "agent"
+  },
+  "description": "Fixed-suite evaluation, baselines, regression reports, and score gates for flows",
+  "homepage": "https://github.com/smithersai/smithers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/smithersai/smithers.git",
+    "directory": "packages/smithers/agent/evals"
+  },
+  "bugs": {
+    "url": "https://github.com/smithersai/smithers/issues"
+  },
+  "tags": [
+    "typescript",
+    "effect",
+    "flow",
+    "evaluation"
+  ],
+  "keywords": [
+    "typescript",
+    "effect",
+    "flow",
+    "evaluation"
+  ],
+  "engines": {
+    "node": ">=26.4.0"
+  },
+  "sideEffects": [],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./internal/*": null,
+    "./*/index": null,
+    "./Baseline": {
+      "import": {
+        "types": "./dist/esm/Baseline.d.ts",
+        "default": "./dist/esm/Baseline.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Baseline.d.ts",
+        "default": "./dist/cjs/Baseline.js"
+      }
+    },
+    "./CaseExecutor": {
+      "import": {
+        "types": "./dist/esm/CaseExecutor.d.ts",
+        "default": "./dist/esm/CaseExecutor.js"
+      },
+      "require": {
+        "types": "./dist/cjs/CaseExecutor.d.ts",
+        "default": "./dist/cjs/CaseExecutor.js"
+      }
+    },
+    "./EvalError": {
+      "import": {
+        "types": "./dist/esm/EvalError.d.ts",
+        "default": "./dist/esm/EvalError.js"
+      },
+      "require": {
+        "types": "./dist/cjs/EvalError.d.ts",
+        "default": "./dist/cjs/EvalError.js"
+      }
+    },
+    "./Gate": {
+      "import": {
+        "types": "./dist/esm/Gate.d.ts",
+        "default": "./dist/esm/Gate.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Gate.d.ts",
+        "default": "./dist/cjs/Gate.js"
+      }
+    },
+    "./Regression": {
+      "import": {
+        "types": "./dist/esm/Regression.d.ts",
+        "default": "./dist/esm/Regression.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Regression.d.ts",
+        "default": "./dist/cjs/Regression.js"
+      }
+    },
+    "./Report": {
+      "import": {
+        "types": "./dist/esm/Report.d.ts",
+        "default": "./dist/esm/Report.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Report.d.ts",
+        "default": "./dist/cjs/Report.js"
+      }
+    },
+    "./Runner": {
+      "import": {
+        "types": "./dist/esm/Runner.d.ts",
+        "default": "./dist/esm/Runner.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Runner.d.ts",
+        "default": "./dist/cjs/Runner.js"
+      }
+    },
+    "./Suite": {
+      "import": {
+        "types": "./dist/esm/Suite.d.ts",
+        "default": "./dist/esm/Suite.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Suite.d.ts",
+        "default": "./dist/cjs/Suite.js"
+      }
+    },
+    "./Trials": {
+      "import": {
+        "types": "./dist/esm/Trials.d.ts",
+        "default": "./dist/esm/Trials.js"
+      },
+      "require": {
+        "types": "./dist/cjs/Trials.d.ts",
+        "default": "./dist/cjs/Trials.js"
+      }
+    },
+    "./index": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "src/**/*.ts",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "dist/**/package.json",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "docs/"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "tag": "next"
+  },
+  "dependencies": {
+    "@smthrs/core": "1.0.0-rc.4",
+    "@smthrs/scorers": "1.0.0-rc.4"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.115"
+  },
+  "devDependencies": {
+    "@effect/language-service": "0.87.2",
+    "@eslint/js": "9.39.5",
+    "@types/node": "26.4.1",
+    "@vitest/coverage-v8": "5.0.0",
+    "dprint": "0.57.1",
+    "effect": "4.0.0-rc.115",
+    "esbuild": "0.28.2",
+    "eslint": "9.39.5",
+    "eslint-import-resolver-typescript": "4.4.5",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-jsdoc": "64.3.4",
+    "eslint-plugin-unicorn": "65.0.0",
+    "madge": "8.0.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.69.0",
+    "vitest": "5.0.0"
+  },
+  "scripts": {
+    "lint": "eslint src --max-warnings=0 && dprint check",
+    "format": "dprint fmt",
+    "build": "node scripts/build.mjs",
+    "check": "tsc -b tsconfig.json && tsc -p tsconfig.test.json --noEmit",
+    "circular": "node scripts/circular.mjs",
+    "test": "vitest",
+    "coverage": "vitest --coverage"
+  }
 }