@systemfsoftware/vitest 0.2.0 → 0.3.0

package/dist/failure.d.ts

@@ -1,8 +1,10 @@
 
-import { a as Values, i as PropertySubject, n as Gens, o as engine_d_exports, r as PropertySpec } from "./engine-YsoQ_9we.js";
-import { S as summaryOf, _ as FailureRecord, b as TestIdentity, g as Breach, h as AttributeValue, i as Checks, t as Asserted, v as FailureRecordInput, x as renderFailureRecord, y as ReplayValue } from "./checks-Cq9of-Lx.js";
-import * as Effect from "effect/Effect";
+import { a as Values, i as PropertySubject, l as Breach, n as Gens, o as engine_d_exports, r as PropertySpec } from "./engine-ZbxyPNiN.js";
+import { i as Checks, t as Asserted } from "./checks-DiuzHhQM.js";
+import * as Cause from "effect/Cause";
+import * as Effect$1 from "effect/Effect";
 import * as Tracer from "effect/Tracer";
+import { Option, Schema } from "effect";
 //#region src/internal/call-site.d.ts
 /** @internal */
 export declare const callFrameOutside: (library: RegExp) => string | undefined;
@@ -14,38 +16,134 @@ export declare const withRaisingFrame: {
   (frame: string | undefined): <A extends Error>(error: A) => A;
 };
 //#endregion
-//#region src/internal/failure-error.d.ts
+//#region src/internal/failure-record.d.ts
+/** A value the renderer narrows rather than assumes. */
+type Opaque<A = unknown> = A;
 /**
- * Renders the record and throws what Vitest prints for it: the record itself when it holds its contract, a
- * `FailureRecordRefused` when it breaks one, and a refusal passed in unchanged, so refusing cannot recurse (R10).
+ * A value a recorded span attribute or a replay path carries. Structured values stay structured on the span
+ * (KTD2); the renderer decides the text.
  *
  * @internal
  */
+type AttributeValue = string | number | boolean | null | ReadonlyArray<AttributeValue> | {
+  readonly [key: string]: AttributeValue;
+};
+/**
+ * The test a failure happened in, as Vitest knows it. `file` is the path the rerun command names, so a caller
+ * that holds an absolute path derives the repo-relative one before handing it over.
+ *
+ * @internal
+ */
+interface TestIdentity {
+  /**
+   * The npm package the test file belongs to, e.g. `@systemfsoftware/effect-readiness`. Empty when the run
+   * provided no name: the rerun command then drops its `pnpm --filter` prefix and runs from the package
+   * directory, which is not a breach (R6).
+   */
+  readonly package: string;
+  /** The test file, as the rerun command writes it. */
+  readonly file: string;
+  /** The scenario name the rerun command filters on with `-t`. */
+  readonly name: string;
+}
+/**
+ * The value a generator chose a run by: the kernel's seed and decision path, or a property counterexample's
+ * seed and path. A path without a seed is a replay value offered for a baseline run, which R6 refuses (KTD5).
+ *
+ * @internal
+ */
+interface ReplayValue {
+  /** The generator's seed, or `undefined` when only a path was recorded. */
+  readonly seed: number | undefined;
+  /** The decisions the generator chose, in order; a decision is the index the scheduler picked (KTD5). */
+  readonly path: ReadonlyArray<number>;
+}
+/**
+ * A contract rule a rendered record breaks; the runner refuses such a record (R10, KTD7).
+ *
+ * @internal
+ */
+/**
+ * What a rendered failure gives Vitest: the tag the error carries, the record text, and the rules it breaks.
+ *
+ * @internal
+ */
+interface FailureRecord {
+  /** The headline's failure tag, e.g. `StepError`; the runner sets it as the thrown error's `name`. */
+  readonly name: string;
+  /** The text Vitest prints as the failure's message. */
+  readonly record: string;
+  /** The contract rules the record breaks: `R1` empty headline, `R2` no location, `R6` replay or rerun. */
+  readonly breaches: ReadonlyArray<Breach>;
+}
+/**
+ * Everything one failure is rendered from: the failure, its run's spans, the test and the replay value.
+ *
+ * @internal
+ */
+interface FailureRecordInput<E = never> {
+  /** The failure itself: a `Cause`, or the value a program threw or failed with. */
+  readonly failure: Cause.Cause<E> | E;
+  /** Every span the failing run recorded, in creation order. */
+  readonly spans: ReadonlyArray<Tracer.NativeSpan>;
+  /** The test the run belonged to. */
+  readonly identity: TestIdentity;
+  /** The generator that chose this run, or `undefined` on a run no generator chose. */
+  readonly replay: ReplayValue | undefined;
+  /**
+   * The seed the kernel's scheduler chose. The kernel knows its own scheduler, so it hands the note over rather
+   * than the renderer guessing it; a run no scheduler chose renders no note (KTD5).
+   */
+  readonly schedule?: {
+    readonly seed: number;
+  } | undefined;
+  /**
+   * The workspace root the rendered paths are relativized against, provided by the shared config the same way the
+   * package name is. Omitted, paths print absolute.
+   */
+  readonly root?: string | undefined;
+}
+/** @internal */
+export declare const summaryOf: (value: Opaque) => string;
+/**
+ * Renders the record Vitest prints for one spec failure, and the contract rules it breaks.
+ *
+ * Never throws: a `Cause` renders layer by layer, a thrown `Error` renders as one layer, and any other value
+ * renders as itself. The first location the record names is the raising frame — the first stack frame outside
+ * `node_modules` and outside the spec libraries' own `src/` and `dist/` — and when no layer has one, the
+ * innermost failed span's site stands in, or the innermost unfinished cell's decide site for a deadlock (KTD6).
+ *
+ * @internal
+ */
+export declare const renderFailureRecord: <E>(input: FailureRecordInput<E>) => FailureRecord;
+/** @internal */
 export declare const throwFailureRecord: <E>(input: FailureRecordInput<E>) => never;
