@systemfsoftware/vitest 2.0.0 → 4.1.1

package/dist/index.d.ts

@@ -1,58 +1,17 @@
 /// <reference types="./compat.d.ts" />
-import { A as VacuousProperty, D as ReplayUnreadable, E as PropertyRefuted, N as __exportAll, O as SeedStoreUnreadable, T as NonBooleanVerdict, a as PropertySubject$1, c as LawApi, d as ProvidedCheckDefaults, f as checkDefaultsKey, i as PropertySpec$1, k as SelfModelLaw, l as kinds_d_exports, n as Gens$1, o as Values$1, s as engine_d_exports, t as ArbitraryInput, u as PropertyBudget, w as CoverageBelowMinimum } from "./engine-D7Q6-BxD.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 { A as VacuousProperty, C as NonBooleanVerdict, D as ReplayUnreadable, E as ReplayNoLongerReproduces, O as SeedStoreUnreadable, S as CoverageBelowMinimum, T as PropertyRefuted, a as PropertySubject$1, c as PropertyBudget, i as PropertySpec$1, k as SelfModelLaw, l as ProvidedCheckDefaults, n as Gens$1, o as Values$1, s as LawApi, t as ArbitraryInput, u as checkDefaultsKey, w as PropertyExhausted } from "./engine-CYGdHvr8.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-BHOX6fGC.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";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
-import * as TestConsole from "effect/testing/TestConsole";
+import "effect/testing/TestConsole";
 import * as Context from "effect/Context";
-import * as Clock from "effect/Clock";
-import * as Scheduler from "effect/Scheduler";
-//#region src/internal/virtual-time.d.ts
-/** @internal */
-interface VirtualRuntime {
-  readonly clock: Clock.Clock;
-  readonly scheduler: Scheduler.Scheduler;
-  /** @internal */
-  readonly observe: Effect.Effect<void, never, never>;
-  /** @internal */
-  readonly end: Effect.Effect<void, never, never>;
-}
-declare namespace runner_d_exports {
-  export { BlockRegistrar, LayerOptions$1 as LayerOptions, NestedLayer, RunEnv, addEqualityTesters$1 as addEqualityTesters, afterEach$1 as afterEach, beforeEach$2 as beforeEach, describeWrapped$1 as describeWrapped, flakyTest$1 as flakyTest, hookTimeout, law$1 as law, layer$1 as layer, makeMethods$1 as makeMethods, perRun, prop$1 as prop, realTime, testEnv, testOptions };
-}
-/** @internal */
-declare const addEqualityTesters$1: () => void;
-/** @internal */
-declare const testOptions: (timeout?: number | V.TestOptions) => V.TestOptions;
-/** @internal */
-declare const hookTimeout: (timeout?: Duration.Input) => number | undefined;
-/** @internal */
-interface RunEnv {
-  readonly runtime: VirtualRuntime | undefined;
-  readonly owned: boolean;
-}
-/** @internal */
-declare const realTime: RunEnv;
-/**
- * A run with its own virtual clock: the clock only ever advances when the run's fibers are idle.
- *
- * @internal
- */
-declare const perRun: () => RunEnv;
-/** @internal */
-declare const testEnv: (env: RunEnv) => Layer.Layer<TestConsole.TestConsole, never, never>;
-/** @internal */
-declare const prop$1: Vitest.SyncProperty;
-/**
- * The law kinds over the sync property family: the top-level `it.law`.
- *
- * @internal
- */
-declare const law$1: LawApi;
+import "effect/Clock";
+import "effect/Scheduler";
+//#region src/internal/runner.d.ts
 /**
  * Options for the top-level `layer` and for `it.layer` inside a `Methods` block.
  *
@@ -87,11 +46,6 @@ type NestedLayer = {
   readonly shared?: boolean;
 };
 /** @internal */
