vitest-sentry-reporter 1.0.0

package/dist/reporter.d.ts

@@ -0,0 +1,23 @@
+import type { Reporter, TestCase, TestModule, TestRunEndReason, SerializedError } from 'vitest/node';
+import type { VitestSentryReporterOptions, VitestUserConsoleLog } from './types.js';
+export declare class VitestSentryReporter implements Reporter {
+    name: string;
+    private options;
+    private enabled;
+    private initialized;
+    private reportedIds;
+    private queued;
+    private logsByTask;
+    private maxEventsPerRun?;
+    constructor(options?: VitestSentryReporterOptions);
+    onInit(): void;
+    onUserConsoleLog(log: VitestUserConsoleLog): void;
+    onTestCaseResult(testCase: TestCase): void;
+    onTestRunEnd(testModules: ReadonlyArray<TestModule>, _unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): Promise<void>;
+    private collectFailure;
+    private enqueueFailure;
+    private reportFailure;
+    private initSentry;
+    private resolveEnabled;
+}
+export default VitestSentryReporter;

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+import type * as Sentry from '@sentry/node';
+export type Primitive = string | number | boolean | null | undefined;
+/**
+ * Configuration for the Sentry-enabled Vitest reporter.
+ *
+ * Defaults are chosen to make the reporter work out-of-the-box in CI when `SENTRY_DSN` is set.
+ * Most fields can be provided via environment variables and are merged with these options.
+ */
+export type VitestSentryReporterOptions = {
+    /**
+     * Sentry DSN. If omitted, `process.env.SENTRY_DSN` is used.
+     * Reporter is disabled when no DSN is available.
+     */
+    dsn?: string;
+    /**
+     * Force enable/disable the reporter regardless of DSN presence.
+     * Defaults to enabled when a DSN is available.
+     */
+    enabled?: boolean;
+    /**
+     * Event environment. If omitted, uses `SENTRY_ENVIRONMENT` or falls back to `ci` when a CI is detected,
+     * otherwise `process.env.NODE_ENV || 'local'`.
+     */
+    environment?: string;
+    /**
+     * Release identifier. If omitted, uses `SENTRY_RELEASE` or commonly available CI commit SHA.
+     */
+    release?: string;
+    /**
+     * Optional server name/hostname. If omitted, Sentry SDK defaults apply.
+     */
+    serverName?: string;
+    /**
+     * Optional logical project tag you can use to group events across multiple repositories.
+     */
+    project?: string;
+    /**
+     * Static tags to attach to every reported failure. Values are coerced to strings.
+     */
+    tags?: Record<string, Primitive>;
+    /**
+     * Additional Sentry Node SDK options merged into the initialization call.
+     */
+    sentryOptions?: Sentry.NodeOptions;
+    /**
+     * Predicate to determine if a given failure should be reported.
+     * Return false to skip reporting.
+     */
+    shouldReport?: (ctx: FailureContext) => boolean;
+    /**
+     * Produce dynamic tags per failure. Merged after static `tags`.
+     */
+    getTags?: (ctx: FailureContext) => Record<string, Primitive> | undefined;
+    /**
+     * Sentry fingerprint to control grouping. If omitted, defaults to
+     * `['vitest-failure', filePath || 'unknown-file', testName]`.
+     */
+    getFingerprint?: (ctx: FailureContext) => string[] | undefined;
+    /**
+     * Associate a user with the event (useful for local runs).
+     */
+    getUser?: (ctx: FailureContext) => {
+        id?: string;
+        email?: string;
+        username?: string;
+    } | undefined;
+    /**
+     * Final event mutation hook, applied via scope event processor before sending.
+     * Return the modified event or `null` to drop it.
+     */
+    beforeSend?: (event: Sentry.Event, hint: Sentry.EventHint, ctx: FailureContext) => Sentry.Event | null;
+    /**
+     * Upper bound on number of events sent in a single Vitest run. Useful to cap noise in very large suites.
+     */
+    maxEventsPerRun?: number;
+    /**
+     * When true, prints what would be sent to Sentry without actually sending events.
+     * It has no effect if `enabled` is false.
+     */
+    dryRun?: boolean;
+};
+export type FailureContext = {
+    id?: string;
+    filePath?: string;
+    testName: string;
+    fullTitle?: string;
+    suitePath?: string[];
+    message?: string;
+    stack?: string;
+    error?: unknown;
+    durationMs?: number;
+    retry?: number;
+    flaky?: boolean;
+    logs?: string[];
+    meta?: Record<string, unknown>;
+};
+/**
+ * Minimal shape of Vitest's `UserConsoleLog`, delivered to the reporter's
+ * `onUserConsoleLog` hook. We only depend on the fields we actually use so the
+ * reporter does not couple to Vitest internals beyond the public reporter API.
+ */
+export interface VitestUserConsoleLog {
+    content: string;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+}

