@systemfsoftware/vitest 1.0.0 → 4.1.1

package/dist/failure.d.ts

@@ -1,7 +1,6 @@
 
-import { a as Values, i as PropertySubject, l as Breach, n as Gens, o as engine_d_exports, r as PropertySpec } from "./engine-CMvYG5V0.js";
-import { i as Checks, t as Asserted } from "./checks-DiuzHhQM.js";
-import * as Cause from "effect/Cause";
+import { A as VacuousProperty, M as Breach, _ as renderFailureRecord, a as PropertySubject, b as throwFailureRecord, d as AttributeValue, f as FailureRecord, g as TestIdentity, h as ReplayValue, i as PropertySpec, j as Witness, l as ProvidedCheckDefaults, m as JsonValue, n as Gens, o as Values, p as FailureRecordInput, r as PropApi, v as summaryOf, x as witnessOf, y as testIdentityOf } from "./engine-CYGdHvr8.js";
+import { i as Checks, t as Asserted } from "./checks-BHOX6fGC.js";
 import * as Effect$1 from "effect/Effect";
 import * as Tracer from "effect/Tracer";
 import { Option, Schema } from "effect";
@@ -16,116 +15,6 @@ export declare const withRaisingFrame: {
   (frame: string | undefined): <A extends Error>(error: A) => A;
 };
 //#endregion
-//#region src/internal/failure-record.d.ts
-/** A value the renderer narrows rather than assumes. */
-type Opaque<A = unknown> = A;
-/**
- * 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;
-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 workspace root every rendered path is relativized against.
@@ -150,6 +39,10 @@ interface RecordedProperty<G extends Gens, S extends PropertySubject, N extends
   readonly name: string;
   readonly spec: PropertySpec<G, S, N>;
   readonly holds: (subject: S, values: Values<G>) => boolean;
+  /** The provided budget the run supplies in place of the configured default, e.g. a derandomizing `seed`. */
+  readonly budget?: ProvidedCheckDefaults | undefined;
+  /** The path of the test file whose seed store to read and write; absent, the run keeps no store. */
+  readonly store?: string | undefined;
 }
 /**
  * Runs one program as the runner runs a lane, with a fresh ledger and its own recorder, and resolves with the
@@ -158,6 +51,11 @@ interface RecordedProperty<G extends Gens, S extends PropertySubject, N extends
  * @internal
  */
 export declare const recordOfRun: <A, E>(program: RecordedRun<A, E>) => Promise<FailureRecord | undefined>;
+/** @internal */
+interface RecordedFile {
+  readonly records: ReadonlyArray<FailureRecord | undefined>;
+  readonly vacuous: VacuousProperty | undefined;
+}
 /**
  * Runs one property the way the runner runs `it.prop`, with a fresh ledger and its own recorder, and resolves with
  * the record its falsification rendered — or `undefined` when it held.
@@ -165,6 +63,21 @@ export declare const recordOfRun: <A, E>(program: RecordedRun<A, E>) => Promise<
  * @internal
  */
 export declare const recordOfProperty: <const G extends Gens, S extends PropertySubject, N extends number>(input: RecordedProperty<G, S, N>) => Promise<FailureRecord | undefined>;
+interface RecordedFileOptions {
+  readonly budget?: ProvidedCheckDefaults | undefined;
+  readonly store?: string | undefined;
+}
+/**
+ * Runs every property and law a file registers, in registration order, then finalises the file's one ledger:
+ * resolves with each property's rendered failure and the file's single vacuous verdict, or `undefined` when the
+ * file holds. The name a property is recorded under is the name it was registered with.
+ *
+ * @internal
+ */
+export declare const recordOfFile: {
+  (register: (api: PropApi<never>) => void, options?: RecordedFileOptions): Promise<RecordedFile>;
+  (options?: RecordedFileOptions): (register: (api: PropApi<never>) => void) => Promise<RecordedFile>;
+};
 //#endregion
 //#region src/internal/span-recorder.d.ts
 /** @internal */
@@ -191,8 +104,8 @@ export type Replay = typeof Replay.Type;
  */
 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.
+ * The kernel's 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
  */
@@ -201,4 +114,4 @@ export declare const ReplayFromText: Schema.decodeTo<Schema.Struct<{
   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 };
+export { type AttributeValue, type Breach, type FailureRecord, type FailureRecordInput, type JsonValue, type RecordedFile, type RecordedProperty, type RecordedRun, type ReplayValue, type SpanRecorder, type TestIdentity, type Witness, providedRoot as providedWorkspaceRoot, renderFailureRecord, summaryOf, testIdentityOf, throwFailureRecord, witnessOf };

package/dist/failure.mjs

@@ -1,4 +1,4 @@
 
-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-D8mPXwf4.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 };
+import { C as providedRoot, D as Replay, O as ReplayFromText, S as witnessOf, b as testIdentityOf, i as createSpanRecorder, k as replayOfText, n as recordOfProperty, r as recordOfRun, t as recordOfFile, v as renderFailureRecord, x as throwFailureRecord, y as summaryOf } from "./failure-C67X1OAe.mjs";
+import { c as callFrameOutside, l as callSite, p as withRaisingFrame } from "./test-context-DelFkLBL.mjs";
+export { Replay, ReplayFromText, callFrameOutside, callSite, createSpanRecorder, providedRoot as providedWorkspaceRoot, recordOfFile, recordOfProperty, recordOfRun, renderFailureRecord, replayOfText, summaryOf, testIdentityOf, throwFailureRecord, withRaisingFrame, witnessOf };

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

@@ -1,5 +1,6 @@
 
 import { chai } from "vitest";
+import * as Predicate from "effect/Predicate";
 //#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)
