@typeonce/effect-machine 0.31.2 → 0.32.0

package/dist/testing/MachineTest.d.ts

@@ -9,15 +9,19 @@ import type * as Schema from "effect/Schema";
 import type { FastCheck } from "effect/testing";
 import type { EnsureExecutable } from "../internal/machine/readiness.js";
 import type { SchemaArbitraryReport } from "../internal/testing/machine/arbitrary.js";
+import * as ExplorationImpl from "../internal/testing/machine/exploration.js";
 import type { FiniteModel } from "../internal/testing/machine/finiteModel.js";
-import type * as ReferenceModel from "../internal/testing/machine/referenceModel.js";
-import * as internal from "../internal/testing/machine/verification.js";
+import * as InvariantTest from "../internal/testing/machine/invariant.js";
+import * as ProbeTest from "../internal/testing/machine/probe.js";
+import * as ReferenceModel from "../internal/testing/machine/referenceModel.js";
+import type * as RuntimeTest from "../internal/testing/machine/runtime.js";
+import * as RuntimeInvariantTest from "../internal/testing/machine/runtimeInvariant.js";
 import type { VerificationError } from "../internal/testing/machine/verification.js";
 import type * as Machine from "../Machine.js";
-export { advanceCommand, type CausalRuntimeAssertionContext, type CausalRuntimeCommandActual, CausalRuntimeCommandFailure, type CausalRuntimeCommandRecord, type CausalRuntimeCommandResult, type CausalRuntimeInspectionContext, type CausalRuntimeModelOptions, type CausalRuntimeModelStep, type CausalRuntimeTranscript, type CausalVerificationAwaitContext, type CausalVerificationOptions, type CausalVerificationTranscript, checkpointCommand, type EnqueuedRuntimeAssertionContext, type EnqueuedRuntimeCommandActual, type EnqueuedRuntimeCommandRecord, type EnqueuedRuntimeInspectionContext, type EnqueuedRuntimeModelOptions, type EnqueuedRuntimeModelStep, type EnqueuedRuntimeTranscript, formatCausalTranscript, formatEnqueuedTranscript, formatRuntimeTranscript, runCausalCommands, runEnqueuedCommands, runRuntimeCommands, type RuntimeAssertionContext, type RuntimeAwait, type RuntimeCommand, type RuntimeCommandActual, RuntimeCommandFailure, type RuntimeCommandRecord, type RuntimeCommandResult, type RuntimeCommands, runtimeCommands, type RuntimeCommandsDiagnostics, type RuntimeCommandsOptions, type RuntimeInspectionContext, type RuntimeModelOptions, type RuntimeModelStep, RuntimeObservationError, RuntimeSynchronization, type RuntimeTranscript, sendCommand, stopCommand, verifyCausalCommands } from "../internal/testing/machine/verification.js";
-export type { SchemaArbitraryOpaqueFilterWarning, SchemaArbitraryReport, SchemaArbitraryWarning } from "../internal/testing/machine/verification.js";
-export { compileModel, type FiniteAtomicState, type FiniteAutomaticTransition, type FiniteCompoundState, type FiniteEventTransition, type FiniteFinalState, type FiniteHistoryMutation, type FiniteHistoryScenario, type FiniteHistoryState, type FiniteHistoryTransfer, type FiniteModel, type FiniteModelDiagnostics, type FiniteModelOptions, type FiniteModels, finiteModels, type FiniteParallelState, type FiniteState, type FiniteTransition, type FiniteTransitionTrigger } from "../internal/testing/machine/verification.js";
-export { ModelVerificationError, type ModelVerificationField, type ModelVerificationLocation, type ModelVerificationMismatch, type ReferenceCompletion, type ReferenceHistoryRecord, type ReferenceInitialStep, type ReferenceMicrostep, type ReferenceState, type ReferenceStateValue, type ReferenceStep, type ReferenceTrace, type ReferenceTransition } from "../internal/testing/machine/verification.js";
+export { advanceCommand, type CausalRuntimeAssertionContext, type CausalRuntimeCommandActual, CausalRuntimeCommandFailure, type CausalRuntimeCommandRecord, type CausalRuntimeCommandResult, type CausalRuntimeInspectionContext, type CausalRuntimeModelOptions, type CausalRuntimeModelStep, type CausalRuntimeTranscript, type CausalVerificationAwaitContext, type CausalVerificationOptions, type CausalVerificationTranscript, checkpointCommand, type EnqueuedRuntimeAssertionContext, type EnqueuedRuntimeCommandActual, type EnqueuedRuntimeCommandRecord, type EnqueuedRuntimeInspectionContext, type EnqueuedRuntimeModelOptions, type EnqueuedRuntimeModelStep, type EnqueuedRuntimeTranscript, formatCausalTranscript, formatEnqueuedTranscript, formatRuntimeTranscript, runCausalCommands, runEnqueuedCommands, runRuntimeCommands, type RuntimeAssertionContext, type RuntimeAwait, type RuntimeCommand, type RuntimeCommandActual, RuntimeCommandFailure, type RuntimeCommandRecord, type RuntimeCommandResult, type RuntimeCommands, runtimeCommands, type RuntimeCommandsDiagnostics, type RuntimeCommandsOptions, type RuntimeInspectionContext, type RuntimeModelOptions, type RuntimeModelStep, RuntimeObservationError, RuntimeSynchronization, type RuntimeTranscript, sendCommand, stopCommand, verifyCausalCommands } from "../internal/testing/machine/runtime.js";
+export type { SchemaArbitraryOpaqueFilterWarning, SchemaArbitraryReport, SchemaArbitraryWarning } from "../internal/testing/machine/arbitrary.js";
+export { compileModel, type FiniteAtomicState, type FiniteAutomaticTransition, type FiniteCompoundState, type FiniteEventTransition, type FiniteFinalState, type FiniteHistoryMutation, type FiniteHistoryScenario, type FiniteHistoryState, type FiniteHistoryTransfer, type FiniteModel, type FiniteModelDiagnostics, type FiniteModelOptions, type FiniteModels, finiteModels, type FiniteParallelState, type FiniteState, type FiniteTransition, type FiniteTransitionTrigger } from "../internal/testing/machine/finiteModel.js";
+export { ModelVerificationError, type ModelVerificationField, type ModelVerificationLocation, type ModelVerificationMismatch, type ReferenceCompletion, type ReferenceHistoryRecord, type ReferenceInitialStep, type ReferenceMicrostep, type ReferenceState, type ReferenceStateValue, type ReferenceStep, type ReferenceTrace, type ReferenceTransition } from "../internal/testing/machine/referenceModel.js";
 /**
  * Purely interprets a finite hierarchical model without compiling a
  * machine.
@@ -43,10 +47,10 @@ type RootReadyMachine<M extends AnyMachine> = ReadyMachine<M> & Machine.Machine.
  * @since 0.4.0
  */
 export type Scenario<M extends AnyMachine> = Machine.Machine.InputSchema<M> extends typeof Schema.Void ? {
-    readonly events: ReadonlyArray<Machine.Machine.InputEvent<M>>;
+    readonly events: ReadonlyArray<Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>>;
 } : {
     readonly input: InputValue<M>;
-    readonly events: ReadonlyArray<Machine.Machine.InputEvent<M>>;
+    readonly events: ReadonlyArray<Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>>;
 };
 /**
  * Options for schema-derived scenario generation.
@@ -113,22 +117,19 @@ export interface Scenarios<M extends AnyMachine> {
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
  * class Reset extends Schema.TaggedClass<Reset>("Reset")("Reset", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(Reset),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(Reset),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Idle.from()))
+ * }).handle({ states: {
  *   Idle: {
  *     on: {
  *       Reset: (to) =>
- *         to.full.Idle().resolve(({ target }) => target.from())
+ *         to.branch.Idle().resolve(({ target }) => target.from())
  *     }
  *   }
- * })
+ * } })
  *
  * const generated = MachineTest.scenarios(machine, { maxEvents: 5 })
  * ```
@@ -162,7 +163,7 @@ export interface Microstep<M extends AnyMachine, Requirements = Machine.Machine.
     readonly transitions: ReadonlyArray<Machine.Machine.RetainedTransition<StatePath<M>, Machine.Machine.TagOf<Machine.Machine.Events<M>[number]>, StateNodePath<M>>>;
     readonly commands: ReadonlyArray<Machine.Command>;
     readonly raisedEvents: ReadonlyArray<Machine.Machine.Event<M>>;
-    readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
+    readonly emittedEvents: ReadonlyArray<Machine.Machine.EmittedEvent<M>>;
     readonly exitPaths: ReadonlyArray<string>;
     readonly entryPaths: ReadonlyArray<string>;
     readonly changed: boolean;
@@ -178,7 +179,7 @@ export type InitialPlan<M extends AnyMachine> = {
     readonly initialEntryPaths: ReadonlyArray<StatePath<M>>;
     readonly state: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
     readonly commands: ReadonlyArray<Machine.Command>;
-    readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
+    readonly emittedEvents: ReadonlyArray<Machine.Machine.EmittedEvent<M>>;
     readonly microsteps: ReadonlyArray<Microstep<M, Machine.Machine.InitialServices<M> | Machine.Machine.Services<M>>>;
 } & PlanCompletion<M>;
 /**
@@ -188,9 +189,10 @@ export type InitialPlan<M extends AnyMachine> = {
  * @since 0.4.0
  */
 export type EventPlan<M extends AnyMachine> = {
+    readonly event: Machine.Machine.InputEvent<M>;
     readonly next: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
     readonly commands: ReadonlyArray<Machine.Command>;
-    readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
+    readonly emittedEvents: ReadonlyArray<Machine.Machine.EmittedEvent<M>>;
     readonly microsteps: ReadonlyArray<Microstep<M>>;
 } & PlanCompletion<M>;
 /**
@@ -252,9 +254,10 @@ export type ProbeMicrostep<M extends AnyMachine> = Omit<Microstep<M>, "transitio
  * @since 0.4.0
  */
 export type ProbePlan<M extends AnyMachine> = {
+    readonly event: Machine.Machine.InputEvent<M>;
     readonly next: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
     readonly commands: ReadonlyArray<Machine.Command>;
-    readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
+    readonly emittedEvents: ReadonlyArray<Machine.Machine.EmittedEvent<M>>;
     readonly microsteps: ReadonlyArray<ProbeMicrostep<M>>;
 } & PlanCompletion<M>;
 /**
@@ -289,12 +292,12 @@ export interface ProbeStep<M extends AnyMachine> {
  */
 export interface Probe<M extends AnyMachine, Error = never, Output = never> {
     readonly machine: M;
-    readonly ref: Machine.MachineRef<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Machine.Machine.InputEvent<M>, Error, Output>;
-    readonly sendAndAwait: (event: Machine.Machine.InputEvent<M>) => Effect.Effect<ProbeStep<M>, Error | Machine.StoppedError>;
+    readonly ref: Machine.MachineRef<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>, Error, Output>;
+    readonly sendAndAwait: (event: Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>) => Effect.Effect<ProbeStep<M>, Error | Machine.MachineSchemaDecodeError | Machine.StoppedError>;
     /** Constructors for asynchronous observation after a causal command. */
     readonly await: {
-        readonly none: internal.RuntimeAwait<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>;
-        readonly until: (predicate: (snapshot: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>) => boolean) => internal.RuntimeAwait<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>;
+        readonly none: RuntimeTest.RuntimeAwait<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>;
+        readonly until: (predicate: (snapshot: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>) => boolean) => RuntimeTest.RuntimeAwait<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>;
     };
 }
 /**
@@ -304,7 +307,7 @@ export interface Probe<M extends AnyMachine, Error = never, Output = never> {
  * @category errors
  * @since 0.4.0
  */
