@typeonce/effect-machine 0.31.2 → 0.32.0

package/src/testing/MachineTest.ts

@@ -10,8 +10,15 @@ 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 Format from "../internal/testing/machine/format.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 * as TraceImpl from "../internal/testing/machine/trace.js"
 import * as internal from "../internal/testing/machine/verification.js"
 import type { VerificationError } from "../internal/testing/machine/verification.js"
 import type * as Machine from "../Machine.js"
@@ -64,13 +71,13 @@ export {
   sendCommand,
   stopCommand,
   verifyCausalCommands
-} from "../internal/testing/machine/verification.js"
+} from "../internal/testing/machine/runtime.js"
 
 export type {
   SchemaArbitraryOpaqueFilterWarning,
   SchemaArbitraryReport,
   SchemaArbitraryWarning
-} from "../internal/testing/machine/verification.js"
+} from "../internal/testing/machine/arbitrary.js"
 
 export {
   compileModel,
@@ -92,7 +99,7 @@ export {
   type FiniteState,
   type FiniteTransition,
   type FiniteTransitionTrigger
-} from "../internal/testing/machine/verification.js"
+} from "../internal/testing/machine/finiteModel.js"
 
 export {
   ModelVerificationError,
@@ -108,7 +115,7 @@ export {
   type ReferenceStep,
   type ReferenceTrace,
   type ReferenceTransition
-} from "../internal/testing/machine/verification.js"
+} from "../internal/testing/machine/referenceModel.js"
 
 /**
  * Purely interprets a finite hierarchical model without compiling a
@@ -118,7 +125,7 @@ export {
  * @since 0.4.0
  */
 export const interpretModel: (model: FiniteModel, events: ReadonlyArray<string>) => ReferenceModel.ReferenceTrace =
-  internal.interpretModel
+  ReferenceModel.interpretModel
 
 type AnyMachine = Machine.Machine.Any
 
@@ -152,11 +159,11 @@ type RootReadyMachine<M extends AnyMachine> =
  * @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>>>
   }
 
 /**
@@ -231,22 +238,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 })
  * ```
@@ -294,7 +298,7 @@ export interface Microstep<
   >
   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
@@ -312,7 +316,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>>
     >
@@ -327,9 +331,10 @@ export type InitialPlan<M extends AnyMachine> =
  */
 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>
@@ -398,9 +403,10 @@ export type ProbeMicrostep<M extends AnyMachine> = Omit<Microstep<M>, "transitio
  */
 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>
@@ -440,16 +446,16 @@ 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>,
+    Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
     Error,
     Output
   >
   readonly sendAndAwait: (
-    event: Machine.Machine.InputEvent<M>
-  ) => Effect.Effect<ProbeStep<M>, Error | Machine.StoppedError>
+    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<
+    readonly none: RuntimeTest.RuntimeAwait<
       Machine.Machine.Snapshot<Machine.Machine.States<M>>,
       Error,
       Output
@@ -462,7 +468,7 @@ export interface Probe<M extends AnyMachine, Error = never, Output = never> {
           Output
         >
       ) => boolean
-    ) => internal.RuntimeAwait<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>
+    ) => RuntimeTest.RuntimeAwait<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Error, Output>
   }
 }
 
@@ -473,7 +479,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.
@@ -490,15 +496,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)
@@ -513,11 +516,11 @@ export const probe: <M extends AnyMachine, Error, Output>(
   machine: ReadyMachine<M>,
   ref: Machine.MachineRef<
     Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-    Machine.Machine.InputEvent<M>,
+    Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
     Error,
     Output
   >
-) => Effect.Effect<Probe<M, Error, Output>, internal.ProbeUnavailableError> = internal.probe
+) => Effect.Effect<Probe<M, Error, Output>, ProbeTest.ProbeUnavailableError> = ProbeTest.probe
 
 /**
  * The runtime error channel exposed by a managed reference for a machine.
@@ -540,8 +543,8 @@ export type RuntimeInvariantErrorChannel<M extends AnyMachine> =
  */
 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>
 }
 
 /**
@@ -551,7 +554,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>
@@ -581,8 +584,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>,
@@ -604,7 +607,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>,
@@ -632,8 +635,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
 }
 
 /**
@@ -648,8 +651,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"]
 }
@@ -762,7 +765,7 @@ export interface RuntimeInvariantBuilder<M extends AnyMachine> {
  * @since 0.4.0
  */
 export const runtimeInvariants: <M extends AnyMachine>(machine: M) => RuntimeInvariantBuilder<M> =
