@systemfsoftware/vitest 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,31 +1,23 @@
 
+import { a as replayOfFailure, d as providedRoot, f as InvalidBudget, h as Slop, i as makeProperty, l as testIdentityOf, m as NonBooleanVerdict, o as isFailureRecordError, p as LeakedState, r as createSpanRecorder, u as throwFailureRecord } from "./failure-DC_SJoxW.mjs";
+import { a as isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-D_-acRSc.mjs";
 import { _ as refuseScopedLiveLane, d as refuseAsyncBody, f as refuseEffectLane, g as refuseScopedLane, i as markTask, l as noCheckRefusal, o as isRefusal$1, p as refuseHook, u as refusalOf$1, v as refuseSyncBody, x as unprovidedText, y as refuseUnyielded } from "./guard-BocOhXt2.mjs";
-import { a as isCheck, i as checksFor, n as vitestTestContextKey$1, o as makeLedger, r as Asserted, t as VitestTestContext$1 } from "./test-context-hvSoKLtw.mjs";
 import * as V from "vitest";
-import { afterAll, assertType, beforeAll, expectTypeOf, inject, inject as inject$1, onTestFailed, onTestFinished, recordArtifact, vi, vitest } from "vitest";
+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 Equal from "effect/Equal";
 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 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 Equal from "effect/Equal";
-import { Schema } from "effect";
-import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
-import * as Data from "effect/Data";
 import * as Clock from "effect/Clock";
 import * as Scheduler from "effect/Scheduler";
-//#region src/internal/property/defaults.ts
-/** @internal The `test.provide` key the shared config fills with this run's tier's check options. */
-const checkDefaultsKey = "@systemfsoftware/vitest:property-check";
-/** @internal The configured property-check defaults, or `undefined` when the run provided none. */
-const providedCheckDefaults = () => inject$1(checkDefaultsKey);
-//#endregion
 //#region src/internal/driver.ts
 /**
 * The driver: one Effect that steps the body's generator in the fiber the test runs in.
@@ -92,509 +84,6 @@ const driven = (body, args, ledger) => Effect.provideService(driveBody(body, arg
 */
 const drive = Function.dual(3, driven);
 //#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 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/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/virtual-time.ts
 const roundNanos = (millis) => BigInt(Math.round(millis * 1e6));
 const byWakeOrder = (first, second) => {
@@ -779,9 +268,18 @@ const virtualClockOf = (runtime) => {
 * `@systemfsoftware/vitest/guard` can tell the fork's tests from a test registered by Vitest itself.
 */
 const getCurrentSuite = V.TestRunner.getCurrentSuite;
+let equalTestersRegistered = false;
+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);
+const registerEqualTesters = () => {
+	if (equalTestersRegistered) return;
+	equalTestersRegistered = true;
+	V.expect.addEqualityTesters([equalTester]);
+};
 /** @internal */
 const addEqualityTesters$1 = () => {
-	registerEqualTester();
+	registerEqualTesters();
 };
 const numbered = (timeout) => ({ timeout });
 const givenOptions = (timeout) => timeout ?? {};
@@ -819,7 +317,11 @@ const perRun = () => ({
 	owned: true
 });
 const propertyEnv = realTime;
-const logErrors = (cause) => Effect.forEach(Cause.prettyErrors(cause), (error) => Effect.logError(error), { discard: true });
+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 schedulerOf = (env) => env.runtime === void 0 ? {} : { scheduler: env.runtime.scheduler };
@@ -838,12 +340,15 @@ const runExit = (effect, ctx, env) => Effect.runPromiseExit(wrapOwned(effect, ow
 * of as a raw defect.
 */
 const isUnprovided = (error) => error instanceof Error && error.message.startsWith("Service not found");
+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: unprovidedText });
+	refuseUnprovided(error);
 	throw error;
 };
-const failExit = (cause) => logErrors(cause).pipe(Effect.runPromise).then(() => rethrowSquashed(cause));
+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 = () => {};
@@ -858,9 +363,31 @@ const trackAbort = (ctx, promise) => {
 	promise.then(() => detach(ctx, onAbort), () => detach(ctx, onAbort));
 	if (ctx.signal.aborted) onAbort();
 };
-const runTest = (ctx, env = realTime) => (effect) => {
-	const promise = runPromise(effect, ctx, env);
-	if (ctx !== void 0) trackAbort(ctx, promise);
+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 clockLayerOf = (env) => env.runtime === void 0 ? TestClock.layer() : virtualClockLayer(env.runtime);
@@ -904,16 +431,16 @@ const rowBodyOf = (row, body) => (checks) => typeof body === "string" ? refuseBo
 /** One test's run: a fresh ledger, and the lane's own services around the program the driver built. */
 const runLaned = (ctx, mapEffect, env, body) => {
 	const ledger = makeLedger(ctx);
-	return runTest(ctx, env)(mapEffect(bindRun(drive(bodyOf(ledger, body), [], ledger), ctx), env));
+	return runRecorded(mapEffect(bindRun(drive(bodyOf(ledger, body), [], ledger), ctx), env), ctx, env);
 };
 const outcomeOf = (promise) => promise.then(() => void 0, (error) => error);
-const isSlop = (error) => Schema$1.is(Slop)(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$1.is(InvalidBudget),
-	Schema$1.is(NonBooleanVerdict),
-	Schema$1.is(LeakedState)
+	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;
@@ -939,7 +466,7 @@ const isClean = (ctx) => presentErrors(ctx.task.result?.errors).length === 0;
 * Runs a property's program as the test that registered it, under the same context the generator lanes use. The
 * env is the bare `propertyEnv`: a `false` verdict is the property's own shrink path, so nothing interrupts it.
 */
-const runProperty = (ctx, program) => runTest(ctx, propertyEnv)(bindRun(Effect.suspend(program), ctx));
+const runProperty = (ctx, program) => runRecorded(bindRun(Effect.suspend(program), ctx), ctx, propertyEnv);
 const property = makeProperty({
 	register: (name, program) => marked(() => V.it(name, (ctx) => runProperty(ctx, program))),
 	provide: (effect) => effect

package/dist/integration.mjs

@@ -1,5 +1,5 @@
 
-import { r as Asserted, t as VitestTestContext } from "./test-context-hvSoKLtw.mjs";
+import { r as Asserted, t as VitestTestContext } from "./test-context-D_-acRSc.mjs";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 //#region src/integration.ts