@systemfsoftware/vitest 0.1.0 → 0.3.0

package/dist/failure-DC_SJoxW.mjs

@@ -0,0 +1,1293 @@
+
+import { 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-D_-acRSc.mjs";
+import * as V from "vitest";
+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 Schema$1 from "effect/Schema";
+import * as Option$1 from "effect/Option";
+import * as Match from "effect/Match";
+import * as Tracer from "effect/Tracer";
+import { Effect, Option, Schema, SchemaGetter, SchemaIssue } from "effect";
+import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
+import * as Data from "effect/Data";
+//#region src/internal/property/defaults.ts
+/** @internal The `test.provide` key the shared config fills with this run's tier's check options. */
+const checkDefaultsKey = "@systemfsoftware/vitest:property-check";
+/** @internal The configured property-check defaults, or `undefined` when the run provided none. */
+const providedCheckDefaults = () => inject(checkDefaultsKey);
+//#endregion
+//#region src/replay.schema.ts
+/**
+* The one replay grammar (KTD10, R6): the `CONFORMANCE_REPLAY` text a failure record's rerun line carries and
+* the spec runtime reads back to re-run the same schedule. The text names the seed a generator chose and the
+* decisions it took, in order — `seed=7;path=1,2,3` — and the path is empty when the run took no decision
+* (`seed=1;path=`). A text that names neither is not a replay.
+*
+* The seed and every decision are branded whole numbers (CONST-D3), 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-D3). */
+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-D3). */
+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)
+});
+const SEED_PREFIX = "seed=";
+const PATH_PREFIX = "path=";
+const PAIR_SEPARATOR = ";";
+const ENTRY_SEPARATOR = ",";
+const WHOLE_NUMBER = /^\d+$/u;
+const NOT_A_REPLAY = "a replay reads \"seed=<whole number>;path=<comma-separated whole numbers>\"";
+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(ENTRY_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 pairPartsOf = (text) => {
+	const [seedPart, pathPart, ...rest] = text.split(PAIR_SEPARATOR);
+	return rest.length === 0 ? Option.all([Option.fromUndefinedOr(seedPart), Option.fromUndefinedOr(pathPart)]) : 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(ENTRY_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);
+/**
+* The 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)
+}));
+//#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 NonBooleanVerdict = class extends Schema.TaggedError()("NonBooleanVerdict", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** @internal */
+var LeakedState = class extends Schema.TaggedError()("LeakedState", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** @internal */
+var Slop = class extends Schema.TaggedError()("Slop", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** @internal */
+var InvalidBudget = class extends Schema.TaggedError()("InvalidBudget", { detail: Schema.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/** @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 (CONST-D3).
+*
+* @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 = (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) => isObject(value) ? renderObject(value) : renderScalar(value);
+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 renderList = (value) => `[${value.map(renderValue).join(",")}]`;
+const renderObject = (value) => tagFieldOf(value) ?? renderRecord$1(value);
+const renderRecord$1 = (value) => `{${pairTextsOf(pairsOf(value)).join(",")}}`;
+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.value(span.status).pipe(Match.when({ _tag: "Started" }, () => "unfinished"), Match.when({ _tag: "Ended" }, (ended) => endedStateOf(ended.exit)), Match.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.value(reason).pipe(Match.when({ _tag: "Fail" }, (fail) => fail.error), Match.when({ _tag: "Die" }, (die) => die.defect), Match.when({ _tag: "Interrupt" }, (interrupt) => interruptTextOf(interrupt)), Match.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 rerunReplayTextOf = (replay) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromUndefinedOr(replay.seed), (seed) => Option$1.map(replayOfParts({
+	seed,
+	path: replay.path
+}), replayTextOf)));
+const replayPrefixText = (text) => text === void 0 ? "" : `CONFORMANCE_REPLAY="${text}" `;
+const replayPrefixOf = (replay) => replayPrefixText(replay === void 0 ? void 0 : rerunReplayTextOf(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) => isCompleteIdentity(identity) ? `  ${replayPrefixOf(replay)}${filterPrefixOf(identity)}vitest run ${identity.file} -t ` + quoted(identity.name) : void 0;
+const rerunLinesOf = (identity, replay) => {
+	const line = rerunLineOf(identity, replay);
+	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)
+	};
+};
+const maybeLine = (line) => line === void 0 ? [] : [line];
+const sectionLines = (header, lines) => lines.length === 0 ? [] : [
+	header,
+	...lines,
+	""
+];
+const linesOf = (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(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(parts).join("\n").trimEnd(), input.root);
+	return {
+		name: nameOf(layers),
+		record,
+		breaches: breachesOf(parts, input, record)
+	};
+};
+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 `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);
+	throw copyDiffFields(printedError(input.failure, record), 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/property/coverage.ts
+/**
+* @internal The R14 coverage classes: labelled input predicates, each with a minimum share of runs.
+*
+* A class fails only when QuickCheck's sequential test (`stdConfidence`) is confident its share is below
+* the minimum, and is satisfied once the test is confident the share is at least 0.9 of the minimum
+* (`TOLERANCE` at a certainty of 10^9). The tolerance is what makes the test terminate: a class sitting
+* exactly at its minimum would otherwise draw forever.
+*/
+const CERTAINTY = 10 ** 9;
+const TOLERANCE = .9;
+const FIRST_BATCH = 64;
+const BATCH_CAP = 4096;
+const DRAW_CAP = 1e5;
+const FAILURE_HEAD = "coverage";
+/** The certainty's two-sided tail probability: `alpha / 2` for `alpha = 1 / CERTAINTY`. */
+const TAIL_PROBABILITY = 1 / (2 * CERTAINTY);
+const C1 = -.007784894002430293;
+const C2 = -.3223964580411365;
+const C3 = -2.400758277161838;
+const C4 = -2.549732539343734;
+const C5 = 4.374664141464968;
+const C6 = 2.938163982698783;
+const D1 = .007784695709041462;
+const D2 = .3224671290700398;
+const D3 = 2.445134137142996;
+const D4 = 3.754408661907416;
+const TAIL_NUMERATOR = [
+	C1,
+	C2,
+	C3,
+	C4,
+	C5,
+	C6
+];
+const TAIL_DENOMINATOR = [
+	D1,
+	D2,
+	D3,
+	D4
+];
+/** Horner's rule over a coefficient list, highest power first. */
+const poly = (coefficients, x) => coefficients.reduceRight((total, coefficient) => total * x + coefficient, 0);
+const tailSpread = (p) => Math.sqrt(-2 * Math.log(p));
+const tailInverse = (spread) => poly(TAIL_NUMERATOR, spread) / poly(TAIL_DENOMINATOR, spread);
+/** The inverse standard-normal CDF at the tail probability the certainty asks for. */
+const TAIL_Z = tailInverse(tailSpread(TAIL_PROBABILITY));
+const wilson = (hits, runs, z) => {
+	const share = hits / runs;
+	const zz = z * z;
+	return (share + zz / (2 * runs) + z * Math.sqrt(share * (1 - share) / runs + zz / (4 * runs * runs))) / (1 + zz / runs);
+};
+/**
+* Thrown when a coverage class is confidently below its minimum share of runs.
+*
+* @internal
+*/
+var CoverageBelowMinimum = class extends Data.Error {};
+const wilsonLower = (entry, runs) => wilson(entry.hits, runs, -TAIL_Z);
+const wilsonUpper = (entry, runs) => wilson(entry.hits, runs, TAIL_Z);
+const covered = (entry, runs) => wilsonLower(entry, runs) >= TOLERANCE * entry.minimum;
+const uncovered = (entry, runs) => wilsonUpper(entry, runs) < entry.minimum;
+const decided = (entry, runs) => covered(entry, runs) || uncovered(entry, runs);
+const settled = (entry, runs) => runs === 0 ? false : decided(entry, runs);
+const entriesOf = (classes) => Object.keys(classes).map((label) => entryAt(classes, label));
+const entryAt = (classes, label) => [label, classOf(classes, label)];
+const classOf = (classes, label) => classes[label] ?? {
+	hits: 0,
+	minimum: 0
+};
+const judgeOf = (classes, runs) => ({
+	classes: new Map(entriesOf(classes)),
+	runs
+});
+const openLabels = (judge) => [...judge.classes].filter(([, entry]) => !settled(entry, judge.runs)).map(([label]) => label);
+const failedEntries = (judge) => [...judge.classes].filter(([, entry]) => uncovered(entry, judge.runs));
+const describeShare = (hits, runs) => `${String(hits)}/${String(runs)}`;
+const describeFailure = (label, entry, runs) => `${FAILURE_HEAD} ${label}: ${describeShare(entry.hits, runs)} of runs, below the required ${String(entry.minimum)}`;
+const reportFailures = (judge) => failedEntries(judge).map(([label, entry]) => describeFailure(label, entry, judge.runs)).join("\n");
+/** @internal */
+const countHit = Function.dual(2, (classes, label) => {
+	const prior = classes.get(label);
+	if (prior !== void 0) classes.set(label, {
+		hits: prior.hits + 1,
+		minimum: prior.minimum
+	});
+});
+const countLabels = (classes, labels) => {
+	for (const label of labels) countHit(classes, label);
+	return classes;
+};
+const countDraws = (classes, drawn) => drawn.reduce(countLabels, new Map(classes));
+const withDraws = (judge, drawn) => ({
+	classes: countDraws(judge.classes, drawn),
+	runs: judge.runs + drawn.length
+});
+const drawBatch = (judge, draw, batch) => withDraws(judge, draw.more(sizeOf(judge, batch)));
+const sizeOf = (judge, batch) => Math.min(batch, DRAW_CAP - judge.runs);
+const grown = (batch) => Math.min(batch * 2, BATCH_CAP);
+const keepDrawing = (judge) => openLabels(judge).length > 0 && judge.runs < DRAW_CAP;
+const toppedUp = (judge, draw, batch) => keepDrawing(judge) ? toppedUp(drawBatch(judge, draw, batch), draw, grown(batch)) : judge;
+const reportOf$1 = (judge) => failedEntries(judge).length === 0 ? void 0 : reportFailures(judge);
+/**
+* Runs R14's sequential draw: tops up the undecided classes until every class is decided or the draw cap
+* is reached, then reports the confidently under-covered classes, naming each label and its observed share.
+*
+* @internal
+*/
+const judgeCoverage = (options) => reportOf$1(toppedUp(judgeOf(options.classes, options.runs), options.draw, FIRST_BATCH));
+//#endregion
+//#region src/internal/property/error.schema.ts
+/**
+* The generator's choice that refuted a property, as data: the seed and the shrink path fast-check recorded. The
+* renderer reads it off the failure value instead of parsing the message (KTD5).
+*
+* @internal
+*/
+const PropertyReplay = Schema$1.Struct({
+	seed: Schema$1.Finite,
+	path: Schema$1.Array(Schema$1.Finite)
+});
+/**
+* A falsified property: the message the failure carries, and the generator's choice when the check result recorded
+* one, so the rerun line can replay it (KTD5).
+*
+* @internal
+*/
+var PropertyRefuted = class extends Schema$1.TaggedError()("PropertyRefuted", {
+	detail: Schema$1.String,
+	replay: Schema$1.optional(PropertyReplay)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+/**
+* Thrown at file end when no property in the file refuted a subject's constant impostor (R12).
+*
+* @internal
+*/
+var VacuousProperty = class extends Schema$1.TaggedError()("VacuousProperty", { detail: Schema$1.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+/**
+* Thrown when a law kind is given a record `of`, which cannot be spread into its subject.
+*
+* @internal
+*/
+var NonTupleOf = class extends Schema$1.TaggedError()("NonTupleOf", { detail: Schema$1.String }) {
+	get message() {
+		return this.detail;
+	}
+};
+//#endregion
+//#region src/internal/property/impostor.ts
+const SUBJECT_KEY = "the subject";
+const NO_VALUE = "";
+const isCallable = (value) => typeof value === "function";
+const isCallableSubject = (target) => typeof target === "function";
+const describeValue = (value) => isCallable(value) ? "a function" : String(value);
+const describeEntry = (key, value) => `${key} always returned ${describeValue(value)}`;
+const emptyState = () => ({ outputs: /* @__PURE__ */ new Map() });
+const frozenAt = (state, key, compute) => state.outputs.has(key) ? state.outputs.get(key) : remember(state, key, compute());
+const remember = (state, key, value) => {
+	state.outputs.set(key, value);
+	return value;
+};
+const callOutput = (state, fn, thisArg, args) => frozenAt(state, SUBJECT_KEY, () => Reflect.apply(fn, thisArg, args));
+const memberWrapper = (state, key, fn) => (...values) => frozenAt(state, key, () => Reflect.apply(fn, void 0, values));
+const memberWrapperOf = (state, fn, key) => fn === void 0 ? void 0 : memberWrapper(state, key, fn);
+const appliedImpostor = (state, target, thisArg, args) => isCallableSubject(target) ? callOutput(state, target, thisArg, args) : void 0;
+const memberImpostor = (state, target, key) => memberWrapperOf(state, target[key], key);
+const readImpostor = (state, target, property) => isCallableSubject(target) ? Reflect.get(target, property, target) : memberRead(state, target, property);
+const memberRead = (state, target, property) => typeof property === "string" ? memberImpostor(state, target, property) : void 0;
+const impostorHandler = (state) => ({
+	apply: (target, thisArg, args) => appliedImpostor(state, target, thisArg, args),
+	get: (target, property) => readImpostor(state, target, property)
+});
+const describeFrozen = (state) => [...state.outputs].map(([key, value]) => describeEntry(key, value)).join("; ");
+/**
+* A constant impostor of `subject`: a function returns its first output forever, and so does each member
+* of a record.
+*
+* @internal
+*/
+const impostorOf = (subject) => {
+	const state = emptyState();
+	return {
+		impostor: new Proxy(subject, impostorHandler(state)),
+		frozen: () => describeFrozen(state)
+	};
+};
+/** @internal */
+const subjectLabel = (subject) => isCallableSubject(subject) ? `a function of ${String(subject.length)} argument(s)` : `a record of ${Object.keys(subject).sort().join(", ")}`;
+const judgeFor = (subject) => ({
+	label: subjectLabel(subject),
+	properties: [],
+	refuters: [],
+	frozen: NO_VALUE,
+	runs: 0
+});
+const trackProperty = (judge, property) => judge.properties.includes(property) ? judge : {
+	...judge,
+	properties: [...judge.properties, property]
+};
+const trackRefuter = (judge, property) => judge.refuters.includes(property) ? judge : {
+	...judge,
+	refuters: [...judge.refuters, property]
+};
+const trackVerdict = (judge, property, verdict) => {
+	const named = trackProperty(judge, property);
+	return verdict.refuted ? trackRefuter(named, property) : {
+		...named,
+		frozen: verdict.frozen,
+		runs: verdict.runs
+	};
+};
+const recordJudge = (state, subject, property, verdict) => {
+	const prior = state.judges.get(subject) ?? judgeFor(subject);
+	state.judges.set(subject, trackVerdict(prior, property, verdict));
+};
+const isVacuous = (judge) => judge.refuters.length === 0;
+const describeVacuous = (judge) => `${judge.properties.join(", ")}: no property in this file refuted the constant impostor of this subject (${judge.label}), so nothing here pins it down. It held for ${judge.runs} run(s) against a fake that ${judge.frozen === NO_VALUE ? "was never called" : judge.frozen}, whatever the input. Laws that only relate outputs to each other (additivity, idempotence, commutativity, round trips through the subject) hold for such constants. Pin the output to the input: compare against an independent model (\`subject(x)\` equals a straightforward reimplementation), or conjoin a base case (\`subject([one])\` equals its known value). Also check that the body calls the \`subject\` it was given, not the imported implementation.`;
+const finaliseJudges = (state, onProblems) => {
+	const vacuous = [...state.judges.values()].filter(isVacuous).map(describeVacuous);
+	if (vacuous.length === 0) return;
+	throw onProblems(vacuous.join("\n\n"));
+};
+const ledgerOf = (state, onProblems) => ({
+	record: (subject, property, verdict) => recordJudge(state, subject, property, verdict),
+	finalise: () => finaliseJudges(state, onProblems)
+});
+/**
+* Collects the impostor verdicts of every property in the file and decides, at file end, which subjects
+* nothing refuted.
+*
+* @internal
+*/
+const makeFileLedger = (onProblems) => ledgerOf({ judges: /* @__PURE__ */ new Map() }, onProblems);
+//#endregion
+//#region src/internal/property/kinds.ts
+/**
+* @internal The R13 law kinds: `model`, `metamorphic`, `roundTrip` and `invariant` are sugar over the
+* gated property (R11/R12); `idempotent` and `deterministic` are declared exempt — they skip the impostor
+* gate, are reported as exempt, and are the only exemptions.
+*
+* Each kind owns the comparison, so there is nowhere to write `return true`: the author hands over
+* functions, and the kind relates their outputs with Effect's structural `Equal`.
+*/
+/**
+* The generated values as the argument list a law subject is called with.
+*
+* @internal
+*/
+const spreadValues = (values) => Array.isArray(values) ? values : refuseRecordOf();
+const refuseRecordOf = () => {
+	throw new NonTupleOf({ detail: "a law kind spreads the generated values into its subject, so `of` must be a tuple; a record `of` holds functions of the record, which only it.prop reaches" });
+};
+const call = (subject, values) => subject(...spreadValues(values));
+const equalOutputs = (original, transformed) => Equal.equals(original, transformed);
+/** @internal */
+const modelHolds = (oracle) => (subject, values) => Equal.equals(call(subject, values), call(oracle, values));
+/** @internal */
+const metamorphicHolds = (relation) => (subject, values) => (relation.relate ?? equalOutputs)(call(subject, values), call(subject, relation.transform(...spreadValues(values))));
+/** @internal */
+const roundTripHolds = (decode) => (subject, values) => Equal.equals(decode(call(subject, values)), values);
+/** @internal */
+const invariantHolds = (holds) => (subject, values) => holds(call(subject, values), ...spreadValues(values));
+const firstOf = (values) => values[0];
+const sameTwice = (subject, value) => value === void 0 ? false : Equal.equals(subject(subject(value)), subject(value));
+/** @internal */
+const idempotentHolds = () => (subject, values) => sameTwice(subject, firstOf(spreadValues(values)));
+/** @internal */
+const deterministicHolds = () => (subject, values) => Equal.equals(call(subject, values), call(subject, values));
+//#endregion
+//#region src/internal/property/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
+/**
+* The replay value a property counterexample carries (KTD5): the seed and the shrink path the generator recorded,
+* read off the failure value and out of the check result as data. Nothing here reads a failure message.
+*
+* The token `effect`'s falsification runner writes is decoded here — never hand-parsed — into the seed and path R6
+* prints.
+*
+* @since 4.0.0
+*/
+/** The token's leading kind that names a numeric seed. */
+const NUMERIC_SEED = 0;
+const numericSeedOf = (token) => token[0] === NUMERIC_SEED ? Number(token[1]) : void 0;
+const replayOf = (token) => Option$1.map(Option$1.fromNullishOr(numericSeedOf(token)), (seed) => ({
+	seed,
+	path: token[4]
+}));
+/** @internal */
+const replayOfToken = (replay) => Option$1.getOrUndefined(Option$1.flatMap(Schema$1.decodeOption(ReplayToken)(replay), replayOf));
+const refutationOf = (value) => Schema$1.is(PropertyRefuted)(value) ? value : void 0;
+/** @internal */
+const replayOfFailure = (value) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromNullishOr(refutationOf(value)), (failure) => Option$1.fromNullishOr(failure.replay)));
+//#endregion
+//#region src/internal/property/engine.ts
+/**
+* @internal The lawful property engine (R11-R15): a property names the function under test, takes a budget
+* that merges its own fields over the configured default over `runs: 100`, accepts only a literal boolean
+* verdict (or an `Effect` of one), judges coverage classes with QuickCheck's sequential test, and defers the
+* constant-impostor verdict to the end of the file.
+*
+* `of` accepts what upstream accepts — a tuple or record of Schemas or Arbitraries (KTD10) — and `holds`
+* receives the generated values exactly as drawn, typed by the gens that produced them.
+*/
+const REWRITE = "it.prop(name, { of, subject, runs }, holds)";
+const DEFAULT_RUNS = 100;
+const isPositiveInteger = (runs) => Number.isInteger(runs) && runs > 0;
+const describeRuns = (runs) => Number.isInteger(runs) ? `${String(runs)}` : "a non-integer";
+const invalidPropertyBudget = (name, runs) => `${name}: pass a positive integer \`runs\`; received ${describeRuns(runs)}. Write ${REWRITE}.`;
+const invalidProvidedBudget = (runs) => `the configured property budget (${checkDefaultsKey}) supplies \`runs\`: ${describeRuns(runs)}; it must be a positive integer.`;
+const requirePositiveRuns = (message, runs) => {
+	if (isInvalidRuns(runs)) throw new InvalidBudget({ detail: message(runs) });
+};
+const isInvalidRuns = (runs) => runs !== void 0 && isPositiveInteger(runs) === false;
+/** The property's own explicit fields, a property-level `runs` outranking the same field in `arbitrary`. */
+const explicitOptions = (spec) => spec.runs === void 0 ? { ...spec.arbitrary } : {
+	...spec.arbitrary,
+	runs: spec.runs
+};
+const mergedOptions = (provided, explicit) => ({
+	runs: DEFAULT_RUNS,
+	...provided,
+	...explicit
+});
+const resolvedRuns = (options) => options.runs ?? DEFAULT_RUNS;
+/**
+* The effective check options: the property's own fields over the configured default over `runs: 100`,
+* merged field by field so a property that sets only `runs` still inherits the configured size and caps.
+*/
+const resolveBudget = (name, spec, provided) => {
+	const explicit = explicitOptions(spec);
+	requirePositiveRuns((runs) => invalidPropertyBudget(name, runs), explicit.runs);
+	requirePositiveRuns(invalidProvidedBudget, provided?.runs);
+	const options = mergedOptions(provided, explicit);
+	return {
+		runs: resolvedRuns(options),
+		options
+	};
+};
+const toArbitrary = (input) => Schema$1.isSchema(input) ? Arbitrary.schema(input) : input;
+const assignArbitrary = (built, of, key) => {
+	const input = of[key];
+	if (input !== void 0) built[key] = toArbitrary(input);
+};
+const recordArbitraries = (of) => {
+	const built = {};
+	for (const key of Object.keys(of)) assignArbitrary(built, of, key);
+	return built;
+};
+const isTupleOf = (of) => Array.isArray(of);
+function arbitraryOf(of) {
+	return isTupleOf(of) ? Arbitrary.all(of.map(toArbitrary)) : Arbitrary.all(recordArbitraries(of));
+}
+const minimumOf = (entry) => entry[1];
+const seedClasses = (entries) => {
+	const classes = /* @__PURE__ */ new Map();
+	for (const [label, entry] of entries) classes.set(label, {
+		hits: 0,
+		minimum: minimumOf(entry)
+	});
+	return classes;
+};
+const satisfiedLabels = (entries, values) => entries.filter(([, entry]) => entry[0](...spreadValues(values))).map(([label]) => label);
+const observeRun = (classes, counter, entries, values) => {
+	counter.runs = counter.runs + 1;
+	for (const label of satisfiedLabels(entries, values)) countHit(classes, label);
+};
+const drawFor = (entries, arbitrary) => ({ more: (count) => Effect$1.runSync(Arbitrary.sampleEffect(arbitrary, { count }).pipe(Effect$1.orDie)).map((values) => satisfiedLabels(entries, values)) });
+const noCoverage = () => ({
+	observe: () => void 0,
+	judge: () => void 0
+});
+const liveCoverage = (cover, arbitrary) => {
+	const entries = Object.entries(cover);
+	const classes = seedClasses(entries);
+	const counter = { runs: 0 };
+	return {
+		observe: (values) => observeRun(classes, counter, entries, values),
+		judge: () => judgeCoverage({
+			classes: Object.fromEntries(classes),
+			runs: counter.runs,
+			draw: drawFor(entries, arbitrary)
+		})
+	};
+};
+const makeCoverage = (cover, arbitrary) => cover === void 0 ? noCoverage() : liveCoverage(cover, arbitrary);
+const describeVerdict = (verdict) => Effect$1.isEffect(verdict) ? "an Effect, which this lane never runs" : `a ${typeof verdict}`;
+const nonBoolean = (verdict, violations) => {
+	violations.add(describeVerdict(verdict));
+	return true;
+};
+const literalVerdict = (verdict, violations) => typeof verdict === "boolean" ? verdict : nonBoolean(verdict, violations);
+const effectVerdict = (lane, verdict, violations) => lane === "sync" ? Effect$1.succeed(nonBoolean(verdict, violations)) : Effect$1.map(verdict, (value) => literalVerdict(value, violations));
+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) : Effect$1.succeed(literalVerdict(verdict, violations));
+};
+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 violationMessage = (name, violations) => `${name}: the property returned no boolean; it returned ${violations.join(", ")}. A property must return a literal boolean verdict — asserting with expect(), or returning an Option, Result or object, is not a verdict; write ${REWRITE}.`;
+const runCheck = (run) => {
+	const violations = /* @__PURE__ */ new Set();
+	return Arbitrary.checkEffect(run.arbitrary, guardedVerdict(run, violations), run.options).pipe(Effect$1.map((result) => ({
+		violations,
+		result
+	})));
+};
+const reportOf = (checked) => Arbitrary.formatCheckFailure(checked.result);
+const violationOf = (name, checked) => checked.violations.size === 0 ? void 0 : violationMessage(name, [...checked.violations]);
+const isRefuted = (checked) => checked.violations.size > 0 || reportOf(checked) !== void 0;
+const dieWithSite = (error, site) => Effect$1.die(withRaisingFrame(error, site));
+const dieViolation = (detail, site) => dieWithSite(new NonBooleanVerdict({ detail }), site);
+const dieReported = (name, report, replay, site) => {
+	const detail = `${name}: the property was falsified. ${report}`;
+	return dieWithSite(new PropertyRefuted(replay === void 0 ? { detail } : {
+		detail,
+		replay
+	}), site);
+};
+const dieUncovered = (failure, site) => dieWithSite(new CoverageBelowMinimum({ message: failure }), site);
+const impostorHolds = (holds, impostor) => (_subject, values) => holds(impostor.impostor, values);
+const recordImpostor = (run, budget, impostor, checked) => {
+	const verdict = {
+		refuted: isRefuted(checked),
+		frozen: impostor.frozen(),
+		runs: budget.runs
+	};
+	gatedLedger.record(run.subject, run.name, verdict);
+};
+const impostorRun = (run, budget) => {
+	const impostor = impostorOf(run.subject);
+	const retry = {
+		...run,
+		holds: impostorHolds(run.holds, impostor),
+		observe: noObserve
+	};
+	return runCheck(retry).pipe(Effect$1.map((checked) => recordImpostor(retry, budget, impostor, checked)));
+};
+const noObserve = () => void 0;
+const gateRun = (run, budget, gate) => gate ? impostorRun(run, budget) : Effect$1.void;
+const finishPassed = (run, budget, coverage, gate) => {
+	const failure = coverage.judge();
+	return failure === void 0 ? gateRun(run, budget, gate) : dieUncovered(`${run.name}: ${failure}`, run.site);
+};
+const falsifiedOf = (result) => "replay" in result ? result : void 0;
+const replayOfChecked = (checked) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromNullishOr(falsifiedOf(checked.result)), (falsified) => Option$1.fromNullishOr(replayOfToken(falsified.replay))));
+const settleReport = (run, budget, coverage, gate, report, replay) => report === void 0 ? finishPassed(run, budget, coverage, gate) : dieReported(run.name, report, replay, run.site);
+const settle = (registration, run, budget, coverage, checked) => {
+	const violation = violationOf(registration.name, checked);
+	return violation === void 0 ? settleReport(run, budget, coverage, registration.gate, reportOf(checked), replayOfChecked(checked)) : dieViolation(violation, registration.site);
+};
+const checkOf = (registration, arbitrary, budget, observe) => ({
+	name: registration.name,
+	lane: registration.lane,
+	subject: registration.spec.subject,
+	holds: registration.holds,
+	arbitrary,
+	observe,
+	options: budget.options,
+	site: registration.site
+});
+const program = (registration) => Effect$1.gen(function* () {
+	const budget = resolveBudget(registration.name, registration.spec, providedCheckDefaults());
+	const arbitrary = arbitraryOf(registration.spec.of);
+	const coverage = makeCoverage(registration.spec.cover, arbitrary);
+	const run = checkOf(registration, arbitrary, budget, coverage.observe);
+	const checked = yield* runCheck(run);
+	yield* settle(registration, run, budget, coverage, checked);
+});
+const programOf = (registration) => () => registration.runtime.provide(program(registration));
+const selfModelMessage = (name) => `${name}: the model is the subject itself; a model law must compare against an independent oracle.`;
+const gatedLedger = makeFileLedger((message) => new VacuousProperty({ detail: message }));
+V.afterAll(() => {
+	gatedLedger.finalise();
+});
+const registeredName = (name, kind, exempt) => exempt ? `${name} [exempt: ${kind}]` : name;
+const isSelfModel = (subject, oracle) => Object.is(subject, oracle);
+/**
+* The property surface over one runtime: `prop`, `effectProp`, and the R13 law kinds routed through the gate.
+*
+* @internal
+*/
+const makeProperty = (runtime) => {
+	const body = (name, spec, holds, lane, gate) => {
+		const registration = {
+			runtime,
+			name,
+			spec,
+			holds,
+			lane,
+			gate,
+			site: callFrame()
+		};
+		runtime.register(name, programOf(registration));
+	};
+	const refuseSelfModel = (name) => {
+		const site = callFrame();
+		runtime.register(name, () => dieWithSite(new VacuousProperty({ detail: selfModelMessage(name) }), site));
+	};
+	const gated = (name, spec, holds, kind, exempt) => body(registeredName(name, kind, exempt), spec, holds, "sync", exempt === false);
+	const model = (name, spec, oracle) => isSelfModel(spec.subject, oracle) ? refuseSelfModel(name) : gated(name, spec, modelHolds(oracle), "model", false);
+	const idempotent = (name, spec) => gated(name, spec, idempotentHolds(), "idempotent", true);
+	const deterministic = (name, spec) => gated(name, spec, deterministicHolds(), "deterministic", true);
+	return {
+		prop: (name, spec, holds) => body(name, spec, holds, "sync", true),
+		effectProp: (name, spec, holds) => body(name, spec, holds, "effect", true),
+		law: {
+			model,
+			metamorphic: (name, spec, relation) => gated(name, spec, metamorphicHolds(relation), "metamorphic", false),
+			roundTrip: (name, spec, decode) => gated(name, spec, roundTripHolds(decode), "roundTrip", false),
+			invariant: (name, spec, holds) => gated(name, spec, invariantHolds(holds), "invariant", false),
+			idempotent,
+			deterministic
+		}
+	};
+};
+//#endregion
+//#region src/internal/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: replayOfFailure(failure),
+	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(program(checksFor(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 = (programs) => ({
+	register: (_name, program) => {
+		programs.push(program);
+	},
+	provide: (effect) => effect
+});
+const capturedProgram = (programs) => Option$1.getOrThrow(Option$1.fromNullishOr(programs[0]));
+/**
+* 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) => {
+	const programs = [];
+	makeProperty(capturingRuntime(programs)).prop(input.name, input.spec, input.holds);
+	return recordOfRun(capturedProgram(programs));
+};
+//#endregion
+export { ReplayFromText as _, replayOfFailure as a, summaryOf as c, providedRoot as d, InvalidBudget as f, Replay as g, Slop as h, makeProperty as i, testIdentityOf as l, NonBooleanVerdict as m, recordOfRun as n, isFailureRecordError as o, LeakedState as p, createSpanRecorder as r, renderFailureRecord as s, recordOfProperty as t, throwFailureRecord as u, replayOfText as v };