-  internal.runtimeInvariants
+  RuntimeInvariantTest.runtimeInvariants
 
 /**
  * Scope of a runtime invariant.
@@ -810,7 +813,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
 }
 
@@ -820,7 +823,7 @@ 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.
@@ -832,7 +835,8 @@ export const checkRuntimeInvariants: <M extends AnyMachine, Error, Output>(
   machine: M,
   transcript: CausalRuntimeEvidence<M, Error, Output>,
   invariants: ReadonlyArray<RuntimeInvariant<M>>
-) => Effect.Effect<RuntimeInvariantReport, internal.RuntimeInvariantError<M>> = internal.checkRuntimeInvariants
+) => Effect.Effect<RuntimeInvariantReport, RuntimeInvariantTest.RuntimeInvariantError<M>> =
+  RuntimeInvariantTest.checkRuntimeInvariants
 
 /**
  * Asserts runtime invariants against an existing causal transcript.
@@ -844,7 +848,7 @@ export const assertRuntimeInvariants: <M extends AnyMachine, Error, Output>(
   machine: M,
   transcript: CausalRuntimeEvidence<M, Error, Output>,
   invariants: ReadonlyArray<RuntimeInvariant<M>>
-) => Effect.Effect<void, internal.RuntimeInvariantError<M>> = internal.assertRuntimeInvariants
+) => Effect.Effect<void, RuntimeInvariantTest.RuntimeInvariantError<M>> = RuntimeInvariantTest.assertRuntimeInvariants
 
 /**
  * One disagreement between pure planning and a causally processed send.
@@ -854,7 +858,7 @@ export const assertRuntimeInvariants: <M extends AnyMachine, Error, Output>(
  */
 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"
@@ -874,7 +878,7 @@ 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.
@@ -885,8 +889,8 @@ export { PlannerRuntimeAgreementError } from "../internal/testing/machine/verifi
 export const assertPlannerRuntimeAgreement: <M extends AnyMachine, Error, Output>(
   machine: RootReadyMachine<M>,
   transcript: CausalRuntimeEvidence<M, Error, Output>
-) => Effect.Effect<void, internal.PlannerRuntimeAgreementError<M>, RunServices<M>> =
-  internal.assertPlannerRuntimeAgreement
+) => Effect.Effect<void, RuntimeInvariantTest.PlannerRuntimeAgreementError<M>, RunServices<M>> =
+  RuntimeInvariantTest.assertPlannerRuntimeAgreement
 
 /**
  * The result of evaluating one semantic invariant.
@@ -1086,7 +1090,7 @@ export const Invariant: {
     check: (context: TraceInvariantContext<M>) => InvariantOutcome,
     options?: InvariantOptions<TraceInvariantContext<M>>
   ) => TraceInvariant<M>
-} = internal.Invariant
+} = InvariantTest.Invariant
 
 /**
  * Creates invariant constructors bound to a machine's exact state and event
@@ -1103,15 +1107,12 @@ export 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",
@@ -1122,7 +1123,7 @@ export const Invariant: {
  * @category constructors
  * @since 0.4.0
  */
-export const invariants: <M extends AnyMachine>(machine: M) => InvariantBuilder<M> = internal.invariants
+export const invariants: <M extends AnyMachine>(machine: M) => InvariantBuilder<M> = InvariantTest.invariants
 
 /**
  * The scope of a semantic invariant.
@@ -1193,7 +1194,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.
@@ -1209,7 +1210,7 @@ export const checkInvariants: <M extends AnyMachine>(
   machine: M,
   trace: Trace<M>,
   invariants: ReadonlyArray<Invariant<M>>
-) => Effect.Effect<InvariantReport, internal.InvariantError<M>> = internal.checkInvariants
+) => Effect.Effect<InvariantReport, InvariantTest.InvariantError<M>> = InvariantTest.checkInvariants
 
 /**
  * Asserts user-defined semantic invariants and discards the success report.
@@ -1225,7 +1226,7 @@ export const assertInvariants: <M extends AnyMachine>(
   machine: M,
   trace: Trace<M>,
   invariants: ReadonlyArray<Invariant<M>>
-) => Effect.Effect<void, internal.InvariantError<M>> = internal.assertInvariants
+) => Effect.Effect<void, InvariantTest.InvariantError<M>> = InvariantTest.assertInvariants
 
 /**
  * User-defined identity for a logical exploration state.
@@ -1438,23 +1439,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({})] : [],
@@ -1470,9 +1468,9 @@ export const explore: <M extends AnyMachine, Key extends ExplorationKey>(
   options: ExploreOptions<M, Key>
 ) => Effect.Effect<
   Exploration<M, Key>,
-  RunFailure<RunError<M>, M> | internal.InvariantError<M>,
+  RunFailure<RunError<M>, M> | InvariantTest.InvariantError<M>,
   RunServices<M>
-> = internal.explore
+> = ExplorationImpl.explore
 
 /**
  * A predicate over one explored logical state.
@@ -1498,7 +1496,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
@@ -1510,7 +1508,7 @@ export { ReachabilityError } from "../internal/testing/machine/verification.js"
 export const findShortest: <M extends AnyMachine, Key extends ExplorationKey>(
   exploration: Exploration<M, Key>,
   predicate: ExplorationPredicate<M, Key>
-) => ExplorationNode<M, Key> | undefined = internal.findShortest
+) => ExplorationNode<M, Key> | undefined = ExplorationImpl.findShortest
 
 /**
  * Requires a matching state and returns its shortest witness.
@@ -1525,7 +1523,7 @@ export 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>> = internal.assertReachable
+) => Effect.Effect<ExplorationNode<M, Key>, ExplorationImpl.ReachabilityError<M, Key>> = ExplorationImpl.assertReachable
 
 /**
  * Requires that no explored state matches a predicate.
@@ -1540,7 +1538,7 @@ export const assertUnreachable: <M extends AnyMachine, Key extends ExplorationKe
   exploration: Exploration<M, Key>,
   name: string,
   predicate: ExplorationPredicate<M, Key>
-) => Effect.Effect<void, internal.ReachabilityError<M, Key>> = internal.assertUnreachable
+) => Effect.Effect<void, ExplorationImpl.ReachabilityError<M, Key>> = ExplorationImpl.assertUnreachable
 
 /**
  * Checks a real planner trace against the independent finite statechart model
@@ -1581,7 +1579,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
@@ -1630,15 +1628,12 @@ export type RunServices<M extends AnyMachine> = IsAny<
  * 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: [] })
  * ```
@@ -1649,7 +1644,7 @@ export type RunServices<M extends AnyMachine> = IsAny<
 export const run: <M extends AnyMachine>(
   machine: RootReadyMachine<M>,
   scenario: Scenario<M>
-) => Effect.Effect<Trace<M>, RunFailure<RunError<M>, M>, RunServices<M>> = internal.run
+) => Effect.Effect<Trace<M>, RunFailure<RunError<M>, M>, RunServices<M>> = TraceImpl.run
 
 /**
  * A deterministic hit/miss summary for a finite set declared by a machine.
@@ -1899,15 +1894,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: [] }),
@@ -1962,7 +1954,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
@@ -2128,15 +2120,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: [] })
@@ -2164,4 +2153,4 @@ export const verify: <M extends AnyMachine>(
  * @since 0.4.0
  */
 export const formatTrace: <M extends AnyMachine, Cause>(trace: Trace<M> | RunFailure<Cause, M>) => string =
