@systemfsoftware/vitest 2.0.0 → 4.1.2

package/dist/{failure-nvq5TwWX.mjs → failure-B094O43o.mjs}

@@ -1,5 +1,7 @@
 
-import { d as isUserFrame, f as siteOfFrame, i as checksFor, o as makeLedger, p as withRaisingFrame, r as Asserted, s as callFrame, t as VitestTestContext, u as framesOf$1 } from "./test-context-D_-acRSc.mjs";
+import { n as providedBudgetOf } from "./tiers-W0BWq1uh.mjs";
+import { a as isCheck, d as isUserFrame, f as siteOfFrame, i as checksFor, o as makeLedger, p as withRaisingFrame, r as Asserted, s as callFrame, t as VitestTestContext, u as framesOf$1 } from "./test-context-DelFkLBL.mjs";
+import { l as noCheckRefusal, u as refusalOf, y as refuseUnyielded } from "./guard-Ci0TyBYv.mjs";
 import { TestRunner, inject } from "vitest";
 import * as Cause from "effect/Cause";
 import * as Effect$1 from "effect/Effect";
@@ -12,8 +14,7 @@ import * as Option$1 from "effect/Option";
 import * as Match$1 from "effect/Match";
 import * as Tracer from "effect/Tracer";
 import { Effect, Match, Option, Schema, SchemaGetter, SchemaIssue } from "effect";
-import { layer } from "@effect/platform-node/NodeFileSystem";
-import { layer as layer$1 } from "@effect/platform-node/NodePath";
+import * as Predicate from "effect/Predicate";
 import * as Arbitrary from "effect/Arbitrary";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -25,8 +26,12 @@ import * as Path from "effect/Path";
 //#region src/internal/property/defaults.ts
 /** @internal The `test.provide` key the shared config fills with this run's tier's check options. */
 const checkDefaultsKey = "@systemfsoftware/vitest:property-check";
-/** @internal The configured property-check defaults, or `undefined` when the run provided none. */
-const providedCheckDefaults = () => inject(checkDefaultsKey);
+const processEnvironment = () => ({ ...typeof process === "undefined" ? void 0 : process.env });
+/**
+* @internal The property-check defaults a run provided through `test.provide`, else the tier's budget for this
+* process's environment, read from the same table the setup entry uses.
+*/
+const providedCheckDefaults = () => inject("@systemfsoftware/vitest:property-check") ?? providedBudgetOf(processEnvironment());
 //#endregion
 //#region src/replay.schema.ts
 /**
@@ -40,15 +45,15 @@ const providedCheckDefaults = () => inject(checkDefaultsKey);
 *   refuted run, so the engine rebuilds the generator's replay token. Several entries are joined by `|`, which no
 *   entry can contain: every key is lowercase letters and every value is digits, commas or a failure tag.
 *
-* A text that names neither form is not a replay. The seed and every decision are branded whole numbers
-* (CONST-D3), and the text is a codec rooted at `Schema.String`, so one declaration serves both the writer and the
+* A text that names neither form is not a replay. The seed and every decision are branded whole numbers, and
+* the text is a codec rooted at `Schema.String`, so one declaration serves both the writer and the
 * reader instead of a pattern each.
 *
 * @since 4.0.0
 */
-/** The seed a replay names: the whole number a generator chose, never negative (CONST-D3). */
+/** The seed a replay names: the whole number a generator chose, never negative (CONST-D1). */
 const ReplaySeed = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ReplaySeed"));