package/dist/utils.d.ts

@@ -0,0 +1,24 @@
+import type { TestCase } from 'vitest/node';
+import type { Primitive, FailureContext } from './types.js';
+export declare function toErrorMessage(err: unknown): string | undefined;
+export declare function toStack(err: unknown): string | undefined;
+/**
+ * Walk a test case's parent chain, collecting the enclosing suite names
+ * (outermost first). The chain ends at the test module, which is not a suite.
+ */
+export declare function collectSuitePath(testCase: TestCase): string[];
+/**
+ * Convert a finished Vitest {@link TestCase} into the reporter's
+ * {@link FailureContext}. `logs` are collected separately via the
+ * `onUserConsoleLog` reporter hook and threaded in by the caller.
+ */
+export declare function toFailureContext(testCase: TestCase, logs?: string[]): FailureContext;
+export declare function ciProvider(): string | undefined;
+export declare function repository(): string | undefined;
+export declare function branch(): string | undefined;
+export declare function commitSha(): string | undefined;
+export declare function inferEnvironment(): string | undefined;
+export declare function vitestVersion(): string | undefined;
+export declare function cleanRecord(obj?: Record<string, unknown>): Record<string, Primitive>;
+export declare function baseTags(ctx: FailureContext): Record<string, Primitive>;
+export declare function extras(ctx: FailureContext): Record<string, unknown>;

package/docs/decisions/0000-use-markdown-architectural-decision-records.md

@@ -0,0 +1,33 @@
+---
+title: Use Markdown Architectural Decision Records (MADR)
+status: accepted
+date: 2025-09-03
+authors:
+  - cadesalaberry
+---
+
+## Context
+
+We want a consistent, lightweight, and review-friendly way to document architectural decisions for `vitest-sentry-reporter`. An ADR format helps capture context, options, and outcomes over time.
+
+## Decision
+
+Adopt MADR (Markdown Architectural Decision Records) as our ADR format and process.
+
+- Store ADRs under `docs/decisions`
+- Use sequential, zero-padded numbering: `NNNN-short-title.md`
+- Start new ADRs from `docs/decisions/adr-template.md`
+- Capture metadata (`title`, `status`, `date`, `authors`) in YAML front matter
+- Use statuses: `proposed`, `accepted`, `rejected`, `deprecated`, `superseded`
+- When an ADR is superseded, link the successor in both directions
+
+## Consequences
+
+- Clear, searchable history of decisions and their rationale
+- Easier onboarding and code reviews through explicit rationale
+- Small process overhead when proposing significant changes
+
+## References
+
+- MADR documentation: https://adr.github.io/madr/
+- MADR repository: https://github.com/adr/madr

package/docs/decisions/0001-adopt-bun-as-package-manager.md

@@ -0,0 +1,32 @@
+---
+title: Adopt Bun as the package manager and runtime
+status: accepted
+date: 2025-09-03
+authors:
+  - cadesalaberry
+---
+
+## Context
+
+This repository is an npm package intended for publication. We want a fast developer experience (installs, scripts) and a single lockfile. Bun provides an all-in-one toolchain (runtime, test runner, bundler, package manager) with strong Node compatibility, which fits this project well.
+
+## Decision
+
+- Use Bun as the primary package manager for this repo.
+- Specify the required Bun version in `package.json` `engines.bun` and set `packageManager: bun@<version>`.
+- Generate and commit `bun.lockb` for reproducible installs.
+- Maintain Node compatibility via a CommonJS entry (`index.js`) so the package can be consumed by Node/Vitest users.
+- Continue to publish to the public npm registry.
+
+## Consequences
+
+- Faster installs and scripts with Bun.
+- One lockfile (`bun.lockb`) maintained in the repo.
+- Contributors need Bun installed locally; Node remains supported for consumers of the published package.
+- CI should use Bun for install and scripts.
+
+## References
+
+- Bun: https://bun.sh/
+- npm Publishing Guide: https://docs.npmjs.com/creating-and-publishing-unscoped-public-packages
+- Vitest reporters: https://vitest.dev/guide/reporters.html