-  internal.formatTrace
+  Format.formatTrace

package/src/unstable/cluster/ClusterMachine.ts

@@ -12,6 +12,7 @@ import type { Rpc } from "effect/unstable/rpc"
 import * as internal from "../../internal/machine/cluster.js"
 import { Accepted, Rejected, Storage } from "../../internal/machine/cluster.js"
 import type { EnsureExecutable } from "../../internal/machine/readiness.js"
+import type { ExcludeCompatibleRuntime } from "../../internal/machine/requirements.js"
 import type * as Machine from "../../Machine.js"
 
 type Snowflake = Snowflake.Snowflake
@@ -191,7 +192,7 @@ type SendRpc<Events extends ReadonlyArray<Machine.Machine.TaggedSchema>> = Rpc.R
 
 type MachineEvents<M extends Machine.Machine.Any> = Machine.Machine.InputEvents<M>
 
-type MachineEmits<M extends Machine.Machine.Any> = Machine.Machine.Emits<M>
+type MachineEmits<M extends Machine.Machine.Any> = Machine.Machine.EmittedEvents<M>
 
 /**
  * Cluster adapter for one machine definition and entity type.
@@ -231,7 +232,7 @@ export interface ClusterMachine<
    */
   readonly toLayer: <R = never>(options?: {
     readonly enqueue?: (
-      event: Machine.Machine.EmitOf<MachineEmits<M>>
+      event: Machine.Machine.EmittedEventOf<MachineEmits<M>>
     ) => Effect.Effect<void, unknown, R>
   }) => Layer.Layer<never, never, Storage | MessageStorage.MessageStorage | Sharding.Sharding | R | Services>
 }
@@ -240,7 +241,7 @@ type MachineServices<M extends Machine.Machine.Any> =
   | ExcludeCompatibleRuntime<
     Machine.ExecutionServices<Machine.Machine.Services<M> | Machine.Machine.InitialServices<M>>,
     Machine.Machine.Event<M>,
-    Machine.Machine.Emit<M>
+    Machine.Machine.EmittedEvent<M>
   >
   | Machine.Machine.SnapshotDecodingServices<Machine.Machine.States<M>>
   | Machine.Machine.SnapshotEncodingServices<Machine.Machine.States<M>>
@@ -292,14 +293,6 @@ type EnsureJsonEncoded<
     }
   }
 
-type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Machine.Runtime.Requirement<
-  infer RequiredEvents,
-  infer RequiredEmits
-> ? IsAny<Requirements> extends true ? Requirements
-  : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements
-  : Requirements
-  : Requirements
-
 /**
  * Creates an in-memory Cluster machine checkpoint store.
  *
@@ -361,15 +354,12 @@ export const layerMemory: Layer.Layer<Storage> = internal.layerMemory
  * import { ClusterMachine } from "@typeonce/effect-machine/cluster"
  *
  * 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 adapter = ClusterMachine.make("IdleMachine", machine, { version: "1" })
  * ```
@@ -440,7 +430,7 @@ export const make: <
   | ExcludeCompatibleRuntime<
     Machine.ExecutionServices<R | InitialR>,
     Machine.Machine.EventOf<Events>,
-    Machine.Machine.EmitOf<Emits>
+    Machine.Machine.EmittedEventOf<Emits>
   >
   | Machine.Machine.SnapshotDecodingServices<States>
   | Machine.Machine.SnapshotEncodingServices<States>