@typeonce/effect-machine 0.31.1 → 0.32.0

package/src/internal/machine/planner.ts

@@ -40,6 +40,7 @@ import {
 } from "./configuration.js"
 import { InfiniteTransitionError, MachineSchemaDecodeError, StartupError, StoppedError } from "./errors.js"
 import { getStateInitializeValues, makeStateInitializeBuilder } from "./initialization.js"
+import * as InvocationDefinition from "./invocationDefinition.js"
 import * as InvocationEvent from "./invocationEvent.js"
 import { decodeEventSync, decodeInputSync, decodeStateValueSync } from "./protocol.js"
 import { InitialEventTypeId } from "./symbols.js"
@@ -56,9 +57,15 @@ import {
   isStateUpdate,
   isTarget,
   makeChoiceTarget,
+  makeStateInput,
   makeTarget,
   TargetSnapshotTypeId
 } from "./topology.js"
+import type {
+  EventTransition,
+  TransitionEvaluator,
+  TransitionHandler as CapturedTransitionHandler
+} from "./transition.js"
 
 export type MicrostepPlan<State, Event, E, R> = {
   readonly next: State
@@ -104,21 +111,12 @@ 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.Declined
-
-type TransitionEvaluation<States extends Machine.StateSchemas, E, R> = {
-  readonly result: Machine.HandlerResult<States, E, R> | Machine.Declined
-  readonly branchIndex: number
-  readonly branchKey: string | undefined
-}
-
-type TransitionEvaluator<States extends Machine.StateSchemas, E, R, Context> = (
-  context: Context,
-  enqueue: Enqueue<any, any>
-) => TransitionEvaluation<States, E, R>
+export type TransitionHandler<States extends Machine.StateSchemas, E, R, Context> = CapturedTransitionHandler<
+  States,
+  E,
+  R,
+  Context
+>
 
 type PlanningMachineReferences = {
   readonly self: MachineTarget<any>
@@ -170,16 +168,6 @@ const resolveMachineReferences = (
   return root
 }
 
-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>
-  }
-
 export type MicrostepTransition<States extends Machine.StateSchemas, E, R, Context> = {
   readonly reenter: boolean
   readonly declinable: boolean
@@ -344,7 +332,9 @@ const completeHistoryConfiguration = (
         if (child.schema !== undefined) {
           const initializer = machine.handlers[path]?.initialize
           if (initializer === undefined) {
-            throw new Error(`Machine shallow history requires an initial value implementation for state "${path}"`)
+            values.set(child.path, decodeStateValueSync(machine, child, makeStateInput({})))
+            changed = true
+            continue
           }
           const initialized = collectStateInitializer(machine, initializer, {
             ...resolveMachineReferences(machine, current),
@@ -374,9 +364,6 @@ const completeHistoryConfiguration = (
             machineReferences: configuration.machineReferences
           } as ActiveConfiguration
           const initializer = valuedMissing.length === 0 ? undefined : machine.handlers[path]?.initialize
-          if (valuedMissing.length > 0 && initializer === undefined) {
-            throw new Error(`Machine shallow history requires an initial value implementation for state "${path}"`)
-          }
           const initialized = initializer === undefined ? undefined : collectStateInitializer(machine, initializer, {
             ...resolveMachineReferences(machine, current),
             state: current.values.get(path),
@@ -392,8 +379,11 @@ const completeHistoryConfiguration = (
             const child = getNode(machine, childPath)
             active.add(child.path)
             if (child.schema !== undefined) {
+              if (initialized === undefined) {
+                values.set(child.path, decodeStateValueSync(machine, child, makeStateInput({})))
+                continue
+              }
               if (
-                initialized === undefined ||
                 initializedValues === undefined || !Object.prototype.hasOwnProperty.call(initializedValues, child.key)
               ) {
                 throw new Error(`Machine parallel state initializer for "${path}" must return region "${child.key}"`)
@@ -468,6 +458,7 @@ function resolveHistoryTarget(
     const completed = completeHistoryConfiguration(machine, restored, event)
     const snapshot = snapshotFromConfigurationAtPath(machine, completed.configuration, target.parent)
     const values = Object.fromEntries(completed.configuration.values)
+    if (target.parent !== "" && configuration.active.has("")) delete values[""]
     return {
       target: makeTarget(target.parent as any, snapshot.value as any, {
         snapshot: snapshot as any,
@@ -487,7 +478,7 @@ function resolveHistoryTarget(
   }
   const collected = collectTransition(machine, fallback, {
     event,
-    target: getTargetBuilder(machine, target.parent).full,
+    target: getTargetBuilder(machine, target.parent).full[""],
     owner: target.parent
   })
   if (collected.state === undefined || isHistoryTarget(collected.state) || !isSnapshot(collected.state)) {
@@ -531,6 +522,7 @@ function resolveHistoryTarget(
   }
   const snapshot = snapshotFromConfigurationAtPath(machine, fallbackConfiguration, target.parent)
   const values = Object.fromEntries(fallbackConfiguration.values)
+  if (target.parent !== "" && configuration.active.has("")) delete values[""]
   return {
     target: makeTarget(target.parent as any, snapshot.value as any, {
       snapshot: snapshot as any,
@@ -765,7 +757,7 @@ const collectStateActions = <
 ) => {
   const commands: Array<RuntimeCommand> = []
   const raisedEvents: Array<Machine.EventOf<Events>> = []
-  const emittedEvents: Array<Machine.EmitOf<Emits>> = []
+  const emittedEvents: Array<Machine.EmittedEventOf<Emits>> = []
   for (const path of paths) {
     const collected = collectStateAction<
       Machine.StateActionContext<States, Events, Emits, Machine.StateIdentifier<States>>,
@@ -784,7 +776,7 @@ const collectStateActions = <
     )
     commands.push(...collected.commands)
     raisedEvents.push(...collected.raisedEvents)
-    emittedEvents.push(...collected.emittedEvents as ReadonlyArray<Machine.EmitOf<Emits>>)
+    emittedEvents.push(...collected.emittedEvents as ReadonlyArray<Machine.EmittedEventOf<Emits>>)
   }
   return { commands, emittedEvents, raisedEvents }
 }
@@ -1024,7 +1016,7 @@ const selectInvocationTransition = <
 ): ReadonlyArray<SelectedTransition<States, E, R, any>> => {
   if (!configuration.active.has(event.path)) return []
   const config = machine.handlers[event.path] as Machine.AnyStateConfig | undefined
-  const invoke = InvocationEvent.definitions(config?.invoke).find((definition) => {
+  const invoke = InvocationDefinition.definitions(config?.invoke).find((definition) => {
     const id = "child" in definition ? definition.child?.id : definition.id
     return String(id) === event.id
   })
@@ -1096,7 +1088,7 @@ export const validateDeclaredTransitionTarget = (
   const actual = typeof target === "object" && target !== null && "path" in target
     ? String(target.path)
     : "<unknown>"
-  if (!declaredTargets.some((path) => actual === path || actual.startsWith(`${path}.`))) {
+  if (!declaredTargets.some((path) => actual === path || (path === "" || actual.startsWith(`${path}.`)))) {
     const triggerLabel = trigger.type === "event" ? String(trigger.event) : trigger.type
     throw new Error(
       `Machine transition from "${sourcePath}" on "${triggerLabel}" returned target "${actual}" outside declared targets: ${
@@ -1277,15 +1269,19 @@ function resolveChoiceTarget(
       if (choice === undefined || typeof choice.transition !== "function") {
         throw new Error(`Machine choice state "${node.path}" requires an implementation`)
       }
+      const provisionalValues = new Map(configuration.values)
+      for (const [path, value] of Object.entries(extracted.values)) {
+        const valueNode = getNode(machine, path)
+        if (valueNode.schema !== undefined) {
+          provisionalValues.set(path, decodeStateValueSync(machine, valueNode, value))
+        }
+      }
       const provisional: ActiveConfiguration = {
         active: new Set([
           ...configuration.active,
           ...Object.keys(extracted.values)
         ]),
-        values: new Map([
-          ...configuration.values,
-          ...Object.entries(extracted.values)
-        ]),
+        values: provisionalValues,
         outputs: configuration.outputs,
         history: configuration.history,
         ...(configuration.machineReferences === undefined ? {} : { machineReferences: configuration.machineReferences })
@@ -1382,10 +1378,9 @@ const collectEvaluatedTransition = <
     ? (() => {
       const node = getNode(machine, stateUpdate.path)
       if (
-        !state.active.has(node.path) || node.schema === undefined ||
-        (node.type !== "compound" && node.type !== "parallel")
+        !state.active.has(node.path) || node.schema === undefined
       ) {
-        throw new Error(`Machine state update owner "${node.path}" must be an active valued compound or parallel state`)
+        throw new Error(`Machine state update owner "${node.path}" must be an active valued state`)
       }
       return {
         path: node.path,
@@ -1703,13 +1698,17 @@ export const planInitialSync = <
     : args.length === 0
     ? (decodeInputSync(machine, machine.input, undefined), args)
     : [decodeInputSync(machine, machine.input, args[0])] as [...Machine.InputArgs<Input>]
-  const state = machine.initial(...inputArgs)
+  const initial = machine.initial(...inputArgs)
   const emptyConfiguration: ActiveConfiguration = {
     active: new Set(),
     values: new Map(),
     outputs: new Map(),
     history: new Map()
   }
+  const rootResolution = isInitialTarget(initial)
+    ? resolveInitialTarget(machine, emptyConfiguration, initial, InitialEvent)
+    : undefined
+  const state = rootResolution?.target ?? initial
   const initialChoice = choiceFromTarget(state)
   const choiceResolution = initialChoice === undefined
     ? undefined
@@ -1725,9 +1724,11 @@ export const planInitialSync = <
   const initialHistoryChoiceTransitions: Array<ResolvedChoiceTransition> = []
   const resolvedInitialTargets: Array<unknown> = []
   for (
-    const target of choiceResolution === undefined
+    const target of choiceResolution !== undefined
+      ? [choiceResolution.target, ...choiceResolution.additionalTargets]
+      : rootResolution === undefined
       ? []
-      : [choiceResolution.target, ...choiceResolution.additionalTargets]
+      : [rootResolution.target]
   ) {
     if (!isHistoryTarget(target)) {
       resolvedInitialTargets.push(target)
@@ -1740,7 +1741,7 @@ export const planInitialSync = <
     initialHistoryEmittedEvents.push(...history.emittedEvents)
     initialHistoryChoiceTransitions.push(...history.transitions)
   }
-  let resolvedConfiguration = choiceResolution === undefined
+  let resolvedConfiguration = resolvedInitialTargets.length === 0
     ? normalizeConfigurationSync<States>(machine, state as Machine.Snapshot<States>)
     : normalizeTargetConfigurationSync<States>(
       machine,
@@ -1757,18 +1758,21 @@ export const planInitialSync = <
     )
   }
   const configuration: ActiveConfiguration = resolvedConfiguration
-  validateInitialConfiguration(machine, configuration)
+  if (machine.initialDefinition.selection.kind === "initial") validateInitialConfiguration(machine, configuration)
   const startingState = snapshotFromConfiguration<States>(machine, configuration)
   const initialEntryPaths = getInitialEntryPaths(machine, configuration)
   const commands = [
+    ...(rootResolution?.commands ?? []),
     ...(choiceResolution?.commands ?? []),
     ...initialHistoryActions
   ]
   const raisedEvents = [
+    ...(rootResolution?.raisedEvents ?? []),
     ...(choiceResolution?.raisedEvents ?? []),
     ...initialHistoryRaisedEvents
   ]
   const emittedEvents = [
+    ...(rootResolution?.emittedEvents ?? []),
     ...(choiceResolution?.emittedEvents ?? []),
     ...initialHistoryEmittedEvents
   ]
@@ -1786,21 +1790,27 @@ export const planInitialSync = <
     [...entry.commands],
     [...raisedEvents, ...entry.raisedEvents] as Array<Machine.EventOf<Events>>,
     [...emittedEvents, ...entry.emittedEvents],
-    choiceResolution === undefined ? [] : [{
-      next: configuration,
-      event: InitialEvent,
-      transitions: [...choiceResolution.transitions, ...initialHistoryChoiceTransitions],
-      commands: [...choiceResolution.commands, ...initialHistoryActions],
-      raisedEvents: [
-        ...choiceResolution.raisedEvents,
-        ...initialHistoryRaisedEvents
-      ] as ReadonlyArray<Machine.EventOf<Events>>,
-      emittedEvents: [...choiceResolution.emittedEvents, ...initialHistoryEmittedEvents],
-      exitPaths: [],
-      entryPaths: [],
-      changed: false,
-      stabilize: false
-    }]
+    choiceResolution === undefined && (rootResolution?.transitions.length ?? 0) === 0 &&
+      initialHistoryChoiceTransitions.length === 0 ?
+      [] :
+      [{
+        next: configuration,
+        event: InitialEvent,
+        transitions: [
+          ...(rootResolution?.transitions ?? []),
+          ...(choiceResolution?.transitions ?? []),
+          ...initialHistoryChoiceTransitions
+        ],
+        commands,
+        raisedEvents: [
+          ...raisedEvents
+        ] as ReadonlyArray<Machine.EventOf<Events>>,
+        emittedEvents,
+        exitPaths: [],
+        entryPaths: [],
+        changed: false,
+        stabilize: false
+      }]
   )
 
   const planned = {
@@ -1811,7 +1821,7 @@ export const planInitialSync = <
       ...commands,
       ...settled.commands
     ],
-    emittedEvents: settled.emittedEvents as ReadonlyArray<Machine.EmitOf<Emits>>,
+    emittedEvents: settled.emittedEvents as ReadonlyArray<Machine.EmittedEventOf<Emits>>,
     microsteps: settled.microsteps.map((step) => ({
       next: snapshotFromConfiguration<States>(machine, step.next),
       event: step.event,
@@ -2204,6 +2214,7 @@ const macrostepConfiguration = <
       throw new Error("Machine reached a terminal configuration without a completed root output")
     }
     return {
+      event: decodedEvent,
       next: completed.configuration,
       commands: [],
       emittedEvents: [],
@@ -2222,6 +2233,7 @@ const macrostepConfiguration = <
     )
   if (selections.length === 0) {
     return {
+      event: decodedEvent,
       next: configuration,
       commands: [],
       emittedEvents: [],
@@ -2240,7 +2252,10 @@ const macrostepConfiguration = <
   const raisedEvents = [...step.raisedEvents]
   const emittedEvents = [...step.emittedEvents]
   const microsteps = [step]
-  return settle(machine, step.next, decodedEvent as any, commands, raisedEvents, emittedEvents, microsteps)
+  return {
+    ...settle(machine, step.next, decodedEvent as any, commands, raisedEvents, emittedEvents, microsteps),
+    event: decodedEvent
+  }
 }
 
 const snapshotMacrostep = <
@@ -2251,9 +2266,10 @@ const snapshotMacrostep = <
   Output
 >(
   machine: Machine.Any,
-  settled: MacrostepPlan<ActiveConfiguration, Event, E, R, Output>
-): MacrostepPlan<Machine.Snapshot<States>, Event, E, R, Output> => {
+  settled: MacrostepPlan<ActiveConfiguration, Event, E, R, Output> & { readonly event: unknown }
+): MacrostepPlan<Machine.Snapshot<States>, Event, E, R, Output> & { readonly event: unknown } => {
   const planned = {
+    event: settled.event,
     next: snapshotFromConfiguration<States>(machine, settled.next),
     commands: settled.commands,
     emittedEvents: settled.emittedEvents,

package/src/internal/machine/process.ts

@@ -16,19 +16,10 @@ import type { StoppedError } from "./errors.js"
 import * as ExecutionPlan from "./executionPlan.js"
 import * as Invocation from "./invocation.js"
 import * as internalPlanner from "./planner.js"
+import type { ExcludeCompatibleRuntime } from "./requirements.js"
 import * as internalRuntime from "./runtime.js"
 import * as Serialization from "./serialization.js"
 
-type IsAny<A> = 0 extends (1 & A) ? true : false
-
-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 ProcessEntry<States extends Machine.StateSchemas, Input extends Schema.Top> =
   | {
     readonly _tag: "Initial"
@@ -50,6 +41,7 @@ const runSequentialDiscard = <E, R>(
 
 const acknowledgedPlan = (
   planned: {
+    readonly event: unknown
     readonly next: unknown
     readonly commands: ReadonlyArray<unknown>
     readonly emittedEvents: ReadonlyArray<unknown>
@@ -69,6 +61,7 @@ const acknowledgedPlan = (
   },
   snapshot: (state: unknown) => unknown
 ): unknown => ({
+  event: planned.event,
   next: snapshot(planned.next),
   commands: planned.commands,
   emittedEvents: planned.emittedEvents,
@@ -397,7 +390,7 @@ const makeProcessLogic: <
   ExcludeCompatibleRuntime<
     Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
     Machine.EventOf<Events>,
-    Machine.EmitOf<Emits>
+    Machine.EmittedEventOf<Emits>
   >,
   Output,
   | InitialE
@@ -469,7 +462,7 @@ const makeProcessLogic: <
               ? undefined
               : CommandRuntime.runEmittedEvents(
                 planned.emittedEvents,
-                CommandRuntime.makeLiveRuntime<Machine.EventOf<Events>, Machine.EmitOf<Emits>>(machine, scope)
+                CommandRuntime.makeLiveRuntime<Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>(machine, scope)
               )
             const result = Effect.succeed({
               state: planned.state,
@@ -531,7 +524,7 @@ const makeProcessLogic: <
             // so the Effect scheduler remains responsible for cooperative yield.
             let configuration: Configuration.ActiveConfiguration | undefined
             let pendingMessage: Option.Option<internalRuntime.ProcessMessage<Machine.EventOf<Events>>> = Option.none()
-            let liveRuntime: Runtime<Machine.EventOf<Events>, Machine.EmitOf<Emits>> | undefined
+            let liveRuntime: Runtime<Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>> | undefined
             while (terminal === undefined) {
               const message = Option.isSome(pendingMessage) ? pendingMessage.value : yield* receiveMessage
               pendingMessage = Option.none()
@@ -563,7 +556,7 @@ const makeProcessLogic: <
                 current = next
                 if (planned.emittedEvents.length > 0) {
                   yield* CommandRuntime.runEmittedEvents(
-                    planned.emittedEvents as ReadonlyArray<Machine.EmitOf<Emits>>,
+                    planned.emittedEvents as ReadonlyArray<Machine.EmittedEventOf<Emits>>,
                     liveRuntime ??= CommandRuntime.makeLiveRuntime(machine, context)
                   )
                 }
@@ -639,7 +632,7 @@ const makeProcessLogic: <
             // worker can continue draining an already queued batch.
             configuration = undefined
             let pendingMessage: Option.Option<internalRuntime.ProcessMessage<Machine.EventOf<Events>>> = Option.none()
-            let liveRuntime: Runtime<Machine.EventOf<Events>, Machine.EmitOf<Emits>> | undefined
+            let liveRuntime: Runtime<Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>> | undefined
 
             // Match the compact non-invoke loop while retaining state-scoped
             // child lifecycle work at the same ordered Effect boundaries.
@@ -687,7 +680,7 @@ const makeProcessLogic: <
                 current = next
                 if (planned.emittedEvents.length > 0) {
                   yield* CommandRuntime.runEmittedEvents(
-                    planned.emittedEvents as ReadonlyArray<Machine.EmitOf<Emits>>,
+                    planned.emittedEvents as ReadonlyArray<Machine.EmittedEventOf<Emits>>,
                     liveRuntime ??= CommandRuntime.makeLiveRuntime(machine, context)
                   )
                 }
@@ -741,7 +734,7 @@ const makeProcessLogic: <
     ExcludeCompatibleRuntime<
       Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
       Machine.EventOf<Events>,
-      Machine.EmitOf<Emits>
+      Machine.EmittedEventOf<Emits>
     >,
     Output,
     | InitialE
@@ -781,7 +774,7 @@ export const toProcessLogic: <
   ExcludeCompatibleRuntime<
     Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
     Machine.EventOf<Events>,
-    Machine.EmitOf<Emits>
+    Machine.EmittedEventOf<Emits>
   >,
   Output,
   | InitialE
@@ -887,7 +880,7 @@ export const start: <
   ExcludeCompatibleRuntime<
     Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
     Machine.EventOf<Events>,
-    Machine.EmitOf<Emits>
+    Machine.EmittedEventOf<Emits>
   >
 > = (machine, ...args) =>
   internalRuntime.startProcess(
@@ -931,7 +924,7 @@ export const prepare: <
     ExcludeCompatibleRuntime<
       Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
       Machine.EventOf<Events>,
-      Machine.EmitOf<Emits>
+      Machine.EmittedEventOf<Emits>
     >
   >
 > = (machine, ...args) =>
@@ -966,7 +959,7 @@ export const resume: <
   ExcludeCompatibleRuntime<
     Exclude<ExecutionServices<R>, internalRuntime.MachineRuntime>,
     Machine.EventOf<Events>,
-    Machine.EmitOf<Emits>
+    Machine.EmittedEventOf<Emits>
   >
 > = (machine, snapshot) =>
   internalRuntime.startProcess(

package/src/internal/machine/protocol.ts

@@ -24,9 +24,7 @@ interface MachineProtocolSchemas {
   readonly event: Schema.Top
   readonly emit: Schema.Top
   readonly eventConstructors: ReadonlySet<object>
-  readonly trustedEvents: WeakSet<object>
   readonly emissionConstructors: ReadonlySet<object>
-  readonly trustedEmissions: WeakSet<object>
 }
 
 interface EventProtocolDefinition {
@@ -171,9 +169,7 @@ export const setProtocol = (machine: Machine.Any): void => {
     event: Schema.Union(events),
     emit: Schema.Union(emittedEvents),
     eventConstructors: collectEventConstructors(events),
-    trustedEvents: new WeakSet(),
-    emissionConstructors: collectEventConstructors(emittedEvents),
-    trustedEmissions: new WeakSet()
+    emissionConstructors: collectEventConstructors(emittedEvents)
   })
 }
 
@@ -419,11 +415,6 @@ const decodeEventConstruction = (
           })
         )
       )
-    ),
-    Effect.tap((event) =>
-      Effect.sync(() =>
-        (boundary === "event" ? protocol.trustedEvents : protocol.trustedEmissions).add(event as object)
-      )
     )
   )
 }
@@ -453,13 +444,9 @@ const decodeEventConstructionSync = (
     boundary,
     event: String(construction._tag)
   })
-  ;(boundary === "event" ? protocol.trustedEvents : protocol.trustedEmissions).add(event as object)
   return event
 }
 
-const isTrustedEvent = (protocol: MachineProtocolSchemas, event: unknown): boolean =>
-  typeof event === "object" && event !== null && protocol.trustedEvents.has(event)
-
 export const decodeInput = <Input extends Schema.Top>(
   machine: Machine.Any,
   schema: Input,
@@ -478,10 +465,9 @@ export const decodeEvent = <const Events extends ReadonlyArray<Machine.TaggedSch
       MachineSchemaDecodeError
     >
   }
-  if (isTrustedEvent(protocol, event)) {
-    return Effect.succeed(event as Machine.EventOf<Events>)
-  }
   const eventName = getEventName(event)
+  // Decoded objects can escape to user code and be mutated. Validation is local
+  // to this delivery; object identity is never evidence of continued validity.
   return decodeBoundary<Machine.EventOf<Events>>(
     machine,
     protocol.event,
@@ -498,9 +484,6 @@ export const decodeEventSync = <const Events extends ReadonlyArray<Machine.Tagge
   if (isEventConstruction(event)) {
     return decodeEventConstructionSync(machine, protocol, event, "event") as Machine.EventOf<Events>
   }
-  if (isTrustedEvent(protocol, event)) {
-    return event as Machine.EventOf<Events>
-  }
   const eventName = getEventName(event)
   return decodeBoundarySync<Machine.EventOf<Events>>(
     machine,
@@ -513,19 +496,16 @@ export const decodeEventSync = <const Events extends ReadonlyArray<Machine.Tagge
 export const decodeEmit = <const Emits extends ReadonlyArray<Machine.TaggedSchema>>(
   machine: Machine.Any,
   event: unknown
-): Effect.Effect<Machine.EmitOf<Emits>, MachineSchemaDecodeError> => {
+): Effect.Effect<Machine.EmittedEventOf<Emits>, MachineSchemaDecodeError> => {
   const protocol = getProtocolSchemas(machine)
   if (isEventConstruction(event)) {
     return decodeEventConstruction(machine, protocol, event, "emission") as Effect.Effect<
-      Machine.EmitOf<Emits>,
+      Machine.EmittedEventOf<Emits>,
       MachineSchemaDecodeError
     >
   }
-  if (typeof event === "object" && event !== null && protocol.trustedEmissions.has(event)) {
-    return Effect.succeed(event as Machine.EmitOf<Emits>)
-  }
   const eventName = getEventName(event)
-  return decodeBoundary<Machine.EmitOf<Emits>>(
+  return decodeBoundary<Machine.EmittedEventOf<Emits>>(
     machine,
     protocol.emit,
     event,
@@ -536,16 +516,13 @@ export const decodeEmit = <const Emits extends ReadonlyArray<Machine.TaggedSchem
 export const decodeEmitSync = <const Emits extends ReadonlyArray<Machine.TaggedSchema>>(
   machine: Machine.Any,
   event: unknown
-): Machine.EmitOf<Emits> => {
+): Machine.EmittedEventOf<Emits> => {
   const protocol = getProtocolSchemas(machine)
   if (isEventConstruction(event)) {
-    return decodeEventConstructionSync(machine, protocol, event, "emission") as Machine.EmitOf<Emits>
-  }
-  if (typeof event === "object" && event !== null && protocol.trustedEmissions.has(event)) {
-    return event as Machine.EmitOf<Emits>
+    return decodeEventConstructionSync(machine, protocol, event, "emission") as Machine.EmittedEventOf<Emits>
   }
   const eventName = getEventName(event)
-  return decodeBoundarySync<Machine.EmitOf<Emits>>(
+  return decodeBoundarySync<Machine.EmittedEventOf<Emits>>(
     machine,
     protocol.emit,
     event,

package/src/internal/machine/readiness.ts

@@ -8,3 +8,4 @@ export type EnsureExecutable<
 > =
   & Machine.Machine.EnsureOutputImplementations<States, OutputStates>
   & Machine.Machine.EnsureHistoryImplementations<States, UnhandledStates>
+  & Machine.Machine.EnsureInitialImplementations<States, UnhandledStates>

package/src/internal/machine/requirements.ts

@@ -0,0 +1,11 @@
+import type { Runtime } from "../../Machine.js"
+
+export type IsAny<A> = 0 extends (1 & A) ? true : false
+
+export 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