@unthrown/vitest 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit Travers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# @unthrown/vitest
+
+> [Vitest](https://vitest.dev) matchers for [unthrown](https://github.com/btravstack/unthrown)'s
+> `Result` and `AsyncResult`.
+
+📖 **[Documentation](https://btravstack.github.io/unthrown/guide/testing)** ·
+[API Reference](https://btravstack.github.io/unthrown/api/vitest/)
+
+```sh
+pnpm add -D @unthrown/vitest
+```
+
+Register the matchers once (e.g. in a Vitest setup file):
+
+```ts
+import "@unthrown/vitest";
+```
+
+```ts
+expect(ok(1)).toBeOk();
+expect(ok(1)).toBeOkWith(1);
+expect(err(new NotFound())).toBeErrTagged("NotFound");
+expect(aDefect).toBeDefect();
+
+// toBeErrTagged also takes an optional payload: a plain object matches exactly,
+// an asymmetric matcher matches partially.
+expect(err(new NotFound({ id: 1 }))).toBeErrTagged("NotFound", { id: 1 });
+expect(err(new NotFound({ id: 1, msg: "x" }))).toBeErrTagged(
+  "NotFound",
+  expect.objectContaining({ id: 1 }),
+);
+
+// AsyncResult — `await` is required
+await expect(fromPromise(load(), qualify)).toBeOk();
+```
+
+Matchers: `toBeOk`, `toBeOkWith`, `toBeErr`, `toBeErrTagged(tag, expected?)`, `toBeDefect`.
+
+> [!WARNING]
+> For an `AsyncResult` the matcher is asynchronous — you **must** `await` the
+> assertion, or it passes silently.
+
+`vitest` is a peer dependency.
+
+## License
+
+[MIT](../../LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -0,0 +1,96 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let unthrown = require("unthrown");
+let vitest = require("vitest");
+//#region src/index.ts
+function isThenable(x) {
+	return (typeof x === "object" || typeof x === "function") && x !== null && typeof x.then === "function";
+}
+function isResult(x) {
+	return typeof x?.isOk === "function";
+}
+function render(result, stringify) {
+	if ((0, unthrown.isOk)(result)) return `Ok(${stringify(result.value)})`;
+	if ((0, unthrown.isErr)(result)) return `Err(${stringify(result.error)})`;
+	if ((0, unthrown.isDefect)(result)) return `Defect(${stringify(result.cause)})`;
+	return stringify(result);
+}
+function payloadOf(error) {
+	const out = {};
+	for (const key of Object.keys(error)) if (key !== "_tag" && key !== "name") out[key] = error[key];
+	return out;
+}
+function settle(received, stringify, check) {
+	const run = (value) => isResult(value) ? check(value) : {
+		pass: false,
+		message: () => `expected an unthrown Result, but received ${stringify(value)}`
+	};
+	return isThenable(received) ? Promise.resolve(received).then(run) : run(received);
+}
+function toBeOk(received) {
+	const { stringify } = this.utils;
+	return settle(received, stringify, (result) => {
+		const pass = (0, unthrown.isOk)(result);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be Ok, but it was ${render(result, stringify)}` : `expected result to be Ok, but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeOkWith(received, expected) {
+	const { stringify } = this.utils;
+	const { equals } = this;
+	return settle(received, stringify, (result) => {
+		const pass = (0, unthrown.isOk)(result) && equals(result.value, expected);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be Ok(${stringify(expected)})` : `expected result to be Ok(${stringify(expected)}), but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeErr(received) {
+	const { stringify } = this.utils;
+	return settle(received, stringify, (result) => {
+		const pass = (0, unthrown.isErr)(result);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be Err, but it was ${render(result, stringify)}` : `expected result to be Err, but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeErrTagged(received, tag, expected) {
+	const { stringify } = this.utils;
+	const { equals } = this;
+	const hasExpected = expected !== void 0;
+	const label = hasExpected ? `Err tagged ${stringify(tag)} matching ${stringify(expected)}` : `Err tagged ${stringify(tag)}`;
+	return settle(received, stringify, (result) => {
+		const error = (0, unthrown.isErr)(result) ? result.error : void 0;
+		const pass = error?._tag === tag && (!hasExpected || equals(payloadOf(error), expected));
+		return {
+			pass,
+			message: () => pass ? `expected result not to be ${label}` : `expected result to be ${label}, but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeDefect(received) {
+	const { stringify } = this.utils;
+	return settle(received, stringify, (result) => {
+		const pass = (0, unthrown.isDefect)(result);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be a Defect, but it was ${render(result, stringify)}` : `expected result to be a Defect, but got ${render(result, stringify)}`
+		};
+	});
+}
+vitest.expect.extend({
+	toBeOk,
+	toBeOkWith,
+	toBeErr,
+	toBeErrTagged,
+	toBeDefect
+});
+//#endregion
+exports.toBeDefect = toBeDefect;
+exports.toBeErr = toBeErr;
+exports.toBeErrTagged = toBeErrTagged;
+exports.toBeOk = toBeOk;
+exports.toBeOkWith = toBeOkWith;

package/dist/index.d.cts

@@ -0,0 +1,33 @@
+import { MatcherResult, MatcherState } from "vitest";
+
+//#region src/index.d.ts
+declare function toBeOk(this: MatcherState, received: unknown): MatcherResult;
+declare function toBeOkWith(this: MatcherState, received: unknown, expected: unknown): MatcherResult;
+declare function toBeErr(this: MatcherState, received: unknown): MatcherResult;
+declare function toBeErrTagged(this: MatcherState, received: unknown, tag: string, expected?: unknown): MatcherResult;
+declare function toBeDefect(this: MatcherState, received: unknown): MatcherResult;
+/**
+ * The matchers `@unthrown/vitest` contributes to Vitest's `expect`. For an
+ * `AsyncResult`, `await` the assertion; `toBeOkWith` compares deeply.
+ *
+ * @typeParam R - the assertion's chaining return type.
+ */
+type UnthrownMatchers<R = unknown> = {
+  toBeOk: () => R;
+  toBeOkWith: (value: unknown) => R;
+  toBeErr: () => R;
+  /**
+   * Assert an `Err` whose error has `_tag === tag`. Optionally pass `expected`
+   * to also match the error's payload (its own props minus `_tag`/`name`): a
+   * plain object matches exactly, an asymmetric matcher (e.g.
+   * `expect.objectContaining(...)`) matches partially.
+   */
+  toBeErrTagged: (tag: string, expected?: unknown) => R;
+  toBeDefect: () => R;
+};
+declare module "vitest" {
+  interface Matchers<T = any> extends UnthrownMatchers<T> {}
+} //# sourceMappingURL=index.d.ts.map
+//#endregion
+export { UnthrownMatchers, toBeDefect, toBeErr, toBeErrTagged, toBeOk, toBeOkWith };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;iBAsES,MAAA,CAAO,IAAA,EAAM,YAAA,EAAc,QAAA,YAAoB,aAAa;AAAA,iBAc5D,UAAA,CAAW,IAAA,EAAM,YAAA,EAAc,QAAA,WAAmB,QAAA,YAAoB,aAAa;AAAA,iBAenF,OAAA,CAAQ,IAAA,EAAM,YAAA,EAAc,QAAA,YAAoB,aAAa;AAAA,iBAc7D,aAAA,CACP,IAAA,EAAM,YAAA,EACN,QAAA,WACA,GAAA,UACA,QAAA,aACC,aAAa;AAAA,iBAqBP,UAAA,CAAW,IAAA,EAAM,YAAA,EAAc,QAAA,YAAoB,aAAa;;;;;;AArEJ;KA6FzD,gBAAA;EACV,MAAA,QAAc,CAAA;EACd,UAAA,GAAa,KAAA,cAAmB,CAAA;EAChC,OAAA,QAAe,CAAA;EAlFS;;;;;;EAyFxB,aAAA,GAAgB,GAAA,UAAa,QAAA,eAAuB,CAAA;EACpD,UAAA,QAAkB,CAAA;AAAA;AAAA;EAAA,UAKR,QAAA,kBAA0B,gBAAgB,CAAC,CAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+import { MatcherResult, MatcherState } from "vitest";
+
+//#region src/index.d.ts
+declare function toBeOk(this: MatcherState, received: unknown): MatcherResult;
+declare function toBeOkWith(this: MatcherState, received: unknown, expected: unknown): MatcherResult;
+declare function toBeErr(this: MatcherState, received: unknown): MatcherResult;
+declare function toBeErrTagged(this: MatcherState, received: unknown, tag: string, expected?: unknown): MatcherResult;
+declare function toBeDefect(this: MatcherState, received: unknown): MatcherResult;
+/**
+ * The matchers `@unthrown/vitest` contributes to Vitest's `expect`. For an
+ * `AsyncResult`, `await` the assertion; `toBeOkWith` compares deeply.
+ *
+ * @typeParam R - the assertion's chaining return type.
+ */
+type UnthrownMatchers<R = unknown> = {
+  toBeOk: () => R;
+  toBeOkWith: (value: unknown) => R;
+  toBeErr: () => R;
+  /**
+   * Assert an `Err` whose error has `_tag === tag`. Optionally pass `expected`
+   * to also match the error's payload (its own props minus `_tag`/`name`): a
+   * plain object matches exactly, an asymmetric matcher (e.g.
+   * `expect.objectContaining(...)`) matches partially.
+   */
+  toBeErrTagged: (tag: string, expected?: unknown) => R;
+  toBeDefect: () => R;
+};
+declare module "vitest" {
+  interface Matchers<T = any> extends UnthrownMatchers<T> {}
+} //# sourceMappingURL=index.d.ts.map
+//#endregion
+export { UnthrownMatchers, toBeDefect, toBeErr, toBeErrTagged, toBeOk, toBeOkWith };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;iBAsES,MAAA,CAAO,IAAA,EAAM,YAAA,EAAc,QAAA,YAAoB,aAAa;AAAA,iBAc5D,UAAA,CAAW,IAAA,EAAM,YAAA,EAAc,QAAA,WAAmB,QAAA,YAAoB,aAAa;AAAA,iBAenF,OAAA,CAAQ,IAAA,EAAM,YAAA,EAAc,QAAA,YAAoB,aAAa;AAAA,iBAc7D,aAAA,CACP,IAAA,EAAM,YAAA,EACN,QAAA,WACA,GAAA,UACA,QAAA,aACC,aAAa;AAAA,iBAqBP,UAAA,CAAW,IAAA,EAAM,YAAA,EAAc,QAAA,YAAoB,aAAa;;;;;;AArEJ;KA6FzD,gBAAA;EACV,MAAA,QAAc,CAAA;EACd,UAAA,GAAa,KAAA,cAAmB,CAAA;EAChC,OAAA,QAAe,CAAA;EAlFS;;;;;;EAyFxB,aAAA,GAAgB,GAAA,UAAa,QAAA,eAAuB,CAAA;EACpD,UAAA,QAAkB,CAAA;AAAA;AAAA;EAAA,UAKR,QAAA,kBAA0B,gBAAgB,CAAC,CAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,93 @@
+import { isDefect, isErr, isOk } from "unthrown";
+import { expect } from "vitest";
+//#region src/index.ts
+function isThenable(x) {
+	return (typeof x === "object" || typeof x === "function") && x !== null && typeof x.then === "function";
+}
+function isResult(x) {
+	return typeof x?.isOk === "function";
+}
+function render(result, stringify) {
+	if (isOk(result)) return `Ok(${stringify(result.value)})`;
+	if (isErr(result)) return `Err(${stringify(result.error)})`;
+	if (isDefect(result)) return `Defect(${stringify(result.cause)})`;
+	return stringify(result);
+}
+function payloadOf(error) {
+	const out = {};
+	for (const key of Object.keys(error)) if (key !== "_tag" && key !== "name") out[key] = error[key];
+	return out;
+}
+function settle(received, stringify, check) {
+	const run = (value) => isResult(value) ? check(value) : {
+		pass: false,
+		message: () => `expected an unthrown Result, but received ${stringify(value)}`
+	};
+	return isThenable(received) ? Promise.resolve(received).then(run) : run(received);
+}
+function toBeOk(received) {
+	const { stringify } = this.utils;
+	return settle(received, stringify, (result) => {
+		const pass = isOk(result);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be Ok, but it was ${render(result, stringify)}` : `expected result to be Ok, but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeOkWith(received, expected) {
+	const { stringify } = this.utils;
+	const { equals } = this;
+	return settle(received, stringify, (result) => {
+		const pass = isOk(result) && equals(result.value, expected);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be Ok(${stringify(expected)})` : `expected result to be Ok(${stringify(expected)}), but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeErr(received) {
+	const { stringify } = this.utils;
+	return settle(received, stringify, (result) => {
+		const pass = isErr(result);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be Err, but it was ${render(result, stringify)}` : `expected result to be Err, but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeErrTagged(received, tag, expected) {
+	const { stringify } = this.utils;
+	const { equals } = this;
+	const hasExpected = expected !== void 0;
+	const label = hasExpected ? `Err tagged ${stringify(tag)} matching ${stringify(expected)}` : `Err tagged ${stringify(tag)}`;
+	return settle(received, stringify, (result) => {
+		const error = isErr(result) ? result.error : void 0;
+		const pass = error?._tag === tag && (!hasExpected || equals(payloadOf(error), expected));
+		return {
+			pass,
+			message: () => pass ? `expected result not to be ${label}` : `expected result to be ${label}, but got ${render(result, stringify)}`
+		};
+	});
+}
+function toBeDefect(received) {
+	const { stringify } = this.utils;
+	return settle(received, stringify, (result) => {
+		const pass = isDefect(result);
+		return {
+			pass,
+			message: () => pass ? `expected result not to be a Defect, but it was ${render(result, stringify)}` : `expected result to be a Defect, but got ${render(result, stringify)}`
+		};
+	});
+}
+expect.extend({
+	toBeOk,
+	toBeOkWith,
+	toBeErr,
+	toBeErrTagged,
+	toBeDefect
+});
+//#endregion
+export { toBeDefect, toBeErr, toBeErrTagged, toBeOk, toBeOkWith };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["// @unthrown/vitest — custom Vitest matchers for `Result` / `AsyncResult`.\n//\n// Import this module once (e.g. in a test setup file) to register the matchers\n// and pull in the type augmentation:\n//\n//   import \"@unthrown/vitest\";\n//   expect(ok(1)).toBeOk();\n//   await expect(fromSafePromise(p)).toBeOk(); // AsyncResult — `await` REQUIRED\n//\n// IMPORTANT: for an AsyncResult the matcher is asynchronous, so you MUST `await`\n// the assertion. A forgotten `await` makes the assertion pass silently.\n\nimport { isDefect, isErr, isOk, type Result } from \"unthrown\";\nimport { expect } from \"vitest\";\nimport type { MatcherResult, MatcherState } from \"vitest\";\n\ntype SomeResult = Result<unknown, unknown>;\ntype Stringify = (value: unknown) => string;\ntype Outcome = { pass: boolean; message: () => string };\n\nfunction isThenable(x: unknown): x is PromiseLike<unknown> {\n  return (\n    (typeof x === \"object\" || typeof x === \"function\") &&\n    x !== null &&\n    typeof (x as { then?: unknown }).then === \"function\"\n  );\n}\n\nfunction isResult(x: unknown): x is SomeResult {\n  return typeof (x as { isOk?: unknown } | null | undefined)?.isOk === \"function\";\n}\n\nfunction render(result: SomeResult, stringify: Stringify): string {\n  if (isOk(result)) return `Ok(${stringify(result.value)})`;\n  if (isErr(result)) return `Err(${stringify(result.error)})`;\n  if (isDefect(result)) return `Defect(${stringify(result.cause)})`;\n  return stringify(result);\n}\n\n// The \"payload\" of a TaggedError: its own enumerable properties minus the\n// `_tag` discriminant and the `name` (both set by TaggedError itself, not by\n// you). This is the data you passed to the constructor, so `toBeErrTagged`'s\n// optional second argument matches it: a plain object asserts it exactly, and an\n// asymmetric matcher (e.g. `expect.objectContaining(...)`) asserts it partially.\nfunction payloadOf(error: object): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const key of Object.keys(error)) {\n    if (key !== \"_tag\" && key !== \"name\") out[key] = (error as Record<string, unknown>)[key];\n  }\n  return out;\n}\n\n// Resolve `received` — awaiting it when it is an AsyncResult — then run `check`.\n// This is what lets one matcher serve both `expect(result)` and\n// `await expect(asyncResult)`. A non-Result fails with a clear message.\nfunction settle(\n  received: unknown,\n  stringify: Stringify,\n  check: (result: SomeResult) => Outcome,\n): MatcherResult {\n  const run = (value: unknown): Outcome =>\n    isResult(value)\n      ? check(value)\n      : {\n          pass: false,\n          message: () => `expected an unthrown Result, but received ${stringify(value)}`,\n        };\n  return isThenable(received) ? Promise.resolve(received).then(run) : run(received);\n}\n\nfunction toBeOk(this: MatcherState, received: unknown): MatcherResult {\n  const { stringify } = this.utils;\n  return settle(received, stringify, (result) => {\n    const pass = isOk(result);\n    return {\n      pass,\n      message: () =>\n        pass\n          ? `expected result not to be Ok, but it was ${render(result, stringify)}`\n          : `expected result to be Ok, but got ${render(result, stringify)}`,\n    };\n  });\n}\n\nfunction toBeOkWith(this: MatcherState, received: unknown, expected: unknown): MatcherResult {\n  const { stringify } = this.utils;\n  const { equals } = this;\n  return settle(received, stringify, (result) => {\n    const pass = isOk(result) && equals(result.value, expected);\n    return {\n      pass,\n      message: () =>\n        pass\n          ? `expected result not to be Ok(${stringify(expected)})`\n          : `expected result to be Ok(${stringify(expected)}), but got ${render(result, stringify)}`,\n    };\n  });\n}\n\nfunction toBeErr(this: MatcherState, received: unknown): MatcherResult {\n  const { stringify } = this.utils;\n  return settle(received, stringify, (result) => {\n    const pass = isErr(result);\n    return {\n      pass,\n      message: () =>\n        pass\n          ? `expected result not to be Err, but it was ${render(result, stringify)}`\n          : `expected result to be Err, but got ${render(result, stringify)}`,\n    };\n  });\n}\n\nfunction toBeErrTagged(\n  this: MatcherState,\n  received: unknown,\n  tag: string,\n  expected?: unknown,\n): MatcherResult {\n  const { stringify } = this.utils;\n  const { equals } = this;\n  const hasExpected = expected !== undefined;\n  const label = hasExpected\n    ? `Err tagged ${stringify(tag)} matching ${stringify(expected)}`\n    : `Err tagged ${stringify(tag)}`;\n  return settle(received, stringify, (result) => {\n    const error = isErr(result) ? result.error : undefined;\n    const tagPass = (error as { _tag?: unknown } | undefined)?._tag === tag;\n    const pass = tagPass && (!hasExpected || equals(payloadOf(error as object), expected));\n    return {\n      pass,\n      message: () =>\n        pass\n          ? `expected result not to be ${label}`\n          : `expected result to be ${label}, but got ${render(result, stringify)}`,\n    };\n  });\n}\n\nfunction toBeDefect(this: MatcherState, received: unknown): MatcherResult {\n  const { stringify } = this.utils;\n  return settle(received, stringify, (result) => {\n    const pass = isDefect(result);\n    return {\n      pass,\n      message: () =>\n        pass\n          ? `expected result not to be a Defect, but it was ${render(result, stringify)}`\n          : `expected result to be a Defect, but got ${render(result, stringify)}`,\n    };\n  });\n}\n\nexpect.extend({ toBeOk, toBeOkWith, toBeErr, toBeErrTagged, toBeDefect });\n\nexport { toBeDefect, toBeErr, toBeErrTagged, toBeOk, toBeOkWith };\n\n/**\n * The matchers `@unthrown/vitest` contributes to Vitest's `expect`. For an\n * `AsyncResult`, `await` the assertion; `toBeOkWith` compares deeply.\n *\n * @typeParam R - the assertion's chaining return type.\n */\nexport type UnthrownMatchers<R = unknown> = {\n  toBeOk: () => R;\n  toBeOkWith: (value: unknown) => R;\n  toBeErr: () => R;\n  /**\n   * Assert an `Err` whose error has `_tag === tag`. Optionally pass `expected`\n   * to also match the error's payload (its own props minus `_tag`/`name`): a\n   * plain object matches exactly, an asymmetric matcher (e.g.\n   * `expect.objectContaining(...)`) matches partially.\n   */\n  toBeErrTagged: (tag: string, expected?: unknown) => R;\n  toBeDefect: () => R;\n};\n\ndeclare module \"vitest\" {\n  // oxlint-disable-next-line typescript/consistent-type-definitions, typescript/no-explicit-any -- a module augmentation must mirror Vitest's `interface Matchers<T = any>` exactly\n  interface Matchers<T = any> extends UnthrownMatchers<T> {}\n}\n"],"mappings":"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"}

package/docs/index.md

@@ -0,0 +1,149 @@
+**@unthrown/vitest**
+
+***
+
+# @unthrown/vitest
+
+## Type Aliases
+
+### UnthrownMatchers
+
+```ts
+type UnthrownMatchers<R> = object;
+```
+
+Defined in: [index.ts:164](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L164)
+
+The matchers `@unthrown/vitest` contributes to Vitest's `expect`. For an
+`AsyncResult`, `await` the assertion; `toBeOkWith` compares deeply.
+
+#### Type Parameters
+
+| Type Parameter | Default type | Description |
+| ------ | ------ | ------ |
+| `R` | `unknown` | the assertion's chaining return type. |
+
+#### Properties
+
+| Property | Type | Description | Defined in |
+| ------ | ------ | ------ | ------ |
+| <a id="tobedefect"></a> `toBeDefect` | () => `R` | - | [index.ts:175](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L175) |
+| <a id="tobeerr"></a> `toBeErr` | () => `R` | - | [index.ts:167](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L167) |
+| <a id="tobeerrtagged"></a> `toBeErrTagged` | (`tag`, `expected?`) => `R` | Assert an `Err` whose error has `_tag === tag`. Optionally pass `expected` to also match the error's payload (its own props minus `_tag`/`name`): a plain object matches exactly, an asymmetric matcher (e.g. `expect.objectContaining(...)`) matches partially. | [index.ts:174](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L174) |
+| <a id="tobeok"></a> `toBeOk` | () => `R` | - | [index.ts:165](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L165) |
+| <a id="tobeokwith"></a> `toBeOkWith` | (`value`) => `R` | - | [index.ts:166](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L166) |
+
+## Functions
+
+### toBeDefect()
+
+```ts
+function toBeDefect(this, received): ExpectationResult;
+```
+
+Defined in: [index.ts:140](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L140)
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `this` | `MatcherState` |
+| `received` | `unknown` |
+
+#### Returns
+
+`ExpectationResult`
+
+***
+
+### toBeErr()
+
+```ts
+function toBeErr(this, received): ExpectationResult;
+```
+
+Defined in: [index.ts:100](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L100)
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `this` | `MatcherState` |
+| `received` | `unknown` |
+
+#### Returns
+
+`ExpectationResult`
+
+***
+
+### toBeErrTagged()
+
+```ts
+function toBeErrTagged(
+   this, 
+   received, 
+   tag, 
+   expected?): ExpectationResult;
+```
+
+Defined in: [index.ts:114](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L114)
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `this` | `MatcherState` |
+| `received` | `unknown` |
+| `tag` | `string` |
+| `expected?` | `unknown` |
+
+#### Returns
+
+`ExpectationResult`
+
+***
+
+### toBeOk()
+
+```ts
+function toBeOk(this, received): ExpectationResult;
+```
+
+Defined in: [index.ts:71](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L71)
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `this` | `MatcherState` |
+| `received` | `unknown` |
+
+#### Returns
+
+`ExpectationResult`
+
+***
+
+### toBeOkWith()
+
+```ts
+function toBeOkWith(
+   this, 
+   received, 
+   expected): ExpectationResult;
+```
+
+Defined in: [index.ts:85](https://github.com/btravstack/unthrown/blob/4553631adb8280ef7c869dfae5bdb13be762095c/packages/vitest/src/index.ts#L85)
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `this` | `MatcherState` |
+| `received` | `unknown` |
+| `expected` | `unknown` |
+
+#### Returns
+
+`ExpectationResult`

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@unthrown/vitest",
+  "version": "0.1.0",
+  "description": "Vitest matchers for unthrown",
+  "keywords": [
+    "errors-as-values",
+    "matchers",
+    "result",
+    "testing",
+    "typescript",
+    "unthrown",
+    "vitest"
+  ],
+  "homepage": "https://github.com/btravstack/unthrown#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/unthrown/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/unthrown.git",
+    "directory": "packages/vitest"
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "unthrown": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "tsdown": "0.22.2",
+    "typedoc": "0.28.19",
+    "typedoc-plugin-markdown": "4.12.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8",
+    "@unthrown/typedoc": "0.1.0",
+    "@unthrown/tsconfig": "0.1.0"
+  },
+  "peerDependencies": {
+    "vitest": "^4"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}