@@ -108,9 +109,13 @@ const refuseRawIt = "✗ this test was registered with vitest's it; import it fr
 *   `new Assertion(...)` on the same class (`chai/index.js:3367`, `:3394`).
 *
 * So this module wraps that prototype once, and every method, chainable method and property on it refuses
-* unless a check opened the window with {@link authorize} for the duration of its matcher call. Nothing
-* asynchronous may run inside that window, so a plain synchronous depth counter is enough; the counter is
-* nested-safe because chai's own matchers build further assertions inside the one call.
+* unless a check opened the window with {@link authorize} for the duration of its matcher call. A matcher that
+* returns a promise keeps its window open until that promise settles, so an async matcher such as
+* `toMatchScreenshot` can build chai assertions after it awaits. Each call closes exactly the window it opened,
+* so the depth counter stays nested-safe: chai's own matchers build further assertions inside the one call.
+* The counter is global to the worker, not scoped to the test that opened it: while an async matcher is
+* pending, a raw `expect` from a concurrently running test in the same worker is let through too. Once the
+* promise settles the window closes and a raw `expect` is refused again.
 *
 * The window, the install flag and the wrapper marks live on `globalThis` under `Symbol.for` keys rather than
 * in module scope. A worker can hold two copies of this file at once — the setup file resolves through Node's
@@ -151,13 +156,20 @@ const authorized = () => state.depth > 0;
 const refuse = () => {
 	throw refusalOf(refuseRawExpect);
 };
+const close = () => {
+	state.depth -= 1;
+};
+const closeWhenSettled = (outcome) => Predicate.isPromiseLike(outcome) ? void Promise.resolve(outcome).then(close, close) : close();
 /** @internal */
 const authorize = (run) => {
 	state.depth += 1;
 	try {
-		return run();
-	} finally {
-		state.depth -= 1;
+		const outcome = run();
+		closeWhenSettled(outcome);
+		return outcome;
+	} catch (failure) {
+		close();
+		throw failure;
 	}
 };
 /** @internal */

package/dist/guard.mjs

@@ -1,5 +1,5 @@
 
-import { h as refuseRawIt, n as installGuard, r as isMarked, u as refusalOf } from "./guard-BocOhXt2.mjs";
+import { h as refuseRawIt, n as installGuard, r as isMarked, u as refusalOf } from "./guard-Ci0TyBYv.mjs";
 import { beforeEach } from "vitest";
 //#region src/guard.ts
 /**
@@ -14,6 +14,6 @@ import { beforeEach } from "vitest";
 installGuard();
 beforeEach((context) => {
 	if (!isMarked(context.task)) throw refusalOf(refuseRawIt);
-});
+}, 0);
 //#endregion
 export {};

package/dist/index.d.ts

@@ -1,65 +1,17 @@
 /// <reference types="./compat.d.ts" />
-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-CMvYG5V0.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 Arbitrary from "effect/Arbitrary";
-import * as Clock from "effect/Clock";
-import * as Scheduler from "effect/Scheduler";
-//#region src/internal/property/defaults.d.ts
-/** @internal The `test.provide` key the shared config fills with this run's tier's check options. */
-declare const checkDefaultsKey = "@systemfsoftware/vitest:property-check";
-/** @internal The check options a run supplies as its property default, minus `replay`. */
-type ProvidedCheckDefaults = Omit<Arbitrary.CheckOptions, 'replay'>;
-//#endregion
-//#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.
  *
@@ -94,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>;
@@ -119,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, Expect, Gate, 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;
@@ -209,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.
@@ -216,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 }) { ... })`.
@@ -495,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, type Expect, 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 { 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-D8mPXwf4.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]);
@@ -374,7 +315,7 @@ const throwRecorded = (cause, recorder, ctx) => {
 		failure,
 		spans: recorder.spans,
 		identity: testIdentityOf(ctx.task),
-		replay: replayOfFailure(failure),
+		replay: void 0,
 		root: providedRoot()
 	});
 };
@@ -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. */
@@ -462,14 +407,26 @@ const NO_ERRORS = [];
 const presentErrors = (errors) => errors === void 0 ? NO_ERRORS : errors;
 /** Whether a run left no failure behind: only a clean first run is worth running a second time. */
 const isClean = (ctx) => presentErrors(ctx.task.result?.errors).length === 0;
+const propertyTaskOf = (ctx) => ({
+	identity: testIdentityOf(ctx.task),
+	filepath: ctx.task.file.filepath,
+	budget: providedCheckDefaults()
+});
 /**
 * Runs a property's program as the test that registered it, under the same context the generator lanes use. The
 * env is the bare `propertyEnv`: a `false` verdict is the property's own shrink path, so nothing interrupts it.
 */
-const runProperty = (ctx, program) => runRecorded(bindRun(Effect.suspend(program), ctx), ctx, propertyEnv);
+const runProperty = (ctx, program) => runRecorded(bindRun(Effect.suspend(() => program(propertyTaskOf(ctx))), ctx), ctx, propertyEnv);
+/** The sync and effect property lanes of one test file share this ledger; it is judged once, at file end (R20). */
+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
+	provide: (effect) => effect,
+	ledger: propertyLedger
 });
 const propImpl = (name, spec, holds) => {
 	refusePositional(spec);
@@ -575,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)));
 	});
@@ -656,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);
@@ -672,11 +630,15 @@ 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))),
-		provide: (effect) => mapEffect(effect, envFor())
+		provide: (effect) => mapEffect(effect, envFor()),
+		ledger: propertyLedger
 	});
 	const prop = (name, spec, holds) => {
 		refusePositional(spec);
@@ -838,4 +800,4 @@ const vitestTestContextKey = vitestTestContextKey$1;
 */
 const VitestTestContext = VitestTestContext$1;
 //#endregion
-export { 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 };