package/docs/decisions/0002-add-dry-run-transport.md

@@ -0,0 +1,42 @@
+---
+title: Add dry-run transport to log Sentry envelopes instead of sending
+status: accepted
+date: 2025-09-04
+authors:
+  - cadesalaberry
+---
+
+## Context
+
+- We want a way to validate what would be reported to Sentry without actually sending events (useful locally or in CI dry runs).
+- The reporter already had a `dryRun` flag that short-circuited reporting. This prevented exercising Sentry scope logic, event processors, and grouping.
+
+## Decision
+
+- Implement a custom Sentry transport factory that logs envelope items (type + payload) and returns a resolved promise.
+- Enable this transport when `dryRun` is true via `Sentry.init({ transport: makeDryRunTransport })`.
+- Allow an inert DSN in dry-run mode to initialize the SDK and run the normal capture flow.
+- Move the transport to `src/dry-run-transport.ts` and keep `src/reporter.ts` focused on reporter behavior.
+
+## Details
+
+- `makeDryRunTransport` implements `{ send(envelope), flush(timeout) }`.
+- `send` iterates `envelope[1]` items and logs `{ type, payload }` with a clear prefix.
+- Minimal internal `Envelope` typings are defined locally to avoid importing Sentry private types.
+- `reportFailure` no longer short-circuits on `dryRun`; events go through scopes, tags, and `beforeSend` processors.
+- `initSentry` chooses a fallback DSN when `dryRun` is enabled and sets the transport accordingly.
+
+## Consequences
+
+- Local and CI dry runs show deterministic logs of would-be sent payloads.
+- The same code paths are exercised in both dry-run and real modes, reducing drift and surprises.
+- No network traffic is emitted during dry runs.
+
+## Alternatives
+
+- Keep early-return logging in the reporter: rejected, because it bypassed Sentry's scope/event pipeline and diverged from real behavior.
+- Mock Sentry client entirely: rejected, higher maintenance and more divergence from SDK behavior.
+
+## Tests
+
+- Added `src/dry-run-transport.test.ts` to assert logging behavior and `flush` returning `true`.

package/docs/decisions/0003-commit-conventions.md

