@systemfsoftware/xstate-test 0.0.0-bootstrap.0 → 2.0.0-beta.2

package/dist/propertyTest-5bO0RsUu.mjs

@@ -0,0 +1,4660 @@
+import { t as ensuringFinalizerWins } from "./finalizerError-DOptAIDs.mjs";
+import { eventsFromSchemas, isTypeOnlySchema } from "./schema.mjs";
+import { dual } from "effect/Function";
+import { SimulatedClock, createActor, createAsyncLogic, getInitialMicrosteps, getMicrosteps, initialTransition, transition } from "@systemfsoftware/xstate";
+import { getDescendantStateNodes, getPathsFromEvents, getShortestPaths, getSimplePaths, serializeSnapshot } from "@systemfsoftware/xstate/graph";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as Cause from "effect/Cause";
+import { squash } from "effect/Cause";
+import * as Data from "effect/Data";
+import * as DateTime from "effect/DateTime";
+import * as Exit from "effect/Exit";
+import * as Logger from "effect/Logger";
+import * as fc from "fast-check";
+// src/engine/coverage.ts
+function dimension() {
+	return {
+		counts: {},
+		declarations: /* @__PURE__ */ new Map()
+	};
+}
+function declare(target, id, declaration = {}) {
+	const previous = target.declarations.get(id);
+	target.declarations.set(id, {
+		unreachable: (previous?.unreachable ?? false) || (declaration.unreachable ?? false),
+		unknown: (previous?.unknown ?? false) || (declaration.unknown ?? false)
+	});
+}
+function declareAggregate(target, id, declaration) {
+	const previous = target.declarations.get(id);
+	target.declarations.set(id, {
+		unreachable: previous !== void 0 ? previous.unreachable && declaration.unreachable : declaration.unreachable,
+		unknown: previous !== void 0 ? previous.unknown && declaration.unknown : declaration.unknown
+	});
+}
+const incrementCoverage = dual(2, function incrementCoverage(target, id) {
+	target.counts[id] = (target.counts[id] ?? 0) + 1;
+});
+function getPropertyConfigurationId(snapshot) {
+	const nodes = snapshot.nodes ?? snapshot._nodes;
+	return JSON.stringify((nodes?.map((node) => node.id) ?? []).sort());
+}
+function stableSerialize(value) {
+	if (Array.isArray(value)) return `[${value.map(stableSerialize).join(",")}]`;
+	if (value !== void 0 && value !== null && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(value[key])}`).join(",")}}`;
+	return JSON.stringify(value) ?? String(value);
+}
+function getPropertyStateId(snapshot) {
+	return stableSerialize(snapshot.value ?? null);
+}
+function getPropertyTransitionId(coverage, transition) {
+	return coverage.transitionIds.get(transition) ?? JSON.stringify([
+		"transition",
+		transition.source.id,
+		transition.eventType || "@eventless",
+		"dynamic"
+	]);
+}
+/**
+* Resolves the default target(s) of a history state node. History nodes are
+* never part of an active configuration themselves; entering one enters these
+* nodes instead, so anything reachable only through a history default target
+* would otherwise be misreported as unreachable.
+*/
+function getHistoryDefaultTargets(node) {
+	const parent = node.parent;
+	if (parent === void 0) return [];
+	const configTarget = node.config.target;
+	const normalized = configTarget === void 0 || configTarget === "" ? void 0 : Array.isArray(configTarget) ? configTarget : [configTarget];
+	if (normalized === void 0) return parent.type === "parallel" ? [parent] : parent.initial?.target ?? [];
+	const targets = [];
+	for (const target of normalized) {
+		if (typeof target !== "string") {
+			targets.push(target);
+			continue;
+		}
+		try {
+			targets.push(resolveStateNodePath(parent, target));
+		} catch {}
+	}
+	return targets;
+}
+/** Resolves a `'#id'` or (escaped) dot-separated path relative to `node`. */
+function resolveStateNodePath(node, path) {
+	if (path.startsWith("#")) try {
+		return node.machine.getStateNodeById(path);
+	} catch {}
+	const segments = [];
+	let segment = "";
+	for (let index = 0; index < path.length; index++) {
+		const char = path[index];
+		if (char === "\\") segment += path[++index] ?? "";
+		else if (char === ".") {
+			segments.push(segment);
+			segment = "";
+		} else segment += char;
+	}
+	segments.push(segment);
+	let current = node;
+	for (const key of segments) {
+		if (key.length === 0) break;
+		const child = current.states[key];
+		if (child === void 0) throw new Error(`Child state '${key}' does not exist on '${current.id}'`);
+		current = child;
+	}
+	return current;
+}
+function collectReachableNodes(root) {
+	const reachable = /* @__PURE__ */ new Set([root.id]);
+	const queue = [root];
+	while (queue.length !== 0) {
+		const node = queue.shift();
+		const candidates = [
+			...node.initial?.target ?? [],
+			...node.type === "parallel" ? Object.values(node.states) : [],
+			...node.type === "history" ? getHistoryDefaultTargets(node) : [],
+			...[...node.transitions.values()].flatMap((definitions) => definitions.flatMap((definition) => definition.target ?? [])),
+			...(node.always ?? []).flatMap((definition) => definition.target ?? [])
+		];
+		for (const target of candidates) if (!reachable.has(target.id)) {
+			reachable.add(target.id);
+			queue.push(target);
+		}
+	}
+	return reachable;
+}
+function registerTransition(coverage, transition, index, reachable, reachabilityUnknown) {
+	const id = JSON.stringify([
+		"transition",
+		transition.source.id,
+		transition.eventType || "@eventless",
+		index
+	]);
+	const sourceUnreachable = !reachable.has(transition.source.id);
+	coverage.transitionIds.set(transition, id);
+	declare(coverage.transitions, id, {
+		unreachable: sourceUnreachable && !reachabilityUnknown,
+		unknown: sourceUnreachable && reachabilityUnknown
+	});
+	declareAggregate(coverage.eventTypes, transition.eventType || "@eventless", {
+		unreachable: sourceUnreachable && !reachabilityUnknown,
+		unknown: sourceUnreachable && reachabilityUnknown
+	});
+	return id;
+}
+/**
+* Upper bound on statically enumerated transition pairs. Pair universes grow
+* quadratically, so large machines report a truncated universe rather than
+* spending unbounded time and memory on it.
+*/
+const TRANSITION_PAIR_UNIVERSE_LIMIT = 2e3;
+/**
+* Machines with more transitions than this skip pair enumeration entirely,
+* since even the static pair universe can grow as O(T^2).
+*/
+const TRANSITION_PAIR_MACHINE_LIMIT = 500;
+function getPropertyTransitionPairId(first, second) {
+	return `${first} -> ${second}`;
+}
+function getDescendantIds(node) {
+	const ids = /* @__PURE__ */ new Set([node.id]);
+	for (const descendant of getDescendantStateNodes(node)) ids.add(descendant.id);
+	return ids;
+}
+/**
+* Declares the pairs of transitions that can run back to back. A pair
+* `(t1, t2)` is possible when `t2`'s source node is within the configuration
+* `t1` can leave behind, approximated as the descendants-or-self of `t1`'s
+* targets (or of its own source when `t1` is targetless).
+*
+* Only pairs of static transitions are declared. A dynamic transition's target
+* is unknown until it runs, so pairs involving one are not part of the
+* universe; when observed at runtime they are still reported as covered.
+*/
+function declareTransitionPairs(coverage, registered) {
+	if (registered.length > TRANSITION_PAIR_MACHINE_LIMIT) {
+		coverage.transitionPairsTruncated = true;
+		return;
+	}
+	const staticTransitions = registered.filter((entry) => entry.transition.to === void 0);
+	const bySource = /* @__PURE__ */ new Map();
+	for (const entry of staticTransitions) {
+		const sourceId = entry.transition.source.id;
+		let entries = bySource.get(sourceId);
+		if (entries === void 0) {
+			entries = [];
+			bySource.set(sourceId, entries);
+		}
+		entries.push(entry);
+	}
+	const descendants = /* @__PURE__ */ new Map();
+	let declared = 0;
+	for (const first of staticTransitions) {
+		const roots = first.transition.target !== void 0 && first.transition.target.length !== 0 ? first.transition.target : [first.transition.source];
+		const firstDeclaration = coverage.transitions.declarations.get(first.id);
+		const reachableSources = /* @__PURE__ */ new Set();
+		for (const root of roots) {
+			let ids = descendants.get(root.id);
+			if (ids === void 0) {
+				ids = getDescendantIds(root);
+				descendants.set(root.id, ids);
+			}
+			for (const id of ids) reachableSources.add(id);
+		}
+		for (const sourceId of reachableSources) for (const second of bySource.get(sourceId) ?? []) {
+			if (declared >= TRANSITION_PAIR_UNIVERSE_LIMIT) {
+				coverage.transitionPairsTruncated = true;
+				return;
+			}
+			declared++;
+			const secondDeclaration = coverage.transitions.declarations.get(second.id);
+			declare(coverage.transitionPairs, getPropertyTransitionPairId(first.id, second.id), {
+				unreachable: firstDeclaration?.unreachable === true || secondDeclaration?.unreachable === true,
+				unknown: firstDeclaration?.unknown === true || secondDeclaration?.unknown === true
+			});
+		}
+	}
+}
+function normalizeRequirements(meta) {
+	const requirements = meta?.requirements;
+	if (typeof requirements === "string") return [requirements];
+	if (Array.isArray(requirements)) return requirements.filter((requirement) => typeof requirement === "string");
+	return [];
+}
+function declareRequirements(coverage, requirements, source, owner, ownerId) {
+	if (requirements.length === 0) return;
+	owner.set(ownerId, [...owner.get(ownerId) ?? [], ...requirements]);
+	for (const requirement of requirements) {
+		declare(coverage.requirements, requirement);
+		const sources = coverage.requirementSources[requirement] ??= [];
+		if (!sources.includes(source)) sources.push(source);
+	}
+}
+function recordRequirements(coverage, requirements) {
+	for (const requirement of requirements ?? []) incrementCoverage(coverage.requirements, requirement);
+}
+function createTestCoverage(logic) {
+	const coverage = {
+		runs: 0,
+		steps: 0,
+		skipped: 0,
+		prefixSteps: 0,
+		generatedSteps: 0,
+		invariantChecks: 0,
+		temporalChecks: 0,
+		clockAdvances: 0,
+		checkpoints: 0,
+		stops: 0,
+		sutComparisons: 0,
+		oracleComparisons: 0,
+		states: dimension(),
+		stateNodes: dimension(),
+		configurations: dimension(),
+		statuses: dimension(),
+		eventTypes: dimension(),
+		eventCases: {},
+		transitions: dimension(),
+		transitionPairs: dimension(),
+		transitionPairsTruncated: false,
+		requirements: dimension(),
+		requirementSources: {},
+		requirementsByStateNode: /* @__PURE__ */ new Map(),
+		requirementsByTransition: /* @__PURE__ */ new Map(),
+		previousTransitionIds: null,
+		frontiers: dimension(),
+		labels: {},
+		temporal: {
+			counts: {},
+			campaignFailed: /* @__PURE__ */ new Set(),
+			warnings: []
+		},
+		shrinkRuns: 0,
+		transitionIds: /* @__PURE__ */ new WeakMap(),
+		maximumObservedSequenceLength: 0,
+		pendingActorSteps: 0
+	};
+	const machine = logic;
+	if (machine.root === void 0) {
+		for (const target of [
+			coverage.states,
+			coverage.stateNodes,
+			coverage.configurations,
+			coverage.eventTypes,
+			coverage.transitions,
+			coverage.transitionPairs
+		]) declare(target, "(not statically enumerable)", { unknown: true });
+		return coverage;
+	}
+	const nodes = [machine.root, ...getDescendantStateNodes(machine.root)];
+	const reachable = collectReachableNodes(machine.root);
+	const hasReachableDynamicTransition = nodes.some((node) => reachable.has(node.id) && ([...node.transitions.values()].some((definitions) => definitions.some((definition) => definition.to !== void 0)) || (node.always ?? []).some((definition) => definition.to !== void 0)));
+	const registered = [];
+	for (const node of nodes) {
+		declareRequirements(coverage, normalizeRequirements(node.meta), `stateNode:${node.id}`, coverage.requirementsByStateNode, node.id);
+		declare(coverage.stateNodes, node.id, {
+			unreachable: !reachable.has(node.id) && !hasReachableDynamicTransition,
+			unknown: !reachable.has(node.id) && hasReachableDynamicTransition
+		});
+		for (const definitions of node.transitions.values()) for (let index = 0; index < definitions.length; index++) {
+			const definition = definitions[index];
+			if (definition === void 0) continue;
+			registered.push({
+				id: registerTransition(coverage, definition, index, reachable, !reachable.has(node.id) && hasReachableDynamicTransition),
+				transition: definition
+			});
+		}
+		const always = node.always ?? [];
+		for (let index = 0; index < always.length; index++) {
+			const definition = always[index];
+			if (definition === void 0) continue;
+			registered.push({
+				id: registerTransition(coverage, definition, index, reachable, !reachable.has(node.id) && hasReachableDynamicTransition),
+				transition: definition
+			});
+		}
+	}
+	for (const entry of registered) declareRequirements(coverage, normalizeRequirements(entry.transition.meta), `transition:${entry.id}`, coverage.requirementsByTransition, entry.id);
+	declareTransitionPairs(coverage, registered);
+	declare(coverage.states, "(runtime serialized states)", { unknown: true });
+	declare(coverage.configurations, "(runtime configurations)", { unknown: true });
+	return coverage;
+}
+const recordPropertySnapshot = dual(2, function(coverage, snapshot) {
+	incrementCoverage(coverage.states, getPropertyStateId(snapshot));
+	incrementCoverage(coverage.configurations, getPropertyConfigurationId(snapshot));
+	incrementCoverage(coverage.statuses, snapshot.status);
+	const nodes = snapshot.nodes ?? snapshot._nodes;
+	for (const node of nodes ?? []) {
+		incrementCoverage(coverage.stateNodes, node.id);
+		recordRequirements(coverage, coverage.requirementsByStateNode.get(node.id));
+	}
+});
+const recordPropertyTransitions = dual(3, function(coverage, event, transitions) {
+	incrementCoverage(coverage.eventTypes, event.type);
+	const ids = [];
+	for (const selected of transitions) {
+		const id = getPropertyTransitionId(coverage, selected);
+		ids.push(id);
+		incrementCoverage(coverage.transitions, id);
+		recordRequirements(coverage, coverage.requirementsByTransition.get(id));
+	}
+	if (ids.length !== 0) {
+		for (const previous of coverage.previousTransitionIds ?? []) for (const current of ids) incrementCoverage(coverage.transitionPairs, getPropertyTransitionPairId(previous, current));
+		coverage.previousTransitionIds = ids;
+	}
+	return ids;
+});
+/**
+* Clears the consecutive-transition chain so pairs are only counted within a
+* single run.
+*/
+function resetPropertyTransitionPairs(coverage) {
+	coverage.previousTransitionIds = null;
+}
+const getPropertyEventCaseId = dual(2, function(eventType, caseName) {
+	return JSON.stringify([
+		"event-case",
+		eventType,
+		caseName
+	]);
+});
+/**
+* Parses an id produced by {@link getPropertyEventCaseId} back into its event
+* type and case name. Returns `undefined` for ids of any other shape.
+*/
+function parsePropertyEventCaseId(id) {
+	let parsed;
+	try {
+		parsed = JSON.parse(id);
+	} catch {
+		return;
+	}
+	if (!Array.isArray(parsed) || parsed.length !== 3 || parsed[0] !== "event-case" || typeof parsed[1] !== "string" || typeof parsed[2] !== "string") return;
+	return {
+		type: parsed[1],
+		name: parsed[2]
+	};
+}
+const declarePropertyEventCase = dual(3, function(coverage, id, weight) {
+	const existing = coverage.eventCases[id];
+	if (existing === void 0) {
+		coverage.eventCases[id] = {
+			weight: weight ?? 1,
+			generated: 0,
+			applicable: 0,
+			executed: 0,
+			ignored: 0
+		};
+		return;
+	}
+	if (weight !== void 0 && existing.weight !== weight) coverage.eventCases[id] = {
+		...existing,
+		weight
+	};
+});
+const recordPropertyEventCase = dual(3, function(coverage, id, stage) {
+	declarePropertyEventCase(coverage, id, void 0);
+	const counts = coverage.eventCases[id];
+	counts[stage]++;
+});
+function finalizeDimension(dimension) {
+	const covered = Object.keys(dimension.counts).sort();
+	const uncovered = [];
+	const unreachable = [];
+	const unknown = [];
+	for (const [id, declaration] of dimension.declarations) {
+		if (dimension.counts[id] !== void 0) continue;
+		if (declaration.unknown) unknown.push(id);
+		else if (declaration.unreachable) unreachable.push(id);
+		else uncovered.push(id);
+	}
+	return {
+		counts: { ...dimension.counts },
+		covered,
+		uncovered: uncovered.sort(),
+		unreachable: unreachable.sort(),
+		unknown: unknown.sort()
+	};
+}
+const finalizeTestCoverage = dual((args) => args.length >= 2 || typeof args[0] === "object" && args[0] !== null && "eventCases" in args[0], function(coverage, exploration = {
+	strategy: "property",
+	mode: "pure",
+	configuredRuns: null,
+	completedRuns: coverage.runs,
+	attemptedRuns: coverage.runs,
+	shrinkRuns: coverage.shrinkRuns,
+	maximumSequenceLength: null,
+	maximumObservedSequenceLength: coverage.maximumObservedSequenceLength,
+	frontiers: [],
+	seeds: [],
+	swarm: null,
+	target: {
+		best: -Infinity,
+		improvements: 0
+	},
+	truncated: false,
+	truncationReasons: [],
+	stoppedBecause: "budget",
+	pendingActorSteps: coverage.pendingActorSteps
+}) {
+	const labelRuns = (exploration.attemptedRuns || coverage.runs) - coverage.shrinkRuns;
+	const temporalCounts = coverage.temporal.counts;
+	const temporalIds = Object.keys(temporalCounts).sort();
+	const temporalCountsOf = (id) => {
+		const counts = temporalCounts[id];
+		if (counts === void 0) throw new TypeError(`Missing temporal counts for '${id}'`);
+		return counts;
+	};
+	return {
+		runs: coverage.runs,
+		steps: coverage.steps,
+		skipped: coverage.skipped,
+		prefixSteps: coverage.prefixSteps,
+		generatedSteps: coverage.generatedSteps,
+		invariantChecks: coverage.invariantChecks,
+		temporalChecks: coverage.temporalChecks,
+		clockAdvances: coverage.clockAdvances,
+		checkpoints: coverage.checkpoints,
+		stops: coverage.stops,
+		sutComparisons: coverage.sutComparisons,
+		oracleComparisons: coverage.oracleComparisons,
+		states: finalizeDimension(coverage.states),
+		stateNodes: finalizeDimension(coverage.stateNodes),
+		configurations: finalizeDimension(coverage.configurations),
+		statuses: finalizeDimension(coverage.statuses),
+		eventTypes: finalizeDimension(coverage.eventTypes),
+		eventCases: Object.fromEntries(Object.entries(coverage.eventCases).sort(([left], [right]) => left.localeCompare(right)).map(([id, counts]) => [id, { ...counts }])),
+		transitions: finalizeDimension(coverage.transitions),
+		transitionPairs: {
+			...finalizeDimension(coverage.transitionPairs),
+			truncated: coverage.transitionPairsTruncated
+		},
+		requirements: {
+			...finalizeDimension(coverage.requirements),
+			sources: Object.fromEntries(Object.entries(coverage.requirementSources).sort(([left], [right]) => left.localeCompare(right)).map(([id, sources]) => [id, [...sources].sort()]))
+		},
+		frontiers: finalizeDimension(coverage.frontiers),
+		labels: Object.fromEntries(Object.entries(coverage.labels).sort(([left], [right]) => left.localeCompare(right)).map(([name, entry]) => [name, {
+			count: entry.count,
+			values: Object.fromEntries(Object.entries(entry.values).sort(([left], [right]) => left.localeCompare(right))),
+			share: labelRuns !== 0 ? Math.min(1, entry.runs / labelRuns) : 0
+		}])),
+		temporal: {
+			satisfied: temporalIds.filter((id) => temporalCountsOf(id).satisfied > 0),
+			failed: [.../* @__PURE__ */ new Set([...temporalIds.filter((id) => temporalCountsOf(id).failed > 0), ...coverage.temporal.campaignFailed])].sort(),
+			inconclusive: temporalIds.filter((id) => temporalCountsOf(id).inconclusive > 0 && temporalCountsOf(id).satisfied === 0 && !coverage.temporal.campaignFailed.has(id)),
+			counts: Object.fromEntries(temporalIds.map((id) => [id, { ...temporalCountsOf(id) }])),
+			warnings: coverage.temporal.warnings.slice()
+		},
+		exploration
+	};
+});
+/**
+* Records one occurrence of a label. `seen` is the set of label names already
+* recorded in the current run, so each run contributes at most once to a
+* label's `share`.
+*/
+const recordPropertyLabel = dual(4, function(coverage, name, value, seen) {
+	const entry = coverage.labels[name] ??= {
+		count: 0,
+		values: {},
+		runs: 0
+	};
+	entry.count++;
+	if (value !== void 0) {
+		const key = String(value);
+		entry.values[key] = (entry.values[key] ?? 0) + 1;
+	}
+	if (!seen.has(name)) {
+		seen.add(name);
+		entry.runs++;
+	}
+});
+/** Records one run's outcome for a temporal property. */
+const recordPropertyTemporal = dual(3, function(coverage, id, outcome) {
+	const counts = coverage.temporal.counts[id] ??= {
+		satisfied: 0,
+		failed: 0,
+		inconclusive: 0
+	};
+	counts[outcome]++;
+});
+const declarePropertyFrontier = dual(2, function(coverage, id) {
+	declare(coverage.frontiers, id);
+});
+function isStateMachine(logic) {
+	const machine = logic;
+	return machine.root !== void 0 && typeof machine.getStateNodeById === "function" && typeof machine.getTransitionData === "function";
+}
+function withMicrostepDetails(result, getSteps) {
+	let microsteps;
+	try {
+		microsteps = getSteps();
+	} catch {
+		microsteps = [];
+	}
+	return [
+		result[0],
+		result[1],
+		microsteps.flatMap(([, , transitions]) => transitions)
+	];
+}
+/**
+* The pure `transition()`, also returning the transitions taken (from
+* `getMicrosteps()`) for coverage attribution.
+*/
+const transitionWithDetails = dual(3, function(logic, snapshot, event) {
+	const result = transition(logic, snapshot, event);
+	if (!isStateMachine(logic) || result[0] === snapshot) return [
+		result[0],
+		result[1],
+		[]
+	];
+	return withMicrostepDetails(result, () => getMicrosteps(logic, snapshot, event));
+});
+/** The pure `initialTransition()`, with the details of {@link transitionWithDetails}. */
+const initialTransitionWithDetails = dual(2, function(logic, input) {
+	const result = initialTransition(logic, input);
+	if (!isStateMachine(logic)) return [
+		result[0],
+		result[1],
+		[]
+	];
+	return withMicrostepDetails(result, () => getInitialMicrosteps(logic, input));
+});
+// src/engine/utils.ts
+function simpleStringify(value) {
+	return JSON.stringify(value);
+}
+/** FNV-1a over a string, as an unsigned 32-bit integer. */
+function fnv1a(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index++) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+/** A deterministic 32-bit PRNG (mulberry32), seeded by `seed`. */
+function createSeededRng(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Events synthesized from the transitions of the active state nodes. */
+function getAllOwnEvents(snapshot) {
+	const events = snapshot.nodes.flatMap((stateNode) => [...stateNode.transitions.values()].flatMap((transitions) => transitions.map((transition) => {
+		const event = {
+			type: transition.eventType,
+			...transition.matches
+		};
+		if ("actorId" in event && (event.type === "xstate.done.actor" || event.type === "xstate.error.actor" || event.type === "xstate.snapshot.actor" || event.type === "xstate.timeout.actor")) event["sessionId"] = snapshot.children[event["actorId"]]?.sessionId;
+		return event;
+	})));
+	return events.filter((event, index) => events.findIndex((candidate) => {
+		const keys = Object.keys(event);
+		return keys.length === Object.keys(candidate).length && keys.every((key) => Object.is(event[key], candidate[key]));
+	}) === index);
+}
+// src/engine/eventDescriptors.ts
+/**
+* Distinguishes the descriptor form (`{ generate, case?, weight?, ... }`) from
+* a bare generator. Generators are opaque adapter values that can themselves
+* be objects with a `generate` *method* (fast-check arbitraries have one), so
+* a `generate` key only marks a descriptor when it does not hold a function;
+* any of the descriptor-only keys marks one regardless.
+* @experimental
+*/
+function isEventDescriptorObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if ("case" in value || "when" in value || "resolve" in value || "weight" in value) return true;
+	return Object.prototype.hasOwnProperty.call(value, "generate") && typeof value.generate !== "function";
+}
+/** @experimental */
+const assertTestWeight = dual(2, function assertTestWeight(weight, location) {
+	if (weight === void 0) return 1;
+	if (typeof weight !== "number" || !Number.isFinite(weight) || weight <= 0) throw new Error(`Property ${location} has an invalid \`weight\` (${String(weight)}). Weights must be positive, finite numbers.`);
+	return weight;
+});
+/**
+* Normalizes the shared `events` option — a map of event type to a bare
+* generator, a descriptor object, or an array of either — into the flat list of
+* declared cases both `propertyTest()` and `testPaths()` work from.
+* @experimental
+*/
+function normalizeEventDescriptors(events) {
+	const descriptors = /* @__PURE__ */ new Map();
+	const cases = [];
+	for (const [type, configured] of Object.entries(events ?? {})) {
+		const configuredCases = Array.isArray(configured) ? configured : [configured];
+		for (const eventCase of configuredCases) {
+			const descriptor = isEventDescriptorObject(eventCase) ? eventCase : { generate: eventCase };
+			const caseName = descriptor.case ?? "default";
+			if (caseName.length === 0) throw new Error(`Property event case for "${type}" must not be empty`);
+			const caseId = getPropertyEventCaseId(type, caseName);
+			if (descriptors.has(caseId)) throw new Error(`Property event case "${caseName}" is duplicated for "${type}"`);
+			descriptors.set(caseId, descriptor);
+			cases.push({
+				type,
+				caseName,
+				caseId,
+				generator: descriptor.generate,
+				weight: assertTestWeight(descriptor.weight, `event case "${caseName}" for "${type}"`),
+				descriptor
+			});
+		}
+	}
+	return {
+		cases,
+		descriptors
+	};
+}
+/**
+* The per-case seed used when sampling payloads. Deriving it from the case id
+* keeps each case's samples stable when other cases are added or removed.
+* @experimental
+*/
+const deriveCaseSeed = dual(2, function deriveCaseSeed(seed, caseId) {
+	return (seed ^ fnv1a(caseId)) >>> 0;
+});
+/**
+* Draws `count` values from a {@link TestGenerator}.
+*
+* @experimental
+*/
+const sampleGenerator = dual(3, function sampleGenerator(generator, rng, count) {
+	const draw = typeof generator === "function" ? generator : typeof generator?.sample === "function" ? (rng2) => generator.sample(rng2) : void 0;
+	if (draw === void 0) throw new Error("Path generation requires each `generate` value to be a function `(rng) => value` or an object with a `sample(rng)` method. In `@xstate/test`, fast-check arbitraries are adapted automatically.");
+	const values = [];
+	for (let index = 0; index < count; index++) values.push(draw(rng));
+	return values;
+});
+/**
+* Builds a {@link TestPickDescriptor} around any index generator. `pick()` in
+* `xstate/graph` and in `@xstate/test` differ only in the generator.
+* @experimental
+*/
+const createPickDescriptor = dual(3, function createPickDescriptor(generate, select, toPayload) {
+	return {
+		generate,
+		resolve: ({ snapshot, generated }) => {
+			const items = select(snapshot);
+			if (items.length === 0) return;
+			const item = items[Math.abs(Math.trunc(generated)) % items.length];
+			if (item === void 0) return;
+			return toPayload !== void 0 ? toPayload(item, snapshot) : item;
+		}
+	};
+});
+// src/engine/constants.ts
+const XSTATE_INIT = "@xstate.init";
+const XSTATE_STOP = "@xstate.stop";
+// src/engine/outcomes.ts
+/**
+* Queues and hands out actor outcomes for stubbed invoke sources.
+*
+* A stub actor asks the registry for its outcome when it starts. If an
+* outcome is already queued for its source it resolves immediately; otherwise
+* the stub stays pending until an `outcome` command (or a seeded replay
+* record) supplies one, which is what lets fast-check shrink service results.
+*/
+var PropertyOutcomeRegistry = class {
+	queued = /* @__PURE__ */ new Map();
+	waiting = /* @__PURE__ */ new Map();
+	/** Called by a stub actor when it starts. */
+	request(src) {
+		const next = this.queued.get(src)?.shift();
+		if (next !== void 0) return Promise.resolve(next);
+		return Effect.runPromise(Effect.callback((resume) => {
+			const resolve = (outcome) => {
+				resume(Effect.succeed(outcome));
+			};
+			const waiters = this.waiting.get(src);
+			if (waiters !== void 0) waiters.push(resolve);
+			else this.waiting.set(src, [resolve]);
+		}));
+	}
+	/** Resolves the oldest pending stub for `src`, or queues for the next one. */
+	provide(src, outcome) {
+		const waiter = this.waiting.get(src)?.shift();
+		if (waiter !== void 0) {
+			waiter(outcome);
+			return;
+		}
+		const queue = this.queued.get(src);
+		if (queue !== void 0) queue.push(outcome);
+		else this.queued.set(src, [outcome]);
+	}
+	/** Pre-loads recorded outcomes so a replay never calls a real service. */
+	seed(records) {
+		for (const record of records) this.provide(record.src, record.outcome);
+	}
+	reset() {
+		this.queued = /* @__PURE__ */ new Map();
+		this.waiting = /* @__PURE__ */ new Map();
+	}
+};
+/**
+* Builds the stub {@link ActorLogic} that replaces an invoke source named
+* `src`, resolving its outcome from `registry` — the registry of the campaign
+* that built the stub. One stub is built per campaign, so concurrent campaigns
+* never resolve each other's outcomes.
+*
+* `registry` is `undefined` for stubs built only so a machine missing an
+* implementation can be provided for pure-mode traversal, which steps logic
+* without running it; a run that starts such a stub is a bug.
+*/
+const createOutcomeStub = dual(2, function createOutcomeStub(src, registry) {
+	return createAsyncLogic({ run: () => Effect.runPromise(Effect.gen(function* () {
+		if (registry === void 0) throw new Error(`Property outcome stub for "${src}" ran outside an executed-mode property run`);
+		const outcome = yield* Effect.promise(() => registry.request(src));
+		if (outcome.ok) return outcome.output;
+		throw outcome.error;
+	})) });
+});
+/** Applies `actors` to a machine, rejecting logic that cannot be provided. */
+const provideActors = dual(2, function provideActors(logic, actors) {
+	const provide = logic.provide;
+	if (typeof provide !== "function") throw new Error("Property `actors` and `outcomes` require a state machine; the provided actor logic has no `provide()`");
+	return provide.call(logic, { actors });
+});
+// src/engine/report.ts
+/**
+* Writes each log message to the console unchanged. The reports this package
+* prints are its output contract, so logging through `Effect.log` with this
+* logger keeps the exact lines callers (and the test suite) rely on.
+*/
+const consoleLineLogger = Logger.withConsoleLog(Logger.make(({ message }) => String(message)));
+/**
+* Tells the data-first form of a coverage formatter from its data-last form: a
+* one-argument call is data-first only when it passes a coverage, the only
+* argument shape that carries `eventCases`.
+*/
+const isCoverageDataFirst = (args) => args.length >= 2 || typeof args[0] === "object" && args[0] !== null && "eventCases" in args[0];
+const DIMENSION_KEYS = [
+	"states",
+	"stateNodes",
+	"configurations",
+	"statuses",
+	"eventTypes",
+	"transitions",
+	"transitionPairs",
+	"requirements",
+	"frontiers"
+];
+/**
+* Coverage declares a `(runtime …)` placeholder in the dimensions whose
+* universe is only known at runtime (serialized states, configurations). It
+* marks the universe as open-ended; it is not an item, so reports leave it out
+* of the counts and lists.
+*/
+function isRuntimePlaceholder(id) {
+	return id.startsWith("(runtime ");
+}
+function getDimension(coverage, key) {
+	const dimension = coverage[key];
+	if (!dimension.unknown.some(isRuntimePlaceholder)) return dimension;
+	return {
+		...dimension,
+		unknown: dimension.unknown.filter((id) => !isRuntimePlaceholder(id))
+	};
+}
+function totalOf(dimension) {
+	return dimension.covered.length + dimension.uncovered.length + dimension.unreachable.length + dimension.unknown.length;
+}
+function percentage(covered, total) {
+	if (total === 0) return "100.0%";
+	return `${(covered / total * 100).toFixed(1)}%`;
+}
+/**
+* Renders a coverage id in a human-readable form. Ids are stable JSON strings;
+* ids that are not recognized are rendered as-is.
+* @experimental
+*/
+function formatTestCoverageId(id) {
+	let parsed;
+	try {
+		parsed = JSON.parse(id);
+	} catch {
+		return id;
+	}
+	if (!Array.isArray(parsed)) return id;
+	const [kind, ...rest] = parsed;
+	if (kind === "transition" && rest.length === 3) {
+		const [source, eventType, index] = rest;
+		return `${source} --${eventType}--> #${String(index)}`;
+	}
+	if (kind === "event-case" && rest.length === 2) {
+		const [eventType, caseName] = rest;
+		return `${eventType} / ${caseName}`;
+	}
+	return id;
+}
+function dimensionLine(name, dimension) {
+	const total = totalOf(dimension);
+	const covered = dimension.covered.length;
+	return `${name}: ${covered}/${total} covered (${percentage(covered, total)}), ${dimension.uncovered.length} uncovered, ${dimension.unreachable.length} unreachable, ${dimension.unknown.length} unknown`;
+}
+function explorationLines(exploration) {
+	const lines = [
+		`runs: configured ${exploration.configuredRuns ?? "n/a"}, completed ${exploration.completedRuns}, attempted ${exploration.attemptedRuns}` + (exploration.shrinkRuns !== 0 ? `, shrinking ${exploration.shrinkRuns}` : ""),
+		`sequence length: max ${exploration.maximumSequenceLength ?? "n/a"}, max observed ${exploration.maximumObservedSequenceLength}`,
+		`stopped because: ${exploration.stoppedBecause}`,
+		...exploration.swarm !== null ? [`swarm: ${exploration.swarm.runs} runs, ${exploration.swarm.averageEnabled.toFixed(2)} cases enabled on average`] : [],
+		...exploration.target.improvements !== 0 ? [`target: best ${exploration.target.best}${exploration.target.label !== void 0 && exploration.target.label.length > 0 ? ` (${exploration.target.label})` : ""}, ${exploration.target.improvements} improvements`] : [],
+		...exploration.truncated ? [`truncated: true${exploration.truncationReasons.length !== 0 ? ` (${[...exploration.truncationReasons].sort().join(", ")})` : ""}`] : [],
+		...exploration.pendingActorSteps !== 0 ? [`pending actors: ${exploration.pendingActorSteps} step(s) settled with actor work in flight`] : []
+	];
+	for (const frontier of exploration.frontiers) lines.push(`frontier ${frontier.id}: prefix ${frontier.prefixLength}, budget ${frontier.runBudget ?? "n/a"}, configured ${frontier.configuredRuns ?? "n/a"}, completed ${frontier.completedRuns}, attempted ${frontier.attemptedRuns}`);
+	for (const seed of exploration.seeds) lines.push(`seed ${seed.frontierId}: engine ${seed.engine ?? "n/a"}, seed ${seed.seed ?? "n/a"}, path ${seed.path ?? "n/a"}`);
+	return lines;
+}
+/** One line per temporal property with its run counts, then the warnings. */
+function temporalLines(coverage, indent) {
+	return [...Object.entries(coverage.temporal.counts).sort(([left], [right]) => left.localeCompare(right)).map(([id, counts]) => `${indent}- ${id}: ${counts.satisfied} satisfied, ${counts.failed} failed, ${counts.inconclusive} inconclusive${coverage.temporal.failed.includes(id) && counts.failed === 0 ? " (never held)" : ""}`), ...coverage.temporal.warnings.map((warning) => `${indent}warning: ${warning}`)];
+}
+function listLines(title, ids) {
+	if (ids.length === 0) return [];
+	return [`${title}:`, ...[...ids].sort().map((id) => `  - ${formatTestCoverageId(id)}`)];
+}
+function markdownTable(headers, rows) {
+	return [
+		`| ${headers.join(" | ")} |`,
+		`| ${headers.map(() => "---").join(" | ")} |`,
+		...rows.map((row) => `| ${row.join(" | ")} |`)
+	];
+}
+function formatText(coverage) {
+	const lines = ["Test coverage", ""];
+	for (const key of DIMENSION_KEYS) lines.push(dimensionLine(key, getDimension(coverage, key)));
+	lines.push("");
+	for (const key of DIMENSION_KEYS) {
+		const dimension = getDimension(coverage, key);
+		lines.push(...listLines(`uncovered ${key}`, dimension.uncovered), ...listLines(`unreachable ${key}`, dimension.unreachable), ...listLines(`unknown ${key}`, dimension.unknown));
+	}
+	const eventCases = Object.entries(coverage.eventCases).sort(([left], [right]) => left.localeCompare(right));
+	if (eventCases.length !== 0) {
+		lines.push("event cases:");
+		for (const [id, counts] of eventCases) lines.push(`  - ${formatTestCoverageId(id)}: ${counts.generated} generated, ${counts.applicable} applicable, ${counts.executed} executed, ${counts.ignored} ignored`);
+	}
+	const labels = Object.entries(coverage.labels).sort(([left], [right]) => left.localeCompare(right));
+	if (labels.length !== 0) {
+		lines.push("labels:");
+		for (const [name, label] of labels) {
+			const values = Object.entries(label.values).sort(([left], [right]) => left.localeCompare(right)).map(([value, count]) => `${value}=${count}`).join(", ");
+			lines.push(`  - ${name}: ${label.count} recorded, ${percentage(Math.round(label.share * 1e3), 1e3)} of runs${values.length > 0 ? ` (${values})` : ""}`);
+		}
+	}
+	lines.push(`temporal: ${coverage.temporal.satisfied.length} satisfied, ${coverage.temporal.failed.length} failed, ${coverage.temporal.inconclusive.length} inconclusive`, ...temporalLines(coverage, "  "), "", "exploration:", ...explorationLines(coverage.exploration).map((line) => `  ${line}`));
+	return lines.join("\n");
+}
+function formatMarkdown(coverage) {
+	const lines = ["# Test coverage", ""];
+	lines.push(...markdownTable([
+		"Dimension",
+		"Covered",
+		"Total",
+		"Ratio",
+		"Uncovered",
+		"Unreachable",
+		"Unknown"
+	], DIMENSION_KEYS.map((key) => {
+		const dimension = getDimension(coverage, key);
+		const total = totalOf(dimension);
+		return [
+			key,
+			String(dimension.covered.length),
+			String(total),
+			percentage(dimension.covered.length, total),
+			String(dimension.uncovered.length),
+			String(dimension.unreachable.length),
+			String(dimension.unknown.length)
+		];
+	})), "");
+	const outstanding = [];
+	for (const key of DIMENSION_KEYS) {
+		const dimension = getDimension(coverage, key);
+		for (const status of [
+			"uncovered",
+			"unreachable",
+			"unknown"
+		]) for (const id of [...dimension[status]].sort()) outstanding.push([
+			key,
+			status,
+			formatTestCoverageId(id)
+		]);
+	}
+	lines.push("## Outstanding", "");
+	if (outstanding.length !== 0) lines.push(...markdownTable([
+		"Dimension",
+		"Status",
+		"Id"
+	], outstanding), "");
+	else lines.push("Everything declared was covered.", "");
+	const eventCases = Object.entries(coverage.eventCases).sort(([left], [right]) => left.localeCompare(right));
+	if (eventCases.length !== 0) lines.push("## Event cases", "", ...markdownTable([
+		"Case",
+		"Generated",
+		"Applicable",
+		"Executed",
+		"Ignored"
+	], eventCases.map(([id, counts]) => [
+		formatTestCoverageId(id),
+		String(counts.generated),
+		String(counts.applicable),
+		String(counts.executed),
+		String(counts.ignored)
+	])), "");
+	const labels = Object.entries(coverage.labels).sort(([left], [right]) => left.localeCompare(right));
+	if (labels.length !== 0) lines.push("## Labels", "", ...markdownTable([
+		"Label",
+		"Count",
+		"Share",
+		"Values"
+	], labels.map(([name, label]) => [
+		name,
+		String(label.count),
+		percentage(Math.round(label.share * 1e3), 1e3),
+		Object.entries(label.values).sort(([left], [right]) => left.localeCompare(right)).map(([value, count]) => `${value}=${count}`).join("; ") || "-"
+	])), "");
+	lines.push("## Temporal", "", ...markdownTable([
+		"Status",
+		"Count",
+		"Ids"
+	], [
+		"satisfied",
+		"failed",
+		"inconclusive"
+	].map((status) => [
+		status,
+		String(coverage.temporal[status].length),
+		[...coverage.temporal[status]].sort().join("; ") || "-"
+	])), "", ...Object.keys(coverage.temporal.counts).length !== 0 ? [...markdownTable([
+		"Property",
+		"Satisfied runs",
+		"Failed runs",
+		"Inconclusive runs"
+	], Object.entries(coverage.temporal.counts).sort(([left], [right]) => left.localeCompare(right)).map(([id, counts]) => [
+		id,
+		String(counts.satisfied),
+		String(counts.failed),
+		String(counts.inconclusive)
+	])), ""] : [], ...coverage.temporal.warnings.map((warning) => `> Warning: ${warning}`), ...coverage.temporal.warnings.length !== 0 ? [""] : [], "## Exploration", "", ...explorationLines(coverage.exploration).map((line) => `- ${line}`));
+	return lines.join("\n");
+}
+/**
+* Formats a {@link TestCoverage} as human-readable text or markdown.
+*
+* @experimental
+*/
+const formatTestCoverage = dual(isCoverageDataFirst, function formatTestCoverage(coverage, options = {}) {
+	return options.format === "markdown" ? formatMarkdown(coverage) : formatText(coverage);
+});
+function dimensionToJSON(dimension) {
+	const total = totalOf(dimension);
+	const covered = dimension.covered.length;
+	return {
+		total,
+		covered,
+		ratio: total !== 0 ? covered / total : 1,
+		counts: { ...dimension.counts },
+		coveredIds: [...dimension.covered],
+		uncovered: [...dimension.uncovered],
+		unreachable: [...dimension.unreachable],
+		unknown: [...dimension.unknown]
+	};
+}
+/**
+* Converts a {@link TestCoverage} to stable, versioned, JSON-safe data.
+*
+* @experimental
+*/
+function testCoverageToJSON(coverage) {
+	const dimensions = {};
+	for (const key of DIMENSION_KEYS) dimensions[key] = dimensionToJSON(getDimension(coverage, key));
+	return {
+		formatVersion: 1,
+		totals: {
+			runs: coverage.runs,
+			steps: coverage.steps,
+			skipped: coverage.skipped,
+			prefixSteps: coverage.prefixSteps,
+			generatedSteps: coverage.generatedSteps,
+			invariantChecks: coverage.invariantChecks,
+			temporalChecks: coverage.temporalChecks,
+			clockAdvances: coverage.clockAdvances,
+			checkpoints: coverage.checkpoints,
+			stops: coverage.stops,
+			sutComparisons: coverage.sutComparisons,
+			oracleComparisons: coverage.oracleComparisons
+		},
+		dimensions,
+		eventCases: Object.fromEntries(Object.entries(coverage.eventCases).sort(([left], [right]) => left.localeCompare(right)).map(([id, counts]) => [id, {
+			weight: counts.weight,
+			generated: counts.generated,
+			applicable: counts.applicable,
+			executed: counts.executed,
+			ignored: counts.ignored
+		}])),
+		temporal: {
+			satisfied: [...coverage.temporal.satisfied],
+			failed: [...coverage.temporal.failed],
+			inconclusive: [...coverage.temporal.inconclusive],
+			counts: Object.fromEntries(Object.entries(coverage.temporal.counts).sort(([left], [right]) => left.localeCompare(right)).map(([id, counts]) => [id, { ...counts }])),
+			warnings: [...coverage.temporal.warnings]
+		},
+		labels: Object.fromEntries(Object.entries(coverage.labels).sort(([left], [right]) => left.localeCompare(right)).map(([name, label]) => [name, {
+			count: label.count,
+			values: { ...label.values },
+			share: label.share
+		}])),
+		exploration: {
+			stoppedBecause: coverage.exploration.stoppedBecause,
+			configuredRuns: coverage.exploration.configuredRuns,
+			completedRuns: coverage.exploration.completedRuns,
+			attemptedRuns: coverage.exploration.attemptedRuns,
+			shrinkRuns: coverage.exploration.shrinkRuns,
+			maximumSequenceLength: coverage.exploration.maximumSequenceLength,
+			maximumObservedSequenceLength: coverage.exploration.maximumObservedSequenceLength,
+			truncated: coverage.exploration.truncated,
+			truncationReasons: [...coverage.exploration.truncationReasons],
+			frontiers: coverage.exploration.frontiers.map((frontier) => ({
+				id: frontier.id,
+				prefixLength: frontier.prefixLength,
+				runBudget: frontier.runBudget,
+				configuredRuns: frontier.configuredRuns,
+				completedRuns: frontier.completedRuns,
+				attemptedRuns: frontier.attemptedRuns
+			})),
+			seeds: coverage.exploration.seeds.map((seed) => ({
+				frontierId: seed.frontierId,
+				engine: seed.engine ?? null,
+				seed: seed.seed ?? null,
+				path: seed.path ?? null
+			})),
+			...coverage.exploration.swarm !== null ? { swarm: {
+				runs: coverage.exploration.swarm.runs,
+				averageEnabled: coverage.exploration.swarm.averageEnabled
+			} } : {},
+			...coverage.exploration.target.improvements !== 0 ? { target: {
+				best: coverage.exploration.target.best,
+				label: coverage.exploration.target.label ?? null,
+				improvements: coverage.exploration.target.improvements
+			} } : {}
+		}
+	};
+}
+function escapeXML(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Formats a {@link TestCoverage} as JUnit XML, with one `<testcase>` per
+* transition and per state node.
+* @experimental
+*/
+const formatTestCoverageJUnit = dual(isCoverageDataFirst, function formatTestCoverageJUnit(coverage, options = {}) {
+	const suiteName = options.suiteName ?? "test-coverage";
+	const cases = [];
+	let tests = 0;
+	let failures = 0;
+	let skipped = 0;
+	for (const key of ["transitions", "stateNodes"]) {
+		const dimension = getDimension(coverage, key);
+		const entries = [
+			...dimension.covered.map((id) => [id, "covered"]),
+			...dimension.uncovered.map((id) => [id, "uncovered"]),
+			...dimension.unreachable.map((id) => [id, "unreachable"]),
+			...dimension.unknown.map((id) => [id, "unknown"])
+		];
+		entries.sort(([left], [right]) => left.localeCompare(right));
+		for (const [id, status] of entries) {
+			tests++;
+			const name = escapeXML(formatTestCoverageId(id));
+			if (status === "covered") cases.push(`    <testcase classname="${key}" name="${name}" />`);
+			else if (status === "uncovered") {
+				failures++;
+				cases.push(`    <testcase classname="${key}" name="${name}">\n      <failure message="uncovered" type="uncovered" />\n    </testcase>`);
+			} else {
+				skipped++;
+				cases.push(`    <testcase classname="${key}" name="${name}">\n      <skipped message="${status}" />\n    </testcase>`);
+			}
+		}
+	}
+	const properties = explorationLines(coverage.exploration).map((line, index) => `      <property name="exploration.${index}" value="${escapeXML(line)}" />`);
+	return [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+		"<testsuites>",
+		`  <testsuite name="${escapeXML(suiteName)}" tests="${tests}" failures="${failures}" skipped="${skipped}">`,
+		"    <properties>",
+		...properties,
+		"    </properties>",
+		...cases,
+		"  </testsuite>",
+		"</testsuites>",
+		""
+	].join("\n");
+});
+function escapeHTML(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/**
+* Formats a {@link TestCoverage} as a self-contained HTML document.
+*
+* @experimental
+*/
+const formatTestCoverageHTML = dual(isCoverageDataFirst, function formatTestCoverageHTML(coverage, options = {}) {
+	const title = options.title ?? "Test coverage";
+	const cards = DIMENSION_KEYS.map((key) => {
+		const dimension = getDimension(coverage, key);
+		const total = totalOf(dimension);
+		return `<div class="card"><h2>${escapeHTML(key)}</h2><p class="ratio">${dimension.covered.length}/${total} (${percentage(dimension.covered.length, total)})</p><p class="detail">${dimension.uncovered.length} uncovered, ${dimension.unreachable.length} unreachable, ${dimension.unknown.length} unknown</p></div>`;
+	}).join("");
+	const rows = [];
+	for (const key of DIMENSION_KEYS) {
+		const dimension = getDimension(coverage, key);
+		for (const status of [
+			"uncovered",
+			"unreachable",
+			"unknown"
+		]) for (const id of [...dimension[status]].sort()) rows.push(`<tr><td>${escapeHTML(key)}</td><td>${escapeHTML(status)}</td><td>${escapeHTML(formatTestCoverageId(id))}</td></tr>`);
+	}
+	const explorationItems = explorationLines(coverage.exploration).map((line) => `<li>${escapeHTML(line)}</li>`).join("");
+	return [
+		"<!doctype html>",
+		"<html lang=\"en\">",
+		"<head>",
+		"<meta charset=\"utf-8\" />",
+		`<title>${escapeHTML(title)}</title>`,
+		"<style>",
+		"body{font-family:system-ui,sans-serif;margin:2rem;color:#111;background:#fff}",
+		".cards{display:flex;flex-wrap:wrap;gap:1rem}",
+		".card{border:1px solid #ddd;border-radius:8px;padding:1rem;min-width:12rem}",
+		".card h2{font-size:.9rem;margin:0 0 .5rem;text-transform:uppercase}",
+		".ratio{font-size:1.4rem;margin:0}",
+		".detail{color:#555;font-size:.8rem;margin:.25rem 0 0}",
+		"table{border-collapse:collapse;margin-top:1rem;width:100%}",
+		"th,td{border:1px solid #ddd;padding:.4rem .6rem;text-align:left;font-size:.85rem}",
+		"</style>",
+		"</head>",
+		"<body>",
+		`<h1>${escapeHTML(title)}</h1>`,
+		`<p>${coverage.runs} runs, ${coverage.steps} steps, ${coverage.invariantChecks} invariant checks</p>`,
+		`<div class="cards">${cards}</div>`,
+		"<h2>Outstanding</h2>",
+		rows.length !== 0 ? `<table><thead><tr><th>Dimension</th><th>Status</th><th>Id</th></tr></thead><tbody>${rows.join("")}</tbody></table>` : "<p>Everything declared was covered.</p>",
+		"<h2>Temporal</h2>",
+		`<p>${coverage.temporal.satisfied.length} satisfied, ${coverage.temporal.failed.length} failed, ${coverage.temporal.inconclusive.length} inconclusive</p>`,
+		...coverage.temporal.warnings.map((warning) => `<p><strong>Warning:</strong> ${escapeHTML(warning)}</p>`),
+		"<h2>Exploration</h2>",
+		`<ul>${explorationItems}</ul>`,
+		"</body>",
+		"</html>",
+		""
+	].join("\n");
+});
+/**
+* Throws an `Error` containing the formatted coverage text when any dimension's
+* covered ratio — `covered / (covered + uncovered)` — is below its threshold.
+* Thresholds are ratios between `0` and `1`.
+* @experimental
+*/
+const assertTestCoverage = dual(2, function assertTestCoverage(coverage, thresholds) {
+	const failures = [];
+	for (const key of DIMENSION_KEYS) {
+		const threshold = thresholds[key];
+		if (threshold === void 0) continue;
+		const dimension = getDimension(coverage, key);
+		const considered = dimension.covered.length + dimension.uncovered.length;
+		if ((considered !== 0 ? dimension.covered.length / considered : 1) < threshold) failures.push(`${key}: ${percentage(dimension.covered.length, considered)} covered, below the ${percentage(threshold, 1)} threshold`);
+	}
+	if (failures.length !== 0) throw new Error(`Test coverage thresholds not met:\n${failures.map((failure) => `  - ${failure}`).join("\n")}\n\n${formatTestCoverage(coverage)}`);
+});
+function formatShare(share) {
+	return `${(share * 100).toFixed(1)}%`.padStart(6);
+}
+/**
+* Formats the distribution of generated data: how executed events split
+* across event cases, and the share of runs that recorded each label. Shrink
+* attempts are not counted. Pass `statistics: true` to `propertyTest()` or
+* `testPaths()` to print it after a passing campaign, or a function,
+* `(report) => void | Promise<void>`, to receive the same string instead.
+* @experimental
+*/
+function formatTestStatistics(coverage) {
+	const runs = coverage.exploration.attemptedRuns - coverage.exploration.shrinkRuns;
+	const lines = [`Test statistics (${runs} run${runs === 1 ? "" : "s"})`];
+	const eventCases = Object.entries(coverage.eventCases).sort(([left], [right]) => left.localeCompare(right));
+	const executed = eventCases.reduce((total, [, counts]) => total + counts.executed, 0);
+	if (eventCases.length !== 0) {
+		lines.push("", "event cases (share of executed events):");
+		for (const [id, counts] of eventCases) lines.push(`  ${formatShare(executed !== 0 ? counts.executed / executed : 0)}  ${formatTestCoverageId(id)}: ${counts.executed} executed, ${counts.ignored} ignored`);
+	}
+	const labels = Object.entries(coverage.labels).sort(([left], [right]) => left.localeCompare(right));
+	if (labels.length !== 0) {
+		lines.push("", "labels (share of runs):");
+		for (const [name, label] of labels) {
+			const values = Object.entries(label.values).sort(([left], [right]) => left.localeCompare(right)).map(([value, count]) => `${value}=${count}`).join(", ");
+			lines.push(`  ${formatShare(label.share)}  ${name}: ${label.count} recorded${values.length > 0 ? ` (${values})` : ""}`);
+		}
+	}
+	return lines.join("\n");
+}
+// src/engine/propertyTest.ts
+/**
+* Awaits a temporal predicate, which may hold synchronously or as a promise.
+* A rejection stays the same error object when the effect is run.
+*/
+const temporalPredicate = (predicate, context) => Effect.promise(() => Promise.resolve(predicate(context)));
+/**
+* Runs an oracle's comparison, which may hold synchronously or as a promise,
+* falling back to structural equivalence. A rejection stays the same error
+* object when the effect is run.
+*/
+const oracleMatches = (equivalent, model, observed) => {
+	const compare = equivalent;
+	return compare === void 0 ? Effect.succeed(defaultEquivalent(model, observed)) : Effect.promise(() => Promise.resolve(compare(model, observed)));
+};
+function getCauseMessage(cause) {
+	if (cause instanceof Error) return cause.message || cause.name;
+	if (typeof cause === "string") return cause;
+}
+/**
+* Builds the full failure message before `Error` captures the stack. The
+* formatted trace is part of the message so reporters that only print
+* `error.stack` still show the counterexample (GH #3435).
+*/
+function getPropertyFailureMessage(summary, trace, cause, replay, fixture, format, extras) {
+	const causeMessage = getCauseMessage(cause);
+	const lines = [causeMessage !== void 0 && causeMessage.length > 0 && !summary.includes(causeMessage) ? `${summary}: ${causeMessage}` : summary];
+	const reproduce = [
+		...replay?.seed === void 0 ? [] : [`seed ${replay.seed}`],
+		...replay?.path === void 0 ? [] : [`path "${replay.path}"`],
+		...replay?.replayPath === void 0 ? [] : [`replayPath "${replay.replayPath}"`]
+	];
+	if (reproduce.length !== 0) lines.push(`Reproduce: ${reproduce.join(", ")}`);
+	if (fixture !== void 0) lines.push("Fixture: failure.fixture (replayTest)");
+	if (replay !== void 0 && replay.numShrinks !== void 0 && replay.numShrinks !== 0) lines.push(`Shrunk ${replay.numShrinks} time(s)`);
+	lines.push(...extras?.notes ?? []);
+	try {
+		lines.push("", formatTestTrace(trace, format));
+	} catch {}
+	if (extras?.report !== void 0 && extras.report.length > 0) lines.push("", extras.report);
+	return lines.join("\n");
+}
+/**
+* Thrown by `propertyTest()`, `testPaths()`, and `replayTest()` when an
+* oracle fails. Carries the trace, a portable replay fixture, and the coverage
+* accumulated up to the failure.
+* @experimental
+*/
+const ModelTestFailureBase = Data.TaggedError("@systemfsoftware/xstate-test/engine/propertyTest/ModelTestFailure");
+var ModelTestFailure = class extends ModelTestFailureBase {
+	trace;
+	cause;
+	replay;
+	fixture;
+	coverage;
+	format;
+	extras;
+	/**
+	* `instanceof` narrows to the default type arguments rather than `any`, so
+	* `error.trace` stays typed in a `catch` block.
+	*/
+	static [Symbol.hasInstance](value) {
+		return Function.prototype[Symbol.hasInstance].call(this, value);
+	}
+	/** The short message, without the formatted trace. */
+	summary;
+	constructor(summary, trace, cause, replay, fixture, coverage, format, extras) {
+		super({ message: getPropertyFailureMessage(summary, trace, cause, replay, fixture, format, extras) });
+		this.trace = trace;
+		this.cause = cause;
+		this.replay = replay;
+		this.fixture = fixture;
+		this.coverage = coverage;
+		this.format = format;
+		this.extras = extras;
+		this.name = "ModelTestFailure";
+		this.summary = summary;
+	}
+};
+/**
+* Thrown when a campaign completes without a counterexample but a
+* campaign-level assertion does not hold: a `sometimes` property that held in
+* no run, or a `reachable` target that no run entered.
+* @experimental
+*/
+const TestCampaignErrorBase = Data.TaggedError("@systemfsoftware/xstate-test/engine/propertyTest/TestCampaignError");
+var TestCampaignError = class extends TestCampaignErrorBase {
+	failures;
+	coverage;
+	name = "TestCampaignError";
+	constructor(failures, coverage) {
+		super({ message: `Campaign assertions failed:\n${failures.map((failure) => `  - ${failure}`).join("\n")}` });
+		this.failures = failures;
+		this.coverage = coverage;
+	}
+};
+/**
+* Structural, key-order insensitive deep equality used to compare model
+* projections against reference/SUT observations. Cycle-safe.
+* @experimental
+*/
+const defaultEquivalent = dual(2, function defaultEquivalent(left, right) {
+	return deepEqual(left, right, /* @__PURE__ */ new Map());
+});
+function deepEqual(left, right, visited) {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return left === right;
+	const seen = visited.get(left);
+	if (seen?.has(right) === true) return true;
+	if (seen !== void 0) seen.add(right);
+	else visited.set(left, /* @__PURE__ */ new Set([right]));
+	if (left instanceof Date || right instanceof Date) return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right)) return false;
+		return left.length === right.length && left.every((value, index) => deepEqual(value, right[index], visited));
+	}
+	if (left instanceof Map || right instanceof Map) {
+		if (!(left instanceof Map) || !(right instanceof Map)) return false;
+		if (left.size !== right.size) return false;
+		for (const [key, value] of left) if (!right.has(key) || !deepEqual(value, right.get(key), visited)) return false;
+		return true;
+	}
+	if (left instanceof Set || right instanceof Set) {
+		if (!(left instanceof Set) || !(right instanceof Set)) return false;
+		if (left.size !== right.size) return false;
+		for (const value of left) if (!right.has(value)) return false;
+		return true;
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key], visited));
+}
+function assertEventPayload(payload, type, caseId) {
+	if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+		const location = caseId !== void 0 && caseId.length > 0 ? `Property event case ${caseId}` : `Property event "${type}"`;
+		throw new Error(`${location} generated a non-object payload (${typeof payload === "string" ? JSON.stringify(payload) : String(payload)}). Event payloads must be plain objects; use a \`resolve\` function to map generated values onto an event payload.`);
+	}
+}
+/** Microtask turns awaited per drain round. */
+const DRAIN_MICROTASKS = 8;
+/** Upper bound on drain rounds awaited before an executed step is settled. */
+const MAX_DRAIN_ROUNDS = 40;
+/** Consecutive rounds without new inspection events that settle a step. */
+const QUIET_DRAIN_ROUNDS = 2;
+/** `count` consecutive indices; a `const` loop counter for generator bodies. */
+const indexRange = (count) => Array.from({ length: count }, (_, index) => index);
+/** One drain turn: `setImmediate` and a zero timer alternate to flush both queues. */
+const drainMacrotaskTurn = (round) => round % 2 === 0 && typeof setImmediate === "function" ? Effect.callback((resume) => {
+	setImmediate(() => resume(Effect.void));
+}) : Effect.sleep(1);
+/** Drains `count` microtask turns in order, so queued continuations settle. */
+const microtaskTurns = (count) => count === 0 ? Effect.void : Effect.promise(() => Promise.resolve()).pipe(Effect.andThen(microtaskTurns(count - 1)));
+/**
+* Records the observation a step produced on its timeline entry. The
+* published entry types freeze `observation` as readonly, so the write goes
+* through one place instead of at every step.
+*/
+const setEntryObservation = (entry, observation) => {
+	Object.assign(entry, { observation });
+};
+/** The modelled transition when no actor is executed. */
+const pureTransitionStep = (logic, coverage, previousSnapshot, event) => {
+	const [snapshot, effects, selected] = transitionWithDetails(logic, previousSnapshot, event);
+	return {
+		snapshot,
+		effects,
+		transitionIds: recordPropertyTransitions(coverage, event, selected),
+		drained: []
+	};
+};
+/** Stops the executed actor and drains the transitions it leaves behind. */
+const stopExecutedStep = (engine, coverage) => Effect.gen(function* () {
+	engine.stop();
+	yield* Effect.promise(() => engine.drain());
+	const drained = engine.consume(coverage);
+	return {
+		snapshot: engine.getSnapshot(),
+		effects: [],
+		transitionIds: [],
+		drained
+	};
+});
+/** Sends one event through the executed actor and attributes its transitions. */
+const sendExecutedStep = (engine, coverage, event) => Effect.gen(function* () {
+	engine.send(event);
+	yield* Effect.promise(() => engine.drain());
+	const drained = engine.consume(coverage);
+	const snapshot = engine.getSnapshot();
+	const primaryIndex = drained.findIndex((entry) => entry.source === "root" && entry.event.type === event.type);
+	const primary = primaryIndex === -1 ? void 0 : drained[primaryIndex];
+	return {
+		snapshot,
+		effects: primary?.effects ?? [],
+		transitionIds: primary?.transitionIds ?? [],
+		drained: primaryIndex === -1 ? drained : drained.slice(primaryIndex + 1)
+	};
+});
+/**
+* Drives a real actor on a `SimulatedClock` and turns its inspection
+* stream into the same transition details the pure path returns.
+*/
+var PropertyExecutionEngine = class {
+	stubbedSources;
+	clock = new SimulatedClock();
+	actor;
+	buffer = [];
+	rootRef;
+	srcByActorId = /* @__PURE__ */ new Map();
+	resolvedBySrc = /* @__PURE__ */ new Map();
+	/** Outcomes observed this run, in resolution order. */
+	outcomes = [];
+	constructor(logic, input, startingSnapshot, stubbedSources = /* @__PURE__ */ new Set()) {
+		this.stubbedSources = stubbedSources;
+		const actor = createActor(logic, {
+			clock: this.clock,
+			input,
+			...startingSnapshot !== void 0 ? { snapshot: startingSnapshot } : {},
+			inspect: (event) => {
+				this.buffer.push(event);
+			}
+		});
+		this.rootRef = actor;
+		this.actor = actor;
+	}
+	start() {
+		this.actor.start();
+	}
+	send(event) {
+		this.actor.send(event);
+	}
+	advance(milliseconds) {
+		this.clock.increment(milliseconds);
+	}
+	stop() {
+		this.actor.stop();
+	}
+	getSnapshot() {
+		return this.actor.getSnapshot();
+	}
+	/**
+	* Runs microtasks and macrotasks until the inspection stream stops growing.
+	* Rounds alternate between `setImmediate` and a zero `setTimeout`, so work
+	* queued on either macrotask queue (a promise actor awaiting
+	* `setTimeout(0)`, say) settles within the step that started it. While a
+	* child actor has asynchronous work in flight, a step settles only after
+	* {@link QUIET_DRAIN_ROUNDS} consecutive rounds without new inspection
+	* events; otherwise one quiet round suffices. The actor's own timers are on
+	* the simulated clock, so nothing here can fire a delayed transition.
+	*/
+	drain() {
+		return Effect.runPromise(Effect.gen(function* () {
+			const quietRounds = yield* Ref.make(0);
+			for (const round of indexRange(MAX_DRAIN_ROUNDS)) {
+				const seen = this.buffer.length;
+				yield* microtaskTurns(DRAIN_MICROTASKS);
+				yield* drainMacrotaskTurn(round);
+				yield* Ref.update(quietRounds, (value) => this.buffer.length === seen ? value + 1 : 0);
+				const current = yield* Ref.get(quietRounds);
+				if (current >= QUIET_DRAIN_ROUNDS || current > 0 && this.getPendingActors().length === 0) return;
+			}
+		}.bind(this)));
+	}
+	/**
+	* Direct children of the tested actor whose asynchronous work (a promise
+	* body, for instance) is still in flight. Stubbed invoke sources are left
+	* out: they wait for an `outcome` command by design.
+	*/
+	getPendingActors() {
+		const children = this.actor.getSnapshot().children ?? {};
+		const pending = [];
+		for (const [id, child] of Object.entries(children)) {
+			const src = this.srcByActorId.get(child?.id ?? id);
+			if (src !== void 0 && this.stubbedSources.has(src)) continue;
+			const snapshot = child?.getSnapshot?.();
+			if (snapshot?.status !== "active" || snapshot.effects === void 0) continue;
+			if (Object.entries(snapshot.effects).some(([key, effect]) => key !== "callback" && effect?.status === "active")) pending.push(id);
+		}
+		return pending.sort();
+	}
+	/**
+	* The milliseconds until the pending `xstate.after` timer for `event` is
+	* due on the simulated clock, or `undefined` when no such timer is
+	* scheduled on the tested actor.
+	*/
+	getAfterTimerRemaining(event) {
+		const timers = this.actor.getSnapshot().timers ?? {};
+		const timerId = Object.keys(timers).find((id) => {
+			const timerEvent = timers[id]?.event;
+			return timerEvent?.type === "xstate.after" && timerEvent.delay === event.delay && timerEvent.stateId === event.stateId;
+		});
+		if (timerId === void 0) return;
+		const system = this.rootRef.system;
+		const scheduled = Object.values(system?.getSnapshot?.()._scheduledTimers ?? {}).find((timer) => timer.source === this.rootRef && timer.id === timerId);
+		if (scheduled === void 0) return;
+		return Math.max(0, scheduled.dueAt - this.clock.now());
+	}
+	/**
+	* Consumes the buffered inspection events, records root transitions into
+	* `coverage`, and returns one {@link DrainedTransition} per transition.
+	*/
+	consume(coverage) {
+		const buffered = this.buffer;
+		this.buffer = [];
+		const drained = [];
+		for (const inspected of buffered) {
+			if (inspected.type === "@xstate.actor") {
+				if (typeof inspected.src === "string") this.srcByActorId.set(inspected.id, inspected.src);
+				continue;
+			}
+			if (inspected.type !== "@xstate.transition") continue;
+			const isRoot = inspected.actorRef === this.rootRef;
+			const actorId = inspected.actorRef?.id ?? "(unknown)";
+			if (!isRoot) this.recordOutcome(actorId, inspected.snapshot);
+			drained.push({
+				source: isRoot ? "root" : "child",
+				actorId,
+				event: inspected.event,
+				snapshot: inspected.snapshot,
+				effects: inspected.actions,
+				transitionIds: isRoot ? recordPropertyTransitions(coverage, inspected.event, inspected.microsteps) : []
+			});
+		}
+		return drained;
+	}
+	recordOutcome(actorId, snapshot) {
+		if (snapshot.status !== "done" && snapshot.status !== "error") return;
+		const src = this.srcByActorId.get(actorId);
+		if (src === void 0) return;
+		const occurrence = this.resolvedBySrc.get(src) ?? 0;
+		this.resolvedBySrc.set(src, occurrence + 1);
+		this.outcomes.push({
+			src,
+			occurrence,
+			outcome: snapshot.status === "done" ? {
+				ok: true,
+				output: snapshot.output
+			} : {
+				ok: false,
+				error: snapshot.error
+			}
+		});
+	}
+};
+/** @experimental */
+var PropertyScenarioRunner = class {
+	logic;
+	input;
+	startingSnapshot;
+	serializeStartingSnapshot;
+	prefixEvents;
+	frontierId;
+	sut;
+	states;
+	reference;
+	invariant;
+	eventDescriptors;
+	coverage;
+	executionConfig;
+	snapshot;
+	initialSnapshot;
+	initialEffects = [];
+	initialTransitionIds = [];
+	timeline = [];
+	temporal;
+	stableStep = 0;
+	started = false;
+	finished = false;
+	sutSession;
+	referenceSession;
+	lastObservation;
+	inconclusiveTemporalIds = [];
+	generatedCommandCount = 0;
+	labelsSeen = /* @__PURE__ */ new Set();
+	execution;
+	swarmCaseIds;
+	swarmEnabled;
+	targetFunction;
+	targetObservations = [];
+	/** Set for runs the adapter starts while shrinking a counterexample. */
+	shrinkRun = false;
+	/** The failure this run ended in, if an oracle failed. */
+	failure;
+	/** Records a label for this run. */
+	label = (name, value) => {
+		if (this.shrinkRun) return;
+		recordPropertyLabel(this.coverage, name, value, this.labelsSeen);
+	};
+	/**
+	* Marks this run as a shrink attempt: its labels and event cases are left
+	* out of the campaign's statistics.
+	*/
+	markShrinkRun() {
+		this.shrinkRun = true;
+	}
+	recordEventCase(caseId, stage) {
+		if (!this.shrinkRun) recordPropertyEventCase(this.coverage, caseId, stage);
+	}
+	/** Records `name` when `condition` holds. */
+	classify = (condition, name) => {
+		if (condition) this.label(name);
+	};
+	/** Records an observation for targeted search. */
+	target = (observation, label) => {
+		if (typeof observation !== "number" || Number.isNaN(observation)) throw new Error("target() requires a numeric observation");
+		this.targetObservations.push({
+			value: observation,
+			label,
+			index: this.timeline.length
+		});
+	};
+	/**
+	* Restricts this run to a subset of the declared event cases. Every other
+	* case reports itself as inapplicable, so a run only exercises the enabled
+	* ones. See the `swarm` option.
+	*/
+	setSwarm(caseIds) {
+		this.swarmCaseIds = caseIds;
+		this.swarmEnabled = new Set(caseIds);
+	}
+	formatOptions;
+	/** Sets how failure messages render snapshots. See `formatSnapshot`. */
+	setFormatSnapshot(formatSnapshot) {
+		this.formatOptions = formatSnapshot !== void 0 ? { formatSnapshot } : void 0;
+	}
+	/** Evaluates `target` on every stable step. See the `target` option. */
+	setTargetFunction(targetFunction) {
+		this.targetFunction = targetFunction;
+	}
+	/** Outcomes observed while the executed run was alive. */
+	executionOutcomes;
+	/** Observations recorded with `target()` during this run. */
+	getTargetObservations() {
+		return this.targetObservations;
+	}
+	/** `true` when the run completed without a property failure. */
+	isFinished() {
+		return this.finished;
+	}
+	constructor(logic, input, startingSnapshot, serializeStartingSnapshot, prefixEvents, frontierId, sut, states, reference, invariant, temporal, eventDescriptors, coverage, executionConfig) {
+		this.logic = logic;
+		this.input = input;
+		this.startingSnapshot = startingSnapshot;
+		this.serializeStartingSnapshot = serializeStartingSnapshot;
+		this.prefixEvents = prefixEvents;
+		this.frontierId = frontierId;
+		this.sut = sut;
+		this.states = states;
+		this.reference = reference;
+		this.invariant = invariant;
+		this.eventDescriptors = eventDescriptors;
+		this.coverage = coverage;
+		this.executionConfig = executionConfig;
+		this.temporal = temporal.map((definition) => ({
+			definition,
+			satisfied: false
+		}));
+	}
+	start() {
+		return Effect.runPromise(Effect.gen(function* () {
+			resetPropertyTransitionPairs(this.coverage);
+			const [initial, effects, selected] = this.startingSnapshot !== void 0 ? [
+				this.startingSnapshot,
+				[],
+				[]
+			] : initialTransitionWithDetails(this.logic, this.input);
+			const snapshot = initial;
+			this.initialTransitionIds = recordPropertyTransitions(this.coverage, { type: XSTATE_INIT }, selected);
+			const initialSnapshot = yield* Ref.make(snapshot);
+			const initialEffects = yield* Ref.make(effects);
+			const executionConfig = this.executionConfig;
+			if (executionConfig !== void 0 && executionConfig.mode === "executed") {
+				executionConfig.registry.reset();
+				executionConfig.registry.seed(executionConfig.seededOutcomes ?? []);
+				const execution = new PropertyExecutionEngine(this.logic, this.input, this.startingSnapshot, new Set(executionConfig.stubbedSources ?? []));
+				this.execution = execution;
+				execution.start();
+				yield* Effect.promise(() => execution.drain());
+				execution.consume(this.coverage);
+				yield* Ref.set(initialSnapshot, execution.getSnapshot());
+				yield* Ref.set(initialEffects, []);
+			}
+			const finalSnapshot = yield* Ref.get(initialSnapshot);
+			const finalEffects = yield* Ref.get(initialEffects);
+			this.snapshot = finalSnapshot;
+			this.initialSnapshot = finalSnapshot;
+			this.initialEffects = finalEffects;
+			this.started = true;
+			this.recordSnapshot(finalSnapshot);
+			const context = {
+				logic: this.logic,
+				input: this.input,
+				snapshot: this.startingSnapshot,
+				label: this.label,
+				classify: this.classify,
+				target: this.target
+			};
+			const reference = this.reference;
+			if (reference !== void 0) this.referenceSession = yield* Effect.promise(() => Promise.resolve(reference.create(context)));
+			const sut = this.sut;
+			if (sut !== void 0) this.sutSession = yield* Effect.promise(() => Promise.resolve(sut.create(context)));
+			yield* this.checkStable(void 0, finalSnapshot, finalSnapshot, finalEffects);
+			for (const event of this.prefixEvents) yield* this.executeEvent(event, "prefix", "frontier", true);
+			if (this.frontierId !== void 0 && this.frontierId.length > 0) incrementCoverage(this.coverage.frontiers, this.frontierId);
+		}.bind(this)));
+	}
+	canRun(event, caseId) {
+		return this.canRunResolved(event, caseId);
+	}
+	canRunGenerated(type, generated, caseId) {
+		return this.canRunResolved(this.resolveGeneratedEvent(type, generated, caseId), caseId);
+	}
+	canRunResolved(event, caseId) {
+		this.recordEventCase(caseId, "generated");
+		const descriptor = this.eventDescriptors.get(caseId);
+		const canRun = (this.swarmEnabled?.has(caseId) ?? true) && event !== void 0 && this.snapshot.status === "active" && (descriptor?.when?.({
+			snapshot: this.snapshot,
+			event
+		}) ?? true);
+		if (!canRun) {
+			this.coverage.skipped++;
+			this.recordEventCase(caseId, "ignored");
+		} else this.recordEventCase(caseId, "applicable");
+		return canRun;
+	}
+	resolveGeneratedEvent(type, generated, caseId) {
+		const descriptor = this.eventDescriptors.get(caseId);
+		const payload = descriptor !== void 0 && "resolve" in descriptor && descriptor.resolve !== void 0 ? descriptor.resolve({
+			snapshot: this.snapshot,
+			generated
+		}) : generated;
+		if (payload === void 0) return;
+		assertEventPayload(payload, type, caseId);
+		return {
+			...payload,
+			type
+		};
+	}
+	/** `outcome` commands only apply while the executed actor is running. */
+	canRunOutcome() {
+		return this.canRunCommand(this.execution !== void 0 && this.snapshot.status === "active");
+	}
+	canRunCommand(applicable) {
+		if (!applicable) this.coverage.skipped++;
+		return applicable;
+	}
+	run(event, caseId) {
+		return Effect.runPromise(Effect.gen(function* () {
+			this.assertStarted();
+			this.recordGeneratedCommand();
+			this.recordEventCase(caseId, "executed");
+			yield* this.executeEvent(event, "generated", "generator", true, true, caseId);
+		}.bind(this)));
+	}
+	runGenerated(type, generated, caseId) {
+		return Effect.runPromise(Effect.gen(function* () {
+			const event = this.resolveGeneratedEvent(type, generated, caseId);
+			if (event === void 0) throw new Error(`Property event case ${caseId} became inapplicable before execution`);
+			yield* Effect.promise(() => this.run(event, caseId));
+		}.bind(this)));
+	}
+	replay(command) {
+		return Effect.runPromise(Effect.gen(function* () {
+			this.assertStarted();
+			if (command.type === "event") yield* this.executeEvent(command.event, command.phase, command.origin, command.origin !== "clock", true, command.caseId);
+			else if (command.type === "advance") {
+				if (this.execution !== void 0) {
+					yield* Effect.promise(() => this.advanceExecuted(command.milliseconds));
+					return;
+				}
+				this.coverage.clockAdvances++;
+				this.timeline.push({
+					kind: "command",
+					index: this.timeline.length,
+					command,
+					previousSnapshot: this.snapshot,
+					snapshot: this.snapshot,
+					effects: [],
+					transitionIds: []
+				});
+			} else if (command.type === "outcome") {
+				if (this.execution === void 0) throw new Error(`Property replay fixture contains an \`outcome\` command for "${command.src}" but the replay is running in pure mode: the fixture was recorded in executed mode; pass mode: 'executed'`);
+				yield* Effect.promise(() => this.outcome(command.src, command.outcome));
+			} else if (command.type === "checkpoint") yield* Effect.promise(() => this.checkpoint(command.label));
+			else yield* Effect.promise(() => this.stop());
+		}.bind(this)));
+	}
+	/** Queues the next resolution of the stubbed invoke source `src`. */
+	outcome(src, outcome) {
+		return Effect.runPromise(Effect.gen(function* () {
+			this.assertStarted();
+			this.recordGeneratedCommand();
+			const execution = this.execution;
+			const executionConfig = this.executionConfig;
+			if (execution === void 0 || executionConfig === void 0) throw new Error("Property `outcome` commands require `mode: 'executed'`");
+			const previousSnapshot = this.snapshot;
+			executionConfig.registry.provide(src, outcome);
+			yield* Effect.promise(() => execution.drain());
+			const drained = execution.consume(this.coverage);
+			this.snapshot = execution.getSnapshot();
+			this.recordSnapshot(this.snapshot);
+			const entry = {
+				kind: "command",
+				index: this.timeline.length,
+				command: {
+					type: "outcome",
+					src,
+					outcome
+				},
+				previousSnapshot,
+				snapshot: this.snapshot,
+				effects: [],
+				transitionIds: []
+			};
+			this.timeline.push(entry);
+			this.markPendingActors(entry);
+			this.pushActorEntries(previousSnapshot, drained);
+			const observation = yield* this.checkStable(void 0, previousSnapshot, this.snapshot, []);
+			setEntryObservation(entry, observation);
+		}.bind(this)));
+	}
+	advance(milliseconds) {
+		return Effect.runPromise(Effect.gen(function* () {
+			this.assertStarted();
+			this.recordGeneratedCommand();
+			if (this.execution !== void 0) {
+				yield* Effect.promise(() => this.advanceExecuted(milliseconds));
+				return;
+			}
+			const sutSession = this.sutSession;
+			if (sutSession?.advance === void 0) {
+				const advancedFrom = this.snapshot;
+				this.coverage.clockAdvances++;
+				const pureEntry = {
+					kind: "command",
+					index: this.timeline.length,
+					command: {
+						type: "advance",
+						milliseconds,
+						deliveredEvents: []
+					},
+					previousSnapshot: advancedFrom,
+					snapshot: this.snapshot,
+					effects: [],
+					transitionIds: []
+				};
+				this.timeline.push(pureEntry);
+				const pureObservation = yield* this.checkStable(void 0, advancedFrom, this.snapshot, []);
+				setEntryObservation(pureEntry, pureObservation);
+				return;
+			}
+			const previousSnapshot = this.snapshot;
+			const advance = sutSession.advance.bind(sutSession);
+			const events = yield* Effect.promise(() => Promise.resolve(advance(milliseconds)));
+			const command = {
+				type: "advance",
+				milliseconds,
+				deliveredEvents: events.slice()
+			};
+			this.coverage.clockAdvances++;
+			this.timeline.push({
+				kind: "command",
+				index: this.timeline.length,
+				command,
+				previousSnapshot,
+				snapshot: this.snapshot,
+				effects: [],
+				transitionIds: []
+			});
+			for (const [index, event] of events.entries()) yield* this.executeEvent(event, "generated", "clock", false, index === events.length - 1);
+			if (events.length === 0) {
+				const observation = yield* this.compareObservations();
+				this.lastObservation = observation;
+				this.replaceLastObservation(observation);
+			}
+		}.bind(this)));
+	}
+	/**
+	* Advances the simulated clock the executed actor runs on, then drains
+	* whatever the elapsed delays produced.
+	*/
+	advanceExecuted(milliseconds) {
+		return Effect.runPromise(Effect.gen(function* () {
+			const execution = this.execution;
+			if (execution === void 0) return;
+			const previousSnapshot = this.snapshot;
+			execution.advance(milliseconds);
+			yield* Effect.promise(() => execution.drain());
+			const drained = execution.consume(this.coverage);
+			this.snapshot = execution.getSnapshot();
+			this.recordSnapshot(this.snapshot);
+			this.coverage.clockAdvances++;
+			const entry = {
+				kind: "command",
+				index: this.timeline.length,
+				command: {
+					type: "advance",
+					milliseconds,
+					deliveredEvents: []
+				},
+				previousSnapshot,
+				snapshot: this.snapshot,
+				effects: [],
+				transitionIds: []
+			};
+			this.timeline.push(entry);
+			this.markPendingActors(entry);
+			this.pushActorEntries(previousSnapshot, drained);
+			const observation = yield* this.checkStable(void 0, previousSnapshot, this.snapshot, []);
+			setEntryObservation(entry, observation);
+		}.bind(this)));
+	}
+	checkpoint(label) {
+		return Effect.runPromise(Effect.gen(function* () {
+			this.assertStarted();
+			this.recordGeneratedCommand();
+			const entry = {
+				kind: "command",
+				index: this.timeline.length,
+				command: {
+					type: "checkpoint",
+					label
+				},
+				previousSnapshot: this.snapshot,
+				snapshot: this.snapshot,
+				effects: [],
+				transitionIds: []
+			};
+			this.timeline.push(entry);
+			yield* Effect.promise(() => Promise.resolve(this.sutSession?.checkpoint?.(label)));
+			this.coverage.checkpoints++;
+			const observation = yield* this.compareObservations();
+			this.lastObservation = observation;
+			setEntryObservation(entry, observation);
+		}.bind(this)));
+	}
+	stop() {
+		return Effect.runPromise(Effect.gen(function* () {
+			this.assertStarted();
+			this.recordGeneratedCommand();
+			const previousSnapshot = this.snapshot;
+			const execution = this.execution;
+			const stopEvent = { type: XSTATE_STOP };
+			const { snapshot, effects, transitionIds, drained } = yield* execution !== void 0 ? stopExecutedStep(execution, this.coverage) : Effect.succeed(pureTransitionStep(this.logic, this.coverage, previousSnapshot, stopEvent));
+			this.snapshot = snapshot;
+			yield* Effect.promise(() => Promise.resolve(this.referenceSession?.stop?.()));
+			yield* Effect.promise(() => Promise.resolve(this.sutSession?.stop?.()));
+			this.coverage.stops++;
+			this.coverage.steps++;
+			this.coverage.generatedSteps++;
+			this.recordSnapshot(snapshot);
+			const entry = {
+				kind: "command",
+				index: this.timeline.length,
+				command: { type: "stop" },
+				previousSnapshot,
+				snapshot,
+				effects,
+				transitionIds
+			};
+			this.timeline.push(entry);
+			this.markPendingActors(entry);
+			this.pushActorEntries(previousSnapshot, drained);
+			const observation = yield* this.checkStable(void 0, previousSnapshot, snapshot, effects);
+			setEntryObservation(entry, observation);
+		}.bind(this)));
+	}
+	finish() {
+		this.assertStarted();
+		if (this.finished) return;
+		for (const state of this.temporal) {
+			if (state.satisfied) continue;
+			const definition = state.definition;
+			if (definition.type === "sometimes") {
+				recordPropertyTemporal(this.coverage, definition.id, "inconclusive");
+				continue;
+			}
+			if (definition.type === "respond" && state.pendingSince === void 0) {
+				recordPropertyTemporal(this.coverage, definition.id, "satisfied");
+				continue;
+			}
+			if (definition.type !== "eventually" && definition.type !== "until" && definition.type !== "respond") {
+				recordPropertyTemporal(this.coverage, definition.id, "satisfied");
+				continue;
+			}
+			if (definition.within !== void 0) {
+				recordPropertyTemporal(this.coverage, definition.id, "inconclusive");
+				this.inconclusiveTemporalIds.push(definition.id);
+				continue;
+			}
+			this.failTemporal(definition);
+		}
+		this.finished = true;
+	}
+	/** Bounded temporal properties that the run ended before deciding. */
+	getInconclusiveTemporalIds() {
+		return this.inconclusiveTemporalIds.slice();
+	}
+	/** The number of stable steps observed so far. */
+	getStableStep() {
+		return this.stableStep;
+	}
+	dispose() {
+		return Effect.runPromise(Effect.gen(function* () {
+			const errors = [];
+			const execution = this.execution;
+			if (execution !== void 0) {
+				this.executionOutcomes = execution.outcomes.slice();
+				const stopExit = yield* Effect.exit(Effect.sync(() => execution.stop()));
+				if (Exit.isFailure(stopExit)) errors.push(Cause.squash(stopExit.cause));
+				this.execution = void 0;
+			}
+			const disposeContext = {
+				passed: this.finished,
+				...this.failure !== void 0 ? { failure: this.failure } : {}
+			};
+			for (const dispose of [this.sutSession?.dispose, this.referenceSession?.dispose]) {
+				if (dispose === void 0) continue;
+				const disposeExit = yield* Effect.exit(Effect.promise(() => Promise.resolve(dispose(disposeContext))));
+				if (Exit.isFailure(disposeExit)) errors.push(Cause.squash(disposeExit.cause));
+			}
+			this.sutSession = void 0;
+			this.referenceSession = void 0;
+			if (errors.length !== 0) throw new AggregateError(errors, "Property scenario disposal failed");
+		}.bind(this)));
+	}
+	getSnapshot() {
+		return this.snapshot;
+	}
+	getTrace() {
+		const steps = this.timeline.filter((entry) => entry.kind === "event").map((entry) => ({
+			...entry,
+			phase: entry.command.phase,
+			event: entry.command.event
+		}));
+		return {
+			start: this.startingSnapshot !== void 0 ? {
+				type: "snapshot",
+				snapshot: this.startingSnapshot
+			} : {
+				type: "input",
+				input: this.input
+			},
+			initialSnapshot: this.initialSnapshot,
+			initialEffects: this.initialEffects,
+			initialTransitionIds: this.initialTransitionIds,
+			timeline: this.timeline.slice(),
+			prefixEvents: steps.filter((step) => step.phase === "prefix").map((step) => step.event),
+			events: steps.filter((step) => step.phase === "generated" && step.command.origin === "generator").map((step) => step.event),
+			commands: this.timeline.filter((entry) => entry.kind === "command").map((entry) => entry.command),
+			steps,
+			finalSnapshot: this.snapshot,
+			finalObservation: this.lastObservation,
+			swarm: this.swarmCaseIds,
+			...this.execution !== void 0 || this.executionOutcomes !== void 0 ? {
+				mode: "executed",
+				outcomes: this.execution?.outcomes.slice() ?? this.executionOutcomes
+			} : {}
+		};
+	}
+	executeEvent(event, phase, origin, sendToSut, compare = true, caseId) {
+		return Effect.gen(function* () {
+			const previousSnapshot = this.snapshot;
+			const execution = this.execution;
+			const { snapshot, effects, transitionIds, drained } = yield* execution !== void 0 ? sendExecutedStep(execution, this.coverage, event) : Effect.succeed(pureTransitionStep(this.logic, this.coverage, previousSnapshot, event));
+			this.snapshot = snapshot;
+			const referenceSession = this.referenceSession;
+			if (referenceSession !== void 0) yield* Effect.promise(() => Promise.resolve(referenceSession.transition(event)));
+			if (sendToSut) {
+				const parsedCase = caseId !== void 0 && caseId.length > 0 ? parsePropertyEventCaseId(caseId) : void 0;
+				yield* Effect.promise(() => Promise.resolve(this.sutSession?.send(event, {
+					snapshot,
+					...caseId === void 0 ? {} : { caseId },
+					...parsedCase !== void 0 ? { case: parsedCase } : {}
+				})));
+			}
+			this.coverage.steps++;
+			if (phase === "prefix") this.coverage.prefixSteps++;
+			else this.coverage.generatedSteps++;
+			this.recordSnapshot(snapshot);
+			const entry = {
+				kind: "event",
+				index: this.timeline.length,
+				command: {
+					type: "event",
+					event,
+					phase,
+					origin,
+					caseId
+				},
+				previousSnapshot,
+				snapshot,
+				effects,
+				transitionIds,
+				activeStateIds: this.getActiveStateIds(snapshot)
+			};
+			this.timeline.push(entry);
+			this.markPendingActors(entry);
+			this.pushActorEntries(previousSnapshot, drained);
+			const observation = yield* this.checkStable(event, previousSnapshot, snapshot, effects, compare);
+			setEntryObservation(entry, observation);
+		}.bind(this));
+	}
+	checkStable(event, previousSnapshot, snapshot, effects, compare = true) {
+		return Effect.gen(function* () {
+			const step = this.stableStep++;
+			const observation = compare ? yield* this.compareObservations() : void 0;
+			this.lastObservation = observation;
+			yield* this.checkStateAssertions(snapshot, step);
+			const check = this.sutSession?.check;
+			if (check !== void 0) {
+				const checkExit = yield* Effect.exit(Effect.promise(() => Promise.resolve(check())));
+				if (Exit.isFailure(checkExit)) this.fail(`SUT check failed after ${step} step${step === 1 ? "" : "s"}`, Cause.squash(checkExit.cause), step);
+			}
+			const invariant = this.invariant;
+			if (invariant !== void 0) {
+				this.coverage.invariantChecks++;
+				const invariantExit = yield* Effect.exit(Effect.promise(() => Promise.resolve(invariant({
+					initialSnapshot: this.initialSnapshot,
+					previousSnapshot,
+					snapshot,
+					event,
+					effects,
+					step,
+					label: this.label,
+					classify: this.classify,
+					target: this.target
+				}))));
+				if (Exit.isFailure(invariantExit)) this.fail(`Property invariant failed after ${step} step${step === 1 ? "" : "s"}`, Cause.squash(invariantExit.cause), step);
+			}
+			if (this.targetFunction !== void 0) this.target(this.targetFunction({
+				initialSnapshot: this.initialSnapshot,
+				previousSnapshot,
+				snapshot,
+				event,
+				effects,
+				step,
+				label: this.label,
+				classify: this.classify,
+				target: this.target
+			}));
+			yield* this.checkTemporal({
+				initialSnapshot: this.initialSnapshot,
+				previousSnapshot,
+				snapshot,
+				event,
+				effects,
+				step,
+				label: this.label,
+				classify: this.classify,
+				target: this.target
+			});
+			return observation;
+		}.bind(this));
+	}
+	/**
+	* Runs the per-state assertions and any `meta.test` hooks that apply to
+	* `snapshot`. Both entry points reach this on every stable step.
+	*/
+	checkStateAssertions(snapshot, step) {
+		return Effect.gen(function* () {
+			const states = this.sutSession?.states ?? this.states;
+			const session = this.sutSession;
+			const failed = (cause) => this.fail(`State assertion failed after ${step} step${step === 1 ? "" : "s"}: ${cause instanceof Error ? cause.message : String(cause)}`, cause, step);
+			if (states !== void 0) {
+				const keys = Object.keys(states).filter((stateKey) => stateKey !== "*" && matchesStateKey(snapshot, stateKey));
+				if (keys.length === 0 && "*" in states) keys.push("*");
+				for (const key of keys) {
+					const assertion = states[key];
+					if (assertion === void 0) continue;
+					const assertionExit = yield* Effect.exit(Effect.promise(() => Promise.resolve(assertion(snapshot, session))));
+					if (Exit.isFailure(assertionExit)) failed(Cause.squash(assertionExit.cause));
+				}
+			}
+			const getMeta = snapshot.getMeta;
+			if (typeof getMeta !== "function") return;
+			for (const meta of Object.values(getMeta.call(snapshot))) {
+				const test = meta?.test;
+				if (typeof test !== "function") continue;
+				const hook = test;
+				const testExit = yield* Effect.exit(Effect.promise(() => Promise.resolve(hook(session, snapshot))));
+				if (Exit.isFailure(testExit)) failed(Cause.squash(testExit.cause));
+			}
+		}.bind(this));
+	}
+	checkTemporal(context) {
+		return Effect.gen(function* () {
+			for (const state of this.temporal) {
+				if (state.satisfied) continue;
+				this.coverage.temporalChecks++;
+				const definition = state.definition;
+				if (definition.type === "always") {
+					if (!(yield* temporalPredicate(definition.predicate, context))) this.failTemporal(definition);
+					continue;
+				}
+				if (definition.type === "never") {
+					if (yield* temporalPredicate(definition.predicate, context)) this.failTemporal(definition);
+					continue;
+				}
+				if (definition.type === "sometimes") {
+					if (yield* temporalPredicate(definition.predicate, context)) {
+						state.satisfied = true;
+						recordPropertyTemporal(this.coverage, definition.id, "satisfied");
+					}
+					continue;
+				}
+				if (definition.type === "respond") {
+					const respond = yield* Effect.cached(temporalPredicate(definition.response, context));
+					if (state.pendingSince !== void 0) {
+						if (yield* respond) state.pendingSince = void 0;
+					} else if ((yield* temporalPredicate(definition.trigger, context)) && !(yield* respond)) state.pendingSince = context.step;
+					if (state.pendingSince !== void 0 && definition.within !== void 0 && context.step - state.pendingSince >= definition.within) this.failTemporal(definition);
+					continue;
+				}
+				if (definition.type === "eventually") state.satisfied = yield* temporalPredicate(definition.predicate, context);
+				else if (yield* temporalPredicate(definition.until, context)) state.satisfied = true;
+				else if (!(yield* temporalPredicate(definition.hold, context))) this.failTemporal(definition);
+				if (state.satisfied) recordPropertyTemporal(this.coverage, definition.id, "satisfied");
+				if (!state.satisfied && definition.within !== void 0 && context.step >= definition.within) this.failTemporal(definition);
+			}
+		}.bind(this));
+	}
+	failTemporal(definition) {
+		recordPropertyTemporal(this.coverage, definition.id, "failed");
+		const failure = {
+			type: definition.type,
+			id: definition.id,
+			description: definition.description,
+			within: definition.type === "eventually" || definition.type === "until" || definition.type === "respond" ? definition.within : void 0,
+			atStep: this.stableStep - 1
+		};
+		this.fail(`Temporal property "${definition.id}" failed`, failure, failure.atStep, failure);
+	}
+	compareObservations() {
+		return Effect.gen(function* () {
+			const comparableModel = this.sut?.projectModel;
+			const comparableSut = comparableModel !== void 0 && this.sutSession?.read !== void 0 ? this.sut : void 0;
+			const referenceOracle = this.reference;
+			if (referenceOracle === void 0 && comparableSut === void 0) {
+				yield* Effect.promise(() => Promise.resolve(this.sutSession?.settle?.()));
+				return;
+			}
+			yield* Effect.promise(() => Promise.resolve(this.sutSession?.settle?.()));
+			const referenceRaw = yield* Effect.promise(() => Promise.resolve(this.referenceSession?.read()));
+			const sutRaw = yield* Effect.promise(() => Promise.resolve(this.sutSession?.read?.()));
+			const model = referenceOracle !== void 0 ? referenceOracle.projectModel(this.snapshot) : comparableModel?.(this.snapshot);
+			const reference = referenceOracle !== void 0 ? referenceOracle.projectReference !== void 0 ? referenceOracle.projectReference(referenceRaw) : referenceRaw : void 0;
+			const sut = comparableSut !== void 0 ? comparableSut.projectSut !== void 0 ? comparableSut.projectSut(sutRaw) : sutRaw : void 0;
+			const sutModel = comparableSut !== void 0 ? comparableModel?.(this.snapshot) : void 0;
+			const observation = {
+				model,
+				reference: referenceOracle !== void 0 ? {
+					model,
+					observed: reference
+				} : void 0,
+				sut: comparableSut !== void 0 ? {
+					model: sutModel,
+					observed: sut
+				} : void 0
+			};
+			if (referenceOracle !== void 0) this.coverage.oracleComparisons++;
+			if (comparableSut !== void 0) this.coverage.sutComparisons++;
+			const referenceMatches = referenceOracle === void 0 ? true : yield* oracleMatches(referenceOracle.equivalent, model, reference);
+			const sutMatches = comparableSut === void 0 ? true : yield* oracleMatches(comparableSut.equivalent, model, sut);
+			if (!referenceMatches || !sutMatches) {
+				this.lastObservation = observation;
+				this.replaceLastObservation(observation);
+				this.fail("Property observation diverged", {
+					model,
+					reference: observation.reference,
+					sut: observation.sut,
+					referenceMatches,
+					sutMatches
+				}, this.stableStep);
+			}
+			return observation;
+		}.bind(this));
+	}
+	replaceLastObservation(observation) {
+		const last = this.timeline.at(-1);
+		if (last !== void 0) setEntryObservation(last, observation);
+	}
+	/**
+	* Records, on an executed step's timeline entry, the child actors whose
+	* asynchronous work was still in flight when the step settled.
+	*/
+	markPendingActors(entry) {
+		if (this.execution === void 0) return;
+		const pending = this.execution.getPendingActors();
+		if (pending.length === 0) return;
+		entry.pendingActors = pending;
+		this.coverage.pendingActorSteps++;
+	}
+	/**
+	* Executed mode only: the milliseconds until the tested actor's pending
+	* `xstate.after` timer for `event` is due, or `undefined` when none is
+	* scheduled.
+	*/
+	getAfterTimerRemaining(event) {
+		return this.execution?.getAfterTimerRemaining(event);
+	}
+	/**
+	* Fails the run with `summary`, recording a trace and a replay fixture the
+	* same way an oracle failure does. Used by drivers that detect the run
+	* departed from the sequence they planned.
+	*/
+	diverge(summary, cause) {
+		this.assertStarted();
+		this.fail(summary, cause, Math.max(0, this.stableStep - 1));
+	}
+	/**
+	* Appends one timeline entry per transition the actor system performed on
+	* its own during an executed step: invoked/spawned actor lifecycle events,
+	* delayed transitions, and relayed sends.
+	*/
+	pushActorEntries(previousSnapshot, drained) {
+		let previous = previousSnapshot;
+		for (const transition of drained) {
+			this.timeline.push({
+				kind: "actorEvent",
+				index: this.timeline.length,
+				source: transition.source,
+				actorId: transition.actorId,
+				event: transition.event,
+				previousSnapshot: previous,
+				snapshot: transition.snapshot,
+				effects: transition.effects,
+				transitionIds: transition.transitionIds
+			});
+			if (transition.source === "root") previous = transition.snapshot;
+		}
+	}
+	recordSnapshot(snapshot) {
+		recordPropertySnapshot(this.coverage, snapshot);
+	}
+	recordGeneratedCommand() {
+		this.generatedCommandCount++;
+		this.coverage.maximumObservedSequenceLength = Math.max(this.coverage.maximumObservedSequenceLength, this.generatedCommandCount);
+	}
+	getActiveStateIds(snapshot) {
+		return (snapshot.nodes ?? snapshot._nodes)?.map((node) => node.id) ?? [];
+	}
+	assertStarted() {
+		if (!this.started) throw new Error("Property scenario runner has not been started");
+	}
+	fail(message, cause, failedAt, temporalFailure) {
+		let fixture;
+		try {
+			fixture = this.getReplayFixture(failedAt, temporalFailure);
+		} catch {
+			fixture = void 0;
+		}
+		this.failure = new ModelTestFailure(message, this.getTrace(), cause, void 0, fixture, void 0, this.formatOptions);
+		throw this.failure;
+	}
+	getReplayFixture(failedAt, temporalFailure) {
+		const identity = this.logic;
+		if (this.startingSnapshot !== void 0 && this.serializeStartingSnapshot === void 0) throw new Error("Property tests starting from a snapshot require serializeSnapshot to create replay fixtures");
+		return {
+			formatVersion: 2,
+			machine: identity.id !== void 0 && identity.id.length > 0 || identity.version !== void 0 && identity.version.length > 0 ? {
+				id: identity.id,
+				version: identity.version
+			} : void 0,
+			start: this.startingSnapshot !== void 0 ? {
+				type: "snapshot",
+				snapshot: this.serializeStartingSnapshot(this.startingSnapshot)
+			} : {
+				type: "input",
+				input: this.input
+			},
+			timeline: this.timeline.filter((entry) => entry.kind !== "actorEvent").map((entry) => ({
+				kind: entry.kind,
+				command: toPortableValue(entry.command)
+			})),
+			failedAt,
+			temporalFailure,
+			...this.swarmCaseIds !== void 0 ? { swarm: this.swarmCaseIds } : {},
+			...this.execution !== void 0 ? {
+				mode: "executed",
+				outcomes: toPortableValue(this.execution.outcomes.slice()),
+				...this.executionConfig?.stubbedSources !== void 0 && this.executionConfig.stubbedSources.length !== 0 ? { stubs: [...this.executionConfig.stubbedSources].sort() } : {}
+			} : {}
+		};
+	}
+};
+/**
+* Replaces every `Error` in `value` with `{ xstate$$error: true, name,
+* message }`, which JSON can carry: `JSON.stringify(new Error('x'))` is `{}`.
+* Fixtures are portable data, so this runs on everything they record;
+* `replayTest()` turns the marked objects back into errors.
+*/
+function toPortableValue(value, seen = /* @__PURE__ */ new Map()) {
+	if (value instanceof Error) return {
+		xstate$$error: true,
+		name: value.name,
+		message: value.message
+	};
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return seen.get(value);
+	if (Array.isArray(value)) {
+		const copy = [];
+		seen.set(value, copy);
+		for (const item of value) copy.push(toPortableValue(item, seen));
+		return copy;
+	}
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	const copy = {};
+	seen.set(value, copy);
+	for (const [key, nested] of Object.entries(value)) copy[key] = toPortableValue(nested, seen);
+	return copy;
+}
+/** Reverses {@link toPortableValue}'s error encoding. */
+function fromPortableValue(value) {
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(fromPortableValue);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	const record = value;
+	if (record["xstate$$error"] === true && typeof record["message"] === "string") {
+		const error = new Error(record["message"]);
+		if (typeof record["name"] === "string") error.name = record["name"];
+		return error;
+	}
+	return Object.fromEntries(Object.entries(record).map(([key, nested]) => [key, fromPortableValue(nested)]));
+}
+const DEFAULT_BATCH_RUNS = 25;
+const DEFAULT_MAX_RUNS = 100;
+const DEFAULT_MAX_FRONTIERS = 5;
+const DEFAULT_FRONTIER_SEARCH_LIMIT = 1e3;
+function getCoverageRatio(dimension) {
+	const considered = dimension.covered.length + dimension.uncovered.length;
+	return considered !== 0 ? dimension.covered.length / considered : 1;
+}
+function getEventCaseRatio(coverage) {
+	const cases = Object.values(coverage.eventCases);
+	if (cases.length === 0) return 1;
+	return cases.filter((counts) => counts.executed > 0).length / cases.length;
+}
+/**
+* Evaluates a {@link TestStopCondition} against aggregated coverage.
+*
+* @experimental
+*/
+function evaluateTestStopCondition(condition, coverage, elapsedMs) {
+	if (typeof condition === "function") return condition(coverage);
+	const clauses = [];
+	for (const key of [
+		"stateNodes",
+		"transitions",
+		"transitionPairs",
+		"requirements"
+	]) {
+		const threshold = condition[key];
+		if (threshold !== void 0) clauses.push(getCoverageRatio(coverage[key]) >= threshold);
+	}
+	if (condition.eventCases !== void 0) clauses.push(getEventCaseRatio(coverage) >= condition.eventCases);
+	if (condition.runs !== void 0) clauses.push(coverage.exploration.completedRuns >= condition.runs);
+	if (condition.timeMs !== void 0) clauses.push(elapsedMs >= condition.timeMs);
+	if (condition.any !== void 0 && condition.any.length !== 0) clauses.push(condition.any.some((nested) => evaluateTestStopCondition(nested, coverage, elapsedMs)));
+	return clauses.length > 0 && clauses.every(Boolean);
+}
+function getSnapshotStateNodeIds(snapshot) {
+	return (snapshot.nodes ?? snapshot._nodes)?.map((node) => node.id) ?? [];
+}
+function getTransitionSourceId(id) {
+	try {
+		const parsed = JSON.parse(id);
+		return Array.isArray(parsed) && parsed[0] === "transition" ? String(parsed[1]) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Picks the shortest paths that reach the state nodes owning the most
+* uncovered transitions, deduplicated by target configuration.
+*/
+function selectUncoveredFrontiers(paths, coverage, maxFrontiers) {
+	const uncoveredBySource = /* @__PURE__ */ new Map();
+	for (const id of coverage.transitions.uncovered) {
+		const source = getTransitionSourceId(id);
+		if (source === void 0) continue;
+		uncoveredBySource.set(source, (uncoveredBySource.get(source) ?? 0) + 1);
+	}
+	const ranked = [...uncoveredBySource].sort(([leftId, left], [rightId, right]) => right - left || leftId.localeCompare(rightId));
+	const selected = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [sourceId] of ranked) {
+		let best;
+		for (const path of paths) {
+			if (path.steps.length === 0 || !getSnapshotStateNodeIds(path.state).includes(sourceId)) continue;
+			if (best === void 0 || path.weight < best.weight) best = path;
+		}
+		if (best === void 0) continue;
+		const key = getPropertyConfigurationId(best.state);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		selected.push(best);
+		if (selected.length >= maxFrontiers) break;
+	}
+	return selected;
+}
+function getLabelExpectationFailures(expectations, coverage) {
+	const failures = [];
+	for (const [name, expectation] of Object.entries(expectations)) {
+		const label = coverage.labels[name] ?? {
+			count: 0,
+			values: {},
+			share: 0
+		};
+		if (expectation.min !== void 0 && label.share < expectation.min) failures.push(`${name}: share ${label.share.toFixed(3)} is below ${expectation.min}`);
+		if (expectation.minCount !== void 0 && label.count < expectation.minCount) failures.push(`${name}: count ${label.count} is below ${expectation.minCount}`);
+	}
+	return failures;
+}
+function getFrontierId(frontier) {
+	return JSON.stringify([
+		"frontier",
+		getPropertyConfigurationId(frontier.state),
+		frontier.steps.map((step) => step.event).filter((event) => event.type !== XSTATE_INIT)
+	]);
+}
+/** The id the initial, frontier-less scenario records. */
+const INITIAL_FRONTIER_ID = JSON.stringify(["frontier", "initial"]);
+/** A stable key for an event prefix, so equivalent prefixes collapse. */
+function getEventPrefixKey(events) {
+	return JSON.stringify(events);
+}
+/** The swarm-subset PRNG: mulberry32 on a seed offset from the campaign's. */
+function createSwarmRng(seed) {
+	return createSeededRng(seed ^ 2654435769);
+}
+function finalizeExploration(coverage, accumulator) {
+	const maximumSequenceLength = accumulator.maximumSequenceLengthUnknown ? null : accumulator.maximumSequenceLength;
+	if (maximumSequenceLength !== null && coverage.maximumObservedSequenceLength >= maximumSequenceLength) accumulator.truncationReasons.add("maximum sequence length reached");
+	return {
+		strategy: accumulator.strategy,
+		mode: accumulator.mode,
+		configuredRuns: accumulator.configuredRunsOverride ?? (accumulator.configuredRunsUnknown ? null : accumulator.configuredRuns),
+		stoppedBecause: accumulator.stoppedBecause,
+		completedRuns: accumulator.completedRuns,
+		attemptedRuns: coverage.runs,
+		shrinkRuns: coverage.shrinkRuns,
+		maximumSequenceLength,
+		maximumObservedSequenceLength: coverage.maximumObservedSequenceLength,
+		frontiers: accumulator.frontiers.slice(),
+		seeds: accumulator.seeds.slice(),
+		swarm: accumulator.swarmUsed ? {
+			runs: accumulator.swarmRuns,
+			averageEnabled: accumulator.swarmRuns !== 0 ? accumulator.swarmEnabledTotal / accumulator.swarmRuns : 0
+		} : null,
+		target: {
+			best: accumulator.targetBest,
+			label: accumulator.targetLabel,
+			improvements: accumulator.targetImprovements
+		},
+		truncated: accumulator.truncationReasons.size > 0,
+		truncationReasons: [...accumulator.truncationReasons].sort(),
+		pendingActorSteps: coverage.pendingActorSteps
+	};
+}
+/**
+* Warns about bounded temporal properties whose bound exceeds the longest
+* sequence the campaign can produce: they can never fail.
+*/
+function getVacuityWarnings(temporal, exploration) {
+	if (exploration.maximumSequenceLength === null) return [];
+	const longest = exploration.maximumSequenceLength + Math.max(0, ...exploration.frontiers.map((frontier) => frontier.prefixLength));
+	const warnings = [];
+	for (const definition of temporal) if ((definition.type === "eventually" || definition.type === "until" || definition.type === "respond") && definition.within !== void 0 && definition.within > longest) warnings.push(`${definition.type} "${definition.id}" has within ${definition.within}, but the longest sequence is ${longest} steps, so it can never fail`);
+	return warnings;
+}
+/** Matches a `reachable` target against a snapshot. */
+function matchesReachableTarget(snapshot, target) {
+	if (matchesStateKey(snapshot, target)) return true;
+	const hasTag = snapshot.hasTag;
+	return typeof hasTag === "function" && hasTag.call(snapshot, target);
+}
+/**
+* The default {@link TestFailureStore} key: the machine id plus a hash of the
+* event cases and oracles, so campaigns that test the same machine
+* differently do not replay each other's fixtures.
+*/
+function getDefaultFailureKey(logic, caseIds, temporal, options) {
+	const signature = JSON.stringify({
+		events: [...caseIds].sort(),
+		temporal: temporal.map(({ type, id }) => `${type}:${id}`).sort(),
+		invariant: options.invariant !== void 0,
+		sut: options.sut !== void 0,
+		reference: options.reference !== void 0,
+		states: Object.keys(options.states ?? {}).sort(),
+		mode: options.mode ?? "pure"
+	});
+	const id = logic.id;
+	return `${typeof id === "string" && id.length > 0 ? id : "machine"}-${fnv1a(signature).toString(16).padStart(8, "0")}`;
+}
+/**
+* The value a thunk produces, or `undefined` when it throws, for the
+* synchronous projections that must not mask a failure.
+*/
+const tryValue = (thunk) => {
+	try {
+		return thunk();
+	} catch {
+		return;
+	}
+};
+/** The array a thunk produces, or `[]` when it throws. */
+const tryArray = (thunk) => {
+	try {
+		return thunk();
+	} catch {
+		return [];
+	}
+};
+/** The failure with a save note appended to its extras. */
+const withFailureNote = (failure, note) => new ModelTestFailure(failure.summary, failure.trace, failure.cause, failure.replay, failure.fixture, failure.coverage, failure.format, {
+	...failure.extras,
+	notes: [...failure.extras?.notes ?? [], note]
+});
+/** Reports a campaign's statistics through the package's console logger. */
+const logTestStatistics = (coverage) => Effect.runSync(Effect.log(formatTestStatistics(coverage)).pipe(Effect.provide(Logger.layer([consoleLineLogger]))));
+/**
+* Disposes a runner, recording the run however its disposal settles, so a
+* throwing disposal still records the run before it propagates.
+*/
+const disposeRunnerWithRecord = (dispose, record) => Effect.runPromise(ensuringFinalizerWins(Effect.promise(() => Promise.resolve(dispose())), Effect.sync(record)));
+/** The campaign behind {@link propertyTest}, as one Effect run per call. */
+const propertyTestProgram = (source, options) => Effect.gen(function* () {
+	const mode = options.mode ?? "pure";
+	if (mode === "pure" && (options.actors !== void 0 || options.outcomes !== void 0)) throw new Error("Property `actors` and `outcomes` require `mode: 'executed'`");
+	const outcomeRegistry = new PropertyOutcomeRegistry();
+	const providedActors = { ...options.actors };
+	for (const src of Object.keys(options.outcomes ?? {})) providedActors[src] = createOutcomeStub(src, outcomeRegistry);
+	const logic = Object.keys(providedActors).length !== 0 ? provideActors(source, providedActors) : source;
+	const { cases: events, descriptors: eventDescriptors } = normalizeEventDescriptors(options.events ?? {});
+	const commands = [];
+	for (const type of [
+		"advance",
+		"checkpoint",
+		"stop"
+	]) {
+		const configured = options.commands?.[type];
+		if (configured === void 0) continue;
+		const descriptor = isEventDescriptorObject(configured) ? configured : { generate: configured };
+		commands.push({
+			type,
+			generator: descriptor.generate,
+			weight: assertTestWeight(descriptor.weight, `"${type}" command`)
+		});
+	}
+	for (const [src, configured] of Object.entries(options.outcomes ?? {})) {
+		const descriptor = isEventDescriptorObject(configured) ? configured : { generate: configured };
+		commands.push({
+			type: "outcome",
+			src,
+			generator: descriptor.generate,
+			weight: assertTestWeight(descriptor.weight, `"outcome" command for "${src}"`)
+		});
+	}
+	if (options.start !== void 0 && typeof options.start.serializeSnapshot !== "function") throw new Error("Property tests starting from a snapshot require a `start.serializeSnapshot` function");
+	const temporal = [...options.temporal ?? [], ...(options.reachable ?? []).map((target) => ({
+		type: "sometimes",
+		id: `reachable:${target}`,
+		predicate: ({ snapshot }) => matchesReachableTarget(snapshot, target)
+	}))];
+	const coverage = createTestCoverage(logic);
+	for (const event of events) declarePropertyEventCase(coverage, event.caseId, event.weight);
+	const exploration = {
+		strategy: "property",
+		mode,
+		configuredRuns: 0,
+		configuredRunsOverride: null,
+		stoppedBecause: "budget",
+		configuredRunsUnknown: false,
+		completedRuns: 0,
+		maximumSequenceLength: 0,
+		maximumSequenceLengthUnknown: false,
+		frontiers: [],
+		seeds: [],
+		swarmRuns: 0,
+		swarmEnabledTotal: 0,
+		swarmUsed: options.swarm !== void 0 && options.swarm !== false,
+		targetBest: -Infinity,
+		targetLabel: void 0,
+		targetImprovements: 0,
+		truncationReasons: /* @__PURE__ */ new Set()
+	};
+	const configuredFrontiers = options.frontiers;
+	const autoFrontierOptions = configuredFrontiers === "auto" ? { strategy: "uncovered" } : configuredFrontiers !== void 0 && !Array.isArray(configuredFrontiers) && configuredFrontiers.strategy === "uncovered" ? configuredFrontiers : null;
+	const targetFrontierOptions = configuredFrontiers !== void 0 && !Array.isArray(configuredFrontiers) && configuredFrontiers.strategy === "target" ? configuredFrontiers : null;
+	const frontierOptions = Array.isArray(configuredFrontiers) ? { paths: configuredFrontiers } : configuredFrontiers !== void 0 && autoFrontierOptions === null && targetFrontierOptions === null ? configuredFrontiers : null;
+	const frontierContexts = (frontierOptions?.paths ?? []).map((frontier, index) => ({
+		frontier,
+		index,
+		id: getFrontierId(frontier)
+	}));
+	for (const context of frontierContexts) declarePropertyFrontier(coverage, context.id);
+	const selectedFrontiers = frontierContexts.filter((context) => frontierOptions?.select?.(context) ?? true);
+	const scenarios = frontierOptions !== null ? selectedFrontiers : [void 0];
+	const swarmOptions = options.swarm !== void 0 && options.swarm !== false ? options.swarm === true ? {} : options.swarm : null;
+	const swarmCaseIds = events.map((event) => event.caseId);
+	const swarmMinimum = Math.max(1, Math.min(swarmCaseIds.length, swarmOptions?.minCases ?? Math.ceil(swarmCaseIds.length / 2)));
+	const swarmSeed = swarmOptions?.seed ?? 0;
+	/** The enabled subset for one run. Deterministic in `swarmSeed + runIndex`. */
+	const selectSwarmCases = (runIndex) => {
+		const rng = createSwarmRng(swarmSeed + runIndex * 625341585);
+		const shuffled = swarmCaseIds.slice();
+		for (let index = shuffled.length - 1; index > 0; index--) {
+			const swapWith = Math.floor(rng() * (index + 1));
+			const current = shuffled[index];
+			const other = shuffled[swapWith];
+			if (current === void 0 || other === void 0) continue;
+			shuffled[index] = other;
+			shuffled[swapWith] = current;
+		}
+		const count = swarmMinimum + Math.floor(rng() * (shuffled.length - swarmMinimum + 1));
+		return shuffled.slice(0, count).sort();
+	};
+	const targetCandidates = [];
+	const targetFrontierLimit = targetFrontierOptions?.maxFrontiers ?? DEFAULT_MAX_FRONTIERS;
+	const failureStore = options.failures;
+	const failureKey = failureStore !== void 0 ? failureStore.key ?? getDefaultFailureKey(logic, events.map((event) => event.caseId), temporal, options) : void 0;
+	const complete = (result) => Effect.ignoreCause(Effect.promise(() => Promise.resolve(options.sut?.complete?.(result))));
+	/** Saves the failure's fixture and adds `Saved: <location>` to its message. */
+	const saveFailure = (failure) => Effect.gen(function* () {
+		const fixture = failure.fixture;
+		if (failureStore === void 0 || failureKey === void 0 || fixture === void 0 || fixture.start.type !== "input") return failure;
+		const attempt = yield* Effect.exit(Effect.promise(() => Promise.resolve(failureStore.onFailure(fixture, failureKey, failure))));
+		if (Exit.isFailure(attempt)) {
+			const cause = Cause.squash(attempt.cause);
+			return withFailureNote(failure, `Not saved: ${cause instanceof Error ? cause.message : String(cause)}`);
+		}
+		const location = attempt.value;
+		return location === void 0 ? failure : withFailureNote(failure, `Saved: ${location}`);
+	});
+	const recordRun = (runner, runIndex, enabled, run) => {
+		const passed = runner.isFinished();
+		run?.report({
+			passed,
+			swarm: enabled
+		});
+		const trace = tryValue(() => runner.getTrace());
+		if (trace === void 0) return;
+		for (const observation of runner.getTargetObservations()) {
+			if (observation.value > exploration.targetBest) {
+				exploration.targetBest = observation.value;
+				exploration.targetLabel = observation.label;
+				exploration.targetImprovements++;
+			}
+			if (targetFrontierOptions === null) continue;
+			const prefix = trace.timeline.slice(0, observation.index);
+			const prefixEvents = prefix.filter((entry) => entry.kind === "event").map((entry) => entry.command.event);
+			if (prefixEvents.length === 0) continue;
+			const key = getEventPrefixKey(prefixEvents);
+			if (targetCandidates.some((candidate) => candidate.key === key)) continue;
+			const lastPrefixEntry = prefix[prefix.length - 1];
+			if (prefix.length > 0 && lastPrefixEntry === void 0) throw new TypeError("prefix entry is missing");
+			targetCandidates.push({
+				value: observation.value,
+				key,
+				events: prefixEvents,
+				state: lastPrefixEntry?.snapshot ?? trace.initialSnapshot
+			});
+		}
+		targetCandidates.sort((left, right) => right.value - left.value || left.events.length - right.events.length || (left.key < right.key ? -1 : 1));
+		targetCandidates.length = Math.min(targetCandidates.length, targetFrontierLimit * 4);
+		options.collect?.(trace, {
+			passed,
+			runIndex
+		});
+	};
+	const runScenario = (frontierContext, runBudget, runOffset) => Effect.gen(function* () {
+		const prefixEvents = frontierContext !== void 0 ? frontierContext.frontier.steps.map((step) => step.event).filter((event) => event.type !== XSTATE_INIT) : [];
+		if (runBudget !== void 0 && (!Number.isInteger(runBudget) || runBudget < 1)) throw new Error("runsPerFrontier must return a positive integer");
+		const attemptedRunsBefore = coverage.runs;
+		const result = yield* Effect.promise(() => options.adapter.run({
+			events,
+			commands,
+			runBudget,
+			runOffset,
+			createEvent: (type, payload) => {
+				assertEventPayload(payload, type);
+				return {
+					...payload,
+					type
+				};
+			},
+			createRunner: (run) => {
+				coverage.runs++;
+				if (run?.shrink === true) coverage.shrinkRuns++;
+				const runsBeforeThisOne = coverage.runs - attemptedRunsBefore - 1;
+				const runIndex = (runOffset ?? 0) + runsBeforeThisOne;
+				const runner = new PropertyScenarioRunner(logic, options.input, options.start?.snapshot, options.start?.serializeSnapshot, prefixEvents, frontierContext?.id, options.sut, options.states, options.reference, options.invariant, temporal, eventDescriptors, coverage, mode === "executed" ? {
+					mode,
+					registry: outcomeRegistry,
+					stubbedSources: Object.keys(options.outcomes ?? {})
+				} : void 0);
+				if (options.target !== void 0) runner.setTargetFunction(options.target);
+				runner.setFormatSnapshot(options.formatSnapshot);
+				if (run?.shrink === true) runner.markShrinkRun();
+				const enabled = swarmOptions !== null ? run?.swarm ?? selectSwarmCases(runIndex) : void 0;
+				if (enabled !== void 0) {
+					runner.setSwarm(enabled);
+					exploration.swarmRuns++;
+					exploration.swarmEnabledTotal += enabled.length;
+				}
+				const dispose = runner.dispose.bind(runner);
+				runner.dispose = () => disposeRunnerWithRecord(dispose, () => {
+					recordRun(runner, runIndex, enabled, run);
+				});
+				return runner;
+			}
+		}));
+		const configuredRuns = result.exploration.configuredRuns;
+		if (configuredRuns === null) exploration.configuredRunsUnknown = true;
+		else exploration.configuredRuns += configuredRuns;
+		exploration.completedRuns += result.runs;
+		const maximumSequenceLength = result.exploration.maximumSequenceLength;
+		if (maximumSequenceLength === null) exploration.maximumSequenceLengthUnknown = true;
+		else exploration.maximumSequenceLength = Math.max(exploration.maximumSequenceLength ?? 0, maximumSequenceLength);
+		const frontierId = frontierContext?.id ?? INITIAL_FRONTIER_ID;
+		exploration.frontiers.push({
+			id: frontierId,
+			prefixLength: prefixEvents.length,
+			runBudget: runBudget ?? null,
+			configuredRuns,
+			completedRuns: result.runs,
+			attemptedRuns: coverage.runs - attemptedRunsBefore
+		});
+		exploration.seeds.push({
+			frontierId,
+			engine: result.exploration.engine,
+			seed: result.exploration.seed,
+			path: result.exploration.path
+		});
+		for (const reason of result.exploration.truncationReasons ?? []) exploration.truncationReasons.add(reason);
+		if (result.exploration.truncated === true && (result.exploration.truncationReasons?.length ?? 0) === 0) exploration.truncationReasons.add("adapter reported truncation");
+		if (result.error !== void 0) {
+			exploration.stoppedBecause = "failure";
+			if (result.error instanceof ModelTestFailure) {
+				const failure = yield* saveFailure(new ModelTestFailure(result.error.summary, result.error.trace, result.error.cause, result.replay, result.error.fixture, snapshotCoverage(), result.error.format, result.report !== void 0 ? {
+					...result.error.extras,
+					report: result.report
+				} : result.error.extras));
+				yield* complete({
+					passed: false,
+					failure
+				});
+				throw failure;
+			}
+			const error = result.error instanceof Error ? result.error : new Error("Property adapter failed", { cause: result.error });
+			yield* complete({
+				passed: false,
+				failure: error
+			});
+			throw error;
+		}
+	});
+	const snapshotCoverage = () => {
+		const bounds = finalizeExploration(coverage, exploration);
+		coverage.temporal.warnings = getVacuityWarnings(temporal, bounds);
+		return finalizeTestCoverage(coverage, bounds);
+	};
+	if (failureStore !== void 0 && failureKey !== void 0 && failureStore.replay !== false) {
+		const store = failureStore;
+		const key = failureKey;
+		const storedFailures = yield* Effect.promise(() => Promise.resolve(store.load(key)));
+		for (const stored of storedFailures) {
+			const replayExit = yield* Effect.exit(Effect.promise(() => replayTest(logic, stored.fixture, {
+				invariant: options.invariant,
+				temporal,
+				reference: options.reference,
+				sut: options.sut,
+				states: options.states,
+				formatSnapshot: options.formatSnapshot,
+				actors: options.actors
+			})));
+			if (Exit.isFailure(replayExit)) {
+				const error = Cause.squash(replayExit.cause);
+				if (error instanceof ReplayNotReproducedError) {
+					yield* Effect.promise(() => Promise.resolve(store.remove?.(stored, key)));
+					continue;
+				}
+				if (error instanceof ModelTestFailure) {
+					const failure = new ModelTestFailure(`${error.summary} (replayed from ${stored.location ?? "the failure store"})`, error.trace, error.cause, error.replay, error.fixture, error.coverage, error.format, error.extras);
+					yield* complete({
+						passed: false,
+						failure
+					});
+					throw failure;
+				}
+				throw error;
+			}
+		}
+		if (store.replay === "only") {
+			exploration.stoppedBecause = "replay";
+			const replayed = snapshotCoverage();
+			yield* complete({ passed: true });
+			return { coverage: replayed };
+		}
+	}
+	const getStaticRunBudget = (frontierContext) => frontierContext !== void 0 ? typeof frontierOptions?.runsPerFrontier === "function" ? frontierOptions.runsPerFrontier(frontierContext) : frontierOptions?.runsPerFrontier : void 0;
+	if (options.until === void 0 && autoFrontierOptions === null && targetFrontierOptions === null) for (const frontierContext of scenarios) yield* runScenario(frontierContext, getStaticRunBudget(frontierContext), void 0);
+	else {
+		const maxRuns = options.maxRuns ?? DEFAULT_MAX_RUNS;
+		const batchRuns = Math.max(1, Math.min(options.batchRuns ?? DEFAULT_BATCH_RUNS, maxRuns));
+		exploration.configuredRunsOverride = maxRuns;
+		const startedAt = DateTime.toEpochMillis(DateTime.nowUnsafe());
+		const shortestPaths = yield* Ref.make(null);
+		const getShortestPathsOnce = () => Effect.gen(function* () {
+			const cached = yield* Ref.get(shortestPaths);
+			if (cached !== null) return cached;
+			const paths = tryArray(() => getShortestPaths(logic, {
+				input: options.input,
+				limit: autoFrontierOptions?.limit ?? DEFAULT_FRONTIER_SEARCH_LIMIT
+			}));
+			yield* Ref.set(shortestPaths, paths);
+			return paths;
+		});
+		const nextFrontierIndex = yield* Ref.make(0);
+		const getAutoScenarios = (budget) => Effect.gen(function* () {
+			const paths = selectUncoveredFrontiers(yield* getShortestPathsOnce(), snapshotCoverage(), autoFrontierOptions.maxFrontiers ?? DEFAULT_MAX_FRONTIERS);
+			if (paths.length === 0) return [[void 0, budget]];
+			const perFrontier = autoFrontierOptions.runsPerFrontier ?? Math.max(1, Math.floor(budget / paths.length));
+			const batch = [];
+			for (const frontier of paths) {
+				const id = getFrontierId(frontier);
+				declarePropertyFrontier(coverage, id);
+				const index = yield* Ref.getAndUpdate(nextFrontierIndex, (value) => value + 1);
+				batch.push([{
+					frontier,
+					index,
+					id
+				}, perFrontier]);
+			}
+			return batch;
+		});
+		const nextTargetIndex = yield* Ref.make(0);
+		const getTargetScenarios = (budget) => Effect.gen(function* () {
+			const candidates = targetCandidates.slice(0, targetFrontierLimit);
+			if (candidates.length === 0) return [[void 0, budget]];
+			const perFrontier = targetFrontierOptions.runsPerFrontier ?? Math.max(1, Math.floor(budget / candidates.length));
+			const batch = [];
+			for (const candidate of candidates) {
+				const frontier = {
+					state: candidate.state,
+					steps: candidate.events.map((event) => ({
+						state: candidate.state,
+						event
+					})),
+					weight: candidate.events.length
+				};
+				const id = getFrontierId(frontier);
+				declarePropertyFrontier(coverage, id);
+				const index = yield* Ref.getAndUpdate(nextTargetIndex, (value) => value + 1);
+				batch.push([{
+					frontier,
+					index,
+					id
+				}, perFrontier]);
+			}
+			return batch;
+		});
+		while (exploration.completedRuns < maxRuns) {
+			const runsBeforeBatch = exploration.completedRuns;
+			const budget = Math.min(batchRuns, maxRuns - exploration.completedRuns);
+			const batch = autoFrontierOptions !== null ? yield* getAutoScenarios(budget) : targetFrontierOptions !== null ? yield* getTargetScenarios(budget) : scenarios.map((frontierContext) => [frontierContext, Math.min(getStaticRunBudget(frontierContext) ?? budget, budget)]);
+			for (const [frontierContext, scenarioBudget] of batch) {
+				yield* runScenario(frontierContext, scenarioBudget, exploration.completedRuns);
+				if (exploration.completedRuns >= maxRuns) break;
+			}
+			if (exploration.completedRuns === runsBeforeBatch) {
+				exploration.truncationReasons.add("adapter made no progress");
+				break;
+			}
+			if (options.until !== void 0 && evaluateTestStopCondition(options.until, snapshotCoverage(), DateTime.toEpochMillis(DateTime.nowUnsafe()) - startedAt)) {
+				exploration.stoppedBecause = "until";
+				break;
+			}
+		}
+	}
+	const finalCoverage = snapshotCoverage();
+	const campaignFailures = [];
+	const completedRuns = finalCoverage.exploration.completedRuns;
+	const reachableCount = options.reachable?.length ?? 0;
+	for (const [index, definition] of temporal.entries()) {
+		if (definition.type !== "sometimes" || finalCoverage.temporal.satisfied.includes(definition.id)) continue;
+		coverage.temporal.campaignFailed.add(definition.id);
+		const reachableIndex = index - (temporal.length - reachableCount);
+		campaignFailures.push(reachableIndex >= 0 ? `reachable "${options.reachable[reachableIndex]}" was not entered in ${completedRuns} run(s)` : `sometimes "${definition.id}" did not hold in ${completedRuns} run(s)`);
+	}
+	if (campaignFailures.length !== 0) {
+		const error = new TestCampaignError(campaignFailures, snapshotCoverage());
+		yield* complete({
+			passed: false,
+			failure: error
+		});
+		throw error;
+	}
+	if (options.expectLabels !== void 0) {
+		const failures = getLabelExpectationFailures(options.expectLabels, finalCoverage);
+		if (failures.length !== 0) {
+			const error = /* @__PURE__ */ new Error(`Property label expectations were not met:\n${failures.map((failure) => `  - ${failure}`).join("\n")}`);
+			error.name = "PropertyLabelExpectationError";
+			error.coverage = finalCoverage;
+			yield* complete({
+				passed: false,
+				failure: error
+			});
+			throw error;
+		}
+	}
+	if (typeof options.statistics === "function") {
+		const deliverReport = options.statistics;
+		const delivery = yield* Effect.promise(() => Promise.resolve().then(() => deliverReport(formatTestStatistics(finalCoverage))).then(() => ({ failed: false }), (error) => ({
+			failed: true,
+			error
+		})));
+		if (delivery.failed) {
+			yield* complete({
+				passed: false,
+				failure: delivery.error
+			});
+			throw delivery.error;
+		}
+	} else if (options.statistics === true) logTestStatistics(finalCoverage);
+	yield* complete({ passed: true });
+	return { coverage: finalCoverage };
+});
+/**
+* Runs generated event and command sequences against the model, and the
+* system under test when one is given, checking every oracle on every stable
+* step. Resolves with the campaign's coverage and throws a
+* {@link ModelTestFailure} on the first failure. Requires an `adapter`;
+* `@xstate/test` exports a version with fast-check built in.
+* @experimental
+*/
+const propertyTest$1 = dual(2, function propertyTest(source, options) {
+	return Effect.runPromise(propertyTestProgram(source, options));
+});
+/**
+* Replaying an `advance` command in pure mode (no executed actor, no SUT
+* clock) only records the command: the events the original run's clock
+* delivered are replayed from the `event` entries that follow it, each marked
+* `origin: 'clock'`. This asserts the fixture still carries those entries in
+* order, so a hand-edited or re-serialized fixture cannot silently drop the
+* delivered events and replay a different timeline.
+*
+* Only a prefix check: a run that failed part-way through a delivery batch
+* legitimately records fewer clock entries than `deliveredEvents`.
+*/
+function assertReplayFixtureClockEvents(fixture) {
+	const timeline = normalizeFixtureTimeline(fixture);
+	for (let index = 0; index < timeline.length; index++) {
+		const entry = timeline[index];
+		if (entry === void 0) continue;
+		const command = entry.command;
+		if (command.type !== "advance" || command.deliveredEvents === void 0 || command.deliveredEvents.length === 0) continue;
+		for (let offset = 0; offset < command.deliveredEvents.length; offset++) {
+			const next = timeline[index + 1 + offset]?.command;
+			if (next === void 0) break;
+			if (next.type !== "event" || next.origin !== "clock") throw new Error(`Property replay fixture is inconsistent: the \`advance\` command at entry ${index} recorded ${command.deliveredEvents.length} delivered event(s), but entry ${index + 1 + offset} is not a clock-delivered event`);
+			if (!defaultEquivalent(next.event, command.deliveredEvents[offset])) throw new Error(`Property replay fixture is inconsistent: the \`advance\` command at entry ${index} recorded ${JSON.stringify(command.deliveredEvents[offset])} as delivered event ${offset}, but entry ${index + 1 + offset} replays ${JSON.stringify(next.event)}`);
+		}
+	}
+}
+function normalizeFixtureTimeline(fixture) {
+	if (fixture.formatVersion === 2) return fixture.timeline;
+	return [...fixture.prefixEvents.map((event) => ({
+		kind: "event",
+		command: {
+			type: "event",
+			event,
+			phase: "prefix",
+			origin: "frontier"
+		}
+	})), ...fixture.events.map((event) => ({
+		kind: "event",
+		command: {
+			type: "event",
+			event,
+			phase: "generated",
+			origin: "generator"
+		}
+	}))];
+}
+/**
+* Thrown by `replayTest()` when a fixture recorded from a failing run
+* replays without reproducing that failure — the regression is fixed, or the
+* machine no longer behaves the way the fixture recorded.
+* @experimental
+*/
+const ReplayNotReproducedErrorBase = Data.TaggedError("@systemfsoftware/xstate-test/engine/propertyTest/ReplayNotReproducedError");
+var ReplayNotReproducedError = class extends ReplayNotReproducedErrorBase {
+	step;
+	name = "ReplayNotReproducedError";
+	constructor(step) {
+		super({ message: `Property replay did not reproduce the recorded failure at step ${step}` });
+		this.step = step;
+	}
+};
+/** The replay behind {@link replayTest}, as one Effect run per call. */
+const replayTestProgram = (source, fixture, options) => Effect.gen(function* () {
+	const mode = options.mode ?? (fixture.formatVersion === 2 ? fixture.mode : void 0) ?? "pure";
+	const recordedOutcomes = fixture.formatVersion === 2 ? fromPortableValue(fixture.outcomes ?? []) : [];
+	const outcomeRegistry = new PropertyOutcomeRegistry();
+	const commandedSrcs = new Set(normalizeFixtureTimeline(fixture).flatMap((entry) => entry.command.type === "outcome" ? [entry.command.src] : []));
+	const seededOutcomes = recordedOutcomes.filter((record) => !commandedSrcs.has(record.src));
+	const providedActors = { ...options.actors };
+	const stubbedSources = [.../* @__PURE__ */ new Set([...fixture.formatVersion === 2 ? fixture.stubs ?? [] : [], ...recordedOutcomes.map((record) => record.src)])];
+	if (mode === "executed") for (const src of stubbedSources) providedActors[src] ??= createOutcomeStub(src, outcomeRegistry);
+	const logic = Object.keys(providedActors).length !== 0 ? provideActors(source, providedActors) : source;
+	const identity = logic;
+	if (fixture.machine?.id !== void 0 && fixture.machine.id.length > 0 && fixture.machine.id !== identity.id) throw new Error(`Property replay fixture targets machine "${fixture.machine.id}", received "${identity.id ?? "(anonymous)"}"`);
+	if (fixture.machine?.version !== void 0 && fixture.machine.version.length > 0 && fixture.machine.version !== identity.version) throw new Error(`Property replay fixture targets machine version "${fixture.machine.version}", received "${identity.version ?? "(unversioned)"}"`);
+	const startingSnapshot = fixture.start.type === "snapshot" ? options.restoreSnapshot?.(fixture.start.snapshot) : void 0;
+	if (fixture.start.type === "snapshot" && startingSnapshot === void 0) throw new Error("Property replay fixture contains a snapshot but no restoreSnapshot function was provided");
+	const coverage = createTestCoverage(logic);
+	coverage.runs = 1;
+	const serializedStartingSnapshot = fixture.start.type === "snapshot" ? fixture.start.snapshot : void 0;
+	const runner = new PropertyScenarioRunner(logic, fixture.start.type === "input" ? fixture.start.input : void 0, startingSnapshot, fixture.start.type === "snapshot" ? () => serializedStartingSnapshot : void 0, [], void 0, options.sut, options.states, options.reference, options.invariant, options.temporal ?? [], /* @__PURE__ */ new Map(), coverage, mode === "executed" ? {
+		mode,
+		registry: outcomeRegistry,
+		seededOutcomes,
+		stubbedSources
+	} : void 0);
+	runner.setFormatSnapshot(options.formatSnapshot);
+	const failedAt = fixture.failedAt;
+	const timeline = Effect.gen(function* () {
+		yield* Effect.promise(() => runner.start());
+		assertReplayFixtureClockEvents(fixture);
+		for (const entry of normalizeFixtureTimeline(fixture)) {
+			const command = fromPortableValue(entry.command);
+			yield* Effect.promise(() => runner.replay(command));
+			if (failedAt !== void 0 && runner.getStableStep() > failedAt) break;
+		}
+		runner.finish();
+		if (options.expect === "pass") return runner.getTrace();
+		throw new ReplayNotReproducedError(failedAt ?? runner.getStableStep());
+	});
+	return yield* ensuringFinalizerWins(timeline, Effect.promise(() => runner.dispose()));
+});
+/**
+* Replays a {@link TestFixture} without a generator. Resolves with the
+* replayed trace; see the `expect` option for how failures are reported.
+* @experimental
+*/
+const replayTest = dual(3, function replayTest(source, fixture, options) {
+	return Effect.runPromise(replayTestProgram(source, fixture, options));
+});
+function serializeSnapshot$1(snapshot) {
+	return "toJSON" in snapshot && typeof snapshot.toJSON === "function" ? snapshot.toJSON() : snapshot;
+}
+/**
+* Converts a trace to JSON-safe data, calling `toJSON()` on snapshots.
+*
+* @experimental
+*/
+function serializeTestTrace(trace) {
+	return {
+		start: trace.start.type === "snapshot" ? {
+			type: "snapshot",
+			snapshot: serializeSnapshot$1(trace.start.snapshot)
+		} : trace.start,
+		initialSnapshot: serializeSnapshot$1(trace.initialSnapshot),
+		initialTransitionIds: trace.initialTransitionIds,
+		timeline: trace.timeline.map((entry) => ({
+			kind: entry.kind,
+			index: entry.index,
+			previousSnapshot: serializeSnapshot$1(entry.previousSnapshot),
+			snapshot: serializeSnapshot$1(entry.snapshot),
+			effects: entry.effects,
+			transitionIds: entry.transitionIds,
+			...entry.kind === "actorEvent" ? {
+				source: entry.source,
+				actorId: entry.actorId,
+				event: entry.event
+			} : {
+				command: entry.command,
+				observation: entry.observation,
+				...entry.kind === "event" ? { activeStateIds: entry.activeStateIds } : {}
+			}
+		})),
+		finalSnapshot: serializeSnapshot$1(trace.finalSnapshot),
+		finalObservation: trace.finalObservation
+	};
+}
+/**
+* The default failure-trace projection: `{ value, context }` for machine
+* snapshots, plus `status`, `output`, `error`, and `tags` when they carry
+* information. Other snapshots are printed without their runtime bookkeeping.
+* @experimental
+*/
+function defaultFormatSnapshot(snapshot) {
+	const json = serializeSnapshot$1(snapshot);
+	if (json === void 0 || typeof json !== "object") return json;
+	const { value, context, status, output, error, tags, _nextTimerId: _timerId, timers: _timers, children: _children, historyValue: _historyValue, sessionId: _sessionId, ...rest } = json;
+	const hasValue = "value" in json;
+	const projected = hasValue ? {
+		value,
+		context
+	} : {
+		...rest,
+		...context === void 0 ? {} : { context }
+	};
+	if (hasValue) {
+		if (status !== void 0 && status !== "active") projected["status"] = status;
+	} else if (status !== void 0) projected["status"] = status;
+	if (output !== void 0) projected["output"] = output;
+	if (error !== void 0) projected["error"] = error;
+	if (Array.isArray(tags) ? tags.length > 0 : tags !== void 0) projected["tags"] = tags;
+	return projected;
+}
+function stringifyForTrace(value) {
+	try {
+		const json = JSON.stringify(value, (_key, nested) => nested instanceof Error ? {
+			name: nested.name,
+			message: nested.message
+		} : typeof nested === "bigint" ? `${nested}n` : nested);
+		return json === void 0 ? String(value) : json;
+	} catch {
+		return String(value);
+	}
+}
+function formatEventForTrace(event) {
+	const { type, sessionId: _sessionId, ...payload } = event;
+	if (type === "xstate.timer" && typeof payload["id"] === "string") return payload["id"];
+	return Object.keys(payload).length !== 0 ? `${type} ${stringifyForTrace(payload)}` : type;
+}
+function getEventOrigin(event, fallback) {
+	if (event.type === "xstate.after" || event.type === "xstate.timer" || event.type.startsWith("xstate.after.")) return "timer";
+	if (event.type === "xstate.done.actor" || event.type === "xstate.error.actor" || event.type.startsWith("xstate.done.actor.") || event.type.startsWith("xstate.error.actor.")) return "outcome";
+	return fallback;
+}
+/**
+* Renders a trace as the human-readable text used in failure messages: one
+* line per step, `N. <origin> <event> -> <state>`, where `<state>` is the
+* snapshot projected through `formatSnapshot`. In executed mode, the events
+* the tested actor then processed on its own follow their step as `↳` lines;
+* child actors' own transitions are left out.
+* @experimental
+*/
+const formatTestTrace = dual((args) => args.length >= 2 || typeof args[0] === "object" && args[0] !== null && "timeline" in args[0], function formatTestTrace(trace, options = {}) {
+	const format = (snapshot) => stringifyForTrace((options.formatSnapshot ?? defaultFormatSnapshot)(snapshot));
+	const lines = [`start ${format(trace.initialSnapshot)}`];
+	const pushObservation = (observation) => {
+		for (const [name, compared] of [["reference", observation?.reference], ["sut", observation?.sut]]) {
+			if (compared === void 0 || defaultEquivalent(compared.model, compared.observed)) continue;
+			lines.push(`   ${name} diverged`, `     model:    ${stringifyForTrace(compared.model)}`, `     observed: ${stringifyForTrace(compared.observed)}`);
+		}
+	};
+	let step = 0;
+	for (const entry of trace.timeline) {
+		if (entry.kind === "actorEvent") {
+			if (entry.source === "root") lines.push(`   ↳ ${getEventOrigin(entry.event, "actor")} ${formatEventForTrace(entry.event)} -> ${format(entry.snapshot)}`);
+			continue;
+		}
+		step++;
+		if (entry.kind === "event") {
+			const { command } = entry;
+			const origin = getEventOrigin(command.event, command.origin === "frontier" ? "prefix" : command.origin);
+			lines.push(`${step}. ${origin} ${formatEventForTrace(command.event)} -> ${format(entry.snapshot)}`);
+		} else {
+			const { command } = entry;
+			switch (command.type) {
+				case "advance":
+					lines.push(`${step}. timer advance ${command.milliseconds}ms -> ${format(entry.snapshot)}`);
+					break;
+				case "outcome":
+					lines.push(`${step}. outcome ${command.src} ${stringifyForTrace(command.outcome)} -> ${format(entry.snapshot)}`);
+					break;
+				case "checkpoint":
+					lines.push(`${step}. checkpoint${command.label === void 0 ? "" : ` ${command.label}`}`);
+					break;
+				default: lines.push(`${step}. stop -> ${format(entry.snapshot)}`);
+			}
+		}
+		if (entry.pendingActors !== void 0 && entry.pendingActors.length !== 0) lines.push(`   pending actors: ${entry.pendingActors.join(", ")}`);
+		pushObservation(entry.observation);
+	}
+	return lines.join("\n");
+});
+/**
+* The `stateMatcher` for models built from bare logic: `'*'` matches every
+* snapshot; on a state machine snapshot, `'#id'` matches when the state node
+* with that id is active and any other key matches through
+* `snapshot.matches(key)`. Node ids are compared rather than node objects, so
+* snapshots of a `machine.provide()`d copy match too.
+*/
+function matchesStateKey(snapshot, stateKey) {
+	if (stateKey === "*") return true;
+	const machineSnapshot = snapshot;
+	if (stateKey.startsWith("#")) {
+		const id = stateKey.slice(1);
+		return machineSnapshot.nodes?.some((node) => node.id === id) ?? false;
+	}
+	if (typeof machineSnapshot.matches !== "function") return false;
+	try {
+		return machineSnapshot.matches(stateKey);
+	} catch {
+		return false;
+	}
+}
+// src/engine/suite.ts
+/** The transition and state node ids a single trace exercised. */
+function getTraceElements(trace) {
+	const elements = /* @__PURE__ */ new Set();
+	for (const id of trace.initialTransitionIds) elements.add(`transition:${id}`);
+	for (const entry of trace.timeline) {
+		for (const id of entry.transitionIds) elements.add(`transition:${id}`);
+		if (entry.kind === "event") for (const id of entry.activeStateIds) elements.add(`stateNode:${id}`);
+	}
+	return [...elements].sort();
+}
+/** A stable identity for a fixture's start and timeline, used to drop duplicates. */
+function fixtureKey(fixture) {
+	return JSON.stringify([fixture.start, fixture.timeline]);
+}
+function toSuiteFixture(trace, machine, serializeStartingSnapshot) {
+	if (trace.start.type === "snapshot" && serializeStartingSnapshot === void 0) throw new Error("Property suites starting from a snapshot require start.serializeSnapshot");
+	return {
+		formatVersion: 2,
+		machine,
+		start: trace.start.type === "snapshot" ? {
+			type: "snapshot",
+			snapshot: serializeStartingSnapshot(trace.start.snapshot)
+		} : trace.start,
+		timeline: trace.timeline.flatMap((entry) => entry.kind === "event" || entry.kind === "command" ? [{
+			kind: entry.kind,
+			command: entry.command
+		}] : []),
+		...trace.swarm !== void 0 ? { swarm: trace.swarm } : {},
+		...trace.mode !== void 0 ? { mode: trace.mode } : {},
+		...trace.outcomes !== void 0 ? { outcomes: trace.outcomes } : {}
+	};
+}
+/** Greedy maximum-coverage selection with deterministic tie-breaking. */
+function selectFixtures(candidates, maxFixtures) {
+	const covered = /* @__PURE__ */ new Set();
+	const remaining = candidates.slice();
+	const selected = [];
+	const limit = maxFixtures ?? Infinity;
+	while (remaining.length !== 0 && selected.length < limit) {
+		let bestIndex = -1;
+		let bestGain = 0;
+		for (let index = 0; index < remaining.length; index++) {
+			const candidate = remaining[index];
+			if (candidate === void 0) continue;
+			const gain = candidate.elements.filter((element) => !covered.has(element)).length;
+			if (gain > bestGain) {
+				bestGain = gain;
+				bestIndex = index;
+			}
+		}
+		if (bestIndex === -1) break;
+		const [candidate] = remaining.splice(bestIndex, 1);
+		if (candidate === void 0) break;
+		selected.push(candidate);
+		for (const element of candidate.elements) covered.add(element);
+	}
+	return selected.sort((left, right) => left.key < right.key ? -1 : 1).map((candidate) => candidate.fixture);
+}
+/**
+* Runs a `propertyTest()` campaign and exports the traces it explored as an
+* offline suite.
+*
+* Only passing runs are recorded: a campaign that finds a counterexample
+* throws, as `propertyTest()` does.
+* @experimental
+*/
+const generateTestSuite$1 = dual(2, function generateTestSuite(source, options) {
+	return Effect.runPromise(Effect.gen(function* () {
+		const traces = [];
+		const { select, maxFixtures, generatedAt, collect, ...rest } = options;
+		const { coverage } = yield* Effect.promise(() => propertyTest$1(source, {
+			...rest,
+			collect: (trace, info) => {
+				collect?.(trace, info);
+				if (info.passed) traces.push(trace);
+			}
+		}));
+		const logic = source;
+		const machine = logic.id !== void 0 && logic.id.length > 0 || logic.version !== void 0 && logic.version.length > 0 ? {
+			id: logic.id,
+			version: logic.version
+		} : void 0;
+		const serializeStartingSnapshot = options.start?.serializeSnapshot;
+		const seen = /* @__PURE__ */ new Set();
+		const candidates = [];
+		for (const trace of traces) {
+			const fixture = toSuiteFixture(trace, machine, serializeStartingSnapshot);
+			const key = fixtureKey(fixture);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			candidates.push({
+				fixture,
+				elements: getTraceElements(trace),
+				key,
+				length: fixture.timeline.length
+			});
+		}
+		candidates.sort((left, right) => left.length - right.length || (left.key < right.key ? -1 : 1));
+		const fixtures = (select ?? "minimal") === "all" ? candidates.slice(0, maxFixtures ?? candidates.length).map((candidate) => candidate.fixture) : selectFixtures(candidates, maxFixtures);
+		return {
+			formatVersion: 1,
+			machineId: machine?.id,
+			machineVersion: machine?.version,
+			generatedAt,
+			fixtures,
+			coverage: testCoverageToJSON(coverage)
+		};
+	}));
+});
+/**
+* Replays one suite fixture. Resolves when the fixture still passes and
+* rejects with the underlying failure when it does not.
+* @experimental
+*/
+const replayTestSuiteFixture = dual(3, function replayTestSuiteFixture(source, fixture, options) {
+	return Effect.runPromise(Effect.promise(() => replayTest(source, fixture, {
+		...options,
+		expect: "pass"
+	})).pipe(Effect.asVoid));
+});
+/**
+* Replays every fixture in a suite. Each fixture is expected to pass.
+*
+* @experimental
+*/
+const replayTestSuite = dual(3, function replayTestSuite(source, suite, options) {
+	return Effect.runPromise(Effect.gen(function* () {
+		const passed = yield* Ref.make(0);
+		const failed = [];
+		for (const [index, fixture] of suite.fixtures.entries()) {
+			const exit = yield* Effect.exit(Effect.promise(() => replayTestSuiteFixture(source, fixture, options)));
+			if (Exit.isFailure(exit)) failed.push({
+				fixture,
+				index,
+				title: formatTestSuiteFixtureTitle(fixture, index),
+				error: Cause.squash(exit.cause)
+			});
+			else yield* Ref.update(passed, (value) => value + 1);
+		}
+		return {
+			passed: yield* Ref.get(passed),
+			failed
+		};
+	}));
+});
+/**
+* A stable, human-readable one-line title for a fixture.
+*
+* @experimental
+*/
+const formatTestSuiteFixtureTitle = dual(2, function formatTestSuiteFixtureTitle(fixture, index) {
+	const steps = fixture.timeline.map((entry) => {
+		const command = entry.command;
+		switch (command.type) {
+			case "event": return command.event.type;
+			case "advance": return `@advance(${command.milliseconds})`;
+			case "checkpoint": return "@checkpoint";
+			case "outcome": return `@outcome(${command.src})`;
+			default: return "@stop";
+		}
+	});
+	return `fixture ${index + 1}: ${steps.join(" -> ") || "(no events)"}`;
+});
+/**
+* Registers one test per suite fixture with a vitest/jest-compatible
+* `it`/`describe` pair.
+* @experimental
+*/
+const describeTestSuite = dual(3, function describeTestSuite(suite, source, options) {
+	const globals = globalThis;
+	const it = options.it ?? globals.it;
+	if (it === void 0) throw new Error("describeTestSuite() requires an `it` function when none is global");
+	const register = () => {
+		suite.fixtures.forEach((fixture, index) => {
+			it(formatTestSuiteFixtureTitle(fixture, index), () => replayTestSuiteFixture(source, fixture, options));
+		});
+	};
+	const describe = options.describe ?? globals.describe;
+	const name = options.name ?? `property suite${suite.machineId !== void 0 && suite.machineId.length > 0 ? ` (${suite.machineId})` : ""}`;
+	if (describe !== void 0) {
+		describe(name, register);
+		return;
+	}
+	register();
+});
+/**
+* Serializes a suite with stable key ordering.
+*
+* @experimental
+*/
+function serializeTestSuite(suite) {
+	return JSON.stringify({
+		formatVersion: suite.formatVersion,
+		machineId: suite.machineId,
+		machineVersion: suite.machineVersion,
+		generatedAt: suite.generatedAt,
+		fixtures: suite.fixtures,
+		coverage: suite.coverage
+	}, null, 2);
+}
+/**
+* Parses a serialized suite, rejecting unknown format versions.
+*
+* @experimental
+*/
+function parseTestSuite(json) {
+	const parsed = JSON.parse(json);
+	if (parsed === null || typeof parsed !== "object") throw new Error("Property suite JSON must be an object");
+	if (parsed.formatVersion !== 1) throw new Error(`Unsupported property suite format version: ${String(parsed.formatVersion)}`);
+	if (!Array.isArray(parsed.fixtures)) throw new Error("Property suite JSON must contain a `fixtures` array");
+	return parsed;
+}
+// src/engine/deduplicatePaths.ts
+/**
+* Deduplicates your paths so that A -> B is not executed separately to A -> B
+* -> C
+*
+* Paths are returned longest first (stable for equal lengths). A path is
+* dropped when its event sequence is a prefix of, or equal to, the event
+* sequence of a path already kept.
+*/
+const deduplicatePaths = dual((args) => args.length >= 2 || Array.isArray(args[0]), (paths, serializeEvent = simpleStringify) => {
+	const pathsWithEventSequence = paths.map((path) => ({
+		path,
+		eventSequence: path.steps.map((step) => serializeEvent(step.event))
+	}));
+	pathsWithEventSequence.sort((a, z) => z.path.steps.length - a.path.steps.length);
+	const root = { children: /* @__PURE__ */ new Map() };
+	const kept = [];
+	for (const { path, eventSequence } of pathsWithEventSequence) {
+		let node = root;
+		for (const event of eventSequence) {
+			node = node.children.get(event);
+			if (node === void 0) break;
+		}
+		if (node !== void 0 && kept.length > 0) continue;
+		let insertAt = root;
+		for (const event of eventSequence) {
+			let child = insertAt.children.get(event);
+			if (child === void 0) {
+				child = { children: /* @__PURE__ */ new Map() };
+				insertAt.children.set(event, child);
+			}
+			insertAt = child;
+		}
+		kept.push(path);
+	}
+	return kept;
+});
+// src/engine/testPaths.ts
+const DEFAULT_SAMPLES = 3;
+/** Default traversal bound; see {@link PathOptions.limit}. */
+const DEFAULT_TRAVERSAL_LIMIT = 1e4;
+/** Lifts a possibly-async value into an Effect, preserving the rejection's identity. */
+const awaited$3 = (value) => Effect.promise(() => Promise.resolve(value));
+/** Internal event types path generation drives explicitly. */
+const DONE_ACTOR_EVENT = "xstate.done.actor";
+const ERROR_ACTOR_EVENT = "xstate.error.actor";
+const AFTER_EVENT = "xstate.after";
+const DONE_STATE_EVENT = "xstate.done.state";
+/**
+* The internal events traversal offers. The other internal events (state and
+* invoke timeouts, actor snapshots) are left out: nothing here can drive them
+* in executed mode, and a path that assumed one would desynchronize.
+*/
+const TRAVERSED_INTERNAL_EVENTS = /* @__PURE__ */ new Set([
+	DONE_ACTOR_EVENT,
+	ERROR_ACTOR_EVENT,
+	AFTER_EVENT
+]);
+/** Internal events are the machine's own; only user events have declared cases. */
+function isInternalEventType(type) {
+	return type.startsWith("xstate.");
+}
+function assertGeneratedOutcome(value, src) {
+	if (value === void 0 || value === null || typeof value !== "object" || typeof value.ok !== "boolean") throw new Error(`The \`outcomes\` generator for "${src}" produced ${JSON.stringify(value)} instead of an actor outcome. Generate \`{ ok: true, output }\` or \`{ ok: false, error }\`.`);
+}
+/**
+* Samples concrete actor outcomes from `outcomes`, the same way event payloads
+* are sampled from `events`, so traversal can label each `xstate.done.actor` /
+* `xstate.error.actor` step with the outcome that produced it.
+*/
+function sampleTestOutcomes(outcomes, samples, seed) {
+	const sampled = /* @__PURE__ */ new Map();
+	for (const [src, configured] of Object.entries(outcomes ?? {})) {
+		const generator = isEventDescriptorObject(configured) ? configured.generate : configured;
+		if (generator === void 0) continue;
+		const rng = createSeededRng(deriveCaseSeed(seed, `outcome:${src}`));
+		const values = sampleGenerator(generator, rng, samples);
+		for (const value of values) assertGeneratedOutcome(value, src);
+		sampled.set(src, values);
+	}
+	return sampled;
+}
+const LEGACY_EVENT_EXECUTOR_MESSAGE = "A pre-2.0 event executor was passed as an event generator. `events` now declares how event *payloads* are generated; the functions that drive the system under test belong in `sut`. Write the `sut` directly.";
+/**
+* A `generate` value without a `resolve` must produce the event payload, so a
+* sample that is not a plain object is a pre-2.0 executor called with the PRNG
+* rather than a generator.
+*/
+function assertGeneratedPayload(value, type) {
+	if (value === void 0) return;
+	if (!(typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.then !== "function")) throw new Error(`Event "${type}" generated ${typeof value === "object" ? "a non-payload value" : `a ${typeof value}`} instead of an event payload object. ${LEGACY_EVENT_EXECUTOR_MESSAGE}`);
+}
+/**
+* Whether the options have the pre-2.0 `TestParam` shape: `events` and
+* `states` both maps of functions, and no `sut`. The unified API allows that
+* shape too (bare `(rng) => payload` generators plus top-level `states`), so
+* it only decides how a generator that does not produce a payload is
+* reported, never whether the options are rejected up front.
+*/
+function hasTestParamShape(options) {
+	const isFunctionMap = (value) => {
+		if (value === null || typeof value !== "object") return false;
+		const entries = Object.values(value);
+		return entries.length > 0 && entries.every((entry) => typeof entry === "function");
+	};
+	return options.sut === void 0 && isFunctionMap(options.events) && isFunctionMap(options.states);
+}
+/**
+* Expands an event type into the concrete events traversal should offer,
+* applying each declared case's `generate`, `resolve`, and `when`.
+*/
+function createEventExpander(cases, samples, seed, caseIds, testParamShaped) {
+	const drawn = /* @__PURE__ */ new Map();
+	const byType = /* @__PURE__ */ new Map();
+	for (const eventCase of cases) {
+		if (eventCase.generator !== void 0) {
+			const rng = createSeededRng(deriveCaseSeed(seed, eventCase.caseId));
+			const legacyCandidate = testParamShaped && typeof eventCase.generator === "function" && eventCase.descriptor.resolve === void 0;
+			let values;
+			try {
+				values = sampleGenerator(eventCase.generator, rng, samples);
+			} catch (cause) {
+				if (legacyCandidate) throw new Error(`Event "${eventCase.type}" threw when called as a payload generator. ${LEGACY_EVENT_EXECUTOR_MESSAGE}`, { cause });
+				throw cause;
+			}
+			if (eventCase.descriptor.resolve === void 0) for (const value of values) {
+				if (legacyCandidate && typeof value?.then === "function") value.then(void 0, () => {});
+				if (legacyCandidate && value === void 0) throw new Error(`Event "${eventCase.type}" generated \`undefined\` instead of an event payload object. ${LEGACY_EVENT_EXECUTOR_MESSAGE}`);
+				assertGeneratedPayload(value, eventCase.type);
+			}
+			drawn.set(eventCase.caseId, values);
+		}
+		const list = byType.get(eventCase.type) ?? [];
+		list.push(eventCase);
+		byType.set(eventCase.type, list);
+	}
+	return {
+		/** The event types `events` declares, whether or not the machine owns them. */
+		declaredTypes: [...byType.keys()],
+		expand(snapshot, template) {
+			const configured = byType.get(template.type);
+			if (configured === void 0) return [template];
+			const expanded = [];
+			for (const eventCase of configured) {
+				const descriptor = eventCase.descriptor;
+				const generated = drawn.get(eventCase.caseId) ?? [void 0];
+				for (const value of generated) {
+					const payload = descriptor.resolve !== void 0 ? descriptor.resolve({
+						snapshot,
+						generated: value
+					}) : value;
+					if (descriptor.resolve !== void 0 && payload === void 0) continue;
+					const event = {
+						...template,
+						...payload ?? {},
+						type: template.type
+					};
+					if (descriptor.when !== void 0 && !descriptor.when({
+						snapshot,
+						event
+					})) continue;
+					caseIds.set(event, eventCase.caseId);
+					expanded.push(event);
+				}
+			}
+			return expanded;
+		}
+	};
+}
+function formatEventForPath(event) {
+	const { type, ...payload } = event;
+	return Object.keys(payload).length !== 0 ? `${type} ${JSON.stringify(payload)}` : type;
+}
+/** A short, human-readable name for a path: its event types, in order. */
+function describePath(path) {
+	const described = path.description;
+	if (typeof described === "string" && described.length > 0) return described;
+	const events = path.steps.map((step) => step.event.type).filter((type) => type !== XSTATE_INIT);
+	return events.length !== 0 ? events.join(" → ") : "initial state";
+}
+/**
+* An adapter that executes a fixed list of paths instead of generating
+* command sequences. One path is one run; there is no shrinking.
+*
+* After every step the run's snapshot is compared with the snapshot the
+* traversal planned for that step, so a run that departs from its path fails
+* instead of passing on a different path.
+*/
+function createPathAdapter(paths, caseIds, results, plan) {
+	return { run(request) {
+		return Effect.runPromise(Effect.gen(function* () {
+			const runs = yield* Ref.make(0);
+			const error = yield* Ref.make(void 0);
+			const maximumSequenceLength = yield* Ref.make(0);
+			for (const path of paths) {
+				const steps = path.steps.filter((step) => step.event.type !== XSTATE_INIT);
+				yield* Ref.update(maximumSequenceLength, (value) => Math.max(value, steps.length));
+				const runner = request.createRunner();
+				const pathError = yield* Ref.make(void 0);
+				const runPath = Effect.gen(function* () {
+					yield* awaited$3(runner.start());
+					for (const [index, step] of steps.entries()) {
+						const event = step.event;
+						const diverge = (reason) => runner.diverge(`Path diverged at step ${index + 1}: ${reason}`, {
+							expected: step.state,
+							actual: runner.getSnapshot()
+						});
+						const describeStatus = () => `the model is ${plan.format(runner.getSnapshot())}`;
+						if (plan.mode === "executed") {
+							const resolved = plan.outcomeByEvent.get(event);
+							if (resolved !== void 0) {
+								if (!runner.canRunOutcome()) diverge(`${formatEventForPath(event)} could not be resolved: ${describeStatus()}`);
+								yield* awaited$3(runner.outcome(resolved.src, resolved.outcome));
+							} else if (event.type === AFTER_EVENT) yield* awaited$3(runner.advance(runner.getAfterTimerRemaining(event) ?? diverge(`no timer is pending for ${formatEventForPath(event)}: ${describeStatus()}`)));
+							else if (event.type === DONE_STATE_EVENT) continue;
+							if (resolved !== void 0 || event.type === AFTER_EVENT) {
+								if (plan.serialize(runner.getSnapshot()) !== plan.serialize(step.state)) diverge(`expected ${plan.format(step.state)}, got ${plan.format(runner.getSnapshot())}`);
+								continue;
+							}
+						}
+						const caseId = caseIds.get(event) ?? getPropertyEventCaseId(event.type, "default");
+						if (!runner.canRun(event, caseId)) diverge(`${formatEventForPath(event)} could not be sent: ${describeStatus()}`);
+						yield* awaited$3(runner.run(event, caseId));
+						if (plan.serialize(runner.getSnapshot()) !== plan.serialize(step.state)) diverge(`expected ${plan.format(step.state)}, got ${plan.format(runner.getSnapshot())}`);
+					}
+					runner.finish();
+				});
+				const pathExit = yield* Effect.exit(runPath);
+				if (Exit.isFailure(pathExit)) yield* Ref.set(pathError, squash(pathExit.cause));
+				const disposeExit = yield* Effect.exit(awaited$3(runner.dispose()));
+				const bodyError = yield* Ref.get(pathError);
+				if (Exit.isFailure(disposeExit) && (bodyError === void 0 || bodyError === null)) yield* Ref.set(pathError, squash(disposeExit.cause));
+				yield* Ref.update(runs, (value) => value + 1);
+				const failure = yield* Ref.get(pathError);
+				results.push({
+					path,
+					passed: failure === void 0 || failure === null,
+					error: failure
+				});
+				if (failure !== void 0 && failure !== null) {
+					yield* Ref.set(error, failure);
+					break;
+				}
+			}
+			const runCount = yield* Ref.get(runs);
+			const runError = yield* Ref.get(error);
+			const truncated = runError !== void 0 && runCount < paths.length;
+			const maxSequenceLength = yield* Ref.get(maximumSequenceLength);
+			return {
+				runs: runCount,
+				exploration: {
+					configuredRuns: paths.length,
+					maximumSequenceLength: maxSequenceLength,
+					engine: "paths",
+					truncated,
+					truncationReasons: truncated ? ["counterexample found before every path ran"] : []
+				},
+				...runError === void 0 ? {} : { error: runError }
+			};
+		}));
+	} };
+}
+function withPathExploration(coverage, pathCount, pathGenerator) {
+	const truncationReasons = coverage.exploration.truncationReasons.filter((reason) => reason !== "maximum sequence length reached");
+	return {
+		...coverage,
+		exploration: {
+			...coverage.exploration,
+			strategy: "paths",
+			pathCount,
+			pathGenerator,
+			stoppedBecause: coverage.exploration.stoppedBecause === "failure" || coverage.exploration.stoppedBecause === "replay" ? coverage.exploration.stoppedBecause : "paths",
+			truncated: truncationReasons.length > 0,
+			truncationReasons
+		}
+	};
+}
+const AFTER_TIMER_PREFIX = "xstate.after.";
+/**
+* Executes model paths against a system under test.
+*
+* `testPaths()` and `propertyTest()` share their `events`, `sut`, `states`,
+* `invariant`, `temporal`, and `reference` options and produce the same
+* coverage object and the same failure type. They differ only in how the event
+* sequences are produced: traversal of the model's state graph here, generated
+* command sequences there.
+* @experimental
+*/
+const testPaths$1 = dual((args) => args.length >= 2 || typeof args[0] === "object" && args[0] !== null && "transition" in args[0], function testPaths(source, options = {}) {
+	return Effect.runPromise(Effect.suspend(() => {
+		if (options["commands"] !== void 0) throw new Error("`commands` is not supported by path generation; use `propertyTest()`. Paths decide their own `advance` and `outcome` commands from the internal events the traversal took.");
+		const samples = options.samples ?? DEFAULT_SAMPLES;
+		if (!Number.isInteger(samples) || samples < 1) throw new Error(`\`samples\` must be an integer of at least 1 (received ${String(options.samples)}).`);
+		const baseLogic = source;
+		const outcomeSources = Object.keys(options.outcomes ?? {});
+		const testLogic = outcomeSources.length !== 0 ? provideActors(baseLogic, Object.fromEntries(outcomeSources.map((src) => [src, createOutcomeStub(src, void 0)]))) : baseLogic;
+		const { cases } = normalizeEventDescriptors(options.events ?? {});
+		const caseIds = /* @__PURE__ */ new WeakMap();
+		const expander = createEventExpander(cases, samples, options.seed ?? 0, caseIds, hasTestParamShape(options));
+		const mode = options.mode ?? "pure";
+		const sampledOutcomes = sampleTestOutcomes(options.outcomes, samples, options.seed ?? 0);
+		/** Invoke `id` to invoke `src`, collected from the state nodes as seen. */
+		const invokeSrcById = /* @__PURE__ */ new Map();
+		const outcomeByEvent = /* @__PURE__ */ new WeakMap();
+		/**
+		* Virtual time. Timers fire in due order, so a state offers only its
+		* earliest-due `after` transition, where "due" counts the time already
+		* spent in enclosing states along the path that reached it. Timer objects
+		* keep their identity across transitions that do not reschedule them.
+		*/
+		const virtualNow = /* @__PURE__ */ new WeakMap();
+		const timerScheduledAt = /* @__PURE__ */ new WeakMap();
+		const afterFiresAt = /* @__PURE__ */ new WeakMap();
+		/**
+		* Turns one synthesized internal event into the concrete events traversal
+		* should offer, and remembers what executed mode has to do to reach it.
+		*/
+		const expandInternalEvent = (event) => {
+			if (event.type === AFTER_EVENT) return [{ ...event }];
+			const ok = event.type === DONE_ACTOR_EVENT;
+			const src = invokeSrcById.get(event.actorId);
+			const matching = (src === void 0 ? void 0 : sampledOutcomes.get(src))?.filter((outcome) => outcome.ok === ok) ?? [];
+			return (matching.length !== 0 ? matching : [ok ? {
+				ok: true,
+				output: void 0
+			} : {
+				ok: false,
+				error: /* @__PURE__ */ new Error("generated failure")
+			}]).map((outcome) => {
+				const { sessionId: _sessionId, ...rest } = event;
+				const offered = {
+					...rest,
+					...outcome.ok ? { output: outcome.output } : { error: outcome.error }
+				};
+				if (src !== void 0) outcomeByEvent.set(offered, {
+					src,
+					outcome
+				});
+				return offered;
+			});
+		};
+		/** Keeps only the earliest-due `after` events, recording their due time. */
+		const selectDueAfterEvents = (snapshot, afterEvents) => {
+			if (afterEvents.length === 0) return [];
+			const now = virtualNow.get(snapshot) ?? 0;
+			const timers = snapshot.timers ?? {};
+			for (const timer of Object.values(timers)) if (timer !== void 0 && !timerScheduledAt.has(timer)) timerScheduledAt.set(timer, now);
+			const due = afterEvents.map((event) => {
+				const { delay, stateId } = event;
+				const timer = timers[`${AFTER_TIMER_PREFIX}${delay}.${stateId}`];
+				const milliseconds = typeof timer?.delay === "number" ? timer.delay : typeof delay === "number" ? delay : Infinity;
+				return (timer !== void 0 ? timerScheduledAt.get(timer) : now) + milliseconds;
+			});
+			const earliest = Math.min(...due);
+			return afterEvents.filter((event, index) => {
+				if (due[index] !== earliest) return false;
+				afterFiresAt.set(event, earliest);
+				return true;
+			});
+		};
+		const traversalEvents = (snapshot) => {
+			const types = new Set(expander.declaredTypes);
+			const internal = [];
+			const afterEvents = [];
+			if (typeof snapshot.nodes === "object") {
+				for (const stateNode of snapshot.nodes) for (const invokeDef of stateNode.invoke ?? []) invokeSrcById.set(invokeDef.id, invokeDef.src);
+				for (const event of getAllOwnEvents(snapshot)) {
+					const { type } = event;
+					if (!isInternalEventType(type)) types.add(type);
+					else if (TRAVERSED_INTERNAL_EVENTS.has(type)) (type === AFTER_EVENT ? afterEvents : internal).push(...expandInternalEvent(event));
+				}
+			}
+			return [
+				...[...types].map((type) => ({ type })).flatMap((template) => expander.expand(snapshot, template)),
+				...internal,
+				...selectDueAfterEvents(snapshot, afterEvents)
+			];
+		};
+		const limit = options.limit ?? DEFAULT_TRAVERSAL_LIMIT;
+		const identity = options.serializeState ?? (isMachineLogic(testLogic) ? serializeSnapshot : simpleStringify);
+		const traversalOptions = {
+			events: traversalEvents,
+			input: options.input,
+			limit,
+			...options.toState === void 0 ? {} : { toState: options.toState },
+			...options.fromState === void 0 ? {} : { fromState: options.fromState },
+			...options.stopWhen === void 0 ? {} : { stopWhen: options.stopWhen },
+			serializeState: (snapshot, event, previousSnapshot) => {
+				if (!virtualNow.has(snapshot)) {
+					const previousNow = previousSnapshot !== void 0 && previousSnapshot !== null ? virtualNow.get(previousSnapshot) ?? 0 : 0;
+					virtualNow.set(snapshot, event !== void 0 && event !== null ? afterFiresAt.get(event) ?? previousNow : previousNow);
+				}
+				return identity(snapshot, event, previousSnapshot);
+			},
+			...options.serializeEvent === void 0 ? {} : { serializeEvent: options.serializeEvent }
+		};
+		function generatePaths(generate) {
+			try {
+				return generate();
+			} catch (error) {
+				if (error instanceof Error && error.message === "Traversal limit exceeded") throw new Error(`Path generation exceeded \`limit\` (${limit} traversal steps) before it exhausted the model. A machine whose context grows without bound never runs out of states, because every distinct context is a distinct state. Pass \`serializeState\` to merge equivalent states, prune traversal with \`stopWhen\` or \`toState\`, or raise \`limit\`.`, { cause: error });
+				throw error;
+			}
+		}
+		let pathGeneratorKind = "shortest";
+		let paths;
+		if (options.paths !== void 0) {
+			pathGeneratorKind = "custom";
+			paths = options.paths;
+		} else if (options.fromEvents !== void 0) {
+			pathGeneratorKind = "events";
+			const { events: _traversalEvents, ...fromEventsOptions } = traversalOptions;
+			paths = generatePaths(() => getPathsFromEvents(testLogic, options.fromEvents, fromEventsOptions));
+		} else {
+			let generated;
+			if (typeof options.pathGenerator === "function") {
+				pathGeneratorKind = "custom";
+				const pathGenerator = options.pathGenerator;
+				generated = generatePaths(() => pathGenerator(testLogic, traversalOptions));
+			} else {
+				pathGeneratorKind = options.pathGenerator ?? "shortest";
+				generated = generatePaths(() => pathGeneratorKind === "simple" ? getSimplePaths(testLogic, traversalOptions) : getShortestPaths(testLogic, traversalOptions));
+			}
+			paths = options.allowDuplicatePaths !== void 0 ? generated : deduplicatePaths(generated);
+		}
+		const declaredTypes = new Set(cases.map((eventCase) => eventCase.type));
+		const extraEvents = {};
+		/** Invoke sources a path resolves, so executed mode can stub them. */
+		const stubbedSources = /* @__PURE__ */ new Set();
+		for (const path of paths) for (const step of path.steps) {
+			const { type } = step.event;
+			if (type === "@xstate.init" || declaredTypes.has(type) || caseIds.has(step.event)) continue;
+			if (isInternalEventType(type)) {
+				const resolved = outcomeByEvent.get(step.event);
+				if (resolved !== void 0) stubbedSources.add(resolved.src);
+				if (mode === "executed") continue;
+			}
+			extraEvents[type] = { generate: void 0 };
+		}
+		const formatSnapshot = options.formatSnapshot ?? defaultFormatSnapshot;
+		const results = [];
+		const adapter = createPathAdapter(paths, caseIds, results, {
+			mode,
+			outcomeByEvent,
+			serialize: (snapshot) => identity(snapshot, void 0, void 0),
+			format: (snapshot) => {
+				try {
+					return JSON.stringify(formatSnapshot(snapshot)) ?? String(snapshot);
+				} catch {
+					return String(snapshot);
+				}
+			}
+		});
+		const { paths: _paths, pathGenerator: _pathGenerator, fromEvents: _fromEvents, limit: _limit, toState: _toState, fromState: _fromState, stopWhen: _stopWhen, samples: _samples, seed: _seed, serializeState: _serializeState, serializeEvent: _serializeEvent, allowDuplicatePaths: _allowDuplicatePaths, events: configuredEvents, outcomes: configuredOutcomes, ...shared } = options;
+		const stubs = {};
+		if (mode === "executed") {
+			for (const src of stubbedSources) stubs[src] = { generate: void 0 };
+			Object.assign(stubs, configuredOutcomes ?? {});
+		}
+		const runSource = mode === "pure" && outcomeSources.length !== 0 ? testLogic : source;
+		return Effect.gen(function* () {
+			const attempt = yield* Effect.exit(awaited$3(propertyTest$1(runSource, {
+				...shared,
+				adapter,
+				...Object.keys(stubs).length !== 0 ? { outcomes: stubs } : {},
+				events: {
+					...configuredEvents ?? {},
+					...extraEvents
+				}
+			})));
+			if (Exit.isFailure(attempt)) {
+				const error = squash(attempt.cause);
+				if (error instanceof ModelTestFailure && error.coverage !== void 0) {
+					const failedIndex = results.length - 1;
+					const failedPath = results[failedIndex]?.path;
+					const detail = error.summary.replace(/^Property /, "");
+					const remapped = new ModelTestFailure(failedPath !== void 0 ? `Path ${failedIndex + 1} (${describePath(failedPath)}) failed: ${detail.charAt(0).toLowerCase() + detail.slice(1)}` : error.summary, error.trace, error.cause, error.replay, error.fixture, withPathExploration(error.coverage, paths.length, pathGeneratorKind), error.format, error.extras);
+					return yield* Effect.die(remapped);
+				}
+				return yield* Effect.failCause(attempt.cause);
+			}
+			const { coverage } = attempt.value;
+			return {
+				coverage: withPathExploration(coverage, paths.length, pathGeneratorKind),
+				results
+			};
+		});
+	}));
+});
+/** Whether `logic` is a state machine (duck-typed, as `xstate/graph` does). */
+function isMachineLogic(logic) {
+	const machine = logic;
+	return typeof machine["getStateNodeById"] === "function" && typeof machine["resolveState"] === "function" && typeof machine["getTransitionData"] === "function";
+}
+// src/scheduler.ts
+let schedulerStorage;
+let schedulerStorageLoading;
+function loadSchedulerStorage() {
+	schedulerStorageLoading ??= import("node:async_hooks").then((hooks) => {
+		schedulerStorage = new hooks.AsyncLocalStorage();
+		return schedulerStorage;
+	});
+	return schedulerStorageLoading;
+}
+/**
+* Awaits `value` as an Effect. A value and a thenable are both accepted, and a
+* rejection stays the same error object when the effect is run.
+*/
+const awaited$2 = (value) => Effect.promise(() => Promise.resolve(value));
+/**
+* The scheduler fast-check generated for the run currently in flight, or
+* `undefined` when the adapter was not configured with `scheduler`.
+*
+* Only defined while a scheduled run is executing, which is exactly when a
+* system under test is created and driven.
+*
+* @experimental
+*/
+function getCurrentScheduler() {
+	return schedulerStorage?.getStore();
+}
+/** @internal */
+const withCurrentScheduler = dual(2, function withCurrentScheduler(scheduler, run) {
+	return loadSchedulerStorage().then((storage) => storage.run(scheduler, run));
+});
+function scheduleMethod(scheduler, method) {
+	if (method === void 0) return;
+	return scheduler.scheduleFunction((...args) => Effect.runPromise(awaited$2(method(...args))));
+}
+/**
+* Wraps a {@link TestSut} so its asynchronous boundaries (`send`, `read`,
+* `settle`, `advance`) resolve in an order chosen by the run's fast-check
+* scheduler instead of in plain microtask order.
+*
+* The wrapper binds to {@link getCurrentScheduler} when the session is created,
+* so it is inert unless the adapter was configured with `scheduler`.
+*
+* @experimental
+*/
+function withScheduledSut(sut) {
+	return {
+		...sut,
+		create: (context) => Effect.runPromise(Effect.gen(function* () {
+			const scheduler = getCurrentScheduler();
+			const session = yield* awaited$2(sut.create(context));
+			if (scheduler === void 0) return session;
+			const send = scheduler.scheduleFunction((event, sendContext) => Promise.resolve(session.send(event, sendContext)));
+			const read = session.read !== void 0 ? scheduler.scheduleFunction(() => Promise.resolve(session.read())) : void 0;
+			const settle = scheduleMethod(scheduler, session.settle?.bind(session));
+			const advance = scheduleMethod(scheduler, session.advance?.bind(session));
+			return {
+				...session,
+				send: (event, sendContext) => send(event, sendContext),
+				...read !== void 0 ? { read: () => read() } : {},
+				...settle !== void 0 ? { settle: () => settle() } : {},
+				...advance !== void 0 ? { advance: (milliseconds) => advance(milliseconds) } : {}
+			};
+		}))
+	};
+}
+/**
+* Wraps a reference oracle the way {@link withScheduledSut} wraps a system
+* under test: its `transition` and `read` calls resolve under the run's
+* scheduler.
+*
+* @experimental
+*/
+function withScheduledReference(reference) {
+	return {
+		...reference,
+		create: (context) => Effect.runPromise(Effect.gen(function* () {
+			const scheduler = getCurrentScheduler();
+			const session = yield* awaited$2(reference.create(context));
+			if (scheduler === void 0) return session;
+			const step = scheduler.scheduleFunction((event) => Promise.resolve(session.transition(event)));
+			const read = scheduler.scheduleFunction(() => Promise.resolve(session.read()));
+			return {
+				...session,
+				transition: (event) => step(event),
+				read: () => read()
+			};
+		}))
+	};
+}
+// src/adapter.ts
+/**
+* Awaits `value` as an Effect. A value and a thenable are both accepted, and a
+* rejection stays the same error object when the effect is run.
+*/
+const awaited$1 = (value) => Effect.promise(() => Promise.resolve(value));
+function createRunSequencer() {
+	let failureSeen = false;
+	let frozenSwarm;
+	return { nextRun: () => ({
+		shrink: failureSeen,
+		swarm: frozenSwarm,
+		report: ({ passed, swarm }) => {
+			if (passed || failureSeen) return;
+			failureSeen = true;
+			frozenSwarm = swarm;
+		}
+	}) };
+}
+/**
+* Runs one fast-check model scenario: start, the generated commands, then
+* disposal, so a failing command still disposes the runner.
+*/
+const runScenario = (runner, generated) => Effect.runPromise(ensuringFinalizerWins(Effect.gen(function* () {
+	yield* awaited$1(runner.start());
+	yield* awaited$1(fc.asyncModelRun(() => ({
+		model: runner,
+		real: void 0
+	}), generated));
+	runner.finish();
+}), Effect.promise(() => runner.dispose())));
+/**
+* Runs the generated command sequence against a fresh runner, releasing the
+* scheduler's tasks with `waitFor` when one is present.
+*/
+const runCommands = (request, sequencer, generated, scheduler) => Effect.runPromise(Effect.gen(function* () {
+	const runner = request.createRunner(sequencer.nextRun());
+	const scenario = () => runScenario(runner, generated);
+	if (scheduler === void 0) {
+		yield* awaited$1(scenario());
+		return;
+	}
+	const finished = scenario();
+	yield* ensuringFinalizerWins(awaited$1(scheduler.waitFor(finished)), Effect.promise(() => scheduler.waitIdle()));
+}));
+function normalizeSchedulerOptions(scheduler) {
+	if (scheduler === void 0 || scheduler === false) return;
+	return scheduler === true ? {} : scheduler;
+}
+function summarizeSchedulerReport(scheduler) {
+	const tasks = scheduler.report().map((item) => ({
+		taskId: item.taskId,
+		label: item.label,
+		schedulingType: item.schedulingType,
+		status: item.status
+	}));
+	return {
+		ordering: tasks.filter(({ status }) => status !== "pending").map(({ taskId }) => taskId),
+		tasks
+	};
+}
+/**
+* `fc.oneof` only accepts integer weights, so relative weights are rescaled by
+* the smallest one before rounding. Ratios are preserved up to rounding, and
+* every entry keeps a weight of at least 1 so no case becomes ungeneratable.
+*/
+function toIntegerWeights(weighted) {
+	const smallest = Math.min(...weighted.map(({ weight }) => weight));
+	return weighted.map(({ arbitrary, weight }) => ({
+		arbitrary,
+		weight: Math.min(MAXIMUM_INTEGER_WEIGHT, Math.max(1, Math.round(weight / smallest)))
+	}));
+}
+/** Keeps rescaled weights well inside safe-integer arithmetic. */
+const MAXIMUM_INTEGER_WEIGHT = 1e6;
+/**
+* Extracts the `replayPath` that fast-check embeds in a `fc.commands`
+* counterexample so a failing run can be replayed deterministically.
+*
+* fast-check exposes no typed accessor for this: `CommandsArbitrary` builds a
+* `CommandsIterable` whose `metadataForReplay()` returns the
+* `replayPath="<path>"` fragment, and whose `toString()` appends that fragment
+* inside a trailing `/* ... *\/` comment. Neither member is declared in
+* `fast-check`'s public typings (checked against fast-check 4.9.0), so this
+* helper is the single place that depends on that shape. It prefers
+* `metadataForReplay()` and falls back to parsing `toString()`.
+*
+* @experimental
+*/
+function extractReplayPath(counterexample) {
+	if (counterexample === null || counterexample === void 0) return;
+	const candidate = counterexample;
+	if (typeof candidate.metadataForReplay === "function") {
+		const fromMetadata = parseReplayPathMetadata(candidate.metadataForReplay());
+		if (fromMetadata !== void 0) return fromMetadata;
+	}
+	if (typeof candidate.toString === "function") return parseReplayPathMetadata(candidate.toString.call(counterexample));
+}
+function parseReplayPathMetadata(metadata) {
+	if (typeof metadata !== "string") return;
+	const match = metadata.match(/replayPath="([^"]*)"/);
+	if (match === null) return;
+	return match[1];
+}
+var EventPropertyCommand = class {
+	type;
+	generated;
+	caseId;
+	constructor(type, generated, caseId) {
+		this.type = type;
+		this.generated = generated;
+		this.caseId = caseId;
+	}
+	check(runner) {
+		return runner.canRunGenerated(this.type, this.generated, this.caseId);
+	}
+	run(runner) {
+		return Effect.runPromise(awaited$1(runner.runGenerated(this.type, this.generated, this.caseId)));
+	}
+	toString() {
+		return `${this.type}(${JSON.stringify(this.generated)})`;
+	}
+};
+var AdvancePropertyCommand = class {
+	milliseconds;
+	constructor(milliseconds) {
+		this.milliseconds = milliseconds;
+	}
+	check(runner) {
+		return runner.canRunCommand(runner.getSnapshot().status === "active");
+	}
+	run(runner) {
+		return Effect.runPromise(awaited$1(runner.advance(this.milliseconds)));
+	}
+	toString() {
+		return `advance(${this.milliseconds})`;
+	}
+};
+var CheckpointPropertyCommand = class {
+	label;
+	constructor(label) {
+		this.label = label;
+	}
+	check(runner) {
+		return runner.canRunCommand(true);
+	}
+	run(runner) {
+		return Effect.runPromise(awaited$1(runner.checkpoint(this.label)));
+	}
+	toString() {
+		return `checkpoint(${JSON.stringify(this.label)})`;
+	}
+};
+var StopPropertyCommand = class {
+	check(runner) {
+		return runner.canRunCommand(runner.getSnapshot().status === "active");
+	}
+	run(runner) {
+		return Effect.runPromise(awaited$1(runner.stop()));
+	}
+	toString() {
+		return "stop()";
+	}
+};
+var OutcomePropertyCommand = class {
+	src;
+	outcome;
+	constructor(src, outcome) {
+		this.src = src;
+		this.outcome = outcome;
+	}
+	check(runner) {
+		return runner.canRunOutcome();
+	}
+	run(runner) {
+		return Effect.runPromise(awaited$1(runner.outcome(this.src, this.outcome)));
+	}
+	toString() {
+		return `outcome(${JSON.stringify(this.src)}, ${JSON.stringify(this.outcome)})`;
+	}
+};
+var FastCheckAdapter = class {
+	options;
+	kind;
+	constructor(options) {
+		this.options = options;
+	}
+	run(request) {
+		const { options } = this;
+		let schedulerReport;
+		return Effect.runPromise(Effect.gen(function* () {
+			const weighted = request.events.map(({ type, caseId, generator, weight }) => ({
+				arbitrary: generator.map((generated) => new EventPropertyCommand(type, generated, caseId)),
+				weight
+			}));
+			for (const command of request.commands) if (command.type === "advance") weighted.push({
+				arbitrary: command.generator.map((milliseconds) => new AdvancePropertyCommand(milliseconds)),
+				weight: command.weight
+			});
+			else if (command.type === "outcome") {
+				const src = command.src;
+				weighted.push({
+					arbitrary: command.generator.map((outcome) => new OutcomePropertyCommand(src, outcome)),
+					weight: command.weight
+				});
+			} else if (command.type === "checkpoint") weighted.push({
+				arbitrary: command.generator.map((value) => new CheckpointPropertyCommand(value.label)),
+				weight: command.weight
+			});
+			else weighted.push({
+				arbitrary: command.generator.map(() => new StopPropertyCommand()),
+				weight: command.weight
+			});
+			if (weighted.length === 0) throw new Error("Property tests require at least one event or command generator. Generators are derived only from runtime schemas in `schemas.events`: event types declared with a type-only `types<...>()` schema, or with no schema, are skipped, so configure them in `events`.");
+			const commands = weighted.every(({ weight }) => weight === 1) ? weighted.map(({ arbitrary }) => arbitrary) : [fc.oneof(...toIntegerWeights(weighted))];
+			const commandConstraints = {
+				...options.maxCommands === void 0 ? {} : {
+					maxCommands: options.maxCommands,
+					size: "max"
+				},
+				...options.replayPath === void 0 ? {} : { replayPath: options.replayPath }
+			};
+			const commandSequence = fc.commands(commands, commandConstraints);
+			const schedulerOptions = normalizeSchedulerOptions(options.scheduler);
+			const sequencer = createRunSequencer();
+			const property = schedulerOptions !== void 0 ? fc.asyncProperty(commandSequence, fc.scheduler(schedulerOptions.act !== void 0 ? { act: schedulerOptions.act } : void 0), (generated, scheduler) => withCurrentScheduler(scheduler, () => runCommands(request, sequencer, generated, scheduler).catch((error) => {
+				schedulerReport = summarizeSchedulerReport(scheduler);
+				throw error;
+			}))) : fc.asyncProperty(commandSequence, (generated) => runCommands(request, sequencer, generated, void 0));
+			const { maxCommands: _, replayPath: __, scheduler: ___, ...parameters } = options;
+			if (request.runBudget !== void 0) parameters.numRuns = request.runBudget;
+			if (request.runOffset !== void 0 && request.runOffset !== 0 && parameters.seed !== void 0) parameters.seed += request.runOffset;
+			const result = yield* awaited$1(fc.check(property, parameters));
+			if (options.asyncReporter !== void 0) yield* awaited$1(options.asyncReporter(result));
+			else if (options.reporter !== void 0) options.reporter(result);
+			const report = result.failed && Number(options.verbose ?? 0) >= 1 ? fc.defaultReportMessage(result) : void 0;
+			const configuredRuns = result.runConfiguration.numRuns ?? 100;
+			const truncationReasons = [];
+			if (result.interrupted) truncationReasons.push("adapter run interrupted");
+			if (result.failed && result.numRuns < configuredRuns) truncationReasons.push(result.errorInstance !== void 0 && result.errorInstance !== null ? "counterexample found before configured runs completed" : "precondition skips exhausted before configured runs completed");
+			const exploration = {
+				configuredRuns,
+				maximumSequenceLength: options.maxCommands ?? null,
+				engine: "fast-check",
+				seed: result.seed,
+				path: result.counterexamplePath ?? void 0,
+				truncated: truncationReasons.length > 0,
+				truncationReasons
+			};
+			if (!result.failed) return {
+				runs: result.numRuns,
+				exploration
+			};
+			return {
+				runs: result.numRuns,
+				exploration,
+				...report !== void 0 ? { report } : {},
+				error: result.errorInstance ?? /* @__PURE__ */ new Error(result.interrupted ? "FastCheck property run was interrupted" : "FastCheck property run exhausted its precondition skips"),
+				replay: {
+					engine: "fast-check",
+					seed: result.seed,
+					path: result.counterexamplePath ?? void 0,
+					replayPath: extractReplayPath(result.counterexample?.[0]),
+					numShrinks: result.numShrinks,
+					...schedulerReport !== void 0 ? { data: { scheduler: schedulerReport } } : {}
+				}
+			};
+		}));
+	}
+};
+/** @experimental */
+function fastCheckAdapter(options = {}) {
+	return new FastCheckAdapter(options);
+}
+// src/failures.ts
+/**
+* Awaits `value` as an Effect. A value and a thenable are both accepted, and a
+* rejection stays the same error object when the effect is run.
+*/
+const awaited = (value) => Effect.promise(() => Promise.resolve(value));
+/** Reads a saved failure file. A file of any other shape is left alone. */
+const parseSavedFailure = (text) => JSON.parse(text);
+/** The bytes a saved failure file holds. */
+const serializeSavedFailure = (saved) => JSON.stringify(saved, null, 2);
+/** The fixture's JSON, hashed to name its file. */
+const fixtureJson = (fixture) => JSON.stringify(fixture);
+const DEFAULT_DIR = ".xstate-test";
+/** Keeps a key usable as a single directory name. */
+function sanitizeKey(key) {
+	return key.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "default";
+}
+/**
+* A {@link TestFailureStore} that saves each failing fixture as
+* `<dir>/<key>/<hash>.json`. Node's `fs` is loaded only when a campaign reads
+* or writes a failure, so importing `@xstate/test` stays free of Node APIs.
+*
+* @experimental
+*/
+function createFailureDatabase(options = {}) {
+	const dir = options.dir ?? DEFAULT_DIR;
+	const folderOf = (key) => Effect.runPromise(Effect.gen(function* () {
+		return (yield* awaited(import("node:path"))).join(dir, sanitizeKey(key));
+	}));
+	return {
+		...options.key === void 0 ? {} : { key: options.key },
+		replay: options.replay ?? "first",
+		load: (key) => Effect.runPromise(Effect.gen(function* () {
+			const [fs, path] = yield* awaited(Promise.all([import("node:fs/promises"), import("node:path")]));
+			const folder = yield* awaited(folderOf(key));
+			const names = yield* Effect.catchCause(awaited(fs.readdir(folder)), () => Effect.succeed([]));
+			const stored = [];
+			for (const name of names.filter((file) => file.endsWith(".json")).sort()) {
+				const location = path.join(folder, name);
+				yield* Effect.ignoreCause(Effect.gen(function* () {
+					const saved = parseSavedFailure(yield* awaited(fs.readFile(location, "utf8")));
+					if (saved?.fixture !== void 0) stored.push({
+						fixture: saved.fixture,
+						location
+					});
+				}));
+			}
+			return stored;
+		})),
+		onFailure: (fixture, key, failure) => Effect.runPromise(Effect.gen(function* () {
+			const [fs, path, crypto] = yield* awaited(Promise.all([
+				import("node:fs/promises"),
+				import("node:path"),
+				import("node:crypto")
+			]));
+			const folder = yield* awaited(folderOf(key));
+			const serialized = fixtureJson(fixture);
+			const hash = crypto.createHash("sha256").update(serialized).digest("hex").slice(0, 12);
+			const location = path.join(folder, `${hash}.json`);
+			const saved = {
+				formatVersion: 1,
+				key,
+				summary: failure.summary,
+				...failure.replay !== void 0 ? { replay: failure.replay } : {},
+				fixture
+			};
+			yield* awaited(fs.mkdir(folder, { recursive: true }));
+			yield* awaited(fs.writeFile(location, `${serializeSavedFailure(saved)}\n`));
+			return location;
+		})),
+		remove: (stored) => Effect.runPromise(Effect.gen(function* () {
+			if (stored.location === void 0 || stored.location.length === 0) return;
+			const fs = yield* awaited(import("node:fs/promises"));
+			yield* awaited(fs.rm(stored.location, { force: true }));
+		}))
+	};
+}
+/** Turns the `failures` option into the store `xstate/graph` expects. */
+function resolveFailuresOption(failures) {
+	if (failures === void 0 || failures === false) return;
+	if (failures === true) return createFailureDatabase();
+	if (typeof failures.load === "function") return failures;
+	return createFailureDatabase(failures);
+}
+// src/propertyTest.ts
+const ADAPTER_OPTION_KEY_SET = /* @__PURE__ */ new Set([
+	"asyncReporter",
+	"endOnFailure",
+	"ignoreEqualValues",
+	"includeErrorInReport",
+	"interruptAfterTimeLimit",
+	"markInterruptAsFailure",
+	"maxCommands",
+	"maxSkipsPerRun",
+	"numRuns",
+	"path",
+	"randomType",
+	"replayPath",
+	"reporter",
+	"scheduler",
+	"seed",
+	"skipAllAfterTimeLimit",
+	"skipEqualValues",
+	"timeout",
+	"unbiased",
+	"verbose"
+]);
+/**
+* Derives generators for the event types the machine declares a runtime schema
+* for and that `events` does not already cover.
+*
+* Event types configured explicitly, and type-only `types<...>()` declarations,
+* are filtered out before `eventsFromSchemas()` sees them. Anything left that
+* the converters do not recognize still throws, so an unsupported schema
+* library is reported rather than silently ignored.
+*/
+function deriveMissingEvents(source, events) {
+	const schemas = source?.schemas?.events;
+	if (schemas === void 0) return;
+	const missing = Object.fromEntries(Object.entries(schemas).filter(([type, schema]) => events?.[type] === void 0 && !isTypeOnlySchema(schema)));
+	if (Object.keys(missing).length === 0) return;
+	return eventsFromSchemas({
+		schemas: { events: missing },
+		events: []
+	}, { eventsWithoutSchema: "skip" });
+}
+function splitOptions(options) {
+	const adapterOptions = {};
+	const rest = {};
+	for (const [key, value] of Object.entries(options)) if (ADAPTER_OPTION_KEY_SET.has(key)) adapterOptions[key] = value;
+	else rest[key] = value;
+	return {
+		adapterOptions,
+		rest
+	};
+}
+/**
+* Builds the options `xstate/graph` expects: the implicit adapter, and the
+* schema-derived `events` map that explicit entries are layered onto.
+*/
+function resolveOptions(source, options) {
+	const { adapterOptions, rest } = splitOptions(options);
+	const { deriveEvents, adapter, events, failures, ...propertyOptions } = rest;
+	const failureStore = resolveFailuresOption(failures);
+	const derived = deriveEvents === false ? void 0 : deriveMissingEvents(source, events);
+	const { maxRuns } = propertyOptions;
+	return {
+		...propertyOptions,
+		...maxRuns === void 0 && typeof adapterOptions["numRuns"] === "number" ? { maxRuns: adapterOptions["numRuns"] } : {},
+		events: derived !== void 0 ? {
+			...derived,
+			...events
+		} : events ?? {},
+		adapter: adapter ?? fastCheckAdapter(adapterOptions),
+		...failureStore !== void 0 ? { failures: failureStore } : {}
+	};
+}
+/**
+* Runs a property-testing campaign with fast-check as the generator.
+*
+* Identical to `propertyTest()` from `xstate/graph`, except that fast-check
+* options (`seed`, `numRuns`, `maxCommands`, `scheduler`, …) are top-level
+* options rather than `fastCheckAdapter()` arguments, and `events` is derived
+* from the machine's `schemas.events` when it declares them.
+*
+* @experimental
+*/
+const propertyTest = dual(2, function propertyTest(source, options) {
+	return propertyTest$1(source, resolveOptions(source, options));
+});
+/**
+* Records an offline property suite from a passing campaign, with fast-check
+* as the generator. See `generateTestSuite()` in `xstate/graph`.
+*
+* @experimental
+*/
+const generateTestSuite = dual(2, function generateTestSuite(source, options) {
+	return generateTestSuite$1(source, resolveOptions(source, options));
+});
+/** fast-check arbitraries expose a `generate` method; plain generators do not. */
+function isArbitrary(value) {
+	return value !== void 0 && value !== null && typeof value === "object" && typeof value.generate === "function";
+}
+/**
+* Replaces every fast-check arbitrary with a `{ sample(rng) }` generator
+* backed by `fc.sample`, so `xstate/graph` can expand it without depending on
+* fast-check. An object rather than a function, so `testPaths()` never
+* mistakes it for a pre-2.0 event executor.
+*/
+function sampleArbitraries(events, samples, seed, prefix = "") {
+	const sampled = (generator, caseId) => {
+		if (!isArbitrary(generator)) return generator;
+		const values = fc.sample(generator, {
+			seed: deriveCaseSeed(seed, caseId),
+			numRuns: Math.max(1, samples)
+		});
+		let index = 0;
+		return { sample: () => values[index++ % values.length] };
+	};
+	const one = (eventCase, type) => {
+		if (!isEventDescriptorObject(eventCase)) return sampled(eventCase, `${prefix}${type}:default`);
+		const descriptor = eventCase;
+		return {
+			...descriptor,
+			generate: sampled(descriptor.generate, `${prefix}${type}:${descriptor.case ?? "default"}`)
+		};
+	};
+	return Object.fromEntries(Object.entries(events ?? {}).map(([type, configured]) => [type, Array.isArray(configured) ? configured.map((eventCase) => one(eventCase, type)) : one(configured, type)]));
+}
+/**
+* Executes model paths against a system under test.
+*
+* The same options as `propertyTest()`, minus the generation controls
+* (`numRuns`, `maxCommands`, `swarm`, `frontiers`, …) and plus the traversal
+* controls (`pathGenerator`, `limit`, `toState`, `samples`, `seed`). fast-check
+* arbitraries are accepted in `events` and sampled into `samples` concrete
+* payloads before traversal.
+*
+* @experimental
+*/
+const testPaths = dual((args) => args.length >= 2 || typeof args[0] === "object" && args[0] !== null && "transition" in args[0], function testPaths(source, options = {}) {
+	const { deriveEvents, events, outcomes, failures, ...rest } = options;
+	const failureStore = resolveFailuresOption(failures);
+	const derived = deriveEvents === false ? void 0 : deriveMissingEvents(source, events);
+	const merged = derived !== void 0 ? {
+		...derived,
+		...events
+	} : events ?? {};
+	const samples = options.samples ?? 3;
+	const seed = options.seed ?? 0;
+	return testPaths$1(source, {
+		...rest,
+		...failureStore !== void 0 ? { failures: failureStore } : {},
+		...outcomes !== void 0 ? { outcomes: sampleArbitraries(outcomes, samples, seed, "outcome:") } : {},
+		events: sampleArbitraries(merged, samples, seed)
+	});
+});
+export { consoleLineLogger as C, formatTestStatistics as D, formatTestCoverageJUnit as E, testCoverageToJSON as O, assertTestCoverage as S, formatTestCoverageHTML as T, ReplayNotReproducedError as _, extractReplayPath as a, replayTest as b, withScheduledReference as c, parseTestSuite as d, replayTestSuite as f, PropertyScenarioRunner as g, ModelTestFailure as h, createFailureDatabase as i, createPickDescriptor as k, withScheduledSut as l, serializeTestSuite as m, propertyTest as n, fastCheckAdapter as o, replayTestSuiteFixture as p, testPaths as r, getCurrentScheduler as s, generateTestSuite as t, describeTestSuite as u, TestCampaignError as v, formatTestCoverage as w, serializeTestTrace as x, defaultEquivalent as y };