diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1de20d5f..8bccb098 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,19 @@ The format is based on [Keep a Changelog], and this project adheres to
 [keep a changelog]: https://keepachangelog.com/en/1.0.0/
 [semantic versioning]: https://semver.org/spec/v2.0.0.html
 
+## [0.14.0] - 2024-03-26
+
+This release updates the `testkit` implementation to adhere to Dogma v0.13.0
+interfaces.
+
+### Removed
+
+- **[BC]** Removed `Test.EventRecorder()`.
+- **[BC]** Removed `EventRecorder`.
+- **[BC]** Removed `EventRecorderInterceptor` and `InterceptEventRecorder()`.
+- **[BC]** Removed `engine.EventRecorder`.
+- **[BC]** Removed `ActionScope.EventRecorder`.
+
 ## [0.13.12] - 2024-03-05
 
 ### Changed
@@ -30,7 +43,8 @@ interfaces.
 
 ### Added
 
-- Added `MessageDescription` method to internal test messages in preparation for it becoming mandatory
+- Added `MessageDescription` method to internal test messages in preparation for
+  it becoming mandatory.
 
 ## [0.13.9] - 2023-01-06
 
@@ -345,6 +359,7 @@ guide][0.11.0 migration guide] for detailed instructions.
 [0.13.10]: https://github.com/dogmatiq/testkit/releases/tag/v0.13.10
 [0.13.11]: https://github.com/dogmatiq/testkit/releases/tag/v0.13.11
 [0.13.12]: https://github.com/dogmatiq/testkit/releases/tag/v0.13.12
+[0.14.12]: https://github.com/dogmatiq/testkit/releases/tag/v0.14.0
 
 <!-- version template
 ## [0.0.1] - YYYY-MM-DD
diff --git a/action.advancetime.go b/action.advancetime.go
index af0f9fa8..425e61bc 100644
--- a/action.advancetime.go
+++ b/action.advancetime.go
@@ -83,7 +83,7 @@ func (a advanceTimeAction) Location() location.Location {
 	return a.loc
 }
 
