@systemfsoftware/vitest 1.0.0 → 4.1.1

package/dist/failure-C67X1OAe.mjs

@@ -0,0 +1,2294 @@
+
+import { n as providedBudgetOf } from "./tiers-W0BWq1uh.mjs";
+import { a as isCheck, d as isUserFrame, f as siteOfFrame, i as checksFor, o as makeLedger, p as withRaisingFrame, r as Asserted, s as callFrame, t as VitestTestContext, u as framesOf$1 } from "./test-context-DelFkLBL.mjs";
+import { l as noCheckRefusal, u as refusalOf, y as refuseUnyielded } from "./guard-Ci0TyBYv.mjs";
+import { TestRunner, inject } from "vitest";
+import * as Cause from "effect/Cause";
+import * as Effect$1 from "effect/Effect";
+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 Schema$1 from "effect/Schema";
+import * as Option$1 from "effect/Option";
+import * as Match$1 from "effect/Match";
+import * as Tracer from "effect/Tracer";
+import { Effect, Match, Option, Schema, SchemaGetter, SchemaIssue } from "effect";
+import * as Predicate from "effect/Predicate";
+import * as Arbitrary from "effect/Arbitrary";
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Random from "effect/Random";
+import * as Ref from "effect/Ref";
+import * as Result from "effect/Result";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+//#region src/internal/property/defaults.ts
+/** @internal The `test.provide` key the shared config fills with this run's tier's check options. */
+const checkDefaultsKey = "@systemfsoftware/vitest:property-check";
+const processEnvironment = () => ({ ...typeof process === "undefined" ? void 0 : process.env });
+/**
+* @internal The property-check defaults a run provided through `test.provide`, else the tier's budget for this
+* process's environment, read from the same table the setup entry uses.
+*/
+const providedCheckDefaults = () => inject("@systemfsoftware/vitest:property-check") ?? providedBudgetOf(processEnvironment());
+//#endregion
+//#region src/replay.schema.ts
+/**
+* The one replay grammar (KTD10, KTD5, KD8, R6, R9-R12): the `CONFORMANCE_REPLAY` text a failure record's rerun
+* line carries and the engine reads back to re-run the same verdict. Two forms share it:
+*
+* - the kernel's schedule, `seed=<whole number>;path=<comma-separated whole numbers>` — the path is empty when the
+*   run took no decision (`seed=1;path=`);
+* - a property entry, `property=<identity hash>;seed=<whole number>;runs=<whole number>` for a run that was not
+*   refuted, and the same entry plus `;attempt=<n>;size=<n>;path=<comma-separated decisions>;failure=<tag>` for a
+*   refuted run, so the engine rebuilds the generator's replay token. Several entries are joined by `|`, which no
+*   entry can contain: every key is lowercase letters and every value is digits, commas or a failure tag.
+*
+* A text that names neither form is not a replay. The seed and every decision are branded whole numbers, and
+* the text is a codec rooted at `Schema.String`, so one declaration serves both the writer and the
+* reader instead of a pattern each.
+*
+* @since 4.0.0
+*/
+/** The seed a replay names: the whole number a generator chose, never negative (CONST-D1). */
+const ReplaySeed = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ReplaySeed"));
+/** One decision along a replay path: the index the scheduler picked at that step. */
+const ReplayStep = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ReplayStep"));
+/** The replay a generator chose: its seed and the decisions it took, in order (R6). */
+const Replay = Schema.Struct({
+	seed: ReplaySeed,
+	path: Schema.Array(ReplayStep)
+});
+/** A property's identity hash: the unsigned whole number `identityHash` derives from its identity (KTD4). */
+const PropertyHash = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("PropertyHash"));
+/** The count of runs a property entry names, never negative (CONST-D1). */
+const ReplayRunCount = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("ReplayRunCount"));
+/** The failure kind effect's falsification runner records in its replay token. */
+const ReplayFailureTag = Schema.Literals(["ReturnedFalse", "PropertyError"]);
+/**
+* A property entry for a run that was not refuted: the property's identity hash, the seed it ran with and its
+* run count (R9, R11).
+*
+* @since 4.0.0
+*/
+const PlainPropertyReplay = Schema.TaggedStruct("Plain", {
+	property: PropertyHash,
+	seed: ReplaySeed,
+	runs: ReplayRunCount
+});
+/**
+* A property entry for a refuted run: the plain fields, plus the generator replay token's parts the engine needs
+* to rebuild it — the attempt, the size, the shrink path and the failure tag (R9, R12, KTD5).
+*
+* @since 4.0.0
+*/
+const RefutedPropertyReplay = Schema.TaggedStruct("Refuted", {
+	property: PropertyHash,
+	seed: ReplaySeed,
+	runs: ReplayRunCount,
+	attempt: ReplayRunCount,
+	size: ReplayRunCount,
+	path: Schema.Array(ReplayStep),
+	failure: ReplayFailureTag
+});
+/** One property entry: a plain run, or a refuted one (R9). */
+const PropertyReplay = Schema.Union([RefutedPropertyReplay, PlainPropertyReplay]);
+/** What a `CONFORMANCE_REPLAY` text names: the kernel's replay, or one or more property entries (KTD5). */
+const ReplayChannel = Schema.Union([Replay, Schema.Array(PropertyReplay)]);
+const SEED_PREFIX = "seed=";
+const PATH_PREFIX = "path=";
+const PROPERTY_PREFIX = "property=";
+const RUNS_PREFIX = "runs=";
+const ATTEMPT_PREFIX = "attempt=";
+const SIZE_PREFIX = "size=";
+const FAILURE_PREFIX = "failure=";
+const PAIR_SEPARATOR = ";";
+const LIST_SEPARATOR = ",";
+const ENTRY_SEPARATOR = "|";
+const WHOLE_NUMBER = /^\d+$/u;
+const ASSIGNMENT = /^([a-z]+)=([\s\S]*)$/u;
+const NOT_A_REPLAY = "a replay reads \"seed=<whole number>;path=<comma-separated whole numbers>\"";
+const NOT_A_CHANNEL = "a replay reads \"seed=<whole number>;path=<whole numbers>\", or one or more \"property=<hash>;seed=<n>;runs=<n>\" entries joined by \"|\"";
+const wholeNumberOf = (text) => WHOLE_NUMBER.test(text) ? Number(text) : void 0;
+const seedDigitsOf = (text) => text.startsWith(SEED_PREFIX) ? text.slice(5) : void 0;
+const pathDigitsOf = (text) => text.startsWith(PATH_PREFIX) ? text.slice(5) : void 0;
+const entriesOf$1 = (text) => text.length === 0 ? [] : text.split(LIST_SEPARATOR);
+const wholeNumbersOf = (entries) => {
+	const numbers = entries.map(wholeNumberOf);
+	return numbers.every((value) => value !== void 0) ? numbers : void 0;
+};
+const seedIn = (part) => Option.flatMap(Option.fromUndefinedOr(seedDigitsOf(part)), (digits) => Option.fromUndefinedOr(wholeNumberOf(digits)));
+const decisionsIn = (part) => Option.flatMap(Option.fromUndefinedOr(pathDigitsOf(part)), (entries) => Option.fromUndefinedOr(wholeNumbersOf(entriesOf$1(entries))));
+const exactlyTwoParts = (parts) => parts.length === 2;
+const pairPartsOf = (text) => {
+	const parts = text.split(PAIR_SEPARATOR);
+	return exactlyTwoParts(parts) ? Option.all([Option.fromUndefinedOr(parts[0]), Option.fromUndefinedOr(parts[1])]) : Option.none();
+};
+/** The seed and decisions a pair names, or nothing when the pair is not `seed=…;path=…`. */
+const namedPairOf = (text) => Option.flatMap(pairPartsOf(text), ([seedPart, pathPart]) => Option.all([seedIn(seedPart), decisionsIn(pathPart)]));
+/** The replay a seed and decision path name, or nothing when either is outside the grammar's domain. */
+const replayOfParts = (parts) => Schema.decodeOption(Replay)(parts);
+const replayOfName = (text) => Option.flatMap(namedPairOf(text), ([seed, path]) => replayOfParts({
+	seed,
+	path
+}));
+const textOfEncodedReplay = (replay) => `${SEED_PREFIX}${replay.seed}${PAIR_SEPARATOR}${PATH_PREFIX}${replay.path.join(LIST_SEPARATOR)}`;
+const replayRefusal = (text) => /* @__PURE__ */ new Error(`CONFORMANCE_REPLAY names neither a seed nor a decision path: ${text}`);
+/**
+* The `CONFORMANCE_REPLAY` text as the replay it names. A text a seed and a path cannot be read out of is refused
+* with the same prose the spec runtime has always thrown, so the grammar and its refusal share one home.
+*
+* @since 4.0.0
+*/
+const replayOfText = (text) => Option.match(replayOfName(text), {
+	onNone: () => {
+		throw replayRefusal(text);
+	},
+	onSome: (replay) => replay
+});
+/** The text a replay is written as: the `CONFORMANCE_REPLAY` value a rerun line carries (R6).
+*
+* @since 4.0.0
+*/
+const replayTextOf = (replay) => textOfEncodedReplay(replay);
+const fieldOfPart = (part) => Option.flatMap(Option.fromNullishOr(ASSIGNMENT.exec(part)), (matched) => Option.map(Option.all([Option.fromUndefinedOr(matched[1]), Option.fromUndefinedOr(matched[2])]), ([key, value]) => [key, value]));
+const fieldsOf$1 = (text) => Option.all(text.split(PAIR_SEPARATOR).map(fieldOfPart));
+const textIn = (fields, key) => Option.map(Option.fromNullishOr(fields.find(([name]) => name === key)), (field) => field[1]);
+/** The entry's keys name exactly `keys`, in order — so a reordered or repeated field is refused (KD8). */
+const keysAre = (fields, keys) => fields.length === keys.length && fields.every(([name], at) => name === keys[at]);
+const naturalIn = (fields, key) => Option.flatMap(textIn(fields, key), (text) => Option.fromUndefinedOr(wholeNumberOf(text)));
+const pathIn = (fields, key) => Option.flatMap(textIn(fields, key), (text) => Option.fromUndefinedOr(wholeNumbersOf(entriesOf$1(text))));
+const failureIn = (fields, key) => Option.flatMap(textIn(fields, key), (text) => Schema.decodeUnknownOption(ReplayFailureTag)(text));
+const PLAIN_KEYS = [
+	"property",
+	"seed",
+	"runs"
+];
+const REFUTED_KEYS = [
+	"property",
+	"seed",
+	"runs",
+	"attempt",
+	"size",
+	"path",
+	"failure"
+];
+const plainEncodedOf = (fields) => Option.map(Option.all([
+	naturalIn(fields, "property"),
+	naturalIn(fields, "seed"),
+	naturalIn(fields, "runs")
+]), ([property, seed, runs]) => ({
+	_tag: "Plain",
+	property,
+	seed,
+	runs
+}));
+const refutedEncodedOf = (fields) => Option.map(Option.all([
+	naturalIn(fields, "property"),
+	naturalIn(fields, "seed"),
+	naturalIn(fields, "runs"),
+	naturalIn(fields, "attempt"),
+	naturalIn(fields, "size"),
+	pathIn(fields, "path"),
+	failureIn(fields, "failure")
+]), ([property, seed, runs, attempt, size, path, failure]) => ({
+	_tag: "Refuted",
+	property,
+	seed,
+	runs,
+	attempt,
+	size,
+	path,
+	failure
+}));
+const plainEntryOf = (fields) => Option.flatMap(plainEncodedOf(fields), (encoded) => Schema.decodeOption(PlainPropertyReplay)(encoded));
+const refutedEntryOf$1 = (fields) => Option.flatMap(refutedEncodedOf(fields), (encoded) => Schema.decodeOption(RefutedPropertyReplay)(encoded));
+const plainWhenKeysOf = (fields) => keysAre(fields, PLAIN_KEYS) ? plainEntryOf(fields) : Option.none();
+const refutedWhenKeysOf = (fields) => keysAre(fields, REFUTED_KEYS) ? refutedEntryOf$1(fields) : Option.none();
+const propertyEntryOf = (text) => Option.flatMap(fieldsOf$1(text), (fields) => Option.orElse(plainWhenKeysOf(fields), () => refutedWhenKeysOf(fields)));
+const propertyChannelOf = (text) => text.length === 0 ? Option.none() : Option.all(text.split(ENTRY_SEPARATOR).map(propertyEntryOf));
+const channelOfName = (text) => Option.match(replayOfName(text), {
+	onNone: () => propertyChannelOf(text),
+	onSome: (replay) => Option.some(replay)
+});
+const isEntries$1 = (channel) => Array.isArray(channel);
+/** The text a plain property entry is written as (R9, R11). */
+const plainReplayText = (fields) => `${PROPERTY_PREFIX}${fields.property}${PAIR_SEPARATOR}${SEED_PREFIX}${fields.seed}${PAIR_SEPARATOR}${RUNS_PREFIX}${fields.runs}`;
+/** The text several plain entries are written as, joined by `|` (R11). */
+const plainReplayTexts = (entries) => entries.map(plainReplayText).join(ENTRY_SEPARATOR);
+/** The text a refuted property entry is written as (R9, R12). */
+const refutedReplayText$1 = (fields) => `${plainReplayText(fields)}${PAIR_SEPARATOR}${ATTEMPT_PREFIX}${fields.attempt}${PAIR_SEPARATOR}${SIZE_PREFIX}${fields.size}${PAIR_SEPARATOR}${PATH_PREFIX}${fields.path.join(LIST_SEPARATOR)}${PAIR_SEPARATOR}${FAILURE_PREFIX}${fields.failure}`;
+const entryTextOf = (entry) => Match.value(entry).pipe(Match.tag("Refuted", (refuted) => refutedReplayText$1(refuted)), Match.tag("Plain", (plain) => plainReplayText(plain)), Match.exhaustive);
+/** The text a channel is written as: the kernel's replay, or the entries joined by `|` (KTD5). */
+const replayChannelTextOf = (channel) => isEntries$1(channel) ? channel.map(entryTextOf).join(ENTRY_SEPARATOR) : textOfEncodedReplay(channel);
+/**
+* The kernel's replay codec: `Schema.String` in, a replay out. A text that names no seed and path fails the decode,
+* and every replay encodes back to the text it was read from.
+*
+* @since 4.0.0
+*/
+const ReplayFromText = Schema.String.pipe(Schema.decodeTo(Replay, {
+	decode: SchemaGetter.transformEffect((text, options) => Effect.fromOption(replayOfName(text), () => new SchemaIssue.InvalidValue({ message: NOT_A_REPLAY }, text, options))),
+	encode: SchemaGetter.transform(textOfEncodedReplay)
+}));
+/**
+* The channel codec: `Schema.String` in, the kernel's replay or the property entries out. A text that names neither
+* form fails the decode, and every channel encodes back to the text it was read from.
+*
+* @since 4.0.0
+*/
+const ReplayChannelFromText = Schema.String.pipe(Schema.decodeTo(ReplayChannel, {
+	decode: SchemaGetter.transformEffect((text, options) => Effect.fromOption(channelOfName(text), () => new SchemaIssue.InvalidValue({ message: NOT_A_CHANNEL }, text, options))),
+	encode: SchemaGetter.transform((channel) => replayChannelTextOf(channel))
+}));
+//#endregion
+//#region src/internal/errors.schema.ts
+/**
+* The contract rules a rendered failure record can break (R10, KTD7).
+*
+* @internal
+*/
+const Breach = Schema.Literals([
+	"R1",
+	"R2",
+	"R6"
+]);
+/** A record's breaches, in the order the renderer found them.
+*
+* @internal
+*/
+const Breaches = Schema.Array(Breach);
+/** The fixed prose each breach is refused with; nothing ever reads a refusal back, so it cannot recurse. */
+const REFUSED_BREACH_TEXT = {
+	R1: "the headline is empty",
+	R2: "the record names no source location",
+	R6: "a replay value names a run no generator chose, or the rerun line is missing"
+};
+/**
+* The one detail a record refusal carries: every breach the renderer found, in the prose above (R10, KTD7). The
+* breach letter is not printed: a reader acts on what is missing, not on which requirement numbered it.
+*
+* @internal
+*/
+const refusedRecordDetail = (breaches) => `✗ refused a failure record: ${breaches.map((breach) => REFUSED_BREACH_TEXT[breach]).join(", and ")}`;
+/** @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;
+	}
+};
+/** @internal */
+var FailureRecordRefused = class extends Schema.TaggedError()("FailureRecordRefused", {
+	breaches: Breaches,
+	cause: Schema.optional(Schema.Unknown)
+}) {
+	get message() {
+		return refusedRecordDetail(this.breaches);
+	}
+};
+//#endregion
+//#region src/internal/provided.schema.ts
+/**
+* The npm name of the package under test, as its own `package.json` spells it.
+*
+* @internal
+*/
+const PackageName = Schema.NonEmptyString.pipe(Schema.brand("PackageName"));
+/**
+* The workspace root every rendered path is relativized against.
+*
+* @internal
+*/
+const WorkspaceRoot = Schema.NonEmptyString.pipe(Schema.brand("WorkspaceRoot"));
+//#endregion
+//#region src/internal/provided.ts
+/**
+* The values the shared vitest config provides for the fork: the package under test's npm name and the workspace
+* root every rendered path is relativized against. Both are read out of the run's provided context (Vitest's
+* `inject`), so no production source reads a Node built-in, and an absent value is simply `undefined` — a rerun
+* line then drops its package filter, and paths print absolute (R6, KTD5).
+*
+* The values are branded (`provided.schema.ts`): a package name and a workspace root are not interchangeable
+* text.
+*
+* @since 4.0.0
+*/
+/** @internal */
+const packageKey = "@systemfsoftware/vitest:package";
+/** @internal */
+const workspaceRootKey = "@systemfsoftware/vitest:workspace-root";
+const isText$1 = (value) => typeof value === "string";
+const nonEmpty = (value) => value.length === 0 ? void 0 : value;
+const nonEmptyText$1 = (value) => isText$1(value) ? nonEmpty(value) : void 0;
+const read = (key) => {
+	try {
+		return nonEmptyText$1(inject(key));
+	} catch {
+		return;
+	}
+};
+const readNamed = (key, schema) => Option.getOrUndefined(Option.flatMap(Option.fromUndefinedOr(read(key)), (text) => Schema.decodeOption(schema)(text)));
+/** @internal */
+const providedPackage = () => readNamed(packageKey, PackageName);
+/** @internal */
+const providedRoot = () => readNamed(workspaceRootKey, WorkspaceRoot);
+//#endregion
+//#region src/internal/failure-record.ts
+/**
+* The one renderer for a spec failure: the failure and the spans its run recorded become the record Vitest
+* prints, together with the contract rules that record breaks (KTD1, KTD7).
+*
+* The record is ordered by R2-R6: the raising frame leads, the failing step and its spec line follow, then every
+* cause layer, then the step trail with the cell decisions each step caused, then the rerun command. The
+* renderer is pure and never throws: a value it cannot read renders as text, never as an exception.
+*
+* @since 4.0.0
+*/
+const STEP_SPAN = "gherkin.step";
+const STEP_KEYWORD = "gherkin.keyword";
+const STEP_TEXT = "gherkin.text";
+const CODE_SITE = "code.site";
+const CELL_NAME = "cell.name";
+const CELL_STACKTRACE = "cell.stacktrace";
+const CELL_DECIDE_STACKTRACE = "cell.decide_stacktrace";
+const CELL_COMMAND_TAG = "cell.command_tag";
+const CELL_MEMBER_TAGS = "cell.member_tags";
+const CELL_DECLARED = "cell.declared";
+const CELL_OUTCOME = "cell.outcome";
+const TAG_FIELD = "_tag";
+const MESSAGE_FIELD = "message";
+const NAME_FIELD = "name";
+const STACK_FIELD = "stack";
+const CAUSE_FIELD = "cause";
+const FILE_PROTOCOL = "file://";
+const UNKNOWN_SITE = "?";
+const DEFAULT_FAILURE_NAME = "Error";
+const NEVER_FINISHED = "   (never finished)";
+const CAUSE_DEPTH = 6;
+/** The fields a layer's own values exclude: the chain renders the cause, and the raise site names the stack. */
+const SKIPPED_FIELDS = {
+	[TAG_FIELD]: true,
+	[MESSAGE_FIELD]: true,
+	[NAME_FIELD]: true,
+	[STACK_FIELD]: true,
+	[CAUSE_FIELD]: true
+};
+/** The contract's "first location": any `<path>:<line>` the record names. */
+const LOCATION = /(?:[\w.@-]+\/)*[\w.@-]+\.[cm]?[jt]sx?:\d+/u;
+const COLUMN_SUFFIX = /:\d+$/u;
+const MARK = {
+	passed: "✓",
+	failed: "✗",
+	unfinished: "✗"
+};
+const not$1 = (value) => !value;
+const and = (left, right) => left && right;
+const or = (left, right) => left || right;
+const firstPresent = (values) => values.find((value) => value !== void 0);
+const isObject = (value) => typeof value === "object" && value !== null;
+const isText = (value) => typeof value === "string";
+const isArray = (value) => Array.isArray(value);
+const isNumber = (value) => typeof value === "number";
+const isBoolean = (value) => typeof value === "boolean";
+const isBigInt = (value) => typeof value === "bigint";
+const isNull = (value) => value === null;
+const isPrimitive = (value) => or(or(isNumber(value), isBoolean(value)), isBigInt(value));
+const objectOrUndefined = (value) => isObject(value) ? value : void 0;
+const isFieldName = (name) => SKIPPED_FIELDS[name] !== true;
+const presentOrUndefined = (text) => text.length === 0 ? void 0 : text;
+const nonEmptyText = (text) => text === void 0 ? void 0 : presentOrUndefined(text);
+const fieldOf = (value, key) => Reflect.get(value, key);
+const textFieldOf = (value, key) => {
+	const field = fieldOf(value, key);
+	return isText(field) ? field : void 0;
+};
+const nonEmptyFieldOf = (value, key) => nonEmptyText(textFieldOf(value, key));
+const tagFieldOf = (value) => nonEmptyFieldOf(value, TAG_FIELD);
+const messageFieldOf = (value) => nonEmptyFieldOf(value, MESSAGE_FIELD);
+const pairOf = (name, text) => ({
+	name,
+	text
+});
+const pairTextOf = (pair) => `${JSON.stringify(pair.name)}:${pair.text}`;
+const pairTextsOf = (pairs) => pairs.map(pairTextOf);
+const hasPair = (pairs, name) => pairs.some((pair) => pair.name === name);
+const pairsOf = (value) => isObject(value) ? Object.keys(value).map((key) => pairOf(key, renderValue(fieldOf(value, key)))) : [];
+const fieldsOf = (value) => pairsOf(value).filter((pair) => isFieldName(pair.name));
+const renderValue = (value) => witnessOf(value).rendered;
+const renderScalar = (value) => isText(value) ? JSON.stringify(value) : renderPrimitive(value);
+const renderPrimitive = (value) => isBigInt(value) ? `${value}n` : renderPlain(value);
+const renderPlain = (value) => isPrimitive(value) ? `${value}` : renderOther(value);
+const renderOther = (value) => isNull(value) ? "null" : renderUndefined(value);
+const renderUndefined = (value) => value === void 0 ? "undefined" : renderContainer(value);
+const renderContainer = (value) => isArray(value) ? renderList(value) : typeof value;
+const listTextOf = (children) => `[${children.join(",")}]`;
+const recordTextOf = (pairs) => `{${pairTextsOf(pairs).join(",")}}`;
+const renderList = (value) => listTextOf(value.map(renderValue));
+const renderRecord$1 = (value) => recordTextOf(pairsOf(value));
+const KIND_FIELD = "_kind";
+const VALUE_FIELD = "value";
+const DESCRIPTION_FIELD = "description";
+const UNDEFINED_JSON = { [KIND_FIELD]: "undefined" };
+const CIRCULAR_WITNESS = {
+	rendered: "[Circular]",
+	value: { [KIND_FIELD]: "circular" }
+};
+const markOf = (kind, field, text) => ({
+	[KIND_FIELD]: kind,
+	[field]: text
+});
+const isSymbol = (value) => typeof value === "symbol";
+const isCallable = (value) => typeof value === "function";
+const callableNameOf = (value) => {
+	const name = fieldOf(value, NAME_FIELD);
+	return isText(name) ? name : "";
+};
+const numberJsonOf = (value) => Number.isFinite(value) ? value : markOf("number", VALUE_FIELD, `${value}`);
+const bigintJsonOf = (value) => markOf("bigint", VALUE_FIELD, `${value}`);
+const functionJsonOf = (value) => markOf("function", NAME_FIELD, callableNameOf(value));
+const symbolJsonOf = (value) => markOf("symbol", DESCRIPTION_FIELD, value.description ?? "");
+const scalarJsonOf = (value) => isText(value) ? value : nonTextJsonOf(value);
+const nonTextJsonOf = (value) => isBoolean(value) ? value : nullOrOtherJsonOf(value);
+const nullOrOtherJsonOf = (value) => isNull(value) ? value : numberOrOtherJsonOf(value);
+const numberOrOtherJsonOf = (value) => isNumber(value) ? numberJsonOf(value) : bigintOrOtherJsonOf(value);
+const bigintOrOtherJsonOf = (value) => isBigInt(value) ? bigintJsonOf(value) : callableOrUndefinedJsonOf(value);
+const callableOrUndefinedJsonOf = (value) => isCallable(value) ? functionJsonOf(value) : symbolOrUndefinedJsonOf(value);
+const symbolOrUndefinedJsonOf = (value) => isSymbol(value) ? symbolJsonOf(value) : UNDEFINED_JSON;
+/**
+* The one traversal a value's rendered text and its JSON projection come from (R3, KD7): `rendered` is exactly
+* `renderValue`'s text, `value` is the same walk with every value JSON cannot carry marked by kind, and a cycle
+* marks `circular` rather than recursing forever.
+*
+* @internal
+*/
+const witnessOf = (value) => witnessAt(value, []);
+const witnessAt = (value, seen) => isObject(value) ? witnessedStructure(value, seen) : witnessedScalar(value);
+const witnessedStructure = (value, seen) => seen.includes(value) ? CIRCULAR_WITNESS : witnessedObject(value, seen);
+const witnessedObject = (value, seen) => isArray(value) ? witnessedList(value, seen) : witnessedRecord(value, seen);
+const witnessedScalar = (value) => ({
+	rendered: renderScalar(value),
+	value: scalarJsonOf(value)
+});
+const witnessedList = (value, seen) => {
+	const children = value.map((item) => witnessAt(item, seenWith(seen, value)));
+	return {
+		rendered: listTextOf(children.map(renderedOf)),
+		value: children.map(witnessValueOf)
+	};
+};
+const witnessedRecord = (value, seen) => {
+	const entries = entriesAt(value, seenWith(seen, value));
+	return {
+		rendered: tagFieldOf(value) ?? recordTextOf(entryPairsOf(entries)),
+		value: entriesJsonOf(entries)
+	};
+};
+const seenWith = (seen, value) => [...seen, value];
+const entriesAt = (value, seen) => Object.keys(value).map((key) => witnessEntryOf(key, witnessAt(fieldOf(value, key), seen)));
+const witnessEntryOf = (name, witness) => ({
+	name,
+	witness
+});
+const entryPairsOf = (entries) => entries.map((entry) => pairOf(entry.name, entry.witness.rendered));
+const entriesJsonOf = (entries) => Object.fromEntries(entries.map((entry) => [entry.name, entry.witness.value]));
+const renderedOf = (witness) => witness.rendered;
+const witnessValueOf = (witness) => witness.value;
+const bracesOf = (pairs) => ` {${pairTextsOf(pairs).join(",")}}`;
+const renderFields = (value) => bracesOf(fieldsOf(value));
+const textSummaryOf = (text) => text.length === 0 ? text : JSON.stringify(text);
+const scalarSummaryOf = (value) => isText(value) ? textSummaryOf(value) : renderScalar(value);
+/** @internal */
+const summaryOf = (value) => isObject(value) ? objectSummaryOf(value) : scalarSummaryOf(value);
+const objectSummaryOf = (value) => {
+	const tag = tagFieldOf(value);
+	return tag === void 0 ? untaggedSummaryOf(value) : taggedSummaryOf(tag, value);
+};
+const untaggedSummaryOf = (value) => isErrorValue(value) ? errorSummaryOf(value) : valueRecordSummaryOf(value);
+const valueRecordSummaryOf = (value) => isArray(value) ? renderList(value) : renderRecord$1(value);
+const isErrorValue = (value) => value instanceof Error;
+const firstLine = (text) => text.split("\n")[0] ?? text;
+const restLines = (text) => text.split("\n").slice(1);
+const taggedSummaryOf = (tag, value) => {
+	const message = messageFieldOf(value);
+	return message === void 0 ? `${tag}${renderFields(value)}` : `${tag}: ${firstLine(message)}`;
+};
+const errorSummaryOf = (value) => {
+	const name = objectNameOf(value);
+	const message = messageFieldOf(value);
+	return message === void 0 ? `${name}${renderFields(value)}` : `${name}: ${firstLine(message)}`;
+};
+const objectNameOf = (value) => firstPresent([tagFieldOf(value), nonEmptyFieldOf(value, NAME_FIELD)]) ?? DEFAULT_FAILURE_NAME;
+const headlineOf = (layers) => layers.length === 0 ? "" : summaryOf(layers[0]);
+const nameOf = (layers) => {
+	const entry = layers[0];
+	return isObject(entry) ? objectNameOf(entry) : DEFAULT_FAILURE_NAME;
+};
+const stripProtocol = (path) => path.startsWith(FILE_PROTOCOL) ? path.slice(7) : path;
+const stripColumn = (site) => site.replace(COLUMN_SUFFIX, "");
+const knownSiteOf = (site) => isText(site) ? stripColumn(stripProtocol(site)) : void 0;
+const siteTextOf = (site) => knownSiteOf(site) ?? UNKNOWN_SITE;
+const siteOfFrames = (frames) => Option$1.getOrUndefined(Option$1.map(Option$1.fromUndefinedOr(frames.find(isUserFrame)), siteOfFrame));
+/** The author's site in a raw captured stack, the form a cell span records instead of a pre-resolved site. */
+const cellStackSiteOf = (stack) => isText(stack) ? siteOfFrames(framesOf$1(stack)) : void 0;
+const stackSiteTextOf = (stack) => knownSiteOf(cellStackSiteOf(stack)) ?? UNKNOWN_SITE;
+const stackIn = (value) => textFieldOf(value, STACK_FIELD) ?? "";
+const stackOf = (value) => isObject(value) ? stackIn(value) : "";
+const framesOf = (value) => framesOf$1(stackOf(value));
+const isFrame = (frame) => frame !== void 0;
+const usableFrameOf = (value) => framesOf(value).find(isUserFrame);
+const frameTextOf = (frame) => `${frame.path}:${frame.line}${frameNameSuffix(frame.fn)}`;
+const isAuthorName = (fn) => fn !== void 0 && !fn.includes("~effect/");
+const frameNameSuffix = (fn) => isAuthorName(fn) ? ` (${fn})` : "";
+const isSameSite = (frame, other) => and(frame.path === other.path, frame.line === other.line);
+const isSameFrame = (frame, other) => other === void 0 ? false : isSameSite(frame, other);
+const chosenFrameOf = (layers) => {
+	const inner = layers.slice(1).map(usableFrameOf).filter(isFrame).at(-1);
+	return inner === void 0 ? usableFrameOf(layers[0]) : inner;
+};
+const attrOf = (span, key) => span.attributes.get(key);
+const textAttrOf = (span, key) => {
+	const value = attrOf(span, key);
+	return isText(value) ? value : void 0;
+};
+const ancestorsIn = (span) => span instanceof Tracer.NativeSpan ? [span, ...ancestorsOf(span.parent)] : [];
+const ancestorsOf = (parent) => Option$1.isNone(parent) ? [] : ancestorsIn(parent.value);
+const stepAncestorOf = (span) => ancestorsOf(span.parent).find((ancestor) => ancestor.name === STEP_SPAN);
+const stateOf = (span) => Match$1.value(span.status).pipe(Match$1.when({ _tag: "Started" }, () => "unfinished"), Match$1.when({ _tag: "Ended" }, (ended) => endedStateOf(ended.exit)), Match$1.exhaustive);
+const endedStateOf = (exit) => Exit.isSuccess(exit) ? "passed" : "failed";
+const stepSpansOf = (spans) => spans.filter(isTopStepSpan);
+const isTopStepSpan = (span) => and(span.name === STEP_SPAN, stepAncestorOf(span) === void 0);
+const isCellSpan = (span) => isText(attrOf(span, CELL_STACKTRACE));
+const cellSpansOf = (spans) => spans.filter(isCellSpan);
+const cellNameOf = (cell) => textAttrOf(cell, CELL_NAME) ?? cell.name;
+const causeFieldOf = (value) => isObject(value) ? objectOrUndefined(fieldOf(value, CAUSE_FIELD)) : void 0;
+/** One layer with whatever its own `cause` adds, depth-limited. */
+const layerWithCauseOf = (value, depth) => [value, ...nestedCauseOf(value, depth - 1)];
+/** The layers the reasons of an Effect `Cause` add, each rendered as any other layer. */
+const reasonLayersOf = (cause, depth) => cause.reasons.flatMap((reason) => layerWithCauseOf(reasonPayloadOf(reason), depth));
+const layersOfCause = (cause, depth) => Cause.isCause(cause) ? reasonLayersOf(cause, depth) : layerWithCauseOf(cause, depth);
+const nestedOf = (cause, depth) => cause === void 0 ? [] : layersOfCause(cause, depth);
+const nestedCauseOf = (value, depth) => depth === 0 ? [] : nestedOf(causeFieldOf(value), depth);
+const causeChainOf = (value) => [value, ...nestedCauseOf(value, CAUSE_DEPTH)];
+const interruptTextOf = (reason) => reason.fiberId === void 0 ? "interrupted" : `interrupted by fiber #${reason.fiberId}`;
+const reasonPayloadOf = (reason) => Match$1.value(reason).pipe(Match$1.when({ _tag: "Fail" }, (fail) => fail.error), Match$1.when({ _tag: "Die" }, (die) => die.defect), Match$1.when({ _tag: "Interrupt" }, (interrupt) => interruptTextOf(interrupt)), Match$1.exhaustive);
+const reasonsOf = (cause) => cause.reasons.flatMap((reason) => causeChainOf(reasonPayloadOf(reason)));
+const layersOf = (failure) => Cause.isCause(failure) ? reasonsOf(failure) : causeChainOf(failure);
+const declineOf = (span) => stateOf(span) === "unfinished" ? NEVER_FINISHED : "";
+const capitalize = (text) => text.length === 0 ? text : `${text.slice(0, 1).toUpperCase()}${text.slice(1)}`;
+const keywordOf = (step) => capitalize(textAttrOf(step, STEP_KEYWORD) ?? "");
+const stepTextOf = (step) => textAttrOf(step, STEP_TEXT) ?? "";
+const stepSiteOf = (step) => siteTextOf(attrOf(step, CODE_SITE));
+const stepLineOf = (step) => `  ${MARK[stateOf(step)]} ${keywordOf(step)} ${stepTextOf(step)}   ${stepSiteOf(step)}${declineOf(step)}`;
+const commandOf = (cell) => textAttrOf(cell, CELL_COMMAND_TAG) ?? "";
+const cellPairsOf = (cell) => {
+	const members = pairsOf(attrOf(cell, CELL_MEMBER_TAGS));
+	const declared = pairsOf(attrOf(cell, CELL_DECLARED)).filter((pair) => !hasPair(members, pair.name));
+	return [...members, ...declared];
+};
+const pairsBracesOf = (cell) => bracesOf(cellPairsOf(cell));
+const outcomeOf$1 = (cell) => {
+	const outcome = textAttrOf(cell, CELL_OUTCOME);
+	return outcome === void 0 ? "" : ` → ${outcome}`;
+};
+const blockOf = (cell) => ({
+	head: `      cell ${cellNameOf(cell)}: ${commandOf(cell)}${pairsBracesOf(cell)}${outcomeOf$1(cell)}`,
+	tail: `        decide ${stackSiteTextOf(attrOf(cell, CELL_DECIDE_STACKTRACE))}   cell ${stackSiteTextOf(attrOf(cell, CELL_STACKTRACE))}`
+});
+const groupOf = (block, count) => ({
+	block,
+	count
+});
+const isSameBlock = (block, other) => and(block.head === other.head, block.tail === other.tail);
+const appendBeside = (groups, block, last) => isSameBlock(last.block, block) ? [...groups.slice(0, -1), groupOf(block, last.count + 1)] : [...groups, groupOf(block, 1)];
+const appendAfter = (groups, block, last) => last === void 0 ? [groupOf(block, 1)] : appendBeside(groups, block, last);
+const appendGroup = (groups, block) => appendAfter(groups, block, groups.at(-1));
+const groupsOf = (blocks) => blocks.reduce(appendGroup, []);
+const groupLinesOf = (group) => [group.count > 1 ? `${group.block.head}  (×${group.count})` : group.block.head, group.block.tail];
+const cellsUnder = (spans, step) => cellSpansOf(spans).filter((cell) => stepAncestorOf(cell) === step);
+const decisionLinesOf = (spans, step) => groupsOf(cellsUnder(spans, step).map(blockOf)).flatMap(groupLinesOf);
+const trailStepsOf = (spans) => {
+	const steps = stepSpansOf(spans);
+	const failing = steps.find((step) => stateOf(step) !== "passed");
+	return failing === void 0 ? steps : steps.slice(0, steps.indexOf(failing) + 1);
+};
+const trailLinesOf = (spans) => trailStepsOf(spans).flatMap((step) => [stepLineOf(step), ...decisionLinesOf(spans, step)]);
+const layerHintOf = (spans) => {
+	const cell = cellSpansOf(spans).at(0);
+	return cell === void 0 ? "" : ` (cell ${cellNameOf(cell)})`;
+};
+const failingStepTextOf = (step) => `Failing step: ${keywordOf(step)} ${stepTextOf(step)}   ${stepSiteOf(step)}`;
+const noFailingStepLineOf = (steps, spans) => steps.length === 0 ? `Failing step: no step ran${layerHintOf(spans)}` : "Failing step: none of the steps failed";
+const failingStepLineOf = (spans) => {
+	const steps = stepSpansOf(spans);
+	const failing = steps.find((step) => stateOf(step) !== "passed");
+	return failing === void 0 ? noFailingStepLineOf(steps, spans) : failingStepTextOf(failing);
+};
+const isFailedSpan = (span) => stateOf(span) === "failed";
+const isUnfinishedCell = (span) => and(isCellSpan(span), stateOf(span) === "unfinished");
+const spanSiteOf = (span) => knownSiteOf(attrOf(span, CODE_SITE)) ?? knownSiteOf(cellStackSiteOf(attrOf(span, CELL_STACKTRACE)));
+const cellSiteOf = (spans) => {
+	const cell = spans.toReversed().find(isCellSpan);
+	return cell === void 0 ? void 0 : spanSiteOf(cell);
+};
+const unfinishedDecideSiteOf = (spans) => {
+	const unfinished = spans.toReversed().find(isUnfinishedCell);
+	return unfinished === void 0 ? void 0 : knownSiteOf(cellStackSiteOf(attrOf(unfinished, CELL_DECIDE_STACKTRACE)));
+};
+const decideSiteOf = (spans) => unfinishedDecideSiteOf(spans) ?? cellSiteOf(spans);
+const failedSiteOf = (spans) => {
+	const failed = spans.toReversed().find(isFailedSpan);
+	return failed === void 0 ? void 0 : spanSiteOf(failed);
+};
+const fallbackSiteOf = (spans) => failedSiteOf(spans) ?? decideSiteOf(spans);
+const fallbackRaisedAtLineOf = (spans) => {
+	const site = fallbackSiteOf(spans);
+	return site === void 0 ? void 0 : `  raised at ${site}`;
+};
+const raisedAtLineOf = (frame, spans) => frame === void 0 ? fallbackRaisedAtLineOf(spans) : `  raised at ${frameTextOf(frame)}`;
+const chainNamedFrame = (frame, chosen) => isSameFrame(frame, chosen) ? "" : `   raised at ${frameTextOf(frame)}`;
+const chainFrameTextOf = (frame, chosen) => frame === void 0 ? "" : chainNamedFrame(frame, chosen);
+const chainLineOf = (layer, chosen) => `  ${summaryOf(layer)}${chainFrameTextOf(usableFrameOf(layer), chosen)}`;
+const chainContinuation = (line) => `    ${line}`;
+const isMessageBearing = (layer) => or(tagFieldOf(layer) !== void 0, isErrorValue(layer));
+const messageOf = (layer) => messageFieldOf(layer) ?? "";
+const messageTailLines = (layer) => isMessageBearing(layer) ? restLines(messageOf(layer)).map(chainContinuation) : [];
+const chainDetailLines = (layer) => isObject(layer) ? messageTailLines(layer) : [];
+const chainLayerLines = (layer, chosen) => [chainLineOf(layer, chosen), ...chainDetailLines(layer)];
+const chainLinesOf = (layers, chosen) => layers.slice(1).flatMap((layer) => chainLayerLines(layer, chosen));
+const quoted = (text) => `"${text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+const REPLAY_FIELD = "replay";
+const propertyReplayTextOf = (failure) => {
+	const layer = propertyFailureOf(failure);
+	return layer === void 0 ? void 0 : textFieldOf(layer, REPLAY_FIELD);
+};
+const rerunReplayTextOf = (replay) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromUndefinedOr(replay.seed), (seed) => Option$1.map(replayOfParts({
+	seed,
+	path: replay.path
+}), replayTextOf)));
+const kernelReplayTextOf = (replay) => replay === void 0 ? void 0 : rerunReplayTextOf(replay);
+const replayPrefixText = (text) => text === void 0 ? "" : `CONFORMANCE_REPLAY="${text}" `;
+const replayPrefixOf = (replayText, replay) => replayPrefixText(replayText ?? kernelReplayTextOf(replay));
+const isCompleteIdentity = (identity) => and(identity.file.length > 0, identity.name.length > 0);
+const filterPrefixOf = (identity) => identity.package.length === 0 ? "" : `pnpm --filter ${identity.package} exec `;
+const rerunLineOf = (identity, replay, replayText) => isCompleteIdentity(identity) ? `  ${replayPrefixOf(replayText, replay)}${filterPrefixOf(identity)}vitest run ${identity.file} -t ` + quoted(identity.name) : void 0;
+const rerunLinesOf = (identity, replay, replayText) => {
+	const line = rerunLineOf(identity, replay, replayText);
+	return line === void 0 ? [] : ["Rerun only this scenario:", line];
+};
+const baselineReplay = (replay) => and(replay.seed === void 0, replay.path.length > 0);
+const replayOnBaseline = (replay) => replay === void 0 ? false : baselineReplay(replay);
+const headMessageOf = (layers) => {
+	const entry = layers[0];
+	return isObject(entry) ? messageFieldOf(entry) : void 0;
+};
+const detailOf = (layers) => {
+	const message = headMessageOf(layers);
+	return message === void 0 ? [] : restLines(message);
+};
+const detailLinesOf = (lines) => lines.length === 0 ? [] : [...lines.map((line) => `  ${line}`), ""];
+const scheduleLinesOf = (schedule) => schedule === void 0 ? [] : [
+	"",
+	`schedule: seed ${schedule.seed}`,
+	""
+];
+const recordPartsOf = (input, layers) => {
+	const chosen = chosenFrameOf(layers);
+	return {
+		headline: headlineOf(layers),
+		raisedAt: raisedAtLineOf(chosen, input.spans),
+		failingStep: failingStepLineOf(input.spans),
+		detail: detailOf(layers),
+		chain: chainLinesOf(layers, chosen),
+		trail: trailLinesOf(input.spans),
+		schedule: scheduleLinesOf(input.schedule),
+		rerun: rerunLinesOf(input.identity, input.replay, propertyReplayTextOf(input.failure))
+	};
+};
+const maybeLine = (line) => line === void 0 ? [] : [line];
+const sectionLines = (header, lines) => lines.length === 0 ? [] : [
+	header,
+	...lines,
+	""
+];
+const linesOf$1 = (parts) => [
+	parts.headline,
+	...maybeLine(parts.raisedAt),
+	parts.failingStep,
+	...detailLinesOf(parts.detail),
+	"",
+	...sectionLines("Cause chain:", parts.chain),
+	...sectionLines("Steps and the decisions each caused:", parts.trail),
+	...parts.schedule,
+	...parts.rerun
+];
+const breachIf = (holds, breach) => holds ? [breach] : [];
+const r6Broken = (parts, input) => or(parts.rerun.length === 0, replayOnBaseline(input.replay));
+const breachesOf = (parts, input, record) => [
+	...breachIf(parts.headline.length === 0, "R1"),
+	...breachIf(not$1(LOCATION.test(record)), "R2"),
+	...breachIf(r6Broken(parts, input), "R6")
+];
+const hasRoot = (root) => root !== void 0 && root.length > 0;
+const relativize = (record, root) => hasRoot(root) ? record.replaceAll(`${root}/`, "") : record;
+/**
+* Renders the record Vitest prints for one spec failure, and the contract rules it breaks.
+*
+* Never throws: a `Cause` renders layer by layer, a thrown `Error` renders as one layer, and any other value
+* renders as itself. The first location the record names is the raising frame — the first stack frame outside
+* `node_modules` and outside the spec libraries' own `src/` and `dist/` — and when no layer has one, the
+* innermost failed span's site stands in, or the innermost unfinished cell's decide site for a deadlock (KTD6).
+*
+* @internal
+*/
+const renderFailureRecord = (input) => {
+	const layers = layersOf(input.failure);
+	const parts = recordPartsOf(input, layers);
+	const record = relativize(linesOf$1(parts).join("\n").trimEnd(), input.root);
+	const property = propertyFailureOf(input.failure);
+	return {
+		name: nameOf(layers),
+		record,
+		breaches: breachesOf(parts, input, record),
+		...property === void 0 ? {} : { failure: property }
+	};
+};
+const RECORD = Symbol.for("@systemfsoftware/vitest/FailureRecord");
+const DIFF_FIELDS = [
+	"actual",
+	"expected",
+	"showDiff",
+	"operator",
+	"diff"
+];
+const ERROR_CAUSE_DEPTH = 8;
+const isDiffLayer = (value) => fieldOf(value, "actual") !== void 0;
+const marked = (error) => {
+	Object.defineProperty(error, RECORD, { value: true });
+	return error;
+};
+const recordSiteOf = (text) => LOCATION.exec(text)?.[0];
+const withoutTag = (record) => {
+	const prefix = `${record.name}: `;
+	return record.record.startsWith(prefix) ? record.record.slice(prefix.length) : record.record;
+};
+const recordStackOf = (record, message) => {
+	const head = `${record.name}: ${message}`;
+	const site = recordSiteOf(record.record);
+	return site === void 0 ? head : `${head}\n    at ${site}`;
+};
+const withStack = (error, record, message) => {
+	error.stack = recordStackOf(record, message);
+	return error;
+};
+const withName = (error, name) => {
+	error.name = name;
+	return error;
+};
+const reasonFieldOf = (reason) => fieldOf(reason, "error") ?? fieldOf(reason, "defect");
+const firstReasonOf = (cause) => {
+	const reason = cause.reasons[0];
+	return reason === void 0 ? cause : reasonFieldOf(reason);
+};
+const payloadOf = (failure) => Cause.isCause(failure) ? firstReasonOf(failure) : failure;
+const errorCauseChainOf = (value, depth) => depth <= 0 ? [] : [value, ...chainedCausesOf(value, depth)];
+const chainedCausesOf = (value, depth) => {
+	const cause = causeFieldOf(value);
+	return cause === void 0 ? [] : errorCauseChainOf(cause, depth - 1);
+};
+const layerChainOf = (failure) => {
+	const first = payloadOf(failure);
+	return [first, ...chainedCausesOf(first, ERROR_CAUSE_DEPTH)];
+};
+const diffCarrierOf = (failure) => layerChainOf(failure).map(objectOrUndefined).filter(isObject).find(isDiffLayer);
+const copyField = (error, carrier, field) => {
+	const value = fieldOf(carrier, field);
+	if (value === void 0) return;
+	Object.defineProperty(error, field, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+};
+const copyFields = (error, carrier) => {
+	for (const field of DIFF_FIELDS) copyField(error, carrier, field);
+	return error;
+};
+const copyDiffFields = (error, failure) => {
+	const carrier = diffCarrierOf(failure);
+	return carrier === void 0 ? error : copyFields(error, carrier);
+};
+/**
+* The property-channel failure tags: a failure whose own fields ride onto the printed error and stay readable from
+* the corpus record (R1, R2, R8). Tags, not the classes, so this module never imports the property engine.
+*/
+const PROPERTY_FAILURE_TAGS = [
+	"PropertyRefuted",
+	"PropertyExhausted",
+	"NonBooleanVerdict",
+	"CoverageBelowMinimum",
+	"SelfModelLaw",
+	"SeedStoreUnreadable",
+	"ReplayUnreadable",
+	"ReplayNoLongerReproduces",
+	"VacuousProperty"
+];
+const isPropertyFailureLayer = (value) => {
+	const tag = tagFieldOf(value);
+	return tag !== void 0 && PROPERTY_FAILURE_TAGS.includes(tag);
+};
+const propertyFailureOf = (failure) => layerChainOf(failure).map(objectOrUndefined).filter(isObject).find(isPropertyFailureLayer);
+/**
+* Copies the property failure's `_tag` and every own field onto the printed error, so a reporter reading the raw
+* error sees them. The message and stack stay untouched.
+*/
+const copyOwnFields = (error, layer) => {
+	for (const field of Object.keys(layer)) copyField(error, layer, field);
+	return error;
+};
+const copyPropertyFields = (error, failure) => {
+	const layer = propertyFailureOf(failure);
+	return layer === void 0 ? error : copyOwnFields(error, layer);
+};
+/**
+* The `Error` Vitest prints for one record (R2, R7, R8): its `name` is the record's failure tag, its `message` is
+* the record, and its `stack` leads with that message — Vitest's JSON reporter hands a consumer `stack || message`,
+* so the record has to ride there too — followed by the record's first location, so no `effect` or library frame
+* stays. The tag is left out of the message because Vitest prints `name: message`: it would otherwise lead twice.
+*
+* A failure that carries a diff — Chai's `actual`, `expected`, `showDiff`, `operator` and Vitest's `diff` — has
+* those fields copied from the innermost layer that holds them, because Vitest renders its Expected/Received
+* block from the thrown error, not from the record text.
+*
+* @internal
+*/
+const failureRecordError = (record) => {
+	const message = withoutTag(record);
+	return marked(withStack(withName(new Error(message), record.name), record, message));
+};
+const isRefusalFailure = (value) => Schema$1.is(FailureRecordRefused)(value);
+/**
+* The refusal thrown in a record's place (R10, KTD7): fixed prose naming each breach, the original failure as its
+* `cause`, and the record that failure would have printed beneath it. The record rides in the stack because
+* Vitest's JSON reporter hands a consumer `stack || message`, where a cause is invisible; the prose never carries
+* record text and is never read back, so a refusal cannot recurse.
+*/
+const refusalError = (failure, record) => {
+	const refusal = new FailureRecordRefused({
+		breaches: record.breaches,
+		cause: failure
+	});
+	refusal.stack = `${refusal.name}: ${refusal.message}\n${failureRecordError(record).stack ?? ""}`;
+	return refusal;
+};
+const printedError = (failure, record) => record.breaches.length > 0 ? refusalError(failure, record) : failureRecordError(record);
+/** @internal */
+const isFailureRecordError = (value) => isObject(value) && fieldOf(value, RECORD) === true;
+/** @internal */
+const throwFailureRecord = (input) => {
+	if (isRefusalFailure(input.failure)) throw input.failure;
+	const record = renderFailureRecord(input);
+	const printed = copyDiffFields(printedError(input.failure, record), input.failure);
+	throw copyPropertyFields(printed, input.failure);
+};
+const LEVEL_SEPARATOR = " > ";
+const EMPTY_TEXT = "";
+const textOrEmpty = (value) => isText(value) ? value : EMPTY_TEXT;
+const firstNonEmptyText = (values) => textOrEmpty(values.find(isText));
+const fileOf = (fullName) => textOrEmpty(fullName).split(LEVEL_SEPARATOR).at(0) ?? EMPTY_TEXT;
+const identityOf = (task) => ({
+	package: providedPackage() ?? EMPTY_TEXT,
+	file: fileOf(task.fullName),
+	name: firstNonEmptyText([task.fullTestName, task.name])
+});
+const currentTask = () => TestRunner.getCurrentTest() ?? {};
+/** @internal */
+const testIdentityOf = (task) => identityOf(task ?? currentTask());
+//#endregion
+//#region src/internal/driver.ts
+/**
+* The driver: one Effect that steps the body's generator in the fiber the test runs in.
+*
+* A `yield*` is a step, so the runner sees every one of them (KTD1):
+* - a branded check is judged against this test's ledger, so it counts, and a failed judgement fails the check
+*   itself and stops the test right there (R8);
+* - anything else opens a new observed state and then runs, which is what makes a second check on one state a
+*   second check in one window (R5), and a check inside a loop the same window as its siblings.
+*
+* The steps run in the same fiber as the test, so layers, virtual time, concurrency, the second run and scope
+* finalizers keep working through the runner unchanged. A step that fails, and the test being interrupted, both
+* return the generator: its `finally` blocks run and the steps after it never start (R8). When the body returns,
+* the gate refuses what the body wrote and never judged, then a body that judged nothing at all (R4).
+*/
+/**
+* A value the body yielded, as the driver runs it. What a body needs of its environment belongs to the layer the
+* runner provides around this whole Effect, so the driver erases the channels here, exactly as the runner erases
+* a body's own (`outputIsEffect` in `runner.ts`): the layer block is where a requirement is checked, and a body
+* that needs a service nothing provides is refused by the runner at run time (R9).
+*/
+const isRunnable = (value) => Effect$1.isEffect(value);
+/** A body that yielded something the driver cannot run ran nothing, so nothing in the test could fail. */
+const refuseUnsteppable = "✗ the body yielded a value that is not an Effect. Yield the Effect itself, or a check: yield* expect(actual).toEqual(expected).";
+/**
+* A yielded Effect: a branded check judges itself, and anything else opens a new observed state before it runs,
+* which is what resets the ledger's one-check window (R5).
+*/
+const runEffect = (value, ledger) => isCheck(value) ? value : Effect$1.andThen(Effect$1.sync(() => ledger.asserted.step()), value);
+/** One step: anything the driver cannot run is refused, because then no step of the test ran at all. */
+const runStep = (value, ledger) => isRunnable(value) ? runEffect(value, ledger) : Effect$1.die(refusalOf(refuseUnsteppable));
+/** Steps the iterator to its end, feeding each yielded Effect's result back into the body. */
+const stepThrough = (steps, ledger, input) => Effect$1.suspend(() => {
+	const state = steps.next(input);
+	if (state.done === true) return Effect$1.void;
+	return Effect$1.flatMap(runStep(state.value, ledger), (value) => stepThrough(steps, ledger, value));
+});
+/**
+* After the body returns: a check written and never yielded is refused first, then a body that judged none.
+* Both carry the same text the refusal carries on its compile channel, branded by `refusalOf` so the runner's
+* second run re-throws them as the refusals they are.
+*/
+const gate = (ledger) => Effect$1.andThen(refusingUnyielded(ledger), judgedNone(ledger));
+/** @internal */
+const refusingUnyielded = (ledger) => Effect$1.suspend(() => ledger.unyielded() > 0 ? refuse(refuseUnyielded) : Effect$1.void);
+const judgedNone = (ledger) => Effect$1.suspend(() => ledger.judged() === 0 ? refuse(noCheckRefusal) : Effect$1.void);
+const refuse = (text) => Effect$1.die(refusalOf(text));
+/**
+* A failure or an interruption returns the generator, so its `finally` blocks run and the step after the failed
+* check never does (R8).
+*/
+const unwind = (steps) => Effect$1.sync(() => {
+	steps.return?.(void 0);
+});
+const driveBody = (body, args, ledger) => Effect$1.suspend(() => {
+	const steps = body(...args);
+	return Effect$1.onExit(Effect$1.flatMap(stepThrough(steps, ledger, void 0), () => gate(ledger)), (exit) => Exit.isSuccess(exit) ? Effect$1.void : unwind(steps));
+});
+/** The body's steps, with this test's ledger provided as the `Asserted` every check in it reaches for. */
+const driven = (body, args, ledger) => Effect$1.provideService(driveBody(body, args, ledger), Asserted, ledger.asserted);
+/**
+* Runs one test's body: `body` called with `args`, stepped against `ledger`, with the ledger's `asserted`
+* provided as `Asserted` so every check in the body — including one yielded inside a forked fiber — reaches it.
+*
+* @internal
+*/
+const drive = Function.dual(3, driven);
+//#endregion
+//#region src/internal/property/coverage.ts
+/**
+* @internal The R14 coverage classes: labelled input predicates, each with a minimum share of runs.
+*
+* 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;
+/** 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);
+};
+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 failedFailures = (judge) => failedEntries(judge).map(([label, entry]) => ({
+	label,
+	hits: entry.hits,
+	runs: judge.runs,
+	minimum: entry.minimum
+}));
+/** @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;
+/**
+* Runs R14's sequential draw: tops up the undecided classes until every class is decided or the draw cap
+* is reached, then hands back the confidently under-covered classes as data, each with its label, hits, the runs
+* counted and the required share.
+*
+* @internal
+*/
+const judgeCoverage = (options) => failedFailures(toppedUp(judgeOf(options.classes, options.runs), options.draw, FIRST_BATCH));
+//#endregion
+//#region src/internal/property/error.schema.ts
+/**
+* The closed set of property-channel failures (KTD1, R1): refuted, non-boolean, under-covered and self-model, plus
+* the vacuous impostor verdict, the seed store's read failure and a stale explicit replay. Every variant is a `Schema.TaggedError` carrying
+* its own data — the property it names, a rendered-and-projected witness, coverage classes, the law that refused
+* itself — and a zero-argument `message` getter computed only from those fields. Wording is free; nothing reads a
+* message back.
+*
+* @since 4.0.0
+*/
+/**
+* A property's seed: a whole number a generator chose, never negative (CONST-D1).
+*
+* @internal
+*/
+const PropertySeed = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("PropertySeed"));
+/**
+* The count of runs a property's check was configured with, never negative (CONST-D1).
+*
+* @internal
+*/
+const PropertyRunCount = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("PropertyRunCount"));
+/** @internal */
+const PropertyShrinkCount = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)), Schema.brand("PropertyShrinkCount"));
+/**
+* One witness: the text the renderer prints for a value, and a JSON-safe projection of the same traversal (R3, KD7).
+*
+* @internal
+*/
+const Witness = Schema.Struct({
+	rendered: Schema.String,
+	value: Schema.Json
+});
+/**
+* One property involved in a failure: its full name, its declaration site, its seed and its run count (R2).
+*
+* @internal
+*/
+const PropertyRun = Schema.Struct({
+	name: Schema.String,
+	site: Schema.NullOr(Schema.String),
+	seed: PropertySeed,
+	runs: PropertyRunCount
+});
+/**
+* The kinds a non-boolean verdict can be: every `typeof` result, plus an `Effect` on the sync lane (R4).
+*
+* @internal
+*/
+const VerdictKind = Schema.Literals([
+	"undefined",
+	"object",
+	"boolean",
+	"number",
+	"bigint",
+	"string",
+	"symbol",
+	"function",
+	"effect"
+]);
+/**
+* A falsified property: the property that ran, the shrunk counterexample the generator settled on, and how many
+* shrink steps it took to reach it (R2-R4).
+*
+* @internal
+*/
+var PropertyRefuted = class extends Schema.TaggedError()("PropertyRefuted", {
+	property: PropertyRun,
+	counterexample: Witness,
+	shrinks: PropertyShrinkCount,
+	replay: Schema.String
+}) {
+	get message() {
+		return `${this.property.name}: the property was falsified within ${String(this.property.runs)} run(s), and ${String(this.shrinks)} shrink(s) settled on its input. Shrunk input: ${this.counterexample.rendered}`;
+	}
+};
+/** @internal */
+var PropertyExhausted = class extends Schema.TaggedError()("PropertyExhausted", {
+	property: PropertyRun,
+	discards: PropertyRunCount,
+	budget: Schema.Struct({
+		runs: PropertyRunCount,
+		maxDiscards: Schema.NullOr(PropertyRunCount)
+	}),
+	replay: Schema.String
+}) {
+	get message() {
+		const cap = this.budget.maxDiscards === null ? "no configured discard cap" : `a discard cap of ${String(this.budget.maxDiscards)}`;
+		return `${this.property.name}: the generator discarded ${String(this.discards)} draw(s) under ${cap} within ${String(this.budget.runs)} run(s), so the property was never evaluated. Narrow the generator so it draws admissible values, or raise \`maxDiscards\`.`;
+	}
+};
+/**
+* A verdict that was not a literal boolean: the property that ran, the first drawn values whose verdict was not a
+* boolean, and every kind of value the property returned (R4).
+*
+* @internal
+*/
+var NonBooleanVerdict = class extends Schema.TaggedError()("NonBooleanVerdict", {
+	property: PropertyRun,
+	drawn: Witness,
+	returned: Schema.Array(VerdictKind),
+	replay: Schema.String
+}) {
+	get message() {
+		return `${this.property.name}: the property returned no boolean; it returned ${this.returned.join(", ")}. A property must return a literal boolean verdict — asserting with expect(), or returning an Option, Result or object, is not a verdict.`;
+	}
+};
+/**
+* One coverage class left under its minimum: its label, hits, runs and required share (R7).
+*
+* @internal
+*/
+const CoverageClassFailure = Schema.Struct({
+	label: Schema.String,
+	hits: Schema.Int,
+	runs: Schema.Int,
+	minimum: Schema.Finite
+});
+/**
+* A property whose declared coverage classes stayed under their minima: the property and the failed classes, in
+* declaration order (R7).
+*
+* @internal
+*/
+var CoverageBelowMinimum = class extends Schema.TaggedError()("CoverageBelowMinimum", {
+	property: PropertyRun,
+	classes: Schema.Array(CoverageClassFailure),
+	replay: Schema.String
+}) {
+	get message() {
+		const lines = this.classes.map((entry) => `coverage ${entry.label}: ${entry.hits}/${entry.runs} of runs, below the required ${entry.minimum}`);
+		return `${this.property.name}: ${lines.join("\n")}`;
+	}
+};
+/**
+* A model law given the subject itself as its oracle, so it compares nothing (R13).
+*
+* @internal
+*/
+var SelfModelLaw = class extends Schema.TaggedError()("SelfModelLaw", {
+	law: Schema.String,
+	site: Schema.NullOr(Schema.String)
+}) {
+	get message() {
+		return `${this.law}: the model is the subject itself; a model law must compare against an independent oracle.`;
+	}
+};
+/**
+* A seed-store line that could not be decoded (R16, KTD6).
+*
+* @internal
+*/
+var SeedStoreUnreadable = class extends Schema.TaggedError()("SeedStoreUnreadable", {
+	file: Schema.String,
+	line: Schema.Int,
+	detail: Schema.String
+}) {
+	get message() {
+		return `the seed store ${this.file} line ${this.line} could not be read: ${this.detail}`;
+	}
+};
+/**
+* What a subject's constant impostor froze for one property: each frozen key — the subject itself, or a record
+* member — with the value its first call returned (R4, R6). Empty when the property never called the subject.
+*
+* @internal
+*/
+const FrozenOutput = Schema.Struct({
+	member: Schema.String,
+	output: Witness
+});
+/**
+* The impostor's frozen outputs (R4).
+*
+* @internal
+*/
+const Frozen = Schema.TaggedStruct("Frozen", { outputs: Schema.Array(FrozenOutput) });
+/**
+* A property whose body never called the subject during the vacuity check: nothing was frozen (R6).
+*
+* @internal
+*/
+const NeverCalled = Schema.TaggedStruct("NeverCalled", {});
+/**
+* One non-refuting property of a vacuous subject: the property it ran, and whether the impostor was called (R5).
+*
+* @internal
+*/
+const VacuousPropertyRun = Schema.Struct({
+	property: PropertyRun,
+	frozen: Schema.Union([Frozen, NeverCalled])
+});
+/**
+* One vacuous subject: what it is, and every non-refuting property in the file that ran over it (R5).
+*
+* @internal
+*/
+const VacuousSubject = Schema.Struct({
+	label: Schema.String,
+	properties: Schema.Array(VacuousPropertyRun)
+});
+/**
+* A law kind exempt from the impostor gate in a refused file: its name and the kind that exempted it (R6).
+*
+* @internal
+*/
+const ExemptLaw = Schema.Struct({
+	name: Schema.String,
+	kind: Schema.String
+});
+const REPAIR_ADVICE = "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 fakeTextOf = (run) => Match.value(run.frozen).pipe(Match.tag("Frozen", (frozen) => frozen.outputs.map((entry) => `${entry.member} always returned ${entry.output.rendered}`)), Match.tag("NeverCalled", () => []), Match.exhaustive);
+const subjectMessageOf = (subject) => {
+	const names = subject.properties.map((run) => run.property.name).join(", ");
+	const runs = subject.properties.reduce((total, run) => total + run.property.runs, 0);
+	const fakes = subject.properties.flatMap(fakeTextOf);
+	const fake = fakes.length === 0 ? "was never called" : fakes.join("; ");
+	return `${names}: no property in this file refuted the constant impostor of this subject (${subject.label}), so nothing here pins it down. It held for ${String(runs)} run(s) against a fake that ${fake}, whatever the input. ${REPAIR_ADVICE}`;
+};
+/**
+* Thrown at file end when no property in the file refuted a subject's constant impostor (R12, R5, R6).
+*
+* @internal
+*/
+var VacuousProperty = class extends Schema.TaggedError()("VacuousProperty", {
+	subjects: Schema.Array(VacuousSubject),
+	exempt: Schema.Array(ExemptLaw),
+	replay: Schema.String
+}) {
+	get message() {
+		return this.subjects.map(subjectMessageOf).join("\n\n");
+	}
+};
+/** @internal */
+var ReplayUnreadable = class extends Schema.TaggedError()("ReplayUnreadable", { text: Schema.String }) {
+	get message() {
+		return `CONFORMANCE_REPLAY names neither a seed and path nor a property entry: ${this.text}`;
+	}
+};
+/**
+* An explicit `CONFORMANCE_REPLAY` replay whose recorded failure no longer reproduces: after the root re-check,
+* the replay still mismatched, so no draw reproduces the failure the text names. The recorded seed-store path is
+* not this — there the entry is one candidate among the novel draws, and only a draw that still fails refutes.
+*
+* @internal
+*/
+var ReplayNoLongerReproduces = class extends Schema.TaggedError()("ReplayNoLongerReproduces", {
+	property: PropertyRun,
+	replay: Schema.String
+}) {
+	get message() {
+		return `${this.property.name}: the CONFORMANCE_REPLAY replay ${this.replay} no longer reproduces a failure for this property; the case it named is gone or its generator changed.`;
+	}
+};
+/**
+* Thrown when a law kind is given a record `of`, which cannot be spread into its subject.
+*
+* @internal
+*/
+var NonTupleOf = class extends Schema.TaggedError()("NonTupleOf", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+//#endregion
+//#region src/internal/property/replay.schema.ts
+/**
+* The token effect's falsification runner records, as the Schema that decodes it (KTD5). One falsification's
+* coordinates ride in a JSON array: a leading `0` naming a numeric seed, the seed text, the attempt, the size,
+* the shrink path, and the failure tag.
+*
+* @since 4.0.0
+*/
+/** @internal */
+const ReplayToken = Schema$1.fromJsonString(Schema$1.Tuple([
+	Schema$1.Finite,
+	Schema$1.Union([Schema$1.Finite, Schema$1.String]),
+	Schema$1.Finite,
+	Schema$1.Finite,
+	Schema$1.Array(Schema$1.Finite),
+	Schema$1.String
+]));
+//#endregion
+//#region src/internal/property/replay.ts
+const NUMERIC_SEED = 0;
+/** @internal */
+const tokenOfReplay = (entry) => JSON.stringify([
+	NUMERIC_SEED,
+	`${entry.seed}`,
+	entry.attempt,
+	entry.size,
+	entry.path,
+	entry.failure
+]);
+const FAILURE_CLASSES = {
+	ReturnedFalse: true,
+	PropertyError: true
+};
+/**
+* The tokens that replay only the root draw of `token`, one per failure class: the recorded attempt with an empty
+* shrink path. Empty for an absent or unreadable token.
+*
+* @internal
+*/
+const rootTokensOf = (token) => Option$1.match(Option$1.flatMap(Option$1.fromNullishOr(token), Schema$1.decodeOption(ReplayToken)), {
+	onNone: () => [],
+	onSome: (decoded) => Object.keys(FAILURE_CLASSES).map((failure) => JSON.stringify([
+		decoded[0],
+		`${decoded[1]}`,
+		decoded[2],
+		decoded[3],
+		[],
+		failure
+	]))
+});
+/** @internal */
+const refutedReplayTextOf = (identity) => Option$1.getOrUndefined(Option$1.map(Schema$1.decodeOption(ReplayToken)(identity.token), (decoded) => refutedReplayText$1({
+	property: identity.property,
+	seed: identity.seed,
+	runs: identity.runs,
+	attempt: decoded[2],
+	size: decoded[3],
+	path: decoded[4],
+	failure: decoded[5]
+})));
+/** @internal */
+const plainReplayTextOf = (identity) => plainReplayText(identity);
+/** @internal */
+const plainReplayEntriesText = (entries) => plainReplayTexts(entries);
+const isEntries = (channel) => Array.isArray(channel);
+/** @internal */
+const selectReplayEntry = (selection) => isEntries(selection.channel) ? selection.channel.find((entry) => entry.property === selection.hash) : void 0;
+//#endregion
+//#region src/internal/property/impostor.ts
+/**
+* @internal The constant impostor of R12: a fake of the subject under test that
+* returns the first output it ever produced, for every later call, whatever the
+* input it was given.
+*
+* A property that still holds for the impostor does not constrain the subject.
+* Whether that is fatal is a per-file question — a subject's impostor must be
+* refuted by some property in its file — so this module builds the fake and
+* collects the verdicts; the engine decides them once, when the file finishes
+* (KTD10).
+*/
+const SUBJECT_KEY = "the subject";
+const isCallableSubject = (target) => typeof target === "function";
+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 frozenOutputs = (state) => [...state.outputs].map(([member, output]) => ({
+	member,
+	output
+}));
+/**
+* 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: () => frozenOutputs(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),
+	verdicts: [],
+	refuters: []
+});
+const addName = (names, name) => names.includes(name) ? names : [...names, name];
+const trackVerdict = (judge, verdict) => {
+	const named = {
+		...judge,
+		refuters: addName(judge.refuters, verdict.property.name)
+	};
+	return verdict.refuted ? named : {
+		...judge,
+		verdicts: [...judge.verdicts, {
+			property: verdict.property,
+			identity: verdict.identity,
+			frozen: verdict.frozen
+		}]
+	};
+};
+const recordJudge = (state, subject, verdict) => {
+	const prior = state.judges.get(subject) ?? judgeFor(subject);
+	state.judges.set(subject, trackVerdict(prior, verdict));
+};
+const isVacuous = (judge) => judge.refuters.length === 0;
+const frozenOf = (frozen) => frozen.length === 0 ? { _tag: "NeverCalled" } : {
+	_tag: "Frozen",
+	outputs: frozen.map(({ member, output }) => ({
+		member,
+		output: witnessOf(output)
+	}))
+};
+const propertyRunOf$1 = (verdict) => ({
+	property: verdict.property,
+	frozen: frozenOf(verdict.frozen)
+});
+const subjectOf = (judge) => ({
+	label: judge.label,
+	properties: judge.verdicts.map(propertyRunOf$1)
+});
+const vacuousReplayTextOf = (judges) => plainReplayEntriesText(judges.flatMap((judge) => judge.verdicts.map((verdict) => ({
+	property: verdict.identity,
+	seed: verdict.property.seed,
+	runs: verdict.property.runs
+}))));
+const refuseVacuous = (judges, exempt) => {
+	const vacuous = judges.filter(isVacuous);
+	return vacuous.length === 0 ? void 0 : new VacuousProperty({
+		subjects: vacuous.map(subjectOf),
+		exempt: [...exempt],
+		replay: vacuousReplayTextOf(vacuous)
+	});
+};
+const finaliseJudges = (state) => refuseVacuous([...state.judges.values()], state.exempts);
+const ledgerOf = (state) => ({
+	record: (subject, verdict) => recordJudge(state, subject, verdict),
+	recordExempt: (name, kind) => {
+		if (state.exempts.some((exempt) => exempt.name === name)) return;
+		state.exempts.push({
+			name,
+			kind
+		});
+	},
+	finalise: () => finaliseJudges(state)
+});
+/**
+* Collects the impostor verdicts of every property in the file and decides, at file end, which subjects
+* nothing refuted.
+*
+* @internal
+*/
+const makeFileLedger = () => ledgerOf({
+	judges: /* @__PURE__ */ new Map(),
+	exempts: []
+});
+//#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/seed-store.schema.ts
+/**
+* @internal The seed store's line grammar (KTD6, R16, R18): one JSON Lines entry per failing run, decoded as a
+* tagged union. A refuted run carries the property's full name plus the parts a generator replay token is rebuilt
+* from; a non-boolean run carries the name, the seed and the run count. The codec a line is read through lives
+* here; the decisions over an entry live in `seed-record.ts`.
+*
+* @since 4.0.0
+*/
+/** @internal */
+const SeedStoreRefuted = Schema$1.TaggedStruct("Refuted", {
+	property: Schema$1.String,
+	seed: PropertySeed,
+	attempt: PropertyRunCount,
+	size: PropertyRunCount,
+	path: Schema$1.Array(ReplayStep),
+	failure: ReplayFailureTag
+});
+/** @internal */
+const SeedStoreNonBoolean = Schema$1.TaggedStruct("NonBoolean", {
+	property: Schema$1.String,
+	seed: PropertySeed,
+	runs: PropertyRunCount
+});
+/** @internal */
+const SeedStoreEntry = Schema$1.Union([SeedStoreRefuted, SeedStoreNonBoolean]);
+/** @internal */
+const SeedStoreLine = Schema$1.fromJsonString(SeedStoreEntry);
+//#endregion
+//#region src/internal/property/seed-record.ts
+/**
+* @internal The seed store's pure decisions (KTD6, R16-R19): the codec a line is read through, the entries a
+* property claims, whether a failure is worth appending, and the replay a stored entry names. No file access
+* lives here — the shell `seed-store.ts` reads and appends lines, and the line grammar is `seed-store.schema.ts`.
+*
+* @since 4.0.0
+*/
+const decodeLine = (file, index, text) => Result.mapError(Schema$1.decodeResult(SeedStoreLine)(text), (error) => new SeedStoreUnreadable({
+	file,
+	line: index + 1,
+	detail: error.message
+}));
+/** @internal */
+const decodeStoreLines = Function.dual(2, (file, lines) => Result.all(lines.map((text, index) => decodeLine(file, index, text))));
+/** @internal */
+const entriesForProperty = Function.dual(2, (entries, property) => entries.filter((entry) => entry.property === property));
+const sameEntry = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const derandomized = (budget) => budget?.seed !== void 0;
+const recordingOptedOut = (budget) => budget?.record === false;
+const alreadyRecorded = (existing, candidate) => existing.some((entry) => sameEntry(entry, candidate));
+const not = (value) => value === false;
+/** @internal */
+const shouldAppendEntry = (input) => [
+	derandomized(input.budget),
+	recordingOptedOut(input.budget),
+	alreadyRecorded(input.existing, input.candidate)
+].every(not);
+/** @internal */
+const refutedEntryOf = (input) => Option$1.flatMap(Schema$1.decodeOption(ReplayToken)(input.token), (parts) => Schema$1.decodeUnknownOption(SeedStoreEntry)({
+	_tag: "Refuted",
+	property: input.property,
+	seed: input.seed,
+	attempt: parts[2],
+	size: parts[3],
+	path: parts[4],
+	failure: parts[5]
+}));
+/** @internal */
+const nonBooleanEntryOf = (input) => Schema$1.decodeOption(SeedStoreEntry)({
+	_tag: "NonBoolean",
+	property: input.property,
+	seed: input.seed,
+	runs: input.runs
+});
+/** @internal */
+const replayEntryOf$1 = Function.dual(2, (entry, hash) => Match$1.value(entry).pipe(Match$1.tag("Refuted", (refuted) => Schema$1.decodeOption(RefutedPropertyReplay)({
+	_tag: "Refuted",
+	property: hash,
+	seed: refuted.seed,
+	runs: 1,
+	attempt: refuted.attempt,
+	size: refuted.size,
+	path: refuted.path,
+	failure: refuted.failure
+})), Match$1.tag("NonBoolean", (plain) => Schema$1.decodeOption(PlainPropertyReplay)({
+	_tag: "Plain",
+	property: hash,
+	seed: plain.seed,
+	runs: plain.runs
+})), Match$1.exhaustive));
+//#endregion
+//#region src/internal/property/seed-store.ts
+/**
+* @internal The seed store's shell (KTD6, R16): the asynchronous file access the engine uses — read a test file's
+* store lines beside it, and append one failing entry's line. The line grammar is `seed-store.schema.ts` and the
+* decisions are `seed-record.ts`; nothing reads or writes a file synchronously here.
+*
+* @since 4.0.0
+*/
+const STORE_DIRECTORY = "__property_seeds__";
+/** @internal */
+const storeFileOf = (filepath) => Effect$1.map(Effect$1.service(Path.Path), (path) => path.join(path.dirname(filepath), STORE_DIRECTORY, `${path.basename(filepath)}.jsonl`));
+const linesOf = (text) => text.length === 0 ? [] : text.replace(/\n$/u, "").split("\n");
+const readText = (file) => Effect$1.flatMap(Effect$1.service(FileSystem.FileSystem), (fs) => fs.readFileString(file).pipe(Effect$1.catchReason("PlatformError", "NotFound", () => Effect$1.succeed(""))));
+/** @internal */
+const readStoreLines = (file) => Effect$1.map(readText(file).pipe(Effect$1.orDie), linesOf);
+const appendLine = (file, line) => Effect$1.flatMap(Effect$1.service(FileSystem.FileSystem), (fs) => Effect$1.flatMap(Effect$1.service(Path.Path), (path) => Effect$1.flatMap(fs.makeDirectory(path.dirname(file), { recursive: true }).pipe(Effect$1.orDie), () => fs.writeFileString(file, `${line}\n`, { flag: "a" }).pipe(Effect$1.orDie))));
+const appendEntry = (filepath, entry) => Effect$1.flatMap(storeFileOf(filepath), (file) => Effect$1.flatMap(Schema$1.encodeEffect(SeedStoreLine)(entry).pipe(Effect$1.orDie), (line) => appendLine(file, line)));
+/** @internal */
+const appendStoreEntry = Function.dual(2, appendEntry);
+//#endregion
+//#region src/internal/property/seed.ts
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+const utf8 = new TextEncoder();
+const PART_SEPARATOR = "\0";
+/** @internal */
+const fnv1a32 = (text) => utf8.encode(text).reduce((hash, byte) => Math.imul(hash ^ byte, FNV_PRIME), FNV_OFFSET_BASIS) >>> 0;
+const identityParts = (identity) => [
+	identity.package,
+	identity.file,
+	identity.name
+];
+/** @internal */
+const identitySeed = Function.dual(2, (salt, identity) => fnv1a32([String(salt), ...identityParts(identity)].join(PART_SEPARATOR)));
+/** @internal */
+const identityHash = (identity) => fnv1a32(identityParts(identity).join(PART_SEPARATOR));
+/** @internal */
+const topUpSeed = Function.dual(2, (seed, drawn) => fnv1a32(`${seed}${PART_SEPARATOR}${drawn}`));
+const ownSeed = (seed) => Match$1.value(seed).pipe(Match$1.when(Match$1.number, (literal) => literal), Match$1.when(Match$1.string, fnv1a32), Match$1.exhaustive);
+const providedSeed = (input) => Option$1.map(Option$1.fromNullishOr(input.provided), identitySeed(input.identity));
+const saltOrProvided = (input) => Option$1.orElse(Option$1.map(Option$1.fromNullishOr(input.own), ownSeed), () => providedSeed(input));
+/** @internal */
+const resolveSeed = (input) => Option$1.getOrElse(saltOrProvided(input), () => input.fresh);
+//#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 newViolations = () => ({
+	kinds: [],
+	drawn: void 0,
+	seen: false
+});
+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 invalidPropertySeed = (name, seed) => `${name}: pass a non-negative integer \`seed\`; received ${describeRuns(seed)}. Write ${REWRITE}.`;
+const isNonInteger = (value) => Number.isInteger(value) === false;
+const isNegative = (value) => value < 0;
+const isInvalidSeedNumber = (value) => isNonInteger(value) || isNegative(value);
+const isInvalidSeed = (seed) => typeof seed === "number" && isInvalidSeedNumber(seed);
+const requireOwnSeed = (name, seed) => {
+	if (isInvalidSeed(seed)) throw new InvalidBudget({ detail: invalidPropertySeed(name, seed) });
+};
+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.
+* The resolved seed replaces the provided and explicit `seed` fields, which are inputs to the derivation
+* rather than a shared stream (KTD4).
+*/
+const EMPTY_PROVIDED_BUDGET = {};
+const resolveBudget = (name, spec, task, fresh) => {
+	const explicit = explicitOptions(spec);
+	const provided = task.budget ?? EMPTY_PROVIDED_BUDGET;
+	requirePositiveRuns((runs) => invalidPropertyBudget(name, runs), explicit.runs);
+	requirePositiveRuns(invalidProvidedBudget, provided.runs);
+	requireOwnSeed(name, explicit.seed);
+	const options = mergedOptions(task.budget, explicit);
+	const seed = resolveSeed({
+		own: explicit.seed,
+		provided: provided.seed,
+		identity: task.identity,
+		fresh
+	});
+	return {
+		runs: resolvedRuns(options),
+		options: {
+			...options,
+			seed
+		},
+		seed
+	};
+};
+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, seed) => {
+	const drawn = Ref.makeUnsafe(0);
+	return { more: (count) => {
+		const soFar = Effect$1.runSync(Ref.getAndUpdate(drawn, (total) => total + count));
+		return Effect$1.runSync(Arbitrary.sampleEffect(arbitrary, {
+			count,
+			seed: topUpSeed(seed, soFar)
+		}).pipe(Effect$1.orDie)).map((values) => satisfiedLabels(entries, values));
+	} };
+};
+const noCoverage = () => ({
+	observe: () => void 0,
+	judge: () => []
+});
+const liveCoverage = (cover, arbitrary, seed) => {
+	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, seed)
+		})
+	};
+};
+const makeCoverage = (cover, arbitrary, seed) => cover === void 0 ? noCoverage() : liveCoverage(cover, arbitrary, seed);
+const verdictKindOf = (verdict) => Match$1.value(verdict).pipe(Match$1.when(Effect$1.isEffect, () => "effect"), Match$1.orElse((value) => typeof value));
+const noteKind = (violations, kind) => {
+	if (violations.kinds.includes(kind) === false) violations.kinds.push(kind);
+};
+const noteDrawn = (violations, values) => {
+	if (violations.seen === false) {
+		violations.seen = true;
+		violations.drawn = values;
+	}
+};
+const noteVerdict = (violations, verdict, values) => {
+	noteKind(violations, verdictKindOf(verdict));
+	noteDrawn(violations, values);
+	return true;
+};
+const literalVerdict = (verdict, violations, values) => typeof verdict === "boolean" ? verdict : noteVerdict(violations, verdict, values);
+const effectVerdict = (lane, verdict, violations, values) => lane === "sync" ? Effect$1.succeed(noteVerdict(violations, verdict, values)) : Effect$1.map(verdict, (value) => literalVerdict(value, violations, values));
+const verdictFor = (run, values, violations) => {
+	run.observe(values);
+	const verdict = run.holds(run.subject, values);
+	return Effect$1.isEffect(verdict) ? effectVerdict(run.lane, verdict, violations, values) : Effect$1.succeed(literalVerdict(verdict, violations, values));
+};
+const tolerateInterruption = (cause) => Cause.hasInterrupts(cause) ? Effect$1.interrupt : Effect$1.fail(cause);
+const guardedVerdict = (run, violations) => (values) => Effect$1.catchCause(Effect$1.suspend(() => verdictFor(run, values, violations)), tolerateInterruption);
+const checkWith = (run, violations, options) => Arbitrary.checkEffect(run.arbitrary, guardedVerdict(run, violations), options);
+const isFalsified = Predicate.isTagged("Falsified");
+const isReplayMismatch = Predicate.isTagged("ReplayMismatch");
+/**
+* A replayed draw whose recorded shrink path no longer replays (`ReplayMismatch`) is re-checked at its root under
+* each failure class, so a root that still falsifies the property refutes it with the root as its counterexample.
+* The classes are tried in order and the check stops at the first that falsifies; when none does, the mismatch
+* stands: the recorded failure no longer reproduces.
+*/
+const rootCheckOf = (run, mismatch) => rootTokensOf(run.options.replay).reduce((previous, replay) => Effect$1.filterOrElse(previous, (found) => isFalsified(found), () => checkWith({
+	...run,
+	observe: noObserve
+}, newViolations(), {
+	...run.options,
+	replay
+})), Effect$1.succeed(mismatch));
+const runCheck = (run) => {
+	const violations = newViolations();
+	return checkWith(run, violations, run.options).pipe(Effect$1.filterOrElse((result) => !isReplayMismatch(result), (mismatch) => rootCheckOf(run, mismatch)), Effect$1.map((result) => ({
+		violations,
+		result
+	})));
+};
+const reportOf = (checked) => isReplayMismatch(checked.result) ? void 0 : Arbitrary.formatCheckFailure(checked.result);
+const seeded = (seed) => Option$1.getOrThrow(Schema$1.decodeOption(PropertySeed)(seed));
+const runCounted = (runs) => Option$1.getOrThrow(Schema$1.decodeOption(PropertyRunCount)(runs));
+const propertyRunOf = (run, budget) => ({
+	name: run.name,
+	site: run.site ?? null,
+	seed: seeded(budget.seed),
+	runs: runCounted(budget.runs)
+});
+const REPLAY_VARIABLE = "CONFORMANCE_REPLAY";
+const replayEntryOf = (text, hash, site) => Option$1.match(text, {
+	onNone: () => Effect$1.succeed(Option$1.none()),
+	onSome: (value) => Option$1.match(Schema$1.decodeOption(ReplayChannelFromText)(value), {
+		onNone: () => dieWithSite(new ReplayUnreadable({ text: value }), site),
+		onSome: (channel) => Effect$1.succeed(Option$1.fromNullishOr(selectReplayEntry({
+			channel,
+			hash
+		})))
+	})
+});
+const replayedBudget = (budget, runs, seed, replay) => {
+	return {
+		runs,
+		seed,
+		options: replay === void 0 ? {
+			...budget.options,
+			runs,
+			seed
+		} : {
+			...budget.options,
+			runs,
+			seed,
+			replay
+		}
+	};
+};
+const applyReplayEntry = (budget, entry) => entry === void 0 ? budget : Match$1.value(entry).pipe(Match$1.tag("Refuted", (refuted) => replayedBudget(budget, refuted.runs, refuted.seed, tokenOfReplay(refuted))), Match$1.tag("Plain", (plain) => replayedBudget(budget, plain.runs, plain.seed, void 0)), Match$1.exhaustive);
+const plainFailureReplay = (run, budget) => plainReplayTextOf({
+	property: run.identityHash,
+	seed: budget.seed,
+	runs: budget.runs
+});
+const falsifiedReplayOf = (checked) => {
+	const falsified = falsifiedOf(checked.result);
+	return falsified === void 0 ? void 0 : falsified.replay;
+};
+const refutedReplayText = (run, budget, token) => Option$1.getOrElse(Option$1.fromUndefinedOr(refutedReplayTextOf({
+	property: run.identityHash,
+	seed: budget.seed,
+	runs: budget.runs,
+	token
+})), () => plainFailureReplay(run, budget));
+const refutedFailureReplay = (run, budget, checked) => {
+	const token = falsifiedReplayOf(checked);
+	return token === void 0 ? plainFailureReplay(run, budget) : refutedReplayText(run, budget, token);
+};
+const violationOf = (run, budget, checked) => checked.violations.kinds.length === 0 ? void 0 : new NonBooleanVerdict({
+	property: propertyRunOf(run, budget),
+	drawn: witnessOf(checked.violations.drawn),
+	returned: [...checked.violations.kinds],
+	replay: plainFailureReplay(run, budget)
+});
+const isRefuted = (checked) => checked.violations.kinds.length > 0 || reportOf(checked) !== void 0;
+const dieWithSite = (error, site) => Effect$1.die(withRaisingFrame(error, site));
+const shrinkCounted = (shrinks) => Option$1.getOrThrow(Schema$1.decodeOption(PropertyShrinkCount)(shrinks));
+const countOrNull = (value) => Option$1.getOrNull(Option$1.flatMap(Option$1.fromUndefinedOr(value), (count) => Schema$1.decodeOption(PropertyRunCount)(count)));
+const refutedOf = (property, falsified, replay) => new PropertyRefuted({
+	property,
+	counterexample: witnessOf(falsified.shrunkInput),
+	shrinks: shrinkCounted(falsified.shrinks),
+	replay
+});
+const dieRefuted = (run, budget, checked, falsified, site) => dieWithSite(refutedOf(propertyRunOf(run, budget), falsified, refutedFailureReplay(run, budget, checked)), site);
+const dieExhausted = (run, budget, exhausted, site) => dieWithSite(new PropertyExhausted({
+	property: propertyRunOf(run, budget),
+	discards: runCounted(exhausted.discards),
+	budget: {
+		runs: runCounted(budget.runs),
+		maxDiscards: countOrNull(budget.options.maxDiscards)
+	},
+	replay: plainFailureReplay(run, budget)
+}), site);
+const dieUncovered = (run, budget, classes, site) => dieWithSite(new CoverageBelowMinimum({
+	property: propertyRunOf(run, budget),
+	classes,
+	replay: plainFailureReplay(run, budget)
+}), site);
+const impostorHolds = (holds, impostor) => (_subject, values) => holds(impostor.impostor, values);
+const noObserve = () => void 0;
+const impostorRun = (run, propertyBudget, budgets) => {
+	const impostor = impostorOf(run.subject);
+	const retry = {
+		...run,
+		holds: impostorHolds(run.holds, impostor),
+		observe: noObserve
+	};
+	return Effect$1.map(Effect$1.forEach(budgets, (budget) => runCheck({
+		...retry,
+		options: budget.options,
+		seed: budget.seed
+	}), { concurrency: 1 }), (checked) => {
+		const verdict = {
+			refuted: checked.some(isRefuted),
+			property: propertyRunOf(retry, propertyBudget),
+			identity: run.identityHash,
+			frozen: impostor.frozen()
+		};
+		run.ledger.record(run.subject, verdict);
+	});
+};
+const gateRun = (run, budget, gate, budgets) => gate ? impostorRun(run, budget, budgets) : Effect$1.void;
+const finishPassed = (run, budget, coverage, gate, budgets) => {
+	const failures = coverage.judge();
+	return failures.length === 0 ? gateRun(run, budget, gate, budgets) : dieUncovered(run, budget, failures, run.site);
+};
+const falsifiedOf = (result) => "replay" in result ? result : void 0;
+const noStore = (name) => ({
+	filepath: null,
+	name,
+	existing: [],
+	recorded: [],
+	budget: void 0
+});
+const appendWhenRecorded = (store, candidate) => Option$1.match(Option$1.fromNullishOr(store.filepath), {
+	onNone: () => Effect$1.void,
+	onSome: (filepath) => shouldAppendEntry({
+		existing: store.existing,
+		candidate,
+		budget: store.budget
+	}) ? appendStoreEntry(filepath, candidate) : Effect$1.void
+});
+const appendThenDie = (store, candidate, die) => Effect$1.flatMap(Option$1.match(candidate, {
+	onNone: () => Effect$1.void,
+	onSome: (entry) => appendWhenRecorded(store, entry)
+}), () => die);
+const refutedCandidate = (store, budget, checked) => Option$1.flatMap(Option$1.fromNullishOr(falsifiedReplayOf(checked)), (token) => refutedEntryOf({
+	property: store.name,
+	seed: budget.seed,
+	token
+}));
+const recordedReport = (registration, run, budget, checked) => Match$1.value(checked.result).pipe(Match$1.tag("Falsified", (falsified) => dieRefuted(run, budget, checked, falsified, registration.site)), Match$1.tag("Exhausted", (exhausted) => dieExhausted(run, budget, exhausted, registration.site)), Match$1.orElse(() => Effect$1.void));
+const settleRecorded = (registration, run, budget, checked) => Option$1.match(Option$1.fromNullishOr(violationOf(run, budget, checked)), {
+	onNone: () => recordedReport(registration, run, budget, checked),
+	onSome: (violation) => dieWithSite(violation, registration.site)
+});
+const settleRefuted = (registration, run, budget, coverage, checked, store) => Match$1.value(checked.result).pipe(Match$1.tag("Falsified", (falsified) => appendThenDie(store, refutedCandidate(store, budget, checked), dieRefuted(run, budget, checked, falsified, registration.site))), Match$1.tag("Exhausted", (exhausted) => appendThenDie(store, Option$1.none(), dieExhausted(run, budget, exhausted, registration.site))), Match$1.orElse(() => finishPassed(run, budget, coverage, registration.gate, [...store.recorded, budget])));
+const settle = (registration, run, budget, coverage, checked, store) => Option$1.match(Option$1.fromNullishOr(violationOf(run, budget, checked)), {
+	onNone: () => settleRefuted(registration, run, budget, coverage, checked, store),
+	onSome: (violation) => appendThenDie(store, nonBooleanEntryOf({
+		property: store.name,
+		seed: budget.seed,
+		runs: budget.runs
+	}), dieWithSite(violation, registration.site))
+});
+const readStoreEntries = (file, site) => Effect$1.flatMap(readStoreLines(file), (lines) => {
+	const decoded = decodeStoreLines(file, lines);
+	return Result.isSuccess(decoded) ? Effect$1.succeed(decoded.success) : dieWithSite(decoded.failure, site);
+});
+const readTaskStore = (task, site) => Option$1.match(Option$1.fromNullishOr(task.filepath), {
+	onNone: () => Effect$1.succeed([]),
+	onSome: (testFile) => Effect$1.flatMap(storeFileOf(testFile), (file) => readStoreEntries(file, site))
+});
+const recordedBudgets = (entries, baseBudget, hash) => entries.flatMap((stored) => Option$1.match(replayEntryOf$1(stored, hash), {
+	onNone: () => [],
+	onSome: (entry) => [applyReplayEntry(baseBudget, entry)]
+}));
+const checkOf = (registration, arbitrary, budget, observe, identityHash) => ({
+	name: registration.name,
+	lane: registration.lane,
+	subject: registration.spec.subject,
+	holds: registration.holds,
+	arbitrary,
+	observe,
+	options: budget.options,
+	seed: budget.seed,
+	identityHash,
+	site: registration.site,
+	ledger: registration.runtime.ledger
+});
+const runRecordedChecks = (registration, arbitrary, hash, recorded) => Effect$1.forEach(recorded, (budget) => {
+	const run = checkOf(registration, arbitrary, budget, noObserve, hash);
+	return Effect$1.flatMap(runCheck(run), (checked) => settleRecorded(registration, run, budget, checked));
+}, {
+	concurrency: 1,
+	discard: true
+});
+const replayRun = (registration, baseBudget, arbitrary, hash, entry, text) => {
+	const budget = applyReplayEntry(baseBudget, entry);
+	const coverage = makeCoverage(registration.spec.cover, arbitrary, budget.seed);
+	const run = checkOf(registration, arbitrary, budget, coverage.observe, hash);
+	return Effect$1.flatMap(runCheck(run), (checked) => isReplayMismatch(checked.result) ? dieWithSite(new ReplayNoLongerReproduces({
+		property: propertyRunOf(run, budget),
+		replay: text
+	}), registration.site) : settle(registration, run, budget, coverage, checked, noStore(registration.name)));
+};
+const storeRun = (registration, task, baseBudget, arbitrary, hash) => Effect$1.gen(function* () {
+	const entries = yield* readTaskStore(task, registration.site);
+	const existing = entriesForProperty(entries, task.identity.name);
+	const recorded = recordedBudgets(existing, baseBudget, hash);
+	yield* runRecordedChecks(registration, arbitrary, hash, recorded);
+	const coverage = makeCoverage(registration.spec.cover, arbitrary, baseBudget.seed);
+	const run = checkOf(registration, arbitrary, baseBudget, coverage.observe, hash);
+	const checked = yield* runCheck(run);
+	yield* settle(registration, run, baseBudget, coverage, checked, {
+		filepath: task.filepath,
+		name: task.identity.name,
+		existing,
+		recorded,
+		budget: task.budget
+	});
+});
+const propertyPlatform = Layer.unwrap(Effect$1.promise(async () => {
+	const [fileSystem, path] = await Promise.all([import("@effect/platform-node/NodeFileSystem"), import("@effect/platform-node/NodePath")]);
+	return Layer.merge(fileSystem.layer, path.layer);
+}));
+const program = (registration, task) => Effect$1.provide(Effect$1.gen(function* () {
+	const fresh = (yield* Random.nextInt) >>> 0;
+	const baseBudget = resolveBudget(registration.name, registration.spec, task, fresh);
+	const hash = identityHash(task.identity);
+	const replayText = yield* Config.option(Config.String(REPLAY_VARIABLE)).pipe(Effect$1.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromEnv()), Effect$1.orDie);
+	const entry = Option$1.getOrUndefined(yield* replayEntryOf(replayText, hash, registration.site));
+	const arbitrary = arbitraryOf(registration.spec.of);
+	yield* Option$1.match(Option$1.fromNullishOr(entry), {
+		onNone: () => storeRun(registration, task, baseBudget, arbitrary, hash),
+		onSome: (replay) => replayRun(registration, baseBudget, arbitrary, hash, replay, Option$1.getOrThrow(replayText))
+	});
+}), propertyPlatform);
+const programOf = (registration) => (task) => registration.runtime.provide(program(registration, task));
+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,
+			site: callFrame()
+		};
+		runtime.register(name, programOf(registration));
+	};
+	const refuseSelfModel = (name) => {
+		const site = callFrame();
+		runtime.register(name, (_task) => dieWithSite(new SelfModelLaw({
+			law: name,
+			site: site ?? null
+		}), site));
+	};
+	const judged = (name, spec, holds) => body(name, spec, holds, "sync", true);
+	const exempted = (name, spec, holds, kind) => {
+		runtime.ledger.recordExempt(name, kind);
+		body(`${name} [exempt: ${kind}]`, spec, holds, "sync", false);
+	};
+	const model = (name, spec, oracle) => isSelfModel(spec.subject, oracle) ? refuseSelfModel(name) : judged(name, spec, modelHolds(oracle));
+	const idempotent = (name, spec) => exempted(name, spec, idempotentHolds(), "idempotent");
+	const deterministic = (name, spec) => exempted(name, spec, deterministicHolds(), "deterministic");
+	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) => judged(name, spec, metamorphicHolds(relation)),
+			roundTrip: (name, spec, decode) => judged(name, spec, roundTripHolds(decode)),
+			invariant: (name, spec, holds) => judged(name, spec, invariantHolds(holds)),
+			idempotent,
+			deterministic
+		}
+	};
+};
+//#endregion
+//#region src/internal/span-recorder.ts
+/**
+* The run recorder: an in-memory {@link Tracer.Tracer} that keeps every span one run opened (KTD2). Nothing is
+* exported from a recorder — its spans are read in process by the failure renderer and dropped with the run.
+*
+* A recorder is per run: the kernel's baseline, each seeded run and each replay each get their own, and so does
+* every program the runner drives. Installing it is the caller's job, through `Effect.withTracer`.
+*
+* @since 4.0.0
+*/
+/** @internal */
+const createSpanRecorder = () => {
+	const spans = [];
+	return {
+		tracer: Tracer.make({ span(options) {
+			const span = new Tracer.NativeSpan(options);
+			spans.push(span);
+			return span;
+		} }),
+		spans
+	};
+};
+//#endregion
+//#region src/internal/recorded-run.ts
+/**
+* The in-process way to run a program the way the runner runs a lane and read back the record its failure rendered
+* (R11, KTD10): a corpus drives a fixture through this instead of spawning Vitest, and without importing `src/`.
+*
+* The run gets its own check ledger — its own `expect` — so a corpus fixture's `Then` asserts on the check it
+* answered with, not on the check the corpus test itself already spent, and its own recorder, so the record is
+* rendered from exactly the spans the run opened.
+*
+* @since 4.0.0
+*/
+const renderRecord = (failure, spans, identity) => renderFailureRecord({
+	failure,
+	spans,
+	identity,
+	replay: void 0,
+	root: providedRoot()
+});
+const outcomeOf = (exit, recorder, identity) => Exit.isSuccess(exit) ? void 0 : renderRecord(Cause.squash(exit.cause), recorder.spans, identity);
+const provideRun = (effect, ledger, ctx) => effect.pipe(Effect$1.provideService(Asserted, ledger.asserted), Effect$1.provideService(VitestTestContext, ctx));
+const runRecorded = (ctx, program) => {
+	const ledger = makeLedger(ctx);
+	const recorder = createSpanRecorder();
+	return Effect$1.runPromiseExit(provideRun(Effect$1.tap(program(checksFor(ledger)), () => refusingUnyielded(ledger)), ledger, ctx).pipe(Effect$1.withTracer(recorder.tracer))).then((exit) => outcomeOf(exit, recorder, testIdentityOf()));
+};
+/**
+* Runs one program as the runner runs a lane, with a fresh ledger and its own recorder, and resolves with the
+* record its failure rendered — or `undefined` when it passed.
+*
+* @internal
+*/
+const recordOfRun = (program) => {
+	const task = TestRunner.getCurrentTest();
+	if (task === void 0) return Promise.resolve(void 0);
+	return runRecorded(task.context, program);
+};
+const capturingRuntime = (captured, ledger) => ({
+	register: (name, program) => {
+		captured.push({
+			name,
+			program
+		});
+	},
+	provide: (effect) => effect,
+	ledger
+});
+const taskOfRecorded = (name, budget, store) => {
+	const current = TestRunner.getCurrentTest();
+	return {
+		identity: {
+			...testIdentityOf(current),
+			name
+		},
+		filepath: Option$1.getOrNull(Option$1.fromNullishOr(store)),
+		budget: budget ?? providedCheckDefaults()
+	};
+};
+/** Runs every captured program in registration order, each as `recordOfProperty` runs one. */
+const runCaptured = (captured, budget, store) => captured.reduce((previous, entry) => previous.then((records) => {
+	const task = taskOfRecorded(entry.name, budget, store);
+	return recordOfRun(() => entry.program(task)).then((record) => [...records, record]);
+}), Promise.resolve([]));
+/** Registers a whole file's properties on a capturing runtime with a fresh ledger, and runs them in order. */
+const capturedRun = (register, budget, store) => {
+	const captured = [];
+	const ledger = makeFileLedger();
+	register(makeProperty(capturingRuntime(captured, ledger)));
+	return runCaptured(captured, budget, store).then((records) => ({
+		records,
+		ledger
+	}));
+};
+/**
+* Runs one property the way the runner runs `it.prop`, with a fresh ledger and its own recorder, and resolves with
+* the record its falsification rendered — or `undefined` when it held.
+*
+* @internal
+*/
+const recordOfProperty = (input) => capturedRun((api) => api.prop(input.name, input.spec, input.holds), input.budget, input.store).then(({ records }) => records[0]);
+const EMPTY_FILE_OPTIONS = {};
+/**
+* Runs every property and law a file registers, in registration order, then finalises the file's one ledger:
+* resolves with each property's rendered failure and the file's single vacuous verdict, or `undefined` when the
+* file holds. The name a property is recorded under is the name it was registered with.
+*
+* @internal
+*/
+const recordOfFile = Function.dual((args) => typeof args[0] === "function", (register, options) => {
+	const resolved = options ?? EMPTY_FILE_OPTIONS;
+	return capturedRun(register, resolved.budget, resolved.store).then(({ records, ledger }) => ({
+		records,
+		vacuous: ledger.finalise()
+	}));
+});
+//#endregion
+export { providedCheckDefaults as A, providedRoot as C, Replay as D, Slop as E, ReplayFromText as O, witnessOf as S, LeakedState as T, isFailureRecordError as _, makeProperty as a, testIdentityOf as b, NonBooleanVerdict as c, ReplayNoLongerReproduces as d, ReplayUnreadable as f, drive as g, VacuousProperty as h, createSpanRecorder as i, replayOfText as k, PropertyExhausted as l, SelfModelLaw as m, recordOfProperty as n, makeFileLedger as o, SeedStoreUnreadable as p, recordOfRun as r, CoverageBelowMinimum as s, recordOfFile as t, PropertyRefuted as u, renderFailureRecord as v, InvalidBudget as w, throwFailureRecord as x, summaryOf as y };