@systemfsoftware/vitest 0.3.0 → 2.0.0

package/dist/{failure-DC_SJoxW.mjs → failure-nvq5TwWX.mjs}

@@ -1,19 +1,27 @@
 
 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 Layer from "effect/Layer";
 import * as Schema$1 from "effect/Schema";
 import * as Option$1 from "effect/Option";
-import * as Match from "effect/Match";
+import * as Match$1 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";
+import { Effect, Match, Option, Schema, SchemaGetter, SchemaIssue } from "effect";
+import { layer } from "@effect/platform-node/NodeFileSystem";
+import { layer as layer$1 } from "@effect/platform-node/NodePath";
+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";
@@ -22,13 +30,19 @@ 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 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 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.
+* - 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
+* (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
 */
@@ -41,25 +55,70 @@ 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-D3). */
+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 ENTRY_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(ENTRY_SEPARATOR);
+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 [seedPart, pathPart, ...rest] = text.split(PAIR_SEPARATOR);
-	return rest.length === 0 ? Option.all([Option.fromUndefinedOr(seedPart), Option.fromUndefinedOr(pathPart)]) : Option.none();
+	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)]));
@@ -69,7 +128,7 @@ const replayOfName = (text) => Option.flatMap(namedPairOf(text), ([seed, path])
 	seed,
 	path
 }));
-const textOfEncodedReplay = (replay) => `${SEED_PREFIX}${replay.seed}${PAIR_SEPARATOR}${PATH_PREFIX}${replay.path.join(ENTRY_SEPARATOR)}`;
+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
@@ -88,9 +147,79 @@ const replayOfText = (text) => Option.match(replayOfName(text), {
 * @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 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.
+* 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
 */
@@ -98,6 +227,16 @@ 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
 /**
@@ -129,12 +268,6 @@ const REFUSED_BREACH_TEXT = {
 */
 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;
@@ -256,7 +389,7 @@ const MARK = {
 	failed: "✗",
 	unfinished: "✗"
 };
-const not = (value) => !value;
+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);
@@ -289,16 +422,85 @@ 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 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 renderList = (value) => `[${value.map(renderValue).join(",")}]`;
-const renderObject = (value) => tagFieldOf(value) ?? renderRecord$1(value);
-const renderRecord$1 = (value) => `{${pairTextsOf(pairsOf(value)).join(",")}}`;
+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);
@@ -359,7 +561,7 @@ const textAttrOf = (span, key) => {
 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 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);
@@ -376,7 +578,7 @@ const nestedOf = (cause, depth) => cause === void 0 ? [] : layersOfCause(cause,
 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 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 : "";
@@ -462,17 +664,23 @@ 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 = (replay) => replayPrefixText(replay === void 0 ? void 0 : rerunReplayTextOf(replay));
+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) => 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);
+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);
@@ -501,7 +709,7 @@ const recordPartsOf = (input, layers) => {
 		chain: chainLinesOf(layers, chosen),
 		trail: trailLinesOf(input.spans),
 		schedule: scheduleLinesOf(input.schedule),
-		rerun: rerunLinesOf(input.identity, input.replay)
+		rerun: rerunLinesOf(input.identity, input.replay, propertyReplayTextOf(input.failure))
 	};
 };
 const maybeLine = (line) => line === void 0 ? [] : [line];
@@ -510,7 +718,7 @@ const sectionLines = (header, lines) => lines.length === 0 ? [] : [
 	...lines,
 	""
 ];
