@systemfsoftware/vitest 0.2.0 → 1.0.0

package/dist/{failure-BquJJPFZ.mjs → failure-D8mPXwf4.mjs}

@@ -1,27 +1,133 @@
 
-import { d as framesOf$1, f as isUserPath, i as checksFor, o as makeLedger, p as withRaisingFrame, r as Asserted, s as callFrame, t as VitestTestContext, u as firstUserSiteOf } from "./test-context-ChvjVyCo.mjs";
-import { b as refusedRecordDetail } from "./guard-p_8ARgPm.mjs";
+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 from "effect/Effect";
+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 from "effect/Option";
-import { Schema } from "effect";
+import * as Option$1 from "effect/Option";
 import * as Match from "effect/Match";
 import * as Tracer from "effect/Tracer";
-import * as Arbitrary from "effect/unstable/arbitrary/Arbitrary";
+import { Effect, Option, Schema, SchemaGetter, SchemaIssue } from "effect";
+import * as Arbitrary from "effect/Arbitrary";
 import * as Data from "effect/Data";
-import * as Equal from "effect/Equal";
 //#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() {
@@ -48,11 +154,7 @@ var InvalidBudget = class extends Schema.TaggedError()("InvalidBudget", { detail
 };
 /** @internal */
 var FailureRecordRefused = class extends Schema.TaggedError()("FailureRecordRefused", {
-	breaches: Schema.Array(Schema.Literals([
-		"R1",
-		"R2",
-		"R6"
-	])),
+	breaches: Breaches,
 	cause: Schema.optional(Schema.Unknown)
 }) {
 	get message() {
@@ -60,6 +162,52 @@ var FailureRecordRefused = class extends Schema.TaggedError()("FailureRecordRefu
 	}
 };
 //#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
@@ -91,7 +239,7 @@ const FILE_PROTOCOL = "file://";
 const UNKNOWN_SITE = "?";
 const DEFAULT_FAILURE_NAME = "Error";
 const NEVER_FINISHED = "   (never finished)";
-const CAUSE_DEPTH$1 = 6;
+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,
@@ -101,7 +249,7 @@ const SKIPPED_FIELDS = {
 	[CAUSE_FIELD]: true
 };
 /** The contract's "first location": any `<path>:<line>` the record names. */
-const LOCATION$1 = /(?:[\w.@-]+\/)*[\w.@-]+\.[cm]?[jt]sx?:\d+/u;
+const LOCATION = /(?:[\w.@-]+\/)*[\w.@-]+\.[cm]?[jt]sx?:\d+/u;
 const COLUMN_SUFFIX = /:\d+$/u;
 const MARK = {
 	passed: "✓",
@@ -112,24 +260,24 @@ 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$1 = (value) => typeof value === "object" && value !== null;
-const isText$2 = (value) => typeof value === "string";
+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$1 = (value) => isObject$1(value) ? value : void 0;
+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$1 = (text) => text === void 0 ? void 0 : presentOrUndefined(text);
-const fieldOf$1 = (value, key) => Reflect.get(value, key);
+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$1(value, key);
-	return isText$2(field) ? field : void 0;
+	const field = fieldOf(value, key);
+	return isText(field) ? field : void 0;
 };
-const nonEmptyFieldOf = (value, key) => nonEmptyText$1(textFieldOf(value, key));
+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) => ({
@@ -139,10 +287,10 @@ const pairOf = (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$1(value) ? Object.keys(value).map((key) => pairOf(key, renderValue(fieldOf$1(value, key)))) : [];
+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$1(value) ? renderObject(value) : renderScalar(value);
-const renderScalar = (value) => isText$2(value) ? JSON.stringify(value) : renderPrimitive(value);
+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);
@@ -154,9 +302,9 @@ 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$2(value) ? textSummaryOf(value) : renderScalar(value);
+const scalarSummaryOf = (value) => isText(value) ? textSummaryOf(value) : renderScalar(value);
 /** @internal */
-const summaryOf = (value) => isObject$1(value) ? objectSummaryOf(value) : scalarSummaryOf(value);
+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);
@@ -179,21 +327,21 @@ const objectNameOf = (value) => firstPresent([tagFieldOf(value), nonEmptyFieldOf
 const headlineOf = (layers) => layers.length === 0 ? "" : summaryOf(layers[0]);
 const nameOf = (layers) => {
 	const entry = layers[0];
-	return isObject$1(entry) ? objectNameOf(entry) : DEFAULT_FAILURE_NAME;
+	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$2(site) ? stripColumn(stripProtocol(site)) : void 0;
+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$2(stack) ? firstUserSiteOf(stack) : void 0;
+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$1 = (value) => isObject$1(value) ? stackIn(value) : "";
-const framesOf = (value) => framesOf$1(stackOf$1(value));
+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 isUserFrame = (frame) => isUserPath(frame.path);
 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})` : "";
@@ -206,31 +354,31 @@ const chosenFrameOf = (layers) => {
 const attrOf = (span, key) => span.attributes.get(key);
 const textAttrOf = (span, key) => {
 	const value = attrOf(span, key);
-	return isText$2(value) ? value : void 0;
+	return isText(value) ? value : void 0;
 };
 const ancestorsIn = (span) => span instanceof Tracer.NativeSpan ? [span, ...ancestorsOf(span.parent)] : [];
-const ancestorsOf = (parent) => Option.isNone(parent) ? [] : ancestorsIn(parent.value);
+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$2(attrOf(span, CELL_STACKTRACE));
+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$1(value) ? objectOrUndefined$1(fieldOf$1(value, CAUSE_FIELD)) : void 0;
+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$1(reason), depth));
+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$1 = (value) => [value, ...nestedCauseOf(value, CAUSE_DEPTH$1)];
+const causeChainOf = (value) => [value, ...nestedCauseOf(value, CAUSE_DEPTH)];
 const interruptTextOf = (reason) => reason.fiberId === void 0 ? "interrupted" : `interrupted by fiber #${reason.fiberId}`;
-const reasonPayloadOf$1 = (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$1(reasonPayloadOf$1(reason)));
-const layersOf = (failure) => Cause.isCause(failure) ? reasonsOf(failure) : causeChainOf$1(failure);
+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) ?? "");
@@ -310,19 +458,16 @@ 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$1(layer) ? messageTailLines(layer) : [];
+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 renderEntryNonNull = (value) => isNull(value) ? "null" : renderEntryValue(value);
-const renderEntryValue = (value) => isPrimitive(value) ? `${value}` : renderEntryStructure(value);
-const renderEntryStructure = (value) => isArray(value) ? renderEntryList(value) : renderEntryRecord(value);
-const renderEntryList = (value) => `[${value.map(renderEntry).join(";")}]`;
-const renderEntryRecord = (value) => `{${Object.entries(value).map(([key, entry]) => `${key}: ${renderEntry(entry)}`).join(";")}}`;
-const renderEntry = (value) => isText$2(value) ? quoted(value) : renderEntryNonNull(value);
-const replayTextOf = (replay) => replay.seed === void 0 ? void 0 : `seed=${replay.seed};path=${replay.path.map(renderEntry).join(",")}`;
+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 : replayTextOf(replay));
+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;
@@ -334,7 +479,7 @@ const baselineReplay = (replay) => and(replay.seed === void 0, replay.path.lengt
 const replayOnBaseline = (replay) => replay === void 0 ? false : baselineReplay(replay);
 const headMessageOf = (layers) => {
 	const entry = layers[0];
-	return isObject$1(entry) ? messageFieldOf(entry) : void 0;
+	return isObject(entry) ? messageFieldOf(entry) : void 0;
 };
 const detailOf = (layers) => {
 	const message = headMessageOf(layers);
@@ -380,7 +525,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$1.test(record)), "R2"),
+	...breachIf(not(LOCATION.test(record)), "R2"),
 	...breachIf(r6Broken(parts, input), "R6")
 ];
 const hasRoot = (root) => root !== void 0 && root.length > 0;