-declare const layer$1: {
-  <R, E>(layer_: Layer.Layer<R, E>, options?: LayerOptions$1): BlockRegistrar<R>;
-  <R, E>(options?: LayerOptions$1): (layer_: Layer.Layer<R, E>) => BlockRegistrar<R>;
-};
-/** @internal */
 declare const flakyTest$1: {
   <A, E, R>(self: Effect.Effect<A, E, R | Scope.Scope>, timeout?: Duration.Input): Effect.Effect<A, never, R>;
   (timeout?: Duration.Input): <A, E, R>(self: Effect.Effect<A, E, R | Scope.Scope>) => Effect.Effect<A, never, R>;
@@ -112,21 +66,8 @@ declare const afterEach$1: {
   (this: HookRefusal, fn: AfterEachFirst, timeout?: number): never;
   (this: HookRefusal, timeout?: number): (fn: AfterEachFirst) => never;
 };
-/**
- * The fork's `it`: the generator lanes on virtual time, the real-clock lane, the lawful property lanes and the
- * layer blocks, callable data-first (`it(name, body)`) or data-last (`it(body, timeout?)(name)`).
- *
- * @internal
- */
-declare const makeMethods$1: (it: V.TestAPI) => Vitest.Methods;
-/** @internal */
-declare const describeWrapped$1: {
-  (name: string, f: (it: Vitest.Methods) => void): V.SuiteCollector;
-  (f: (it: Vitest.Methods) => void): (name: string) => V.SuiteCollector;
-};
-declare namespace mod_d_exports {
-  export { Asserted, Check, Checks, CoverageBelowMinimum, Expect, Gate, NonBooleanVerdict, PropertyBudget, PropertyRefuted, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, Vitest, VitestTestContext, addEqualityTesters, afterAll, afterEach, assertType, beforeAll, beforeEach, describe, describeWrapped, expectTypeOf, flakyTest, inject, it, law, layer, makeMethods, onTestFailed, onTestFinished, prop, recordArtifact, test, vi, vitest, vitestTestContextKey };
-}
+//#endregion
+//#region src/mod.d.ts
 declare module 'vitest' {
   interface ProvidedContext {
     [checkDefaultsKey]?: ProvidedCheckDefaults;
@@ -202,6 +143,15 @@ export declare namespace Vitest {
    * @since 4.0.0
    */
   type BodyRefusal = RefuseSyncBody | RefuseAsyncBody | RefuseEffectBody;
+  /**
+   * A registration's options: Vitest's own, plus `rerun` — the body the leak-check second run runs in place of
+   * the registered one. Without it, a clean first run is followed by a second run of the registered body.
+   *
+   * @since 4.0.0
+   */
+  interface TestOptions<Eff, AEff> extends V.TestOptions {
+    readonly rerun?: Body<Eff, AEff>;
+  }
   /**
    * A test lane: `it(name, function* ({ expect }) { ... })`. `R` is what the lane's own environment provides
    * besides the checks — its scope, and the services of the `layer` block it is written in.
@@ -209,8 +159,8 @@ export declare namespace Vitest {
    * @since 4.0.0
    */
   interface Test<R> {
-    <Eff, AEff>(name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>, body: Body<Eff, AEff> | BodyRefusal, timeout?: number | V.TestOptions): void;
-    <Eff, AEff>(body: Body<Eff, AEff> | BodyRefusal, timeout?: number | V.TestOptions): (name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>) => void;
+    <Eff, AEff>(name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>, body: Body<Eff, AEff> | BodyRefusal, timeout?: number | TestOptions<Eff, AEff>): void;
+    <Eff, AEff>(body: Body<Eff, AEff> | BodyRefusal, timeout?: number | TestOptions<Eff, AEff>): (name: NoInfer<Gate<RequirementOf<Eff>, Lane<R>>>) => void;
   }
   /**
    * A row lane: `it.each(rows)(name, function* (row, { expect }) { ... })`.
@@ -488,4 +438,4 @@ export declare const VitestTestContext: Context.Reference<V.TestContext | null>;
  */
 export type Gate<R, Provided = never> = Vitest.Gate<R, Provided>;
 //#endregion
-export { type Asserted, type Check, type Checks, CoverageBelowMinimum, type Expect, NonBooleanVerdict, type PropertyBudget, PropertyRefuted, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest };
+export { type Asserted, type Check, type Checks, CoverageBelowMinimum, type Expect, NonBooleanVerdict, type PropertyBudget, PropertyExhausted, PropertyRefuted, ReplayNoLongerReproduces, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, afterAll, assertType, beforeAll, expectTypeOf, inject, onTestFailed, onTestFinished, recordArtifact, vi, vitest };

package/dist/index.mjs

@@ -1,7 +1,7 @@
 
-import { C as Slop, D as providedCheckDefaults, S as LeakedState, _ as testIdentityOf, a as makeProperty, b as providedRoot, c as NonBooleanVerdict, d as SeedStoreUnreadable, f as SelfModelLaw, i as createSpanRecorder, l as PropertyRefuted, m as isFailureRecordError, o as makeFileLedger, p as VacuousProperty, s as CoverageBelowMinimum, u as ReplayUnreadable, v as throwFailureRecord, x as InvalidBudget } from "./failure-nvq5TwWX.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 { A as providedCheckDefaults, C as providedRoot, E as Slop, T as LeakedState, _ as isFailureRecordError, a as makeProperty, b as testIdentityOf, c as NonBooleanVerdict, d as ReplayNoLongerReproduces, f as ReplayUnreadable, g as drive, h as VacuousProperty, i as createSpanRecorder, l as PropertyExhausted, m as SelfModelLaw, o as makeFileLedger, p as SeedStoreUnreadable, s as CoverageBelowMinimum, u as PropertyRefuted, w as InvalidBudget, x as throwFailureRecord } from "./failure-C67X1OAe.mjs";
+import { i as checksFor, n as vitestTestContextKey$1, o as makeLedger, t as VitestTestContext$1 } from "./test-context-DelFkLBL.mjs";
+import { _ as refuseScopedLiveLane, d as refuseAsyncBody, f as refuseEffectLane, g as refuseScopedLane, i as markTask, o as isRefusal$1, p as refuseHook, u as refusalOf$1, v as refuseSyncBody, x as unprovidedText } from "./guard-Ci0TyBYv.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";
@@ -18,72 +18,6 @@ import * as TestClock from "effect/testing/TestClock";
 import * as TestConsole from "effect/testing/TestConsole";
 import * as Clock from "effect/Clock";
 import * as Scheduler from "effect/Scheduler";
-//#region src/internal/driver.ts
-/**
-* The driver: one Effect that steps the body's generator in the fiber the test runs in.
-*
-* A `yield*` is a step, so the runner sees every one of them (KTD1):
-* - a branded check is judged against this test's ledger, so it counts, and a failed judgement fails the check
-*   itself and stops the test right there (R8);
-* - anything else opens a new observed state and then runs, which is what makes a second check on one state a
-*   second check in one window (R5), and a check inside a loop the same window as its siblings.
-*
-* The steps run in the same fiber as the test, so layers, virtual time, concurrency, the second run and scope
-* finalizers keep working through the runner unchanged. A step that fails, and the test being interrupted, both
-* return the generator: its `finally` blocks run and the steps after it never start (R8). When the body returns,
-* the gate refuses what the body wrote and never judged, then a body that judged nothing at all (R4).
-*/
-/**
-* A value the body yielded, as the driver runs it. What a body needs of its environment belongs to the layer the
-* runner provides around this whole Effect, so the driver erases the channels here, exactly as the runner erases
-* a body's own (`outputIsEffect` in `runner.ts`): the layer block is where a requirement is checked, and a body
-* that needs a service nothing provides is refused by the runner at run time (R9).
-*/
-const isRunnable = (value) => Effect.isEffect(value);
-/** A body that yielded something the driver cannot run ran nothing, so nothing in the test could fail. */
-const refuseUnsteppable = "✗ the body yielded a value that is not an Effect. Yield the Effect itself, or a check: yield* expect(actual).toEqual(expected).";
-/**
-* A yielded Effect: a branded check judges itself, and anything else opens a new observed state before it runs,
-* which is what resets the ledger's one-check window (R5).
-*/
-const runEffect = (value, ledger) => isCheck(value) ? value : Effect.andThen(Effect.sync(() => ledger.asserted.step()), value);
-/** One step: anything the driver cannot run is refused, because then no step of the test ran at all. */
-const runStep = (value, ledger) => isRunnable(value) ? runEffect(value, ledger) : Effect.die(refusalOf$1(refuseUnsteppable));
-/** Steps the iterator to its end, feeding each yielded Effect's result back into the body. */
-const stepThrough = (steps, ledger, input) => Effect.suspend(() => {
-	const state = steps.next(input);
-	if (state.done === true) return Effect.void;
-	return Effect.flatMap(runStep(state.value, ledger), (value) => stepThrough(steps, ledger, value));
-});
-/**
-* After the body returns: a check written and never yielded is refused first, then a body that judged none.
-* Both carry the same text the refusal carries on its compile channel, branded by `refusalOf` so the runner's
-* second run re-throws them as the refusals they are.
-*/
-const gate = (ledger) => Effect.suspend(() => ledger.unyielded() > 0 ? refuse(refuseUnyielded) : judgedNone(ledger));
-const judgedNone = (ledger) => ledger.judged() === 0 ? refuse(noCheckRefusal) : Effect.void;
-const refuse = (text) => Effect.die(refusalOf$1(text));
-/**
-* A failure or an interruption returns the generator, so its `finally` blocks run and the step after the failed
-* check never does (R8).
-*/
-const unwind = (steps) => Effect.sync(() => {
-	steps.return?.(void 0);
-});
-const driveBody = (body, args, ledger) => Effect.suspend(() => {
-	const steps = body(...args);
-	return Effect.onExit(Effect.flatMap(stepThrough(steps, ledger, void 0), () => gate(ledger)), (exit) => Exit.isSuccess(exit) ? Effect.void : unwind(steps));
-});
-/** The body's steps, with this test's ledger provided as the `Asserted` every check in it reaches for. */
-const driven = (body, args, ledger) => Effect.provideService(driveBody(body, args, ledger), Asserted, ledger.asserted);
-/**
-* Runs one test's body: `body` called with `args`, stepped against `ledger`, with the ledger's `asserted`
-* provided as `Asserted` so every check in the body — including one yielded inside a forked fiber — reaches it.
-*
-* @internal
-*/
-const drive = Function.dual(3, driven);
-//#endregion
 //#region src/internal/virtual-time.ts
 const roundNanos = (millis) => BigInt(Math.round(millis * 1e6));
 const byWakeOrder = (first, second) => {
@@ -285,8 +219,15 @@ const numbered = (timeout) => ({ timeout });
 const givenOptions = (timeout) => timeout ?? {};
 /** @internal */
 const testOptions = (timeout) => typeof timeout === "number" ? numbered(timeout) : givenOptions(timeout);
+/** Vitest's own options from a registration's: the fork's `rerun` body never reaches Vitest's registrar. */
+const vitestOptionsOf = (given) => {
+	const { rerun: _rerun, ...options } = given;
+	return options;
+};
+const registrationOptions = (timeout) => typeof timeout === "object" ? vitestOptionsOf(timeout) : testOptions(timeout);
 /** @internal */
 const hookTimeout = (timeout) => timeout === void 0 ? void 0 : Duration.toMillis(Duration.fromInputUnsafe(timeout));
+const rerunOf = (timeout) => typeof timeout === "object" ? timeout.rerun : void 0;
 const isName = (first) => typeof first === "string";
 const byName = (args) => isName(args[0]);
 const byLayer = (args) => Layer.isLayer(args[0]);
@@ -426,6 +367,10 @@ const stepsOfRow = (row, body, checks) => isGeneratorBody(body) ? asSteps(body(r
 const bodyOf = (ledger, body) => () => asSteps(body(checksFor(ledger)));
 /** The body a lane registered, closed over its checks: the generator itself, or the refusal for what it is not. */
 const laneBodyOf = (body) => (checks) => typeof body === "string" ? refuseBody(refuseSyncBody) : stepsOfBody(body, checks);
+const rerunBodyOf = (timeout, registered) => {
+	const rerun = rerunOf(timeout);
+	return rerun === void 0 ? registered : laneBodyOf(rerun);
+};
 /** The row body a lane registered: Vitest's `it.for` order is the row first, then the checks (R9). */
 const rowBodyOf = (row, body) => (checks) => typeof body === "string" ? refuseBody(refuseSyncBody) : stepsOfRow(row, body, checks);
 /** One test's run: a fresh ledger, and the lane's own services around the program the driver built. */
@@ -477,7 +422,7 @@ const propertyLedger = makeFileLedger();
 V.afterAll(() => {
 	const refused = propertyLedger.finalise();
 	if (refused !== void 0) throw new VacuousProperty(refused);
-});
+}, 0);
 const property = makeProperty({
 	register: (name, program) => marked(() => V.it(name, (ctx) => runProperty(ctx, program))),
 	provide: (effect) => effect,
@@ -587,7 +532,7 @@ const freshBlock = (layer_, options) => {
 		excludeTestServices
 	}, void 0);
 	const nestedLayer = Function.dual(byLayer, nestedOpen);
-	const makeIt = (it) => methodsFor((effect, env) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, Layer.orDie(Layer.fresh(withTestEnv(env))))), it, perRun, true, nestedLayer);
+	const makeIt = (it) => methodsFor((effect, env) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, withTestEnv(env).pipe(Layer.fresh, Layer.orDie))), it, perRun, true, nestedLayer);
 	return blockOpener((f) => f(makeIt(V.it)), (name, f) => {
 		V.describe(name, describeOptions(options, false), () => f(makeIt(V.it)));
 	});
@@ -668,13 +613,14 @@ const makeTesterWith = (mapEffect, it, envFor, rerunnable) => {
 	const rerun = (ctx, body) => outcomeOf(runOnce(ctx, body)).then(leakedOrNothing);
 	const shouldRerun = (ctx) => rerunnable && isClean(ctx);
 	const rerunIfClean = (ctx, body) => shouldRerun(ctx) ? rerun(ctx, body) : Promise.resolve();
-	const run = (ctx, body) => outcomeOf(runOnce(ctx, body)).then((error) => {
+	const run = (ctx, body, second) => outcomeOf(runOnce(ctx, body)).then((error) => {
 		if (error !== void 0) throw error;
-		return rerunIfClean(ctx, body);
+		return rerunIfClean(ctx, second);
 	});
 	const registering = (registrar) => (name, body, timeout) => {
 		const lane = laneBodyOf(body);
-		marked(() => registrar(name, testOptions(timeout), (ctx) => run(ctx, lane)));
+		const second = rerunBodyOf(timeout, lane);
+		marked(() => registrar(name, registrationOptions(timeout), (ctx) => run(ctx, lane, second)));
 	};
 	const dualLane = (registrar) => Function.dual(byName, registering(registrar));
 	const base = dualLane(it);
@@ -684,7 +630,10 @@ const makeTesterWith = (mapEffect, it, envFor, rerunnable) => {
 	const only = dualLane(it.only);
 	const fails = dualLane(it.fails);
 	const each = (cases) => (name, body, timeout) => {
-		marked(() => it.for(cases)(name, testOptions(timeout), (row, ctx) => run(ctx, rowBodyOf(row, body))));
+		marked(() => it.for(cases)(name, testOptions(timeout), (row, ctx) => {
+			const lane = rowBodyOf(row, body);
+			return run(ctx, lane, lane);
+		}));
 	};
 	const effectProperty = makeProperty({
 		register: (name, program) => marked(() => it(name, (ctx) => runProperty(ctx, program))),
@@ -851,4 +800,4 @@ const vitestTestContextKey = vitestTestContextKey$1;
 */
 const VitestTestContext = VitestTestContext$1;
 //#endregion
-export { CoverageBelowMinimum, NonBooleanVerdict, PropertyRefuted, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, VitestTestContext, addEqualityTesters, afterAll, afterEach, assertType, beforeAll, beforeEach, describe, describeWrapped, expectTypeOf, flakyTest, inject, it, law, layer, makeMethods, onTestFailed, onTestFinished, prop, recordArtifact, test, vi, vitest, vitestTestContextKey };
+export { CoverageBelowMinimum, NonBooleanVerdict, PropertyExhausted, PropertyRefuted, ReplayNoLongerReproduces, ReplayUnreadable, SeedStoreUnreadable, SelfModelLaw, VacuousProperty, VitestTestContext, addEqualityTesters, afterAll, afterEach, assertType, beforeAll, beforeEach, describe, describeWrapped, expectTypeOf, flakyTest, inject, it, law, layer, makeMethods, onTestFailed, onTestFinished, prop, recordArtifact, test, vi, vitest, vitestTestContextKey };

package/dist/integration.d.ts

@@ -1,5 +1,5 @@
 
-import { a as Expect, n as AssertedShape, r as Check, t as Asserted } from "./checks-DiuzHhQM.js";
+import { a as Expect, n as AssertedShape, r as Check, t as Asserted } from "./checks-BHOX6fGC.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-D_-acRSc.mjs";
+import { r as Asserted, t as VitestTestContext } from "./test-context-DelFkLBL.mjs";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 //#region src/integration.ts

package/dist/property-defaults.d.ts

@@ -0,0 +1,11 @@
+
+import * as Arbitrary from "effect/Arbitrary";
+//#region src/internal/property/tiers.d.ts
+type Env = Readonly<Record<string, string | undefined>>;
+/**
+ * @internal The check options direct `Arbitrary` checks use by default: `{ check: { runs } }` for the tier. A property
+ * test that passes its own `runs` still wins over this default.
+ */
+export declare const propertyTestDefaults: (env: Env) => Arbitrary.GlobalOptions;
+//#endregion
+export {};

package/dist/property-defaults.mjs

@@ -0,0 +1,15 @@
+
+import { t as propertyTestDefaults } from "./tiers-W0BWq1uh.mjs";
+import * as Arbitrary from "effect/Arbitrary";
+//#region src/property-defaults.ts
+/**
+* The setup file that sets the run count of direct `Arbitrary` checks from the environment, published as
+* `@systemfsoftware/vitest/property-defaults` and listed beside the guard in the shared Vitest config's `setupFiles`.
+* The table it reads is `propertyTestDefaults`, re-exported here so a test can supply its own environment record.
+*
+* @since 4.1.0
+*/
+const processEnvironment = () => ({ ...typeof process === "undefined" ? void 0 : process.env });
+Arbitrary.configureGlobal(propertyTestDefaults(processEnvironment()));
+//#endregion
+export { propertyTestDefaults };

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

@@ -1,11 +1,12 @@
 
-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 { a as booleanRefusal, b as refusedText, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf } from "./guard-Ci0TyBYv.mjs";
 import * as V from "vitest";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Schema from "effect/Schema";
 import * as Option from "effect/Option";
 import * as Context from "effect/Context";
+import * as Predicate from "effect/Predicate";
 //#region src/internal/call-site.ts
 /**
 * The one rule that reads a frame out of a stack: which frame a failure is raised from, and which frame an author
@@ -126,10 +127,12 @@ const branded = /* @__PURE__ */ new WeakSet();
 const isObject = (value) => typeof value === "object" && value !== null;
 /** @internal */
 const isCheck = (value) => isObject(value) && branded.has(value);
+const settled = (outcome) => Predicate.isPromiseLike(outcome) ? Effect.asVoid(Effect.promise(() => outcome)) : Effect.void;
 const makeCheck = (judgement, written) => {
 	written(judgement);
 	const check = Effect.gen(function* () {
-		(yield* Asserted).judge(judgement);
+		const asserted = yield* Asserted;
+		yield* settled(asserted.judge(judgement));
 	});
 	branded.add(check);
 	return check;
@@ -176,21 +179,22 @@ const memberAt = (target, property) => Reflect.get(target, property, target);
 const isCallable = (value) => typeof value === "function";
 const invokeMember = (target, property, args) => {
 	const member = memberAt(target, property);
-	if (isCallable(member)) Reflect.apply(member, target, args);
+	return isCallable(member) ? Reflect.apply(member, target, args) : void 0;
 };
 const judgedBy = (view, property, args, make) => {
 	const assertion = make(view.actual, view.message);
 	const target = view.negated ? assertion.not : assertion;
-	invokeMember(target, property, args);
+	return invokeMember(target, property, args);
 };
 const raisedFailure = (thrown, site) => thrown instanceof Error ? withRaisingFrame(thrown, site) : thrown;
+const framedOutcome = (outcome, site) => Predicate.isPromiseLike(outcome) ? outcome.then(void 0, (thrown) => Promise.reject(raisedFailure(thrown, site))) : outcome;
 /**
 * A failed judgement is a failure the fork raised: by now the stack holds only the fork's frames, so the site the
 * body called `expect` from is prepended to the error's stack (R2, KTD6).
 */
 const judgementOf = (view, property, args) => (make) => {
 	try {
-		judgedBy(view, property, args, make);
+		return framedOutcome(judgedBy(view, property, args, make), view.site);
 	} catch (thrown) {
 		throw raisedFailure(thrown, view.site);
 	}
@@ -294,7 +298,7 @@ const makeLedger = (ctx) => {
 				counter.judged += 1;
 				counter.since += 1;
 				if (counter.since > 1) throw refusalOf(refusePiecewise);
-				authorize(() => judgement(hard));
+				return authorize(() => judgement(hard));
 			},
 			step: () => {
 				counter.since = 0;

package/dist/tiers-W0BWq1uh.mjs

@@ -0,0 +1,36 @@
+
+//#region src/internal/property/tiers.ts
+const RUNS = {
+	mutation: 30,
+	ci: 1e3,
+	local: 100
+};
+const CI_OFF_VALUES = [
+	void 0,
+	"",
+	"false",
+	"0"
+];
+const isCi = (env) => env["AGENT"] === void 0 && !CI_OFF_VALUES.includes(env["CI"]);
+const isMutationWorker = (env) => env["STRYKER_MUTATOR_WORKER"] !== void 0;
+const ciOrLocal = (env) => isCi(env) ? "ci" : "local";
+/** @internal A Stryker worker wants fast mutant runs; CI wants the thorough tier; everything else is local. */
+const tierOf = (env) => isMutationWorker(env) ? "mutation" : ciOrLocal(env);
+/**
+* @internal The check options direct `Arbitrary` checks use by default: `{ check: { runs } }` for the tier. A property
+* test that passes its own `runs` still wins over this default.
+*/
+const propertyTestDefaults = (env) => ({ check: { runs: RUNS[tierOf(env)] } });
+/**
+* @internal The property budget a run uses when it provides none: the tier's runs, and no seed-store writes in CI or a
+* Stryker worker, where a checkout is discarded or a mutant run fails on purpose.
+*/
+const providedBudgetOf = (env) => {
+	const tier = tierOf(env);
+	return tier === "local" ? { runs: RUNS.local } : {
+		runs: RUNS[tier],
+		record: false
+	};
+};
+//#endregion
+export { providedBudgetOf as n, propertyTestDefaults as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "2.0.0",
+  "version": "4.1.1",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -37,6 +37,10 @@
       "types": "./dist/integration.d.ts",
       "default": "./dist/integration.mjs"
     },
+    "./property-defaults": {
+      "types": "./dist/property-defaults.d.ts",
+      "default": "./dist/property-defaults.mjs"
+    },
     "./TestClock": {
       "types": "./dist/TestClock.d.ts",
       "default": "./dist/TestClock.mjs"
@@ -47,32 +51,25 @@
     "dist"
   ],
   "dependencies": {
-    "@effect/platform-node": "^4"
+    "@effect/platform-node": "^4.1.2"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/oxlint-config-recommended": "^4.0.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",
-    "@types/node": "^26",
-    "effect": "^4",
-    "oxlint": "~1.82.0",
+    "@systemfsoftware/oxlint-config-recommended": "^6.0.1",
+    "@systemfsoftware/tsconfig": "^2.1.0",
+    "@systemfsoftware/tsdown-config": "^0.1.2",
+    "@systemfsoftware/vitest-config": "^0.1.3",
+    "@types/node": "^26.6.5",
+    "effect": "^4.1.2",
+    "oxlint": "~1.89.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "tstyche": "^7.2.5",
-    "vitest": "^5"
+    "vitest": "^5.1.0"
   },
   "peerDependencies": {
-    "effect": "^4",
-    "vitest": "^5"
+    "effect": "^4.1.2",
+    "vitest": "^5.1.0"
   },
   "publishConfig": {
     "access": "public",
@@ -83,7 +80,6 @@
     "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 ."