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

package/dist/index-CSbyUxJr.d.ts

@@ -0,0 +1,2062 @@
+import { ActorLogic, AnyActorLogic, AnyTransitionDefinition, EventFromLogic, EventObject, InputFrom, Snapshot, SnapshotFrom } from "@systemfsoftware/xstate";
+import { PathGenerator, StatePath } from "@systemfsoftware/xstate/graph";
+import * as Cause from "effect/Cause";
+import "effect/Logger";
+/**
+ * A value generator usable by the generator-neutral path runner.
+ *
+ * `testPaths()` samples concrete event payloads from a `generate` value before
+ * traversal, so a generator only has to produce a value from a pseudo-random
+ * number source. `@xstate/test` additionally accepts fast-check arbitraries and
+ * adapts them to this shape.
+ * @experimental
+ */
+type TestGenerator<T> = ((rng: () => number) => T) | {
+  sample: (rng: () => number) => T;
+};
+/**
+ * The descriptor shape both entry points accept for a single event case.
+ *
+ * @experimental
+ */
+interface AnyTestEventDescriptor<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly generate?: unknown;
+  readonly case?: string;
+  readonly weight?: number;
+  readonly when?: (context: {
+    readonly snapshot: TSnapshot;
+    readonly event: TEvent;
+  }) => boolean;
+  readonly resolve?: (context: {
+    readonly snapshot: TSnapshot;
+    readonly generated: unknown;
+  }) => object | undefined;
+}
+/**
+ * The event descriptor `pick()` returns: a shrinkable index in `generate`,
+ * and a `resolve` that picks the item at that index from the current snapshot.
+ * @experimental
+ */
+interface TestPickDescriptor<TGenerator, TSnapshot extends Snapshot<unknown>, TPayload> {
+  readonly generate: TGenerator;
+  resolve(context: {
+    readonly snapshot: TSnapshot;
+    readonly generated: number;
+  }): TPayload | undefined;
+}
+/**
+ * One coverage dimension, with its ids grouped by status.
+ *
+ * @experimental
+ */
+interface TestCoverageDimension {
+  /** Hits per id. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** Ids hit at least once. */
+  readonly covered: readonly string[];
+  /** Reachable ids that were never hit. */
+  readonly uncovered: readonly string[];
+  /** Ids that cannot be reached from the start state. */
+  readonly unreachable: readonly string[];
+  /** Ids whose reachability cannot be decided statically. */
+  readonly unknown: readonly string[];
+}
+interface TestTransitionPairCoverageDimension extends TestCoverageDimension {
+  /**
+   * `true` when the statically enumerable pair universe exceeded
+   * `TRANSITION_PAIR_UNIVERSE_LIMIT` and was cut short. Pairs observed at
+   * runtime are still reported as covered.
+   */
+  readonly truncated: boolean;
+}
+interface TestRequirementCoverageDimension extends TestCoverageDimension {
+  /** Requirement id to the state nodes and transitions that declare it. */
+  readonly sources: Readonly<Record<string, readonly string[]>>;
+}
+/** @experimental */
+interface TestEventCaseCounts {
+  /** Effective relative generation weight for this case. Defaults to `1`. */
+  readonly weight: number;
+  readonly generated: number;
+  readonly applicable: number;
+  readonly executed: number;
+  readonly ignored: number;
+}
+/** @experimental */
+interface TestExplorationFrontier {
+  readonly id: string;
+  readonly prefixLength: number;
+  readonly runBudget: number | null;
+  readonly configuredRuns: number | null;
+  readonly completedRuns: number;
+  /** Runner creations, including shrink attempts. */
+  readonly attemptedRuns: number;
+}
+/** @experimental */
+interface TestExplorationSeed {
+  readonly frontierId: string;
+  readonly engine?: string | undefined;
+  readonly seed?: number | undefined;
+  readonly path?: string | undefined;
+}
+/**
+ * Swarm testing statistics. Only present when `swarm` was enabled.
+ *
+ * @experimental
+ */
+interface TestExplorationSwarm {
+  /** Runs that were given a swarm subset of the event cases. */
+  readonly runs: number;
+  /** Mean number of event cases enabled per swarm run. */
+  readonly averageEnabled: number;
+}
+/**
+ * Targeted-search statistics. Only present when `target` was used.
+ *
+ * @experimental
+ */
+interface TestExplorationTarget {
+  /** The best (highest) observed target value, `-Infinity` when none. */
+  readonly best: number;
+  /** The label recorded alongside the best value, when one was given. */
+  readonly label?: string | undefined;
+  /** How many times the best value improved during the campaign. */
+  readonly improvements: number;
+}
+/**
+ * Why a property campaign stopped running batches.
+ *
+ * @experimental
+ */
+type TestStoppedBecause = 'until' | 'budget' | 'failure' | 'paths' | 'replay';
+/** @experimental */
+interface TestExplorationBounds {
+  /**
+   * `'property'` when the campaign generated command sequences,
+   * `'paths'` when it executed paths produced by graph traversal.
+   */
+  readonly strategy: 'property' | 'paths';
+  /** Paths executed. Only present for `strategy: 'paths'`. */
+  readonly pathCount?: number;
+  /** How the paths were produced. Only present for `strategy: 'paths'`. */
+  readonly pathGenerator?: 'shortest' | 'simple' | 'events' | 'custom';
+  /**
+   * `'pure'` when the campaign stepped the machine through `transition()`,
+   * `'executed'` when it drove a real actor on a simulated clock.
+   */
+  readonly mode: 'pure' | 'executed';
+  readonly configuredRuns: number | null;
+  readonly completedRuns: number;
+  /** Runner creations, including shrink attempts. */
+  readonly attemptedRuns: number;
+  /**
+   * Runs started after the first failing run, while the adapter shrank the
+   * counterexample. Included in `attemptedRuns`; excluded from `labels` and
+   * `eventCases`.
+   */
+  readonly shrinkRuns: number;
+  readonly maximumSequenceLength: number | null;
+  readonly maximumObservedSequenceLength: number;
+  readonly frontiers: readonly TestExplorationFrontier[];
+  readonly seeds: readonly TestExplorationSeed[];
+  /** Swarm testing statistics, or `null` when `swarm` was not enabled. */
+  readonly swarm: TestExplorationSwarm | null;
+  /** Targeted-search statistics. `best` is `-Infinity` when unused. */
+  readonly target: TestExplorationTarget;
+  readonly truncated: boolean;
+  readonly truncationReasons: readonly string[];
+  /**
+   * `'until'` when a stop condition was met, `'failure'` when a
+   * counterexample ended the campaign, `'budget'` when the configured runs
+   * were exhausted, `'paths'` when `testPaths()` executed every path, and
+   * `'replay'` when `failures.replay` was `'only'` and no campaign ran.
+   */
+  readonly stoppedBecause: TestStoppedBecause;
+  /**
+   * Executed-mode steps that settled while an invoked or spawned actor's
+   * asynchronous work was still in flight. Each such timeline entry lists the
+   * actors in `pendingActors`. Non-zero means some results may have landed
+   * in a later step than the one that started them.
+   */
+  readonly pendingActorSteps: number;
+}
+/**
+ * Aggregated occurrences of a label recorded with `label()`/`classify()`.
+ *
+ * @experimental
+ */
+interface TestLabelCoverage {
+  /** Total number of times the label was recorded across all runs. */
+  readonly count: number;
+  /** Occurrences per recorded value. Labels without a value are not listed. */
+  readonly values: Readonly<Record<string, number>>;
+  /**
+   * Runs in which the label was recorded at least once, over attempted runs
+   * that were not shrink attempts. Always between `0` and `1`.
+   */
+  readonly share: number;
+}
+/**
+ * Per-run outcomes of one temporal property.
+ *
+ * @experimental
+ */
+interface TestTemporalCounts {
+  /** Runs in which the property held. */
+  readonly satisfied: number;
+  /** Runs the property failed. */
+  readonly failed: number;
+  /** Runs that ended before the property was decided. */
+  readonly inconclusive: number;
+}
+/**
+ * Temporal-property outcomes across a campaign.
+ *
+ * @experimental
+ */
+interface TestTemporalCoverage {
+  /** Temporal definitions satisfied in at least one run. */
+  readonly satisfied: readonly string[];
+  /**
+   * Temporal definitions that caused a run to fail, and `sometimes` or
+   * `reachable` definitions that held in no run of the campaign.
+   */
+  readonly failed: readonly string[];
+  /**
+   * Definitions that were inconclusive in every run that checked them, and
+   * satisfied in none.
+   */
+  readonly inconclusive: readonly string[];
+  /** Per-id run counts. */
+  readonly counts: Readonly<Record<string, TestTemporalCounts>>;
+  /**
+   * Bounded definitions that can never fail with the configured bounds, such
+   * as an `eventually` whose `within` exceeds the longest sequence.
+   */
+  readonly warnings: readonly string[];
+}
+/**
+ * What a campaign exercised, resolved by `propertyTest()` and `testPaths()`.
+ * Relative to the supplied event cases and bounds; not a claim of complete
+ * behavioral coverage.
+ * @experimental
+ */
+interface TestCoverage {
+  /** Runs attempted, including shrink attempts. */
+  readonly runs: number;
+  readonly steps: number;
+  readonly skipped: number;
+  readonly prefixSteps: number;
+  readonly generatedSteps: number;
+  readonly invariantChecks: number;
+  readonly temporalChecks: number;
+  readonly clockAdvances: number;
+  readonly checkpoints: number;
+  readonly stops: number;
+  readonly sutComparisons: number;
+  readonly oracleComparisons: number;
+  /** Serialized snapshots observed during the campaign. */
+  readonly states: TestCoverageDimension;
+  /** State node ids. */
+  readonly stateNodes: TestCoverageDimension;
+  /** Sets of simultaneously active state nodes. */
+  readonly configurations: TestCoverageDimension;
+  /** Snapshot statuses, such as `active` and `done`. */
+  readonly statuses: TestCoverageDimension;
+  /** Delivered event types. This does not describe payload-domain coverage. */
+  readonly eventTypes: TestCoverageDimension;
+  /** Lifecycle counts for the event cases supplied to `propertyTest()`. */
+  readonly eventCases: Readonly<Record<string, TestEventCaseCounts>>;
+  /** Transition definitions, attributed from the microsteps XState took. */
+  readonly transitions: TestCoverageDimension;
+  /** Pairs of consecutive executed transitions, as `${t1} -> ${t2}`. */
+  readonly transitionPairs: TestTransitionPairCoverageDimension;
+  /** Requirement ids declared via `meta.requirements`. */
+  readonly requirements: TestRequirementCoverageDimension;
+  /** Frontier ids from the `frontiers` option. */
+  readonly frontiers: TestCoverageDimension;
+  /** Labels recorded with `label()`/`classify()`, keyed by label name. */
+  readonly labels: Readonly<Record<string, TestLabelCoverage>>;
+  /** Temporal property ids by outcome. */
+  readonly temporal: TestTemporalCoverage;
+  /** The bounds, budgets, and seeds the campaign ran with. */
+  readonly exploration: TestExplorationBounds;
+}
+interface Declaration {
+  unreachable: boolean;
+  unknown: boolean;
+}
+interface MutableDimension {
+  counts: Record<string, number>;
+  declarations: Map<string, Declaration>;
+}
+interface MutableTestCoverage {
+  runs: number;
+  steps: number;
+  skipped: number;
+  prefixSteps: number;
+  generatedSteps: number;
+  invariantChecks: number;
+  temporalChecks: number;
+  clockAdvances: number;
+  checkpoints: number;
+  stops: number;
+  sutComparisons: number;
+  oracleComparisons: number;
+  states: MutableDimension;
+  stateNodes: MutableDimension;
+  configurations: MutableDimension;
+  statuses: MutableDimension;
+  eventTypes: MutableDimension;
+  eventCases: Record<string, TestEventCaseCounts>;
+  transitions: MutableDimension;
+  transitionPairs: MutableDimension;
+  transitionPairsTruncated: boolean;
+  requirements: MutableDimension;
+  requirementSources: Record<string, string[]>;
+  requirementsByStateNode: Map<string, readonly string[]>;
+  requirementsByTransition: Map<string, readonly string[]>;
+  previousTransitionIds: readonly string[] | null;
+  frontiers: MutableDimension;
+  labels: Record<string, {
+    count: number;
+    values: Record<string, number>;
+    runs: number;
+  }>;
+  temporal: {
+    counts: Record<string, {
+      satisfied: number;
+      failed: number;
+      inconclusive: number;
+    }>;
+    /** Campaign-level failures of `sometimes` and `reachable`. */
+    campaignFailed: Set<string>;
+    warnings: string[];
+  };
+  /** Runs started after the first failing run. */
+  shrinkRuns: number;
+  transitionIds: WeakMap<AnyTransitionDefinition, string>;
+  maximumObservedSequenceLength: number;
+  pendingActorSteps: number;
+}
+/**
+ * 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.
+ */
+declare class PropertyOutcomeRegistry {
+  private queued;
+  private waiting;
+  /** Called by a stub actor when it starts. */
+  request(src: string): Promise<TestActorOutcome>;
+  /** Resolves the oldest pending stub for `src`, or queues for the next one. */
+  provide(src: string, outcome: TestActorOutcome): void;
+  /** Pre-loads recorded outcomes so a replay never calls a real service. */
+  seed(records: readonly TestOutcomeRecord[]): void;
+  reset(): void;
+}
+/**
+ * The snapshot, event and input types of the actor logic a helper is
+ * parameterized by. Declared once here so the bundled declaration emitter has
+ * one declaration to name rather than a `_2`/`$1` suffix per module.
+ *
+ * @experimental
+ */
+type SnapshotFromSource<TSource> = SnapshotFrom<TSource>;
+/** @experimental */
+type EventFromSource<TSource> = TSource extends ActorLogic<any, infer TEvent, any> ? TEvent : never;
+/** @experimental */
+type InputFromSource<TSource> = InputFrom<TSource>;
+/** @experimental */
+interface PropertyGeneratorKind {
+  readonly target: unknown;
+  readonly generator: unknown;
+}
+/** @experimental */
+type PropertyGenerator<TKind extends PropertyGeneratorKind, TValue> = (TKind & {
+  readonly target: TValue;
+})['generator'];
+/** @experimental */
+interface TestReplayMetadata {
+  readonly engine: string;
+  readonly engineVersion?: string | undefined;
+  readonly seed?: number | undefined;
+  readonly path?: string | undefined;
+  readonly replayPath?: string | undefined;
+  /** How many times the engine shrank the counterexample, when it reports it. */
+  readonly numShrinks?: number | undefined;
+  readonly data?: unknown;
+}
+/**
+ * `'pure'` steps the machine through the pure `transition()` path: no effect
+ * runs, no invoked or spawned actor starts, no delayed transition fires.
+ * `'executed'` drives a real actor on a `SimulatedClock` instead, so
+ * invoked/spawned actors run and `after` transitions are reachable through
+ * generated `advance` commands.
+ * @experimental
+ */
+type TestMode = 'pure' | 'executed';
+/**
+ * A resolved actor outcome queued for a stubbed invoke source.
+ *
+ * @experimental
+ */
+type TestActorOutcome = {
+  readonly ok: true;
+  readonly output: unknown;
+} | {
+  readonly ok: false;
+  readonly error: unknown;
+};
+/**
+ * An actor outcome observed during an executed-mode run, keyed by invoke
+ * source and by how many actors of that source had already resolved.
+ * Recorded into replay fixtures so a failure can be replayed against stubbed
+ * actors instead of the real ones.
+ * @experimental
+ */
+interface TestOutcomeRecord {
+  readonly src: string;
+  readonly occurrence: number;
+  readonly outcome: TestActorOutcome;
+}
+/** @experimental */
+type TestCommand<TEvent extends EventObject = EventObject> = {
+  readonly type: 'event';
+  readonly event: TEvent;
+  readonly phase: 'prefix' | 'generated';
+  readonly origin: 'frontier' | 'generator' | 'clock';
+  readonly caseId?: string | undefined;
+} | {
+  readonly type: 'advance';
+  readonly milliseconds: number;
+  readonly deliveredEvents: readonly TEvent[];
+} | {
+  readonly type: 'checkpoint';
+  readonly label?: string | undefined;
+} | {
+  /** Queues the next resolution of a stubbed invoke source. */
+  readonly type: 'outcome';
+  readonly src: string;
+  readonly outcome: TestActorOutcome;
+} | {
+  readonly type: 'stop';
+};
+/**
+ * An event the actor system produced on its own during an executed-mode step:
+ * an invoked actor's `onDone`/`onError`/`onSnapshot`, a delayed transition, a
+ * `sendTo`/`raise`, or a child actor's own transition.
+ * @experimental
+ */
+interface TestActorTimelineEntry<TSnapshot extends Snapshot<unknown>> {
+  readonly kind: 'actorEvent';
+  readonly index: number;
+  /** `'root'` when the tested actor transitioned, `'child'` otherwise. */
+  readonly source: 'root' | 'child';
+  /** The `id` of the actor that transitioned. */
+  readonly actorId: string;
+  readonly event: EventObject;
+  readonly previousSnapshot: TSnapshot;
+  readonly snapshot: TSnapshot;
+  readonly effects: readonly unknown[];
+  readonly transitionIds: readonly string[];
+  /** Never set: reference/SUT comparison happens on the settled step. */
+  readonly observation?: undefined;
+}
+/** @experimental */
+interface TestComparedObservation {
+  /** The model projection that was compared. */
+  readonly model: unknown;
+  /** The value observed on the reference oracle or the system under test. */
+  readonly observed: unknown;
+}
+/** @experimental */
+interface TestObservation {
+  /**
+   * The model projection of the reference oracle when one is configured,
+   * otherwise the model projection of the system under test. Prefer the
+   * explicit `reference` and `sut` fields, which always report the projection
+   * they were compared against.
+   */
+  readonly model: unknown;
+  /** Present when a reference oracle is configured. */
+  readonly reference?: TestComparedObservation | undefined;
+  /** Present when a system under test is configured. */
+  readonly sut?: TestComparedObservation | undefined;
+}
+/** @experimental */
+interface TestEventTimelineEntry<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly kind: 'event';
+  readonly index: number;
+  readonly command: Extract<TestCommand<TEvent>, {
+    type: 'event';
+  }>;
+  readonly previousSnapshot: TSnapshot;
+  readonly snapshot: TSnapshot;
+  readonly effects: readonly unknown[];
+  readonly transitionIds: readonly string[];
+  readonly activeStateIds: readonly string[];
+  readonly observation?: TestObservation;
+  /**
+   * Executed mode only: invoked or spawned actors whose asynchronous work was
+   * still in flight when the step settled. Their results may land in a later
+   * step, so the step is not reproducible from the trace alone.
+   */
+  readonly pendingActors?: readonly string[];
+}
+/** @experimental */
+interface TestRuntimeTimelineEntry<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly kind: 'command';
+  readonly index: number;
+  readonly command: Exclude<TestCommand<TEvent>, {
+    type: 'event';
+  }>;
+  readonly previousSnapshot: TSnapshot;
+  readonly snapshot: TSnapshot;
+  readonly effects: readonly unknown[];
+  readonly transitionIds: readonly string[];
+  readonly observation?: TestObservation;
+  /** See {@link TestEventTimelineEntry.pendingActors}. */
+  readonly pendingActors?: readonly string[];
+}
+/** @experimental */
+type TestTimelineEntry<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> = TestEventTimelineEntry<TSnapshot, TEvent> | TestRuntimeTimelineEntry<TSnapshot, TEvent> | TestActorTimelineEntry<TSnapshot>;
+/** @experimental */
+interface PortableTestTimelineEntry {
+  readonly kind: 'event' | 'command';
+  readonly command: TestCommand;
+}
+/** @experimental */
+interface PortableTemporalFailure {
+  readonly type: 'eventually' | 'until' | 'always' | 'never' | 'respond';
+  readonly id: string;
+  readonly description?: string | undefined;
+  /** Only present for bounded (`eventually`/`until`/`respond`) properties. */
+  readonly within?: number | undefined;
+  readonly atStep: number;
+}
+/** @experimental */
+interface TestFixture {
+  readonly formatVersion: 2;
+  readonly machine?: {
+    readonly id?: string | undefined;
+    readonly version?: string | undefined;
+  } | undefined;
+  readonly start: {
+    readonly type: 'input';
+    readonly input: unknown;
+  } | {
+    readonly type: 'snapshot';
+    readonly snapshot: unknown;
+  };
+  readonly timeline: readonly PortableTestTimelineEntry[];
+  /**
+   * The step the recorded run failed at. Absent on fixtures recorded from a
+   * passing run, such as the ones an offline property suite is built from.
+   */
+  readonly failedAt?: number;
+  readonly temporalFailure?: PortableTemporalFailure | undefined;
+  /** Event case ids enabled for the run, when swarm testing was used. */
+  readonly swarm?: readonly string[];
+  /** Executed-mode runs only. See `TestOutcomeRecord`. */
+  readonly mode?: TestMode;
+  /** Actor outcomes observed during an executed-mode run, in resolution order. */
+  readonly outcomes?: readonly TestOutcomeRecord[];
+  /**
+   * Invoke sources the recorded run replaced with outcome stubs, including
+   * ones that never resolved. A replay stubs every one of them.
+   */
+  readonly stubs?: readonly string[];
+}
+interface LegacyPortablePropertyReplayFixture {
+  readonly formatVersion: 1;
+  readonly machine?: {
+    readonly id?: string;
+    readonly version?: string;
+  };
+  readonly start: {
+    readonly type: 'input';
+    readonly input: unknown;
+  } | {
+    readonly type: 'snapshot';
+    readonly snapshot: unknown;
+  };
+  readonly prefixEvents: readonly unknown[];
+  readonly events: readonly unknown[];
+  readonly failedAt: number;
+}
+/** @experimental */
+interface TestAdapterResult {
+  readonly runs: number;
+  readonly exploration: {
+    readonly configuredRuns: number | null;
+    readonly maximumSequenceLength: number | null;
+    readonly engine?: string | undefined;
+    readonly seed?: number | undefined;
+    readonly path?: string | undefined;
+    readonly truncated?: boolean | undefined;
+    readonly truncationReasons?: readonly string[] | undefined;
+  };
+  readonly replay?: TestReplayMetadata;
+  readonly error?: unknown;
+  /**
+   * Engine-specific text appended to the failure message, such as fast-check's
+   * report when `verbose` is set.
+   */
+  readonly report?: string;
+}
+/** @experimental */
+interface PropertyGeneratedCommand {
+  readonly type: 'advance' | 'checkpoint' | 'stop' | 'outcome';
+  readonly generator: unknown;
+  /** Relative generation weight. `1` unless configured otherwise. */
+  readonly weight: number;
+  /**
+   * The invoke source an `'outcome'` command resolves. Always present for
+   * `'outcome'` commands and never present for the others.
+   */
+  readonly src?: string;
+}
+/** @experimental */
+interface TestAdapterRequest<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly events: readonly {
+    readonly type: string;
+    readonly caseId: string;
+    readonly generator: unknown;
+    /** Relative generation weight. `1` unless configured otherwise. */
+    readonly weight: number;
+  }[];
+  readonly commands: readonly PropertyGeneratedCommand[];
+  readonly runBudget?: number | undefined;
+  /**
+   * The number of runs already completed by earlier batches of the same
+   * campaign. Adapters that derive their seed from a fixed value should offset
+   * it by this number so batches explore different sequences.
+   */
+  readonly runOffset?: number | undefined;
+  readonly createEvent: (type: string, payload: unknown) => TEvent;
+  readonly createRunner: (run?: TestAdapterRunContext) => PropertyScenarioRunner<TSnapshot, TEvent>;
+}
+interface TestAdapterRunOutcome {
+  readonly passed: boolean;
+  readonly swarm: readonly string[] | undefined;
+}
+interface TestAdapterRunContext {
+  readonly shrink: boolean;
+  readonly swarm: readonly string[] | undefined;
+  readonly report: (outcome: TestAdapterRunOutcome) => void;
+}
+/** @experimental */
+interface TestAdapter<TKind extends PropertyGeneratorKind = PropertyGeneratorKind> {
+  readonly kind?: TKind;
+  run<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject>(request: TestAdapterRequest<TSnapshot, TEvent>): Promise<TestAdapterResult>;
+}
+/** @experimental */
+interface TestSutContext<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> extends TestLabelRecorders {
+  readonly logic: ActorLogic<TSnapshot, TEvent, unknown>;
+  readonly input: unknown;
+  readonly snapshot: TSnapshot | undefined;
+}
+/** @experimental */
+interface TestSut<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  /** Creates a fresh session for one run. Called once per run and shrink attempt. */
+  readonly create: (context: TestSutContext<TSnapshot, TEvent>) => TestSutSession<TSnapshot, TEvent> | Promise<TestSutSession<TSnapshot, TEvent>>;
+  /**
+   * Projects the model snapshot onto the shape `read()` returns. Required only
+   * when the session reads observations back for comparison.
+   */
+  readonly projectModel?: (snapshot: TSnapshot) => unknown;
+  /** Normalizes the value `read()` returns before comparison. Defaults to identity. */
+  readonly projectSut?: (observed: unknown) => unknown;
+  /** Compares the two projections. Defaults to `defaultEquivalent`. */
+  readonly equivalent?: (model: unknown, sut: unknown) => boolean | Promise<boolean>;
+  /**
+   * Called once when the campaign ends, after every session was disposed.
+   * `failure` is the error the campaign throws, if any. Use it to publish
+   * artifacts collected for the final counterexample.
+   */
+  readonly complete?: (result: TestSutCompleteContext) => void | Promise<void>;
+}
+/**
+ * Passed to {@link TestSut.complete}.
+ *
+ * @experimental
+ */
+interface TestSutCompleteContext {
+  readonly passed: boolean;
+  /** The error the campaign throws. Usually a {@link ModelTestFailure}. */
+  readonly failure?: unknown;
+}
+/**
+ * Passed to {@link TestSutSession.dispose}.
+ *
+ * @experimental
+ */
+interface TestSutDisposeContext {
+  /** `false` when the run ended in a failure. */
+  readonly passed: boolean;
+  /** The failure the run ended in, when an oracle failed. */
+  readonly failure?: ModelTestFailure<any, any>;
+}
+/**
+ * Metadata about the step an event belongs to, passed to `send`.
+ *
+ * @experimental
+ */
+interface TestSutSendContext<TSnapshot = unknown> {
+  /** The model snapshot after the event was applied to the model. */
+  readonly snapshot: TSnapshot;
+  /**
+   * The internal generated event case id, when the event came from a
+   * generator. Absent for prefix, clock, and replayed events. It is an opaque
+   * string; use {@link TestSutSendContext.case} to identify a case.
+   */
+  readonly caseId?: string;
+  /**
+   * The user-facing descriptor of the generated event case: the event `type`
+   * and the configured case `name` (`'default'` when the event was configured
+   * without a `case`). Absent whenever `caseId` is.
+   */
+  readonly case?: {
+    readonly type: string;
+    readonly name: string;
+  };
+}
+/**
+ * One run's connection to the system under test, returned by `TestSut.create()`.
+ *
+ * @experimental
+ */
+interface TestSutSession<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TEvent extends EventObject = EventObject> {
+  /** Performs `event` against the system under test. */
+  readonly send: (event: TEvent, context: TestSutSendContext<TSnapshot>) => void | Promise<void>;
+  /**
+   * Reads the current observable state of the system under test. Compared
+   * against `projectModel(snapshot)` after every stable step when both are
+   * present.
+   */
+  readonly read?: () => unknown | Promise<unknown>;
+  /**
+   * Per-state assertions run after every stable step, keyed by state value (or
+   * `'#id'`), with `'*'` as the fallthrough. Overrides the top-level `states`
+   * option when present.
+   */
+  readonly states?: TestStateAssertions<TSnapshot, TEvent>;
+  /** Waits for the system under test to become quiescent before each comparison. */
+  readonly settle?: () => void | Promise<void>;
+  /**
+   * Advances the system under test's own clock, returning the events it
+   * delivered. They are applied to the model before the next comparison.
+   */
+  readonly advance?: (milliseconds: number) => readonly TEvent[] | Promise<readonly TEvent[]>;
+  /** Handles a `checkpoint` command. */
+  readonly checkpoint?: (label?: string) => void | Promise<void>;
+  /** Handles a `stop` command. */
+  readonly stop?: () => void | Promise<void>;
+  /**
+   * Checks the system under test after every stable step, after the
+   * comparison. Throws to fail the step.
+   */
+  readonly check?: () => void | Promise<void>;
+  /** Tears the session down at the end of the run, whether it passed or failed. */
+  readonly dispose?: (context: TestSutDisposeContext) => void | Promise<void>;
+}
+/** Dotted state-value paths of a machine's `value` type: `'a'`, `'a.b'`. */
+type StateValuePaths<TValue> = TValue extends string ? TValue : TValue extends object ? { [K in keyof TValue & string]: K | `${K}.${StateValuePaths<TValue[K]>}`; }[keyof TValue & string] : never;
+/**
+ * The keys a {@link TestStateAssertions} map suggests: every state-value path
+ * of the snapshot's `value`, and `'*'`. Any other string, such as a
+ * `'#node.id'`, is accepted too.
+ * @experimental
+ */
+type TestStateKey<TSnapshot extends Snapshot<unknown>> = '*' | `#${string}` | (TSnapshot extends {
+  readonly value: infer TValue;
+} ? StateValuePaths<TValue> : never);
+/**
+ * One per-state assertion. See {@link TestStateAssertions}.
+ *
+ * @experimental
+ */
+type TestStateAssertion<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject = EventObject> = (snapshot: TSnapshot, session: TestSutSession<TSnapshot, TEvent> | undefined) => void | Promise<void>;
+/**
+ * Per-state assertions, keyed by state value (`'green'`, `'a.b'`), by state
+ * node id (`'#some.id'`), or `'*'` as the fallthrough when nothing else
+ * matches. Run after every stable step in both `propertyTest()` and
+ * `testPaths()`.
+ * @experimental
+ */
+type TestStateAssertions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject = EventObject> = { readonly [TKey in TestStateKey<TSnapshot>]?: TestStateAssertion<TSnapshot, TEvent>; } & {
+  readonly [stateKey: string]: TestStateAssertion<TSnapshot, TEvent> | undefined;
+};
+/** @experimental */
+interface TestReferenceContext<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> extends TestSutContext<TSnapshot, TEvent> {}
+/**
+ * A second implementation of the model's logic, compared with it on every stable step.
+ *
+ * @experimental
+ */
+interface TestReference<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  /** Creates a fresh reference session for one run. */
+  readonly create: (context: TestReferenceContext<TSnapshot, TEvent>) => TestReferenceSession<TEvent> | Promise<TestReferenceSession<TEvent>>;
+  /** Projects the model snapshot onto the shape the reference's `read()` returns. */
+  readonly projectModel: (snapshot: TSnapshot) => unknown;
+  /** Normalizes the value the reference's `read()` returns. Defaults to identity. */
+  readonly projectReference?: (observed: unknown) => unknown;
+  readonly equivalent?: (model: unknown, reference: unknown) => boolean | Promise<boolean>;
+}
+/** @experimental */
+interface TestReferenceSession<TEvent extends EventObject> {
+  readonly transition: (event: TEvent) => void | Promise<void>;
+  readonly read: () => unknown | Promise<unknown>;
+  readonly stop?: () => void | Promise<void>;
+  readonly dispose?: () => void | Promise<void>;
+}
+type EventType<TEvent extends EventObject> = TEvent['type'] & string;
+type EventForType<TEvent extends EventObject, TType extends EventType<TEvent>> = Extract<TEvent, {
+  type: TType;
+}>;
+type EventPayload<TEvent extends EventObject> = Omit<TEvent, 'type'>;
+/**
+ * Records a statistic for the current run.
+ *
+ * @experimental
+ */
+interface TestLabelRecorders {
+  /**
+   * Records `name` (optionally with `value`) for the current run. Labels are
+   * aggregated across the campaign into `coverage.labels`.
+   */
+  readonly label: (name: string, value?: string | number | boolean) => void;
+  /** Records `name` when `condition` holds. */
+  readonly classify: (condition: boolean, name: string) => void;
+  /**
+   * Records an observation for targeted search. The campaign keeps the best
+   * (highest) observed value and steers later batches towards the prefixes
+   * that reached it. See `frontiers: { strategy: 'target' }`.
+   */
+  readonly target: (observation: number, label?: string) => void;
+}
+/** @experimental */
+interface TestInvariantContext<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> extends TestLabelRecorders {
+  readonly initialSnapshot: TSnapshot;
+  readonly previousSnapshot: TSnapshot;
+  readonly snapshot: TSnapshot;
+  readonly event: TEvent | undefined;
+  readonly effects: readonly unknown[];
+  readonly step: number;
+}
+/** @experimental */
+type TestInvariant<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> = (context: TestInvariantContext<TSnapshot, TEvent>) => void | Promise<void>;
+/** @experimental */
+interface TestEventDescriptor<TGenerator, TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly generate: TGenerator;
+  readonly case?: string;
+  /**
+   * Relative generation weight for this case. Must be a positive, finite
+   * number. Defaults to `1`.
+   */
+  readonly weight?: number;
+  readonly when?: (context: {
+    readonly snapshot: TSnapshot;
+    readonly event: TEvent;
+  }) => boolean;
+  readonly resolve?: never;
+}
+/** @experimental */
+interface TestResolvedEventDescriptor<TGenerator, TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TGenerated = unknown> {
+  readonly generate: TGenerator;
+  readonly case?: string;
+  /**
+   * Relative generation weight for this case. Must be a positive, finite
+   * number. Defaults to `1`.
+   */
+  readonly weight?: number;
+  /**
+   * Resolves a shrinkable symbolic value against the current model snapshot.
+   * Returning `undefined` makes the case inapplicable.
+   */
+  resolve(context: {
+    readonly snapshot: TSnapshot;
+    readonly generated: TGenerated;
+  }): EventPayload<TEvent> | undefined;
+  readonly when?: (context: {
+    readonly snapshot: TSnapshot;
+    readonly event: TEvent;
+  }) => boolean;
+}
+type PropertyEventGenerator<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TKind extends PropertyGeneratorKind> = PropertyGenerator<TKind, EventPayload<TEvent>> | TestEventDescriptor<PropertyGenerator<TKind, EventPayload<TEvent>>, TSnapshot, TEvent> | TestResolvedEventDescriptor<PropertyGenerator<TKind, unknown>, TSnapshot, TEvent>;
+/** @experimental */
+type TestEventGenerators<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TKind extends PropertyGeneratorKind> = { [TType in EventType<TEvent>]?: PropertyEventGenerator<TSnapshot, EventForType<TEvent, TType>, TKind> | readonly PropertyEventGenerator<TSnapshot, EventForType<TEvent, TType>, TKind>[]; };
+/** @experimental */
+type TestTemporalPredicate<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> = (context: TestInvariantContext<TSnapshot, TEvent>) => boolean | Promise<boolean>;
+/** @experimental */
+type TestTemporal<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> = {
+  readonly type: 'eventually';
+  readonly id: string;
+  readonly description?: string;
+  /**
+   * Fails as soon as this many stable steps elapse without the predicate
+   * holding. When omitted, the predicate must hold before the run ends.
+   */
+  readonly within?: number;
+  readonly predicate: TestTemporalPredicate<TSnapshot, TEvent>;
+} | {
+  readonly type: 'until';
+  readonly id: string;
+  readonly description?: string;
+  /**
+   * Fails as soon as this many stable steps elapse without `until`
+   * holding. When omitted, `until` must hold before the run ends.
+   */
+  readonly within?: number;
+  readonly hold: TestTemporalPredicate<TSnapshot, TEvent>;
+  readonly until: TestTemporalPredicate<TSnapshot, TEvent>;
+} | {
+  /** The predicate must hold on every stable step. */
+  readonly type: 'always';
+  readonly id: string;
+  readonly description?: string;
+  readonly predicate: TestTemporalPredicate<TSnapshot, TEvent>;
+} | {
+  /** The predicate must never hold on any stable step. */
+  readonly type: 'never';
+  readonly id: string;
+  readonly description?: string;
+  readonly predicate: TestTemporalPredicate<TSnapshot, TEvent>;
+} | {
+  /**
+   * The predicate must hold on at least one stable step of at least one
+   * run. Checked when the campaign ends: a run in which it never holds
+   * does not fail.
+   */
+  readonly type: 'sometimes';
+  readonly id: string;
+  readonly description?: string;
+  readonly predicate: TestTemporalPredicate<TSnapshot, TEvent>;
+} | {
+  /**
+   * Every step on which `trigger` holds must be followed by a step on
+   * which `response` holds. The response may hold on the trigger step
+   * itself.
+   */
+  readonly type: 'respond';
+  readonly id: string;
+  readonly description?: string;
+  /**
+   * Fails as soon as this many stable steps elapse after a trigger
+   * without a response. When omitted, the response must hold before the
+   * run ends.
+   */
+  readonly within?: number;
+  readonly trigger: TestTemporalPredicate<TSnapshot, TEvent>;
+  readonly response: TestTemporalPredicate<TSnapshot, TEvent>;
+};
+/** @experimental */
+interface TestStep<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> extends TestEventTimelineEntry<TSnapshot, TEvent> {
+  readonly phase: 'prefix' | 'generated';
+  readonly event: TEvent;
+}
+/** @experimental */
+interface TestTrace<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly start: {
+    readonly type: 'input';
+    readonly input: unknown;
+  } | {
+    readonly type: 'snapshot';
+    readonly snapshot: TSnapshot;
+  };
+  readonly initialSnapshot: TSnapshot;
+  readonly initialEffects: readonly unknown[];
+  readonly initialTransitionIds: readonly string[];
+  readonly timeline: readonly TestTimelineEntry<TSnapshot, TEvent>[];
+  readonly prefixEvents: readonly TEvent[];
+  readonly events: readonly TEvent[];
+  readonly commands: readonly Exclude<TestCommand<TEvent>, {
+    type: 'event';
+  }>[];
+  readonly steps: readonly TestStep<TSnapshot, TEvent>[];
+  readonly finalSnapshot: TSnapshot;
+  readonly finalObservation?: TestObservation | undefined;
+  /** Event case ids enabled for the run, when swarm testing was used. */
+  readonly swarm?: readonly string[] | undefined;
+  /** The mode the run was recorded in. */
+  readonly mode?: TestMode;
+  /** Actor outcomes observed during an executed-mode run, in resolution order. */
+  readonly outcomes?: readonly TestOutcomeRecord[];
+}
+/**
+ * Options that shape how a {@link ModelTestFailure} message is rendered.
+ *
+ * @experimental
+ */
+interface TestFailureFormatOptions<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>> {
+  /**
+   * Projects a snapshot onto the value printed in the failure trace. Defaults
+   * to `{ value, context }` for machine snapshots, plus `status`, `output`,
+   * `error`, and `tags` when they carry information.
+   */
+  readonly formatSnapshot?: (snapshot: TSnapshot) => unknown;
+}
+/**
+ * Lines added to a {@link ModelTestFailure} message after it was built.
+ *
+ * @experimental
+ */
+interface TestFailureExtras {
+  /** Printed after the `Reproduce:` and `Fixture:` lines, such as `Saved: …`. */
+  readonly notes?: readonly string[];
+  /** Printed after the trace, such as fast-check's verbose report. */
+  readonly report?: string;
+}
+/**
+ * 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
+ */
+declare const ModelTestFailureBase: new (args: {
+  readonly message: string;
+}) => Cause.YieldableError & {
+  readonly _tag: "@systemfsoftware/xstate-test/engine/propertyTest/ModelTestFailure";
+} & Readonly<{
+  readonly message: string;
+}>;
+declare class ModelTestFailure<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TEvent extends EventObject = EventObject> extends ModelTestFailureBase {
+  readonly trace: TestTrace<TSnapshot, TEvent>;
+  readonly cause: unknown;
+  readonly replay?: TestReplayMetadata | undefined;
+  readonly fixture?: TestFixture | undefined;
+  readonly coverage?: TestCoverage | undefined;
+  /** How the message renders snapshots. Kept so rethrows render the same. */
+  readonly format?: TestFailureFormatOptions<TSnapshot> | undefined;
+  /** Extra message lines. Kept so rethrows render the same. */
+  readonly extras?: TestFailureExtras | undefined;
+  /**
+   * `instanceof` narrows to the default type arguments rather than `any`, so
+   * `error.trace` stays typed in a `catch` block.
+   */
+  static [Symbol.hasInstance](value: unknown): value is ModelTestFailure;
+  /** The short message, without the formatted trace. */
+  readonly summary: string;
+  constructor(summary: string, trace: TestTrace<TSnapshot, TEvent>, cause: unknown, replay?: TestReplayMetadata | undefined, fixture?: TestFixture | undefined, coverage?: TestCoverage | undefined,
+  /** How the message renders snapshots. Kept so rethrows render the same. */
+  format?: TestFailureFormatOptions<TSnapshot> | undefined,
+  /** Extra message lines. Kept so rethrows render the same. */
+  extras?: TestFailureExtras | undefined);
+}
+/**
+ * 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
+ */
+declare const TestCampaignErrorBase: new (args: {
+  readonly message: string;
+}) => Cause.YieldableError & {
+  readonly _tag: "@systemfsoftware/xstate-test/engine/propertyTest/TestCampaignError";
+} & Readonly<{
+  readonly message: string;
+}>;
+declare class TestCampaignError extends TestCampaignErrorBase {
+  /** One line per assertion that did not hold. */
+  readonly failures: readonly string[];
+  readonly coverage: TestCoverage;
+  readonly name = "TestCampaignError";
+  constructor(
+  /** One line per assertion that did not hold. */
+  failures: readonly string[], coverage: TestCoverage);
+}
+/**
+ * One saved failure, as a {@link TestFailureStore} loads it.
+ *
+ * @experimental
+ */
+interface TestStoredFailure {
+  readonly fixture: TestFixture;
+  /** Where the failure is stored, such as a file path. Used in messages. */
+  readonly location?: string;
+}
+/**
+ * Persists failing fixtures and replays them before the next campaign. Both
+ * entry points accept one as `failures`; `@xstate/test` provides a
+ * file-system implementation.
+ * @experimental
+ */
+interface TestFailureStore {
+  /**
+   * The key fixtures are stored under. Defaults to the machine id plus a hash
+   * of the configured event cases and oracles.
+   */
+  readonly key?: string;
+  /**
+   * `'first'` (the default) replays stored fixtures before the campaign and
+   * fails on the first one that still reproduces. `'only'` replays them and
+   * skips the campaign. `false` replays nothing.
+   */
+  readonly replay?: 'first' | 'only' | false;
+  /** Loads the fixtures stored under `key`. */
+  readonly load: (key: string) => readonly TestStoredFailure[] | Promise<readonly TestStoredFailure[]>;
+  /**
+   * Stores the fixture of a failing campaign. Returns its location, which is
+   * added to the failure message as `Saved: <location>`.
+   */
+  readonly onFailure: (fixture: TestFixture, key: string, failure: ModelTestFailure<any, any>) => string | void | Promise<string | void>;
+  /** Removes a stored fixture that no longer reproduces. */
+  readonly remove?: (stored: TestStoredFailure, key: string) => void | Promise<void>;
+}
+/**
+ * Executed-mode wiring handed to a {@link PropertyScenarioRunner}.
+ *
+ * @experimental
+ */
+interface PropertyExecutionConfig {
+  readonly mode: TestMode;
+  readonly registry: PropertyOutcomeRegistry;
+  /** Outcomes pre-loaded before the run starts (replay). */
+  readonly seededOutcomes?: readonly TestOutcomeRecord[];
+  /**
+   * Invoke sources replaced by an outcome stub. Recorded into replay fixtures
+   * so a replay stubs the same sources, including ones that never resolved.
+   */
+  readonly stubbedSources?: readonly string[];
+}
+/**
+ * A single `target()` observation, recorded against the timeline.
+ *
+ * @experimental
+ */
+interface PropertyTargetObservation {
+  readonly value: number;
+  readonly label?: string | undefined;
+  /** Number of timeline entries recorded when the observation was made. */
+  readonly index: number;
+}
+/** @experimental */
+declare class PropertyScenarioRunner<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  private readonly logic;
+  private readonly input;
+  private readonly startingSnapshot;
+  private readonly serializeStartingSnapshot;
+  private readonly prefixEvents;
+  private readonly frontierId;
+  private readonly sut;
+  private readonly states;
+  private readonly reference;
+  private readonly invariant;
+  private readonly eventDescriptors;
+  private readonly coverage;
+  private readonly executionConfig?;
+  private snapshot;
+  private initialSnapshot;
+  private initialEffects;
+  private initialTransitionIds;
+  private readonly timeline;
+  private readonly temporal;
+  private stableStep;
+  private started;
+  private finished;
+  private sutSession;
+  private referenceSession;
+  private lastObservation;
+  private readonly inconclusiveTemporalIds;
+  private generatedCommandCount;
+  private readonly labelsSeen;
+  private execution;
+  private swarmCaseIds;
+  private swarmEnabled;
+  private targetFunction;
+  private readonly targetObservations;
+  /** Set for runs the adapter starts while shrinking a counterexample. */
+  private shrinkRun;
+  /** The failure this run ended in, if an oracle failed. */
+  private failure;
+  /** Records a label for this run. */
+  readonly label: (name: string, value?: string | number | boolean) => void;
+  /**
+   * Marks this run as a shrink attempt: its labels and event cases are left
+   * out of the campaign's statistics.
+   */
+  markShrinkRun(): void;
+  private recordEventCase;
+  /** Records `name` when `condition` holds. */
+  readonly classify: (condition: boolean, name: string) => void;
+  /** Records an observation for targeted search. */
+  readonly target: (observation: number, label?: string) => void;
+  /**
+   * 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: readonly string[]): void;
+  private formatOptions;
+  /** Sets how failure messages render snapshots. See `formatSnapshot`. */
+  setFormatSnapshot(formatSnapshot: ((snapshot: TSnapshot) => unknown) | undefined): void;
+  /** Evaluates `target` on every stable step. See the `target` option. */
+  setTargetFunction(targetFunction: (context: TestInvariantContext<TSnapshot, TEvent>) => number): void;
+  /** Outcomes observed while the executed run was alive. */
+  private executionOutcomes;
+  /** Observations recorded with `target()` during this run. */
+  getTargetObservations(): readonly PropertyTargetObservation[];
+  /** `true` when the run completed without a property failure. */
+  isFinished(): boolean;
+  constructor(logic: ActorLogic<TSnapshot, TEvent, unknown>, input: unknown, startingSnapshot: TSnapshot | undefined, serializeStartingSnapshot: ((snapshot: TSnapshot) => unknown) | undefined, prefixEvents: readonly TEvent[], frontierId: string | undefined, sut: TestSut<TSnapshot, TEvent> | undefined, states: TestStateAssertions<TSnapshot, TEvent> | undefined, reference: TestReference<TSnapshot, TEvent> | undefined, invariant: TestInvariant<TSnapshot, TEvent> | undefined, temporal: readonly TestTemporal<TSnapshot, TEvent>[], eventDescriptors: ReadonlyMap<string, AnyTestEventDescriptor<TSnapshot, TEvent>>, coverage: MutableTestCoverage, executionConfig?: PropertyExecutionConfig | undefined);
+  start(): Promise<void>;
+  canRun(event: TEvent, caseId: string): boolean;
+  canRunGenerated(type: string, generated: unknown, caseId: string): boolean;
+  private canRunResolved;
+  private resolveGeneratedEvent;
+  /** `outcome` commands only apply while the executed actor is running. */
+  canRunOutcome(): boolean;
+  canRunCommand(applicable: boolean): boolean;
+  run(event: TEvent, caseId: string): Promise<void>;
+  runGenerated(type: string, generated: unknown, caseId: string): Promise<void>;
+  replay(command: TestCommand<TEvent>): Promise<void>;
+  /** Queues the next resolution of the stubbed invoke source `src`. */
+  outcome(src: string, outcome: TestActorOutcome): Promise<void>;
+  advance(milliseconds: number): Promise<void>;
+  /**
+   * Advances the simulated clock the executed actor runs on, then drains
+   * whatever the elapsed delays produced.
+   */
+  private advanceExecuted;
+  checkpoint(label?: string): Promise<void>;
+  stop(): Promise<void>;
+  finish(): void;
+  /** Bounded temporal properties that the run ended before deciding. */
+  getInconclusiveTemporalIds(): readonly string[];
+  /** The number of stable steps observed so far. */
+  getStableStep(): number;
+  dispose(): Promise<void>;
+  getSnapshot(): TSnapshot;
+  getTrace(): TestTrace<TSnapshot, TEvent>;
+  private executeEvent;
+  private checkStable;
+  /**
+   * Runs the per-state assertions and any `meta.test` hooks that apply to
+   * `snapshot`. Both entry points reach this on every stable step.
+   */
+  private checkStateAssertions;
+  private checkTemporal;
+  private failTemporal;
+  private compareObservations;
+  private replaceLastObservation;
+  /**
+   * Records, on an executed step's timeline entry, the child actors whose
+   * asynchronous work was still in flight when the step settled.
+   */
+  private markPendingActors;
+  /**
+   * 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: EventObject): number | undefined;
+  /**
+   * 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: string, cause?: unknown): never;
+  /**
+   * 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.
+   */
+  private pushActorEntries;
+  private recordSnapshot;
+  private recordGeneratedCommand;
+  private getActiveStateIds;
+  private assertStarted;
+  private fail;
+  private getReplayFixture;
+}
+/** @experimental */
+interface PropertyFrontierContext<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly frontier: StatePath<TSnapshot, TEvent>;
+  readonly index: number;
+  readonly id: string;
+}
+/** @experimental */
+interface PropertyFrontierOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly paths: readonly StatePath<TSnapshot, TEvent>[];
+  readonly select?: (context: PropertyFrontierContext<TSnapshot, TEvent>) => boolean;
+  readonly runsPerFrontier?: number | ((context: PropertyFrontierContext<TSnapshot, TEvent>) => number);
+}
+/**
+ * A command generator, optionally paired with a relative generation weight. A
+ * bare generator is equivalent to `{ generate, weight: 1 }`; a `weight` key is
+ * what distinguishes the descriptor form.
+ * @experimental
+ */
+interface PropertyCommandDescriptor<TGenerator> {
+  readonly generate: TGenerator;
+  /** Positive, finite relative generation weight. Defaults to `1`. */
+  readonly weight?: number;
+}
+/** @experimental */
+type PropertyCommandGenerator<TKind extends PropertyGeneratorKind, TValue> = PropertyGenerator<TKind, TValue> | PropertyCommandDescriptor<PropertyGenerator<TKind, TValue>>;
+/**
+ * The options both entry points share: what to send, what to send it to, and
+ * what to assert. `testPaths()` adds its own path options; `propertyTest()`
+ * adds {@link PropertyOptions}.
+ * @experimental
+ */
+interface TestOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput, TKind extends PropertyGeneratorKind = PropertyGeneratorKind> {
+  /**
+   * `'pure'` (the default) steps the machine through `transition()`, so no
+   * effects run. `'executed'` runs a real actor on a `SimulatedClock`:
+   * invoked and spawned actors start, `onDone`/`onError`/`onSnapshot` fire,
+   * and `after` transitions are reached with generated `advance` commands.
+   */
+  readonly mode?: TestMode;
+  /**
+   * Actor logic substituted for the machine's named invoke/spawn sources
+   * before the campaign runs, via `machine.provide({ actors })`. Executed
+   * mode only.
+   */
+  readonly actors?: Readonly<Record<string, ActorLogic<any, any, any>>>;
+  /**
+   * Invoke source names whose actors are replaced by a stub that resolves from
+   * an `outcome` command instead of running for real.
+   *
+   * `propertyTest()` generates the outcomes, so the adapter shrinks service
+   * results alongside events; it requires `mode: 'executed'`. `testPaths()`
+   * samples them, the same way it samples event payloads, in either mode: pure
+   * mode sends the sampled `output` or `error` as the payload of the
+   * `xstate.done.actor` / `xstate.error.actor` step the traversal took, and
+   * executed mode resolves the stub with it. In executed mode, a source that a
+   * path resolves but that is not declared here is stubbed with a synthesized
+   * outcome.
+   */
+  readonly outcomes?: {
+    readonly [src: string]: PropertyCommandGenerator<TKind, TestActorOutcome>;
+  };
+  /**
+   * Event types a run may send, keyed by type: a generator for the payload, an
+   * event descriptor, or an array of either.
+   */
+  readonly events?: TestEventGenerators<TSnapshot, TEvent, TKind>;
+  /** The system under test, compared with the model after every stable step. */
+  readonly sut?: TestSut<TSnapshot, TEvent>;
+  /**
+   * Per-state assertions run after every stable step. A `states` map on the
+   * SUT session takes precedence over this one.
+   */
+  readonly states?: TestStateAssertions<TSnapshot, TEvent>;
+  /** A second implementation compared with the model after every stable step. */
+  readonly reference?: TestReference<TSnapshot, TEvent>;
+  /** Machine input for every run. */
+  readonly input?: TInput;
+  /**
+   * Starts every run from `snapshot` instead of the initial state.
+   * `serializeSnapshot` produces the value recorded in replay fixtures.
+   */
+  readonly start?: {
+    readonly snapshot: TSnapshot;
+    readonly serializeSnapshot: (snapshot: TSnapshot) => unknown;
+  };
+  /**
+   * Evaluated on every stable step. The campaign keeps the best (highest)
+   * observed value, reports it as `coverage.exploration.target`, and, with
+   * `frontiers: { strategy: 'target' }`, replays the prefixes that reached it
+   * as frontiers for the next batch. Equivalent to calling `target()` from
+   * the invariant.
+   */
+  readonly target?: (context: TestInvariantContext<TSnapshot, TEvent>) => number;
+  /**
+   * Called once per run, after the runner has finished and been disposed.
+   * `passed` is `false` when the run ended in a property failure.
+   */
+  readonly collect?: (trace: TestTrace<TSnapshot, TEvent>, info: {
+    readonly passed: boolean;
+    readonly runIndex: number;
+  }) => void;
+  /** Checked on every stable step; throws to fail the run. */
+  readonly invariant?: TestInvariant<TSnapshot, TEvent>;
+  /** Temporal properties checked on every stable step. */
+  readonly temporal?: readonly TestTemporal<TSnapshot, TEvent>[];
+  /**
+   * States that at least one run must enter, as state values (`'a.b'`), state
+   * node ids (`'#machine.a'`), or tags. Checked when the campaign ends. Each
+   * target is reported in `coverage.temporal` as `reachable:<target>`.
+   */
+  readonly reachable?: readonly string[];
+  /** Minimum label frequencies the campaign must reach. */
+  readonly expectLabels?: TestLabelExpectations;
+  /**
+   * Saves the fixture of a failing campaign, and replays saved fixtures
+   * before the next one. See {@link TestFailureStore}.
+   */
+  readonly failures?: TestFailureStore;
+  /**
+   * Reports `formatTestStatistics(coverage)` after a passing campaign: the
+   * distribution of executed event cases and the share of runs per label.
+   * `true` prints it through the package's console logger; a function
+   * receives the same string once, instead of the print, and is awaited when
+   * it returns a promise; `false`, or leaving it out, reports nothing. A
+   * function that throws or rejects fails the campaign with that error, after
+   * the system under test's `complete` hook ran.
+   */
+  readonly statistics?: boolean | ((report: string) => void | Promise<void>);
+  /**
+   * Projects a snapshot onto the value printed for each step of a failure
+   * trace. Defaults to `{ value, context }` for machine snapshots.
+   */
+  readonly formatSnapshot?: (snapshot: TSnapshot) => unknown;
+}
+/**
+ * The options only `propertyTest()` accepts.
+ *
+ * @experimental
+ */
+interface PropertyOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TKind extends PropertyGeneratorKind = PropertyGeneratorKind> {
+  /** The generator engine. `@xstate/test` supplies the fast-check one. */
+  readonly adapter: TestAdapter<TKind>;
+  /**
+   * Generators for runtime commands: `advance` (milliseconds), `checkpoint`
+   * (`{ label? }`), and `stop` (`{}`).
+   */
+  readonly commands?: {
+    readonly advance?: PropertyCommandGenerator<TKind, number>;
+    readonly checkpoint?: PropertyCommandGenerator<TKind, {
+      readonly label?: string;
+    }>;
+    readonly stop?: PropertyCommandGenerator<TKind, Record<string, never>>;
+  };
+  /**
+   * Prefixes to start runs from: fixed paths, `{ paths, select,
+   * runsPerFrontier }`, `'auto'` (coverage-guided), or
+   * `{ strategy: 'target' }` (targeted search).
+   */
+  readonly frontiers?: readonly StatePath<TSnapshot, TEvent>[] | PropertyFrontierOptions<TSnapshot, TEvent> | 'auto' | PropertyAutoFrontierOptions | PropertyTargetFrontierOptions;
+  /**
+   * Swarm testing: each run only enables a seeded random subset of the
+   * declared event cases, so rarely-reachable interleavings are not crowded
+   * out by the most common ones. `true` enables at least half the cases.
+   */
+  readonly swarm?: boolean | PropertySwarmOptions;
+  /**
+   * Stops the campaign as soon as the condition holds. Coverage is
+   * re-evaluated between batches of `batchRuns` runs. Without `until` (and
+   * without `frontiers: 'auto'`) the adapter is invoked exactly once.
+   */
+  readonly until?: TestStopCondition;
+  /** Runs per batch in a batched campaign. Defaults to 25. */
+  readonly batchRuns?: number;
+  /** Total runs a batched campaign may complete. Defaults to 100. */
+  readonly maxRuns?: number;
+}
+/** @experimental */
+type PropertyTestOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput, TKind extends PropertyGeneratorKind = PropertyGeneratorKind> = TestOptions<TSnapshot, TEvent, TInput, TKind> & PropertyOptions<TSnapshot, TEvent, TKind>;
+/**
+ * Minimum frequencies required of labels recorded during the campaign.
+ *
+ * @experimental
+ */
+interface TestLabelExpectations {
+  readonly [name: string]: {
+    /** Minimum share of attempted runs that must record the label, `0`..`1`. */
+    readonly min?: number;
+    /** Minimum total occurrences of the label. */
+    readonly minCount?: number;
+  };
+}
+/**
+ * Ratios are `covered / (covered + uncovered)`. Every listed key must hold;
+ * `any` holds when at least one of its conditions does.
+ * @experimental
+ */
+interface TestStopConditionObject {
+  readonly stateNodes?: number;
+  readonly transitions?: number;
+  readonly transitionPairs?: number;
+  /** The share of event cases executed at least once. */
+  readonly eventCases?: number;
+  readonly requirements?: number;
+  readonly runs?: number;
+  readonly timeMs?: number;
+  readonly any?: readonly TestStopCondition[];
+}
+/** @experimental */
+type TestStopCondition = TestStopConditionObject | ((coverage: TestCoverage) => boolean);
+/**
+ * Swarm testing options. See the `swarm` option.
+ *
+ * @experimental
+ */
+interface PropertySwarmOptions {
+  /**
+   * The fewest event cases a run may enable. Defaults to half the declared
+   * cases, rounded up.
+   */
+  readonly minCases?: number;
+  /** Campaign seed the per-run subsets are derived from. Defaults to `0`. */
+  readonly seed?: number;
+}
+/**
+ * Targeted search. See `frontiers: { strategy: 'target' }`.
+ *
+ * @experimental
+ */
+interface PropertyTargetFrontierOptions {
+  readonly strategy: 'target';
+  /** Best-scoring prefixes carried into the next batch. Defaults to 5. */
+  readonly maxFrontiers?: number;
+  /** Runs per frontier. Defaults to an even split of the batch. */
+  readonly runsPerFrontier?: number;
+}
+/**
+ * Coverage-guided exploration. See `frontiers: 'auto'`.
+ *
+ * @experimental
+ */
+interface PropertyAutoFrontierOptions {
+  readonly strategy: 'uncovered';
+  /** Frontiers explored per batch. Defaults to 5. */
+  readonly maxFrontiers?: number;
+  /** Runs per frontier. Defaults to an even split of the batch. */
+  readonly runsPerFrontier?: number;
+  /** Traversal limit for the shortest-path search. Defaults to 1000. */
+  readonly limit?: number;
+}
+/**
+ * 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
+ */
+declare const ReplayNotReproducedErrorBase: new (args: {
+  readonly message: string;
+}) => Cause.YieldableError & {
+  readonly _tag: "@systemfsoftware/xstate-test/engine/propertyTest/ReplayNotReproducedError";
+} & Readonly<{
+  readonly message: string;
+}>;
+declare class ReplayNotReproducedError extends ReplayNotReproducedErrorBase {
+  /** The step the fixture recorded the failure at. */
+  readonly step: number;
+  readonly name = "ReplayNotReproducedError";
+  constructor(
+  /** The step the fixture recorded the failure at. */
+  step: number);
+}
+/**
+ * Replays a {@link TestFixture} without a generator. Resolves with the
+ * replayed trace; see the `expect` option for how failures are reported.
+ * @experimental
+ */
+declare const replayTest: {
+  <TSource extends ActorLogic<any, any, any>>(fixture: TestFixture | LegacyPortablePropertyReplayFixture, options: {
+    readonly invariant?: TestInvariant<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly temporal?: readonly TestTemporal<SnapshotFromSource<TSource>, EventFromSource<TSource>>[];
+    readonly reference?: TestReference<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly sut?: TestSut<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly states?: TestStateAssertions<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly restoreSnapshot?: (snapshot: unknown) => SnapshotFromSource<TSource>;
+    readonly formatSnapshot?: (snapshot: SnapshotFromSource<TSource>) => unknown;
+    readonly mode?: TestMode;
+    readonly actors?: Readonly<Record<string, ActorLogic<any, any, any>>>;
+    readonly expect?: 'failure' | 'pass';
+  }): (source: TSource) => Promise<TestTrace<SnapshotFromSource<TSource>, EventFromSource<TSource>>>;
+  <TSource extends ActorLogic<any, any, any>>(source: TSource, fixture: TestFixture | LegacyPortablePropertyReplayFixture, options: {
+    readonly invariant?: TestInvariant<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly temporal?: readonly TestTemporal<SnapshotFromSource<TSource>, EventFromSource<TSource>>[];
+    readonly reference?: TestReference<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly sut?: TestSut<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly states?: TestStateAssertions<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+    readonly restoreSnapshot?: (snapshot: unknown) => SnapshotFromSource<TSource>;
+    readonly formatSnapshot?: (snapshot: SnapshotFromSource<TSource>) => unknown;
+    readonly mode?: TestMode;
+    readonly actors?: Readonly<Record<string, ActorLogic<any, any, any>>>;
+    readonly expect?: 'failure' | 'pass';
+  }): Promise<TestTrace<SnapshotFromSource<TSource>, EventFromSource<TSource>>>;
+};
+/**
+ * Converts a trace to JSON-safe data, calling `toJSON()` on snapshots.
+ *
+ * @experimental
+ */
+declare function serializeTestTrace<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject>(trace: TestTrace<TSnapshot, TEvent>): unknown;
+/**
+ * One completed operation of a concurrent history: the event that was sent
+ * (`invocation`), what the system under test answered (`response`), and the
+ * interval during which the operation was in flight. Intervals may overlap.
+ * @experimental
+ */
+interface LinearizabilityEntry<TEvent = unknown> {
+  readonly id: string | number;
+  /** The concurrent branch the operation ran on. Informational. */
+  readonly actor?: string;
+  readonly invocation: TEvent;
+  readonly response: unknown;
+  readonly start: number;
+  readonly end: number;
+}
+/**
+ * The sequential specification a history is checked against.
+ *
+ * @experimental
+ */
+interface LinearizabilityModel<TState, TEvent = unknown> {
+  readonly initial: TState;
+  readonly apply: (state: TState, event: TEvent) => {
+    readonly state: TState;
+    readonly response: unknown;
+  };
+  readonly equalResponse?: ((model: unknown, observed: unknown) => boolean) | undefined;
+  /**
+   * Returns a stable string identity for a state, used to memoize search
+   * branches. Return `undefined` for states that cannot be serialized; those
+   * branches are then explored without memoization. Defaults to
+   * `JSON.stringify`.
+   */
+  readonly serializeState?: ((state: TState) => string | undefined) | undefined;
+}
+/** @experimental */
+interface LinearizabilityOptions {
+  /**
+   * Maximum number of candidate linearization steps to explore before giving
+   * up. When the cap is hit the result is `linearizable: false` with
+   * `truncated: true`, which means "not proven", not "proven wrong".
+   */
+  readonly maxExplored?: number | undefined;
+}
+/** @experimental */
+interface LinearizabilityResult<TEvent = unknown> {
+  readonly linearizable: boolean;
+  /** The sequential order that explains the history, when one was found. */
+  readonly witness?: readonly LinearizabilityEntry<TEvent>[] | undefined;
+  readonly explored: number;
+  readonly truncated: boolean;
+}
+/**
+ * Decides whether a concurrent `history` is linearizable against a sequential
+ * `model`: whether some total order of the operations, consistent with the
+ * real-time order of non-overlapping operations, produces exactly the observed
+ * responses.
+ *
+ * The search is the Wing–Gong just-in-time linearization: depth-first over the
+ * operations that could come next (those starting no later than the earliest
+ * end time still outstanding), backtracking whenever a response disagrees with
+ * the model, and memoizing `(state, completed set)` pairs so equivalent
+ * branches are explored once.
+ * @experimental
+ */
+declare const checkLinearizable: {
+  <TState, TEvent>(model: LinearizabilityModel<TState, TEvent>, options?: LinearizabilityOptions): (history: readonly LinearizabilityEntry<TEvent>[]) => LinearizabilityResult<TEvent>;
+  <TState, TEvent>(history: readonly LinearizabilityEntry<TEvent>[], model: LinearizabilityModel<TState, TEvent>, options?: LinearizabilityOptions): LinearizabilityResult<TEvent>;
+};
+/**
+ * The system under test driven by {@link runParallelPropertyCommands}.
+ *
+ * @experimental
+ */
+interface ParallelPropertySutSession<TEvent> {
+  /**
+   * Sends an event. The resolved value is the operation's response; when it is
+   * `undefined` the response is read back with `read()`, which makes a
+   * `TestSutSession` usable as-is.
+   */
+  readonly send: (event: TEvent, context?: unknown) => unknown;
+  readonly read?: () => unknown;
+  readonly dispose?: () => void | Promise<void>;
+}
+/** @experimental */
+interface ParallelPropertySut<TSnapshot, TEvent> {
+  readonly create: (context: TestSutContext<any, any>) => ParallelPropertySutSession<TEvent> | Promise<ParallelPropertySutSession<TEvent>>;
+  /** Projects a model snapshot to the value a response is compared against. */
+  readonly projectModel: (snapshot: TSnapshot) => unknown;
+  /** Projects a raw SUT response before comparison. */
+  readonly projectSut?: (observed: unknown) => unknown;
+}
+/** @experimental */
+interface ParallelPropertyCommandsOptions<TLogic extends AnyActorLogic> {
+  /** Events applied sequentially before the concurrent phase starts. */
+  readonly prefix?: readonly EventFromLogic<TLogic>[];
+  /** Each branch runs its events sequentially, all branches run concurrently. */
+  readonly branches: readonly (readonly EventFromLogic<TLogic>[])[];
+  readonly sut: ParallelPropertySut<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>;
+  readonly input?: unknown;
+  readonly maxExplored?: number;
+  readonly equalResponse?: (model: unknown, observed: unknown) => boolean;
+  /**
+   * Returns a stable string identity for a model snapshot, used to memoize
+   * search branches. Defaults to the snapshot's `value`, `context` and
+   * `status`, which keeps states that merely share a projection distinct.
+   */
+  readonly serializeState?: (snapshot: SnapshotFrom<TLogic>) => string | undefined;
+}
+/** @experimental */
+interface ParallelPropertyCommandsResult<TEvent> extends LinearizabilityResult<TEvent> {
+  readonly history: readonly LinearizabilityEntry<TEvent>[];
+}
+/**
+ * Runs a sequential prefix and then N branches concurrently against a system
+ * under test, records the resulting concurrent history, and checks it against
+ * the machine's own pure `transition()` as the sequential specification.
+ *
+ * This is the analogue of `parallel_commands` in QuickCheck State Machine and
+ * PropEr: the prefix puts the system in an interesting state, the branches
+ * race, and linearizability decides whether the observed responses could have
+ * come from any sequential interleaving.
+ * @experimental
+ */
+declare const runParallelPropertyCommands: {
+  <TLogic extends AnyActorLogic>(options: ParallelPropertyCommandsOptions<TLogic>): (logic: TLogic) => Promise<ParallelPropertyCommandsResult<EventFromLogic<TLogic>>>;
+  <TLogic extends AnyActorLogic>(logic: TLogic, options: ParallelPropertyCommandsOptions<TLogic>): Promise<ParallelPropertyCommandsResult<EventFromLogic<TLogic>>>;
+};
+/**
+ * Options for {@link formatTestCoverage}.
+ *
+ * @experimental
+ */
+interface FormatTestCoverageOptions {
+  /** `'text'` (default) renders plain text; `'markdown'` renders tables. */
+  readonly format?: 'text' | 'markdown';
+}
+/**
+ * Options for {@link formatTestCoverageJUnit}.
+ *
+ * @experimental
+ */
+interface FormatTestCoverageJUnitOptions {
+  readonly suiteName?: string;
+}
+/**
+ * Options for {@link formatTestCoverageHTML}.
+ *
+ * @experimental
+ */
+interface FormatTestCoverageHTMLOptions {
+  readonly title?: string;
+}
+/**
+ * A JSON-safe summary of a single coverage dimension.
+ *
+ * @experimental
+ */
+interface TestCoverageDimensionJSON {
+  readonly total: number;
+  readonly covered: number;
+  readonly ratio: number;
+  readonly counts: Record<string, number>;
+  readonly coveredIds: string[];
+  readonly uncovered: string[];
+  readonly unreachable: string[];
+  readonly unknown: string[];
+}
+/**
+ * The stable, versioned JSON representation of a {@link TestCoverage}.
+ *
+ * @experimental
+ */
+interface TestCoverageJSON {
+  readonly formatVersion: 1;
+  readonly totals: {
+    readonly runs: number;
+    readonly steps: number;
+    readonly skipped: number;
+    readonly prefixSteps: number;
+    readonly generatedSteps: number;
+    readonly invariantChecks: number;
+    readonly temporalChecks: number;
+    readonly clockAdvances: number;
+    readonly checkpoints: number;
+    readonly stops: number;
+    readonly sutComparisons: number;
+    readonly oracleComparisons: number;
+  };
+  readonly dimensions: Record<string, TestCoverageDimensionJSON>;
+  readonly eventCases: Record<string, TestEventCaseCounts>;
+  readonly temporal: {
+    readonly satisfied: string[];
+    readonly failed: string[];
+    readonly inconclusive: string[];
+    readonly counts: Record<string, {
+      readonly satisfied: number;
+      readonly failed: number;
+      readonly inconclusive: number;
+    }>;
+    readonly warnings: string[];
+  };
+  readonly labels: Record<string, {
+    readonly count: number;
+    readonly values: Record<string, number>;
+    readonly share: number;
+  }>;
+  readonly exploration: {
+    readonly stoppedBecause: string;
+    readonly configuredRuns: number | null;
+    readonly completedRuns: number;
+    readonly attemptedRuns: number;
+    readonly shrinkRuns: number;
+    readonly maximumSequenceLength: number | null;
+    readonly maximumObservedSequenceLength: number;
+    readonly truncated: boolean;
+    readonly truncationReasons: string[];
+    readonly frontiers: {
+      readonly id: string;
+      readonly prefixLength: number;
+      readonly runBudget: number | null;
+      readonly configuredRuns: number | null;
+      readonly completedRuns: number;
+      readonly attemptedRuns: number;
+    }[];
+    readonly seeds: {
+      readonly frontierId: string;
+      readonly engine: string | null;
+      readonly seed: number | null;
+      readonly path: string | null;
+    }[];
+    /** Only present when swarm testing was enabled. */
+    readonly swarm?: {
+      readonly runs: number;
+      readonly averageEnabled: number;
+    };
+    /** Only present when a target observation was recorded. */
+    readonly target?: {
+      readonly best: number;
+      readonly label: string | null;
+      readonly improvements: number;
+    };
+  };
+}
+/**
+ * Thresholds accepted by {@link assertTestCoverage}.
+ *
+ * @experimental
+ */
+type TestCoverageThresholds = { readonly [K in DimensionKey]?: number; };
+type DimensionKey = 'states' | 'stateNodes' | 'configurations' | 'statuses' | 'eventTypes' | 'transitions' | 'transitionPairs' | 'requirements' | 'frontiers';
+/**
+ * Formats a {@link TestCoverage} as human-readable text or markdown.
+ *
+ * @experimental
+ */
+declare const formatTestCoverage: {
+  (options?: FormatTestCoverageOptions): (coverage: TestCoverage) => string;
+  (coverage: TestCoverage, options?: FormatTestCoverageOptions): string;
+};
+/**
+ * Converts a {@link TestCoverage} to stable, versioned, JSON-safe data.
+ *
+ * @experimental
+ */
+declare function testCoverageToJSON(coverage: TestCoverage): TestCoverageJSON;
+/**
+ * Formats a {@link TestCoverage} as JUnit XML, with one `<testcase>` per
+ * transition and per state node.
+ * @experimental
+ */
+declare const formatTestCoverageJUnit: {
+  (options?: FormatTestCoverageJUnitOptions): (coverage: TestCoverage) => string;
+  (coverage: TestCoverage, options?: FormatTestCoverageJUnitOptions): string;
+};
+/**
+ * Formats a {@link TestCoverage} as a self-contained HTML document.
+ *
+ * @experimental
+ */
+declare const formatTestCoverageHTML: {
+  (options?: FormatTestCoverageHTMLOptions): (coverage: TestCoverage) => string;
+  (coverage: TestCoverage, options?: FormatTestCoverageHTMLOptions): string;
+};
+/**
+ * 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
+ */
+declare const assertTestCoverage: {
+  (thresholds: TestCoverageThresholds): (coverage: TestCoverage) => void;
+  (coverage: TestCoverage, thresholds: TestCoverageThresholds): void;
+};
+/**
+ * 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
+ */
+declare function formatTestStatistics(coverage: TestCoverage): string;
+/** @experimental */
+interface TestSuite {
+  readonly formatVersion: 1;
+  readonly machineId?: string | undefined;
+  readonly machineVersion?: string | undefined;
+  /** ISO timestamp, only present when `generatedAt` was supplied. */
+  readonly generatedAt?: string | undefined;
+  readonly fixtures: readonly TestFixture[];
+  readonly coverage: TestCoverageJSON;
+}
+/** @experimental */
+interface GenerateTestSuiteOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput, TKind extends PropertyGeneratorKind> extends PropertyTestOptions<TSnapshot, TEvent, TInput, TKind> {
+  /**
+   * `'minimal'` (the default) keeps the smallest greedy subset of recorded
+   * traces that preserves the campaign's covered set. `'all'` keeps every
+   * distinct trace.
+   */
+  readonly select?: 'minimal' | 'all';
+  /** Upper bound on the number of fixtures kept. */
+  readonly maxFixtures?: number;
+  /** Recorded verbatim as `generatedAt`. Omit to keep the suite byte-stable. */
+  readonly generatedAt?: string;
+}
+/** @experimental */
+interface ReplayTestSuiteOptions<TSource extends ActorLogic<any, any, any>> {
+  readonly invariant: TestInvariant<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+  readonly temporal?: readonly TestTemporal<SnapshotFromSource<TSource>, EventFromSource<TSource>>[];
+  readonly reference?: TestReference<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+  readonly sut?: TestSut<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+  readonly states?: TestStateAssertions<SnapshotFromSource<TSource>, EventFromSource<TSource>>;
+  readonly restoreSnapshot?: (snapshot: unknown) => SnapshotFromSource<TSource>;
+}
+/** @experimental */
+interface TestSuiteReplayFailure {
+  readonly fixture: TestFixture;
+  readonly index: number;
+  readonly title: string;
+  readonly error: unknown;
+}
+/** @experimental */
+interface TestSuiteReplayResult {
+  readonly passed: number;
+  readonly failed: readonly TestSuiteReplayFailure[];
+}
+/**
+ * Replays one suite fixture. Resolves when the fixture still passes and
+ * rejects with the underlying failure when it does not.
+ * @experimental
+ */
+declare const replayTestSuiteFixture: {
+  <TSource extends ActorLogic<any, any, any>>(fixture: TestFixture, options: ReplayTestSuiteOptions<TSource>): (source: TSource) => Promise<void>;
+  <TSource extends ActorLogic<any, any, any>>(source: TSource, fixture: TestFixture, options: ReplayTestSuiteOptions<TSource>): Promise<void>;
+};
+/**
+ * Replays every fixture in a suite. Each fixture is expected to pass.
+ *
+ * @experimental
+ */
+declare const replayTestSuite: {
+  <TSource extends ActorLogic<any, any, any>>(suite: TestSuite, options: ReplayTestSuiteOptions<TSource>): (source: TSource) => Promise<TestSuiteReplayResult>;
+  <TSource extends ActorLogic<any, any, any>>(source: TSource, suite: TestSuite, options: ReplayTestSuiteOptions<TSource>): Promise<TestSuiteReplayResult>;
+};
+/** @experimental */
+interface DescribeTestSuiteOptions<TSource extends ActorLogic<any, any, any>> extends ReplayTestSuiteOptions<TSource> {
+  /** Defaults to the ambient `it`. */
+  readonly it?: (name: string, fn: () => Promise<void> | void) => unknown;
+  /** Defaults to the ambient `describe`, when one exists. */
+  readonly describe?: (name: string, fn: () => void) => unknown;
+  /** The `describe` block name. Defaults to `property suite (<machine id>)`. */
+  readonly name?: string;
+}
+/**
+ * Registers one test per suite fixture with a vitest/jest-compatible
+ * `it`/`describe` pair.
+ * @experimental
+ */
+declare const describeTestSuite: {
+  <TSource extends ActorLogic<any, any, any>>(source: TSource, options: DescribeTestSuiteOptions<TSource>): (suite: TestSuite) => void;
+  <TSource extends ActorLogic<any, any, any>>(suite: TestSuite, source: TSource, options: DescribeTestSuiteOptions<TSource>): void;
+};
+/**
+ * Serializes a suite with stable key ordering.
+ *
+ * @experimental
+ */
+declare function serializeTestSuite(suite: TestSuite): string;
+/**
+ * Parses a serialized suite, rejecting unknown format versions.
+ *
+ * @experimental
+ */
+declare function parseTestSuite(json: string): TestSuite;
+/**
+ * The result of executing one path.
+ *
+ * @experimental
+ */
+interface TestPathRunResult<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly path: StatePath<TSnapshot, TEvent>;
+  readonly passed: boolean;
+  readonly error?: unknown;
+}
+/**
+ * Path-generation options. The counterpart of the property-only options.
+ *
+ * @experimental
+ */
+interface PathOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput> {
+  /**
+   * Paths to execute. Defaults to the shortest paths through the machine, or
+   * to whatever `pathGenerator` produces.
+   */
+  readonly paths?: readonly StatePath<TSnapshot, TEvent>[];
+  /**
+   * `'shortest'` (the default), `'simple'`, or a custom
+   * {@link PathGenerator}. `'events'` is implied by `fromEvents`.
+   */
+  readonly pathGenerator?: 'shortest' | 'simple' | PathGenerator<TSnapshot, TEvent, TInput>;
+  /** Executes a single path built from this literal event sequence. */
+  readonly fromEvents?: readonly TEvent[];
+  /**
+   * The most traversal steps path generation takes before it gives up and
+   * throws. Defaults to `10_000`. A machine whose context grows without bound
+   * reaches it, since every distinct context is a distinct state; merge
+   * equivalent states with `serializeState`, or prune with `stopWhen`.
+   */
+  readonly limit?: number;
+  /** Keeps only the paths that end in a state matching this predicate. */
+  readonly toState?: (snapshot: TSnapshot) => boolean;
+  /** Starts traversal from this snapshot instead of the initial state. */
+  readonly fromState?: TSnapshot;
+  /** Stops expanding a state when this returns `true`. */
+  readonly stopWhen?: (snapshot: TSnapshot) => boolean;
+  /**
+   * Concrete values sampled from each event case's `generate` before
+   * traversal. Must be an integer of at least `1`. Defaults to `3`.
+   */
+  readonly samples?: number;
+  /**
+   * Seed for the sampling PRNG. Defaults to `0`. Each event case draws from
+   * its own stream, derived from `seed` and the case id, so adding or removing
+   * a case leaves the other cases' payloads unchanged.
+   */
+  readonly seed?: number;
+  /** Identifies a traversal state. Two snapshots with the same string are one node. */
+  readonly serializeState?: (snapshot: TSnapshot, event: TEvent | undefined, previousSnapshot?: TSnapshot) => string;
+  /** Identifies a traversal event. */
+  readonly serializeEvent?: (event: TEvent) => string;
+  /**
+   * Keeps paths that are prefixes of longer paths instead of dropping them.
+   *
+   * @default false
+   */
+  readonly allowDuplicatePaths?: boolean;
+}
+/**
+ * The generator kind path generation understands natively: a plain
+ * `(rng) => value` function, or an object with a `sample(rng)` method.
+ * `@xstate/test` adapts fast-check arbitraries into this shape before calling
+ * `testPaths()`, so `xstate/graph` never depends on fast-check.
+ * @experimental
+ */
+interface SeededGeneratorKind extends PropertyGeneratorKind {
+  readonly generator: TestGenerator<this['target']>;
+}
+/** @experimental */
+type TestPathsOptions<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput, TKind extends PropertyGeneratorKind = SeededGeneratorKind> = TestOptions<TSnapshot, TEvent, TInput, TKind> & PathOptions<TSnapshot, TEvent, TInput>;
+/**
+ * What `testPaths()` resolves with.
+ *
+ * @experimental
+ */
+interface TestPathsResult<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> {
+  readonly coverage: TestCoverage;
+  readonly results: readonly TestPathRunResult<TSnapshot, TEvent>[];
+}
+export { TestReference as $, ParallelPropertyCommandsResult as A, TestActorOutcome as B, formatTestStatistics as C, LinearizabilityOptions as D, LinearizabilityModel as E, PropertyGeneratorKind as F, TestEventGenerators as G, TestCampaignError as H, PropertyScenarioRunner as I, TestFailureStore as J, TestFailureExtras as K, PropertyTargetObservation as L, runParallelPropertyCommands as M, ModelTestFailure as N, LinearizabilityResult as O, PropertyExecutionConfig as P, TestMode as Q, PropertyTestOptions as R, formatTestCoverageJUnit as S, LinearizabilityEntry as T, TestCommand as U, TestAdapter as V, TestEventDescriptor as W, TestInvariant as X, TestFixture as Y, TestInvariantContext as Z, TestCoverageJSON as _, TestCoverage as _t, GenerateTestSuiteOptions as a, TestStopCondition as at, formatTestCoverage as b, AnyTestEventDescriptor as bt, TestSuiteReplayResult as c, TestSutSendContext as ct, replayTestSuite as d, TestTrace as dt, TestReferenceSession as et, replayTestSuiteFixture as f, replayTest as ft, FormatTestCoverageOptions as g, SnapshotFromSource as gt, FormatTestCoverageJUnitOptions as h, InputFromSource as ht, DescribeTestSuiteOptions as i, TestStep as it, checkLinearizable as j, ParallelPropertyCommandsOptions as k, describeTestSuite as l, TestSutSession as lt, FormatTestCoverageHTMLOptions as m, EventFromSource as mt, TestPathsOptions as n, TestStateAssertion as nt, ReplayTestSuiteOptions as o, TestSut as ot, serializeTestSuite as p, serializeTestTrace as pt, TestFailureFormatOptions as q, TestPathsResult as r, TestStateAssertions as rt, TestSuite as s, TestSutContext as st, TestPathRunResult as t, TestReplayMetadata as tt, parseTestSuite as u, TestTemporal as ut, TestCoverageThresholds as v, TestCoverageDimension as vt, testCoverageToJSON as w, formatTestCoverageHTML as x, TestPickDescriptor as xt, assertTestCoverage as y, TestExplorationBounds as yt, ReplayNotReproducedError as z };