-/** One decision along a replay path: the index the scheduler picked at that step (CONST-D3). */
+/** One decision along a replay path: the index the scheduler picked at that step. */
 const ReplayStep = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ReplayStep"));
 /** The replay a generator chose: its seed and the decisions it took, in order (R6). */
 const Replay = Schema.Struct({
@@ -57,7 +62,7 @@ const Replay = Schema.Struct({
 });
 /** A property's identity hash: the unsigned whole number `identityHash` derives from its identity (KTD4). */
 const PropertyHash = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("PropertyHash"));
-/** The count of runs a property entry names, never negative (CONST-D3). */
+/** The count of runs a property entry names, never negative (CONST-D1). */
 const ReplayRunCount = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ReplayRunCount"));
 /** The failure kind effect's falsification runner records in its replay token. */
 const ReplayFailureTag = Schema.Literals(["ReturnedFalse", "PropertyError"]);
@@ -317,7 +322,7 @@ const WorkspaceRoot = Schema.NonEmptyString.pipe(Schema.brand("WorkspaceRoot"));
 * line then drops its package filter, and paths print absolute (R6, KTD5).
 *
 * The values are branded (`provided.schema.ts`): a package name and a workspace root are not interchangeable
-* text (CONST-D3).
+* text.
 *
 * @since 4.0.0
 */
@@ -832,11 +837,13 @@ const copyDiffFields = (error, failure) => {
 */
 const PROPERTY_FAILURE_TAGS = [
 	"PropertyRefuted",
+	"PropertyExhausted",
 	"NonBooleanVerdict",
 	"CoverageBelowMinimum",
 	"SelfModelLaw",
 	"SeedStoreUnreadable",
 	"ReplayUnreadable",
+	"ReplayNoLongerReproduces",
 	"VacuousProperty"
 ];
 const isPropertyFailureLayer = (value) => {
@@ -911,6 +918,74 @@ const currentTask = () => TestRunner.getCurrentTest() ?? {};
 /** @internal */
 const testIdentityOf = (task) => identityOf(task ?? currentTask());
 //#endregion
+//#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$1.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$1.andThen(Effect$1.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$1.die(refusalOf(refuseUnsteppable));
+/** Steps the iterator to its end, feeding each yielded Effect's result back into the body. */
+const stepThrough = (steps, ledger, input) => Effect$1.suspend(() => {
+	const state = steps.next(input);
+	if (state.done === true) return Effect$1.void;
+	return Effect$1.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$1.andThen(refusingUnyielded(ledger), judgedNone(ledger));
+/** @internal */
+const refusingUnyielded = (ledger) => Effect$1.suspend(() => ledger.unyielded() > 0 ? refuse(refuseUnyielded) : Effect$1.void);
+const judgedNone = (ledger) => Effect$1.suspend(() => ledger.judged() === 0 ? refuse(noCheckRefusal) : Effect$1.void);
+const refuse = (text) => Effect$1.die(refusalOf(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$1.sync(() => {
+	steps.return?.(void 0);
+});
+const driveBody = (body, args, ledger) => Effect$1.suspend(() => {
+	const steps = body(...args);
+	return Effect$1.onError(Effect$1.flatMap(stepThrough(steps, ledger, void 0), () => gate(ledger)), () => 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$1.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/property/coverage.ts
 /**
 * @internal The R14 coverage classes: labelled input predicates, each with a minimum share of runs.
@@ -1020,7 +1095,7 @@ const judgeCoverage = (options) => failedFailures(toppedUp(judgeOf(options.class
 //#region src/internal/property/error.schema.ts
 /**
 * The closed set of property-channel failures (KTD1, R1): refuted, non-boolean, under-covered and self-model, plus
-* the vacuous impostor verdict and the seed store's read failure. Every variant is a `Schema.TaggedError` carrying
+* the vacuous impostor verdict, the seed store's read failure and a stale explicit replay. Every variant is a `Schema.TaggedError` carrying
 * its own data — the property it names, a rendered-and-projected witness, coverage classes, the law that refused
 * itself — and a zero-argument `message` getter computed only from those fields. Wording is free; nothing reads a
 * message back.
@@ -1028,13 +1103,13 @@ const judgeCoverage = (options) => failedFailures(toppedUp(judgeOf(options.class
 * @since 4.0.0
 */
 /**
-* A property's seed: a whole number a generator chose, never negative (CONST-D3).
+* A property's seed: a whole number a generator chose, never negative (CONST-D1).
 *
 * @internal
 */
 const PropertySeed = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("PropertySeed"));
 /**
-* The count of runs a property's check was configured with, never negative (CONST-D3).
+* The count of runs a property's check was configured with, never negative (CONST-D1).
 *
 * @internal
 */
@@ -1093,6 +1168,21 @@ var PropertyRefuted = class extends Schema.TaggedError()("PropertyRefuted", {
 		return `${this.property.name}: the property was falsified within ${String(this.property.runs)} run(s), and ${String(this.shrinks)} shrink(s) settled on its input. Shrunk input: ${this.counterexample.rendered}`;
 	}
 };
+/** @internal */
+var PropertyExhausted = class extends Schema.TaggedError()("PropertyExhausted", {
+	property: PropertyRun,
+	discards: PropertyRunCount,
+	budget: Schema.Struct({
+		runs: PropertyRunCount,
+		maxDiscards: Schema.NullOr(PropertyRunCount)
+	}),
+	replay: Schema.String
+}) {
+	get message() {
+		const cap = this.budget.maxDiscards === null ? "no configured discard cap" : `a discard cap of ${String(this.budget.maxDiscards)}`;
+		return `${this.property.name}: the generator discarded ${String(this.discards)} draw(s) under ${cap} within ${String(this.budget.runs)} run(s), so the property was never evaluated. Narrow the generator so it draws admissible values, or raise \`maxDiscards\`.`;
+	}
+};
 /**
 * A verdict that was not a literal boolean: the property that ran, the first drawn values whose verdict was not a
 * boolean, and every kind of value the property returned (R4).
@@ -1142,11 +1232,11 @@ var CoverageBelowMinimum = class extends Schema.TaggedError()("CoverageBelowMini
 * @internal
 */
 var SelfModelLaw = class extends Schema.TaggedError()("SelfModelLaw", {
-	name: Schema.String,
+	law: Schema.String,
 	site: Schema.NullOr(Schema.String)
 }) {
 	get message() {
-		return `${this.name}: the model is the subject itself; a model law must compare against an independent oracle.`;
+		return `${this.law}: the model is the subject itself; a model law must compare against an independent oracle.`;
 	}
 };
 /**
@@ -1242,6 +1332,21 @@ var ReplayUnreadable = class extends Schema.TaggedError()("ReplayUnreadable", {
 	}
 };
 /**
+* An explicit `CONFORMANCE_REPLAY` replay whose recorded failure no longer reproduces: after the root re-check,
+* the replay still mismatched, so no draw reproduces the failure the text names. The recorded seed-store path is
+* not this — there the entry is one candidate among the novel draws, and only a draw that still fails refutes.
+*
+* @internal
+*/
+var ReplayNoLongerReproduces = class extends Schema.TaggedError()("ReplayNoLongerReproduces", {
+	property: PropertyRun,
+	replay: Schema.String
+}) {
+	get message() {
+		return `${this.property.name}: the CONFORMANCE_REPLAY replay ${this.replay} no longer reproduces a failure for this property; the case it named is gone or its generator changed.`;
+	}
+};
+/**
 * Thrown when a law kind is given a record `of`, which cannot be spread into its subject.
 *
 * @internal
@@ -1271,15 +1376,6 @@ const ReplayToken = Schema$1.fromJsonString(Schema$1.Tuple([
 ]));
 //#endregion
 //#region src/internal/property/replay.ts
-/**
-* The property replay channel (KTD5, R9-R12): the text a property failure carries, the generator replay token a
-* refuted entry rebuilds, and the entry the engine selects for a property's identity hash.
-*
-* The token `effect`'s falsification runner writes is decoded here through its codec — never hand-parsed — into the
-* parts a refuted entry names, and rebuilt from them the way `makeReplay` reads them back.
-*
-* @since 4.0.0
-*/
 const NUMERIC_SEED = 0;
 /** @internal */
 const tokenOfReplay = (entry) => JSON.stringify([
@@ -1290,6 +1386,27 @@ const tokenOfReplay = (entry) => JSON.stringify([
 	entry.path,
 	entry.failure
 ]);
+const FAILURE_CLASSES = {
+	ReturnedFalse: true,
+	PropertyError: true
+};
+/**
+* The tokens that replay only the root draw of `token`, one per failure class: the recorded attempt with an empty
+* shrink path. Empty for an absent or unreadable token.
+*
+* @internal
+*/
+const rootTokensOf = (token) => Option$1.match(Option$1.flatMap(Option$1.fromNullishOr(token), Schema$1.decodeOption(ReplayToken)), {
+	onNone: () => [],
+	onSome: (decoded) => Object.keys(FAILURE_CLASSES).map((failure) => JSON.stringify([
+		decoded[0],
+		`${decoded[1]}`,
+		decoded[2],
+		decoded[3],
+		[],
+		failure
+	]))
+});
 /** @internal */
 const refutedReplayTextOf = (identity) => Option$1.getOrUndefined(Option$1.map(Schema$1.decodeOption(ReplayToken)(identity.token), (decoded) => refutedReplayText$1({
 	property: identity.property,
@@ -1757,14 +1874,30 @@ const verdictFor = (run, values, violations) => {
 };
 const tolerateInterruption = (cause) => Cause.hasInterrupts(cause) ? Effect$1.interrupt : Effect$1.fail(cause);
 const guardedVerdict = (run, violations) => (values) => Effect$1.catchCause(Effect$1.suspend(() => verdictFor(run, values, violations)), tolerateInterruption);
+const checkWith = (run, violations, options) => Arbitrary.checkEffect(run.arbitrary, guardedVerdict(run, violations), options);
+const isFalsified = Predicate.isTagged("Falsified");
+const isReplayMismatch = Predicate.isTagged("ReplayMismatch");
+/**
+* A replayed draw whose recorded shrink path no longer replays (`ReplayMismatch`) is re-checked at its root under
+* each failure class, so a root that still falsifies the property refutes it with the root as its counterexample.
+* The classes are tried in order and the check stops at the first that falsifies; when none does, the mismatch
+* stands: the recorded failure no longer reproduces.
+*/
+const rootCheckOf = (run, mismatch) => rootTokensOf(run.options.replay).reduce((previous, replay) => Effect$1.filterOrElse(previous, (found) => isFalsified(found), () => checkWith({
+	...run,
+	observe: noObserve
+}, newViolations(), {
+	...run.options,
+	replay
+})), Effect$1.succeed(mismatch));
 const runCheck = (run) => {
 	const violations = newViolations();
-	return Arbitrary.checkEffect(run.arbitrary, guardedVerdict(run, violations), run.options).pipe(Effect$1.map((result) => ({
+	return checkWith(run, violations, run.options).pipe(Effect$1.filterOrElse((result) => !isReplayMismatch(result), (mismatch) => rootCheckOf(run, mismatch)), Effect$1.map((result) => ({
 		violations,
 		result
 	})));
 };
-const reportOf = (checked) => Arbitrary.formatCheckFailure(checked.result);
+const reportOf = (checked) => isReplayMismatch(checked.result) ? void 0 : Arbitrary.formatCheckFailure(checked.result);
 const seeded = (seed) => Option$1.getOrThrow(Schema$1.decodeOption(PropertySeed)(seed));
 const runCounted = (runs) => Option$1.getOrThrow(Schema$1.decodeOption(PropertyRunCount)(runs));
 const propertyRunOf = (run, budget) => ({
@@ -1829,20 +1962,23 @@ const violationOf = (run, budget, checked) => checked.violations.kinds.length ==
 const isRefuted = (checked) => checked.violations.kinds.length > 0 || reportOf(checked) !== void 0;
 const dieWithSite = (error, site) => Effect$1.die(withRaisingFrame(error, site));
 const shrinkCounted = (shrinks) => Option$1.getOrThrow(Schema$1.decodeOption(PropertyShrinkCount)(shrinks));
-const NO_FALSIFICATION = {
-	counterexample: witnessOf(void 0),
-	shrinks: shrinkCounted(0)
-};
-const falsificationOf = (falsified) => falsified === void 0 ? NO_FALSIFICATION : {
-	counterexample: witnessOf(falsified.shrunkInput),
-	shrinks: shrinkCounted(falsified.shrinks)
-};
-const refutedOf = (property, checked, replay) => new PropertyRefuted({
+const countOrNull = (value) => Option$1.getOrNull(Option$1.flatMap(Option$1.fromUndefinedOr(value), (count) => Schema$1.decodeOption(PropertyRunCount)(count)));
+const refutedOf = (property, falsified, replay) => new PropertyRefuted({
 	property,
-	...falsificationOf(falsifiedOf(checked.result)),
+	counterexample: witnessOf(falsified.shrunkInput),
+	shrinks: shrinkCounted(falsified.shrinks),
 	replay
 });
-const dieReported = (run, budget, checked, site) => dieWithSite(refutedOf(propertyRunOf(run, budget), checked, refutedFailureReplay(run, budget, checked)), site);
+const dieRefuted = (run, budget, checked, falsified, site) => dieWithSite(refutedOf(propertyRunOf(run, budget), falsified, refutedFailureReplay(run, budget, checked)), site);
+const dieExhausted = (run, budget, exhausted, site) => dieWithSite(new PropertyExhausted({
+	property: propertyRunOf(run, budget),
+	discards: runCounted(exhausted.discards),
+	budget: {
+		runs: runCounted(budget.runs),
+		maxDiscards: countOrNull(budget.options.maxDiscards)
+	},
+	replay: plainFailureReplay(run, budget)
+}), site);
 const dieUncovered = (run, budget, classes, site) => dieWithSite(new CoverageBelowMinimum({
 	property: propertyRunOf(run, budget),
 	classes,
@@ -1901,12 +2037,12 @@ const refutedCandidate = (store, budget, checked) => Option$1.flatMap(Option$1.f
 	seed: budget.seed,
 	token
 }));
-const recordedReport = (registration, run, budget, checked) => reportOf(checked) === void 0 ? Effect$1.void : dieReported(run, budget, checked, registration.site);
+const recordedReport = (registration, run, budget, checked) => Match$1.value(checked.result).pipe(Match$1.tag("Falsified", (falsified) => dieRefuted(run, budget, checked, falsified, registration.site)), Match$1.tag("Exhausted", (exhausted) => dieExhausted(run, budget, exhausted, registration.site)), Match$1.orElse(() => Effect$1.void));
 const settleRecorded = (registration, run, budget, checked) => Option$1.match(Option$1.fromNullishOr(violationOf(run, budget, checked)), {
 	onNone: () => recordedReport(registration, run, budget, checked),
 	onSome: (violation) => dieWithSite(violation, registration.site)
 });
-const settleRefuted = (registration, run, budget, coverage, checked, store) => reportOf(checked) === void 0 ? finishPassed(run, budget, coverage, registration.gate, [...store.recorded, budget]) : appendThenDie(store, refutedCandidate(store, budget, checked), dieReported(run, budget, checked, registration.site));
+const settleRefuted = (registration, run, budget, coverage, checked, store) => Match$1.value(checked.result).pipe(Match$1.tag("Falsified", (falsified) => appendThenDie(store, refutedCandidate(store, budget, checked), dieRefuted(run, budget, checked, falsified, registration.site))), Match$1.tag("Exhausted", (exhausted) => appendThenDie(store, Option$1.none(), dieExhausted(run, budget, exhausted, registration.site))), Match$1.orElse(() => finishPassed(run, budget, coverage, registration.gate, [...store.recorded, budget])));
 const settle = (registration, run, budget, coverage, checked, store) => Option$1.match(Option$1.fromNullishOr(violationOf(run, budget, checked)), {
 	onNone: () => settleRefuted(registration, run, budget, coverage, checked, store),
 	onSome: (violation) => appendThenDie(store, nonBooleanEntryOf({
@@ -1947,11 +2083,14 @@ const runRecordedChecks = (registration, arbitrary, hash, recorded) => Effect$1.
 	concurrency: 1,
 	discard: true
 });
-const replayRun = (registration, baseBudget, arbitrary, hash, entry) => {
+const replayRun = (registration, baseBudget, arbitrary, hash, entry, text) => {
 	const budget = applyReplayEntry(baseBudget, entry);
 	const coverage = makeCoverage(registration.spec.cover, arbitrary, budget.seed);
 	const run = checkOf(registration, arbitrary, budget, coverage.observe, hash);
-	return Effect$1.flatMap(runCheck(run), (checked) => settle(registration, run, budget, coverage, checked, noStore(registration.name)));
+	return Effect$1.flatMap(runCheck(run), (checked) => isReplayMismatch(checked.result) ? dieWithSite(new ReplayNoLongerReproduces({
+		property: propertyRunOf(run, budget),
+		replay: text
+	}), registration.site) : settle(registration, run, budget, coverage, checked, noStore(registration.name)));
 };
 const storeRun = (registration, task, baseBudget, arbitrary, hash) => Effect$1.gen(function* () {
 	const entries = yield* readTaskStore(task, registration.site);
@@ -1969,7 +2108,10 @@ const storeRun = (registration, task, baseBudget, arbitrary, hash) => Effect$1.g
 		budget: task.budget
 	});
 });
-const propertyPlatform = Layer.merge(layer, layer$1);
+const propertyPlatform = Layer.unwrap(Effect$1.promise(async () => {
+	const [fileSystem, path] = await Promise.all([import("@effect/platform-node/NodeFileSystem"), import("@effect/platform-node/NodePath")]);
+	return Layer.merge(fileSystem.layer, path.layer);
+}));
 const program = (registration, task) => Effect$1.provide(Effect$1.gen(function* () {
 	const fresh = (yield* Random.nextInt) >>> 0;
 	const baseBudget = resolveBudget(registration.name, registration.spec, task, fresh);
@@ -1979,7 +2121,7 @@ const program = (registration, task) => Effect$1.provide(Effect$1.gen(function*
 	const arbitrary = arbitraryOf(registration.spec.of);
 	yield* Option$1.match(Option$1.fromNullishOr(entry), {
 		onNone: () => storeRun(registration, task, baseBudget, arbitrary, hash),
-		onSome: (replay) => replayRun(registration, baseBudget, arbitrary, hash, replay)
+		onSome: (replay) => replayRun(registration, baseBudget, arbitrary, hash, replay, Option$1.getOrThrow(replayText))
 	});
 }), propertyPlatform);
 const programOf = (registration) => (task) => registration.runtime.provide(program(registration, task));
@@ -2005,7 +2147,7 @@ const makeProperty = (runtime) => {
 	const refuseSelfModel = (name) => {
 		const site = callFrame();
 		runtime.register(name, (_task) => dieWithSite(new SelfModelLaw({
-			name,
+			law: name,
 			site: site ?? null
 		}), site));
 	};
@@ -2077,7 +2219,7 @@ const provideRun = (effect, ledger, ctx) => effect.pipe(Effect$1.provideService(
 const runRecorded = (ctx, program) => {
 	const ledger = makeLedger(ctx);
 	const recorder = createSpanRecorder();
-	return Effect$1.runPromiseExit(provideRun(program(checksFor(ledger)), ledger, ctx).pipe(Effect$1.withTracer(recorder.tracer))).then((exit) => outcomeOf(exit, recorder, testIdentityOf()));
+	return Effect$1.runPromiseExit(provideRun(Effect$1.tap(program(checksFor(ledger)), () => refusingUnyielded(ledger)), ledger, ctx).pipe(Effect$1.withTracer(recorder.tracer))).then((exit) => outcomeOf(exit, recorder, testIdentityOf()));
 };
 /**
 * Runs one program as the runner runs a lane, with a fresh ledger and its own recorder, and resolves with the
@@ -2149,4 +2291,4 @@ const recordOfFile = Function.dual((args) => typeof args[0] === "function", (reg
 	}));
 });
 //#endregion
-export { Slop as C, providedCheckDefaults as D, replayOfText as E, LeakedState as S, ReplayFromText as T, testIdentityOf as _, makeProperty as a, providedRoot as b, NonBooleanVerdict as c, SeedStoreUnreadable as d, SelfModelLaw as f, summaryOf as g, renderFailureRecord as h, createSpanRecorder as i, PropertyRefuted as l, isFailureRecordError as m, recordOfProperty as n, makeFileLedger as o, VacuousProperty as p, recordOfRun as r, CoverageBelowMinimum as s, recordOfFile as t, ReplayUnreadable as u, throwFailureRecord as v, Replay as w, InvalidBudget as x, witnessOf as y };
+export { providedCheckDefaults as A, providedRoot as C, Replay as D, Slop as E, ReplayFromText as O, witnessOf as S, LeakedState as T, isFailureRecordError as _, makeProperty as a, testIdentityOf as b, NonBooleanVerdict as c, ReplayNoLongerReproduces as d, ReplayUnreadable as f, drive as g, VacuousProperty as h, createSpanRecorder as i, replayOfText as k, PropertyExhausted as l, SelfModelLaw as m, recordOfProperty as n, makeFileLedger as o, SeedStoreUnreadable as p, recordOfRun as r, CoverageBelowMinimum as s, recordOfFile as t, PropertyRefuted as u, renderFailureRecord as v, InvalidBudget as w, throwFailureRecord as x, summaryOf as y };

package/dist/failure.d.ts

@@ -1,6 +1,6 @@
 
-import { A as VacuousProperty, C as witnessOf, M as Breach, S as throwFailureRecord, _ as ReplayValue, a as PropertySubject, b as summaryOf, d as ProvidedCheckDefaults, g as JsonValue, h as FailureRecordInput, i as PropertySpec, j as Witness, m as FailureRecord, n as Gens, o as Values, p as AttributeValue, r as PropApi, s as engine_d_exports, v as TestIdentity, x as testIdentityOf, y as renderFailureRecord } from "./engine-D7Q6-BxD.js";
-import { i as Checks, t as Asserted } from "./checks-DiuzHhQM.js";
+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";

package/dist/failure.mjs

@@ -1,4 +1,4 @@
 
-import { E as replayOfText, T as ReplayFromText, _ as testIdentityOf, b as providedRoot, g as summaryOf, h as renderFailureRecord, i as createSpanRecorder, n as recordOfProperty, r as recordOfRun, t as recordOfFile, v as throwFailureRecord, w as Replay, y as witnessOf } from "./failure-nvq5TwWX.mjs";
-import { c as callFrameOutside, l as callSite, p as withRaisingFrame } from "./test-context-D_-acRSc.mjs";
+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-B094O43o.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 {};