@typeonce/effect-machine 0.16.0 → 0.17.0

package/src/internal/machine/planner.ts

@@ -7,13 +7,7 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import type * as Schema from "effect/Schema"
-import type {
-  Enqueue,
-  InitialEvent as MachineInitialEvent,
-  Machine,
-  MachineReferences,
-  MachineTarget
-} from "../../Machine.js"
+import type { Enqueue, InitialEvent as MachineInitialEvent, Machine, MachineTarget } from "../../Machine.js"
 import { getTargetBuilder, makeCollector, type RuntimeCommand } from "./command.js"
 import {
   type ActiveConfiguration,
@@ -53,6 +47,7 @@ import {
   getNode,
   type InitialTarget as InitialTargetInstruction,
   isChoiceTarget,
+  isDeclined,
   isHistoryTarget,
   isInitialTarget,
   isNoTarget,
@@ -104,10 +99,10 @@ export type MacrostepPlan<State, Event, E, R, Output> =
 export type TransitionHandler<States extends Machine.StateSchemas, E, R, Context> = (
   context: Context,
   enqueue: Enqueue<any, any>
-) => Machine.HandlerResult<States, E, R>
+) => Machine.HandlerResult<States, E, R> | Machine.Declined
 
 type TransitionEvaluation<States extends Machine.StateSchemas, E, R> = {
-  readonly result: Machine.HandlerResult<States, E, R>
+  readonly result: Machine.HandlerResult<States, E, R> | Machine.Declined
   readonly branchIndex: number
   readonly branchKey: string | undefined
 }
@@ -117,24 +112,42 @@ type TransitionEvaluator<States extends Machine.StateSchemas, E, R, Context> = (
   enqueue: Enqueue<any, any>
 ) => TransitionEvaluation<States, E, R>
 
-const rootMachineReferences = new WeakMap<Machine.Any, MachineReferences<any, any>>()
-const scopedMachineReferences = new WeakMap<Machine.Any, MachineReferences<any, any>>()
+type PlanningMachineReferences = {
+  readonly self: MachineTarget<any>
+  readonly parent: MachineTarget<any> | undefined
+}
+
+type BehaviorMachineReferences = {
+  readonly self: MachineTarget<any>
+  readonly parent?: MachineTarget<any> | undefined
+}
+
+const rootMachineReferences = new WeakMap<Machine.Any, BehaviorMachineReferences>()
+const scopedMachineReferences = new WeakMap<Machine.Any, BehaviorMachineReferences>()
+
+const exposeMachineReferences = (
+  machine: Machine.Any,
+  machineReferences: PlanningMachineReferences
+): BehaviorMachineReferences =>
+  machine.parent === undefined
+    ? { self: machineReferences.self }
+    : { self: machineReferences.self, parent: machineReferences.parent }
 
 export const withMachineReferences = (
   machine: Machine.Any,
-  machineReferences: MachineReferences<any, any>
+  machineReferences: PlanningMachineReferences
 ): Machine.Any => {
   const scoped = Object.create(machine) as Machine.Any
-  scopedMachineReferences.set(scoped, { self: machineReferences.self, parent: machineReferences.parent })
+  scopedMachineReferences.set(scoped, exposeMachineReferences(machine, machineReferences))
   return scoped
 }
 
 const resolveMachineReferences = (
   machine: Machine.Any,
   configuration: ActiveConfiguration
-): MachineReferences<any, any> => {
+): BehaviorMachineReferences => {
   const scope = configuration.machineReferences
-  if (scope !== undefined) return scope
+  if (scope !== undefined) return exposeMachineReferences(machine, scope)
   const machineScope = scopedMachineReferences.get(machine)
   if (machineScope !== undefined) return machineScope
   const cached = rootMachineReferences.get(machine)
@@ -144,7 +157,7 @@ const resolveMachineReferences = (
     sessionId: "Machine.plan",
     send: () => Effect.fail(new StoppedError())
   }
-  const root = { self, parent: undefined }
+  const root = exposeMachineReferences(machine, { self, parent: undefined })
   rootMachineReferences.set(machine, root)
   return root
 }
@@ -153,6 +166,7 @@ type EventTransition<States extends Machine.StateSchemas, E, R, Context> =
   | TransitionHandler<States, E, R, Context>
   | {
     readonly reenter?: boolean
+    readonly declinable?: boolean
     readonly targets?: ReadonlyArray<string>
     readonly transition: TransitionHandler<States, E, R, Context>
     readonly evaluate?: TransitionEvaluator<States, E, R, Context>
@@ -160,6 +174,7 @@ type EventTransition<States extends Machine.StateSchemas, E, R, Context> =
 
 export type MicrostepTransition<States extends Machine.StateSchemas, E, R, Context> = {
   readonly reenter: boolean
+  readonly declinable: boolean
   readonly targets: ReadonlyArray<string> | undefined
   readonly transition: TransitionHandler<States, E, R, Context>
   readonly evaluate: TransitionEvaluator<States, E, R, Context> | undefined
@@ -172,9 +187,10 @@ export const normalizeTransition = <States extends Machine.StateSchemas, E, R, C
     return undefined
   }
   return typeof transition === "function"
-    ? { reenter: false, targets: undefined, transition, evaluate: undefined }
+    ? { reenter: false, declinable: false, targets: undefined, transition, evaluate: undefined }
     : {
       reenter: transition.reenter === true,
+      declinable: transition.declinable === true,
       targets: transition.targets,
       transition: transition.transition,
       evaluate: transition.evaluate
@@ -218,7 +234,11 @@ const collectTransition = <
   const evaluated = evaluate === undefined
     ? { result: transition(context, collected.enqueue), branchIndex: 0, branchKey: undefined }
     : evaluate(context, collected.enqueue)
+  if (isDeclined(evaluated.result)) {
+    return { declined: true as const }
+  }
   return {
+    declined: false as const,
     state: isNoTarget(evaluated.result) ? undefined : evaluated.result,
     branchIndex: evaluated.branchIndex,
     branchKey: evaluated.branchKey,
@@ -521,6 +541,29 @@ export type SelectedTransition<States extends Machine.StateSchemas, E, R, Contex
   readonly trigger: Machine.TransitionTrigger
   readonly transition: MicrostepTransition<States, E, R, Context>
   readonly context: Context
+  readonly collected?: {
+    readonly declined: false
+    readonly state: unknown
+    readonly branchIndex: number
+    readonly branchKey: string | undefined
+    readonly commands: ReadonlyArray<RuntimeCommand>
+    readonly raisedEvents: ReadonlyArray<unknown>
+    readonly emittedEvents: ReadonlyArray<unknown>
+  }
+}
+
+const resolveDeclinableCandidate = <States extends Machine.StateSchemas, E, R, Context>(
+  machine: Machine.Any,
+  selection: SelectedTransition<States, E, R, Context>
+): SelectedTransition<States, E, R, Context> | undefined => {
+  if (!selection.transition.declinable) return selection
+  const collected = collectTransition(
+    machine,
+    selection.transition.transition,
+    selection.context,
+    selection.transition.evaluate
+  )
+  return collected.declined ? undefined : { ...selection, collected }
 }
 
 export type EvaluatedTransition<States extends Machine.StateSchemas, Event, E, R, Context> = {
@@ -759,15 +802,16 @@ const selectAlwaysTransitions = <
     >
   > = []
   const selectedSources = new Set<string>()
+  const evaluatedSources = new Map<string, SelectedTransition<States, E, R, any> | undefined>()
   let snapshot: Machine.Snapshot<States> | undefined
   const capturedSnapshot = () => snapshot ??= snapshotFromConfiguration<States>(machine, configuration)
   for (const leaf of getActiveLeafPaths(machine, configuration)) {
     for (const path of getLeafCandidatePaths(machine, leaf)) {
       const always = normalizeTransition(machine.handlers[path]?.always)
       if (always !== undefined) {
-        if (!selectedSources.has(path)) {
-          selectedSources.add(path)
-          selected.push({
+        let candidate = evaluatedSources.get(path)
+        if (!evaluatedSources.has(path)) {
+          candidate = resolveDeclinableCandidate(machine, {
             sourcePath: path,
             leafPath: leaf,
             trigger: { type: "always" },
@@ -796,6 +840,12 @@ const selectAlwaysTransitions = <
               target: getTargetBuilder(machine, path)
             }
           })
+          evaluatedSources.set(path, candidate)
+        }
+        if (candidate === undefined) continue
+        if (!selectedSources.has(path)) {
+          selectedSources.add(path)
+          selected.push(candidate as (typeof selected)[number])
         }
         break
       }
@@ -838,7 +888,7 @@ const selectDoneTransitions = <
     const onDone = normalizeTransition(machine.handlers[completion.path]?.onDone)
     if (onDone !== undefined && !selectedSources.has(completion.path)) {
       selectedSources.add(completion.path)
-      selected.push({
+      const candidate = resolveDeclinableCandidate(machine, {
         sourcePath: completion.path,
         leafPath: getActiveLeafPathFrom(machine, configuration, completion.path),
         trigger: { type: "done" },
@@ -857,6 +907,7 @@ const selectDoneTransitions = <
           capturedSnapshot()
         )
       })
+      if (candidate !== undefined) selected.push(candidate)
     }
   }
   return selected
@@ -897,15 +948,16 @@ const selectEventTransitions = <
     >
   > = []
   const selectedSources = new Set<string>()
+  const evaluatedSources = new Map<string, SelectedTransition<States, E, R, any> | undefined>()
   let snapshot: Machine.Snapshot<States> | undefined
   const capturedSnapshot = () => snapshot ??= snapshotFromConfiguration<States>(machine, configuration)
   for (const leaf of getActiveLeafPaths(machine, configuration)) {
     for (const path of getLeafCandidatePaths(machine, leaf)) {
       const transition = normalizeTransition(machine.handlers[path]?.on?.[event._tag])
       if (transition !== undefined) {
-        if (!selectedSources.has(path)) {
-          selectedSources.add(path)
-          selected.push({
+        let candidate = evaluatedSources.get(path)
+        if (!evaluatedSources.has(path)) {
+          candidate = resolveDeclinableCandidate(machine, {
             sourcePath: path,
             leafPath: leaf,
             trigger: { type: "event", event: event._tag },
@@ -931,6 +983,12 @@ const selectEventTransitions = <
               Machine.TagOf<Events[number]>
             >(machine as any, configuration, path, event, capturedSnapshot())
           })
+          evaluatedSources.set(path, candidate)
+        }
+        if (candidate === undefined) continue
+        if (!selectedSources.has(path)) {
+          selectedSources.add(path)
+          selected.push(candidate as (typeof selected)[number])
         }
         break
       }
@@ -983,13 +1041,14 @@ const selectInvocationTransition = <
       ? { error: event.error }
       : { snapshot: event.snapshot })
   }
-  return [{
+  const candidate = resolveDeclinableCandidate(machine, {
     sourcePath: event.path,
     leafPath: getActiveLeafPathFrom(machine, configuration, event.path),
     trigger: { type: "invoke", id: event.id, outcome: event.type },
     transition: transition as unknown as MicrostepTransition<States, E, R, any>,
     context
-  }]
+  })
+  return candidate === undefined ? [] : [candidate]
 }
 
 export const getTargetNodePath = <const States extends Machine.StateSchemas>(
@@ -1275,12 +1334,15 @@ const collectEvaluatedTransition = <
   selection: SelectedTransition<States, E, R, Context>
 ) => {
   const stateIdentifier = selection.leafPath
-  const transitionResult = collectTransition<States, Event, E, R, Context>(
+  const transitionResult = selection.collected ?? collectTransition<States, Event, E, R, Context>(
     machine,
     selection.transition.transition,
     selection.context,
     selection.transition.evaluate
   )
+  if (transitionResult.declined) {
+    throw new Error("Machine transition returned decline without declaring declinable: true")
+  }
   const unresolvedTarget = transitionResult.state === undefined
     ? undefined
     : transitionResult.state as

package/src/internal/machine/stateDefinition.ts

@@ -138,6 +138,22 @@ const assertPlainRecord: (
   }
 }
 
+const validateTargetSelectorChildKey = (
+  boundary: StateDefinitionBoundary,
+  path: string,
+  states: unknown,
+  key: "initial" | "with",
+  message: string
+): void => {
+  if (typeof states !== "object" || states === null || Array.isArray(states) || !hasOwn(states, key)) return
+  const child = (states as Readonly<Record<string, unknown>>)[key]
+  if (
+    typeof child === "object" && child !== null && !Schema.isSchema(child) &&
+    (child as Readonly<Record<string, unknown>>).type === "history"
+  ) return
+  fail(boundary, `${path}.${key}`, message)
+}
+
 const assertAllowedProperties = (
   boundary: StateDefinitionBoundary,
   path: string,
@@ -252,6 +268,22 @@ const validateStateTree = (
       if (typeof node.initial !== "string") {
         fail(boundary, `${path}.initial`, "compound states must declare an initial child key")
       }
+      validateTargetSelectorChildKey(
+        boundary,
+        path,
+        node.states,
+        "initial",
+        "active and choice child states cannot use the reserved target selector key \"initial\""
+      )
+      if (valued) {
+        validateTargetSelectorChildKey(
+          boundary,
+          path,
+          node.states,
+          "with",
+          "schema-backed compound child states cannot use the reserved local target selector key \"with\""
+        )
+      }
       const initialKey = node.initial as string
       validateStateTree(boundary, node.states, path, true)
       if (!hasOwn(node.states as object, initialKey)) {
@@ -270,6 +302,13 @@ const validateStateTree = (
       if (!hasOwn(node, "states")) {
         fail(boundary, `${path}.states`, "parallel states must declare child regions")
       }
+      validateTargetSelectorChildKey(
+        boundary,
+        path,
+        node.states,
+        "initial",
+        "active and choice child states cannot use the reserved target selector key \"initial\""
+      )
       validateStateTree(boundary, node.states, path, true)
     }
   }

package/src/internal/machine/topology.ts

@@ -25,6 +25,8 @@ export const ChoiceTargetTypeId: unique symbol = Symbol("effect/Machine/ChoiceTa
 
 export const NoTargetTypeId: unique symbol = Symbol("effect/Machine/NoTarget")
 
+export const DeclinedTypeId: unique symbol = Symbol("effect/Machine/Declined")
+
 export const TargetSelectionTypeId: unique symbol = Symbol("effect/Machine/TargetSelection")
 
 export const SelectedBranchTypeId: unique symbol = Symbol("effect/Machine/SelectedBranch")
@@ -66,6 +68,11 @@ export interface NoTarget {
   readonly [NoTargetTypeId]: typeof NoTargetTypeId
 }
 
+/** Internal marker returned when a declinable transition is not enabled. */
+export interface Declined {
+  readonly [DeclinedTypeId]: typeof DeclinedTypeId
+}
+
 export type TargetSelectionKind = "state" | "initial" | "history" | "choice" | "none"
 
 export type TargetSelectionScope = "local" | "branch" | "full" | "initial"
@@ -99,6 +106,9 @@ export const makeTargetSelection = (
     path
   })
 
+/** Source-independent definition-time selection for an explicitly targetless transition. */
+export const noneTargetSelection: TargetSelection = makeTargetSelection("none", undefined, "local")
+
 export const isTargetSelection = (u: unknown): u is TargetSelection => hasProperty(u, TargetSelectionTypeId)
 
 export const makeSelectedBranch = (
@@ -125,6 +135,14 @@ export const makeNoTarget = (): Machine.NoTarget => noTarget
 
 export const isNoTarget = (u: unknown): u is Machine.NoTarget => hasProperty(u, NoTargetTypeId)
 
+const declined = Object.freeze({
+  [DeclinedTypeId]: DeclinedTypeId
+}) as Declined
+
+export const makeDeclined = (): Machine.Declined => declined
+
+export const isDeclined = (u: unknown): u is Machine.Declined => hasProperty(u, DeclinedTypeId)
+
 export const makeHistoryTarget = (path: string, parent: string): HistoryTarget => ({
   [HistoryTargetTypeId]: HistoryTargetTypeId,
   path,
@@ -441,6 +459,11 @@ const transitionBranches = (handler: unknown): ReadonlyArray<Machine.TransitionB
     ? Array.from(handler.branches as ReadonlyArray<Machine.TransitionBranch>)
     : []
 
+const transitionAcceptance = (handler: unknown): Machine.TransitionAcceptance =>
+  typeof handler === "object" && handler !== null && "declinable" in handler && handler.declinable === true
+    ? "declinable"
+    : "required"
+
 export const transitionDefinitions = (
   machine: Machine.Any
 ): ReadonlyArray<Machine.TransitionDefinition> => {
@@ -457,6 +480,7 @@ export const transitionDefinitions = (
           source: node.path,
           trigger: { type: "choice" },
           reenter: false,
+          acceptance: "required",
           branches: transitionBranches(choice)
         })
       }
@@ -468,6 +492,7 @@ export const transitionDefinitions = (
         source: node.path,
         trigger: { type: "event", event },
         reenter: hasProperty(handler, "reenter") && handler.reenter === true,
+        acceptance: transitionAcceptance(handler),
         branches: transitionBranches(handler)
       })
     }
@@ -476,6 +501,7 @@ export const transitionDefinitions = (
         source: node.path,
         trigger: { type: "always" },
         reenter: false,
+        acceptance: transitionAcceptance(config.always),
         branches: transitionBranches(config.always)
       })
     }
@@ -484,6 +510,7 @@ export const transitionDefinitions = (
         source: node.path,
         trigger: { type: "done" },
         reenter: false,
+        acceptance: transitionAcceptance(config.onDone),
         branches: transitionBranches(config.onDone)
       })
     }
@@ -507,6 +534,7 @@ export const transitionDefinitions = (
             source: node.path,
             trigger: { type: "invoke", id, outcome },
             reenter: typeof handler === "object" && handler !== null && handler.reenter === true,
+            acceptance: transitionAcceptance(handler),
             branches: transitionBranches(handler)
           })
         }

package/src/internal/testing/machine/finiteModel.ts

@@ -1316,7 +1316,7 @@ const selectHistoryTarget = (builder: Record<string, any>, path: string): unknow
   const parts = path.split(".")
   let current: any = builder
   for (let index = 0; index < parts.length - 1; index++) current = current[parts[index]!]
-  return current[parts[parts.length - 1]!]()
+  return current[parts[parts.length - 1]!]
 }
 
 const selectableDefinitionTarget = (
@@ -1356,7 +1356,7 @@ const selectDefinitionTarget = (
   const parts = selectable.split(".")
   for (const part of parts) current = current[part]
   if (typeof current === "function") return current()
-  return current.initial()
+  return current.initial
 }
 
 const resolveDefinitionTarget = (
@@ -1415,11 +1415,10 @@ const makeHandlers = (
     if (node._tag === "History") continue
     if (node._tag === "Choice") {
       handlers[node.key] = {
-        choice: (Machine.transition as any)({
-          target: (to: Record<string, any>) => selectDefinitionTarget(to, path, node.selected, byPath) as any,
-          resolve: ({ target }: { readonly target: any }) =>
-            resolveDefinitionTarget(target, path, node.selected, byPath)
-        } as any)
+        choice: (to: Record<string, any>) =>
+          (selectDefinitionTarget(to, path, node.selected, byPath) as any).resolve(
+            ({ target }: { readonly target: any }) => resolveDefinitionTarget(target, path, node.selected, byPath)
+          )
       }
       continue
     }
@@ -1432,17 +1431,16 @@ const makeHandlers = (
     let onDone: unknown
     for (const transition of transitions.values()) {
       if (transition.source !== path) continue
-      const config = (Machine.transition as any)({
-        ...("reenter" in transition ? { reenter: transition.reenter } : {}),
-        target: (to: Record<string, any>) =>
-          transition.target === undefined
-            ? to.none()
-            : selectDefinitionTarget(to, path, transition.target, byPath),
-        resolve: transition.target === undefined
+      const config = (to: Record<string, any>) => {
+        const selected = transition.target === undefined
+          ? to.none
+          : selectDefinitionTarget(to, path, transition.target, byPath)
+        const resolve = transition.target === undefined
           ? () => undefined
           : ({ target }: { readonly target: any }) =>
             resolveDefinitionTarget(target, path, transition.target!, byPath, transition.targetValue)
-      } as any)
+        return selected.resolve(resolve, "reenter" in transition ? { reenter: transition.reenter } : undefined)
+      }
       if (transition.trigger.type === "event") on[transition.trigger.event] = config
       else if (transition.trigger.type === "always") always = config
       else onDone = config
@@ -1515,13 +1513,12 @@ export const compileModel = (model: FiniteModel): Machine.Machine.Any => {
   const machine = Machine.make({
     states: defined.states as any,
     events: Machine.events(...eventSchemas) as any,
-    initial: {
-      target: (to: Record<string, any>) => {
-        const selected = to[initial.path]
-        return typeof selected === "function" ? selected() : selected.initial()
-      },
-      resolve: ({ target }: { readonly target: any }) =>
+    initial: (to: Record<string, any>) => {
+      const selected = to[initial.path]
+      const selection = typeof selected === "function" ? selected() : selected.initial
+      return selection.resolve(({ target }: { readonly target: any }) =>
         selectSnapshot({ [initial.path]: target }, initial.path, byPath, [initial.path], 0) as any
+      )
     }
   } as any)
   const transitions = new Map(model.transitions.map((transition) => [

package/src/internal/testing/machine/transitionCoverage.ts

@@ -66,6 +66,7 @@ export const makeTransitionCoverageCollector = <M extends AnyMachine>(
       source: definition.source,
       trigger: definition.trigger,
       reenter: definition.reenter,
+      acceptance: definition.acceptance,
       branches: definition.branches
     })
   )
@@ -85,6 +86,7 @@ export const makeTransitionCoverageCollector = <M extends AnyMachine>(
         source: definition.source,
         trigger: definition.trigger,
         reenter: definition.reenter,
+        acceptance: definition.acceptance,
         branch
       })
     })

package/src/testing/MachineTest.ts

@@ -138,6 +138,10 @@ type ReadyMachine<M extends AnyMachine> =
     Machine.Machine.OutputStates<M>
   >
 
+type RootReadyMachine<M extends AnyMachine> =
+  & ReadyMachine<M>
+  & Machine.Machine.RootCompatible<Machine.Machine.ParentEvents<M>>
+
 /**
  * A generated public-input scenario for a machine.
  *
@@ -238,10 +242,8 @@ export interface Scenarios<M extends AnyMachine> {
  * }).handle({
  *   Idle: {
  *     on: {
- *       Reset: Machine.transition({
- *         target: (to) => to.full.Idle(),
- *         resolve: ({ target }) => target.from()
- *       })
+ *       Reset: (to) =>
+ *         to.full.Idle().resolve(({ target }) => target.from())
  *     }
  *   }
  * })
@@ -881,7 +883,7 @@ export { PlannerRuntimeAgreementError } from "../internal/testing/machine/verifi
  * @since 0.4.0
  */
 export const assertPlannerRuntimeAgreement: <M extends AnyMachine, Error, Output>(
-  machine: ReadyMachine<M>,
+  machine: RootReadyMachine<M>,
   transcript: CausalRuntimeEvidence<M, Error, Output>
 ) => Effect.Effect<void, internal.PlannerRuntimeAgreementError<M>, RunServices<M>> =
   internal.assertPlannerRuntimeAgreement
@@ -1447,10 +1449,9 @@ export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = Ex
  * }).handle({
  *   Count: {
  *     on: {
- *       Increment: Machine.transition({
- *         target: (to) => to.full.Count(),
- *         resolve: ({ state, target }) => target(new Count({ value: state.value + 1 }))
- *       })
+ *       Increment: (to) =>
+ *         to.full.Count().resolve(({ state, target }) =>
+ *           target(new Count({ value: state.value + 1 })))
  *     }
  *   }
  * })
@@ -1465,7 +1466,7 @@ export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = Ex
  * @since 0.4.0
  */
 export const explore: <M extends AnyMachine, Key extends ExplorationKey>(
-  machine: ReadyMachine<M>,
+  machine: RootReadyMachine<M>,
   options: ExploreOptions<M, Key>
 ) => Effect.Effect<
   Exploration<M, Key>,
@@ -1646,7 +1647,7 @@ export type RunServices<M extends AnyMachine> = IsAny<
  * @since 0.4.0
  */
 export const run: <M extends AnyMachine>(
-  machine: ReadyMachine<M>,
+  machine: RootReadyMachine<M>,
   scenario: Scenario<M>
 ) => Effect.Effect<Trace<M>, RunFailure<RunError<M>, M>, RunServices<M>> = internal.run
 
@@ -1703,6 +1704,7 @@ export interface TransitionDefinitionCoverageItem<
   readonly source: SourcePath
   readonly trigger: Machine.Machine.TransitionTrigger<EventTag>
   readonly reenter: boolean
+  readonly acceptance: Machine.Machine.TransitionAcceptance
   readonly branches: ReadonlyArray<Machine.Machine.TransitionBranch<TargetPath>>
 }
 
@@ -1725,6 +1727,7 @@ export interface TransitionBranchCoverageItem<
   readonly source: SourcePath
   readonly trigger: Machine.Machine.TransitionTrigger<EventTag>
   readonly reenter: boolean
+  readonly acceptance: Machine.Machine.TransitionAcceptance
   readonly branch: Machine.Machine.TransitionBranch<TargetPath>
 }
 

package/src/unstable/cluster/ClusterMachine.ts

@@ -342,7 +342,8 @@ export const make: <
   Output,
   Emits extends ReadonlyArray<Machine.Machine.TaggedSchema>,
   OutputStates extends Machine.Machine.StateIdentifier<States>,
-  InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = readonly []
 >(
   type: Type,
   machine:
@@ -359,9 +360,11 @@ export const make: <
       Output,
       Emits,
       OutputStates,
-      InputEvents
+      InputEvents,
+      ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.Machine.RootCompatible<ParentEvents>,
   options: {
     readonly version: string
   },
@@ -381,7 +384,8 @@ export const make: <
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >,
   | ExcludeCompatibleRuntime<
     Machine.ExecutionServices<R | InitialR>,