-const linesOf = (parts) => [
+const linesOf$1 = (parts) => [
 	parts.headline,
 	...maybeLine(parts.raisedAt),
 	parts.failingStep,
@@ -525,7 +733,7 @@ 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(not$1(LOCATION.test(record)), "R2"),
 	...breachIf(r6Broken(parts, input), "R6")
 ];
 const hasRoot = (root) => root !== void 0 && root.length > 0;
@@ -543,11 +751,13 @@ const relativize = (record, root) => hasRoot(root) ? record.replaceAll(`${root}/
 const renderFailureRecord = (input) => {
 	const layers = layersOf(input.failure);
 	const parts = recordPartsOf(input, layers);
-	const record = relativize(linesOf(parts).join("\n").trimEnd(), input.root);
+	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)
+		breaches: breachesOf(parts, input, record),
+		...property === void 0 ? {} : { failure: property }
 	};
 };
 const RECORD = Symbol.for("@systemfsoftware/vitest/FailureRecord");
@@ -617,6 +827,36 @@ const copyDiffFields = (error, 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",
+	"NonBooleanVerdict",
+	"CoverageBelowMinimum",
+	"SelfModelLaw",
+	"SeedStoreUnreadable",
+	"ReplayUnreadable",
+	"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
@@ -654,7 +894,8 @@ const isFailureRecordError = (value) => isObject(value) && fieldOf(value, RECORD
 const throwFailureRecord = (input) => {
 	if (isRefusalFailure(input.failure)) throw input.failure;
 	const record = renderFailureRecord(input);
-	throw copyDiffFields(printedError(input.failure, record), input.failure);
+	const printed = copyDiffFields(printedError(input.failure, record), input.failure);
+	throw copyPropertyFields(printed, input.failure);
 };
 const LEVEL_SEPARATOR = " > ";
 const EMPTY_TEXT = "";
@@ -684,7 +925,6 @@ 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;
@@ -722,12 +962,6 @@ const wilson = (hits, runs, z) => {
 	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;
@@ -746,9 +980,12 @@ const judgeOf = (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");
+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);
@@ -771,48 +1008,237 @@ 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.
+* 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) => reportOf$1(toppedUp(judgeOf(options.classes, options.runs), options.draw, FIRST_BATCH));
+const judgeCoverage = (options) => failedFailures(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).
+* The closed set of property-channel failures (KTD1, R1): refuted, non-boolean, under-covered and self-model, plus
+* the vacuous impostor verdict and the seed store's read failure. 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-D3).
+*
+* @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-D3).
+*
+* @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 PropertyReplay = Schema$1.Struct({
-	seed: Schema$1.Finite,
-	path: Schema$1.Array(Schema$1.Finite)
+const Witness = Schema.Struct({
+	rendered: Schema.String,
+	value: Schema.Json
 });
 /**
-* 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).
+* One property involved in a failure: its full name, its declaration site, its seed and its run count (R2).
 *
 * @internal
 */
-var PropertyRefuted = class extends Schema$1.TaggedError()("PropertyRefuted", {
-	detail: Schema$1.String,
-	replay: Schema$1.optional(PropertyReplay)
+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.detail;
+		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}`;
 	}
 };
 /**
-* Thrown at file end when no property in the file refuted a subject's constant impostor (R12).
+* 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 VacuousProperty = class extends Schema$1.TaggedError()("VacuousProperty", { detail: Schema$1.String }) {
+var NonBooleanVerdict = class extends Schema.TaggedError()("NonBooleanVerdict", {
+	property: PropertyRun,
+	drawn: Witness,
+	returned: Schema.Array(VerdictKind),
+	replay: Schema.String
+}) {
 	get message() {
-		return this.detail;
+		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", {
+	name: Schema.String,
+	site: Schema.NullOr(Schema.String)
+}) {
+	get message() {
+		return `${this.name}: 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}`;
 	}
 };
 /**
@@ -820,19 +1246,82 @@ var VacuousProperty = class extends Schema$1.TaggedError()("VacuousProperty", {
 *
 * @internal
 */
