@systemfsoftware/vitest 0.0.0 → 0.2.0

package/dist/index.mjs

@@ -1,59 +1,88 @@
 
-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 { a as replayOfFailure, c as isFailureRecordError, f as InvalidBudget, h as Slop, i as makeProperty, l as throwFailureRecord, m as NonBooleanVerdict, o as testIdentityOf, p as LeakedState, r as createSpanRecorder, s as providedRoot } from "./failure-BquJJPFZ.mjs";
+import { a as isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-ChvjVyCo.mjs";
+import { S as unprovidedText, _ as refuseScopedLiveLane, d as refuseAsyncBody, f as refuseEffectLane, g as refuseScopedLane, i as markTask, l as noCheckRefusal, o as isRefusal$1, p as refuseHook, u as refusalOf$1, v as refuseSyncBody, y as refuseUnyielded } from "./guard-p_8ARgPm.mjs";
 import * 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, 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 Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as TestClock from "effect/testing/TestClock";
 import * as TestConsole from "effect/testing/TestConsole";
-import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
-import * as Data from "effect/Data";
+import * as Equal from "effect/Equal";
 import * as Clock from "effect/Clock";
-export * from "vitest";
-//#region src/internal/binding.ts
+import * as Scheduler from "effect/Scheduler";
+//#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).
+*/
+/**
+* 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 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;
-	}
+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;
@@ -67,653 +96,6 @@ const equalTester = (first, second) => equalTogether(first, second) ? true : voi
 const equalTogether = (first, second) => bothEqualable(first, second) && Equal.equals(first, second);
 const bothEqualable = (first, second) => Equal.isEqual(first) && Equal.isEqual(second);
 //#endregion
-//#region src/internal/errors.schema.ts
-/** @internal */
-var NonBooleanVerdict = class extends Schema.TaggedError()("NonBooleanVerdict", { detail: Schema.String }) {
-	get message() {
-		return this.detail;
-	}
-};
-/** @internal */
-var LeakedState = class extends Schema.TaggedError()("LeakedState", { detail: Schema.String }) {
-	get message() {
-		return this.detail;
-	}
-};
-/** @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;
-	}
-};
-/** @internal */
-var InvalidBudget = class extends Schema.TaggedError()("InvalidBudget", { detail: Schema.String }) {
-	get message() {
-		return this.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.
-*
-* A class fails only when QuickCheck's sequential test (`stdConfidence`) is confident its share is below
-* the minimum, and is satisfied once the test is confident the share is at least 0.9 of the minimum
-* (`TOLERANCE` at a certainty of 10^9). The tolerance is what makes the test terminate: a class sitting
-* exactly at its minimum would otherwise draw forever.
-*/
-const CERTAINTY = 10 ** 9;
-const TOLERANCE = .9;
-const FIRST_BATCH = 64;
-const BATCH_CAP = 4096;
-const DRAW_CAP = 1e5;
-const FAILURE_HEAD = "coverage";
-/** The certainty's two-sided tail probability: `alpha / 2` for `alpha = 1 / CERTAINTY`. */
-const TAIL_PROBABILITY = 1 / (2 * CERTAINTY);
-const C1 = -.007784894002430293;
-const C2 = -.3223964580411365;
-const C3 = -2.400758277161838;
-const C4 = -2.549732539343734;
-const C5 = 4.374664141464968;
-const C6 = 2.938163982698783;
-const D1 = .007784695709041462;
-const D2 = .3224671290700398;
-const D3 = 2.445134137142996;
-const D4 = 3.754408661907416;
-const TAIL_NUMERATOR = [
-	C1,
-	C2,
-	C3,
-	C4,
-	C5,
-	C6
-];
-const TAIL_DENOMINATOR = [
-	D1,
-	D2,
-	D3,
-	D4
-];
-/** Horner's rule over a coefficient list, highest power first. */
-const poly = (coefficients, x) => coefficients.reduceRight((total, coefficient) => total * x + coefficient, 0);
-const tailSpread = (p) => Math.sqrt(-2 * Math.log(p));
-const tailInverse = (spread) => poly(TAIL_NUMERATOR, spread) / poly(TAIL_DENOMINATOR, spread);
-/** The inverse standard-normal CDF at the tail probability the certainty asks for. */
-const TAIL_Z = tailInverse(tailSpread(TAIL_PROBABILITY));
-const wilson = (hits, runs, z) => {
-	const share = hits / runs;
-	const zz = z * z;
-	return (share + zz / (2 * runs) + z * Math.sqrt(share * (1 - share) / runs + zz / (4 * runs * runs))) / (1 + zz / runs);
-};
-/**
-* Thrown when a coverage class is confidently below its minimum share of runs.
-*
-* @internal
-*/
-var CoverageBelowMinimum = class extends Data.Error {};
-const wilsonLower = (entry, runs) => wilson(entry.hits, runs, -TAIL_Z);
-const wilsonUpper = (entry, runs) => wilson(entry.hits, runs, TAIL_Z);
-const covered = (entry, runs) => wilsonLower(entry, runs) >= TOLERANCE * entry.minimum;
-const uncovered = (entry, runs) => wilsonUpper(entry, runs) < entry.minimum;
-const decided = (entry, runs) => covered(entry, runs) || uncovered(entry, runs);
-const settled = (entry, runs) => runs === 0 ? false : decided(entry, runs);
-const entriesOf = (classes) => Object.keys(classes).map((label) => entryAt(classes, label));
-const entryAt = (classes, label) => [label, classOf(classes, label)];
-const classOf = (classes, label) => classes[label] ?? {
-	hits: 0,
-	minimum: 0
-};
-const judgeOf = (classes, runs) => ({
-	classes: new Map(entriesOf(classes)),
-	runs
-});
-const openLabels = (judge) => [...judge.classes].filter(([, entry]) => !settled(entry, judge.runs)).map(([label]) => label);
-const failedEntries = (judge) => [...judge.classes].filter(([, entry]) => uncovered(entry, judge.runs));
-const describeShare = (hits, runs) => `${String(hits)}/${String(runs)}`;
-const describeFailure = (label, entry, runs) => `${FAILURE_HEAD} ${label}: ${describeShare(entry.hits, runs)} of runs, below the required ${String(entry.minimum)}`;
-const reportFailures = (judge) => failedEntries(judge).map(([label, entry]) => describeFailure(label, entry, judge.runs)).join("\n");
-/** @internal */
-const countHit = Function.dual(2, (classes, label) => {
-	const prior = classes.get(label);
-	if (prior !== void 0) classes.set(label, {
-		hits: prior.hits + 1,
-		minimum: prior.minimum
-	});
-});
-const countLabels = (classes, labels) => {
-	for (const label of labels) countHit(classes, label);
-	return classes;
-};
-const countDraws = (classes, drawn) => drawn.reduce(countLabels, new Map(classes));
-const withDraws = (judge, drawn) => ({
-	classes: countDraws(judge.classes, drawn),
-	runs: judge.runs + drawn.length
-});
-const drawBatch = (judge, draw, batch) => withDraws(judge, draw.more(sizeOf(judge, batch)));
-const sizeOf = (judge, batch) => Math.min(batch, DRAW_CAP - judge.runs);
-const grown = (batch) => Math.min(batch * 2, BATCH_CAP);
-const keepDrawing = (judge) => openLabels(judge).length > 0 && judge.runs < DRAW_CAP;
-const toppedUp = (judge, draw, batch) => keepDrawing(judge) ? toppedUp(drawBatch(judge, draw, batch), draw, grown(batch)) : judge;
-const reportOf$1 = (judge) => failedEntries(judge).length === 0 ? void 0 : reportFailures(judge);
-/**
-* Runs R14's sequential draw: tops up the undecided classes until every class is decided or the draw cap
-* is reached, then reports the confidently under-covered classes, naming each label and its observed share.
-*
-* @internal
-*/
-const judgeCoverage = (options) => reportOf$1(toppedUp(judgeOf(options.classes, options.runs), options.draw, FIRST_BATCH));
-//#endregion
-//#region src/internal/property/error.schema.ts
-/**
-* Thrown at file end when no property in the file refuted a subject's constant impostor (R12).
-*
-* @internal
-*/
-var VacuousProperty = class extends Schema$1.TaggedError()("VacuousProperty", { detail: Schema$1.String }) {
-	get message() {
-		return this.detail;
-	}
-};
-/**
-* Thrown when a law kind is given a record `of`, which cannot be spread into its subject.
-*
-* @internal
-*/
-var NonTupleOf = class extends Schema$1.TaggedError()("NonTupleOf", { detail: Schema$1.String }) {
-	get message() {
-		return this.detail;
-	}
-};
-//#endregion
-//#region src/internal/property/impostor.ts
-const SUBJECT_KEY = "the subject";
-const NO_VALUE = "";
-const isCallable = (value) => typeof value === "function";
-const isCallableSubject = (target) => typeof target === "function";
-const describeValue = (value) => isCallable(value) ? "a function" : String(value);
-const describeEntry = (key, value) => `${key} always returned ${describeValue(value)}`;
-const emptyState = () => ({ outputs: /* @__PURE__ */ new Map() });
-const frozenAt = (state, key, compute) => state.outputs.has(key) ? state.outputs.get(key) : remember(state, key, compute());
-const remember = (state, key, value) => {
-	state.outputs.set(key, value);
-	return value;
-};
-const callOutput = (state, fn, thisArg, args) => frozenAt(state, SUBJECT_KEY, () => Reflect.apply(fn, thisArg, args));
-const memberWrapper = (state, key, fn) => (...values) => frozenAt(state, key, () => Reflect.apply(fn, void 0, values));
-const memberWrapperOf = (state, fn, key) => fn === void 0 ? void 0 : memberWrapper(state, key, fn);
-const appliedImpostor = (state, target, thisArg, args) => isCallableSubject(target) ? callOutput(state, target, thisArg, args) : void 0;
-const memberImpostor = (state, target, key) => memberWrapperOf(state, target[key], key);
-const readImpostor = (state, target, property) => isCallableSubject(target) ? Reflect.get(target, property, target) : memberRead(state, target, property);
-const memberRead = (state, target, property) => typeof property === "string" ? memberImpostor(state, target, property) : void 0;
-const impostorHandler = (state) => ({
-	apply: (target, thisArg, args) => appliedImpostor(state, target, thisArg, args),
-	get: (target, property) => readImpostor(state, target, property)
-});
-const describeFrozen = (state) => [...state.outputs].map(([key, value]) => describeEntry(key, value)).join("; ");
-/**
-* A constant impostor of `subject`: a function returns its first output forever, and so does each member
-* of a record.
-*
-* @internal
-*/
-const impostorOf = (subject) => {
-	const state = emptyState();
-	return {
-		impostor: new Proxy(subject, impostorHandler(state)),
-		frozen: () => describeFrozen(state)
-	};
-};
-/** @internal */
-const subjectLabel = (subject) => isCallableSubject(subject) ? `a function of ${String(subject.length)} argument(s)` : `a record of ${Object.keys(subject).sort().join(", ")}`;
-const judgeFor = (subject) => ({
-	label: subjectLabel(subject),
-	properties: [],
-	refuters: [],
-	frozen: NO_VALUE,
-	runs: 0
-});
-const trackProperty = (judge, property) => judge.properties.includes(property) ? judge : {
-	...judge,
-	properties: [...judge.properties, property]
-};
-const trackRefuter = (judge, property) => judge.refuters.includes(property) ? judge : {
-	...judge,
-	refuters: [...judge.refuters, property]
-};
-const trackVerdict = (judge, property, verdict) => {
-	const named = trackProperty(judge, property);
-	return verdict.refuted ? trackRefuter(named, property) : {
-		...named,
-		frozen: verdict.frozen,
-		runs: verdict.runs
-	};
-};
-const recordJudge = (state, subject, property, verdict) => {
-	const prior = state.judges.get(subject) ?? judgeFor(subject);
-	state.judges.set(subject, trackVerdict(prior, property, verdict));
-};
-const isVacuous = (judge) => judge.refuters.length === 0;
-const describeVacuous = (judge) => `${judge.properties.join(", ")}: no property in this file refuted the constant impostor of this subject (${judge.label}), so nothing here pins it down. It held for ${judge.runs} run(s) against a fake that ${judge.frozen === NO_VALUE ? "was never called" : judge.frozen}, whatever the input. Laws that only relate outputs to each other (additivity, idempotence, commutativity, round trips through the subject) hold for such constants. Pin the output to the input: compare against an independent model (\`subject(x)\` equals a straightforward reimplementation), or conjoin a base case (\`subject([one])\` equals its known value). Also check that the body calls the \`subject\` it was given, not the imported implementation.`;
-const finaliseJudges = (state, onProblems) => {
-	const vacuous = [...state.judges.values()].filter(isVacuous).map(describeVacuous);
-	if (vacuous.length === 0) return;
-	throw onProblems(vacuous.join("\n\n"));
-};
-const ledgerOf = (state, onProblems) => ({
-	record: (subject, property, verdict) => recordJudge(state, subject, property, verdict),
-	finalise: () => finaliseJudges(state, onProblems)
-});
-/**
-* Collects the impostor verdicts of every property in the file and decides, at file end, which subjects
-* nothing refuted.
-*
-* @internal
-*/
-const makeFileLedger = (onProblems) => ledgerOf({ judges: /* @__PURE__ */ new Map() }, onProblems);
-//#endregion
-//#region src/internal/property/kinds.ts
-/**
-* @internal The R13 law kinds: `model`, `metamorphic`, `roundTrip` and `invariant` are sugar over the
-* gated property (R11/R12); `idempotent` and `deterministic` are declared exempt — they skip the impostor
-* gate, are reported as exempt, and are the only exemptions.
-*
-* Each kind owns the comparison, so there is nowhere to write `return true`: the author hands over
-* functions, and the kind relates their outputs with Effect's structural `Equal`.
-*/
-/**
-* The generated values as the argument list a law subject is called with.
-*
-* @internal
-*/
-const spreadValues = (values) => Array.isArray(values) ? values : refuseRecordOf();
-const refuseRecordOf = () => {
-	throw new NonTupleOf({ detail: "a law kind spreads the generated values into its subject, so `of` must be a tuple; a record `of` holds functions of the record, which only it.prop reaches" });
-};
-const call = (subject, values) => subject(...spreadValues(values));
-const equalOutputs = (original, transformed) => Equal.equals(original, transformed);
-/** @internal */
-const modelHolds = (oracle) => (subject, values) => Equal.equals(call(subject, values), call(oracle, values));
-/** @internal */
-const metamorphicHolds = (relation) => (subject, values) => (relation.relate ?? equalOutputs)(call(subject, values), call(subject, relation.transform(...spreadValues(values))));
-/** @internal */
-const roundTripHolds = (decode) => (subject, values) => Equal.equals(decode(call(subject, values)), values);
-/** @internal */
-const invariantHolds = (holds) => (subject, values) => holds(call(subject, values), ...spreadValues(values));
-const firstOf = (values) => values[0];
-const sameTwice = (subject, value) => value === void 0 ? false : Equal.equals(subject(subject(value)), subject(value));
-/** @internal */
-const idempotentHolds = () => (subject, values) => sameTwice(subject, firstOf(spreadValues(values)));
-/** @internal */
-const deterministicHolds = () => (subject, values) => Equal.equals(call(subject, values), call(subject, values));
-//#endregion
-//#region src/internal/property/engine.ts
-/**
-* @internal The lawful property engine (R11-R15): a property names the function under test, takes a budget
-* that merges its own fields over the configured default over `runs: 100`, accepts only a literal boolean
-* verdict (or an `Effect` of one), judges coverage classes with QuickCheck's sequential test, and defers the
-* constant-impostor verdict to the end of the file.
-*
-* `of` accepts what upstream accepts — a tuple or record of Schemas or Arbitraries (KTD10) — and `holds`
-* receives the generated values exactly as drawn, typed by the gens that produced them.
-*/
-const REWRITE = "it.prop(name, { of, subject, runs }, holds)";
-const DEFAULT_RUNS = 100;
-const isPositiveInteger = (runs) => Number.isInteger(runs) && runs > 0;
-const describeRuns = (runs) => Number.isInteger(runs) ? `${String(runs)}` : "a non-integer";
-const invalidPropertyBudget = (name, runs) => `${name}: pass a positive integer \`runs\`; received ${describeRuns(runs)}. Write ${REWRITE}.`;
-const invalidProvidedBudget = (runs) => `the configured property budget (${checkDefaultsKey}) supplies \`runs\`: ${describeRuns(runs)}; it must be a positive integer.`;
-const requirePositiveRuns = (message, runs) => {
-	if (isInvalidRuns(runs)) throw new InvalidBudget({ detail: message(runs) });
-};
-const isInvalidRuns = (runs) => runs !== void 0 && isPositiveInteger(runs) === false;
-/** The property's own explicit fields, a property-level `runs` outranking the same field in `arbitrary`. */
-const explicitOptions = (spec) => spec.runs === void 0 ? { ...spec.arbitrary } : {
-	...spec.arbitrary,
-	runs: spec.runs
-};
-const mergedOptions = (provided, explicit) => ({
-	runs: DEFAULT_RUNS,
-	...provided,
-	...explicit
-});
-const resolvedRuns = (options) => options.runs ?? DEFAULT_RUNS;
-/**
-* The effective check options: the property's own fields over the configured default over `runs: 100`,
-* merged field by field so a property that sets only `runs` still inherits the configured size and caps.
-*/
-const resolveBudget = (name, spec, provided) => {
-	const explicit = explicitOptions(spec);
-	requirePositiveRuns((runs) => invalidPropertyBudget(name, runs), explicit.runs);
-	requirePositiveRuns(invalidProvidedBudget, provided?.runs);
-	const options = mergedOptions(provided, explicit);
-	return {
-		runs: resolvedRuns(options),
-		options
-	};
-};
-const toArbitrary = (input) => Schema$1.isSchema(input) ? Arbitrary.schema(input) : input;
-const assignArbitrary = (built, of, key) => {
-	const input = of[key];
-	if (input !== void 0) built[key] = toArbitrary(input);
-};
-const recordArbitraries = (of) => {
-	const built = {};
-	for (const key of Object.keys(of)) assignArbitrary(built, of, key);
-	return built;
-};
-const isTupleOf = (of) => Array.isArray(of);
-function arbitraryOf(of) {
-	return isTupleOf(of) ? Arbitrary.all(of.map(toArbitrary)) : Arbitrary.all(recordArbitraries(of));
-}
-const minimumOf = (entry) => entry[1];
-const seedClasses = (entries) => {
-	const classes = /* @__PURE__ */ new Map();
-	for (const [label, entry] of entries) classes.set(label, {
-		hits: 0,
-		minimum: minimumOf(entry)
-	});
-	return classes;
-};
-const satisfiedLabels = (entries, values) => entries.filter(([, entry]) => entry[0](...spreadValues(values))).map(([label]) => label);
-const observeRun = (classes, counter, entries, values) => {
-	counter.runs = counter.runs + 1;
-	for (const label of satisfiedLabels(entries, values)) countHit(classes, label);
-};
-const drawFor = (entries, arbitrary) => ({ more: (count) => Effect.runSync(Arbitrary.sampleEffect(arbitrary, { count }).pipe(Effect.orDie)).map((values) => satisfiedLabels(entries, values)) });
-const noCoverage = () => ({
-	observe: () => void 0,
-	judge: () => void 0
-});
-const liveCoverage = (cover, arbitrary) => {
-	const entries = Object.entries(cover);
-	const classes = seedClasses(entries);
-	const counter = { runs: 0 };
-	return {
-		observe: (values) => observeRun(classes, counter, entries, values),
-		judge: () => judgeCoverage({
-			classes: Object.fromEntries(classes),
-			runs: counter.runs,
-			draw: drawFor(entries, arbitrary)
-		})
-	};
-};
-const makeCoverage = (cover, arbitrary) => cover === void 0 ? noCoverage() : liveCoverage(cover, arbitrary);
-const describeVerdict = (verdict) => Effect.isEffect(verdict) ? "an Effect, which this lane never runs" : `a ${typeof verdict}`;
-const nonBoolean = (verdict, violations) => {
-	violations.add(describeVerdict(verdict));
-	return true;
-};
-const literalVerdict = (verdict, violations) => typeof verdict === "boolean" ? verdict : nonBoolean(verdict, violations);
-const effectVerdict = (lane, verdict, violations) => lane === "sync" ? Effect.succeed(nonBoolean(verdict, violations)) : Effect.map(verdict, (value) => literalVerdict(value, violations));
-const verdictFor = (run, values, violations) => {
-	run.observe(values);
-	const verdict = run.holds(run.subject, values);
-	return Effect.isEffect(verdict) ? effectVerdict(run.lane, verdict, violations) : Effect.succeed(literalVerdict(verdict, violations));
-};
-const tolerateInterruption = (cause) => Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.fail(cause);
-const guardedVerdict = (run, violations) => (values) => Effect.catchCause(Effect.suspend(() => verdictFor(run, values, violations)), tolerateInterruption);
-const violationMessage = (name, violations) => `${name}: the property returned no boolean; it returned ${violations.join(", ")}. A property must return a literal boolean verdict — asserting with expect(), or returning an Option, Result or object, is not a verdict; write ${REWRITE}.`;
-const runCheck = (run) => {
-	const violations = /* @__PURE__ */ new Set();
-	return Arbitrary.checkEffect(run.arbitrary, guardedVerdict(run, violations), run.options).pipe(Effect.map((result) => ({
-		violations,
-		result
-	})));
-};
-const reportOf = (checked) => Arbitrary.formatCheckFailure(checked.result);
-const violationOf = (name, checked) => checked.violations.size === 0 ? void 0 : violationMessage(name, [...checked.violations]);
-const isRefuted = (checked) => checked.violations.size > 0 || reportOf(checked) !== void 0;
-const dieViolation = (detail) => Effect.die(new NonBooleanVerdict({ detail }));
-const dieReported = (name, report) => Effect.die(/* @__PURE__ */ new Error(`${name}: the property was falsified. ${report}`));
-const dieUncovered = (failure) => Effect.die(new CoverageBelowMinimum({ message: failure }));
-const impostorHolds = (holds, impostor) => (_subject, values) => holds(impostor.impostor, values);
-const recordImpostor = (run, budget, impostor, checked) => {
-	const verdict = {
-		refuted: isRefuted(checked),
-		frozen: impostor.frozen(),
-		runs: budget.runs
-	};
-	gatedLedger.record(run.subject, run.name, verdict);
-};
-const impostorRun = (run, budget) => {
-	const impostor = impostorOf(run.subject);
-	const retry = {
-		...run,
-		holds: impostorHolds(run.holds, impostor),
-		observe: noObserve
-	};
-	return runCheck(retry).pipe(Effect.map((checked) => recordImpostor(retry, budget, impostor, checked)));
-};
-const noObserve = () => void 0;
-const gateRun = (run, budget, gate) => gate ? impostorRun(run, budget) : Effect.void;
-const finishPassed = (run, budget, coverage, gate) => {
-	const failure = coverage.judge();
-	return failure === void 0 ? gateRun(run, budget, gate) : dieUncovered(`${run.name}: ${failure}`);
-};
-const settleReport = (run, budget, coverage, gate, report) => report === void 0 ? finishPassed(run, budget, coverage, gate) : dieReported(run.name, report);
-const settle = (registration, run, budget, coverage, checked) => {
-	const violation = violationOf(registration.name, checked);
-	return violation === void 0 ? settleReport(run, budget, coverage, registration.gate, reportOf(checked)) : dieViolation(violation);
-};
-const checkOf = (registration, arbitrary, budget, observe) => ({
-	name: registration.name,
-	lane: registration.lane,
-	subject: registration.spec.subject,
-	holds: registration.holds,
-	arbitrary,
-	observe,
-	options: budget.options
-});
-const program = (registration) => Effect.gen(function* () {
-	const budget = resolveBudget(registration.name, registration.spec, providedCheckDefaults());
-	const arbitrary = arbitraryOf(registration.spec.of);
-	const coverage = makeCoverage(registration.spec.cover, arbitrary);
-	const run = checkOf(registration, arbitrary, budget, coverage.observe);
-	const checked = yield* runCheck(run);
-	yield* settle(registration, run, budget, coverage, checked);
-});
-const programOf = (registration) => () => registration.runtime.provide(program(registration));
-const selfModelMessage = (name) => `${name}: the model is the subject itself; a model law must compare against an independent oracle.`;
-const gatedLedger = makeFileLedger((message) => new VacuousProperty({ detail: message }));
-V.afterAll(() => {
-	gatedLedger.finalise();
-});
-const registeredName = (name, kind, exempt) => exempt ? `${name} [exempt: ${kind}]` : name;
-const isSelfModel = (subject, oracle) => Object.is(subject, oracle);
-/**
-* The property surface over one runtime: `prop`, `effectProp`, and the R13 law kinds routed through the gate.
-*
-* @internal
-*/
-const makeProperty = (runtime) => {
-	const body = (name, spec, holds, lane, gate) => {
-		const registration = {
-			runtime,
-			name,
-			spec,
-			holds,
-			lane,
-			gate
-		};
-		runtime.register(name, programOf(registration));
-	};
-	const refuseSelfModel = (name) => {
-		runtime.register(name, () => Effect.die(new VacuousProperty({ detail: selfModelMessage(name) })));
-	};
-	const gated = (name, spec, holds, kind, exempt) => body(registeredName(name, kind, exempt), spec, holds, "sync", exempt === false);
-	const model = (name, spec, oracle) => isSelfModel(spec.subject, oracle) ? refuseSelfModel(name) : gated(name, spec, modelHolds(oracle), "model", false);
-	const idempotent = (name, spec) => gated(name, spec, idempotentHolds(), "idempotent", true);
-	const deterministic = (name, spec) => gated(name, spec, deterministicHolds(), "deterministic", true);
-	return {
-		prop: (name, spec, holds) => body(name, spec, holds, "sync", true),
-		effectProp: (name, spec, holds) => body(name, spec, holds, "effect", true),
-		law: {
-			model,
-			metamorphic: (name, spec, relation) => gated(name, spec, metamorphicHolds(relation), "metamorphic", false),
-			roundTrip: (name, spec, decode) => gated(name, spec, roundTripHolds(decode), "roundTrip", false),
-			invariant: (name, spec, holds) => gated(name, spec, invariantHolds(holds), "invariant", false),
-			idempotent,
-			deterministic
-		}
-	};
-};
-//#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 +267,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 +290,73 @@ 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 logErrors = (cause) => Effect.forEach(Cause.prettyErrors(cause), (error) => Effect.logError(error), { discard: true });
-const failedAfter = (ctx, before) => () => errorCount(ctx) > before;
+const propertyEnv = realTime;
+const payloadOf = (reason) => Cause.isFailReason(reason) ? reason.error : reasonDefectOf(reason);
+const reasonDefectOf = (reason) => Cause.isDieReason(reason) ? reason.defect : void 0;
+const isLoggable = (thrown) => (reason) => !Cause.isInterruptReason(reason) && payloadOf(reason) !== thrown;
+const unthrownOf = (cause) => cause.pipe(Cause.squash, isLoggable, (loggable) => Cause.fromReasons(cause.reasons.filter(loggable)));
+const logUnthrownErrors = (cause) => cause.pipe(unthrownOf, Cause.prettyErrors, Effect.forEach((error) => Effect.logError(error), { discard: true }));
 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 refuseUnprovided = (failure) => {
+	if (isUnprovided(failure)) throw new Slop({ detail: unprovidedText });
+};
 const rethrowSquashed = (cause) => {
 	const error = Cause.squash(cause);
-	if (isUnprovided(error)) throw new Slop({ detail: refuseUnprovided });
+	refuseUnprovided(error);
 	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) => logUnthrownErrors(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 +366,126 @@ 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 rethrowRendered = (failure) => {
+	if (isFailureRecordError(failure)) throw failure;
+};
+const throwRecorded = (cause, recorder, ctx) => {
+	const failure = Cause.squash(cause);
+	rethrowRendered(failure);
+	refuseUnprovided(failure);
+	return throwFailureRecord({
+		failure,
+		spans: recorder.spans,
+		identity: testIdentityOf(ctx.task),
+		replay: replayOfFailure(failure),
+		root: providedRoot()
+	});
+};
+const failRecorded = (cause, recorder, ctx) => logUnthrownErrors(cause).pipe(Effect.runPromise).then(() => throwRecorded(cause, recorder, ctx));
+const reportRecorded = (exit, recorder, ctx) => Exit.isSuccess(exit) ? Promise.resolve(exit.value) : failRecorded(exit.cause, recorder, ctx);
+/**
+* One test's run, recorded: its own in-memory tracer collects the spans the record is rendered from, and a failure
+* leaves as the rendered record instead of a raw Cause (KTD2, R2, R7, R8).
+*/
+const runRecorded = (effect, ctx, env) => {
+	const recorder = createSpanRecorder();
+	const promise = runExit(effect.pipe(Effect.withTracer(recorder.tracer)), ctx, env).then((exit) => reportRecorded(exit, recorder, ctx));
+	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.
-*/
-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 });
+* 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) => 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);
+/**
+* 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 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 runRecorded(mapEffect(bindRun(drive(bodyOf(ledger, body), [], ledger), ctx), env), ctx, env);
 };
-const refuseAfter = (promise) => {
-	Promise.resolve(promise).catch(noop);
-	return refusePromiseBody();
+const outcomeOf = (promise) => promise.then(() => void 0, (error) => error);
+const isSlop = (error) => Schema.is(Slop)(error);
+/** Every failure the fork itself names: the branded refusals, plus the Schema-tagged families. */
+const otherRefusals = [
+	isSlop,
+	Schema.is(InvalidBudget),
+	Schema.is(NonBooleanVerdict),
+	Schema.is(LeakedState)
+];
+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) });
 };
