anchor.diff:          | :? 'TCmd as cmd -> 
               let id = commandHandler.GetId commandContext cmd
               let stream = aggregateConfiguration.GetCommandStreamName commandContext id
  -            runCommand stream aggregateConfiguration.StateBuilder commandHandler.StateBuilder commandHandler.SystemConfiguration (processCommand cmd)
  +            eventStream {
  +                let! (eventsConsumed, combinedState) = 
  +                    aggregateConfiguration.StateBuilder 
  +                    |> CombinedStateBuilder.toStreamProgram stream
  +
  +                return! runCommand stream (eventsConsumed, combinedState) commandHandler.StateBuilder commandHandler.SystemConfiguration (processCommand cmd)
  +            }
           | _ -> 
               eventStream {
                   return NonEmptyList.singleton (sprintf "Invalid command type: %A expected %A" (cmd.GetType()) typeof<'TCmd>) |> Choice2Of2
  
positive.code:             sb.GetId context cmd
          | _ -> failwith <| sprintf "Invalid command %A" (cmd.GetType())
  
      let getChildState combinedState (childStateBuilder : NamedStateBuilder<'TChildState, 'TMetadata>) stream = eventStream {
              let! (eventsConsumed, state) = 
                  combinedState 
                  |> CombinedStateBuilder.toStreamProgram stream
  
              let childState = 
                  Option.maybe {
                      let! stateValue = state
                      match stateValue |> Map.tryFind childStateBuilder.Name with
                      | Some hasValue ->
                          return hasValue :?> 'TChildState
                      | None ->
                          return childStateBuilder.Builder.InitialState
                  }
  
              return (eventsConsumed, childState)
          }
  
      let inline runCommand stream combinedStateBuilder commandStateBuilder systemConfiguration f = 
          let unwrapper = MagicMapper.getUnwrapper<'TEvent>()
  
          eventStream {
              let! (eventsConsumed, commandState) = getChildState combinedStateBuilder commandStateBuilder stream
  
              let result = 
                  f commandState
  
negative.code:                 let typedEvent = evt.Body :?> 'TOnEvent
                  let resultingStream = aggregateConfig.GetEventStreamName eventContext (fId typedEvent)
  
                  let! (eventsConsumed, combinedState) = 
                      aggregateConfig.StateBuilder |> CombinedStateBuilder.toStreamProgram resultingStream
                  let! state = getChildState combinedState stateBuilder
  
                  let! eventTypeMap = getEventTypeMap()
  
  