@@ -405,24 +550,7 @@ const renderFailureRecord = (input) => {
 		breaches: breachesOf(parts, input, record)
 	};
 };
-//#endregion
-//#region src/internal/failure-error.ts
-/**
-* 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`: the tag 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.
-*
-* @since 4.0.0
-*/
-const LOCATION = /(?:[\w.@-]+\/)*[\w.@-]+\.[cm]?[jt]sx?:\d+/u;
-/** The mark a rendered record's Error carries, so a throw site that receives one passes it through unchanged. */
 const RECORD = Symbol.for("@systemfsoftware/vitest/FailureRecord");
-/** The fields Vitest reads to render its diff; each is copied only when the layer actually holds one. */
 const DIFF_FIELDS = [
 	"actual",
 	"expected",
@@ -430,52 +558,44 @@ const DIFF_FIELDS = [
 	"operator",
 	"diff"
 ];
-const CAUSE_DEPTH = 8;
-const isObject = (value) => typeof value === "object" && value !== null;
-const objectOrUndefined = (value) => isObject(value) ? value : void 0;
-const fieldOf = (value, key) => Reflect.get(value, key);
+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 siteOf = (text) => LOCATION.exec(text)?.[0];
+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 stackOf = (record, message) => {
+const recordStackOf = (record, message) => {
 	const head = `${record.name}: ${message}`;
-	const site = siteOf(record.record);
+	const site = recordSiteOf(record.record);
 	return site === void 0 ? head : `${head}\n    at ${site}`;
 };
 const withStack = (error, record, message) => {
-	error.stack = stackOf(record, message);
+	error.stack = recordStackOf(record, message);
 	return error;
 };
 const withName = (error, name) => {
 	error.name = name;
 	return error;
 };
-const reasonPayloadOf = (reason) => fieldOf(reason, "error") ?? fieldOf(reason, "defect");
+const reasonFieldOf = (reason) => fieldOf(reason, "error") ?? fieldOf(reason, "defect");
 const firstReasonOf = (cause) => {
 	const reason = cause.reasons[0];
-	if (reason === void 0) return cause;
-	return reasonPayloadOf(reason);
+	return reason === void 0 ? cause : reasonFieldOf(reason);
 };
 const payloadOf = (failure) => Cause.isCause(failure) ? firstReasonOf(failure) : failure;
-const causeOf = (value) => isObject(value) ? objectOrUndefined(fieldOf(value, "cause")) : void 0;
+const errorCauseChainOf = (value, depth) => depth <= 0 ? [] : [value, ...chainedCausesOf(value, depth)];
 const chainedCausesOf = (value, depth) => {
-	const cause = causeOf(value);
-	return cause === void 0 ? [] : causeChainOf(cause, depth - 1);
-};
-const causeChainOf = (value, depth) => {
-	if (depth <= 0) return [];
-	return [value, ...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, CAUSE_DEPTH)];
+	return [first, ...chainedCausesOf(first, ERROR_CAUSE_DEPTH)];
 };
 const diffCarrierOf = (failure) => layerChainOf(failure).map(objectOrUndefined).filter(isObject).find(isDiffLayer);
 const copyField = (error, carrier, field) => {
@@ -496,7 +616,18 @@ const copyDiffFields = (error, failure) => {
 	const carrier = diffCarrierOf(failure);
 	return carrier === void 0 ? error : copyFields(error, carrier);
 };
-/** @internal */
+/**
+* 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));
@@ -504,9 +635,9 @@ const failureRecordError = (record) => {
 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.
+* `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({
@@ -517,81 +648,26 @@ const refusalError = (failure, record) => {
 	return refusal;
 };
 const printedError = (failure, record) => record.breaches.length > 0 ? refusalError(failure, record) : failureRecordError(record);
-/** Whether a value is the Error one rendered record threw, which a second throw site passes through unchanged.
-*
-* @internal
-*/
+/** @internal */
 const isFailureRecordError = (value) => isObject(value) && fieldOf(value, RECORD) === true;
-/**
-* Renders the record and throws what Vitest prints for it: the record itself when it holds its contract, a
-* `FailureRecordRefused` when it breaks one, and a refusal passed in unchanged, so refusing cannot recurse (R10).
-*
-* @internal
-*/
+/** @internal */
 const throwFailureRecord = (input) => {
 	if (isRefusalFailure(input.failure)) throw input.failure;
 	const record = renderFailureRecord(input);
 	throw copyDiffFields(printedError(input.failure, record), input.failure);
 };
-//#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).
-*
-* @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 = (value) => isText$1(value) ? nonEmpty(value) : void 0;
-const read = (key) => {
-	try {
-		return nonEmptyText(inject(key));
-	} catch {
-		return;
-	}
-};
-/** @internal */
-const providedPackage = () => read(packageKey);
-/** @internal */
-const providedRoot = () => read(workspaceRootKey);
-//#endregion
-//#region src/internal/failure-identity.ts
-/**
-* The identity one record names: the package, the test file and the scenario the rerun command writes (KTD1, R6).
-*
-* The task comes from Vitest, `TestRunner.getCurrentTest()`, which Vitest maintains for the test being run, so it
-* is readable wherever a failure is rendered — including from the promise a kernel run returns, where no Effect
-* service is in reach. The package name comes from the shared config's provided context, so it is this package's
-* real npm name and never a guess from a directory; a run that provided none renders a rerun line without a
-* `pnpm --filter` prefix.
-*
-* @since 4.0.0
-*/
 const LEVEL_SEPARATOR = " > ";
-const EMPTY = "";
-const isText = (value) => typeof value === "string" && value.length > 0;
-const textOrEmpty = (value) => isText(value) ? value : EMPTY;
-const firstText = (values) => textOrEmpty(values.find(isText));
-const fileOf = (fullName) => textOrEmpty(fullName).split(LEVEL_SEPARATOR).at(0) ?? EMPTY;
+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,
+	package: providedPackage() ?? EMPTY_TEXT,
 	file: fileOf(task.fullName),
-	name: firstText([task.fullTestName, task.name])
+	name: firstNonEmptyText([task.fullTestName, task.name])
 });
 const currentTask = () => TestRunner.getCurrentTest() ?? {};
