@systemfsoftware/vitest 0.0.0 → 0.1.0

package/dist/index.mjs

@@ -1,59 +1,96 @@
 
-import { a as refuseBareEffect, c as refuseNoAssertion, i as refuseAsync, l as refusePositionalProp, n as narrowVacuous, r as presenceMessage, s as refuseHook, t as narrowNegated, u as refuseUnprovided } from "./refusals-BQtDszyU.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 isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-hvSoKLtw.mjs";
 import * as V from "vitest";
-import { inject } from "vitest";
-import * as Function from "effect/Function";
-import * as Context from "effect/Context";
-import * as Fiber from "effect/Fiber";
-import * as Equal from "effect/Equal";
-import { Schema } from "effect";
-import * as Effect from "effect/Effect";
+import { afterAll, assertType, beforeAll, expectTypeOf, inject, inject as inject$1, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
 import * as Cause from "effect/Cause";
 import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Schedule from "effect/Schedule";
-import * as Scheduler from "effect/Scheduler";
 import * as Schema$1 from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as TestClock from "effect/testing/TestClock";
 import * as TestConsole from "effect/testing/TestConsole";
+import * as Equal from "effect/Equal";
+import { Schema } from "effect";
 import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
 import * as Data from "effect/Data";
 import * as Clock from "effect/Clock";
-export * from "vitest";
-//#region src/internal/binding.ts
+import * as Scheduler from "effect/Scheduler";
+//#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$1(checkDefaultsKey);
+//#endregion
+//#region src/internal/driver.ts
 /**
-* The run a test's fibers execute in. Effect code reads it through
-* `Fiber.getCurrent`, so no node-only store is needed (KTD4).
+* The driver: one Effect that steps the body's generator in the fiber the test runs in.
 *
-* @internal
+* 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).
 */
-const Running = Context.Reference("effect-vitest/binding", { defaultValue: () => void 0 });
-/** @internal */
-const currentRun = () => Fiber.getCurrent()?.getRef(Running);
-let syncRun = void 0;
-/** @internal */
-const withSyncRun = Function.dual(2, (run, body) => {
-	const previous = syncRun;
-	syncRun = run;
-	try {
-		return body();
-	} finally {
-		syncRun = previous;
-	}
+/**
+* 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);
 /**
-* The run the current execution belongs to: the fiber's binding first, then the
-* synchronous slot for code that runs outside a fiber.
+* 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 lookupRun = () => currentRun() ?? syncRun;
-const NO_ERRORS = [];
-/** @internal */
-const errorCount = (ctx) => presentErrors(ctx.task.result?.errors).length;
-const presentErrors = (errors) => errors === void 0 ? NO_ERRORS : errors;
+const drive = Function.dual(3, driven);
 //#endregion
 //#region src/internal/equal.ts
 let registered = false;
@@ -81,12 +118,6 @@ var LeakedState = class extends Schema.TaggedError()("LeakedState", { detail: Sc
 	}
 };
 /** @internal */
-var AfterFailedExpect = class extends Schema.TaggedError()("AfterFailedExpect", { detail: Schema.String }) {
-	get message() {
-		return this.detail;
-	}
-};
-/** @internal */
 var Slop = class extends Schema.TaggedError()("Slop", { detail: Schema.String }) {
 	get message() {
 		return this.detail;
@@ -99,120 +130,6 @@ var InvalidBudget = class extends Schema.TaggedError()("InvalidBudget", { detail
 	}
 };
 //#endregion
-//#region src/internal/owned.ts
-/** @internal */
-const OwnedAssertions = Context.Reference("effect-vitest/owned", { defaultValue: () => false });
-/** @internal */
-const isOwned = () => Fiber.getCurrent()?.getRef(OwnedAssertions) === true;
-/** @internal */
-const owned$1 = (self) => Effect.provideService(self, OwnedAssertions, true);
-/**
-* Counts an Effect-native check as an assertion of the run it happens in, so the run's own gate sees it.
-*
-* @internal
-*/
-const recordAssertion$1 = () => {
-	const run = lookupRun();
-	if (run !== void 0) bump(run);
-};
-const bump = (run) => {
-	const { expect } = run.ctx;
-	expect.setState({ assertionCalls: expect.getState().assertionCalls + 1 });
-};
-const bindingOf = (running, owned) => ({ bind: (self) => self.pipe(Effect.provideService(Running, running), Effect.provideService(OwnedAssertions, owned)) });
-/**
-* The run binding of the test the caller is executing in.
-*
-* @internal
-*/
-const captureRunBinding$1 = Effect.withFiber((fiber) => Effect.succeed(bindingOf(fiber.getRef(Running), fiber.getRef(OwnedAssertions))));
-//#endregion
-//#region src/internal/expect.ts
-registerEqualTester();
-const refuse = (detail) => {
-	throw new Slop({ detail });
-};
-const narrowedNames = (negated) => negated ? narrowNegated : narrowVacuous;
-const narrowedName = (property, negated) => namedMatch(property, narrowedNames(negated));
-const namedMatch = (property, names) => typeof property === "string" ? foundMatch(property, names) : void 0;
-const foundMatch = (property, names) => names.find((name) => name === property);
-const refuseNarrowed = (name) => () => refuse(presenceMessage(name));
-const refusedMember = (property, negated) => {
-	const name = narrowedName(property, negated);
-	return name === void 0 ? void 0 : refuseNarrowed(name);
-};
-const memberAt = (target, property) => Reflect.get(target, property, target);
-/**
-* The narrowed names answer with the refusal, `not` re-enters the guard with the negation flipped, and every
-* other member is Vitest's own, handed over unbound so Chai's property accessors keep working.
-*/
-const guardOf = (assertion, negated) => new Proxy(assertion, guardHandler(negated));
-const guardHandler = (negated) => ({ get: (target, property) => guardedMember(target, negated, property) });
-const guardedMember = (target, negated, property) => property === "not" ? guardOf(target.not, !negated) : forwardedMember(target, negated, property);
-const forwardedMember = (target, negated, property) => refusedMember(property, negated) ?? memberAt(target, property);
-const plainAssertion = (actual, message) => counted(guardOf(V.expect(actual, message), false));
-const countsInThisRun = () => lookupRun()?.shadow !== true;
-/**
-* A check outside a soft run counts on the run it happens in: an `owned` region's checks throw, and a
-* check outside every run has no gate to satisfy.
-*/
-const counted = (assertion) => {
-	if (countsInThisRun()) recordAssertion$1();
-	return assertion;
-};
-const softAssertion = (running, actual, message) => guardOf(running.ctx.expect.soft(actual, message), false);
-const isSoftRun = (running) => running.shadow === false && isOwned() === false;
-const liveAssertion = (running, actual, message) => isSoftRun(running) ? softAssertion(running, actual, message) : plainAssertion(actual, message);
-/**
-* A check inside a run is soft: it records the failure and the test stops at the next step. The second run
-* and an `owned` region throw, so their own handler sees the failure.
-*/
-const assertionFor = (actual, message) => {
-	const running = lookupRun();
-	return running === void 0 ? plainAssertion(actual, message) : liveAssertion(running, actual, message);
-};
-Function.dual(2, assertionFor);
-const messageOf = (value) => typeof value === "string" ? value : void 0;
-const applyCheck = (args) => assertionFor(args[0], messageOf(args[1]));
-/** The statics are Vitest's; only `soft` is the fork's, and soft is what a check already is inside a run. */
-const makeExpect = () => new Proxy(V.expect, {
-	get: (target, property) => property === "soft" ? assertionFor : memberAt(target, property),
-	apply: (_target, _thisArg, args) => applyCheck(args)
-});
-/**
-* The fork's `expect`: soft within one Effect step, refusing the slop forms.
-*
-* @internal
-*/
-const expect$1 = makeExpect();
-const refuseHookNow = () => refuse(refuseHook);
-const takesHook = (args) => typeof args[0] === "function";
-const refuseHookPair = (fn, timeout) => {
-	return refuseHookNow();
-};
-/**
-* @internal
-*/
-const beforeEach$1 = Function.dual(takesHook, refuseHookPair);
-/**
-* @internal
-*/
-const afterEach$1 = Function.dual(takesHook, refuseHookPair);
-/**
-* @internal
-*/
-const beforeAll$1 = Function.dual(takesHook, V.beforeAll);
-/**
-* @internal
-*/
-const afterAll$1 = Function.dual(takesHook, V.afterAll);
-//#endregion
-//#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);
-//#endregion
 //#region src/internal/property/coverage.ts
 /**
 * @internal The R14 coverage classes: labelled input predicates, each with a minimum share of runs.
@@ -678,42 +595,6 @@ const makeProperty = (runtime) => {
 	};
 };
 //#endregion
-//#region src/internal/step-boundary.ts
-/** @internal */
-const makeStopState = (failed) => ({
-	stopped: /* @__PURE__ */ new WeakSet(),
-	failed
-});
-const alreadyStopped = (state, fiber) => state.stopped.has(fiber);
-/** @internal */
-const stopChecker = Function.dual(2, (state, fiber) => alreadyStopped(state, fiber) === false && state.failed());
-const markStopped = (state, fiber) => {
-	state.stopped.add(fiber);
-};
-/** @internal */
-const stopAfterFailedCheck = Function.dual(2, (scheduler, state) => ({
-	executionMode: scheduler.executionMode,
-	makeDispatcher: () => scheduler.makeDispatcher(),
-	shouldYield: (fiber) => checkFiber(state, scheduler, fiber)
-}));
-const checkFiber = (state, scheduler, fiber) => {
-	const steppable = fiber;
-	if (stopChecker(state, steppable) === false) return scheduler.shouldYield(fiber);
-	markStopped(state, steppable);
-	steppable.interruptUnsafe(steppable.id);
-	return true;
-};
-//#endregion
-//#region src/internal/test-context.ts
-/** @internal */
-const vitestTestContextKey$1 = "@systemfsoftware/vitest/TestContext";
-/**
-* The running Vitest test, or `null` outside a run; provided on every test the fork runs.
-*
-* @internal
-*/
-const VitestTestContext$1 = Context.Reference(vitestTestContextKey$1, { defaultValue: () => null });
-//#endregion
 //#region src/internal/virtual-time.ts
 const roundNanos = (millis) => BigInt(Math.round(millis * 1e6));
 const byWakeOrder = (first, second) => {
@@ -885,6 +766,18 @@ const virtualClockOf = (runtime) => {
 };
 //#endregion
 //#region src/internal/runner.ts
+/**
+* The fork's runner: the test lanes, the layer blocks, the property lanes and the run pipeline.
+*
+* A test body is a generator the driver steps (KTD1), so `expect` is the body's own parameter and every check is
+* yielded. Everything #512 promised holds unchanged: a fresh build of a test's layers, virtual time that advances
+* when the fibers are idle, concurrent and shuffled blocks, a declared-shared block as the only sharing, a second
+* run on a fresh build that reports leaked state, and Effect `Equal` in `toEqual`.
+*
+* What is a refusal here: a body that is not a generator, and the habit lanes `it.effect`, `it.scoped` and
+* `it.scopedLive` (R2, R9). Registration marks every task this file adds (KTD8), so the guard in
+* `@systemfsoftware/vitest/guard` can tell the fork's tests from a test registered by Vitest itself.
+*/
 const getCurrentSuite = V.TestRunner.getCurrentSuite;
 /** @internal */
 const addEqualityTesters$1 = () => {
@@ -896,80 +789,66 @@ const givenOptions = (timeout) => timeout ?? {};
 const testOptions = (timeout) => typeof timeout === "number" ? numbered(timeout) : givenOptions(timeout);
 /** @internal */
 const hookTimeout = (timeout) => timeout === void 0 ? void 0 : Duration.toMillis(Duration.fromInputUnsafe(timeout));
+const isName = (first) => typeof first === "string";
+const byName = (args) => isName(args[0]);
+const byLayer = (args) => Layer.isLayer(args[0]);
+const byEffect = (args) => Effect.isEffect(args[0]);
 /**
-* The positional form is refused at run time with the R15 rewrite; the public type already refuses it.
+* The positional property form is refused at run time with the R15 rewrite; the public type refuses it first
+* because a `PropertySpec` is an object and the positional shape is not.
 */
+const refusePositionalProp = "✗ it.prop(name, [arbitraries], predicate) is removed. Name the function under test and pass a budget: it.prop(name, { of, subject, runs }, holds).";
+const isAbsent = (spec) => spec === null || spec === void 0;
+const hasNoOf = (spec) => Object.hasOwn(spec, "of") === false;
+const lacksInputs = (spec) => isAbsent(spec) || hasNoOf(spec);
 const refusePositional = (spec) => {
 	if (lacksInputs(spec)) throw new Slop({ detail: refusePositionalProp });
 };
-const lacksInputs = (spec) => isAbsent(spec) || hasNoOf(spec);
-const isAbsent = (spec) => spec === null || spec === void 0;
-const hasNoOf = (spec) => Object.hasOwn(spec, "of") === false;
-const stopCheckOf = (ctx) => ctx === void 0 ? void 0 : failedAfter(ctx, errorCount(ctx));
-const neverStop = () => void 0;
 /** @internal */
 const realTime = {
 	runtime: void 0,
-	owned: false,
-	stop: stopCheckOf
+	owned: false
 };
-/** @internal */
+/**
+* A run with its own virtual clock: the clock only ever advances when the run's fibers are idle.
+*
+* @internal
+*/
 const perRun = () => ({
 	runtime: makeVirtualRuntime(),
-	owned: true,
-	stop: stopCheckOf
+	owned: true
 });
-const propertyEnv = {
-	runtime: void 0,
-	owned: false,
-	stop: neverStop
-};
+const propertyEnv = realTime;
 const logErrors = (cause) => Effect.forEach(Cause.prettyErrors(cause), (error) => Effect.logError(error), { discard: true });
-const failedAfter = (ctx, before) => () => errorCount(ctx) > before;
 const signalOf = (ctx) => ctx?.signal;
 const signalOnly = (signal) => signal === void 0 ? {} : { signal };
-const withScheduler = (signal, scheduler) => ({
-	...signalOnly(signal),
-	scheduler
+const schedulerOf = (env) => env.runtime === void 0 ? {} : { scheduler: env.runtime.scheduler };
+const runOptions = (ctx, env) => ({
+	...signalOnly(signalOf(ctx)),
+	...schedulerOf(env)
 });
-const runOptions = (ctx, scheduler) => scheduler === void 0 ? signalOnly(signalOf(ctx)) : withScheduler(signalOf(ctx), scheduler);
-const baseScheduler = (env) => env.runtime?.scheduler;
-const stopScheduler = (base, failedCheck) => stopAfterFailedCheck(base ?? new Scheduler.MixedScheduler(), makeStopState(failedCheck));
-const pickScheduler = (env, failedCheck) => failedCheck === void 0 ? baseScheduler(env) : stopScheduler(baseScheduler(env), failedCheck);
-const runPromise = (effect, ctx, env = realTime) => {
-	const failedCheck = env.stop(ctx);
-	return runExit(effect, ctx, env, failedCheck).then(reportExit(failedCheck));
-};
-const runExit = (effect, ctx, env, failedCheck) => {
-	const program = wrapOwned(effect, ownedRuntime(env));
-	return Effect.runPromiseExit(program, runOptions(ctx, pickScheduler(env, failedCheck)));
-};
 const ownedRuntime = (env) => env.owned === false ? void 0 : env.runtime;
 const observeOf = (runtime) => runtime === void 0 ? Effect.void : runtime.observe;
 const endOf = (runtime) => runtime === void 0 ? Effect.void : runtime.end;
 const wrapOwned = (effect, runtime) => observeOf(runtime).pipe(Effect.andThen(effect.pipe(Effect.ensuring(endOf(runtime)))));
-const stoppedSettled = () => Promise.resolve(void 0);
-const stoppedExit = (cause) => Cause.hasInterruptsOnly(cause) ? stoppedSettled() : failExit(cause);
-const stoppedChecked = (cause, failed) => failed ? stoppedExit(cause) : failExit(cause);
-const failedOrThrow = (cause, failedCheck) => failedCheck === void 0 ? failExit(cause) : stoppedChecked(cause, failedCheck());
-const reportExit = (failedCheck) => (exit) => Exit.isSuccess(exit) ? Promise.resolve(exit.value) : failedOrThrow(exit.cause, failedCheck);
+const runExit = (effect, ctx, env) => Effect.runPromiseExit(wrapOwned(effect, ownedRuntime(env)), runOptions(ctx, env));
 /**
 * A body that needs a service nothing provides dies with Effect's own `Service not found`. That is a
-* test-authoring error — the layers were never wired — so it is reported as the unprovided rewrite (R9)
-* instead of as a raw defect. Failures an `owned` region is responsible for are recovered by their owner
-* and never reach here.
+* test-authoring error — the layers were never wired — so it is reported as the unprovided rewrite (R9) instead
+* of as a raw defect.
 */
 const isUnprovided = (error) => error instanceof Error && error.message.startsWith("Service not found");
-const failExit = (cause) => logErrors(cause).pipe(Effect.runPromise).then(() => rethrowSquashed(cause));
 const rethrowSquashed = (cause) => {
 	const error = Cause.squash(cause);
-	if (isUnprovided(error)) throw new Slop({ detail: refuseUnprovided });
+	if (isUnprovided(error)) throw new Slop({ detail: unprovidedText });
 	throw error;
 };
-const runTest = (ctx, env = realTime) => (effect) => {
-	const promise = runPromise(effect, ctx, env);
-	if (ctx !== void 0) trackAbort(ctx, promise);
-	return promise;
+const failExit = (cause) => logErrors(cause).pipe(Effect.runPromise).then(() => rethrowSquashed(cause));
+const reportExit = (exit) => Exit.isSuccess(exit) ? Promise.resolve(exit.value) : failExit(exit.cause);
+const runPromise = (effect, ctx, env = realTime) => runExit(effect, ctx, env).then(reportExit);
+const noop = () => {};
+const detach = (ctx, onAbort) => {
+	ctx.signal.removeEventListener("abort", onAbort);
 };
 const trackAbort = (ctx, promise) => {
 	const onAbort = () => {
@@ -979,168 +858,104 @@ const trackAbort = (ctx, promise) => {
 	promise.then(() => detach(ctx, onAbort), () => detach(ctx, onAbort));
 	if (ctx.signal.aborted) onAbort();
 };
-const detach = (ctx, onAbort) => {
-	ctx.signal.removeEventListener("abort", onAbort);
+const runTest = (ctx, env = realTime) => (effect) => {
+	const promise = runPromise(effect, ctx, env);
+	if (ctx !== void 0) trackAbort(ctx, promise);
+	return promise;
 };
-const noop = () => {};
 const clockLayerOf = (env) => env.runtime === void 0 ? TestClock.layer() : virtualClockLayer(env.runtime);
 /** @internal */
 const testEnv = (env) => Layer.mergeAll(TestConsole.layer, clockLayerOf(env));
 /**
-* The run a test's fibers execute in: the test's own context as `Running`, and the same context under the
-* fork's `VitestTestContext` for every library built on the fork.
+* The run a test's fibers execute in: the test's own context under the fork's `VitestTestContext`, so a library
+* built on the fork reads the same context the runner does.
 */
-const bindRun = (effect, ctx, shadow) => effect.pipe(Effect.provideService(Running, {
-	ctx,
-	shadow
-}), Effect.provideService(VitestTestContext$1, ctx));
-const isObject = (output) => typeof output === "object" && output !== null;
-const isThenable = (value) => "then" in value ? typeof value.then === "function" : false;
-const isPromiseLike = (output) => isObject(output) && isThenable(output);
-const refusePromiseBody = () => {
-	throw new Slop({ detail: refuseAsync });
-};
-const refuseAfter = (promise) => {
-	Promise.resolve(promise).catch(noop);
-	return refusePromiseBody();
-};
-const checkPromiseBody = (output) => {
-	if (isPromiseLike(output)) refuseAfter(output);
-};
-const outputIsEffect = (output) => Effect.isEffect(output);
-const buildSingleRun = (body, mapOne, env, shadow) => (ctx) => {
-	const output = withSyncRun({
-		ctx,
-		shadow
-	}, () => body(ctx));
-	checkPromiseBody(output);
-	return outputIsEffect(output) ? runBuilt(ctx, env, mapOne, output, shadow) : Promise.resolve(void 0);
-};
-const runBuilt = (ctx, env, mapOne, output, shadow) => runTest(ctx, env)(mapOne(bindRun(Effect.suspend(() => output), ctx, shadow)));
+const bindRun = (effect, ctx) => effect.pipe(Effect.provideService(VitestTestContext$1, ctx));
+const refuseBody = (text) => {
+	throw refusalOf$1(text);
+};
+/** The constructor names of the function kinds that hand back a promise instead of a generator. */
+const AWAITED_KINDS = {
+	AsyncFunction: true,
+	AsyncGeneratorFunction: true
+};
+/** The constructor name of the one function kind the driver steps: a generator hands its steps over. */
+const GENERATOR_KIND = "GeneratorFunction";
+const kindOf = (body) => body.constructor.name;
+const isGeneratorBody = (body) => kindOf(body) === GENERATOR_KIND;
+const isSteps = (returned) => "next" in returned && typeof returned.next === "function";
+/** The iterator a generator handed over; only a generator reaches here, so the guard is for the compiler alone. */
+const asSteps = (returned) => isSteps(returned) ? returned : refuseBody(refuseSyncBody);
 /**
-* Runs a property's program as the test that registered it, under the same binding the Effect lanes use, so a
-* check or an annotation inside `holds` belongs to the test that declared the property. The env is the bare
-* `propertyEnv`: no step boundary interrupts a property, so its `false` verdict still shrinks (R6, U4).
+* The refusal a body reaches before it runs (R2). An `async` body hands back a promise and runs outside the test
+* runtime. A plain body can only be told from one by calling it, and nothing in a refused body may run, so it is
+* refused as a sync body, whose rewrite is to pass a generator; the compile channel prints each shape's own text.
 */
-const runProperty = (ctx, program) => buildSingleRun(() => program(), (effect) => effect, propertyEnv, false)(ctx);
-const property = makeProperty({
-	register: (name, program) => {
-		V.it(name, (ctx) => runProperty(ctx, program));
-	},
-	provide: (effect) => effect
-});
-const isName = (first) => typeof first === "string";
-const byName = (args) => isName(args[0]);
-const byLayer = (args) => Layer.isLayer(args[0]);
-const byEffect = (args) => Effect.isEffect(args[0]);
-const propImpl = (name, spec, holds) => {
-	refusePositional(spec);
-	property.prop(name, spec, holds);
+const refusalOf = (body) => AWAITED_KINDS[kindOf(body)] === true ? refuseAsyncBody : refuseSyncBody;
+/** The body's generator, or the refusal for a body the driver cannot step. */
+const stepsOfBody = (body, checks) => isGeneratorBody(body) ? asSteps(body(checks)) : refuseBody(refusalOf(body));
+/** The same for a row body: Vitest's `it.for` order is the row first, then the checks (R9). */
+const stepsOfRow = (row, body, checks) => isGeneratorBody(body) ? asSteps(body(row, checks)) : refuseBody(refusalOf(body));
+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);
+/** 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. */
+const runLaned = (ctx, mapEffect, env, body) => {
+	const ledger = makeLedger(ctx);
+	return runTest(ctx, env)(mapEffect(bindRun(drive(bodyOf(ledger, body), [], ledger), ctx), env));
 };
-/** @internal */
-const prop$1 = Function.dual(byName, propImpl);
 const outcomeOf = (promise) => promise.then(() => void 0, (error) => error);
-/**
-* The second run's failure: a diagnosis the fork itself made is rethrown as that diagnosis, because the
-* second run exists to catch leaked state, not to relabel a refusal as a leak (F7). Anything else is the leak.
-*/
-const throwSecondRun = (error) => {
-	if (isRefusal(error)) throw error;
-	return throwLeaked(error);
-};
-const leakedOrNothing = (error) => {
-	if (error !== void 0) throwSecondRun(error);
-};
-const makeTesterWith = (mapEffect, it, envFor, rerunnable) => {
-	const runOne = (ctx, args, self, shadow) => {
-		const env = envFor();
-		return buildSingleRun(() => self(...args), (effect) => mapEffect(effect, env), env, shadow)(ctx);
-	};
-	/**
-	* The second run: the same layer build the first run used, built again, with the shadow flag set so its
-	* checks throw instead of reporting softly (R5, KTD7).
-	*/
-	const rerun = (ctx, args, self) => outcomeOf(runOne(ctx, args, self, true)).then(leakedOrNothing);
-	const run = (ctx, args, self) => outcomeOf(runOne(ctx, args, self, false)).then((error) => afterFirst(ctx, args, self, error));
-	const afterFirst = (ctx, args, self, error) => {
-		if (error !== void 0) throwAfterCheck(ctx, error);
-		gateNoAssertion(ctx);
-		return rerunIfClean(ctx, args, self);
-	};
-	const rerunIfClean = (ctx, args, self) => shouldRerun(ctx) ? rerun(ctx, args, self) : Promise.resolve();
-	const shouldRerun = (ctx) => rerunnable && isClean(ctx);
-	const registerOn = (registrar, name, self, timeout) => {
-		registrar(name, testOptions(timeout), (ctx) => run(ctx, [ctx], self));
-	};
-	const dualTest = (register) => Function.dual(byName, register);
-	const f = dualTest((name, self, timeout) => registerOn(it, name, self, timeout));
-	const skip = dualTest((name, self, timeout) => registerOn(it.skip, name, self, timeout));
-	const skipIf = (condition) => dualTest((name, self, timeout) => registerOn(it.skipIf(condition), name, self, timeout));
-	const runIf = (condition) => dualTest((name, self, timeout) => registerOn(it.runIf(condition), name, self, timeout));
-	const only = dualTest((name, self, timeout) => registerOn(it.only, name, self, timeout));
-	const each = (cases) => (name, self, timeout) => it.for(cases)(name, testOptions(timeout), (row, ctx) => run(ctx, [row], self));
-	const fails = dualTest((name, self, timeout) => registerOn(V.it.fails, name, self, timeout));
-	const effectProperty = makeProperty({
-		register: (name, program) => {
-			it(name, (ctx) => runProperty(ctx, program));
-		},
-		provide: (effect) => mapEffect(effect, envFor())
-	});
-	const testerProp = (name, spec, holds) => {
-		refusePositional(spec);
-		effectProperty.effectProp(name, spec, holds);
-	};
-	return Object.assign(f, {
-		skip,
-		skipIf,
-		runIf,
-		only,
-		each,
-		fails,
-		prop: testerProp
-	});
-};
-const makeTester = (mapEffect, it = V.it) => makeTesterWith(mapEffect, it, perRun, true);
-const makeSharedTester = (mapEffect, it, envFor) => makeTesterWith(mapEffect, it, envFor, false);
 const isSlop = (error) => Schema$1.is(Slop)(error);
-/** Every failure the fork itself names, as `Schema.is`: the families a second run must not relabel. */
-const refusalChecks = [
+/** Every failure the fork itself names: the branded refusals, plus the Schema-tagged families. */
+const otherRefusals = [
 	isSlop,
-	Schema$1.is(AfterFailedExpect),
 	Schema$1.is(InvalidBudget),
 	Schema$1.is(NonBooleanVerdict),
 	Schema$1.is(LeakedState)
 ];
-const isRefusal = (error) => refusalChecks.some((matches) => matches(error));
-const throwAfterCheck = (ctx, error) => {
-	if (isSlop(error)) throw error;
-	return afterFailedCheck(ctx, error);
-};
-const afterFailedCheck = (ctx, error) => {
-	if (errorCount(ctx) > 0) throwAfterFailed();
-	throw error;
-};
-const throwAfterFailed = () => {
-	throw new AfterFailedExpect({ detail: "thrown after a failed expect above, most likely caused by it" });
+const isRefusal = (error) => isRefusal$1(error) || otherRefusals.some((matches) => matches(error));
+const clipped = (message) => message.length > 400 ? message.slice(0, 400) : message;
+const throwLeaked = (outcome) => {
+	throw new LeakedState({ detail: "✗ this test passed, then failed when run again on a fresh build of its services: something keeps state outside its layer, so tests here see each other's changes. The second run failed with: " + clipped(outcome.message) });
 };
-/** Whether a run left no failure behind: the second run is only worth doing for a clean first one. */
-const isClean = (ctx) => errorCount(ctx) === 0;
-const silentRun = (ctx) => errorCount(ctx) === 0 && assertionCalls(ctx) === 0;
 /**
-* The test's own assertion count. Every check the fork runs inside a test binds to that test's `expect`,
-* so a sibling test's checks are never visible here.
+* The second run's failure: a diagnosis the fork itself made is rethrown as that diagnosis, because the second
+* run exists to catch leaked state, not to relabel a refusal as a leak. Anything else is the leak.
 */
-const assertionCalls = (ctx) => ctx.expect.getState().assertionCalls;
-const gateNoAssertion = (ctx) => {
-	if (silentRun(ctx)) throwNoAssertion();
+const throwSecondRun = (error) => {
+	if (isRefusal(error)) throw error;
+	return throwLeaked(error);
 };
-const throwNoAssertion = () => {
-	throw new Slop({ detail: refuseNoAssertion });
+const leakedOrNothing = (error) => {
+	if (error !== void 0) throwSecondRun(error);
 };
-const clipped = (message) => message.length > 400 ? message.slice(0, 400) : message;
-const throwLeaked = (outcome) => {
-	throw new LeakedState({ detail: "✗ this test passed, then failed when run again on a fresh build of its services: something keeps state outside its layer, so tests here see each other's changes. The second run failed with: " + clipped(outcome.message) });
+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;
+/**
+* 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) => runTest(ctx, propertyEnv)(bindRun(Effect.suspend(program), ctx));
+const property = makeProperty({
+	register: (name, program) => marked(() => V.it(name, (ctx) => runProperty(ctx, program))),
+	provide: (effect) => effect
+});
+const propImpl = (name, spec, holds) => {
+	refusePositional(spec);
+	property.prop(name, spec, holds);
 };
+/** @internal */
+const prop$1 = Function.dual(byName, propImpl);
+/**
+* The law kinds over the sync property family: the top-level `it.law`.
+*
+* @internal
+*/
+const law$1 = property.law;
 const CONCURRENT_BLOCK = {
 	concurrent: true,
 	shuffle: true
@@ -1158,25 +973,24 @@ const memoMapIn = (options) => options?.memoMap;
 const excludeTestServicesOf = (options) => withDefault(excludedIn(options), false);
 const blockEnvOf = (inherited) => withDefault(inherited, {
 	runtime: makeVirtualRuntime(),
-	owned: false,
-	stop: stopCheckOf
+	owned: false
 });
 const memoMapOf = (options) => withDefault(memoMapIn(options), Effect.runSync(Layer.makeMemoMap));
 const blockHookTimeout = (options) => hookTimeout(timeoutIn(options));
 const isSharedBlock = (options) => sharedIn(options) === true;
-/**
-* A named block's suite options: its tests run concurrently and in shuffled order (R4). A declared-shared
-* block is the stateful exception — its tests read each other's writes through one build, so it stays in
-* declaration order and runs alone.
-*/
-const describeOptions = (options, shared) => mergeBlockOptions(options, shared ? ALONE_BLOCK : CONCURRENT_BLOCK);
 const mergeBlockOptions = (options, fallback) => ({
 	concurrent: withDefault(concurrencyIn(options), fallback.concurrent),
 	shuffle: fallback.shuffle
 });
 /**
-* The block's layer with the test's own services merged in, unless the block excludes them. `Layer`'s output
-* is contravariant, so the merged layer is the *narrower* `Layer<R, E>` the callers provide to a run.
+* A named block's suite options: its tests run concurrently and in shuffled order (R4). A declared-shared block
+* is the stateful exception — its tests read each other's writes through one build, so it stays in declaration
+* order and runs alone.
+*/
+const describeOptions = (options, shared) => mergeBlockOptions(options, shared ? ALONE_BLOCK : CONCURRENT_BLOCK);
+/**
+* The block's layer with the test's own services merged in, unless the block excludes them. `Layer`'s output is
+* contravariant, so the merged layer is the *narrower* `Layer<R, E>` the callers provide to a run.
 */
 const mergeTestEnv = (layer_, env, excludeTestServices) => excludeTestServices ? layer_ : Layer.provideMerge(layer_, env);
 const sharedContext = (shared, memoMap, scope) => Layer.buildWithMemoMap(shared, memoMap, scope).pipe(Effect.orDie, Effect.cached, Effect.runSync);
@@ -1200,6 +1014,31 @@ const routeBlock = (first, second, anonymous, named) => {
 const openNamed = (name, f, named) => {
 	if (f !== void 0) named(name, f);
 };
+/** Runs a registration and marks every test task it added, which is how the guard knows the fork registered it. */
+const marked = (register) => {
+	const before = suiteTasks(getCurrentSuite()).length;
+	register();
+	markAdded(before);
+};
+const markAdded = (before) => {
+	for (const task of collectTasks(suiteTasks(getCurrentSuite()).slice(before))) markTask(task);
+};
+const blockTasksOf = () => suiteTasks(getCurrentSuite());
+const suiteTasks = (suite) => suite.tasks;
+const collectTasks = (tasks) => {
+	const acc = [];
+	for (const task of tasks) collectOne(task, acc);
+	return acc;
+};
+const collectNested = (task, acc) => {
+	if (task.tasks !== void 0) collectTasks(task.tasks).forEach((nested) => acc.push(nested));
+};
+const collectOne = (task, acc) => {
+	if (isRunnableTest(task)) acc.push(task);
+	else collectNested(task, acc);
+};
+const notSkipped = (task) => task.mode !== "skip" && task.mode !== "todo";
+const isRunnableTest = (task) => task.type === "test" && notSkipped(task);
 const layerFor = (layer_, options, inherited) => isSharedBlock(options) ? sharedBlock(layer_, options, inherited) : freshBlock(layer_, options);
 const freshBlock = (layer_, options) => {
 	const excludeTestServices = excludeTestServicesOf(options);
@@ -1209,13 +1048,7 @@ const freshBlock = (layer_, options) => {
 		excludeTestServices
 	}, void 0);
 	const nestedLayer = Function.dual(byLayer, nestedOpen);
-	const makeIt = (it) => makeItProxy(it, {
-		effect: makeTester((effect, env) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, Layer.orDie(Layer.fresh(withTestEnv(env))))), it),
-		prop: prop$1,
-		law: property.law,
-		flakyTest: flakyTest$1,
-		layer: nestedLayer
-	}, true);
+	const makeIt = (it) => methodsFor((effect, env) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, Layer.orDie(Layer.fresh(withTestEnv(env))))), it, perRun, true, nestedLayer);
 	return blockOpener((f) => f(makeIt(V.it)), (name, f) => {
 		V.describe(name, describeOptions(options, false), () => f(makeIt(V.it)));
 	});
@@ -1225,24 +1058,15 @@ const nestedBlock = (nested, memoMap) => ({
 	memoMap: Layer.forkMemoMapUnsafe(memoMap),
 	shared: true
 });
-const sharedOverrides = (shared, contextEffect, memoMap, blockEnv) => {
-	const nestedOpen = (nestedLayer, nestedOptions) => layerFor(() => Layer.provideMerge(nestedLayer, shared), nestedBlock(nestedOptions, memoMap), blockEnv);
-	const nestedLayer = Function.dual(byLayer, nestedOpen);
-	return {
-		effect: makeSharedTester((effect) => Effect.flatMap(contextEffect, (context) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, context))), V.it, () => blockEnv),
-		prop: prop$1,
-		law: property.law,
-		flakyTest: flakyTest$1,
-		layer: nestedLayer
-	};
-};
 const sharedBlock = (layer_, options, inherited) => {
 	const blockEnv = blockEnvOf(inherited);
 	const memoMap = memoMapOf(options);
 	const scope = Scope.makeUnsafe();
 	const shared = mergeTestEnv(layer_(blockEnv), testEnv(blockEnv), excludeTestServicesOf(options));
 	const contextEffect = sharedContext(shared, memoMap, scope);
-	const makeIt = (it) => makeItProxy(it, sharedOverrides(shared, contextEffect, memoMap, blockEnv), false);
+	const nestedOpen = (nestedLayer, nestedOptions) => layerFor(() => Layer.provideMerge(nestedLayer, shared), nestedBlock(nestedOptions, memoMap), blockEnv);
+	const nestedLayer = Function.dual(byLayer, nestedOpen);
+	const makeIt = (it) => methodsFor((effect) => Effect.flatMap(contextEffect, (context) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, context))), it, () => blockEnv, false, nestedLayer);
 	const closeScope = makeScopeCloser(scope);
 	return blockOpener((f) => sharedAnonymous(f, makeIt, options, blockTasksOf(), blockEnv, contextEffect, closeScope), (name, f) => describeShared(name, f, makeIt, options, contextEffect, closeScope, blockEnv));
 };
@@ -1253,8 +1077,6 @@ const describeShared = (name, f, makeIt, options, contextEffect, closeScope, blo
 		return f(makeIt(V.it));
 	});
 };
-const blockTasksOf = () => suiteTasks(getCurrentSuite());
-const suiteTasks = (suite) => suite.tasks;
 const sharedAnonymous = (register, makeIt, options, blockTasks, blockEnv, contextEffect, closeScope) => {
 	const previousTasks = new Set(blockTasks);
 	register(makeIt(V.it));
@@ -1282,20 +1104,6 @@ const sharedBeforeEach = (ctx, blockTaskSet, finish, contextEffect, blockEnv) =>
 	ctx.onTestFinished(() => finish());
 	return runPromise(Effect.asVoid(contextEffect), ctx, blockEnv);
 };
-const collectTasks = (tasks) => {
-	const acc = [];
-	for (const task of tasks) collectOne(task, acc);
-	return acc;
-};
-const collectOne = (task, acc) => {
-	if (isRunnableTest(task)) acc.push(task);
-	else collectNested(task, acc);
-};
-const collectNested = (task, acc) => {
-	if (task.tasks !== void 0) collectTasks(task.tasks).forEach((nested) => acc.push(nested));
-};
-const notSkipped = (task) => task.mode !== "skip" && task.mode !== "todo";
-const isRunnableTest = (task) => task.type === "test" && notSkipped(task);
 const layerImpl = (layer_, options) => layerFor(() => layer_, options, void 0);
 /** @internal */
 const layer$1 = Function.dual(byLayer, layerImpl);
@@ -1304,82 +1112,101 @@ const retryWithin = (timeout) => Schedule.while(Schedule.recurs(10), (state) =>
 const flakyTestImpl = (self, timeout = Duration.seconds(30)) => self.pipe(Effect.scoped, Effect.sandbox, (sandboxed) => Effect.retry(sandboxed, retryWithin(timeout)), Effect.orDie);
 /** @internal */
 const flakyTest$1 = Function.dual(byEffect, flakyTestImpl);
-const isFunction = (arg) => typeof arg === "function";
 /**
-* The two returns the bare lane refuses: a promise, which runs outside the test runtime (R9), and an Effect,
-* which the bare lane never runs — it belongs on `it.effect`.
+* The lanes a removed habit name reaches: the call is refused with its rewrite, on the `this` type and at run
+* time, and the property the lane used to carry still runs (R9, KTD3).
 */
-const refuseBareOutput = (output) => {
-	checkPromiseBody(output);
-	if (outputIsEffect(output)) throw new Slop({ detail: refuseBareEffect });
-};
-/** One pass of the bare body: it runs bound to the run's context, and its return is refused here. */
-const bareRunOnce = (ctx, self, shadow) => {
-	const returned = withSyncRun({
-		ctx,
-		shadow
-	}, () => self(ctx));
-	if (isObject(returned)) refuseBareOutput(returned);
-};
-/** The bare body's outcome: `undefined` when it passed, or the failure it threw or was refused with. */
-const bareOutcome = (ctx, self, shadow) => outcomeOf(Promise.resolve().then(() => bareRunOnce(ctx, self, shadow)));
-const shouldRerunBare = (ctx, rerunnable) => rerunnable && isClean(ctx);
-const afterBareGate = (ctx, self, rerunnable) => shouldRerunBare(ctx, rerunnable) ? bareOutcome(ctx, self, true).then(leakedOrNothing) : Promise.resolve();
-const afterBareFirst = (ctx, self, rerunnable, failure) => {
-	if (failure !== void 0) throwAfterCheck(ctx, failure);
-	gateNoAssertion(ctx);
-	return afterBareGate(ctx, self, rerunnable);
+const refuseHabitLane = (text) => {
+	throw refusalOf$1(text);
 };
+const effectLaneRefusal = (prop, text) => Object.assign(() => refuseHabitLane(text), { prop });
 /**
-* The bare `it(name, body)` lane: Vitest's own registration with the fork's defaults instead of an Effect
-* lane. The body is synchronous, so it is gated for a leftover assertion and run a second time on its own,
-* which is what catches a body that only passes while nothing else touched its module (R5, R9).
+* The lanes over one `mapEffect`: `it`, its modifiers and `it.each` all register the same generator body, and
+* the Effect-lane property is bound to the same services the lane provides (R7, R9).
 */
-const runDefault = (ctx, self, rerunnable) => bareOutcome(ctx, self, false).then((failure) => afterBareFirst(ctx, self, rerunnable, failure));
-const defaultLane = (self, rerunnable) => (ctx) => runDefault(ctx, self, rerunnable);
+const makeTesterWith = (mapEffect, it, envFor, rerunnable) => {
+	const runOnce = (ctx, body) => runLaned(ctx, mapEffect, envFor(), body);
+	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) => {
+		if (error !== void 0) throw error;
+		return rerunIfClean(ctx, body);
+	});
+	const registering = (registrar) => (name, body, timeout) => {
+		const lane = laneBodyOf(body);
+		marked(() => registrar(name, testOptions(timeout), (ctx) => run(ctx, lane)));
+	};
+	const dualLane = (registrar) => Function.dual(byName, registering(registrar));
+	const base = dualLane(it);
+	const skip = dualLane(it.skip);
+	const skipIf = (condition) => dualLane(it.skipIf(condition));
+	const runIf = (condition) => dualLane(it.runIf(condition));
+	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))));
+	};
+	const effectProperty = makeProperty({
+		register: (name, program) => marked(() => it(name, (ctx) => runProperty(ctx, program))),
+		provide: (effect) => mapEffect(effect, envFor())
+	});
+	const prop = (name, spec, holds) => {
+		refusePositional(spec);
+		effectProperty.effectProp(name, spec, holds);
+	};
+	return Object.assign(base, {
+		skip,
+		skipIf,
+		runIf,
+		only,
+		fails,
+		each,
+		prop
+	});
+};
+/** The block's methods: the generator lanes, the refusing habit lanes, and the block's own nested `layer`. */
+const methodsFor = (mapEffect, it, envFor, rerunnable, layer) => {
+	const tester = makeTesterWith(mapEffect, it, envFor, rerunnable);
+	return Object.assign(tester, {
+		effect: effectLaneRefusal(tester.prop, refuseEffectLane),
+		scoped: effectLaneRefusal(tester.prop, refuseScopedLane),
+		scopedLive: effectLaneRefusal(tester.prop, refuseScopedLiveLane),
+		prop: prop$1,
+		law: property.law,
+		flakyTest: flakyTest$1,
+		layer
+	});
+};
+const refuseHookNow = () => {
+	throw refusalOf$1(refuseHook);
+};
+const takesHook = (args) => typeof args[0] === "function";
+const refuseHookPair = (fn, timeout) => {
+	return refuseHookNow();
+};
 /**
-* The fork's `it`: Vitest's test API with the fork's Effect lanes and lawful property lanes attached,
-* callable data-first (`it(name, body)`) or data-last (`it(body, options?)(name)`).
-*
 * @internal
 */
-const makeMethods$1 = (it) => makeItProxy(it, {
-	effect: makeTester((effect, env) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, testEnv(env))), it),
-	live: makeTesterWith((effect) => Effect.scoped(effect), it, () => realTime, true),
-	flakyTest: flakyTest$1,
-	layer: layer$1,
-	prop: prop$1,
-	law: property.law
-}, true);
-/** @internal */
-const { effect: effect$1, live: live$1 } = makeMethods$1(V.it);
-function makeItProxy(it, overrides, rerunnable) {
-	return new Proxy(it, {
-		apply: (target, thisArg, args) => routeCall(target, thisArg, args, rerunnable),
-		get: (target, property, receiver) => memberOrOverride(target, overrides, property, receiver)
-	});
-}
-function routeCall(target, thisArg, args, rerunnable) {
-	return isName(args[0]) ? applied(target, thisArg, args, rerunnable) : (name) => applied(target, thisArg, [
-		name,
-		args[0],
-		args[1]
-	], rerunnable);
-}
+const beforeEach$2 = Function.dual(takesHook, refuseHookPair);
 /**
-* The route's registration. Vitest takes `[name, body]`, `[name, body, options]` or `[name, options, body]`,
-* so the body is the argument that is a function, and it is the one the fork's bare lane wraps. Vitest's own
-* helpers (`it.skip`, `it.each`, ...) come through the proxy's `get` trap and are handed over untouched.
+* @internal
 */
-function applied(target, thisArg, args, rerunnable) {
-	Reflect.apply(target, thisArg, args.map((arg) => isFunction(arg) ? defaultLane(arg, rerunnable) : arg));
-}
-function memberOrOverride(target, overrides, property, receiver) {
-	return Object.hasOwn(overrides, property) ? memberOf(overrides, property, receiver) : memberOf(target, property, receiver);
-}
-function memberOf(target, property, receiver) {
-	return Reflect.get(target, property, receiver);
-}
+const afterEach$1 = Function.dual(takesHook, refuseHookPair);
+/**
+* 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
+*/
+const makeMethods$1 = (it) => {
+	const base = methodsFor((effect, env) => effect.pipe(Effect.scoped, (scoped) => Effect.provide(scoped, testEnv(env))), it, perRun, true, layer$1);
+	const live = makeTesterWith((effect) => Effect.scoped(effect), it, () => realTime, true);
+	return Object.assign(base, {
+		live,
+		layer: layer$1
+	});
+};
 const describeImpl = (name, f) => V.describe(name, {
 	concurrent: true,
 	shuffle: true
@@ -1389,60 +1216,50 @@ const describeWrapped$1 = Function.dual(byName, describeImpl);
 //#endregion
 //#region src/mod.ts
 /**
+* The fork's test API, with the generator lanes of R2 and R9.
+*
 * @since 4.0.0
 */
-const addEqualityTesters = addEqualityTesters$1;
+const it = makeMethods$1(V.it);
 /**
+* The same lanes under the other name upstream publishes.
+*
 * @since 4.0.0
 */
-const effect = effect$1;
+const test = it;
 /**
+* The fork's lawful collector: it forces the fork's concurrency and shuffle defaults and hands its body the
+* fork's methods.
+*
 * @since 4.0.0
 */
-const live = live$1;
+const describeWrapped = describeWrapped$1;
 /**
-* Share a `Layer` between multiple tests, optionally wrapping
-* the tests in a `describe` block if a name is provided.
-*
-* Named layers accept `concurrent` to override inherited suite concurrency.
-* Anonymous layers always inherit the enclosing suite's concurrency.
-* Use `ctx.expect` in concurrent tests for test-local snapshots and assertion counts.
-*
 * @since 4.0.0
+*/
+const describe = describeWrapped$1;
+/**
+* Share a `Layer` between multiple tests, optionally wrapping the tests in a `describe` block if a name is
+* provided. Every test in the block gets its own fresh build of the layer, unless the block declares
+* `shared: true`.
 *
 * ```ts
-* import { assert, layer } from "@systemfsoftware/vitest"
-* import { Effect, Layer, Context } from "effect"
+* import { it, layer } from "@systemfsoftware/vitest"
+* import { Context, Effect, Layer } from "effect"
 *
 * class Foo extends Context.Service<Foo, "foo">()("Foo") {
 *   static layer = Layer.succeed(Foo, "foo")
 * }
 *
-* class Bar extends Context.Service<Bar, "bar">()("Bar") {
-*   static layer = Layer.effect(
-*     Bar,
-*     Effect.map(Foo, () => "bar" as const)
-*   )
-* }
-*
 * layer(Foo.layer)("layer", (it) => {
-*   it.effect("adds context", () =>
-*     Effect.gen(function*() {
-*       const foo = yield* Foo
-*       assert.strictEqual(foo, "foo")
-*     }))
-*
-*   it.layer(Bar.layer)("nested", (it) => {
-*     it.effect("adds context", () =>
-*       Effect.gen(function*() {
-*         const foo = yield* Foo
-*         const bar = yield* Bar
-*         assert.strictEqual(foo, "foo")
-*         assert.strictEqual(bar, "bar")
-*       }))
+*   it("reads the service", function* ({ expect }) {
+*     const foo = yield* Foo
+*     yield* expect(foo).toEqual("foo")
 *   })
 * })
 * ```
+*
+* @since 4.0.0
 */
 const layer = layer$1;
 /**
@@ -1456,68 +1273,42 @@ const prop = prop$1;
 /**
 * @since 4.0.0
 */
-const owned = owned$1;
-/**
-* @since 4.0.0
-*/
-const recordAssertion = recordAssertion$1;
+const law = law$1;
 /**
-* The run binding of the test the effect is executing in. `bind` re-provides it
-* to an effect a library runs on a runtime of its own — its own scheduler, a
-* worker, a simulation kernel — so the checks inside it count as this test's
-* assertions, report softly, and see the same `owned` regions as the test.
+* The fork's test API over another Vitest `it`, so a library can register tests in its own suite.
 *
 * @since 4.0.0
 */
-const captureRunBinding = captureRunBinding$1;
+const makeMethods = makeMethods$1;
 /**
-* The key the running test's context is published under. A library that carries its own view of the task
-* context builds that view on this key, so the context a case lane sees and a property lane sees agree.
+* Refused: hooks share state between tests, and services come fresh per test from `layer`.
 *
 * @since 4.0.0
 */
-const vitestTestContextKey = vitestTestContextKey$1;
+const beforeEach = beforeEach$2;
 /**
-* The running Vitest `TestContext`, provided on every test the fork runs — the Effect lanes, both property
-* lanes, and each `it.each` row. It is `null` outside a run.
+* Refused: hooks share state between tests, and services come fresh per test from `layer`.
 *
 * @since 4.0.0
 */
-const VitestTestContext = VitestTestContext$1;
-/**
-* @since 4.0.0
-*/
-const it = makeMethods$1(V.it);
-/**
-* @since 4.0.0
-*/
-const makeMethods = makeMethods$1;
+const afterEach = afterEach$1;
 /**
 * @since 4.0.0
 */
-const describeWrapped = describeWrapped$1;
-const describe = describeWrapped$1;
+const addEqualityTesters = addEqualityTesters$1;
 /**
-* The fork's `expect`: soft within one Effect step, refusing the slop forms.
+* The key the running test's context is published under. A library that carries its own view of the task
+* context builds that view on this key, so the context a case lane sees and a property lane sees agree.
 *
 * @since 4.0.0
 */
-const expect = expect$1;
-/**
-* @since 4.0.0
-*/
-const beforeEach = beforeEach$1;
-/**
-* @since 4.0.0
-*/
-const afterEach = afterEach$1;
-/**
-* @since 4.0.0
-*/
-const beforeAll = beforeAll$1;
+const vitestTestContextKey = vitestTestContextKey$1;
 /**
+* The running Vitest `TestContext`, provided on every test the fork runs — every generator lane, both property
+* lanes, and each `it.each` row. It is `null` outside a run.
+*
 * @since 4.0.0
 */
-const afterAll = afterAll$1;
+const VitestTestContext = VitestTestContext$1;
 //#endregion
-export { VitestTestContext, addEqualityTesters, afterAll, afterEach, beforeAll, beforeEach, captureRunBinding, describe, describeWrapped, effect, expect, flakyTest, it, layer, live, makeMethods, owned, prop, recordAssertion, vitestTestContextKey };
+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 };