-const checkPromiseBody = (output) => {
-	if (isPromiseLike(output)) refuseAfter(output);
+/**
+* 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 throwSecondRun = (error) => {
+	if (isRefusal(error)) throw error;
+	return throwLeaked(error);
 };
-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 leakedOrNothing = (error) => {
+	if (error !== void 0) throwSecondRun(error);
 };
-const runBuilt = (ctx, env, mapOne, output, shadow) => runTest(ctx, env)(mapOne(bindRun(Effect.suspend(() => output), ctx, shadow)));
+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 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).
+* 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) => buildSingleRun(() => program(), (effect) => effect, propertyEnv, false)(ctx);
+const runProperty = (ctx, program) => runRecorded(bindRun(Effect.suspend(program), ctx), ctx, propertyEnv);
 const property = makeProperty({
-	register: (name, program) => {
-		V.it(name, (ctx) => runProperty(ctx, program));
-	},
+	register: (name, program) => marked(() => 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);
 };
 /** @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 = [
-	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" });
-};
-/** 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 law kinds over the sync property family: the top-level `it.law`.
+*
+* @internal
 */
-const assertionCalls = (ctx) => ctx.expect.getState().assertionCalls;
-const gateNoAssertion = (ctx) => {
-	if (silentRun(ctx)) throwNoAssertion();
-};
-const throwNoAssertion = () => {
-	throw new Slop({ detail: refuseNoAssertion });
-};
-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 law$1 = property.law;
 const CONCURRENT_BLOCK = {
 	concurrent: true,
 	shuffle: true
@@ -1158,25 +503,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 +544,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 +578,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 +588,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 +607,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 +634,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 +642,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 });
+const refuseHabitLane = (text) => {
+	throw refusalOf$1(text);
+};
+const effectLaneRefusal = (prop, text) => Object.assign(() => refuseHabitLane(text), { prop });
+/**
+* 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 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
+	});
 };
-/** 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 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);
 };
-/** 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 takesHook = (args) => typeof args[0] === "function";
+const refuseHookPair = (fn, timeout) => {
+	return refuseHookNow();
 };
 /**
-* 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).
+* @internal
 */
-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 beforeEach$2 = Function.dual(takesHook, refuseHookPair);
 /**
-* 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 afterEach$1 = 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.
+* 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
 */
-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 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 +746,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 +803,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 };