-export { ProbeUnavailableError } from "../internal/testing/machine/verification.js";
+export { ProbeUnavailableError } from "../internal/testing/machine/probe.js";
 /**
  * Attaches testing-only causal event delivery to a running statechart.
  *
@@ -320,15 +323,12 @@ export { ProbeUnavailableError } from "../internal/testing/machine/verification.
  * import { MachineTest } from "@typeonce/effect-machine/testing"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const program = Effect.gen(function*() {
  *   const ref = yield* Machine.start(machine)
@@ -339,7 +339,7 @@ export { ProbeUnavailableError } from "../internal/testing/machine/verification.
  * @category runtime testing
  * @since 0.4.0
  */
-export declare const probe: <M extends AnyMachine, Error, Output>(machine: ReadyMachine<M>, ref: Machine.MachineRef<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Machine.Machine.InputEvent<M>, Error, Output>) => Effect.Effect<Probe<M, Error, Output>, internal.ProbeUnavailableError>;
+export declare const probe: <M extends AnyMachine, Error, Output>(machine: ReadyMachine<M>, ref: Machine.MachineRef<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>, Error, Output>) => Effect.Effect<Probe<M, Error, Output>, ProbeTest.ProbeUnavailableError>;
 /**
  * The runtime error channel exposed by a managed reference for a machine.
  *
@@ -355,8 +355,8 @@ export type RuntimeInvariantErrorChannel<M extends AnyMachine> = Machine.Machine
  */
 export interface CausalRuntimeEvidenceRecord<M extends AnyMachine, Error, Output> {
     readonly index: number;
-    readonly command: internal.RuntimeCommand<Machine.Machine.InputEvent<M>>;
-    readonly actual: internal.CausalRuntimeCommandActual<M, Error, Output, unknown>;
+    readonly command: RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>;
+    readonly actual: RuntimeTest.CausalRuntimeCommandActual<M, Error, Output, unknown>;
 }
 /**
  * The model-independent evidence shared by causal command transcripts.
@@ -365,7 +365,7 @@ export interface CausalRuntimeEvidenceRecord<M extends AnyMachine, Error, Output
  * @since 0.4.0
  */
 export interface CausalRuntimeEvidence<M extends AnyMachine, Error, Output> {
-    readonly commands: ReadonlyArray<internal.RuntimeCommand<Machine.Machine.InputEvent<M>>>;
+    readonly commands: ReadonlyArray<RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>>;
     readonly initial: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>;
     readonly records: ReadonlyArray<CausalRuntimeEvidenceRecord<M, Error, Output>>;
     readonly final: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>;
@@ -392,8 +392,8 @@ export type RuntimeSnapshotObservation = "initial" | "command" | "awaited" | "fi
  */
 export interface RuntimeInvariantRecord<M extends AnyMachine> {
     readonly index: number;
-    readonly command: internal.RuntimeCommand<Machine.Machine.InputEvent<M>>;
-    readonly result: internal.CausalRuntimeCommandResult<M>;
+    readonly command: RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>;
+    readonly result: RuntimeTest.CausalRuntimeCommandResult<M>;
     readonly snapshot: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, RuntimeInvariantErrorChannel<M>, Machine.Machine.Output<M>>;
     readonly awaited: ReadonlyArray<Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, RuntimeInvariantErrorChannel<M>, Machine.Machine.Output<M>>>;
 }
@@ -404,7 +404,7 @@ export interface RuntimeInvariantRecord<M extends AnyMachine> {
  * @since 0.4.0
  */
 export interface RuntimeInvariantTranscript<M extends AnyMachine> {
-    readonly commands: ReadonlyArray<internal.RuntimeCommand<Machine.Machine.InputEvent<M>>>;
+    readonly commands: ReadonlyArray<RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>>;
     readonly initial: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, RuntimeInvariantErrorChannel<M>, Machine.Machine.Output<M>>;
     readonly records: ReadonlyArray<RuntimeInvariantRecord<M>>;
     readonly final: Machine.RuntimeSnapshot<Machine.Machine.Snapshot<Machine.Machine.States<M>>, RuntimeInvariantErrorChannel<M>, Machine.Machine.Output<M>>;
@@ -423,8 +423,8 @@ export interface RuntimeSnapshotInvariantContext<M extends AnyMachine> {
     readonly phase: RuntimeSnapshotObservation;
     readonly commandIndex: number | undefined;
     readonly awaitedIndex: number | undefined;
-    readonly command: internal.RuntimeCommand<Machine.Machine.InputEvent<M>> | undefined;
-    readonly result: internal.CausalRuntimeCommandResult<M> | undefined;
+    readonly command: RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>> | undefined;
+    readonly result: RuntimeTest.CausalRuntimeCommandResult<M> | undefined;
 }
 /**
  * Evidence passed to an invariant for one completed causal command.
@@ -438,8 +438,8 @@ export interface RuntimeCommandInvariantContext<M extends AnyMachine> {
     readonly record: RuntimeInvariantRecord<M>;
     readonly previous: RuntimeInvariantRecord<M> | undefined;
     readonly index: number;
-    readonly command: internal.RuntimeCommand<Machine.Machine.InputEvent<M>>;
-    readonly result: internal.CausalRuntimeCommandResult<M>;
+    readonly command: RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>;
+    readonly result: RuntimeTest.CausalRuntimeCommandResult<M>;
     readonly snapshot: RuntimeInvariantRecord<M>["snapshot"];
     readonly awaited: RuntimeInvariantRecord<M>["awaited"];
 }
@@ -564,7 +564,7 @@ export interface RuntimeInvariantViolation<M extends AnyMachine = AnyMachine> {
     readonly commandIndex: number | undefined;
     readonly awaitedIndex?: number;
     readonly phase?: RuntimeSnapshotObservation;
-    readonly command?: internal.RuntimeCommand<Machine.Machine.InputEvent<M>>;
+    readonly command?: RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>;
     readonly message: string;
 }
 /**
@@ -573,21 +573,21 @@ export interface RuntimeInvariantViolation<M extends AnyMachine = AnyMachine> {
  * @category errors
  * @since 0.4.0
  */
-export { RuntimeInvariantError } from "../internal/testing/machine/verification.js";
+export { RuntimeInvariantError } from "../internal/testing/machine/runtimeInvariant.js";
 /**
  * Checks runtime invariants and returns their complete non-vacuity report.
  *
  * @category verification
  * @since 0.4.0
  */
-export declare const checkRuntimeInvariants: <M extends AnyMachine, Error, Output>(machine: M, transcript: CausalRuntimeEvidence<M, Error, Output>, invariants: ReadonlyArray<RuntimeInvariant<M>>) => Effect.Effect<RuntimeInvariantReport, internal.RuntimeInvariantError<M>>;
+export declare const checkRuntimeInvariants: <M extends AnyMachine, Error, Output>(machine: M, transcript: CausalRuntimeEvidence<M, Error, Output>, invariants: ReadonlyArray<RuntimeInvariant<M>>) => Effect.Effect<RuntimeInvariantReport, RuntimeInvariantTest.RuntimeInvariantError<M>>;
 /**
  * Asserts runtime invariants against an existing causal transcript.
  *
  * @category verification
  * @since 0.4.0
  */
-export declare const assertRuntimeInvariants: <M extends AnyMachine, Error, Output>(machine: M, transcript: CausalRuntimeEvidence<M, Error, Output>, invariants: ReadonlyArray<RuntimeInvariant<M>>) => Effect.Effect<void, internal.RuntimeInvariantError<M>>;
+export declare const assertRuntimeInvariants: <M extends AnyMachine, Error, Output>(machine: M, transcript: CausalRuntimeEvidence<M, Error, Output>, invariants: ReadonlyArray<RuntimeInvariant<M>>) => Effect.Effect<void, RuntimeInvariantTest.RuntimeInvariantError<M>>;
 /**
  * One disagreement between pure planning and a causally processed send.
  *
@@ -596,7 +596,7 @@ export declare const assertRuntimeInvariants: <M extends AnyMachine, Error, Outp
  */
 export interface PlannerRuntimeAgreementViolation<M extends AnyMachine = AnyMachine> {
     readonly commandIndex: number;
-    readonly command: internal.RuntimeCommand<Machine.Machine.InputEvent<M>>;
+    readonly command: RuntimeTest.RuntimeCommand<Machine.Machine.InputEvent<M>>;
     readonly field: "planning" | "handled" | "configurationChanged" | "planNext" | "after" | "completion" | "commands" | "emittedEvents" | "microsteps";
     readonly message: string;
 }
@@ -606,14 +606,14 @@ export interface PlannerRuntimeAgreementViolation<M extends AnyMachine = AnyMach
  * @category errors
  * @since 0.4.0
  */
-export { PlannerRuntimeAgreementError } from "../internal/testing/machine/verification.js";
+export { PlannerRuntimeAgreementError } from "../internal/testing/machine/runtimeInvariant.js";
 /**
  * Checks that every processed public send agrees with a fresh pure plan.
  *
  * @category verification
  * @since 0.4.0
  */
-export declare const assertPlannerRuntimeAgreement: <M extends AnyMachine, Error, Output>(machine: RootReadyMachine<M>, transcript: CausalRuntimeEvidence<M, Error, Output>) => Effect.Effect<void, internal.PlannerRuntimeAgreementError<M>, RunServices<M>>;
+export declare const assertPlannerRuntimeAgreement: <M extends AnyMachine, Error, Output>(machine: RootReadyMachine<M>, transcript: CausalRuntimeEvidence<M, Error, Output>) => Effect.Effect<void, RuntimeInvariantTest.PlannerRuntimeAgreementError<M>, RunServices<M>>;
 /**
  * The result of evaluating one semantic invariant.
  *
@@ -791,15 +791,12 @@ export declare const Invariant: {
  * class Count extends Schema.TaggedClass<Count>("Count")("Count", {
  *   value: Schema.Number
  * }) {}
- * const States = Machine.states({ Count })
+ * const States = Machine.state({ initial: "Count", states: { Count } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Count(),
- *     resolve: ({ target }) => target.decoded(new Count({ value: 0 }))
- *   }
- * }).handle({ Count: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Count.decoded(new Count({ value: 0 }))))
+ * }).handle({ states: { Count: {} } })
  *
  * const nonNegative = MachineTest.invariants(machine).state(
  *   "count is non-negative",
@@ -875,7 +872,7 @@ export interface InvariantViolation<M extends AnyMachine = AnyMachine> {
  * @category errors
  * @since 0.4.0
  */
-export { InvariantError } from "../internal/testing/machine/verification.js";
+export { InvariantError } from "../internal/testing/machine/invariant.js";
 /**
  * Checks user-defined semantic invariants against an existing planner trace.
  *
@@ -886,7 +883,7 @@ export { InvariantError } from "../internal/testing/machine/verification.js";
  * @category verification
  * @since 0.4.0
  */
-export declare const checkInvariants: <M extends AnyMachine>(machine: M, trace: Trace<M>, invariants: ReadonlyArray<Invariant<M>>) => Effect.Effect<InvariantReport, internal.InvariantError<M>>;
+export declare const checkInvariants: <M extends AnyMachine>(machine: M, trace: Trace<M>, invariants: ReadonlyArray<Invariant<M>>) => Effect.Effect<InvariantReport, InvariantTest.InvariantError<M>>;
 /**
  * Asserts user-defined semantic invariants and discards the success report.
  *
@@ -897,7 +894,7 @@ export declare const checkInvariants: <M extends AnyMachine>(machine: M, trace:
  * @category verification
  * @since 0.4.0
  */
-export declare const assertInvariants: <M extends AnyMachine>(machine: M, trace: Trace<M>, invariants: ReadonlyArray<Invariant<M>>) => Effect.Effect<void, internal.InvariantError<M>>;
+export declare const assertInvariants: <M extends AnyMachine>(machine: M, trace: Trace<M>, invariants: ReadonlyArray<Invariant<M>>) => Effect.Effect<void, InvariantTest.InvariantError<M>>;
 /**
  * User-defined identity for a logical exploration state.
  *
@@ -1083,23 +1080,20 @@ export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = Ex
  *   value: Schema.Number
  * }) {}
  * class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {}) {}
- * const States = Machine.states({ Count })
+ * const States = Machine.state({ initial: "Count", states: { Count } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(Increment),
- *   initial: {
- *     target: (to) => to.Count(),
- *     resolve: ({ target }) => target.decoded(new Count({ value: 0 }))
- *   }
- * }).handle({
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(Increment),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Count.decoded(new Count({ value: 0 }))))
+ * }).handle({ states: {
  *   Count: {
  *     on: {
  *       Increment: (to) =>
- *         to.full.Count().resolve(({ state, target }) =>
+ *         to.branch.Count().resolve(({ state, target }) =>
  *           target.decoded(new Count({ value: state.value + 1 })))
  *     }
  *   }
- * })
+ * } })
  *
  * const explored = MachineTest.explore(machine, {
  *   events: ({ snapshot }) => snapshot.value.value < 2 ? [new Increment({})] : [],
@@ -1110,7 +1104,7 @@ export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = Ex
  * @category exploration
  * @since 0.4.0
  */
-export declare const explore: <M extends AnyMachine, Key extends ExplorationKey>(machine: RootReadyMachine<M>, options: ExploreOptions<M, Key>) => Effect.Effect<Exploration<M, Key>, RunFailure<RunError<M>, M> | internal.InvariantError<M>, RunServices<M>>;
+export declare const explore: <M extends AnyMachine, Key extends ExplorationKey>(machine: RootReadyMachine<M>, options: ExploreOptions<M, Key>) => Effect.Effect<Exploration<M, Key>, RunFailure<RunError<M>, M> | InvariantTest.InvariantError<M>, RunServices<M>>;
 /**
  * A predicate over one explored logical state.
  *
@@ -1131,7 +1125,7 @@ export type ReachabilityFailure = "NotFound" | "UnexpectedMatch" | "Inconclusive
  * @category errors
  * @since 0.4.0
  */
-export { ReachabilityError } from "../internal/testing/machine/verification.js";
+export { ReachabilityError } from "../internal/testing/machine/exploration.js";
 /**
  * Finds the first, and therefore shortest, explored state matching a
  * predicate.
@@ -1149,7 +1143,7 @@ export declare const findShortest: <M extends AnyMachine, Key extends Exploratio
  * @category exploration
  * @since 0.4.0
  */
-export declare const assertReachable: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, name: string, predicate: ExplorationPredicate<M, Key>) => Effect.Effect<ExplorationNode<M, Key>, internal.ReachabilityError<M, Key>>;
+export declare const assertReachable: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, name: string, predicate: ExplorationPredicate<M, Key>) => Effect.Effect<ExplorationNode<M, Key>, ExplorationImpl.ReachabilityError<M, Key>>;
 /**
  * Requires that no explored state matches a predicate.
  *
@@ -1159,7 +1153,7 @@ export declare const assertReachable: <M extends AnyMachine, Key extends Explora
  * @category exploration
  * @since 0.4.0
  */
-export declare const assertUnreachable: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, name: string, predicate: ExplorationPredicate<M, Key>) => Effect.Effect<void, internal.ReachabilityError<M, Key>>;
+export declare const assertUnreachable: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, name: string, predicate: ExplorationPredicate<M, Key>) => Effect.Effect<void, ExplorationImpl.ReachabilityError<M, Key>>;
 /**
  * Checks a real planner trace against the independent finite statechart model
  * interpreter.
@@ -1193,7 +1187,7 @@ export type RunFailure<Cause, M extends AnyMachine = AnyMachine> = {
     readonly scenario: Scenario<M>;
     readonly phase: "event";
     readonly eventIndex: number;
-    readonly event: Machine.Machine.InputEvent<M>;
+    readonly event: Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>;
     readonly initial: InitialTrace<M>;
     readonly steps: ReadonlyArray<TraceStep<M>>;
     readonly cause: Cause;
@@ -1232,15 +1226,12 @@ export type RunServices<M extends AnyMachine> = IsAny<Machine.PlanningServices<M
  * import { MachineTest } from "@typeonce/effect-machine/testing"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const trace = MachineTest.run(machine, { events: [] })
  * ```
@@ -1465,15 +1456,12 @@ export interface Coverage<M extends AnyMachine> {
  * import { MachineTest } from "@typeonce/effect-machine/testing"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const report = Effect.map(
  *   MachineTest.run(machine, { events: [] }),
@@ -1522,7 +1510,7 @@ export interface ObservedGraphMicrostep<M extends AnyMachine> {
     readonly event: Machine.Machine.Event<M> | Machine.InitialEvent;
     readonly transitions: Microstep<M, any>["transitions"];
     readonly raisedEvents: ReadonlyArray<Machine.Machine.Event<M>>;
-    readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
+    readonly emittedEvents: ReadonlyArray<Machine.Machine.EmittedEvent<M>>;
     readonly exitPaths: ReadonlyArray<StatePath<M>>;
     readonly entryPaths: ReadonlyArray<StatePath<M>>;
     readonly changed: boolean;
@@ -1635,15 +1623,12 @@ export interface VerifyOptions {
  * import { MachineTest } from "@typeonce/effect-machine/testing"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(tree => tree.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const checked = Effect.gen(function*() {
  *   const trace = yield* MachineTest.run(machine, { events: [] })