@typeonce/effect-machine 0.31.2 → 0.33.0

package/src/internal/machine/machine.ts

@@ -3,7 +3,7 @@ import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import { Prototype as PipeablePrototype } from "effect/Pipeable"
 import { hasProperty } from "effect/Predicate"
-import type * as Schema from "effect/Schema"
+import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type {
@@ -21,22 +21,31 @@ import type {
   MachineSchemaEncodeError,
   Parent,
   ParentMode,
-  Runtime,
   RuntimeOutcome,
   SpawnOptions,
+  State,
   StoppedError
 } from "../../Machine.js"
 import * as Activities from "./activities.js"
 import * as Configuration from "./configuration.js"
 import type { ChildAlreadyExistsError, InfiniteTransitionError, StartupError } from "./errors.js"
+import * as InvocationDefinition from "./invocationDefinition.js"
 import * as internalPlanner from "./planner.js"
 import * as internalProcess from "./process.js"
 import * as Protocol from "./protocol.js"
 import type { EnsureExecutable } from "./readiness.js"
+import type { ExcludeCompatibleRuntime } from "./requirements.js"
 import * as internalRuntime from "./runtime.js"
 import * as Serialization from "./serialization.js"
 import * as StateDefinition from "./stateDefinition.js"
-import { ChildMachineLogicTypeId, SnapshotBuilderStateTypeId } from "./symbols.js"
+import { ChildMachineLogicTypeId } from "./symbols.js"
+import {
+  getLocalTargetScope,
+  getTargetBuilderNode,
+  makeSnapshotBuilder,
+  makeTargetBuilder,
+  withFrom
+} from "./targetBuilder.js"
 import * as Topology from "./topology.js"
 
 export {
@@ -56,15 +65,8 @@ export const InvokeTypeId: unique symbol = Symbol.for("effect/Machine/Invoke")
 export const TransitionTypeId: unique symbol = Symbol.for("effect/Machine/Transition")
 const InvokeBuilderDescriptorTypeId: unique symbol = Symbol("effect/Machine/InvokeBuilderDescriptor")
 const ChildMachineTypeId = "~effect/Machine/ChildMachine"
-type IsAny<A> = 0 extends 1 & A ? true : false
 type MachineRuntimeRequirement = internalRuntime.MachineRuntime
-type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<
-  infer RequiredEvents,
-  infer RequiredEmits
-> ? IsAny<Requirements> extends true ? Requirements
-  : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements
-  : Requirements
-  : Requirements
+
 type SpawnRequirements<Requirements> = Exclude<Requirements, Scope.Scope>
 type SpawnIdError<Options extends SpawnOptions> = "id" extends keyof Options ? Options extends {
     readonly id?: infer Id
@@ -77,34 +79,6 @@ type SpawnResult<State, Event, Error, Requirements, Output, SpawnError, InitialE
   SpawnError | InitialError,
   MachineRuntimeRequirement | SpawnRequirements<Requirements>
 >
-type DefineStateTreeInput<States extends Machine.StateSchemas> = States
-type ValidateDefinedStates<States extends Machine.StateSchemas> = [States] extends
-  [Machine.ValidateStateSchemas<States>] ? []
-  : [validation: Machine.ValidateStateSchemas<States>]
-type InvalidDefinedStateTreeInput<States extends Machine.StateSchemas> = [States] extends
-  [Machine.ValidateStateSchemas<States>] ? never
-  : States & Machine.ValidateStateSchemas<States>
-type ReusableStateNodeConfig =
-  | Machine.AtomicStateNodeConfig
-  | Machine.CompoundStateNodeConfig
-  | Machine.ParallelStateNodeConfig
-interface StateConstructor {
-  <const Node extends ReusableStateNodeConfig>(node: Node): Node
-}
-interface StatesConstructor {
-  <const States extends Machine.StateSchemas>(
-    states: States,
-    ..._validation: ValidateDefinedStates<NoInfer<States>>
-  ): Machine.DefinedStates<States>
-  <const States extends Machine.StateSchemas>(states: InvalidDefinedStateTreeInput<States>): never
-}
-type ValidateInputEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>> = InputEvents extends
-  ReadonlyArray<Machine.TaggedSchema> ? unknown : never
-type ValidateInternalEventProtocol<
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>
-> = InputEvents | InternalEvents extends ReadonlyArray<Machine.TaggedSchema> ? unknown : never
-
 const Proto = {
   ...Inspectable.BaseProto,
   ...PipeablePrototype,
@@ -122,6 +96,7 @@ const makeWithHandlers = (
 ): Machine.Any => {
   const machine = Object.create(Proto)
   machine.states = self.states
+  machine.root = self.root
   machine.events = self.events
   machine.internalEvents = self.internalEvents
   machine.emittedEvents = self.emittedEvents
@@ -164,8 +139,8 @@ type DirectTransitionDescriptor = {
   readonly [TransitionBuilderDescriptorTypeId]: typeof TransitionBuilderDescriptorTypeId
   readonly type: "direct"
   readonly selection: Topology.TargetSelection
-  readonly resolve?: (context: any, enqueue: unknown) => unknown
-  readonly reenter: boolean
+  readonly resolver?: (context: any, enqueue: unknown) => unknown
+  readonly reenterSource: boolean
   readonly declinable: boolean
 }
 
@@ -174,7 +149,7 @@ type BranchesTransitionDescriptor = {
   readonly type: "branches"
   readonly declarations: unknown
   readonly resolve: (context: any, enqueue: unknown) => unknown
-  readonly reenter: boolean
+  readonly reenterSource: boolean
   readonly declinable: boolean
 }
 
@@ -193,38 +168,95 @@ const plainTargetSelection = (selection: Topology.TargetSelection): Topology.Tar
     ? Topology.noneTargetSelection
     : Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, selection.updatePath)
 
-const transitionOptions = (options: unknown): { readonly reenter: boolean; readonly declinable: boolean } => {
+const transitionOptions = (options: unknown): { readonly declinable: boolean } => {
   const configuration = typeof options === "object" && options !== null
-    ? options as { readonly reenter?: unknown; readonly declinable?: unknown }
+    ? options as { readonly declinable?: unknown }
     : {}
-  return {
-    reenter: configuration.reenter === true,
-    declinable: configuration.declinable === true
+  if (hasProperty(configuration, "reenter")) {
+    throw new Error("Use .reenter() before construction instead of the resolver reenter option")
   }
+  return { declinable: configuration.declinable === true }
 }
 
 const makeDirectTransitionDescriptor = (
   selection: Topology.TargetSelection,
   resolve: ((context: any, enqueue: unknown) => unknown) | undefined,
-  options: unknown
+  options: unknown,
+  reenterSource = false
 ): DirectTransitionDescriptor => {
-  const shared: Omit<DirectTransitionDescriptor, "resolve"> = {
+  const shared: Omit<DirectTransitionDescriptor, "resolver"> = {
     [TransitionBuilderDescriptorTypeId]: TransitionBuilderDescriptorTypeId,
     type: "direct",
     selection: plainTargetSelection(selection),
+    reenterSource,
     ...transitionOptions(options)
   }
   return resolve === undefined
     ? Object.freeze(shared)
-    : Object.freeze({ ...shared, resolve })
+    : Object.freeze({ ...shared, resolver: resolve })
 }
 
-const decorateTransitionSelection = (selection: Topology.TargetSelection): Topology.TargetSelection =>
+// The authored callback crosses an erased schema boundary here. Each builder
+// retains its construction mode, and planning validates both resulting values.
+const constructSelectionValue = (
+  selection: Topology.TargetSelection,
+  context: any,
+  method: "from" | "decoded",
+  value: unknown
+): unknown => {
+  if (selection.kind === "update") return context.owner[method](value)
+  if (selection.updatePath === undefined) return context.target[method](value)
+  const values = value as { readonly target: unknown; readonly update: unknown }
+  return context.target[method](values.target).update(context.owner[method](values.update))
+}
+
+const guardedSelection = (
+  selection: Topology.TargetSelection,
+  predicate: (context: any) => boolean,
+  reenterSource: boolean
+): object => {
+  const wrap = (resolve: (context: any, enqueue: unknown) => unknown, options?: unknown) =>
+    makeDirectTransitionDescriptor(
+      selection,
+      (context, enqueue) => predicate(context) ? resolve(context, enqueue) : Topology.makeDeclined(),
+      { ...transitionOptions(options), declinable: true },
+      reenterSource
+    )
+  return Object.freeze({
+    ...wrap((context) => selection.kind === "none" ? undefined : constructSelectedTarget(context.target)),
+    from: (value: (context: any) => unknown) =>
+      wrap((context) => constructSelectionValue(selection, context, "from", value(context))),
+    decoded: (value: (context: any) => unknown) =>
+      wrap((context) => constructSelectionValue(selection, context, "decoded", value(context))),
+    resolve: wrap
+  })
+}
+
+const decorateTransitionSelection = (
+  selection: Topology.TargetSelection,
+  reenterSource = false
+): Topology.TargetSelection =>
   Object.freeze({
     ...selection,
+    ...(reenterSource ? makeDirectTransitionDescriptor(selection, undefined, undefined, true) : {}),
+    guard: (predicate: (context: any) => boolean) => guardedSelection(selection, predicate, reenterSource),
+    from: (value: (context: any) => unknown) =>
+      makeDirectTransitionDescriptor(
+        selection,
+        (context) => constructSelectionValue(selection, context, "from", value(context)),
+        undefined,
+        reenterSource
+      ),
+    decoded: (value: (context: any) => unknown) =>
+      makeDirectTransitionDescriptor(
+        selection,
+        (context) => constructSelectionValue(selection, context, "decoded", value(context)),
+        undefined,
+        reenterSource
+      ),
     resolve: (resolve: (context: any, enqueue: unknown) => unknown, options?: unknown) =>
-      makeDirectTransitionDescriptor(selection, resolve, options),
-    reenter: () => makeDirectTransitionDescriptor(selection, undefined, { reenter: true }),
+      makeDirectTransitionDescriptor(selection, resolve, options, reenterSource),
+    reenter: () => decorateTransitionSelection(selection, true),
     updating: (owner: unknown) => {
       if (typeof owner !== "function") {
         throw new Error("Machine updating owner must be a state selector")
@@ -237,20 +269,12 @@ const decorateTransitionSelection = (selection: Topology.TargetSelection): Topol
         throw new Error("Machine updating owner must be addressed by one branch state selector")
       }
       return decorateTransitionSelection(
-        Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, ownerSelection.path)
+        Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, ownerSelection.path),
+        reenterSource
       )
     }
   })
 
-const decorateStateUpdateSelection = (selection: Topology.TargetSelection): Topology.TargetSelection => {
-  const update = (
-    resolve: (context: any, enqueue: unknown) => unknown,
-    options?: unknown
-  ) => makeDirectTransitionDescriptor(selection, resolve, options)
-  Object.assign(update, selection)
-  return Object.freeze(update) as unknown as Topology.TargetSelection
-}
-
 const noneTransitionSelection = decorateTransitionSelection(Topology.noneTargetSelection)
 
 const makeInitialBuilderDescriptor = (
@@ -266,6 +290,10 @@ const makeInitialBuilderDescriptor = (
 const decorateInitialSelection = (selection: Topology.TargetSelection): Topology.TargetSelection =>
   Object.freeze({
     ...selection,
+    from: (value: (context: any) => unknown) =>
+      makeInitialBuilderDescriptor(selection, (context) => context.target.from(value(context))),
+    decoded: (value: (context: any) => unknown) =>
+      makeInitialBuilderDescriptor(selection, (context) => context.target.decoded(value(context))),
     resolve: (resolve: (context: any) => unknown) => makeInitialBuilderDescriptor(selection, resolve)
   })
 
@@ -292,7 +320,12 @@ const decorateInitialSelectorNode = (node: unknown): unknown => {
 
 const decorateTransitionSelectorNode = (node: unknown): unknown => {
   if (Topology.isTargetSelection(node)) {
-    if (node.kind === "update") return decorateStateUpdateSelection(node)
+    if (node.kind === "state" && node.scope === "full" && hasProperty(node, "initial")) {
+      return Object.freeze({
+        ...decorateTransitionSelection(node),
+        initial: decorateTransitionSelection(node.initial as Topology.TargetSelection)
+      })
+    }
     return node === Topology.noneTargetSelection ? noneTransitionSelection : decorateTransitionSelection(node)
   }
   if (typeof node === "function") {
@@ -314,29 +347,31 @@ const decorateTransitionSelectorNode = (node: unknown): unknown => {
   return node
 }
 
+const decorateBranches = (declarations: unknown, reenterSource = false): object =>
+  Object.freeze({
+    reenter: () => decorateBranches(declarations, true),
+    resolve: (
+      resolve: (context: any, enqueue: unknown) => unknown,
+      options?: unknown
+    ): BranchesTransitionDescriptor =>
+      Object.freeze({
+        [TransitionBuilderDescriptorTypeId]: TransitionBuilderDescriptorTypeId,
+        type: "branches",
+        declarations,
+        resolve,
+        reenterSource,
+        ...transitionOptions(options)
+      })
+  })
+
 const makeTransitionSelector = (
   stateNodes: Machine.StateNodes,
   source: string
-): unknown => {
-  const selector = {
-    ...decorateTransitionSelectorNode(makeTargetSelector(stateNodes, source)) as Record<string, unknown>
-  }
-  selector.branches = (declarations: unknown) =>
-    Object.freeze({
-      resolve: (
-        resolve: (context: any, enqueue: unknown) => unknown,
-        options?: unknown
-      ): BranchesTransitionDescriptor =>
-        Object.freeze({
-          [TransitionBuilderDescriptorTypeId]: TransitionBuilderDescriptorTypeId,
-          type: "branches",
-          declarations,
-          resolve,
-          ...transitionOptions(options)
-        })
-    })
-  return Object.freeze(selector)
-}
+): unknown =>
+  Object.freeze({
+    ...decorateTransitionSelectorNode(makeTargetSelector(stateNodes, source)) as Record<string, unknown>,
+    branches: (declarations: unknown) => decorateBranches(declarations)
+  })
 
 const normalizeTransitionBuilder = (
   transition: (selector: unknown) => unknown,
@@ -344,7 +379,7 @@ const normalizeTransitionBuilder = (
   path: string
 ): unknown => {
   const result = transition(makeTransitionSelector(stateNodes, path))
-  if (Topology.isTargetSelection(result)) {
+  if (Topology.isTargetSelection(result) && !hasProperty(result, TransitionBuilderDescriptorTypeId)) {
     const selection = plainTargetSelection(result)
     return { target: () => selection }
   }
@@ -354,14 +389,14 @@ const normalizeTransitionBuilder = (
     return {
       branches: () => descriptor.declarations,
       resolve: descriptor.resolve,
-      reenter: descriptor.reenter,
+      reenter: descriptor.reenterSource,
       declinable: descriptor.declinable
     }
   }
   return {
     target: () => descriptor.selection,
-    resolve: descriptor.resolve,
-    reenter: descriptor.reenter,
+    resolve: descriptor.resolver,
+    reenter: descriptor.reenterSource,
     declinable: descriptor.declinable
   }
 }
@@ -430,7 +465,7 @@ const makeSelectionNode = (
     }
     if (
       scope === "branch" && source !== undefined && node.schema !== undefined &&
-      (source === path || source.startsWith(`${path}.`)) &&
+      (source === path || Configuration.isDescendantOf(source, path)) &&
       getTargetBuilderNode(stateNodes, source).type !== "choice"
     ) {
       Object.defineProperty(method, "update", {
@@ -439,6 +474,9 @@ const makeSelectionNode = (
       })
     }
   }
+  if (node.type === "atomic" && scope === "branch" && source === path && node.schema !== undefined) {
+    Object.defineProperty(method, "update", { value: makeStateUpdateSelection(path, "branch"), enumerable: true })
+  }
   return method
 }
 
@@ -463,15 +501,12 @@ const makeTargetSelector = (
   stateNodes: Machine.StateNodes,
   source: string
 ): unknown => {
-  const full: Record<string, unknown> = {}
-  for (const node of stateNodes.byPath.values()) {
-    if (node.parent === undefined && node.type !== "history" && node.type !== "choice") {
-      full[node.key] = makeSelectionNode(stateNodes, node.path, "full")
-    }
-  }
+  const full = Object.assign({}, makeSelectionValue("state", "", "full"), {
+    initial: makeSelectionValue("initial", "", "full")
+  })
   const branch: Record<string, unknown> = {}
-  const root = getTargetBuilderNode(stateNodes, source.split(".")[0]!)
-  branch[root.key] = makeSelectionNode(stateNodes, root.path, "branch", source)
+  const root = getTargetBuilderNode(stateNodes, stateNodes.roots[0]!)
+  addSelectionChildren(branch, stateNodes, root.path, "branch", source)
   const local: Record<string, unknown> = {}
   const localScope = getLocalTargetScope(stateNodes, source)
   if (localScope !== undefined) {
@@ -486,10 +521,15 @@ const makeTargetSelector = (
   }
   return {
     none: Topology.noneTargetSelection,
+    self: getTargetBuilderNode(stateNodes, source).schema === undefined ||
+        getTargetBuilderNode(stateNodes, source).type === "final"
+      ? {}
+      : { update: makeStateUpdateSelection(source, "branch") },
+    root: makeSelectionNode(stateNodes, root.path, "branch", source),
     local,
     branch,
     full,
-    history: makeHistorySelectionTree(stateNodes, undefined)
+    history: makeHistorySelectionTree(stateNodes, "")
   }
 }
 
@@ -580,6 +620,7 @@ const getSelectionBuilder = (
   let parts = selection.path!.split(".")
   if (selection.kind === "history") {
     builder = target.history
+    if (selection.path !== "") parts.unshift("")
   } else if (selection.scope === "local") {
     builder = target.local
     const scope = getLocalTargetScope(stateNodes, source)
@@ -588,11 +629,12 @@ const getSelectionBuilder = (
         builder = builder.with
         parts = []
       } else {
-        parts = selection.path!.slice(scope.length + 1).split(".")
+        parts = (scope === "" ? selection.path! : selection.path!.slice(scope.length + 1)).split(".")
       }
     }
   } else if (selection.scope === "branch") {
     builder = target.branch
+    if (selection.path !== "") parts.unshift("")
   } else {
     builder = target.full
   }
@@ -645,7 +687,7 @@ const validateResolvedSelection = (
     (selectedNode?.type === "compound" || selectedNode?.type === "parallel")
   if (
     resultPath === undefined ||
-    (resultPath !== selection.path && !(acceptsDescendant && resultPath.startsWith(`${selection.path}.`)))
+    (resultPath !== selection.path && !(acceptsDescendant && Configuration.isDescendantOf(resultPath, selection.path!)))
   ) {
     throw new Error(
       `Machine transition resolver selected "${selection.path}" but constructed "${resultPath ?? "<invalid>"}"`
@@ -737,6 +779,11 @@ const captureNamedBranches = (
     if (target.updatePath !== undefined) {
       throw new Error(`Machine transition branch "${key}" cannot declare an updating target`)
     }
+    if (hasProperty(target, TransitionBuilderDescriptorTypeId)) {
+      throw new Error(
+        `Machine transition branch "${key}" requires a topology selection; apply .reenter() to .branches(...)`
+      )
+    }
     if (title !== undefined && (typeof title !== "string" || title.length === 0)) {
       throw new Error(`Machine transition branch "${key}" title must be a non-empty string`)
     }
@@ -1005,9 +1052,9 @@ const captureInvokeDefinition = (
         captured[key] = captureTransition(captured[key], stateNodes, path, key)
       }
     }
-    return captured
+    return InvocationDefinition.capture(captured, path)
   })
-  if (Array.isArray(authored)) return capturedDefinitions
+  if (Array.isArray(authored)) return Object.freeze(capturedDefinitions)
   return capturedDefinitions[0]
 }
 
@@ -1028,6 +1075,14 @@ const flattenHandlers = (
       throw new Error(`Machine expected state "${path}" handler to be an object`)
     }
     const { states: childConfig, ...stateConfig } = nodeConfig as Record<string, unknown>
+    if (typeof stateConfig.history === "object" && stateConfig.history !== null) {
+      stateConfig.history = Object.freeze(Object.fromEntries(
+        Object.entries(stateConfig.history).map(([key, entry]) => [
+          key,
+          typeof entry === "object" && entry !== null ? Object.freeze({ ...entry }) : entry
+        ])
+      ))
+    }
     const on = stateConfig.on
     if (typeof on === "object" && on !== null) {
       const capturedOn = captureEventHandlers(on, stateNodes, path)
@@ -1073,7 +1128,7 @@ const flattenHandlers = (
 const makeHandle = (self: Definition.Any): Definition.Any["handle"] =>
   ((config: Record<string, unknown>) => {
     const handlers: Record<PropertyKey, Machine.AnyStateConfig> = Object.create(null)
-    flattenHandlers(handlers, self.stateNodes, self.states, "", config)
+    flattenHandlers(handlers, self.stateNodes, self.states, "", { "": config })
     return makeWithHandlers(self, handlers)
   }) as Definition.Any["handle"]
 
@@ -1114,523 +1169,6 @@ export const isFinal = <
   state: Machine.Snapshot<States>
 ): state is Machine.SnapshotContainingFinal<States, FinalStates> => internalPlanner.isFinal(machine as any, state)
 
-type SnapshotBuilderOptions = {
-  readonly mode: "initial" | "full"
-  readonly prefix: string
-}
-
-type FromMethodKind = "leaf" | "nested"
-
-const withFrom = <Method extends (value: unknown, ...args: ReadonlyArray<any>) => unknown>(
-  method: Method,
-  kind: FromMethodKind,
-  valued: boolean
-): {
-  readonly decoded?: Method
-  readonly from: (...args: ReadonlyArray<any>) => unknown
-} => {
-  const builder: Record<string, unknown> = {}
-  if (valued) {
-    Object.defineProperty(builder, "decoded", {
-      value: method,
-      enumerable: false
-    })
-  }
-  Object.defineProperty(builder, "from", {
-    value: (...args: ReadonlyArray<any>) => {
-      if (!valued) {
-        return method(undefined, ...args)
-      }
-      const omitted = args.length === 0 || (kind === "nested" && args.length === 1 && typeof args[0] === "function")
-      const input = omitted ? {} : args[0]
-      const rest = omitted ? args : args.slice(1)
-      return method(Topology.makeStateInput(input), ...rest)
-    },
-    enumerable: false
-  })
-  return builder as {
-    readonly decoded?: Method
-    readonly from: (...args: ReadonlyArray<any>) => unknown
-  }
-}
-
-const withInitial = <Builder extends object>(
-  builder: Builder,
-  path: string,
-  valued: boolean,
-  values?: Readonly<Record<string, unknown>>
-): Builder => {
-  const initial = withFrom(
-    (value: unknown) => Topology.makeInitialTarget(path, value, values),
-    "leaf",
-    valued
-  )
-  Object.defineProperty(builder, "initial", {
-    value: initial,
-    enumerable: false
-  })
-  return builder
-}
-
-const makeSnapshotBuilder = (
-  states: Machine.StateTree,
-  options: SnapshotBuilderOptions
-): unknown => {
-  const builder: Record<string, unknown> = {}
-  for (const key of Object.keys(states)) {
-    const definition = states[key]!
-    const pseudoType = (definition as { readonly type?: unknown }).type
-    if (pseudoType === "history") {
-      continue
-    }
-    const path = options.prefix === "" ? key : `${options.prefix}.${key}`
-    if (pseudoType === "choice") {
-      builder[key] = () => Topology.makeChoiceTarget(path, getParentPathRuntime(path))
-      continue
-    }
-    const node = Topology.getStateNodeDefinition(path, definition)
-    const method = withFrom(
-      (value: unknown, selector?: (builder: unknown) => unknown) =>
-        makeSnapshotForNode(definition, key, value, selector, options),
-      node.states === undefined ? "leaf" : "nested",
-      node.schema !== undefined
-    )
-    builder[key] = node.states === undefined || options.mode !== "full" || options.prefix !== ""
-      ? method
-      : withInitial(method, path, node.schema !== undefined)
-  }
-  return builder
-}
-
-const makeParallelSnapshotBuilder = (
-  states: Machine.StateTree,
-  options: SnapshotBuilderOptions,
-  regions: Readonly<Record<string, unknown>>
-): unknown => {
-  const builder: Record<string, unknown> = {}
-  Object.defineProperty(builder, SnapshotBuilderStateTypeId, {
-    value: regions,
-    enumerable: false
-  })
-  for (const key of Object.keys(states)) {
-    const definition = states[key]!
-    const pseudoType = (definition as { readonly type?: unknown }).type
-    if (pseudoType === "history" || pseudoType === "choice") {
-      continue
-    }
-    if (hasProperty(regions, key)) {
-      continue
-    }
-    const path = options.prefix === "" ? key : `${options.prefix}.${key}`
-    const node = Topology.getStateNodeDefinition(path, definition)
-    const method = withFrom(
-      (value: unknown, selector?: (builder: unknown) => unknown) => {
-        const nextRegions: Record<string, unknown> = {}
-        for (const regionKey of Object.keys(regions)) {
-          nextRegions[regionKey] = regions[regionKey]
-        }
-        nextRegions[key] = makeSnapshotForNode(definition, key, value, selector, options)
-        return makeParallelSnapshotBuilder(states, options, nextRegions)
-      },
-      node.states === undefined ? "leaf" : "nested",
-      node.schema !== undefined
-    )
-    builder[key] = method
-  }
-  return builder
-}
-
-const getParallelSnapshotBuilderRegions = (
-  path: string,
-  states: Machine.StateTree,
-  builder: unknown
-): Readonly<Record<string, unknown>> => {
-  if (typeof builder !== "object" || builder === null || !hasProperty(builder, SnapshotBuilderStateTypeId)) {
-    throw new Error(`Machine expected parallel state "${path}" builder callback to return a builder`)
-  }
-  const regions = (builder as { readonly [SnapshotBuilderStateTypeId]: Readonly<Record<string, unknown>> })[
-    SnapshotBuilderStateTypeId
-  ]
-  for (const key of Object.keys(states)) {
-    const pseudoType = (states[key] as { readonly type?: unknown }).type
-    if (pseudoType === "history" || pseudoType === "choice") {
-      continue
-    }
-    if (!hasProperty(regions, key)) {
-      throw new Error(`Machine expected parallel state "${path}" builder callback to provide region "${key}"`)
-    }
-  }
-  return regions
-}
-
-const makeSnapshotForNode = (
-  definition: Machine.TaggedSchema | Machine.StateNodeConfig,
-  key: string,
-  value: unknown,
-  selector: ((builder: unknown) => unknown) | undefined,
-  options: SnapshotBuilderOptions
-): Record<string, unknown> => {
-  const path = options.prefix === "" ? key : `${options.prefix}.${key}`
-  const node = Topology.getStateNodeDefinition(path, definition)
-  const snapshot: Record<string, unknown> = {
-    path,
-    value
-  }
-  if (node.states === undefined) {
-    return snapshot
-  }
-  if (selector === undefined) {
-    throw new Error(`Machine expected state "${path}" builder to provide active child states`)
-  }
-  if (node.type === "parallel") {
-    const builder = makeParallelSnapshotBuilder(node.states, { ...options, prefix: path }, {})
-    const selected = selector(builder)
-    snapshot.states = getParallelSnapshotBuilderRegions(path, node.states, selected)
-    return snapshot
-  }
-  const childStates = options.mode === "initial" && node.initial !== undefined
-    ? { [node.initial]: node.states[node.initial]! }
-    : node.states
-  const selected = selector(makeSnapshotBuilder(childStates, { ...options, prefix: path }))
-  snapshot.state = selected
-  return snapshot
-}
-
-const getTargetBuilderNode = (
-  stateNodes: Machine.StateNodes,
-  path: string
-): Machine.StateNode => {
-  const node = stateNodes.byPath.get(path)
-  if (node === undefined) {
-    throw new Error(`Machine expected state path "${path}" to exist`)
-  }
-  return node
-}
-
-const getLocalTargetScope = (
-  stateNodes: Machine.StateNodes,
-  source: string
-): string | undefined => {
-  let current: string | undefined = source
-  while (current !== undefined) {
-    const node = stateNodes.byPath.get(current)
-    if (node === undefined) {
-      return undefined
-    }
-    if (node.type === "compound") {
-      return node.path
-    }
-    current = node.parent
-  }
-  return undefined
-}
-
-const hasTargetValues = (
-  values: Readonly<Record<string, unknown>> | undefined
-): values is Readonly<Record<string, unknown>> => values !== undefined && Object.keys(values).length > 0
-
-const makeTargetWithValues = (
-  path: string,
-  value: unknown,
-  values: Readonly<Record<string, unknown>> | undefined
-): Machine.Target<any, any> =>
-  hasTargetValues(values)
-    ? Topology.makeTarget(path as any, value as any, { values: values as any })
-    : Topology.makeTarget(path as any, value as any)
-
-const getTargetBuilderDefinition = (
-  states: Machine.StateTree,
-  targetPath: string
-): Machine.TaggedSchema | Machine.StateNodeConfig => {
-  let children = states
-  let path = ""
-  let definition: Machine.TaggedSchema | Machine.StateNodeConfig | undefined
-  for (const key of targetPath.split(".")) {
-    if (!hasProperty(children, key)) {
-      throw new Error(`Machine expected state path "${targetPath}" to exist`)
-    }
-    definition = children[key]!
-    path = path === "" ? key : `${path}.${key}`
-    const node = Topology.getStateNodeDefinition(path, definition)
-    children = node.states ?? {}
-  }
-  return definition!
-}
-
-const makeParallelTarget = (
-  states: Machine.StateTree,
-  node: Machine.StateNode,
-  value: unknown,
-  selector: ((builder: unknown) => unknown) | undefined,
-  values: Readonly<Record<string, unknown>> | undefined
-): Machine.Target<any, any> => {
-  if (selector === undefined) {
-    throw new Error(`Machine expected parallel target "${node.path}" builder to provide every active region`)
-  }
-  const snapshot = makeSnapshotForNode(
-    getTargetBuilderDefinition(states, node.path),
-    node.key,
-    value,
-    selector,
-    { mode: "full", prefix: node.parent ?? "" }
-  )
-  return Topology.makeTarget(node.path as any, value as any, {
-    snapshot: snapshot as any,
-    values: values as any
-  })
-}
-
-const extendTargetValues = (
-  values: Readonly<Record<string, unknown>> | undefined,
-  path: string,
-  value: unknown
-): Readonly<Record<string, unknown>> => {
-  const next: Record<string, unknown> = {}
-  if (values !== undefined) {
-    for (const key of Object.keys(values)) {
-      next[key] = values[key]
-    }
-  }
-  next[path] = value
-  return next
-}
-
-const makeLocalTargetChildBuilder = (
-  states: Machine.StateTree,
-  stateNodes: Machine.StateNodes,
-  parentPath: string,
-  values: Readonly<Record<string, unknown>> | undefined,
-  source: string
-): unknown => {
-  const parent = getTargetBuilderNode(stateNodes, parentPath)
-  const builder: Record<string, unknown> = {}
-  for (
-    const childPath of Array.from(stateNodes.byPath.values())
-      .filter((node) => node.parent === parent.path && node.type !== "history")
-      .map((node) => node.path)
-  ) {
-    const child = getTargetBuilderNode(stateNodes, childPath)
-    if (child.type === "choice") {
-      builder[child.key] = () => Topology.makeChoiceTarget(child.path, parent.path, values)
-      continue
-    }
-    const method = withFrom(
-      (value: unknown, selector?: (builder: unknown) => unknown) => {
-        if (child.type === "atomic" || child.type === "final") {
-          return makeTargetWithValues(child.path, value, values)
-        }
-        if (child.type === "parallel") {
-          if (source !== child.path && !source.startsWith(`${child.path}.`)) {
-            return makeParallelTarget(states, child, value, selector, values)
-          }
-          if (selector === undefined) {
-            throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`)
-          }
-          return selector(makeLocalTargetChildBuilder(
-            states,
-            stateNodes,
-            child.path,
-            child.schema === undefined ? values : extendTargetValues(values, child.path, value),
-            source
-          ))
-        }
-        if (selector === undefined) {
-          throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`)
-        }
-        return selector(makeLocalTargetChildBuilder(
-          states,
-          stateNodes,
-          child.path,
-          child.schema === undefined ? values : extendTargetValues(values, child.path, value),
-          source
-        ))
-      },
-      child.type === "atomic" || child.type === "final" ? "leaf" : "nested",
-      child.schema !== undefined
-    )
-    builder[child.key] = child.type === "atomic" || child.type === "final"
-      ? method
-      : withInitial(method, child.path, child.schema !== undefined, values)
-  }
-  return builder
-}
-
-const makeLocalTargetBuilder = (
-  states: Machine.StateTree,
-  stateNodes: Machine.StateNodes,
-  source: string
-): unknown => {
-  const scope = getLocalTargetScope(stateNodes, source)
-  if (scope === undefined) {
-    return {}
-  }
-  const builder = makeLocalTargetChildBuilder(states, stateNodes, scope, undefined, source) as Record<string, unknown>
-  const scopeNode = getTargetBuilderNode(stateNodes, scope)
-  if (scopeNode.schema !== undefined) {
-    builder.with = withFrom(
-      (value: unknown, selector?: (builder: unknown) => unknown) => {
-        if (selector === undefined) {
-          throw new Error(`Machine expected target "${scope}" builder to provide an active child state`)
-        }
-        return selector(makeLocalTargetChildBuilder(states, stateNodes, scope, { [scope]: value }, source))
-      },
-      "nested",
-      true
-    )
-  }
-  return builder
-}
-
-const addBranchTargetChildren = (
-  builder: Record<string, unknown>,
-  states: Machine.StateTree,
-  stateNodes: Machine.StateNodes,
-  parentPath: string,
-  values: Readonly<Record<string, unknown>> | undefined,
-  source: string
-): void => {
-  const parent = getTargetBuilderNode(stateNodes, parentPath)
-  for (
-    const childPath of Array.from(stateNodes.byPath.values())
-      .filter((node) => node.parent === parent.path && node.type !== "history")
-      .map((node) => node.path)
-  ) {
-    const child = getTargetBuilderNode(stateNodes, childPath)
-    if (child.type === "choice") {
-      builder[child.key] = () => Topology.makeChoiceTarget(child.path, parent.path, values)
-      continue
-    }
-    builder[child.key] = makeBranchTargetNodeBuilder(states, stateNodes, child.path, values, source)
-  }
-}
-
-const makeBranchTargetNodeBuilder = (
-  states: Machine.StateTree,
-  stateNodes: Machine.StateNodes,
-  path: string,
-  values: Readonly<Record<string, unknown>> | undefined,
-  source: string
-): unknown => {
-  const node = getTargetBuilderNode(stateNodes, path)
-  if (node.type === "atomic" || node.type === "final") {
-    return withFrom(
-      (value: unknown) => makeTargetWithValues(node.path, value, values),
-      "leaf",
-      node.schema !== undefined
-    )
-  }
-  const builder = withFrom(
-    (value: unknown, selector?: (builder: unknown) => unknown) => {
-      if (node.type === "parallel") {
-        if (source !== node.path && !source.startsWith(`${node.path}.`)) {
-          return makeParallelTarget(states, node, value, selector, values)
-        }
-        if (selector === undefined) {
-          throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`)
-        }
-        const nextBuilder: Record<string, unknown> = {}
-        addBranchTargetChildren(
-          nextBuilder,
-          states,
-          stateNodes,
-          node.path,
-          node.schema === undefined ? values : extendTargetValues(values, node.path, value),
-          source
-        )
-        return selector(nextBuilder)
-      }
-      if (selector === undefined) {
-        throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`)
-      }
-      const nextBuilder: Record<string, unknown> = {}
-      addBranchTargetChildren(
-        nextBuilder,
-        states,
-        stateNodes,
-        node.path,
-        node.schema === undefined ? values : extendTargetValues(values, node.path, value),
-        source
-      )
-      return selector(nextBuilder)
-    },
-    "nested",
-    node.schema !== undefined
-  ) as unknown as Record<string, unknown>
-  withInitial(builder, node.path, node.schema !== undefined, values)
-  if (node.type !== "parallel" || source === node.path || source.startsWith(`${node.path}.`)) {
-    addBranchTargetChildren(builder, states, stateNodes, node.path, values, source)
-  }
-  return builder
-}
-
-const makeBranchTargetBuilder = (
-  states: Machine.StateTree,
-  stateNodes: Machine.StateNodes,
-  source: string
-): unknown => {
-  const rootPath = source.split(".")[0]!
-  const root = getTargetBuilderNode(stateNodes, rootPath)
-  return {
-    [root.key]: makeBranchTargetNodeBuilder(states, stateNodes, root.path, undefined, source)
-  }
-}
-
-const makeHistoryTargetBuilder = (
-  states: Machine.StateTree,
-  prefix: string
-): unknown => {
-  const builder: Record<string, unknown> = {}
-  for (const key of Object.keys(states)) {
-    const path = prefix === "" ? key : `${prefix}.${key}`
-    const definition = Topology.getStateNodeDefinition(path, states[key]!)
-    if (definition.type === "history") {
-      const parent = getParentPathRuntime(path)
-      builder[key] = () => Topology.makeHistoryTarget(path, parent)
-      continue
-    }
-    if (definition.states !== undefined) {
-      builder[key] = makeHistoryTargetBuilder(definition.states, path)
-    }
-  }
-  return builder
-}
-
-const getParentPathRuntime = (path: string): string => {
-  const separator = path.lastIndexOf(".")
-  if (separator < 0) {
-    throw new Error(`Machine expected history state "${path}" to have an active parent`)
-  }
-  return path.slice(0, separator)
-}
-
-const makeTargetBuilder = <const States extends Machine.StateSchemas>(
-  states: States,
-  stateNodes: Machine.StateNodes
-) => {
-  const full = makeSnapshotBuilder(states, { mode: "full", prefix: "" }) as Machine.FullTargetBuilder<States>
-  const history = makeHistoryTargetBuilder(states, "") as Machine.HistoryTargetBuilder<States>
-  return <Source extends Machine.StateNodeIdentifier<States>>(source: Source): Machine.TargetBuilder<States, Source> =>
-    ({
-      none: Topology.makeNoTarget,
-      local: makeLocalTargetBuilder(states, stateNodes, source),
-      branch: makeBranchTargetBuilder(states, stateNodes, source),
-      full,
-      history
-    }) as Machine.TargetBuilder<States, Source>
-}
-
-const makeInitialSelector = (stateNodes: Machine.StateNodes): unknown => {
-  const selector: Record<string, unknown> = {}
-  for (const node of stateNodes.byPath.values()) {
-    if (node.parent === undefined && node.type !== "history" && node.type !== "choice") {
-      selector[node.key] = node.type === "atomic" || node.type === "final"
-        ? makeSelectionMethod("state", node.path, "initial")
-        : Object.freeze({ initial: makeSelectionValue("initial", node.path, "initial") })
-    }
-  }
-  return Object.freeze(selector)
-}
-
 const getInitialSelectionBuilder = (
   initialBuilder: Record<string, any>,
   selection: Topology.TargetSelection
@@ -1648,17 +1186,18 @@ const getInitialSelectionBuilder = (
 
 const captureInitialBranch = (
   definition: unknown,
-  stateNodes: Machine.StateNodes,
-  initialBuilder: Record<string, any>
+  initialBuilder: Record<string, any>,
+  configuration: boolean
 ): {
   readonly selection: Topology.TargetSelection
   readonly resolve?: (context: any) => unknown
   readonly builder: Record<string, any>
 } => {
-  if (typeof definition !== "function") {
+  if (definition !== undefined && typeof definition !== "function") {
     throw new Error("Machine initial definition must be a target-first callback")
   }
-  const result = definition(decorateInitialSelectorNode(makeInitialSelector(stateNodes)))
+  const selector = decorateInitialSelection(makeSelectionValue(configuration ? "state" : "initial", "", "initial"))
+  const result = definition === undefined ? selector : definition(selector)
   let selection: Topology.TargetSelection
   let resolve: ((context: any) => unknown) | undefined
   if (Topology.isTargetSelection(result)) {
@@ -1694,13 +1233,17 @@ const validateInitialSelection = (result: unknown, selection: Topology.TargetSel
 const compileInitial = (
   definition: unknown,
   states: Machine.StateTree,
-  stateNodes: Machine.StateNodes
+  stateNodes: Machine.StateNodes,
+  configuration = false
 ): {
   readonly initial: (input?: unknown) => unknown
   readonly definition: Machine.InitialDefinition
 } => {
-  const initialBuilder = makeSnapshotBuilder(states, { mode: "initial", prefix: "" }) as Record<string, any>
-  const branch = captureInitialBranch(definition, stateNodes, initialBuilder)
+  const rootNode = getTargetBuilderNode(stateNodes, "")
+  const initialBuilder = configuration ?
+    makeSnapshotBuilder(states, { mode: "full", prefix: "" }) as Record<string, any>
+    : { "": withFrom((value: unknown) => Topology.makeInitialTarget("", value), "leaf", rootNode.schema !== undefined) }
+  const branch = captureInitialBranch(definition, initialBuilder, configuration)
   return {
     initial: (input?: unknown) => {
       const result = branch.resolve === undefined
@@ -1716,62 +1259,35 @@ const compileInitial = (
   }
 }
 
-export const state: StateConstructor = (<const Node extends ReusableStateNodeConfig>(node: Node): Node => {
-  StateDefinition.validateStateDefinitions({ state: node }, "Machine.state")
-  return StateDefinition.captureStateDefinitions({ state: node }).state
-}) as StateConstructor
+export const state = (node: unknown): State<Machine.StateNodeConfig> => {
+  const captured = StateDefinition.captureRoot(node) as Machine.StateNodeConfig
+  const access = makeStateHelpers()
+  return Object.freeze({ ...access, "~effect/Machine/State": "~effect/Machine/State", node: captured })
+}
 
-export const states: StatesConstructor = (<const States extends Machine.StateSchemas>(
-  states: States
-): Machine.DefinedStates<States> => {
-  StateDefinition.validateStateDefinitions(states, "Machine.states")
-  const captured = StateDefinition.captureStateDefinitions(states)
+const makeStateHelpers = (): Machine.StateAccessors<{ readonly "": Machine.StateNodeConfig }> => {
   return {
-    states: captured,
-    path: ((path: string) => path) as Machine.DefinedStates<States>["path"],
+    path: ((path: string) => path) as Machine.StateAccessors<{ readonly "": Machine.StateNodeConfig }>["path"],
     get:
       ((snapshot: Machine.AtomicSnapshot<string, unknown>, path: string) =>
         Topology.getSnapshotByPath(snapshot, path).pipe(
           Option.map((snapshot) => snapshot.value)
-        )) as Machine.DefinedStates<States>["get"],
+        )) as Machine.StateAccessors<{ readonly "": Machine.StateNodeConfig }>["get"],
     getWithParents: ((snapshot, path) => {
       const parents: Record<string, unknown> = {}
       return Topology.getSnapshotByPath(snapshot, path, parents).pipe(
         Option.map((snapshot) => ({ value: snapshot.value, parents }))
       )
-    }) as Machine.DefinedStates<States>["getWithParents"],
-    getSnapshot: Topology.getSnapshotByPath as unknown as Machine.DefinedStates<States>["getSnapshot"],
+    }) as Machine.StateAccessors<{ readonly "": Machine.StateNodeConfig }>["getWithParents"],
+    getSnapshot: Topology.getSnapshotByPath as unknown as Machine.StateAccessors<
+      { readonly "": Machine.StateNodeConfig }
+    >["getSnapshot"],
     matches:
       ((snapshot: Machine.AtomicSnapshot<string, unknown>, path: string) =>
-        Option.isSome(Topology.getSnapshotByPath(snapshot, path))) as Machine.DefinedStates<States>["matches"]
+        Option.isSome(Topology.getSnapshotByPath(snapshot, path))) as Machine.StateAccessors<
+          { readonly "": Machine.StateNodeConfig }
+        >["matches"]
   }
-}) as StatesConstructor
-
-type MakeConfig<
-  States extends Machine.StateSchemas,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  Input extends Schema.Top,
-  InitialE,
-  InitialR,
-  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentDeclaration extends Parent.Any | undefined
-> = {
-  readonly id?: string
-  readonly states: States & DefineStateTreeInput<NoInfer<States>>
-  readonly events:
-    & Machine.EventProtocol<"public", InputEvents>
-    & ValidateInputEventProtocol<NoInfer<InputEvents>>
-  readonly internalEvents?:
-    & Machine.EventProtocol<"internal", InternalEvents>
-    & ValidateInternalEventProtocol<
-      NoInfer<InputEvents>,
-      NoInfer<InternalEvents>
-    >
-  readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>
-  readonly parent?: ParentDeclaration
-  readonly input?: Input
-  readonly initial: unknown
 }
 
 type MakeResult<
@@ -1796,40 +1312,7 @@ type MakeResult<
   Machine.ParentEventsOf<ParentDeclaration>
 >
 
-interface Make {
-  <
-    const States extends Machine.StateSchemas,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const Input extends Schema.Top = typeof Schema.Void,
-    InitialE = never,
-    InitialR = never,
-    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentDeclaration extends Parent.Any | undefined = undefined
-  >(
-    config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>,
-    ..._validation: ValidateDefinedStates<NoInfer<States>>
-  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>
-  <
-    const States extends Machine.StateSchemas,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const Input extends Schema.Top = typeof Schema.Void,
-    InitialE = never,
-    InitialR = never,
-    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentDeclaration extends Parent.Any | undefined = undefined
-  >(
-    config:
-      & Omit<
-        MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>,
-        "states"
-      >
-      & { readonly states: InvalidDefinedStateTreeInput<States> }
-  ): never
-}
-
-export const make: Make = (<
+export const make = <
   const States extends Machine.StateSchemas,
   const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
   const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
@@ -1841,7 +1324,8 @@ export const make: Make = (<
 >(
   config: {
     readonly id?: string
-    readonly states: States
+    readonly root: State<Machine.StateNodeConfig>
+    readonly initialConfiguration?: unknown
     readonly events: Machine.EventProtocol<"public", InputEvents>
     readonly internalEvents?: Machine.EventProtocol<"internal", InternalEvents>
     readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>
@@ -1850,25 +1334,31 @@ export const make: Make = (<
     readonly initial: unknown
   }
 ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration> => {
-  StateDefinition.validateStateDefinitions(config.states, "Machine.make")
+  const states = Object.freeze({ "": config.root.node })
   const self = Object.create(Proto)
-  self.states = config.states
+  self.states = states
+  self.root = config.root
   self.events = config.events
   self.internalEvents = config.internalEvents ?? Protocol.makeEventProtocol("internal", [] as const)
   self.emittedEvents = config.emittedEvents ?? Protocol.makeEventProtocol("emitted", [] as const)
   self.parent = config.parent
   self.input = config.input
   self.id = config.id
-  self.stateNodes = Topology.compileStateNodes(config.states)
-  const compiledInitial = compileInitial(config.initial, config.states, self.stateNodes)
+  self.stateNodes = Topology.compileStateNodes(states)
+  const compiledInitial = compileInitial(
+    config.initialConfiguration ?? config.initial,
+    states,
+    self.stateNodes,
+    config.initialConfiguration !== undefined
+  )
   self.initial = compiledInitial.initial
   self.initialDefinition = compiledInitial.definition
-  self.makeTargetBuilder = makeTargetBuilder(config.states, self.stateNodes)
+  self.makeTargetBuilder = makeTargetBuilder(states, self.stateNodes)
   self.handlers = Object.create(null)
   self.handle = makeHandle(self)
   Protocol.setProtocol(self)
   return self
-}) as Make
+}
 
 const flattenEventProtocolInputs = <Kind extends Machine.EventProtocolKind>(
   kind: Kind,
@@ -1888,6 +1378,22 @@ export const events = <const Inputs extends ReadonlyArray<Machine.EventProtocolI
     flattenEventProtocolInputs("public", inputs)
   ) as Machine.EventProtocol<"public", Machine.EventProtocolInputSchemasOf<"public", Inputs>>
 
+const eventFieldSchemas = (
+  cases: Readonly<Record<string, Schema.Struct.Fields>>
+): ReadonlyArray<Machine.TaggedSchema> => {
+  for (const [tag, fields] of Object.entries(cases)) {
+    if (Object.hasOwn(fields, "_tag")) throw new Error(`Machine event "${tag}" fields cannot declare _tag`)
+  }
+  return Object.keys(cases).length === 0 ? [] : [Schema.TaggedUnion(cases)]
+}
+
+export const eventsFromFields = (cases: Readonly<Record<string, Schema.Struct.Fields>>) =>
+  Protocol.makeEventProtocol("public", eventFieldSchemas(cases))
+export const internalEventsFromFields = (cases: Readonly<Record<string, Schema.Struct.Fields>>) =>
+  Protocol.makeEventProtocol("internal", eventFieldSchemas(cases))
+export const emittedEventsFromFields = (cases: Readonly<Record<string, Schema.Struct.Fields>>) =>
+  Protocol.makeEventProtocol("emitted", eventFieldSchemas(cases))
+
 const makeParent = <
   const Mode extends ParentMode,
   const Events extends ReadonlyArray<Machine.TaggedSchema>
@@ -2038,7 +1544,7 @@ export const planInitial: <
     readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>
     readonly state: Machine.Snapshot<States>
     readonly commands: ReadonlyArray<Command>
-    readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>
+    readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>
     readonly microsteps: ReadonlyArray<{
       readonly next: Machine.Snapshot<States>
       readonly event: Machine.EventOf<Events> | InitialEventModel
@@ -2051,7 +1557,7 @@ export const planInitial: <
       >
       readonly commands: ReadonlyArray<Command>
       readonly raisedEvents: ReadonlyArray<Machine.EventOf<Events>>
-      readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>
+      readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>
       readonly exitPaths: ReadonlyArray<string>
       readonly entryPaths: ReadonlyArray<string>
       readonly changed: boolean
@@ -2216,7 +1722,7 @@ export const plan: <
   & {
     readonly next: Machine.Snapshot<States>
     readonly commands: ReadonlyArray<Command>
-    readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>
+    readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>
     readonly microsteps: ReadonlyArray<{
       readonly next: Machine.Snapshot<States>
       readonly event: Machine.EventOf<Events> | InitialEventModel
@@ -2229,7 +1735,7 @@ export const plan: <
       >
       readonly commands: ReadonlyArray<Command>
       readonly raisedEvents: ReadonlyArray<Machine.EventOf<Events>>
-      readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>
+      readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>
       readonly exitPaths: ReadonlyArray<string>
       readonly entryPaths: ReadonlyArray<string>
       readonly changed: boolean
@@ -2450,7 +1956,7 @@ export const start: <
   ExcludeCompatibleRuntime<
     ExecutionServices<InitialR | R>,
     Machine.EventOf<Events>,
-    Machine.EmitOf<Emits>
+    Machine.EmittedEventOf<Emits>
   >
 > = internalProcess.start as any
 
@@ -2503,6 +2009,6 @@ export const resume: <
   ExcludeCompatibleRuntime<
     ExecutionServices<R>,
     Machine.EventOf<Events>,
-    Machine.EmitOf<Emits>
+    Machine.EmittedEventOf<Emits>
   >
 > = internalProcess.resume as any