-func (a advanceTimeAction) ConfigurePredicate(o *PredicateOptions) {
+func (a advanceTimeAction) ConfigurePredicate(*PredicateOptions) {
 }
 
 func (a advanceTimeAction) Do(ctx context.Context, s ActionScope) error {
diff --git a/action.call.go b/action.call.go
index 44ae48c4..4799d289 100644
--- a/action.call.go
+++ b/action.call.go
@@ -52,7 +52,6 @@ type callAction struct {
 	fn        func()
 	loc       location.Location
 	onExecute CommandExecutorInterceptor
-	onRecord  EventRecorderInterceptor
 }
 
 func (a callAction) Caption() string {
@@ -67,7 +66,7 @@ func (a callAction) ConfigurePredicate(o *PredicateOptions) {
 	o.MatchDispatchCycleStartedFacts = true
 }
 
-func (a callAction) Do(ctx context.Context, s ActionScope) error {
+func (a callAction) Do(_ context.Context, s ActionScope) error {
 	// Setup the command executor for use during this action.
 	s.Executor.Bind(s.Engine, s.OperationOptions)
 	defer s.Executor.Unbind()
@@ -77,15 +76,6 @@ func (a callAction) Do(ctx context.Context, s ActionScope) error {
 		defer s.Executor.Intercept(prev)
 	}
 
-	// Setup the event recorder for use during this action.
-	s.Recorder.Bind(s.Engine, s.OperationOptions)
-	defer s.Recorder.Unbind()
-
-	if a.onRecord != nil {
-		prev := s.Recorder.Intercept(a.onRecord)
-		defer s.Recorder.Intercept(prev)
-	}
-
 	// Execute the user-supplied function.
 	a.fn()
 
diff --git a/action.call_test.go b/action.call_test.go
index 3dadad9c..f8afa162 100644
--- a/action.call_test.go
+++ b/action.call_test.go
@@ -35,8 +35,10 @@ var _ = g.Describe("func Call()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "832d78d7-a006-414f-b6d7-3153aa7c9ab8")
-						c.ConsumesCommandType(MessageC{})
-						c.ProducesEventType(MessageE{})
+						c.Routes(
+							dogma.HandlesCommand[MessageC](),
+							dogma.RecordsEvent[MessageE](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(
 						dogma.Message,
@@ -47,8 +49,10 @@ var _ = g.Describe("func Call()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "b64cdd19-782e-4e4e-9e5f-a95a943d6340")
-						c.ConsumesEventType(MessageE{})
-						c.ProducesCommandType(MessageC{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),
+							dogma.ExecutesCommand[MessageC](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -109,41 +113,6 @@ var _ = g.Describe("func Call()", func() {
 		))
 	})
 
-	g.It("allows use of the test's recorder", func() {
-		r := test.EventRecorder()
-
-		test.Prepare(
-			Call(func() {
-				r.RecordEvent(
-					context.Background(),
-					MessageE1,
-				)
-			}),
-		)
-
-		Expect(buf.Facts()).To(ContainElement(
-			fact.DispatchCycleBegun{
-				Envelope: &envelope.Envelope{
-					MessageID:     "1",
-					CausationID:   "1",
-					CorrelationID: "1",
-					Message:       MessageE1,
-					Type:          MessageEType,
-					Role:          message.EventRole,
-					CreatedAt:     startTime,
-				},
-				EngineTime: startTime,
-				EnabledHandlerTypes: map[configkit.HandlerType]bool{
-					configkit.AggregateHandlerType:   true,
-					configkit.IntegrationHandlerType: false,
-					configkit.ProcessHandlerType:     true,
-					configkit.ProjectionHandlerType:  false,
-				},
-				EnabledHandlers: map[string]bool{},
-			},
-		))
-	})
-
 	g.It("allows expectations to match commands executed via the test's executor", func() {
 		e := test.CommandExecutor()
 
@@ -158,20 +127,6 @@ var _ = g.Describe("func Call()", func() {
 		)
 	})
 
-	g.It("allows expectations to match events recorded via the test's recorder", func() {
-		r := test.EventRecorder()
-
-		test.Expect(
-			Call(func() {
-				r.RecordEvent(
-					context.Background(),
-					MessageE1,
-				)
-			}),
-			ToRecordEvent(MessageE1),
-		)
-	})
-
 	g.It("produces the expected caption", func() {
 		test.Prepare(
 			Call(func() {}),
diff --git a/action.dispatch.command_test.go b/action.dispatch.command_test.go
index 0e76451b..77bfcf35 100644
--- a/action.dispatch.command_test.go
+++ b/action.dispatch.command_test.go
@@ -34,8 +34,10 @@ var _ = g.Describe("func ExecuteCommand()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "d1cf3af1-6c20-4125-8e68-192a6075d0b4")
-						c.ConsumesCommandType(MessageC{})
-						c.ProducesEventType(MessageE{})
+						c.Routes(
+							dogma.HandlesCommand[MessageC](),
+							dogma.RecordsEvent[MessageE](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(
 						dogma.Message,
diff --git a/action.dispatch.event_test.go b/action.dispatch.event_test.go
index a131ec68..6de0545d 100644
--- a/action.dispatch.event_test.go
+++ b/action.dispatch.event_test.go
@@ -35,8 +35,10 @@ var _ = g.Describe("func RecordEvent()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "1c0dd111-fe12-4dee-a8bc-64abea1dce8f")
-						c.ConsumesEventType(MessageE{})
-						c.ProducesCommandType(MessageC{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),
+							dogma.ExecutesCommand[MessageC](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
diff --git a/action.dispatch.go b/action.dispatch.go
index fb0451c3..cc3de70e 100644
--- a/action.dispatch.go
+++ b/action.dispatch.go
@@ -12,7 +12,7 @@ import (
 
 // ExecuteCommand returns an Action that executes a command message.
 func ExecuteCommand(m dogma.Message) Action {
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := validateMessage(m); err != nil {
 		panic(fmt.Sprintf("ExecuteCommand(%T): %s", m, err))
 	}
 
@@ -25,7 +25,7 @@ func ExecuteCommand(m dogma.Message) Action {
 
 // RecordEvent returns an Action that records an event message.
 func RecordEvent(m dogma.Message) Action {
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := validateMessage(m); err != nil {
 		panic(fmt.Sprintf("RecordEvent(%T): %s", m, err))
 	}
 
@@ -56,7 +56,7 @@ func (a dispatchAction) Location() location.Location {
 	return a.loc
 }
 
-func (a dispatchAction) ConfigurePredicate(o *PredicateOptions) {
+func (a dispatchAction) ConfigurePredicate(*PredicateOptions) {
 }
 
 func (a dispatchAction) Do(ctx context.Context, s ActionScope) error {
diff --git a/action.go b/action.go
index 38ccccda..9206788c 100644
--- a/action.go
+++ b/action.go
@@ -48,10 +48,6 @@ type ActionScope struct {
 	// method.
 	Executor *CommandExecutor
 
-	// Recorder is the event recorder returned by the Test's EventRecorder()
-	// method.
-	Recorder *EventRecorder
-
 	// OperationOptions is the set of options that should be used with calling
 	// Engine.Dispatch() or Engine.Tick().
 	OperationOptions []engine.OperationOption
diff --git a/compare_test.go b/compare_test.go
index d7b6d2ce..40be61b3 100644
--- a/compare_test.go
+++ b/compare_test.go
@@ -81,8 +81,10 @@ var _ = g.Describe("func WithMessageComparator()", func() {
 		handler := &IntegrationMessageHandler{
 			ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 				c.Identity("<handler-name>", "7cb41db6-0116-4d03-80d7-277cc391b47e")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 			HandleCommandFunc: func(
 				_ context.Context,
diff --git a/engine/engine.go b/engine/engine.go
index 16c04e3c..9fd5b666 100644
--- a/engine/engine.go
+++ b/engine/engine.go
@@ -190,7 +190,7 @@ func (e *Engine) Dispatch(
 	m dogma.Message,
 	options ...OperationOption,
 ) error {
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := m.Validate(); err != nil {
 		panic(fmt.Sprintf(
 			"cannot dispatch invalid %T message: %s",
 			m,
diff --git a/engine/engine_test.go b/engine/engine_test.go
index 7503f3e5..6b465cca 100644
--- a/engine/engine_test.go
+++ b/engine/engine_test.go
@@ -32,8 +32,10 @@ var _ = g.Describe("type Engine", func() {
 		aggregate = &AggregateMessageHandler{
 			ConfigureFunc: func(c dogma.AggregateConfigurer) {
 				c.Identity("<aggregate>", "c72c106b-771e-42f8-b3e6-05452d4002ed")
-				c.ConsumesCommandType(MessageA{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageA](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 			RouteCommandToInstanceFunc: func(dogma.Message) string {
 				return "<instance>"
@@ -43,9 +45,11 @@ var _ = g.Describe("type Engine", func() {
 		process = &ProcessMessageHandler{
 			ConfigureFunc: func(c dogma.ProcessConfigurer) {
 				c.Identity("<process>", "4721492d-7fa3-4cfa-9f0f-a3cb1f95933e")
-				c.ConsumesEventType(MessageB{})
-				c.ConsumesEventType(MessageE{}) // shared with <projection>
-				c.ProducesCommandType(MessageC{})
+				c.Routes(
+					dogma.HandlesEvent[MessageB](),
+					dogma.HandlesEvent[MessageE](), // shared with <projection>
+					dogma.ExecutesCommand[MessageC](),
+				)
 			},
 			RouteEventToInstanceFunc: func(context.Context, dogma.Message) (string, bool, error) {
 				return "<instance>", true, nil
@@ -55,16 +59,20 @@ var _ = g.Describe("type Engine", func() {
 		integration = &IntegrationMessageHandler{
 			ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 				c.Identity("<integration>", "8b840c55-0b04-4107-bd4c-c69052c9fca3")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageF{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageF](),
+				)
 			},
 		}
 
 		projection = &ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<projection>", "f2b324d6-74f1-409e-8b28-8e44454037a9")
-				c.ConsumesEventType(MessageD{})
-				c.ConsumesEventType(MessageE{}) // shared with <process>
+				c.Routes(
+					dogma.HandlesEvent[MessageD](),
+					dogma.HandlesEvent[MessageE](), // shared with <process>
+				)
 			},
 		}
 
diff --git a/engine/executor.go b/engine/executor.go
index 6fd882c2..481b398a 100644
--- a/engine/executor.go
+++ b/engine/executor.go
@@ -20,6 +20,6 @@ type CommandExecutor struct {
 // ExecuteCommand enqueues a command for execution.
 //
 // It panics if the command is not routed to any handlers.
-func (e CommandExecutor) ExecuteCommand(ctx context.Context, m dogma.Message) error {
+func (e CommandExecutor) ExecuteCommand(ctx context.Context, m dogma.Message, _ ...dogma.ExecuteCommandOption) error {
 	return e.Engine.mustDispatch(ctx, message.CommandRole, m, e.Options...)
 }
diff --git a/engine/executor_test.go b/engine/executor_test.go
index 1bf7dc36..4b2160d7 100644
--- a/engine/executor_test.go
+++ b/engine/executor_test.go
@@ -23,8 +23,10 @@ var _ = g.Describe("type CommandExecutor", func() {
 		aggregate = &AggregateMessageHandler{
 			ConfigureFunc: func(c dogma.AggregateConfigurer) {
 				c.Identity("<aggregate>", "4acf3050-8d02-4052-a9af-abb9e67add78")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 			RouteCommandToInstanceFunc: func(dogma.Message) string {
 				return "<instance>"
diff --git a/engine/internal/aggregate/controller.go b/engine/internal/aggregate/controller.go
index 0ba4933d..37d86a5a 100644
--- a/engine/internal/aggregate/controller.go
+++ b/engine/internal/aggregate/controller.go
@@ -39,7 +39,7 @@ func (c *Controller) Tick(
 
 // Handle handles a message.
 func (c *Controller) Handle(
-	ctx context.Context,
+	_ context.Context,
 	obs fact.Observer,
 	now time.Time,
 	env *envelope.Envelope,
diff --git a/engine/internal/aggregate/controller_test.go b/engine/internal/aggregate/controller_test.go
index 2dfb01d5..3725e76f 100644
--- a/engine/internal/aggregate/controller_test.go
+++ b/engine/internal/aggregate/controller_test.go
@@ -35,8 +35,10 @@ var _ = g.Describe("type Controller", func() {
 		handler = &AggregateMessageHandler{
 			ConfigureFunc: func(c dogma.AggregateConfigurer) {
 				c.Identity("<name>", "e8fd6bd4-c3a3-4eb4-bf0f-56862a123229")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 			// setup routes for "C" (command) messages to an instance ID based on the
 			// message's content
diff --git a/engine/internal/aggregate/scope.go b/engine/internal/aggregate/scope.go
index 520e75ba..d82cf219 100644
--- a/engine/internal/aggregate/scope.go
+++ b/engine/internal/aggregate/scope.go
@@ -60,7 +60,7 @@ func (s *scope) RecordEvent(m dogma.Message) {
 		})
 	}
 
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := m.Validate(); err != nil {
 		panic(panicx.UnexpectedBehavior{
 			Handler:        s.config,
 			Interface:      "AggregateMessageHandler",
diff --git a/engine/internal/aggregate/scope_test.go b/engine/internal/aggregate/scope_test.go
index 7a041495..4f67920e 100644
--- a/engine/internal/aggregate/scope_test.go
+++ b/engine/internal/aggregate/scope_test.go
@@ -35,8 +35,10 @@ var _ = g.Describe("type scope", func() {
 		handler = &AggregateMessageHandler{
 			ConfigureFunc: func(c dogma.AggregateConfigurer) {
 				c.Identity("<name>", "fd88e430-32fe-49a6-888f-f678dcf924ef")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 			RouteCommandToInstanceFunc: func(m dogma.Message) string {
 				switch m.(type) {
diff --git a/engine/internal/integration/controller_test.go b/engine/internal/integration/controller_test.go
index 14dae3ae..76346159 100644
--- a/engine/internal/integration/controller_test.go
+++ b/engine/internal/integration/controller_test.go
@@ -35,8 +35,10 @@ var _ = g.Describe("type Controller", func() {
 		handler = &IntegrationMessageHandler{
 			ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 				c.Identity("<name>", "8cbb8bca-b5eb-4c94-a877-dfc8dc9968ca")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 		}
 
diff --git a/engine/internal/integration/scope.go b/engine/internal/integration/scope.go
index 3591ba15..1d8d6d81 100644
--- a/engine/internal/integration/scope.go
+++ b/engine/internal/integration/scope.go
@@ -35,7 +35,7 @@ func (s *scope) RecordEvent(m dogma.Message) {
 		})
 	}
 
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := m.Validate(); err != nil {
 		panic(panicx.UnexpectedBehavior{
 			Handler:        s.config,
 			Interface:      "IntegrationMessageHandler",
diff --git a/engine/internal/integration/scope_test.go b/engine/internal/integration/scope_test.go
index df385fba..af228a71 100644
--- a/engine/internal/integration/scope_test.go
+++ b/engine/internal/integration/scope_test.go
@@ -35,8 +35,10 @@ var _ = g.Describe("type scope", func() {
 		handler = &IntegrationMessageHandler{
 			ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 				c.Identity("<name>", "24ec3839-5d51-4904-9b45-34b5282e7f24")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 		}
 
diff --git a/engine/internal/panicx/unexpectedbehavior_test.go b/engine/internal/panicx/unexpectedbehavior_test.go
index 75dd01d8..f76a04a6 100644
--- a/engine/internal/panicx/unexpectedbehavior_test.go
+++ b/engine/internal/panicx/unexpectedbehavior_test.go
@@ -14,7 +14,9 @@ var _ = g.Describe("type UnexpectedBehavior", func() {
 		&ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<name>", "fce4f9f3-e8ee-45ce-924f-be8c3c0a9285")
-				c.ConsumesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+				)
 			},
 		},
 	)
diff --git a/engine/internal/panicx/unexpectedmessage_test.go b/engine/internal/panicx/unexpectedmessage_test.go
index ccb923c7..c4543518 100644
--- a/engine/internal/panicx/unexpectedmessage_test.go
+++ b/engine/internal/panicx/unexpectedmessage_test.go
@@ -15,7 +15,9 @@ var _ = g.Describe("type UnexpectedMessage", func() {
 		&ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<name>", "a0eab8dd-db22-467a-87c2-c38138c582e8")
-				c.ConsumesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+				)
 			},
 		},
 	)
@@ -51,7 +53,9 @@ var _ = g.Describe("func EnrichUnexpectedMessage()", func() {
 		&ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<name>", "b665eca3-936e-41e3-b9ab-c618cfa95ec2")
-				c.ConsumesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+				)
 			},
 		},
 	)
diff --git a/engine/internal/process/controller.go b/engine/internal/process/controller.go
index 9c49889b..41bc74dc 100644
--- a/engine/internal/process/controller.go
+++ b/engine/internal/process/controller.go
@@ -33,8 +33,8 @@ func (c *Controller) HandlerConfig() configkit.RichHandler {
 
 // Tick returns the timeout messages that are ready to be handled.
 func (c *Controller) Tick(
-	ctx context.Context,
-	obs fact.Observer,
+	_ context.Context,
+	_ fact.Observer,
 	now time.Time,
 ) ([]*envelope.Envelope, error) {
 	var i int
@@ -230,7 +230,7 @@ func (c *Controller) routeEvent(
 }
 
 func (c *Controller) routeTimeout(
-	ctx context.Context,
+	_ context.Context,
 	obs fact.Observer,
 	env *envelope.Envelope,
 ) (string, bool, error) {
diff --git a/engine/internal/process/controller_test.go b/engine/internal/process/controller_test.go
index e1be3e94..e3e49bb6 100644
--- a/engine/internal/process/controller_test.go
+++ b/engine/internal/process/controller_test.go
@@ -49,9 +49,11 @@ var _ = g.Describe("type Controller", func() {
 		handler = &ProcessMessageHandler{
 			ConfigureFunc: func(c dogma.ProcessConfigurer) {
 				c.Identity("<name>", "7db72921-b805-4db5-8287-0af94a768643")
-				c.ConsumesEventType(MessageE{})
-				c.ProducesCommandType(MessageC{})
-				c.SchedulesTimeoutType(MessageT{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+					dogma.ExecutesCommand[MessageC](),
+					dogma.SchedulesTimeout[MessageT](),
+				)
 			},
 			// setup routes for "E" (event) messages to an instance ID based on the
 			// message's content
diff --git a/engine/internal/process/scope.go b/engine/internal/process/scope.go
index e30e2bf4..a4791c13 100644
--- a/engine/internal/process/scope.go
+++ b/engine/internal/process/scope.go
@@ -62,7 +62,7 @@ func (s *scope) ExecuteCommand(m dogma.Message) {
 		})
 	}
 
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := m.Validate(); err != nil {
 		panic(panicx.UnexpectedBehavior{
 			Handler:        s.config,
 			Interface:      "ProcessMessageHandler",
@@ -124,7 +124,7 @@ func (s *scope) ScheduleTimeout(m dogma.Message, t time.Time) {
 		})
 	}
 
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := m.Validate(); err != nil {
 		panic(panicx.UnexpectedBehavior{
 			Handler:        s.config,
 			Interface:      "ProcessMessageHandler",
diff --git a/engine/internal/process/scope_test.go b/engine/internal/process/scope_test.go
index 179d289d..0d1dcc51 100644
--- a/engine/internal/process/scope_test.go
+++ b/engine/internal/process/scope_test.go
@@ -35,9 +35,11 @@ var _ = g.Describe("type scope", func() {
 		handler = &ProcessMessageHandler{
 			ConfigureFunc: func(c dogma.ProcessConfigurer) {
 				c.Identity("<name>", "6901c34c-6e4d-4184-9414-780cb21a791a")
-				c.ConsumesEventType(MessageE{})
-				c.ProducesCommandType(MessageC{})
-				c.SchedulesTimeoutType(MessageT{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+					dogma.ExecutesCommand[MessageC](),
+					dogma.SchedulesTimeout[MessageT](),
+				)
 			},
 			RouteEventToInstanceFunc: func(
 				_ context.Context,
diff --git a/engine/internal/projection/controller_test.go b/engine/internal/projection/controller_test.go
index c51f3c12..bbe06301 100644
--- a/engine/internal/projection/controller_test.go
+++ b/engine/internal/projection/controller_test.go
@@ -32,7 +32,9 @@ var _ = g.Describe("type Controller", func() {
 		handler = &ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<name>", "fcbe8fe1-1085-497d-ba8e-09bedb031db2")
-				c.ConsumesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+				)
 			},
 		}
 
diff --git a/engine/internal/projection/scope_test.go b/engine/internal/projection/scope_test.go
index 671e7220..fbebe68d 100644
--- a/engine/internal/projection/scope_test.go
+++ b/engine/internal/projection/scope_test.go
@@ -30,7 +30,9 @@ var _ = g.Describe("type scope", func() {
 		handler = &ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<name>", "deaaf068-bfd3-4ed2-a69d-850cb9bfab8d")
-				c.ConsumesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+				)
 			},
 		}
 
diff --git a/engine/recorder.go b/engine/recorder.go
deleted file mode 100644
index 429a41c5..00000000
--- a/engine/recorder.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package engine
-
-import (
-	"context"
-
-	"github.com/dogmatiq/configkit/message"
-	"github.com/dogmatiq/dogma"
-)
-
-// EventRecorder adapts an Engine to the dogma.EventRecorder interface.
-type EventRecorder struct {
-	// Engine is the engine that handles the recorded events.
-	Engine *Engine
-
-	// Options is a set of options used when dispatching the message to the
-	// engine.
-	Options []OperationOption
-}
-
-// RecordEvent records the occurrence of an event.
-//
-// It is not an error to record an event that is not routed to any handlers.
-func (r EventRecorder) RecordEvent(ctx context.Context, m dogma.Message) error {
-	return r.Engine.mustDispatch(ctx, message.EventRole, m, r.Options...)
-}
diff --git a/engine/recorder_test.go b/engine/recorder_test.go
deleted file mode 100644
index 5c653ce4..00000000
--- a/engine/recorder_test.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package engine_test
-
-import (
-	"context"
-
-	"github.com/dogmatiq/configkit"
-	"github.com/dogmatiq/dogma"
-	. "github.com/dogmatiq/dogma/fixtures"
-	. "github.com/dogmatiq/testkit/engine"
-	g "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = g.Describe("type EventRecorder", func() {
-	var (
-		process  *ProcessMessageHandler
-		app      *Application
-		engine   *Engine
-		recorder *EventRecorder
-	)
-
-	g.BeforeEach(func() {
-		process = &ProcessMessageHandler{
-			ConfigureFunc: func(c dogma.ProcessConfigurer) {
-				c.Identity("<process>", "173b93f6-8359-4605-8c0a-f1076e14993e")
-				c.ConsumesEventType(MessageE{})
-				c.ProducesCommandType(MessageC{})
-			},
-		}
-
-		app = &Application{
-			ConfigureFunc: func(c dogma.ApplicationConfigurer) {
-				c.Identity("<app>", "6b4206e5-8d36-440b-828f-9fb4623432e2")
-				c.RegisterProcess(process)
-			},
-		}
-
-		engine = MustNew(
-			configkit.FromApplication(app),
-		)
-
-		recorder = &EventRecorder{
-			Engine: engine,
-		}
-	})
-
-	g.Describe("func RecordEvent()", func() {
-		g.It("dispatches to the engine", func() {
-			called := false
-			process.RouteEventToInstanceFunc = func(
-				context.Context,
-				dogma.Message,
-			) (string, bool, error) {
-				return "<instance>", true, nil
-			}
-
-			process.HandleEventFunc = func(
-				_ context.Context,
-				_ dogma.ProcessRoot,
-				_ dogma.ProcessEventScope,
-				m dogma.Message,
-			) error {
-				called = true
-				Expect(m).To(Equal(MessageE1))
-				return nil
-			}
-
-			err := recorder.RecordEvent(context.Background(), MessageE1)
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(called).To(BeTrue())
-		})
-
-		g.It("panics if the message is not an event", func() {
-			Expect(func() {
-				recorder.RecordEvent(context.Background(), MessageC1)
-			}).To(PanicWith("cannot record event, fixtures.MessageC is configured as a command"))
-		})
-
-		g.It("panics if the message is unrecognized", func() {
-			Expect(func() {
-				recorder.RecordEvent(context.Background(), MessageX1)
-			}).To(PanicWith("cannot record event, fixtures.MessageX is a not a recognized message type"))
-		})
-	})
-})
diff --git a/envelope/envelope.go b/envelope/envelope.go
index b0e15e52..ad65aaf6 100644
--- a/envelope/envelope.go
+++ b/envelope/envelope.go
@@ -50,7 +50,7 @@ func NewCommand(
 	m dogma.Message,
 	t time.Time,
 ) *Envelope {
-	return new(id, m, message.CommandRole, t)
+	return newEnvelope(id, m, message.CommandRole, t)
 }
 
 // NewEvent constructs a new envelope containing the given event message.
@@ -61,14 +61,14 @@ func NewEvent(
 	m dogma.Message,
 	t time.Time,
 ) *Envelope {
-	return new(id, m, message.EventRole, t)
+	return newEnvelope(id, m, message.EventRole, t)
 }
 
-// new constructs a new envelope containing the given message.
+// newEnvelope constructs a newEnvelope envelope containing the given message.
 //
 // It panics if r is message.TimeoutRole, as a timeout cannot occur except as a
 // result of some other message.
-func new(
+func newEnvelope(
 	id string,
 	m dogma.Message,
 	r message.Role,
diff --git a/envelope/envelope_test.go b/envelope/envelope_test.go
index 5699689b..aaa96434 100644
--- a/envelope/envelope_test.go
+++ b/envelope/envelope_test.go
@@ -64,8 +64,10 @@ var _ = g.Describe("type Envelope", func() {
 		handler := configkit.FromProcess(&ProcessMessageHandler{
 			ConfigureFunc: func(c dogma.ProcessConfigurer) {
 				c.Identity("<handler>", "d1c7e18a-4d72-4705-a120-6cfb29eef655")
-				c.ConsumesEventType(MessageE{})
-				c.ProducesCommandType(MessageC{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+					dogma.ExecutesCommand[MessageC](),
+				)
 			},
 		})
 
@@ -107,8 +109,10 @@ var _ = g.Describe("type Envelope", func() {
 		handler := configkit.FromAggregate(&AggregateMessageHandler{
 			ConfigureFunc: func(c dogma.AggregateConfigurer) {
 				c.Identity("<handler>", "8688dc39-b5d0-4468-89fd-0d9452667c0c")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 		})
 
@@ -150,9 +154,11 @@ var _ = g.Describe("type Envelope", func() {
 		handler := configkit.FromProcess(&ProcessMessageHandler{
 			ConfigureFunc: func(c dogma.ProcessConfigurer) {
 				c.Identity("<handler>", "1d4e3d22-52fe-4b1b-9bf5-44b2050c08c2")
-				c.ConsumesEventType(MessageE{})
-				c.ProducesCommandType(MessageC{})
-				c.SchedulesTimeoutType(MessageT{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+					dogma.ExecutesCommand[MessageC](),
+					dogma.SchedulesTimeout[MessageT](),
+				)
 			},
 		})
 
diff --git a/executor.go b/executor.go
index c8ca57b5..6186b2bf 100644
--- a/executor.go
+++ b/executor.go
@@ -8,7 +8,7 @@ import (
 	"github.com/dogmatiq/testkit/engine"
 )
 
-// CommandExecutor is an implementation of dogma.CommandExecutor that executes
+// CommandExecutor is an implementation of [dogma.CommandExecutor] that executes
 // commands within the context of a Test.
 //
 // Each instance is bound to a particular Test. Use Test.CommandExecutor() to
@@ -19,11 +19,17 @@ type CommandExecutor struct {
 	interceptor CommandExecutorInterceptor
 }
 
+var _ dogma.CommandExecutor = (*CommandExecutor)(nil)
+
 // ExecuteCommand executes the command message m.
 //
 // It panics unless it is called during an Action, such as when calling
 // Test.Prepare() or Test.Expect().
-func (e *CommandExecutor) ExecuteCommand(ctx context.Context, m dogma.Message) error {
+func (e *CommandExecutor) ExecuteCommand(
+	ctx context.Context,
+	m dogma.Message,
+	_ ...dogma.ExecuteCommandOption,
+) error {
 	e.m.RLock()
 	defer e.m.RUnlock()
 
diff --git a/executor_test.go b/executor_test.go
index 81124118..44e6447b 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -30,8 +30,10 @@ var _ = g.Describe("func InterceptCommandExecutor()", func() {
 				c.RegisterIntegration(&IntegrationMessageHandler{
 					ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 						c.Identity("<handler-name>", "67c167a8-d09e-4827-beab-7c8c9817bb1a")
-						c.ConsumesCommandType(MessageC{})
-						c.ProducesEventType(MessageE{})
+						c.Routes(
+							dogma.HandlesCommand[MessageC](),
+							dogma.RecordsEvent[MessageE](),
+						)
 					},
 					HandleCommandFunc: func(
 						_ context.Context,
diff --git a/expectation.go b/expectation.go
index 66dbafe7..b247f501 100644
--- a/expectation.go
+++ b/expectation.go
@@ -1,7 +1,10 @@
 package testkit
 
 import (
+	"errors"
+
 	"github.com/dogmatiq/configkit"
+	"github.com/dogmatiq/dogma"
 	"github.com/dogmatiq/testkit/fact"
 )
 
@@ -72,3 +75,10 @@ type PredicateOptions struct {
 	// by handlers.
 	MatchDispatchCycleStartedFacts bool
 }
+
+func validateMessage(m dogma.Message) error {
+	if m == nil {
+		return errors.New("message must not be nil")
+	}
+	return m.Validate()
+}
diff --git a/expectation.message.command_test.go b/expectation.message.command_test.go
index 47082e9e..cb9ff5f6 100644
--- a/expectation.message.command_test.go
+++ b/expectation.message.command_test.go
@@ -30,8 +30,10 @@ var _ = g.Describe("func ToExecuteCommand()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "49fa7c5f-7682-4743-bf8a-ed96dee2d81a")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ProducesEventType(MessageN{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](),
+							dogma.RecordsEvent[MessageN](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -48,11 +50,14 @@ var _ = g.Describe("func ToExecuteCommand()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "8b4c4701-be92-4b28-83b6-0d69b97fb451")
-						c.ConsumesEventType(MessageE{})    // E = event
-						c.ConsumesEventType(MessageN{})    // N = (do) nothing
-						c.ProducesCommandType(MessageC{})  // C = command
-						c.ProducesCommandType(&MessageC{}) // pointer, used to test type similarity
-						c.ProducesCommandType(MessageX{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),     // E = event
+							dogma.HandlesEvent[MessageN](),     // N = (do) nothing
+							dogma.ExecutesCommand[MessageC](),  // C = command
+							dogma.ExecutesCommand[*MessageC](), // pointer, used to test type similarity
+							dogma.ExecutesCommand[MessageX](),
+						)
+
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
diff --git a/expectation.message.commandcall_test.go b/expectation.message.commandcall_test.go
index 06963ca4..e89f5bc8 100644
--- a/expectation.message.commandcall_test.go
+++ b/expectation.message.commandcall_test.go
@@ -31,10 +31,12 @@ var _ = g.Describe("func ToExecuteCommand() (when used with the Call() action)",
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "c94fc20f-f6fc-46c6-ad6f-45bb854aeb6c")
-						c.ConsumesCommandType(MessageR{})  // R = record an event
-						c.ConsumesCommandType(&MessageR{}) // pointer, used to test type similarity
-						c.ConsumesCommandType(MessageX{})
-						c.ProducesEventType(MessageN{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](),  // R = record an event
+							dogma.HandlesCommand[*MessageR](), // pointer, used to test type similarity
+							dogma.HandlesCommand[MessageX](),
+							dogma.RecordsEvent[MessageN](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -51,9 +53,11 @@ var _ = g.Describe("func ToExecuteCommand() (when used with the Call() action)",
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "e914b7b8-745b-4635-88a7-2d06628098a4")
-						c.ConsumesEventType(MessageE{})   // E = event
-						c.ConsumesEventType(MessageN{})   // N = (do) nothing
-						c.ProducesCommandType(MessageC{}) // C = command
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),    // E = event
+							dogma.HandlesEvent[MessageN](),    // N = (do) nothing
+							dogma.ExecutesCommand[MessageC](), // C = command
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -84,13 +88,6 @@ var _ = g.Describe("func ToExecuteCommand() (when used with the Call() action)",
 		})
 	}
 
-	recordEventViaRecorder := func(m dogma.Message) Action {
-		return Call(func() {
-			err := test.EventRecorder().RecordEvent(context.Background(), m)
-			Expect(err).ShouldNot(HaveOccurred())
-		})
-	}
-
 	g.DescribeTable(
 		"expectation behavior",
 		func(
@@ -114,22 +111,6 @@ var _ = g.Describe("func ToExecuteCommand() (when used with the Call() action)",
 				`✓ execute a specific 'fixtures.MessageR' command`,
 			),
 		),
-		g.Entry(
-			"no matching command executed",
-			recordEventViaRecorder(MessageE1),
-			ToExecuteCommand(MessageX1),
-			expectFail,
-			expectReport(
-				`✗ execute a specific 'fixtures.MessageX' command`,
-				``,
-				`  | EXPLANATION`,
-				`  |     nothing executed a matching command`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • verify the logic within the '<process>' process message handler`,
-				`  |     • verify the logic within the code that uses the dogma.CommandExecutor`,
-			),
-		),
 		g.Entry(
 			"no messages produced at all",
 			Call(func() {}),
@@ -145,22 +126,6 @@ var _ = g.Describe("func ToExecuteCommand() (when used with the Call() action)",
 				`  |     • verify the logic within the code that uses the dogma.CommandExecutor`,
 			),
 		),
-		g.Entry(
-			"no commands produced at all",
-			recordEventViaRecorder(MessageN1),
-			ToExecuteCommand(MessageC{}),
-			expectFail,
-			expectReport(
-				`✗ execute a specific 'fixtures.MessageC' command`,
-				``,
-				`  | EXPLANATION`,
-				`  |     no commands were executed at all`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • verify the logic within the '<process>' process message handler`,
-				`  |     • verify the logic within the code that uses the dogma.CommandExecutor`,
-			),
-		),
 		g.Entry(
 			"no matching command executed and all relevant handler types disabled",
 			executeCommandViaExecutor(MessageR1),
diff --git a/expectation.message.event_test.go b/expectation.message.event_test.go
index 41faf1da..59d23901 100644
--- a/expectation.message.event_test.go
+++ b/expectation.message.event_test.go
@@ -30,11 +30,13 @@ var _ = g.Describe("func ToExecuteCommandOfType()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "8746651e-df4d-421c-9eea-177585e5b8eb")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ConsumesCommandType(MessageN{}) // N = do nothing
-						c.ProducesEventType(MessageE{})
-						c.ProducesEventType(&MessageE{}) // pointer, used to test type similarity
-						c.ProducesEventType(MessageX{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.HandlesCommand[MessageN](), // N = do nothing
+							dogma.RecordsEvent[MessageE](),
+							dogma.RecordsEvent[*MessageE](), // pointer, used to test type similarity
+							dogma.RecordsEvent[MessageX](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -53,9 +55,11 @@ var _ = g.Describe("func ToExecuteCommandOfType()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "209c7f0f-49ad-4419-88a6-4e9ee1cf204a")
-						c.ConsumesEventType(MessageE{}) // E = execute a command
-						c.ConsumesEventType(MessageO{}) // O = only consumed, never produced
-						c.ProducesCommandType(MessageN{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](), // E = execute a command
+							dogma.HandlesEvent[MessageO](), // O = only consumed, never produced
+							dogma.ExecutesCommand[MessageN](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
diff --git a/expectation.message.eventcall_test.go b/expectation.message.eventcall_test.go
index e028c3cc..0d7f5585 100644
--- a/expectation.message.eventcall_test.go
+++ b/expectation.message.eventcall_test.go
@@ -6,7 +6,6 @@ import (
 	"github.com/dogmatiq/dogma"
 	. "github.com/dogmatiq/dogma/fixtures"
 	. "github.com/dogmatiq/testkit"
-	"github.com/dogmatiq/testkit/engine"
 	"github.com/dogmatiq/testkit/internal/testingmock"
 	g "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -31,11 +30,13 @@ var _ = g.Describe("func ToRecordEvent() (when used with the Call() action)", fu
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "eb9a40bd-6edf-4922-88dd-dfbdad42c88a")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ConsumesCommandType(MessageN{}) // N = do nothing
-						c.ProducesEventType(MessageE{})
-						c.ProducesEventType(&MessageE{}) // pointer, used to test type similarity
-						c.ProducesEventType(MessageX{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.HandlesCommand[MessageN](), // N = do nothing
+							dogma.RecordsEvent[MessageE](),
+							dogma.RecordsEvent[*MessageE](), // pointer, used to test type similarity
+							dogma.RecordsEvent[MessageX](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -54,9 +55,11 @@ var _ = g.Describe("func ToRecordEvent() (when used with the Call() action)", fu
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "c8e3b9de-c8e5-4e91-8658-58c9e989b048")
-						c.ConsumesEventType(MessageE{}) // E = execute a command
-						c.ConsumesEventType(MessageA{}) // A = also execute a command
-						c.ProducesCommandType(MessageN{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](), // E = execute a command
+							dogma.HandlesEvent[MessageA](), // A = also execute a command
+							dogma.ExecutesCommand[MessageN](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -87,13 +90,6 @@ var _ = g.Describe("func ToRecordEvent() (when used with the Call() action)", fu
 		})
 	}
 
-	recordEventViaRecorder := func(m dogma.Message) Action {
-		return Call(func() {
-			err := test.EventRecorder().RecordEvent(context.Background(), m)
-			Expect(err).ShouldNot(HaveOccurred())
-		})
-	}
-
 	g.DescribeTable(
 		"expectation behavior",
 		func(
@@ -108,15 +104,6 @@ var _ = g.Describe("func ToRecordEvent() (when used with the Call() action)", fu
 			rm(testingT)
 			Expect(testingT.Failed()).To(Equal(!ok))
 		},
-		g.Entry(
-			"event recorded as expected",
-			recordEventViaRecorder(MessageE1),
-			ToRecordEvent(MessageE1),
-			expectPass,
-			expectReport(
-				`✓ record a specific 'fixtures.MessageE' event`,
-			),
-		),
 		g.Entry(
 			"no matching event recorded",
 			executeCommandViaExecutor(MessageR1),
@@ -166,65 +153,5 @@ var _ = g.Describe("func ToRecordEvent() (when used with the Call() action)", fu
 				`  |     • verify the logic within the code that uses the dogma.EventRecorder`,
 			),
 		),
-		g.Entry(
-			"no matching event recorded and all relevant handler types disabled",
-			recordEventViaRecorder(MessageA1),
-			ToRecordEvent(MessageE1),
-			expectFail,
-			expectReport(
-				`✗ record a specific 'fixtures.MessageE' event`,
-				``,
-				`  | EXPLANATION`,
-				`  |     nothing recorded a matching event`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • enable aggregate handlers using the EnableHandlerType() option`,
-				`  |     • enable integration handlers using the EnableHandlerType() option`,
-				`  |     • verify the logic within the code that uses the dogma.EventRecorder`,
-			),
-			WithUnsafeOperationOptions(
-				engine.EnableAggregates(false),
-			),
-		),
-		g.Entry(
-			"similar event recorded with a different type",
-			recordEventViaRecorder(MessageE1),
-			ToRecordEvent(&MessageE1), // note: message type is pointer
-			expectFail,
-			expectReport(
-				`✗ record a specific '*fixtures.MessageE' event`,
-				``,
-				`  | EXPLANATION`,
-				`  |     an event of a similar type was recorded via a dogma.EventRecorder`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • check the message type, should it be a pointer?`,
-				`  | `,
-				`  | MESSAGE DIFF`,
-				`  |     [-*-]fixtures.MessageE{`,
-				`  |         Value: "E1"`,
-				`  |     }`,
-			),
-		),
-		g.Entry(
-			"similar event recorded with a different value",
-			recordEventViaRecorder(MessageE1),
-			ToRecordEvent(MessageE2),
-			expectFail,
-			expectReport(
-				`✗ record a specific 'fixtures.MessageE' event`,
-				``,
-				`  | EXPLANATION`,
-				`  |     a similar event was recorded via a dogma.EventRecorder`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • check the content of the message`,
-				`  | `,
-				`  | MESSAGE DIFF`,
-				`  |     fixtures.MessageE{`,
-				`  |         Value: "E[-2-]{+1+}"`,
-				`  |     }`,
-			),
-		),
 	)
 })
diff --git a/expectation.message.go b/expectation.message.go
index 512d5344..bcc827cd 100644
--- a/expectation.message.go
+++ b/expectation.message.go
@@ -16,7 +16,7 @@ import (
 // ToExecuteCommand returns an expectation that passes if a command is executed
 // that is equal to m.
 func ToExecuteCommand(m dogma.Message) Expectation {
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := validateMessage(m); err != nil {
 		panic(fmt.Sprintf("ToExecuteCommand(%T): %s", m, err))
 	}
 
@@ -30,7 +30,7 @@ func ToExecuteCommand(m dogma.Message) Expectation {
 // ToRecordEvent returns an expectation that passes if an event is recorded that
 // is equal to m.
 func ToRecordEvent(m dogma.Message) Expectation {
-	if err := dogma.ValidateMessage(m); err != nil {
+	if err := validateMessage(m); err != nil {
 		panic(fmt.Sprintf("ToRecordEvent(%T): %s", m, err))
 	}
 
diff --git a/expectation.messagematch.command_test.go b/expectation.messagematch.command_test.go
index 796d3e2d..10102b0c 100644
--- a/expectation.messagematch.command_test.go
+++ b/expectation.messagematch.command_test.go
@@ -31,8 +31,10 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "0c7df570-4c3b-4d88-b6aa-68f8716bd93b")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ProducesEventType(MessageN{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.RecordsEvent[MessageN](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -49,10 +51,12 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "d28572f4-ecce-48eb-92c5-d3968ab8636c")
-						c.ConsumesEventType(MessageE{})   // E = event
-						c.ConsumesEventType(MessageN{})   // N = (do) nothing
-						c.ProducesCommandType(MessageC{}) // C = command
-						c.ProducesCommandType(MessageX{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),    // E = event
+							dogma.HandlesEvent[MessageN](),    // N = [do)]()thing
+							dogma.ExecutesCommand[MessageC](), // C = command
+							dogma.ExecutesCommand[MessageX](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -108,7 +112,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectPass,
 			expectReport(
-				`✓ execute a command that matches the predicate near expectation.messagematch.command_test.go:101`,
+				`✓ execute a command that matches the predicate near expectation.messagematch.command_test.go:105`,
 			),
 		),
 		g.Entry(
@@ -125,7 +129,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:118`,
+				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:122`,
 				``,
 				`  | EXPLANATION`,
 				`  |     none of the engaged handlers executed a matching command`,
@@ -148,7 +152,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:145`,
+				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:149`,
 				``,
 				`  | EXPLANATION`,
 				`  |     no messages were produced at all`,
@@ -167,7 +171,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:164`,
+				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:168`,
 				``,
 				`  | EXPLANATION`,
 				`  |     no commands were executed at all`,
@@ -190,7 +194,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:183`,
+				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:187`,
 				``,
 				`  | EXPLANATION`,
 				`  |     no relevant handler types were enabled`,
@@ -212,7 +216,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:209`,
+				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:213`,
 				``,
 				`  | EXPLANATION`,
 				`  |     none of the engaged handlers executed a matching command`,
@@ -234,7 +238,7 @@ var _ = g.Describe("func ToExecuteCommandMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:231`,
+				`✗ execute a command that matches the predicate near expectation.messagematch.command_test.go:235`,
 				``,
 				`  | EXPLANATION`,
 				`  |     none of the engaged handlers executed a matching command`,
diff --git a/expectation.messagematch.commandonly_test.go b/expectation.messagematch.commandonly_test.go
index b1c46676..ddcd2ace 100644
--- a/expectation.messagematch.commandonly_test.go
+++ b/expectation.messagematch.commandonly_test.go
@@ -31,8 +31,10 @@ var _ = g.Describe("func ToOnlyExecuteCommandsMatching()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "39869c73-5ff0-4ae6-8317-eb494c87167b")
-						c.ConsumesEventType(MessageE{})   // E = event
-						c.ProducesCommandType(MessageC{}) // C = command
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),    // E = event
+							dogma.ExecutesCommand[MessageC](), // C = command
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -80,7 +82,7 @@ var _ = g.Describe("func ToOnlyExecuteCommandsMatching()", func() {
 			),
 			expectPass,
 			expectReport(
-				`✓ only execute commands that match the predicate near expectation.messagematch.commandonly_test.go:78`,
+				`✓ only execute commands that match the predicate near expectation.messagematch.commandonly_test.go:80`,
 			),
 		),
 		g.Entry(
@@ -93,7 +95,7 @@ var _ = g.Describe("func ToOnlyExecuteCommandsMatching()", func() {
 			),
 			expectPass,
 			expectReport(
-				`✓ only execute commands that match the predicate near expectation.messagematch.commandonly_test.go:90`,
+				`✓ only execute commands that match the predicate near expectation.messagematch.commandonly_test.go:92`,
 			),
 		),
 		g.Entry(
@@ -113,7 +115,7 @@ var _ = g.Describe("func ToOnlyExecuteCommandsMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ only execute commands that match the predicate near expectation.messagematch.commandonly_test.go:103`,
+				`✗ only execute commands that match the predicate near expectation.messagematch.commandonly_test.go:105`,
 				``,
 				`  | EXPLANATION`,
 				`  |     only 1 of 2 relevant commands matched the predicate`,
diff --git a/expectation.messagematch.event_test.go b/expectation.messagematch.event_test.go
index 22a646fb..51fc476d 100644
--- a/expectation.messagematch.event_test.go
+++ b/expectation.messagematch.event_test.go
@@ -31,11 +31,13 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "8305181b-b87f-4446-8f56-a3c38d5bd32f")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ConsumesCommandType(MessageN{}) // N = do nothing
-						c.ProducesEventType(MessageE{})
-						c.ProducesEventType(&MessageE{}) // pointer, used to test type similarity
-						c.ProducesEventType(MessageX{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.HandlesCommand[MessageN](), // N = do nothing
+							dogma.RecordsEvent[MessageE](),
+							dogma.RecordsEvent[*MessageE](), // pointer, used to test type similarity
+							dogma.RecordsEvent[MessageX](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -58,9 +60,11 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "0bd19cfa-c910-453f-a6cc-959fdce9c34f")
-						c.ConsumesEventType(MessageE{}) // E = execute a command
-						c.ConsumesEventType(MessageO{}) // O = only consumed, never produced
-						c.ProducesCommandType(MessageN{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](), // E = execute a command
+							dogma.HandlesEvent[MessageO](), // O = only consumed, never produced
+							dogma.ExecutesCommand[MessageN](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -112,7 +116,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectPass,
 			expectReport(
-				`✓ record an event that matches the predicate near expectation.messagematch.event_test.go:105`,
+				`✓ record an event that matches the predicate near expectation.messagematch.event_test.go:109`,
 			),
 		),
 		g.Entry(
@@ -129,7 +133,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:122`,
+				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:126`,
 				``,
 				`  | EXPLANATION`,
 				`  |     none of the engaged handlers recorded a matching event`,
@@ -153,7 +157,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:150`,
+				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:154`,
 				``,
 				`  | EXPLANATION`,
 				`  |     no messages were produced at all`,
@@ -173,7 +177,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:170`,
+				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:174`,
 				``,
 				`  | EXPLANATION`,
 				`  |     no events were recorded at all`,
@@ -193,7 +197,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:190`,
+				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:194`,
 				``,
 				`  | EXPLANATION`,
 				`  |     no relevant handler types were enabled`,
@@ -218,7 +222,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:215`,
+				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:219`,
 				``,
 				`  | EXPLANATION`,
 				`  |     none of the engaged handlers recorded a matching event`,
@@ -241,7 +245,7 @@ var _ = g.Describe("func ToRecordEventMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:238`,
+				`✗ record an event that matches the predicate near expectation.messagematch.event_test.go:242`,
 				``,
 				`  | EXPLANATION`,
 				`  |     none of the engaged handlers recorded a matching event`,
diff --git a/expectation.messagematch.eventonly_test.go b/expectation.messagematch.eventonly_test.go
index ed14724a..ec365167 100644
--- a/expectation.messagematch.eventonly_test.go
+++ b/expectation.messagematch.eventonly_test.go
@@ -30,8 +30,10 @@ var _ = g.Describe("func ToOnlyRecordEventsMatching()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "bc64cfe4-3339-4eee-a9d2-364d33dff47d")
-						c.ConsumesCommandType(MessageC{}) // C = command
-						c.ProducesEventType(MessageE{})   // E = event
+						c.Routes(
+							dogma.HandlesCommand[MessageC](), // C = command
+							dogma.RecordsEvent[MessageE](),   // E = event
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -74,7 +76,7 @@ var _ = g.Describe("func ToOnlyRecordEventsMatching()", func() {
 			),
 			expectPass,
 			expectReport(
-				`✓ only record events that match the predicate near expectation.messagematch.eventonly_test.go:72`,
+				`✓ only record events that match the predicate near expectation.messagematch.eventonly_test.go:74`,
 			),
 		),
 		g.Entry(
@@ -87,7 +89,7 @@ var _ = g.Describe("func ToOnlyRecordEventsMatching()", func() {
 			),
 			expectPass,
 			expectReport(
-				`✓ only record events that match the predicate near expectation.messagematch.eventonly_test.go:84`,
+				`✓ only record events that match the predicate near expectation.messagematch.eventonly_test.go:86`,
 			),
 		),
 		g.Entry(
@@ -107,7 +109,7 @@ var _ = g.Describe("func ToOnlyRecordEventsMatching()", func() {
 			),
 			expectFail,
 			expectReport(
-				`✗ only record events that match the predicate near expectation.messagematch.eventonly_test.go:97`,
+				`✗ only record events that match the predicate near expectation.messagematch.eventonly_test.go:99`,
 				``,
 				`  | EXPLANATION`,
 				`  |     only 1 of 2 relevant events matched the predicate`,
diff --git a/expectation.messagetype.command_test.go b/expectation.messagetype.command_test.go
index 685c1ac2..94e35171 100644
--- a/expectation.messagetype.command_test.go
+++ b/expectation.messagetype.command_test.go
@@ -30,8 +30,10 @@ var _ = g.Describe("func ToExecuteCommandOfType()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "c0094d00-d270-4fa0-bb4b-3cb24060cbe2")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ProducesEventType(MessageN{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.RecordsEvent[MessageN](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -48,11 +50,13 @@ var _ = g.Describe("func ToExecuteCommandOfType()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "551c1b77-4c4c-4b0c-b97f-b7c1ff6eada2")
-						c.ConsumesEventType(MessageE{})    // E = event
-						c.ConsumesEventType(MessageN{})    // N = (do) nothing
-						c.ProducesCommandType(MessageC{})  // C = command
-						c.ProducesCommandType(&MessageC{}) // pointer, used to test type similarity
-						c.ProducesCommandType(MessageX{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),     // E = event
+							dogma.HandlesEvent[MessageN](),     // N = (do) nothing
+							dogma.ExecutesCommand[MessageC](),  // C = command
+							dogma.ExecutesCommand[*MessageC](), // pointer, used to test type similarity
+							dogma.ExecutesCommand[MessageX](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
diff --git a/expectation.messagetype.commandcall_test.go b/expectation.messagetype.commandcall_test.go
index 128460a9..11b650f6 100644
--- a/expectation.messagetype.commandcall_test.go
+++ b/expectation.messagetype.commandcall_test.go
@@ -31,10 +31,12 @@ var _ = g.Describe("func ToExecuteCommandOfType() (when used with the Call() act
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "5c44e153-9e42-4816-87b0-59b4b4943dc4")
-						c.ConsumesCommandType(MessageR{})  // R = record an event
-						c.ConsumesCommandType(&MessageR{}) // pointer, used to test type similarity
-						c.ConsumesCommandType(MessageX{})
-						c.ProducesEventType(MessageN{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](),  // R = record an event
+							dogma.HandlesCommand[*MessageR](), // pointer, used to test type similarity
+							dogma.HandlesCommand[MessageX](),
+							dogma.RecordsEvent[MessageN](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -51,9 +53,11 @@ var _ = g.Describe("func ToExecuteCommandOfType() (when used with the Call() act
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "3994dd62-43f7-4569-813f-a616dc444486")
-						c.ConsumesEventType(MessageE{})   // E = event
-						c.ConsumesEventType(MessageN{})   // N = (do) nothing
-						c.ProducesCommandType(MessageC{}) // C = command
+						c.Routes(
+							dogma.HandlesEvent[MessageE](),    // E = event
+							dogma.HandlesEvent[MessageN](),    // N = (do) nothing
+							dogma.ExecutesCommand[MessageC](), // C = command
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -84,13 +88,6 @@ var _ = g.Describe("func ToExecuteCommandOfType() (when used with the Call() act
 		})
 	}
 
-	recordEventViaRecorder := func(m dogma.Message) Action {
-		return Call(func() {
-			err := test.EventRecorder().RecordEvent(context.Background(), m)
-			Expect(err).ShouldNot(HaveOccurred())
-		})
-	}
-
 	g.DescribeTable(
 		"expectation behavior",
 		func(
@@ -114,22 +111,6 @@ var _ = g.Describe("func ToExecuteCommandOfType() (when used with the Call() act
 				`✓ execute any 'fixtures.MessageR' command`,
 			),
 		),
-		g.Entry(
-			"no matching command types executed",
-			recordEventViaRecorder(MessageE1),
-			ToExecuteCommandOfType(MessageX{}),
-			expectFail,
-			expectReport(
-				`✗ execute any 'fixtures.MessageX' command`,
-				``,
-				`  | EXPLANATION`,
-				`  |     nothing executed a matching command`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • verify the logic within the '<process>' process message handler`,
-				`  |     • verify the logic within the code that uses the dogma.CommandExecutor`,
-			),
-		),
 		g.Entry(
 			"no messages produced at all",
 			Call(func() {}),
@@ -145,22 +126,6 @@ var _ = g.Describe("func ToExecuteCommandOfType() (when used with the Call() act
 				`  |     • verify the logic within the code that uses the dogma.CommandExecutor`,
 			),
 		),
-		g.Entry(
-			"no commands produced at all",
-			recordEventViaRecorder(MessageN1),
-			ToExecuteCommandOfType(MessageC{}),
-			expectFail,
-			expectReport(
-				`✗ execute any 'fixtures.MessageC' command`,
-				``,
-				`  | EXPLANATION`,
-				`  |     no commands were executed at all`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • verify the logic within the '<process>' process message handler`,
-				`  |     • verify the logic within the code that uses the dogma.CommandExecutor`,
-			),
-		),
 		g.Entry(
 			"no matching command type executed and all relevant handler types disabled",
 			executeCommandViaExecutor(MessageR1),
diff --git a/expectation.messagetype.event_test.go b/expectation.messagetype.event_test.go
index 4b67df7b..97c8b27b 100644
--- a/expectation.messagetype.event_test.go
+++ b/expectation.messagetype.event_test.go
@@ -30,11 +30,13 @@ var _ = g.Describe("func ToExecuteCommandOfType()", func() {
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "bef4f7fd-cd2a-4e10-9c52-691d389847b3")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ConsumesCommandType(MessageN{}) // N = do nothing
-						c.ProducesEventType(MessageE{})
-						c.ProducesEventType(&MessageE{}) // pointer, used to test type similarity
-						c.ProducesEventType(MessageX{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.HandlesCommand[MessageN](), // N = do nothing
+							dogma.RecordsEvent[MessageE](),
+							dogma.RecordsEvent[*MessageE](), // pointer, used to test type similarity
+							dogma.RecordsEvent[MessageX](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -53,9 +55,11 @@ var _ = g.Describe("func ToExecuteCommandOfType()", func() {
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "6a2146fa-00e5-49a3-acd8-fb0a6451a8ff")
-						c.ConsumesEventType(MessageE{}) // E = execute a command
-						c.ConsumesEventType(MessageO{}) // O = only consumed, never produced
-						c.ProducesCommandType(MessageN{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](), // E = execute a command
+							dogma.HandlesEvent[MessageO](), // O = only consumed, never produced
+							dogma.ExecutesCommand[MessageN](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
diff --git a/expectation.messagetype.eventcall_test.go b/expectation.messagetype.eventcall_test.go
index 2429f2ba..2e319df9 100644
--- a/expectation.messagetype.eventcall_test.go
+++ b/expectation.messagetype.eventcall_test.go
@@ -6,7 +6,6 @@ import (
 	"github.com/dogmatiq/dogma"
 	. "github.com/dogmatiq/dogma/fixtures"
 	. "github.com/dogmatiq/testkit"
-	"github.com/dogmatiq/testkit/engine"
 	"github.com/dogmatiq/testkit/internal/testingmock"
 	g "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -31,11 +30,13 @@ var _ = g.Describe("func ToRecordEventOfType() (when used with the Call() action
 				c.RegisterAggregate(&AggregateMessageHandler{
 					ConfigureFunc: func(c dogma.AggregateConfigurer) {
 						c.Identity("<aggregate>", "23c7a071-0a52-4aae-8dbf-d2bc06e32079")
-						c.ConsumesCommandType(MessageR{}) // R = record an event
-						c.ConsumesCommandType(MessageN{}) // N = do nothing
-						c.ProducesEventType(MessageE{})
-						c.ProducesEventType(&MessageE{}) // pointer, used to test type similarity
-						c.ProducesEventType(MessageX{})
+						c.Routes(
+							dogma.HandlesCommand[MessageR](), // R = record an event
+							dogma.HandlesCommand[MessageN](), // N = do nothing
+							dogma.RecordsEvent[MessageE](),
+							dogma.RecordsEvent[*MessageE](), // pointer, used to test type similarity
+							dogma.RecordsEvent[MessageX](),
+						)
 					},
 					RouteCommandToInstanceFunc: func(dogma.Message) string {
 						return "<instance>"
@@ -54,9 +55,11 @@ var _ = g.Describe("func ToRecordEventOfType() (when used with the Call() action
 				c.RegisterProcess(&ProcessMessageHandler{
 					ConfigureFunc: func(c dogma.ProcessConfigurer) {
 						c.Identity("<process>", "d2fdcbb0-b600-487c-97b4-f885b997cad3")
-						c.ConsumesEventType(MessageE{}) // E = execute a command
-						c.ConsumesEventType(MessageA{}) // A = also execute a command
-						c.ProducesCommandType(MessageN{})
+						c.Routes(
+							dogma.HandlesEvent[MessageE](), // E = execute a command
+							dogma.HandlesEvent[MessageA](), // A = also execute a command
+							dogma.ExecutesCommand[MessageN](),
+						)
 					},
 					RouteEventToInstanceFunc: func(
 						context.Context,
@@ -87,13 +90,6 @@ var _ = g.Describe("func ToRecordEventOfType() (when used with the Call() action
 		})
 	}
 
-	recordEventViaRecorder := func(m dogma.Message) Action {
-		return Call(func() {
-			err := test.EventRecorder().RecordEvent(context.Background(), m)
-			Expect(err).ShouldNot(HaveOccurred())
-		})
-	}
-
 	g.DescribeTable(
 		"expectation behavior",
 		func(
@@ -108,15 +104,6 @@ var _ = g.Describe("func ToRecordEventOfType() (when used with the Call() action
 			rm(testingT)
 			Expect(testingT.Failed()).To(Equal(!ok))
 		},
-		g.Entry(
-			"event type recorded as expected",
-			recordEventViaRecorder(MessageE1),
-			ToRecordEventOfType(MessageE{}),
-			expectPass,
-			expectReport(
-				`✓ record any 'fixtures.MessageE' event`,
-			),
-		),
 		g.Entry(
 			"no matching event types recorded",
 			executeCommandViaExecutor(MessageR1),
@@ -166,43 +153,5 @@ var _ = g.Describe("func ToRecordEventOfType() (when used with the Call() action
 				`  |     • verify the logic within the code that uses the dogma.EventRecorder`,
 			),
 		),
-		g.Entry(
-			"no matching event type recorded and all relevant handler types disabled",
-			recordEventViaRecorder(MessageA1),
-			ToRecordEventOfType(MessageE{}),
-			expectFail,
-			expectReport(
-				`✗ record any 'fixtures.MessageE' event`,
-				``,
-				`  | EXPLANATION`,
-				`  |     nothing recorded a matching event`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • enable aggregate handlers using the EnableHandlerType() option`,
-				`  |     • enable integration handlers using the EnableHandlerType() option`,
-				`  |     • verify the logic within the code that uses the dogma.EventRecorder`,
-			),
-			WithUnsafeOperationOptions(
-				engine.EnableAggregates(false),
-			),
-		),
-		g.Entry(
-			"event of a similar type recorded",
-			recordEventViaRecorder(MessageE1),
-			ToRecordEventOfType(&MessageE{}), // note: message type is pointer
-			expectFail,
-			expectReport(
-				`✗ record any '*fixtures.MessageE' event`,
-				``,
-				`  | EXPLANATION`,
-				`  |     an event of a similar type was recorded via a dogma.EventRecorder`,
-				`  | `,
-				`  | SUGGESTIONS`,
-				`  |     • check the message type, should it be a pointer?`,
-				`  | `,
-				`  | MESSAGE TYPE DIFF`,
-				`  |     [-*-]fixtures.MessageE`,
-			),
-		),
 	)
 })
diff --git a/fact/logger_test.go b/fact/logger_test.go
index 2758069e..b9306c87 100644
--- a/fact/logger_test.go
+++ b/fact/logger_test.go
@@ -35,31 +35,39 @@ var _ = g.Describe("type Logger", func() {
 		aggregate := configkit.FromAggregate(&AggregateMessageHandler{
 			ConfigureFunc: func(c dogma.AggregateConfigurer) {
 				c.Identity("<aggregate>", "986495b4-c878-4e3a-b16b-73f8aefbc2ca")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 		})
 
 		integration := configkit.FromIntegration(&IntegrationMessageHandler{
 			ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 				c.Identity("<integration>", "2425a151-ba72-42ec-970a-8b3b4133b22f")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 		})
 
 		process := configkit.FromProcess(&ProcessMessageHandler{
 			ConfigureFunc: func(c dogma.ProcessConfigurer) {
 				c.Identity("<process>", "570684db-0144-4628-a58f-ae815c55dea3")
-				c.ConsumesEventType(MessageE{})
-				c.ProducesCommandType(MessageC{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+					dogma.ExecutesCommand[MessageC](),
+				)
 			},
 		})
 
 		projection := configkit.FromProjection(&ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<projection>", "36f29880-6b87-42c5-848c-f515c9f1c74b")
-				c.ConsumesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesEvent[MessageE](),
+				)
 			},
 		})
 
diff --git a/recorder.go b/recorder.go
deleted file mode 100644
index ce94b9bd..00000000
--- a/recorder.go
+++ /dev/null
@@ -1,128 +0,0 @@
-package testkit
-
-import (
-	"context"
-	"sync"
-
-	"github.com/dogmatiq/dogma"
-	"github.com/dogmatiq/testkit/engine"
-)
-
-// EventRecorder is an implementation of dogma.EventRecorder that records events
-// within the context of a Test.
-//
-// Each instance is bound to a particular Test. Use Test.EventRecorder() to
-// obtain an instance.
-type EventRecorder struct {
-	m           sync.RWMutex
-	next        engine.EventRecorder
-	interceptor EventRecorderInterceptor
-}
-
-// RecordEvent records the event message m.
-//
-// It panics unless it is called during an Action, such as when calling
-// Test.Prepare() or Test.Expect().
-func (r *EventRecorder) RecordEvent(ctx context.Context, m dogma.Message) error {
-	r.m.RLock()
-	defer r.m.RUnlock()
-
-	if r.next.Engine == nil {
-		panic("RecordEvent(): cannot be called outside of a test")
-	}
-
-	if r.interceptor != nil {
-		return r.interceptor(ctx, m, r.next)
-	}
-
-	return r.next.RecordEvent(ctx, m)
-}
-
-// Bind sets the engine and options used to record events.
-//
-// It is intended for use within Action implementations that support recording
-// events outside of a Dogma handler, such as Call().
-//
-// It must be called before RecordEvent(), otherwise RecordEvent() panics.
-//
-// It must be accompanied by a call to Unbind() upon completion of the Action.
-func (r *EventRecorder) Bind(eng *engine.Engine, options []engine.OperationOption) {
-	r.m.Lock()
-	defer r.m.Unlock()
-
-	r.next.Engine = eng
-	r.next.Options = options
-}
-
-// Unbind removes the engine and options configured by a prior call to Bind().
-//
-// Calls to RecordEvent() on an unbound recorder will cause a panic.
-func (r *EventRecorder) Unbind() {
-	r.m.Lock()
-	defer r.m.Unlock()
-
-	r.next.Engine = nil
-	r.next.Options = nil
-}
-
-// Intercept installs an interceptor function that is invoked whenever
-// RecordEvent() is called.
-//
-// If fn is nil the interceptor is removed.
-//
-// It returns the previous interceptor, if any.
-func (r *EventRecorder) Intercept(fn EventRecorderInterceptor) EventRecorderInterceptor {
-	r.m.Lock()
-	defer r.m.Unlock()
-
-	prev := r.interceptor
-	r.interceptor = fn
-
-	return prev
-}
-
-// EventRecorderInterceptor is used by the InterceptEventRecorder() option to
-// specify custom behavior for the dogma.EventRecorder returned by
-// Test.EventRecorder().
-//
-// m is the event being recorded.
-//
-// e can be used to record the event as it would be recorded without this
-// interceptor installed.
-type EventRecorderInterceptor func(
-	ctx context.Context,
-	m dogma.Message,
-	r dogma.EventRecorder,
-) error
-
-// InterceptEventRecorder returns an option that causes fn to be called
-// whenever an event is recorded via the dogma.EventRecorder returned by
-// Test.EventRecorder().
-//
-// Intercepting calls to the event recorder allows the user to simulate
-// failures (or any other behavior) in the event recorder.
-func InterceptEventRecorder(fn EventRecorderInterceptor) interface {
-	TestOption
-	CallOption
-} {
-	if fn == nil {
-		panic("InterceptEventRecorder(<nil>): function must not be nil")
-	}
-
-	return interceptEventRecorderOption{fn}
-}
-
-// interceptEventRecorderOption is an implementation of both TestOption and
-// CallOption that allows the InterceptEventRecorder() option to be used with
-// both Test.Begin() and Call().
-type interceptEventRecorderOption struct {
-	fn EventRecorderInterceptor
-}
-
-func (o interceptEventRecorderOption) applyTestOption(t *Test) {
-	t.recorder.Intercept(o.fn)
-}
-
-func (o interceptEventRecorderOption) applyCallOption(a *callAction) {
-	a.onRecord = o.fn
-}
diff --git a/recorder_test.go b/recorder_test.go
deleted file mode 100644
index 713f12b1..00000000
--- a/recorder_test.go
+++ /dev/null
@@ -1,189 +0,0 @@
-package testkit_test
-
-import (
-	"context"
-	"errors"
-
-	"github.com/dogmatiq/dogma"
-	. "github.com/dogmatiq/dogma/fixtures"
-	. "github.com/dogmatiq/testkit"
-	"github.com/dogmatiq/testkit/internal/testingmock"
-	g "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = g.Describe("func InterceptEventRecorder()", func() {
-	var (
-		testingT                  *testingmock.T
-		app                       dogma.Application
-		doNothing                 EventRecorderInterceptor
-		recordEventAndReturnError EventRecorderInterceptor
-	)
-
-	g.BeforeEach(func() {
-		testingT = &testingmock.T{}
-
-		app = &Application{
-			ConfigureFunc: func(c dogma.ApplicationConfigurer) {
-				c.Identity("<app>", "01fdba5c-9010-4b6e-9cc4-bdb63f95c423")
-
-				c.RegisterProcess(&ProcessMessageHandler{
-					ConfigureFunc: func(c dogma.ProcessConfigurer) {
-						c.Identity("<handler-name>", "531c9909-ebcc-4214-8dba-b0a3a93ae5b4")
-						c.ConsumesEventType(MessageE{})
-						c.ProducesCommandType(MessageC{})
-					},
-					RouteEventToInstanceFunc: func(
-						context.Context,
-						dogma.Message,
-					) (string, bool, error) {
-						return "<instance>", true, nil
-					},
-					HandleEventFunc: func(
-						_ context.Context,
-						_ dogma.ProcessRoot,
-						s dogma.ProcessEventScope,
-						_ dogma.Message,
-					) error {
-						s.ExecuteCommand(MessageC1)
-						return nil
-					},
-				})
-			},
-		}
-
-		doNothing = func(
-			context.Context,
-			dogma.Message,
-			dogma.EventRecorder,
-		) error {
-			return nil
-		}
-
-		recordEventAndReturnError = func(
-			ctx context.Context,
-			m dogma.Message,
-			e dogma.EventRecorder,
-		) error {
-			Expect(m).To(Equal(MessageE1))
-
-			err := e.RecordEvent(ctx, m)
-			Expect(err).ShouldNot(HaveOccurred())
-
-			return errors.New("<error>")
-		}
-	})
-
-	g.It("panics if the interceptor function is nil", func() {
-		Expect(func() {
-			InterceptEventRecorder(nil)
-		}).To(PanicWith("InterceptEventRecorder(<nil>): function must not be nil"))
-	})
-
-	g.When("used as a TestOption", func() {
-		g.It("intercepts calls to RecordEvent()", func() {
-			test := Begin(
-				testingT,
-				app,
-				InterceptEventRecorder(recordEventAndReturnError),
-			)
-
-			test.EnableHandlers("<handler-name>")
-
-			test.Expect(
-				Call(func() {
-					err := test.EventRecorder().RecordEvent(
-						context.Background(),
-						MessageE1,
-					)
-					Expect(err).To(MatchError("<error>"))
-				}),
-				ToExecuteCommand(MessageC1),
-			)
-		})
-	})
-
-	g.When("used as a CallOption", func() {
-		g.It("intercepts calls to RecordEvent()", func() {
-			test := Begin(
-				&testingmock.T{},
-				app,
-			)
-
-			test.EnableHandlers("<handler-name>")
-
-			test.Expect(
-				Call(
-					func() {
-						err := test.EventRecorder().RecordEvent(
-							context.Background(),
-							MessageE1,
-						)
-						Expect(err).To(MatchError("<error>"))
-					},
-					InterceptEventRecorder(recordEventAndReturnError),
-				),
-				ToExecuteCommand(MessageC1),
-			)
-		})
-
-		g.It("uninstalls the interceptor upon completion of the Call() action", func() {
-			test := Begin(
-				&testingmock.T{},
-				app,
-			)
-
-			test.Prepare(
-				Call(
-					func() {
-						err := test.EventRecorder().RecordEvent(
-							context.Background(),
-							MessageE1,
-						)
-						Expect(err).To(MatchError("<error>"))
-					},
-					InterceptEventRecorder(recordEventAndReturnError),
-				),
-				Call(
-					func() {
-						err := test.EventRecorder().RecordEvent(
-							context.Background(),
-							MessageE1,
-						)
-						Expect(err).ShouldNot(HaveOccurred())
-					},
-				),
-			)
-		})
-
-		g.It("re-installs the test-level interceptor upon completion of the Call() action", func() {
-			test := Begin(
-				&testingmock.T{},
-				app,
-				InterceptEventRecorder(recordEventAndReturnError),
-			)
-
-			test.Prepare(
-				Call(
-					func() {
-						err := test.EventRecorder().RecordEvent(
-							context.Background(),
-							MessageE1,
-						)
-						Expect(err).ShouldNot(HaveOccurred())
-					},
-					InterceptEventRecorder(doNothing),
-				),
-				Call(
-					func() {
-						err := test.EventRecorder().RecordEvent(
-							context.Background(),
-							MessageE1,
-						)
-						Expect(err).To(MatchError("<error>"))
-					},
-				),
-			)
-		})
-	})
-})
diff --git a/test.go b/test.go
index c76a061b..42248804 100644
--- a/test.go
+++ b/test.go
@@ -21,7 +21,6 @@ type Test struct {
 	virtualClock     time.Time
 	engine           *engine.Engine
 	executor         CommandExecutor
-	recorder         EventRecorder
 	predicateOptions PredicateOptions
 	operationOptions []engine.OperationOption
 }
@@ -149,18 +148,6 @@ func (t *Test) CommandExecutor() dogma.CommandExecutor {
 	return &t.executor
 }
 
-// EventRecorder returns a dogma.EventRecorder which can be used to record
-// events within the context of this test.
-//
-// The recorder can be obtained at any time, but it can only be used within
-// specific test actions.
-//
-// Call() is the only built-in action that supports the event recorder. It may
-// be supported by other user-defined actions.
-func (t *Test) EventRecorder() dogma.EventRecorder {
-	return &t.recorder
-}
-
 // EnableHandlers enables a set of handlers by name.
 //
 // By default all integration and projection handlers are disabled.
@@ -204,7 +191,6 @@ func (t *Test) doAction(act Action, options ...engine.OperationOption) error {
 			VirtualClock:     &t.virtualClock,
 			Engine:           t.engine,
 			Executor:         &t.executor,
-			Recorder:         &t.recorder,
 			OperationOptions: opts,
 		},
 	)
diff --git a/test_test.go b/test_test.go
index b6b26294..0b9a36cb 100644
--- a/test_test.go
+++ b/test_test.go
@@ -61,7 +61,9 @@ var _ = g.Describe("type Test", func() {
 					c.RegisterProjection(&ProjectionMessageHandler{
 						ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 							c.Identity("<projection>", "fb5f05c0-589c-4d64-9599-a4875b5a3569")
-							c.ConsumesEventType(MessageE{})
+							c.Routes(
+								dogma.HandlesEvent[MessageE](),
+							)
 						},
 						HandleEventFunc: func(
 							_ context.Context,
@@ -92,8 +94,10 @@ var _ = g.Describe("type Test", func() {
 					c.RegisterAggregate(&AggregateMessageHandler{
 						ConfigureFunc: func(c dogma.AggregateConfigurer) {
 							c.Identity("<aggregate>", "524f7944-a252-48e0-864b-503a903067c2")
-							c.ConsumesCommandType(MessageC{})
-							c.ProducesEventType(MessageE{})
+							c.Routes(
+								dogma.HandlesCommand[MessageC](),
+								dogma.RecordsEvent[MessageE](),
+							)
 						},
 						RouteCommandToInstanceFunc: func(dogma.Message) string {
 							return "<instance>"
diff --git a/testoption_test.go b/testoption_test.go
index 2e6676f2..80ad575e 100644
--- a/testoption_test.go
+++ b/testoption_test.go
@@ -20,7 +20,9 @@ var _ = g.Describe("func StartTimeAt()", func() {
 		handler := &ProjectionMessageHandler{
 			ConfigureFunc: func(c dogma.ProjectionConfigurer) {
 				c.Identity("<handler-name>", "ca76057c-9ad0-4a55-a9d9-7fbffe92e644")
-				c.ConsumesEventType(MessageA{})
+				c.Routes(
+					dogma.HandlesEvent[MessageA](),
+				)
 			},
 			HandleEventFunc: func(
 				_ context.Context,
@@ -58,8 +60,10 @@ var _ = g.Describe("func WithMessageComparator()", func() {
 		handler := &IntegrationMessageHandler{
 			ConfigureFunc: func(c dogma.IntegrationConfigurer) {
 				c.Identity("<handler-name>", "191580b7-0b16-4e5e-be03-eda07e92b9b0")
-				c.ConsumesCommandType(MessageC{})
-				c.ProducesEventType(MessageE{})
+				c.Routes(
+					dogma.HandlesCommand[MessageC](),
+					dogma.RecordsEvent[MessageE](),
+				)
 			},
 			HandleCommandFunc: func(
 				_ context.Context,