-var NonTupleOf = class extends Schema$1.TaggedError()("NonTupleOf", { detail: Schema$1.String }) {
+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
+/**
+* The property replay channel (KTD5, R9-R12): the text a property failure carries, the generator replay token a
+* refuted entry rebuilds, and the entry the engine selects for a property's identity hash.
+*
+* The token `effect`'s falsification runner writes is decoded here through its codec — never hand-parsed — into the
+* parts a refuted entry names, and rebuilt from them the way `makeReplay` reads them back.
+*
+* @since 4.0.0
+*/
+const NUMERIC_SEED = 0;
+/** @internal */
+const tokenOfReplay = (entry) => JSON.stringify([
+	NUMERIC_SEED,
+	`${entry.seed}`,
+	entry.attempt,
+	entry.size,
+	entry.path,
+	entry.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 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) => {
@@ -850,7 +1339,10 @@ 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("; ");
+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.
@@ -861,48 +1353,75 @@ const impostorOf = (subject) => {
 	const state = emptyState();
 	return {
 		impostor: new Proxy(subject, impostorHandler(state)),
-		frozen: () => describeFrozen(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),
-	properties: [],
-	refuters: [],
-	frozen: NO_VALUE,
-	runs: 0
+	verdicts: [],
+	refuters: []
 });
-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 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, property, verdict) => {
+const recordJudge = (state, subject, verdict) => {
 	const prior = state.judges.get(subject) ?? judgeFor(subject);
-	state.judges.set(subject, trackVerdict(prior, property, verdict));
+	state.judges.set(subject, trackVerdict(prior, 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)
+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
@@ -910,7 +1429,10 @@ const ledgerOf = (state, onProblems) => ({
 *
 * @internal
 */
-const makeFileLedger = (onProblems) => ledgerOf({ judges: /* @__PURE__ */ new Map() }, onProblems);
+const makeFileLedger = () => ledgerOf({
+	judges: /* @__PURE__ */ new Map(),
+	exempts: []
+});
 //#endregion
 //#region src/internal/property/kinds.ts
 /**
@@ -947,46 +1469,140 @@ const idempotentHolds = () => (subject, values) => sameTwice(subject, firstOf(sp
 /** @internal */
 const deterministicHolds = () => (subject, values) => Equal.equals(call(subject, values), call(subject, values));
 //#endregion
-//#region src/internal/property/replay.schema.ts
+//#region src/internal/property/seed-store.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.
+* @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 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
-]));
+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/replay.ts
+//#region src/internal/property/seed-record.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.
+* @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
 */
-/** 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]
+const decodeLine = (file, index, text) => Result.mapError(Schema$1.decodeResult(SeedStoreLine)(text), (error) => new SeedStoreUnreadable({
+	file,
+	line: index + 1,
+	detail: error.message
 }));
 /** @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;
+const decodeStoreLines = Function.dual(2, (file, lines) => Result.all(lines.map((text, index) => decodeLine(file, index, text))));
 /** @internal */
-const replayOfFailure = (value) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromNullishOr(refutationOf(value)), (failure) => Option$1.fromNullishOr(failure.replay)));
+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
 /**
@@ -999,11 +1615,24 @@ const replayOfFailure = (value) => Option$1.getOrUndefined(Option$1.flatMap(Opti
 * 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) });
 };
@@ -1022,15 +1651,30 @@ 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 resolveBudget = (name, spec, provided) => {
+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);
-	const options = mergedOptions(provided, explicit);
+	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: {
+			...options,
+			seed
+		},
+		seed
 	};
 };
 const toArbitrary = (input) => Schema$1.isSchema(input) ? Arbitrary.schema(input) : input;
@@ -1061,12 +1705,21 @@ 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 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: () => void 0
+	judge: () => []
 });
-const liveCoverage = (cover, arbitrary) => {
+const liveCoverage = (cover, arbitrary, seed) => {
 	const entries = Object.entries(cover);
 	const classes = seedClasses(entries);
 	const counter = { runs: 0 };
@@ -1075,78 +1728,206 @@ const liveCoverage = (cover, arbitrary) => {
 		judge: () => judgeCoverage({
 			classes: Object.fromEntries(classes),
 			runs: counter.runs,
-			draw: drawFor(entries, arbitrary)
+			draw: drawFor(entries, arbitrary, seed)
 		})
 	};
 };
-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));
+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) => 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 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) : Effect$1.succeed(literalVerdict(verdict, violations));
+	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 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();
+	const violations = newViolations();
 	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
+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
+		}
 	};
-	gatedLedger.record(run.subject, run.name, verdict);
 };
-const impostorRun = (run, budget) => {
+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 NO_FALSIFICATION = {
+	counterexample: witnessOf(void 0),
+	shrinks: shrinkCounted(0)
+};
+const falsificationOf = (falsified) => falsified === void 0 ? NO_FALSIFICATION : {
+	counterexample: witnessOf(falsified.shrunkInput),
+	shrinks: shrinkCounted(falsified.shrinks)
+};
+const refutedOf = (property, checked, replay) => new PropertyRefuted({
+	property,
+	...falsificationOf(falsifiedOf(checked.result)),
+	replay
+});
+const dieReported = (run, budget, checked, site) => dieWithSite(refutedOf(propertyRunOf(run, budget), checked, refutedFailureReplay(run, budget, checked)), 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 runCheck(retry).pipe(Effect$1.map((checked) => recordImpostor(retry, budget, impostor, checked)));
+	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 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 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 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) => ({
+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) => reportOf(checked) === void 0 ? Effect$1.void : dieReported(run, budget, checked, registration.site);
+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) => reportOf(checked) === void 0 ? finishPassed(run, budget, coverage, registration.gate, [...store.recorded, budget]) : appendThenDie(store, refutedCandidate(store, budget, checked), dieReported(run, budget, checked, registration.site));
+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,
@@ -1154,23 +1935,54 @@ const checkOf = (registration, arbitrary, budget, observe) => ({
 	arbitrary,
 	observe,
 	options: budget.options,
-	site: registration.site
+	seed: budget.seed,
+	identityHash,
+	site: registration.site,
+	ledger: registration.runtime.ledger
 });
-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 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 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 replayRun = (registration, baseBudget, arbitrary, hash, entry) => {
+	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) => 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 registeredName = (name, kind, exempt) => exempt ? `${name} [exempt: ${kind}]` : name;
+const propertyPlatform = Layer.merge(layer, layer$1);
+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)
+	});
+}), 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.
@@ -1192,20 +2004,27 @@ const makeProperty = (runtime) => {
 	};
 	const refuseSelfModel = (name) => {
 		const site = callFrame();
-		runtime.register(name, () => dieWithSite(new VacuousProperty({ detail: selfModelMessage(name) }), site));
+		runtime.register(name, (_task) => dieWithSite(new SelfModelLaw({
+			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 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);
+	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) => 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),
+			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
 		}
@@ -1250,7 +2069,7 @@ const renderRecord = (failure, spans, identity) => renderFailureRecord({
 	failure,
 	spans,
 	identity,
-	replay: replayOfFailure(failure),
+	replay: void 0,
 	root: providedRoot()
 });
 const outcomeOf = (exit, recorder, identity) => Exit.isSuccess(exit) ? void 0 : renderRecord(Cause.squash(exit.cause), recorder.spans, identity);
@@ -1271,23 +2090,63 @@ const recordOfRun = (program) => {
 	if (task === void 0) return Promise.resolve(void 0);
 	return runRecorded(task.context, program);
 };
-const capturingRuntime = (programs) => ({
-	register: (_name, program) => {
-		programs.push(program);
+const capturingRuntime = (captured, ledger) => ({
+	register: (name, program) => {
+		captured.push({
+			name,
+			program
+		});
 	},
-	provide: (effect) => effect
+	provide: (effect) => effect,
+	ledger
 });
-const capturedProgram = (programs) => Option$1.getOrThrow(Option$1.fromNullishOr(programs[0]));
+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) => {
-	const programs = [];
-	makeProperty(capturingRuntime(programs)).prop(input.name, input.spec, input.holds);
-	return recordOfRun(capturedProgram(programs));
-};
+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 { 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 };
+export { Slop as C, providedCheckDefaults as D, replayOfText as E, LeakedState as S, ReplayFromText as T, testIdentityOf as _, makeProperty as a, providedRoot as b, NonBooleanVerdict as c, SeedStoreUnreadable as d, SelfModelLaw as f, summaryOf as g, renderFailureRecord as h, createSpanRecorder as i, PropertyRefuted as l, isFailureRecordError as m, recordOfProperty as n, makeFileLedger as o, VacuousProperty as p, recordOfRun as r, CoverageBelowMinimum as s, recordOfFile as t, ReplayUnreadable as u, throwFailureRecord as v, Replay as w, InvalidBudget as x, witnessOf as y };