-/**
-* The identity of the test being run, or of the task handed in. A run outside a test, or one whose task carries
-* no file, yields an incomplete identity, which the renderer reports as the R6 breach it is.
-*
-* @internal
-*/
+/** @internal */
 const testIdentityOf = (task) => identityOf(task ?? currentTask());
 //#endregion
 //#region src/internal/property/coverage.ts
@@ -902,15 +978,15 @@ const ReplayToken = Schema$1.fromJsonString(Schema$1.Tuple([
 /** 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.map(Option.fromNullishOr(numericSeedOf(token)), (seed) => ({
+const replayOf = (token) => Option$1.map(Option$1.fromNullishOr(numericSeedOf(token)), (seed) => ({
 	seed,
 	path: token[4]
 }));
 /** @internal */
-const replayOfToken = (replay) => Option.getOrUndefined(Option.flatMap(Schema$1.decodeOption(ReplayToken)(replay), replayOf));
+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.getOrUndefined(Option.flatMap(Option.fromNullishOr(refutationOf(value)), (failure) => Option.fromNullishOr(failure.replay)));
+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
 /**
@@ -985,7 +1061,7 @@ const observeRun = (classes, counter, entries, values) => {
 	counter.runs = counter.runs + 1;
 	for (const label of satisfiedLabels(entries, values)) countHit(classes, label);
 };
-const drawFor = (entries, arbitrary) => ({ more: (count) => Effect.runSync(Arbitrary.sampleEffect(arbitrary, { count }).pipe(Effect.orDie)).map((values) => satisfiedLabels(entries, values)) });
+const 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
@@ -1004,24 +1080,24 @@ const liveCoverage = (cover, arbitrary) => {
 	};
 };
 const makeCoverage = (cover, arbitrary) => cover === void 0 ? noCoverage() : liveCoverage(cover, arbitrary);
-const describeVerdict = (verdict) => Effect.isEffect(verdict) ? "an Effect, which this lane never runs" : `a ${typeof verdict}`;
+const 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.succeed(nonBoolean(verdict, violations)) : Effect.map(verdict, (value) => literalVerdict(value, 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.isEffect(verdict) ? effectVerdict(run.lane, verdict, violations) : Effect.succeed(literalVerdict(verdict, violations));
+	return Effect$1.isEffect(verdict) ? effectVerdict(run.lane, verdict, violations) : Effect$1.succeed(literalVerdict(verdict, violations));
 };
-const tolerateInterruption = (cause) => Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.fail(cause);
-const guardedVerdict = (run, violations) => (values) => Effect.catchCause(Effect.suspend(() => verdictFor(run, values, violations)), tolerateInterruption);
+const 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.map((result) => ({
+	return Arbitrary.checkEffect(run.arbitrary, guardedVerdict(run, violations), run.options).pipe(Effect$1.map((result) => ({
 		violations,
 		result
 	})));
@@ -1029,7 +1105,7 @@ const runCheck = (run) => {
 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.die(withRaisingFrame(error, site));
+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}`;
@@ -1055,16 +1131,16 @@ const impostorRun = (run, budget) => {
 		holds: impostorHolds(run.holds, impostor),
 		observe: noObserve
 	};
-	return runCheck(retry).pipe(Effect.map((checked) => recordImpostor(retry, budget, impostor, checked)));
+	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.void;
+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.getOrUndefined(Option.flatMap(Option.fromNullishOr(falsifiedOf(checked.result)), (falsified) => Option.fromNullishOr(replayOfToken(falsified.replay))));
+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);
@@ -1080,7 +1156,7 @@ const checkOf = (registration, arbitrary, budget, observe) => ({
 	options: budget.options,
 	site: registration.site
 });
-const program = (registration) => Effect.gen(function* () {
+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);
@@ -1178,11 +1254,11 @@ const renderRecord = (failure, spans, identity) => renderFailureRecord({
 	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.provideService(Asserted, ledger.asserted), Effect.provideService(VitestTestContext, ctx));
+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.runPromiseExit(provideRun(program(checksFor(ledger)), ledger, ctx).pipe(Effect.withTracer(recorder.tracer))).then((exit) => outcomeOf(exit, recorder, testIdentityOf()));
+	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
@@ -1201,7 +1277,7 @@ const capturingRuntime = (programs) => ({
 	},
 	provide: (effect) => effect
 });
-const capturedProgram = (programs) => Option.getOrThrow(Option.fromNullishOr(programs[0]));
+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.
@@ -1214,4 +1290,4 @@ const recordOfProperty = (input) => {
 	return recordOfRun(capturedProgram(programs));
 };
 //#endregion
-export { replayOfFailure as a, isFailureRecordError as c, summaryOf as d, InvalidBudget as f, Slop as h, makeProperty as i, throwFailureRecord as l, NonBooleanVerdict as m, recordOfRun as n, testIdentityOf as o, LeakedState as p, createSpanRecorder as r, providedRoot as s, recordOfProperty as t, renderFailureRecord as u };
+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 };