-//#endregion
-//#region src/internal/failure-identity.d.ts
-/** The fields this reads off a Vitest task: every one optional, so a partial context yields an incomplete identity. */
 interface TaskLike {
   readonly name?: string | undefined;
   readonly fullName?: string | undefined;
   readonly fullTestName?: string | undefined;
 }
+/** @internal */
+export declare const testIdentityOf: (task?: TaskLike | null) => TestIdentity;
+//#endregion
+//#region src/internal/provided.schema.d.ts
 /**
- * The identity of the test being run, or of the task handed in. A run outside a test, or one whose task carries
- * no file, yields an incomplete identity, which the renderer reports as the R6 breach it is.
+ * The workspace root every rendered path is relativized against.
  *
  * @internal
  */
-export declare const testIdentityOf: (task?: TaskLike | null) => TestIdentity;
+declare const WorkspaceRoot: Schema.brand<Schema.NonEmptyString, "WorkspaceRoot">;
+/** @internal */
+type WorkspaceRoot = typeof WorkspaceRoot.Type;
 //#endregion
 //#region src/internal/provided.d.ts
 /** @internal */
-declare const providedRoot: () => string | undefined;
+declare const providedRoot: () => WorkspaceRoot | undefined;
 //#endregion
 //#region src/internal/recorded-run.d.ts
 /** @internal */
 interface RecordedRun<A, E> {
-  (checks: Checks): Effect.Effect<A, E, Asserted>;
+  (checks: Checks): Effect$1.Effect<A, E, Asserted>;
 }
 /** @internal */
 interface RecordedProperty<G extends Gens, S extends PropertySubject, N extends number> {
@@ -77,4 +175,30 @@ interface SpanRecorder {
 /** @internal */
 export declare const createSpanRecorder: () => SpanRecorder;
 //#endregion
-export { type AttributeValue, type Breach, type FailureRecord, type FailureRecordInput, type RecordedProperty, type RecordedRun, type ReplayValue, type SpanRecorder, type TestIdentity, providedRoot as providedWorkspaceRoot, renderFailureRecord, summaryOf };
+//#region src/replay.schema.d.ts
+/** The replay a generator chose: its seed and the decisions it took, in order (R6). */
+export declare const Replay: Schema.Struct<{
+  readonly seed: Schema.brand<Schema.Int, "ReplaySeed">;
+  readonly path: Schema.$Array<Schema.brand<Schema.Int, "ReplayStep">>;
+}>;
+/** @since 4.0.0 */
+export type Replay = typeof Replay.Type;
+/**
+ * The `CONFORMANCE_REPLAY` text as the replay it names. A text a seed and a path cannot be read out of is refused
+ * with the same prose the spec runtime has always thrown, so the grammar and its refusal share one home.
+ *
+ * @since 4.0.0
+ */
+export declare const replayOfText: (text: string) => Replay;
+/**
+ * The replay codec: `Schema.String` in, a replay out. A text that names no seed and path fails the decode, and
+ * every replay encodes back to the text it was read from.
+ *
+ * @since 4.0.0
+ */
+export declare const ReplayFromText: Schema.decodeTo<Schema.Struct<{
+  readonly seed: Schema.brand<Schema.Int, "ReplaySeed">;
+  readonly path: Schema.$Array<Schema.brand<Schema.Int, "ReplayStep">>;
+}>, Schema.String, never, never>;
+//#endregion
+export { type AttributeValue, type Breach, type FailureRecord, type FailureRecordInput, type RecordedProperty, type RecordedRun, type ReplayValue, type SpanRecorder, type TestIdentity, providedRoot as providedWorkspaceRoot };

package/dist/failure.mjs

@@ -1,4 +1,4 @@
 
-import { d as summaryOf, l as throwFailureRecord, n as recordOfRun, o as testIdentityOf, r as createSpanRecorder, s as providedRoot, t as recordOfProperty, u as renderFailureRecord } from "./failure-BquJJPFZ.mjs";
-import { c as callFrameOutside, l as callSite, p as withRaisingFrame } from "./test-context-ChvjVyCo.mjs";
-export { callFrameOutside, callSite, createSpanRecorder, providedRoot as providedWorkspaceRoot, recordOfProperty, recordOfRun, renderFailureRecord, summaryOf, testIdentityOf, throwFailureRecord, withRaisingFrame };
+import { _ as ReplayFromText, c as summaryOf, d as providedRoot, g as Replay, l as testIdentityOf, n as recordOfRun, r as createSpanRecorder, s as renderFailureRecord, t as recordOfProperty, u as throwFailureRecord, v as replayOfText } from "./failure-DC_SJoxW.mjs";
+import { c as callFrameOutside, l as callSite, p as withRaisingFrame } from "./test-context-D_-acRSc.mjs";
+export { Replay, ReplayFromText, callFrameOutside, callSite, createSpanRecorder, providedRoot as providedWorkspaceRoot, recordOfProperty, recordOfRun, renderFailureRecord, replayOfText, summaryOf, testIdentityOf, throwFailureRecord, withRaisingFrame };

package/dist/{guard-p_8ARgPm.mjs → guard-BocOhXt2.mjs}

@@ -2,6 +2,16 @@
 import { chai } from "vitest";
 //#region src/internal/refusals.ts
 /**
+* Every refusal the fork prints, as the one text it uses on both channels: the `this` type (or parameter union)
+* the compiler prints at the call site, and the message thrown at run time.
+*
+* Surface: `it(name, function* ({ expect }) { ... })`. Ported verbatim from the prototype's `checks.ts`; the
+* prototype's `test(` surfaces are rewritten to `it(`, and `refusedText` gained the `expect` statics
+* (`.resolves`, `.rejects`, `expect.anything`, `expect.poll`, `expect.soft`).
+*
+* @since 4.0.0
+*/
+/**
 * The brand every run-time refusal carries. A test is run a second time on a fresh build to catch leaked state,
 * so when that second run fails with a refusal the fork itself made, the runner re-throws the refusal rather than
 * relabelling it as a leak (see `throwSecondRun` in `runner.ts`). The brand is a `Symbol.for` value because a
@@ -81,20 +91,6 @@ const refuseHook = "✗ hooks share state between tests. Build what a test needs
 const refuseRawExpect = "✗ an expect imported from vitest ran; take it from the test callback: it(name, function* ({ expect }) { ... })";
 /** @internal */
 const refuseRawIt = "✗ this test was registered with vitest's it; import it from @systemfsoftware/vitest";
-/**
-* The fixed prose each breach of the record contract is refused with (R10, KTD7). A refusal carries this text and
-* nothing from the record itself, and nothing ever reads it back, so a refusal cannot recurse. The breach letter is
-* not printed: a reader acts on what is missing, not on which requirement numbered it.
-*/
-/** @internal */
-const refusedRecordText = {
-	R1: "the headline is empty",
-	R2: "the record names no source location",
-	R6: "a replay value names a run no generator chose, or the rerun line is missing"
-};
-/** The one detail a record refusal carries: every breach the renderer found, in the prose above (R10). */
-/** @internal */
-const refusedRecordDetail = (breaches) => `✗ refused a failure record: ${breaches.map((breach) => refusedRecordText[breach]).join(", and ")}`;
 //#endregion
 //#region src/internal/guard.ts
 /**
@@ -247,4 +243,4 @@ const installGuard = () => {
 	patchExtend();
 };
 //#endregion
-export { unprovidedText as S, refuseScopedLiveLane as _, booleanRefusal as a, refusedRecordDetail as b, negatedText as c, refuseAsyncBody as d, refuseEffectLane as f, refuseScopedLane as g, refuseRawIt as h, markTask as i, noCheckRefusal as l, refusePiecewise as m, installGuard as n, isRefusal as o, refuseHook as p, isMarked as r, neededText as s, authorize as t, refusalOf as u, refuseSyncBody as v, refusedText as x, refuseUnyielded as y };
+export { refuseScopedLiveLane as _, booleanRefusal as a, refusedText as b, negatedText as c, refuseAsyncBody as d, refuseEffectLane as f, refuseScopedLane as g, refuseRawIt as h, markTask as i, noCheckRefusal as l, refusePiecewise as m, installGuard as n, isRefusal as o, refuseHook as p, isMarked as r, neededText as s, authorize as t, refusalOf as u, refuseSyncBody as v, unprovidedText as x, refuseUnyielded as y };

package/dist/guard.mjs

@@ -1,5 +1,5 @@
 
-import { h as refuseRawIt, n as installGuard, r as isMarked, u as refusalOf } from "./guard-p_8ARgPm.mjs";
+import { h as refuseRawIt, n as installGuard, r as isMarked, u as refusalOf } from "./guard-BocOhXt2.mjs";
 import { beforeEach } from "vitest";
 //#region src/guard.ts
 /**

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="./compat.d.ts" />
-import { a as Values$1, c as kinds_d_exports, i as PropertySubject$1, l as __exportAll, n as Gens$1, o as engine_d_exports, r as PropertySpec$1, s as LawApi, t as ArbitraryInput } from "./engine-YsoQ_9we.js";
-import { a as Expect, c as NoCheckRefusal, d as RefuseSyncBody, f as ScopedLaneRefusal, i as Checks, l as RefuseAsyncBody, m as UnprovidedRefusal, o as EffectLaneRefusal, p as ScopedLiveLaneRefusal, r as Check, s as HookRefusal, t as Asserted, u as RefuseEffectBody } from "./checks-Cq9of-Lx.js";
+import { a as Values$1, c as kinds_d_exports, i as PropertySubject$1, n as Gens$1, o as engine_d_exports, r as PropertySpec$1, s as LawApi, t as ArbitraryInput, u as __exportAll } from "./engine-ZbxyPNiN.js";
+import { a as Expect, c as NoCheckRefusal, d as RefuseSyncBody, f as ScopedLaneRefusal, i as Checks, l as RefuseAsyncBody, m as UnprovidedRefusal, o as EffectLaneRefusal, p as ScopedLiveLaneRefusal, r as Check, s as HookRefusal, t as Asserted, u as RefuseEffectBody } from "./checks-DiuzHhQM.js";
 import * as V from "vitest";
 import { afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
 import * as Duration from "effect/Duration";

package/dist/index.mjs

@@ -1,12 +1,13 @@
 
-import { a as replayOfFailure, c as isFailureRecordError, f as InvalidBudget, h as Slop, i as makeProperty, l as throwFailureRecord, m as NonBooleanVerdict, o as testIdentityOf, p as LeakedState, r as createSpanRecorder, s as providedRoot } from "./failure-BquJJPFZ.mjs";
-import { a as isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-ChvjVyCo.mjs";
-import { S as unprovidedText, _ as refuseScopedLiveLane, d as refuseAsyncBody, f as refuseEffectLane, g as refuseScopedLane, i as markTask, l as noCheckRefusal, o as isRefusal$1, p as refuseHook, u as refusalOf$1, v as refuseSyncBody, y as refuseUnyielded } from "./guard-p_8ARgPm.mjs";
+import { a as replayOfFailure, d as providedRoot, f as InvalidBudget, h as Slop, i as makeProperty, l as testIdentityOf, m as NonBooleanVerdict, o as isFailureRecordError, p as LeakedState, r as createSpanRecorder, u as throwFailureRecord } from "./failure-DC_SJoxW.mjs";
+import { a as isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-D_-acRSc.mjs";
+import { _ as refuseScopedLiveLane, d as refuseAsyncBody, f as refuseEffectLane, g as refuseScopedLane, i as markTask, l as noCheckRefusal, o as isRefusal$1, p as refuseHook, u as refusalOf$1, v as refuseSyncBody, x as unprovidedText, y as refuseUnyielded } from "./guard-BocOhXt2.mjs";
 import * as V from "vitest";
 import { afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
 import * as Cause from "effect/Cause";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
@@ -15,7 +16,6 @@ import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as TestClock from "effect/testing/TestClock";
 import * as TestConsole from "effect/testing/TestConsole";
-import * as Equal from "effect/Equal";
 import * as Clock from "effect/Clock";
 import * as Scheduler from "effect/Scheduler";
 //#region src/internal/driver.ts
@@ -84,18 +84,6 @@ const driven = (body, args, ledger) => Effect.provideService(driveBody(body, arg
 */
 const drive = Function.dual(3, driven);
 //#endregion
-//#region src/internal/equal.ts
-let registered = false;
-/** @internal */
-const registerEqualTester = () => {
-	if (registered) return;
-	registered = true;
-	V.expect.addEqualityTesters([equalTester]);
-};
-const equalTester = (first, second) => equalTogether(first, second) ? true : void 0;
-const equalTogether = (first, second) => bothEqualable(first, second) && Equal.equals(first, second);
-const bothEqualable = (first, second) => Equal.isEqual(first) && Equal.isEqual(second);
-//#endregion
 //#region src/internal/virtual-time.ts
 const roundNanos = (millis) => BigInt(Math.round(millis * 1e6));
 const byWakeOrder = (first, second) => {
@@ -280,9 +268,18 @@ const virtualClockOf = (runtime) => {
 * `@systemfsoftware/vitest/guard` can tell the fork's tests from a test registered by Vitest itself.
 */
 const getCurrentSuite = V.TestRunner.getCurrentSuite;
+let equalTestersRegistered = false;
+const equalTester = (first, second) => equalTogether(first, second) ? true : void 0;
+const equalTogether = (first, second) => bothEqualable(first, second) && Equal.equals(first, second);
+const bothEqualable = (first, second) => Equal.isEqual(first) && Equal.isEqual(second);
+const registerEqualTesters = () => {
+	if (equalTestersRegistered) return;
+	equalTestersRegistered = true;
+	V.expect.addEqualityTesters([equalTester]);
+};
 /** @internal */
 const addEqualityTesters$1 = () => {
-	registerEqualTester();
+	registerEqualTesters();
 };
 const numbered = (timeout) => ({ timeout });
 const givenOptions = (timeout) => timeout ?? {};

package/dist/integration.d.ts

@@ -1,5 +1,5 @@
 
-import { a as Expect, n as AssertedShape, r as Check, t as Asserted } from "./checks-Cq9of-Lx.js";
+import { a as Expect, n as AssertedShape, r as Check, t as Asserted } from "./checks-DiuzHhQM.js";
 import * as Effect from "effect/Effect";
 //#region src/integration.d.ts
 /**

package/dist/integration.mjs

@@ -1,5 +1,5 @@
 
-import { r as Asserted, t as VitestTestContext } from "./test-context-ChvjVyCo.mjs";
+import { r as Asserted, t as VitestTestContext } from "./test-context-D_-acRSc.mjs";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 //#region src/integration.ts

package/dist/{test-context-ChvjVyCo.mjs → test-context-D_-acRSc.mjs}

@@ -1,5 +1,5 @@
 
-import { a as booleanRefusal, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf, x as refusedText } from "./guard-p_8ARgPm.mjs";
+import { a as booleanRefusal, b as refusedText, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf } from "./guard-BocOhXt2.mjs";
 import * as V from "vitest";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
@@ -43,7 +43,6 @@ const LIBRARY_DIRS = [
 const isVendoredPath = (path) => path.includes("node_modules") || path.startsWith("node:");
 const inOwnDir = (path) => (dir) => path.includes(`/${dir}/src/`) || path.includes(`/${dir}/dist/`);
 const isLibraryPath = (path) => LIBRARY_DIRS.some(inOwnDir(path));
-/** @internal */
 const isUserPath = (path) => and(not(isVendoredPath(path)), not(isLibraryPath(path)));
 const stripProtocol = (path) => path.startsWith(FILE_PROTOCOL) ? path.slice(7) : path;
 const isFrame = (frame) => frame !== void 0;
@@ -73,17 +72,13 @@ const frameOfLine = (line) => {
 };
 /** @internal */
 const framesOf = (stack) => stack.split("\n").map(frameOfLine).filter(isFrame);
-const frameSiteOf = (frame) => `${frame.path}:${frame.line}:${frame.column}`;
-const isUserFrame = (frame) => isUserPath(frame.path);
-const firstUserFrameOf = (stack) => framesOf(stack).find(isUserFrame);
 /** @internal */
-const firstUserSiteOf = (stack) => {
-	const frame = firstUserFrameOf(stack);
-	return frame === void 0 ? void 0 : frameSiteOf(frame);
-};
+const siteOfFrame = (frame) => `${frame.path}:${frame.line}:${frame.column}`;
+/** @internal */
+const isUserFrame = (frame) => isUserPath(frame.path);
 const NO_LIBRARY = /$^/u;
 const currentStack = () => (/* @__PURE__ */ new Error()).stack ?? "";
-const isSiteOf = (library) => (frame) => and(isUserPath(frame.path), not(library.test(frame.raw)));
+const isSiteOf = (library) => (frame) => and(isUserFrame(frame), not(library.test(frame.raw)));
 const firstFrameOf = (stack, library) => framesOf(stack).find(isSiteOf(library));
 /** @internal */
 const callFrameOutside = (library) => {
@@ -94,7 +89,7 @@ const callFrameOutside = (library) => {
 const callFrame = () => callFrameOutside(NO_LIBRARY);
 const callSiteOutside = (library) => {
 	const frame = firstFrameOf(currentStack(), library);
-	return frame === void 0 ? void 0 : frameSiteOf(frame);
+	return frame === void 0 ? void 0 : siteOfFrame(frame);
 };
 /** @internal */
 const callSite = () => callSiteOutside(NO_LIBRARY);
@@ -325,4 +320,4 @@ const vitestTestContextKey = "@systemfsoftware/vitest/TestContext";
 */
 const VitestTestContext = Context.Reference(vitestTestContextKey, { defaultValue: () => null });
 //#endregion
-export { isCheck as a, callFrameOutside as c, framesOf as d, isUserPath as f, checksFor as i, callSite as l, vitestTestContextKey as n, makeLedger as o, withRaisingFrame as p, Asserted as r, callFrame as s, VitestTestContext as t, firstUserSiteOf as u };
+export { isCheck as a, callFrameOutside as c, isUserFrame as d, siteOfFrame as f, checksFor as i, callSite as l, vitestTestContextKey as n, makeLedger as o, withRaisingFrame as p, Asserted as r, callFrame as s, VitestTestContext as t, framesOf as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -48,7 +48,14 @@
   ],
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/oxlint-config-recommended": "^3.2.0",
+    "@systemfsoftware/oxlint-config-recommended": "^3.3.0",
+    "@systemfsoftware/stryker-config": "^0.1.0",
+    "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "latest",
+    "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "latest",
+    "@systemfsoftware/stryker-js": "latest",
+    "@systemfsoftware/stryker-js-typescript-checker": "latest",
+    "@systemfsoftware/stryker-js-vitest-runner": "latest",
+    "@systemfsoftware/stryker-test-contribution": "latest",
     "@systemfsoftware/tsconfig": "^2.0.1",
     "@systemfsoftware/tsdown-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
@@ -73,6 +80,7 @@
     "build": "tsdown -l warn",
     "typecheck": "tsc -b",
     "test": "vitest run",
+    "mutation": "stryker run",
     "test:types": "TSTYCHE_TYPESCRIPT_MODULE=tstyche-typescript tstyche",
     "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
     "attw": "attw --pack ."