@@ -0,0 +1,50 @@
+---
+title: Adopt Conventional Commits and Gitmoji
+status: accepted
+date: 2025-11-25
+authors:
+  - cadesalaberry
+---
+
+## Context
+
+A consistent commit history is crucial for project maintainability, automated release generation, and developer collaboration. Without a strict convention, commit messages can become inconsistent, making it difficult to understand the history of changes, generate changelogs, or trigger automated workflows based on commit types.
+
+We need a standardized way to format commit messages that is both machine-readable (for automation) and human-readable (for quick scanning).
+
+## Decision
+
+We will adopt **Conventional Commits v1.0.0-beta.4** combined with **Gitmoji**.
+
+1.  **Conventional Commits**: Provides a structured format (`type(scope): description`) that is widely supported by tools for changelog generation and semantic versioning.
+2.  **Gitmoji**: Adds a visual layer to commit messages, making it easier to scan the history and identify the nature of changes at a glance.
+
+The required format is:
+```
+<type>(optional scope): <gitmoji> <description>
+```
+
+Example:
+```
+feat(auth): ✨ add login functionality
+```
+
+We have documented the specific rules and the list of allowed Gitmojis in `docs/COMMIT_CONVENTION.md`.
+All agents and contributors are expected to follow this convention.
+
+## Consequences
+
+**Positive:**
+- **Automated Releases**: We can use tools like `semantic-release` or `standard-version` to automatically determine the next version number and generate changelogs based on commit types (e.g., `feat` -> minor, `fix` -> patch, `BREAKING CHANGE` -> major).
+- **Readability**: The history becomes easier to scan. Gitmojis provide instant visual cues about the commit's purpose.
+- **Consistency**: All contributors (human and agents) will follow the same standard.
+
+**Negative:**
+- **Learning Curve**: Contributors need to learn the specific types and emojis.
+- **Overhead**: Writing commit messages takes slightly more thought and time to look up the correct emoji.
+
+## References
+
+- [Conventional Commits](https://www.conventionalcommits.org/)
+- [Gitmoji](https://gitmoji.dev/)
+- [Project Commit Convention](../COMMIT_CONVENTION.md)

package/docs/decisions/0004-migrate-to-vitest-4-reported-tasks-api.md

@@ -0,0 +1,92 @@
+---
+title: Migrate the reporter to the Vitest 4 reported-tasks API
+status: accepted
+date: 2026-06-07
+authors:
+  - cadesalaberry
+---
+
+## Context
+
+The reporter was written against the pre-Vitest-4 task-based reporter API. On
+Vitest 4 it still ran without crashing, but it produced corrupt events:
+
+- `onTaskUpdate(packs)` — Vitest 4 keeps dispatching this *deprecated* hook, but
+  with the legacy pack shape `[id, result, meta]`. The code read `pack[0]` as a
+  *task object* when it is actually an **id string**, so every event got
+  `test_name: 'unknown'` and a `Math.random()` id. Dedup keyed on that id never
+  matched, so a single failure was reported multiple times.
+- `onTestRunEnd(testModules)` — the hook name was correct, but the body iterated
+  `file.tasks` (the old `File` shape). Vitest 4 passes `TestModule[]` with no
+  `.tasks`, so the end-of-run sweep collected nothing.
+- State checks compared against `'fail'`, but Vitest 4 uses `'failed'`, and
+  `types.ts` carried a whole hand-rolled legacy type layer shadowing the real
+  Vitest types.
+
+A first migration attempt landed in #1, was reverted in #2, and is re-landed
+here in #3.
+
+## Decision
+
+Rewrite the reporter onto Vitest 4's public **reported-tasks** reporter API
+(`vitest/node`) and remove the legacy code paths.
+
+- **`src/reporter.ts`** — drop `onTaskUpdate`; the class now `implements Reporter`
+  from `vitest/node` and uses:
+  - `onTestCaseResult(testCase)` for incremental collection of failures as they
+    happen;
+  - `onTestRunEnd(testModules, …)` iterating `TestModule.children.allTests('failed')`
+    as a defensive final sweep, then flushing;
+  - `onUserConsoleLog(log)` to buffer per-test console output (keyed by `taskId`)
+    so it can be attached to the failure event, preserving the documented `logs`
+    extra.
+  - A shared `collectFailure` dedup helper keyed on `testCase.id`, and
+    `maxEventsPerRun` now counts events actually sent rather than ids seen.
+- **`src/utils.ts`** — `toFailureContext` consumes a `TestCase`
+  (`.result()`, `.diagnostic()`, `.module.moduleId`, `.fullName`);
+  `collectSuitePath` walks the `TestCase.parent` chain (ending at the module).
+  Removed the now-unused `buildFullTitle` and `extractLogs` helpers.
+- **`src/types.ts`** — delete the legacy type layer (`VitestTaskLike`,
+  `VitestTaskResult`, `VitestSuiteNode`, `TaskUpdatePack`, the stale
+  `declare class`); add a minimal `VitestUserConsoleLog` covering only the fields
+  the reporter reads.
+- **Tests** — rewrite `utils.test.ts` against the `TestCase` API, add
+  `reporter.test.ts` (dedup, end-of-run sweep, `maxEventsPerRun`, `shouldReport`,
+  log buffering, no-DSN path), and fix a pre-existing wrong assertion in
+  `dry-run-transport.test.ts`.
+- **`package.json` / `README.md`** — bump the `vitest` peer dependency from
+  `>=1.0.0` to `>=4.0.0` and update the README compatibility note to "Vitest 4+".
+- Clean up two leftover debug hacks in `initSentry`: `debug: true || isDryRun`
+  becomes `debug: isDryRun`, and the DSN `console.log` is gated behind dry-run.
+
+## Consequences
+
+- **Breaking change.** Vitest < 4 is no longer supported (peer dependency
+  `>=4.0.0`). This warrants a major version bump for the package.
+- Events are now correct on Vitest 4: real `test_name`, `test_full_title`
+  (`suite > test`), `test_file`, `flaky`, `retry`, and `extras`
+  (`suite_path`, `duration_ms`, `vitest_version`). End-to-end verification
+  showed exactly one event per run (`count: 2` across two runs), confirming
+  dedup works.
+- The reporter now depends on the **public** `vitest/node` reporter contract
+  rather than reverse-engineered internal task shapes, so it is less fragile and
+  easier to keep in step with future Vitest releases.
+- Consumers still on Vitest 2/3 must either pin an older release of this package
+  or upgrade Vitest.
+
+## Alternatives
+
+- **Keep dual code paths for both the legacy task API and the reported-tasks
+  API.** Rejected: the deprecated `onTaskUpdate` pack shape on Vitest 4 differs
+  from the pre-4 shape, so a compatibility shim would be complex and fragile for
+  diminishing benefit as Vitest 2/3 fade out.
+- **Stay on the deprecated `onTaskUpdate` hook and just fix the pack parsing.**
+  Rejected: the hook is deprecated and slated for removal, and it does not give
+  clean access to the new `TestCase` result/diagnostic data the reporter needs.
+
+## References
+
+- PR #3: https://github.com/cadesalaberry/vitest-sentry-reporter/pull/3
+- Superseded earlier attempts: PR #1 (reverted by PR #2)
+- Vitest reporters: https://vitest.dev/guide/reporters.html
+- Vitest advanced reporter / reported tasks API: https://vitest.dev/advanced/api/reporters.html

package/docs/decisions/0005-support-vitest-3.md

@@ -0,0 +1,36 @@
+---
+title: Support Vitest 3 by relaxing the peer dependency range
+status: accepted
+date: 2026-06-07
+authors:
+  - cadesalaberry
+---
+
+## Context
+
+- The reporter declared `peerDependencies.vitest: ">=4.0.0"`, which blocked installation on Vitest 3 projects.
+- The reporter is built on the "reported-tasks" reporter API (`onTestCaseResult`, `onTestRunEnd`, and the `TestCase` / `TestModule` / `TestSuite` objects from `vitest/node`). That API was introduced in Vitest `3.0.0`; the API that was removed in Vitest 4 is the older one (`onTaskUpdate`, `onFinished`, `onCollected`), which this reporter never used.
+- Every method and property the reporter touches — `testCase.result()`, `testCase.diagnostic()` (`duration`/`retryCount`/`flaky`), `testCase.fullName`, `testCase.module.moduleId`, `testCase.parent`, `testCase.project.name`, and `testModule.children.allTests('failed')` — exists with identical signatures in Vitest `3.0.0`. No source changes are needed for compatibility.
+
+## Decision
+
+- Relax `peerDependencies.vitest` from `">=4.0.0"` to `">=3.0.0"`.
+- Keep `devDependencies.vitest` on the latest major (`^4.0.13`) so development and type-checking happen against the newest API surface.
+- Add a CI matrix that builds and runs the test suite against both Vitest 3 and Vitest 4 so the compatibility claim is verified on every push and cannot silently regress.
+- Do not lower support below `3.0.0`: the `onTestCaseResult` / `onTestRunEnd` lifecycle did not exist in 2.x (only the experimental reported-tasks objects did).
+
+## Consequences
+
+- Vitest 3 users can install and use the reporter.
+- The `build` step (`tsc --emitDeclarationOnly`) type-checks `src/` against the installed Vitest types, so a green matrix leg doubles as a type-compatibility check for that major.
+- The CI matrix doubles the job count for this workflow.
+
+## Verification
+
+- Type-check (`bun run build`) and the unit suite (`bun run test run`) pass against `vitest@3.0.0` and `vitest@3.2.6`.
+- An end-to-end dry-run against real `vitest@3.0.0` objects (a deliberately failing test reported through the reporter in `dryRun` mode) produced the expected Sentry envelope with correct `test_file`, `test_name`, and `test_full_title` tags.
+
+## References
+
+- Vitest 4 migration guide: reporter APIs `onCollected`, `onTaskUpdate`, `onFinished` removed; "The new APIs were introduced in Vitest `v3.0.0`."
+- ADR 0002 (dry-run transport), reused for the end-to-end verification above.

package/docs/decisions/README.md

@@ -0,0 +1,58 @@
+# Architectural Decision Records (ADR)
+
+This directory contains Architectural Decision Records using MADR (Markdown Architectural Decision Records).
+
+- Format: MADR. See the docs at [adr.github.io/madr](https://adr.github.io/madr/) and the repository at [github.com/adr/madr](https://github.com/adr/madr).
+- Template: `adr-template.md`
+- Each ADR carries its metadata (`title`, `status`, `date`, `authors`) in YAML front matter, followed by `## Context`, `## Decision`, and `## Consequences` sections.
+
+## Index
+
+| ADR | Title | Status | Date |
+| --- | --- | --- | --- |
+| [0000](0000-use-markdown-architectural-decision-records.md) | Use Markdown Architectural Decision Records (MADR) | accepted | 2025-09-03 |
+| [0001](0001-adopt-bun-as-package-manager.md) | Adopt Bun as the package manager and runtime | accepted | 2025-09-03 |
+| [0002](0002-add-dry-run-transport.md) | Add dry-run transport to log Sentry envelopes instead of sending | accepted | 2025-09-04 |
+| [0003](0003-commit-conventions.md) | Adopt Conventional Commits and Gitmoji | accepted | 2025-11-25 |
+| [0004](0004-migrate-to-vitest-4-reported-tasks-api.md) | Migrate the reporter to the Vitest 4 reported-tasks API | accepted | 2026-06-07 |
+| [0005](0005-support-vitest-3.md) | Support Vitest 3 by relaxing the peer dependency range | accepted | 2026-06-07 |
+
+ADRs are numbered sequentially in the chronological order in which they were decided.
+
+## How to create a new ADR
+
+1. Choose the next zero-padded number (e.g., `0006`).
+2. Copy the template:
+
+```
+cp adr-template.md 0006-short-title.md
+```
+
+3. Fill in the front matter (`title`, `status`, `date`, `authors`) and the `## Context` / `## Decision` / `## Consequences` sections.
+4. Add a row to the [Index](#index) above.
+5. Commit the ADR following the project [commit convention](../COMMIT_CONVENTION.md), e.g. `docs(adr): 📝 add ADR for X`.
+
+## Front matter
+
+```yaml
+---
+title: Short imperative title
+status: proposed
+date: YYYY-MM-DD
+authors:
+  - your-github-handle
+---
+```
+
+## Naming
+
+- File name: `NNNN-short-title.md` where `NNNN` is the zero-padded sequence number.
+- Title: Use a short imperative phrase.
+
+## Status values
+
+- `proposed`: Under discussion
+- `accepted`: Agreed and to be implemented (or already implemented)
+- `rejected`: Considered but not adopted
+- `deprecated`: No longer recommended for new work
+- `superseded`: Replaced by another ADR (link the successor)

package/docs/decisions/adr-template.md

@@ -0,0 +1,23 @@
+---
+title: Short imperative title
+status: proposed
+date: YYYY-MM-DD
+authors:
+  - your-github-handle
+---
+
+## Context
+
+What is the issue that motivates this decision or change?
+
+## Decision
+
+What change are we proposing and/or implementing?
+
+## Consequences
+
+What becomes easier or harder because of this decision?
+
+## References
+
+- Links to related ADRs, issues, docs, and external resources

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "vitest-sentry-reporter",
+  "version": "1.0.0",
+  "description": "Vitest reporter that sends failures and context to Sentry.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "build": "bun build --target=node --format=esm --outdir=dist src/index.ts && bun run build:types",
+    "build:types": "tsc --emitDeclarationOnly",
+    "prepublishOnly": "bun run build",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:dogfood": "DOGFOOD=true bun run test run",
+    "prepare": "echo \"Using Bun as the package manager\""
+  },
+  "keywords": [
+    "vitest",
+    "reporter",
+    "sentry",
+    "testing",
+    "ci"
+  ],
+  "author": "C-A de Salaberry",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chanto/vitest-sentry-reporter.git"
+  },
+  "homepage": "https://github.com/chanto/vitest-sentry-reporter#readme",
+  "bugs": {
+    "url": "https://github.com/chanto/vitest-sentry-reporter/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "docs/decisions"
+  ],
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.1.0"
+  },
+  "packageManager": "bun@1.2.21",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@sentry/node": ">=10.0.0",
+    "vitest": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@sentry/node": "^10.27.0",
+    "@types/node": "^18",
+    "@vitest/coverage-v8": "^4.0.13",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.13"
+  }
+}