@systemfsoftware/vitest 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1523 @@
+
+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 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 * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+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 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
+/**
+* The run a test's fibers execute in. Effect code reads it through
+* `Fiber.getCurrent`, so no node-only store is needed (KTD4).
+*
+* @internal
+*/
+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;
+	}
+});
+/**
+* The run the current execution belongs to: the fiber's binding first, then the
+* synchronous slot for code that runs outside a fiber.
+*
+* @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;
+//#endregion
+//#region src/internal/equal.ts
+let registered = false;
+/** @internal */
+const registerEqualTester = () => {
+	if (registered) return;
+	registered = true;
+	V.expect.addEqualityTesters([equalTester]);
+};
+const equalTester = (first, second) => equalTogether(first, second) ? true : void 0;
+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) => {
+	const time = first.at - second.at;
+	if (time !== 0) return time;
+	return tieBreak(first, second);
+};
+const tieBreak = (first, second) => {
+	const role = Number(first.observer) - Number(second.observer);
+	if (role !== 0) return role;
+	return first.sequence - second.sequence;
+};
+const sortSleepers = (sleepers) => {
+	sleepers.sort(byWakeOrder);
+};
+const dueNow = (sleepers, now, observer) => sleepers.filter((sleeper) => sleeper.at <= now && sleeper.observer === observer);
+const removeAll = (time, due) => {
+	due.forEach((sleeper) => time.removeSleeper(sleeper));
+};
+const wakeAll = (due) => {
+	due.forEach((sleeper) => sleeper.wake());
+};
+const runnable = (frozen, queued) => frozen === false && queued > 0;
+const settledForAdvance = (frozen, pending, queued) => runnable(frozen, queued) && pending === 0;
+const shouldStartAdvance = (watching, time) => watching.checking === false && runnable(watching.frozen, time.sleepers().length);
+const removeEntry = (entries, entry) => {
+	const index = entries.indexOf(entry);
+	if (index !== -1) entries.splice(index, 1);
+};
+const makeVirtualTime = () => {
+	const sleepers = [];
+	const state = {
+		now: 0,
+		sequence: 0,
+		pending: 0
+	};
+	return {
+		now: () => state.now,
+		sleepers: () => sleepers,
+		addSleeper: (sleeper) => {
+			sleepers.push(sleeper);
+		},
+		removeSleeper: (sleeper) => removeEntry(sleepers, sleeper),
+		advanceTo: (at) => {
+			state.now = Math.max(state.now, at);
+		},
+		claimSequence: () => claimNext(state),
+		pendingTasks: () => state.pending,
+		beginTask: () => {
+			state.pending = state.pending + 1;
+		},
+		completeTask: () => {
+			state.pending = state.pending - 1;
+		}
+	};
+};
+const claimNext = (state) => {
+	const claimed = state.sequence;
+	state.sequence = claimed + 1;
+	return claimed;
+};
+const runTracked = (time, task, advance) => {
+	try {
+		task();
+	} finally {
+		time.completeTask();
+		if (time.pendingTasks() === 0) advance();
+	}
+};
+const sleepUntil = (time, advance, observerOf, duration) => {
+	if (Duration.toMillis(duration) <= 0) return Effect.void;
+	return Effect.flatMap(Effect.fiberId, (fiberId) => Effect.callback((resume) => {
+		const sleeper = {
+			at: time.now() + Duration.toMillis(duration),
+			observer: fiberId === observerOf(),
+			sequence: time.claimSequence(),
+			wake: () => resume(Effect.void)
+		};
+		time.addSleeper(sleeper);
+		advance();
+		return Effect.sync(() => time.removeSleeper(sleeper));
+	}));
+};
+/** @internal */
+const makeVirtualRuntime = () => {
+	const inner = new Scheduler.MixedScheduler();
+	const time = makeVirtualTime();
+	const watching = {
+		checking: false,
+		frozen: false,
+		observer: -1
+	};
+	const advanceWhenIdle = () => {
+		if (shouldStartAdvance(watching, time) === false) return;
+		watching.checking = true;
+		setImmediate(advanceFromIdle);
+	};
+	const advanceFromIdle = () => {
+		watching.checking = false;
+		if (settledForAdvance(watching.frozen, time.pendingTasks(), time.sleepers().length) === false) return;
+		wakeEarliest(time);
+		advanceWhenIdle();
+	};
+	const scheduler = {
+		executionMode: inner.executionMode,
+		shouldYield: (fiber) => inner.shouldYield(fiber),
+		makeDispatcher: () => {
+			const dispatcher = inner.makeDispatcher();
+			return {
+				scheduleTask: (task, priority) => {
+					time.beginTask();
+					dispatcher.scheduleTask(() => runTracked(time, task, advanceWhenIdle), priority);
+				},
+				flush: () => dispatcher.flush()
+			};
+		}
+	};
+	return {
+		clock: {
+			currentTimeMillisUnsafe: () => time.now(),
+			currentTimeMillis: Effect.sync(() => time.now()),
+			currentTimeNanosUnsafe: () => roundNanos(time.now()),
+			currentTimeNanos: Effect.sync(() => roundNanos(time.now())),
+			monotonicTimeNanosUnsafe: () => roundNanos(time.now()),
+			monotonicTimeNanos: Effect.sync(() => roundNanos(time.now())),
+			sleep: (duration) => sleepUntil(time, advanceWhenIdle, () => watching.observer, duration)
+		},
+		scheduler,
+		observe: Effect.flatMap(Effect.fiberId, (id) => Effect.sync(() => {
+			watching.observer = id;
+		})),
+		end: Effect.sync(() => {
+			watching.frozen = true;
+		})
+	};
+};
+const wakeEarliest = (time) => {
+	const ordered = [...time.sleepers()];
+	sortSleepers(ordered);
+	const first = ordered[0];
+	if (first === void 0) return;
+	time.advanceTo(first.at);
+	const due = dueNow(time.sleepers(), time.now(), first.observer);
+	removeAll(time, due);
+	wakeAll(due);
+};
+/**
+* The clock a virtual-time test runs on: a `Clock` that also answers the
+* `TestClock` interface, so `TestClock.adjust` moves virtual time by letting
+* that much time pass instead of waiting for a real clock (KTD6, R7).
+*
+* @internal
+*/
+const virtualClockLayer = (runtime) => Layer.succeed(Clock.Clock, virtualClockOf(runtime));
+const virtualClockOf = (runtime) => {
+	const live = runtime.clock;
+	return {
+		currentTimeMillisUnsafe: () => live.currentTimeMillisUnsafe(),
+		currentTimeMillis: Effect.sync(() => live.currentTimeMillisUnsafe()),
+		currentTimeNanosUnsafe: () => live.currentTimeNanosUnsafe(),
+		currentTimeNanos: Effect.sync(() => live.currentTimeNanosUnsafe()),
+		monotonicTimeNanosUnsafe: () => live.monotonicTimeNanosUnsafe(),
+		monotonicTimeNanos: Effect.sync(() => live.monotonicTimeNanosUnsafe()),
+		sleep: (duration) => live.sleep(duration),
+		adjust: (duration) => Effect.sleep(duration),
+		setTime: (timestamp) => Effect.suspend(() => Effect.sleep(Duration.millis(Math.max(0, timestamp - live.currentTimeMillisUnsafe())))),
+		withLive: (effect) => Effect.provideService(effect, Clock.Clock, live)
+	};
+};
+//#endregion
+//#region src/internal/runner.ts
+const getCurrentSuite = V.TestRunner.getCurrentSuite;
+/** @internal */
+const addEqualityTesters$1 = () => {
+	registerEqualTester();
+};
+const numbered = (timeout) => ({ timeout });
+const givenOptions = (timeout) => timeout ?? {};
+/** @internal */
+const testOptions = (timeout) => typeof timeout === "number" ? numbered(timeout) : givenOptions(timeout);
+/** @internal */
+const hookTimeout = (timeout) => timeout === void 0 ? void 0 : Duration.toMillis(Duration.fromInputUnsafe(timeout));
+/**
+* The positional form is refused at run time with the R15 rewrite; the public type already refuses it.
+*/
+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
+};
+/** @internal */
+const perRun = () => ({
+	runtime: makeVirtualRuntime(),
+	owned: true,
+	stop: stopCheckOf
+});
+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 signalOf = (ctx) => ctx?.signal;
+const signalOnly = (signal) => signal === void 0 ? {} : { signal };
+const withScheduler = (signal, scheduler) => ({
+	...signalOnly(signal),
+	scheduler
+});
+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);
+/**
+* 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.
+*/
+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 });
+	throw error;
+};
+const runTest = (ctx, env = realTime) => (effect) => {
+	const promise = runPromise(effect, ctx, env);
+	if (ctx !== void 0) trackAbort(ctx, promise);
+	return promise;
+};
+const trackAbort = (ctx, promise) => {
+	const onAbort = () => {
+		ctx.onTestFinished(() => promise.then(noop, noop));
+	};
+	ctx.signal.addEventListener("abort", onAbort, { once: true });
+	promise.then(() => detach(ctx, onAbort), () => detach(ctx, onAbort));
+	if (ctx.signal.aborted) onAbort();
+};
+const detach = (ctx, onAbort) => {
+	ctx.signal.removeEventListener("abort", onAbort);
+};
+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 });
+};
+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)));
+/**
+* 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).
+*/
+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);
+};
+/** @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.
+*/
+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 CONCURRENT_BLOCK = {
+	concurrent: true,
+	shuffle: true
+};
+const ALONE_BLOCK = {
+	concurrent: false,
+	shuffle: false
+};
+const withDefault = (given, fallback) => given ?? fallback;
+const concurrencyIn = (options) => options?.concurrent;
+const timeoutIn = (options) => options?.timeout;
+const excludedIn = (options) => options?.excludeTestServices;
+const sharedIn = (options) => options?.shared;
+const memoMapIn = (options) => options?.memoMap;
+const excludeTestServicesOf = (options) => withDefault(excludedIn(options), false);
+const blockEnvOf = (inherited) => withDefault(inherited, {
+	runtime: makeVirtualRuntime(),
+	owned: false,
+	stop: stopCheckOf
+});
+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.
+*/
+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);
+const makeScopeCloser = (scope) => {
+	let closed = false;
+	return () => {
+		if (closed) return Promise.resolve();
+		closed = true;
+		return runPromise(Scope.close(scope, Exit.void)).then(noop);
+	};
+};
+/**
+* Opens a block from its arguments: an anonymous body, or a named one. The sole implementation behind both
+* arities, so `layer(L)(fn)` and `layer(L)("name", fn)` cannot drift apart.
+*/
+const blockOpener = (anonymous, named) => (first, second) => routeBlock(first, second, anonymous, named);
+const routeBlock = (first, second, anonymous, named) => {
+	if (typeof first === "string") return openNamed(first, second, named);
+	return anonymous(first);
+};
+const openNamed = (name, f, named) => {
+	if (f !== void 0) named(name, f);
+};
+const layerFor = (layer_, options, inherited) => isSharedBlock(options) ? sharedBlock(layer_, options, inherited) : freshBlock(layer_, options);
+const freshBlock = (layer_, options) => {
+	const excludeTestServices = excludeTestServicesOf(options);
+	const withTestEnv = (env) => mergeTestEnv(layer_(env), testEnv(env), excludeTestServices);
+	const nestedOpen = (nestedLayer, nestedOptions) => layerFor((env) => Layer.provideMerge(nestedLayer, withTestEnv(env)), {
+		...nestedOptions,
+		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);
+	return blockOpener((f) => f(makeIt(V.it)), (name, f) => {
+		V.describe(name, describeOptions(options, false), () => f(makeIt(V.it)));
+	});
+};
+const nestedBlock = (nested, memoMap) => ({
+	...nested,
+	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 closeScope = makeScopeCloser(scope);
+	return blockOpener((f) => sharedAnonymous(f, makeIt, options, blockTasksOf(), blockEnv, contextEffect, closeScope), (name, f) => describeShared(name, f, makeIt, options, contextEffect, closeScope, blockEnv));
+};
+const describeShared = (name, f, makeIt, options, contextEffect, closeScope, blockEnv) => {
+	V.describe(name, describeOptions(options, true), () => {
+		V.beforeAll(() => runPromise(Effect.asVoid(contextEffect), void 0, blockEnv), blockHookTimeout(options));
+		V.afterAll(() => closeScope(), blockHookTimeout(options));
+		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));
+	const added = collectTasks(blockTasksOf().filter((task) => previousTasks.has(task) === false));
+	if (added.length === 0) {
+		V.afterAll(() => closeScope(), blockHookTimeout(options));
+		return;
+	}
+	openAddedTests(added, blockEnv, contextEffect, closeScope, options);
+};
+const openAddedTests = (added, blockEnv, contextEffect, closeScope, options) => {
+	const blockTaskSet = new Set(added);
+	V.beforeEach((ctx) => sharedBeforeEach(ctx, blockTaskSet, countDown(added.length, closeScope), contextEffect, blockEnv), blockHookTimeout(options));
+	V.afterAll(() => closeScope(), blockHookTimeout(options));
+};
+const countDown = (remaining, closeScope) => {
+	let left = remaining;
+	return () => {
+		left -= 1;
+		return left === 0 ? closeScope() : void 0;
+	};
+};
+const sharedBeforeEach = (ctx, blockTaskSet, finish, contextEffect, blockEnv) => {
+	if (blockTaskSet.has(ctx.task) === false) return void 0;
+	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);
+const withinTimeout = (elapsed, timeout) => Duration.isLessThanOrEqualTo(Duration.fromInputUnsafe(elapsed), Duration.fromInputUnsafe(timeout));
+const retryWithin = (timeout) => Schedule.while(Schedule.recurs(10), (state) => Effect.succeed(withinTimeout(state.elapsed, timeout)));
+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`.
+*/
+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);
+};
+/**
+* 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).
+*/
+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);
+/**
+* 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);
+}
+/**
+* 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.
+*/
+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 describeImpl = (name, f) => V.describe(name, {
+	concurrent: true,
+	shuffle: true
+}, (it) => f(makeMethods$1(it)));
+/** @internal */
+const describeWrapped$1 = Function.dual(byName, describeImpl);
+//#endregion
+//#region src/mod.ts
+/**
+* @since 4.0.0
+*/
+const addEqualityTesters = addEqualityTesters$1;
+/**
+* @since 4.0.0
+*/
+const effect = effect$1;
+/**
+* @since 4.0.0
+*/
+const live = live$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
+*
+* ```ts
+* import { assert, layer } from "@systemfsoftware/vitest"
+* import { Effect, Layer, Context } 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")
+*       }))
+*   })
+* })
+* ```
+*/
+const layer = layer$1;
+/**
+* @since 4.0.0
+*/
+const flakyTest = flakyTest$1;
+/**
+* @since 4.0.0
+*/
+const prop = prop$1;
+/**
+* @since 4.0.0
+*/
+const owned = owned$1;
+/**
+* @since 4.0.0
+*/
+const recordAssertion = recordAssertion$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.
+*
+* @since 4.0.0
+*/
+const captureRunBinding = captureRunBinding$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.
+*
+* @since 4.0.0
+*/
+const vitestTestContextKey = vitestTestContextKey$1;
+/**
+* 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.
+*
+* @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;
+/**
+* @since 4.0.0
+*/
+const describeWrapped = describeWrapped$1;
+const describe = describeWrapped$1;
+/**
+* The fork's `expect`: soft within one Effect step, refusing the slop forms.
+*
+* @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;
+/**
+* @since 4.0.0
+*/
+const afterAll = afterAll$1;
+//#endregion
+export { VitestTestContext, addEqualityTesters, afterAll, afterEach, beforeAll, beforeEach, captureRunBinding, describe, describeWrapped, effect, expect, flakyTest, it, layer, live, makeMethods, owned, prop, recordAssertion, vitestTestContextKey };