@temporalio/core-bridge 1.9.2 → 1.10.0

package/sdk-core/core/src/worker/workflow/driven_workflow.rs

@@ -12,7 +12,7 @@ use temporal_sdk_core_protos::{
 
 /// Represents a connection to a lang side workflow that can have activations fed into it and
 /// command responses pulled out.
-pub struct DrivenWorkflow {
+pub(crate) struct DrivenWorkflow {
     started_attrs: Option<WorkflowStartedInfo>,
     incoming_commands: Receiver<Vec<WFCommand>>,
     /// Outgoing activation jobs that need to be sent to the lang sdk
@@ -20,7 +20,7 @@ pub struct DrivenWorkflow {
 }
 
 impl DrivenWorkflow {
-    pub fn new() -> (Self, Sender<Vec<WFCommand>>) {
+    pub(super) fn new() -> (Self, Sender<Vec<WFCommand>>) {
         let (tx, rx) = mpsc::channel();
         (
             Self {
@@ -32,7 +32,7 @@ impl DrivenWorkflow {
         )
     }
     /// Start the workflow
-    pub fn start(
+    pub(super) fn start(
         &mut self,
         workflow_id: String,
         randomness_seed: u64,
@@ -53,7 +53,7 @@ impl DrivenWorkflow {
     }
 
     /// Return the attributes from the workflow execution started event if this workflow has started
-    pub fn get_started_info(&self) -> Option<&WorkflowStartedInfo> {
+    pub(super) fn get_started_info(&self) -> Option<&WorkflowStartedInfo> {
         self.started_attrs.as_ref()
     }
 
@@ -68,7 +68,7 @@ impl DrivenWorkflow {
     }
 
     /// Drain all pending jobs, so that they may be sent to the driven workflow
-    pub fn drain_jobs(&mut self) -> Vec<WorkflowActivationJob> {
+    pub(super) fn drain_jobs(&mut self) -> Vec<WorkflowActivationJob> {
         self.outgoing_wf_activation_jobs
             .drain(..)
             .map(Into::into)
@@ -79,7 +79,7 @@ impl DrivenWorkflow {
     /// responsible for calling workflow code as a result of receiving tasks from
     /// [crate::Core::poll_task], we cannot directly iterate it here. Commands are simply pulled
     /// from a buffer that the language side sinks into when it calls [crate::Core::complete_task]
-    pub fn fetch_workflow_iteration_output(&mut self) -> Vec<WFCommand> {
+    pub(super) fn fetch_workflow_iteration_output(&mut self) -> Vec<WFCommand> {
         let in_cmds = self.incoming_commands.try_recv();
         let in_cmds = in_cmds.unwrap_or_else(|_| vec![WFCommand::NoCommandsFromLang]);
         debug!(in_cmds = %in_cmds.display(), "wf bridge iteration fetch");

package/sdk-core/core/src/worker/workflow/history_update.rs

@@ -7,6 +7,7 @@ use crate::{
 };
 use futures::{future::BoxFuture, FutureExt, Stream};
 use itertools::Itertools;
+use once_cell::sync::Lazy;
 use std::{
     collections::VecDeque,
     fmt::Debug,
@@ -23,33 +24,29 @@ use temporal_sdk_core_protos::temporal::api::{
 };
 use tracing::Instrument;
 
-lazy_static::lazy_static! {
-    static ref EMPTY_FETCH_ERR: tonic::Status
-        = tonic::Status::unknown("Fetched empty history page");
-    static ref EMPTY_TASK_ERR: tonic::Status
-        = tonic::Status::unknown("Received an empty workflow task with no queries or history");
-}
+static EMPTY_FETCH_ERR: Lazy<tonic::Status> =
+    Lazy::new(|| tonic::Status::unknown("Fetched empty history page"));
+static EMPTY_TASK_ERR: Lazy<tonic::Status> = Lazy::new(|| {
+    tonic::Status::unknown("Received an empty workflow task with no queries or history")
+});
 
 /// Represents one or more complete WFT sequences. History events are expected to be consumed from
 /// it and applied to the state machines via [HistoryUpdate::take_next_wft_sequence]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-pub struct HistoryUpdate {
+pub(crate) struct HistoryUpdate {
     events: Vec<HistoryEvent>,
     /// The event ID of the last started WFT, as according to the WFT which this update was
     /// extracted from. Hence, while processing multiple logical WFTs during replay which were part
     /// of one large history fetched from server, multiple updates may have the same value here.
-    pub previous_wft_started_id: i64,
+    pub(crate) previous_wft_started_id: i64,
     /// The `started_event_id` field from the WFT which this update is tied to. Multiple updates
     /// may have the same value if they're associated with the same WFT.
-    pub wft_started_id: i64,
+    pub(crate) wft_started_id: i64,
     /// True if this update contains the final WFT in history, and no more attempts to extract
     /// additional updates should be made.
     has_last_wft: bool,
     wft_count: usize,
 }
+
 impl Debug for HistoryUpdate {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.is_real() {
@@ -69,7 +66,7 @@ impl Debug for HistoryUpdate {
 }
 
 #[derive(Debug)]
-pub enum NextWFT {
+pub(crate) enum NextWFT {
     ReplayOver,
     WFT(Vec<HistoryEvent>, bool),
     NeedFetch,
@@ -77,32 +74,23 @@ pub enum NextWFT {
 
 #[derive(derive_more::DebugCustom)]
 #[debug(fmt = "HistoryPaginator(run_id: {run_id})")]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(default = "HistoryPaginator::fake_deserialized")
-)]
-pub struct HistoryPaginator {
+pub(crate) struct HistoryPaginator {
     pub(crate) wf_id: String,
     pub(crate) run_id: String,
     pub(crate) previous_wft_started_id: i64,
     pub(crate) wft_started_event_id: i64,
     id_of_last_event_in_last_extracted_update: Option<i64>,
 
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip))]
     client: Arc<dyn WorkerClient>,
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip))]
     event_queue: VecDeque<HistoryEvent>,
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip))]
     next_page_token: NextPageToken,
     /// These are events that should be returned once pagination has finished. This only happens
     /// during cache misses, where we got a partial task but need to fetch history from the start.
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip))]
     final_events: Vec<HistoryEvent>,
 }
 
 #[derive(Clone, Debug)]
-pub enum NextPageToken {
+pub(crate) enum NextPageToken {
     /// There is no page token, we need to fetch history from the beginning
     FetchFromStart,
     /// There is a page token
@@ -224,22 +212,6 @@ impl HistoryPaginator {
         }
     }
 
-    #[cfg(feature = "save_wf_inputs")]
-    pub(super) fn fake_deserialized() -> HistoryPaginator {
-        use crate::worker::client::mocks::mock_manual_workflow_client;
-        HistoryPaginator {
-            client: Arc::new(mock_manual_workflow_client()),
-            event_queue: Default::default(),
-            wf_id: "".to_string(),
-            run_id: "".to_string(),
-            next_page_token: NextPageToken::FetchFromStart,
-            final_events: vec![],
-            previous_wft_started_id: -2,
-            wft_started_event_id: -2,
-            id_of_last_event_in_last_extracted_update: None,
-        }
-    }
-
     /// Return at least the next two WFT sequences (as determined by the passed-in ID) as a
     /// [HistoryUpdate]. Two sequences supports the required peek-ahead during replay without
     /// unnecessary back-and-forth.
@@ -409,7 +381,7 @@ struct StreamingHistoryPaginator {
 impl StreamingHistoryPaginator {
     // Kept since can be used for history downloading
     #[cfg(test)]
-    pub fn new(inner: HistoryPaginator) -> Self {
+    fn new(inner: HistoryPaginator) -> Self {
         Self {
             inner,
             open_history_request: None,
@@ -451,7 +423,7 @@ impl Stream for StreamingHistoryPaginator {
 impl HistoryUpdate {
     /// Sometimes it's useful to take an update out of something without needing to use an option
     /// field. Use this to replace the field with an empty update.
-    pub fn dummy() -> Self {
+    pub(crate) fn dummy() -> Self {
         Self {
             events: vec![],
             previous_wft_started_id: -1,
@@ -460,10 +432,12 @@ impl HistoryUpdate {
             wft_count: 0,
         }
     }
-    pub fn is_real(&self) -> bool {
+
+    pub(crate) fn is_real(&self) -> bool {
         self.previous_wft_started_id >= 0
     }
-    pub fn first_event_id(&self) -> Option<i64> {
+
+    pub(crate) fn first_event_id(&self) -> Option<i64> {
         self.events.first().map(|e| e.event_id)
     }
 
@@ -485,7 +459,7 @@ impl HistoryUpdate {
     /// partial WFT sequence at the end, all events after the last complete WFT sequence (ending
     /// with WFT started) are returned back to the caller, since the history update only works in
     /// terms of complete WFT sequences.
-    pub fn from_events<I: IntoIterator<Item = HistoryEvent>>(
+    pub(crate) fn from_events<I: IntoIterator<Item = HistoryEvent>>(
         events: I,
         previous_wft_started_id: i64,
         wft_started_id: i64,
@@ -566,7 +540,7 @@ impl HistoryUpdate {
     /// of one or more complete WFT sequences. IE: The event iterator must not end in the middle
     /// of a WFT sequence.
     #[cfg(test)]
-    pub fn new_from_events<I: IntoIterator<Item = HistoryEvent>>(
+    fn new_from_events<I: IntoIterator<Item = HistoryEvent>>(
         events: I,
         previous_wft_started_id: i64,
         wft_started_id: i64,
@@ -590,7 +564,7 @@ impl HistoryUpdate {
     ///
     /// If we are out of WFT sequences that can be yielded by this update, it will return an empty
     /// vec, indicating more pages will need to be fetched.
-    pub fn take_next_wft_sequence(&mut self, from_wft_started_id: i64) -> NextWFT {
+    pub(crate) fn take_next_wft_sequence(&mut self, from_wft_started_id: i64) -> NextWFT {
         // First, drop any events from the queue which are earlier than the passed-in id.
         if let Some(ix_first_relevant) = self.starting_index_after_skipping(from_wft_started_id) {
             self.events.drain(0..ix_first_relevant);
@@ -629,7 +603,7 @@ impl HistoryUpdate {
     /// [take_next_wft_sequence]. Will always return the first available WFT sequence if that has
     /// not been called first. May also return an empty iterator or incomplete sequence if we are at
     /// the end of history.
-    pub fn peek_next_wft_sequence(&self, from_wft_started_id: i64) -> &[HistoryEvent] {
+    pub(crate) fn peek_next_wft_sequence(&self, from_wft_started_id: i64) -> &[HistoryEvent] {
         let ix_first_relevant = self
             .starting_index_after_skipping(from_wft_started_id)
             .unwrap_or_default();
@@ -645,7 +619,7 @@ impl HistoryUpdate {
 
     /// Returns true if this update has the next needed WFT sequence, false if events will need to
     /// be fetched in order to create a complete update with the entire next WFT sequence.
-    pub fn can_take_next_wft_sequence(&self, from_wft_started_id: i64) -> bool {
+    pub(crate) fn can_take_next_wft_sequence(&self, from_wft_started_id: i64) -> bool {
         let next_wft_ix =
             find_end_index_of_next_wft_seq(&self.events, from_wft_started_id, self.has_last_wft);
         if let NextWFTSeqEndIndex::Incomplete(_) = next_wft_ix {
@@ -658,7 +632,7 @@ impl HistoryUpdate {
 
     /// Returns the next WFT completed event attributes, if any, starting at (inclusive) the
     /// `from_id`
-    pub fn peek_next_wft_completed(
+    pub(crate) fn peek_next_wft_completed(
         &self,
         from_id: i64,
     ) -> Option<&WorkflowTaskCompletedEventAttributes> {
@@ -776,7 +750,7 @@ fn find_end_index_of_next_wft_seq(
 }
 
 #[cfg(test)]
-pub mod tests {
+mod tests {
     use super::*;
     use crate::{
         replay::{HistoryInfo, TestHistoryBuilder},
@@ -806,7 +780,7 @@ pub mod tests {
         }
     }
 
-    pub trait TestHBExt {
+    trait TestHBExt {
         fn as_history_update(&self) -> HistoryUpdate;
     }
 

package/sdk-core/core/src/worker/workflow/machines/activity_state_machine.rs

@@ -28,7 +28,7 @@ use temporal_sdk_core_protos::{
         history::v1::{
             history_event, ActivityTaskCanceledEventAttributes,
             ActivityTaskCompletedEventAttributes, ActivityTaskFailedEventAttributes,
-            ActivityTaskTimedOutEventAttributes, HistoryEvent,
+            ActivityTaskTimedOutEventAttributes,
         },
     },
 };
@@ -117,8 +117,8 @@ impl ActivityMachine {
         let mut s = Self::from_parts(
             Created {}.into(),
             SharedState {
-                cancellation_type: ActivityCancellationType::from_i32(attrs.cancellation_type)
-                    .unwrap(),
+                cancellation_type: ActivityCancellationType::try_from(attrs.cancellation_type)
+                    .unwrap_or(ActivityCancellationType::TryCancel),
                 attrs,
                 internal_flags,
                 scheduled_event_id: 0,
@@ -286,19 +286,6 @@ impl WFMachinesAdapter for ActivityMachine {
             }
         })
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::ActivityTaskScheduled
-                | EventType::ActivityTaskStarted
-                | EventType::ActivityTaskCompleted
-                | EventType::ActivityTaskFailed
-                | EventType::ActivityTaskTimedOut
-                | EventType::ActivityTaskCancelRequested
-                | EventType::ActivityTaskCanceled
-        )
-    }
 }
 
 impl TryFrom<CommandType> for ActivityMachineEvents {
@@ -781,7 +768,7 @@ fn new_cancel_failure(dat: &SharedState, attrs: ActivityTaskCanceledEventAttribu
     }
 }
 
-pub fn activity_fail_info(
+pub(super) fn activity_fail_info(
     act_type: String,
     act_id: String,
     identity: Option<String>,

package/sdk-core/core/src/worker/workflow/machines/cancel_external_state_machine.rs

@@ -14,7 +14,7 @@ use temporal_sdk_core_protos::{
         command::v1::{command, Command, RequestCancelExternalWorkflowExecutionCommandAttributes},
         enums::v1::{CancelExternalWorkflowExecutionFailedCause, CommandType, EventType},
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
-        history::v1::{history_event, HistoryEvent},
+        history::v1::history_event,
     },
 };
 
@@ -210,15 +210,6 @@ impl WFMachinesAdapter for CancelExternalMachine {
             }
         })
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::ExternalWorkflowExecutionCancelRequested
-                | EventType::RequestCancelExternalWorkflowExecutionFailed
-                | EventType::RequestCancelExternalWorkflowExecutionInitiated
-        )
-    }
 }
 
 impl Cancellable for CancelExternalMachine {}

package/sdk-core/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs

@@ -1,6 +1,6 @@
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, HistoryEvent,
-    NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
 use crate::worker::workflow::machines::HistEventData;
 use rustfsm::{fsm, StateMachine, TransitionResult};
@@ -27,9 +27,6 @@ fsm! {
         --> CancelWorkflowCommandRecorded;
 }
 
-#[derive(thiserror::Error, Debug)]
-pub(super) enum CancelWorkflowMachineError {}
-
 #[derive(Debug, derive_more::Display)]
 pub(super) enum CancelWorkflowCommand {}
 
@@ -75,8 +72,8 @@ impl TryFrom<HistEventData> for CancelWorkflowMachineEvents {
 
     fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
         let e = e.event;
-        Ok(match EventType::from_i32(e.event_type) {
-            Some(EventType::WorkflowExecutionCanceled) => Self::WorkflowExecutionCanceled,
+        Ok(match EventType::try_from(e.event_type) {
+            Ok(EventType::WorkflowExecutionCanceled) => Self::WorkflowExecutionCanceled,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Cancel workflow machine does not handle this event: {e}"
@@ -105,10 +102,6 @@ impl WFMachinesAdapter for CancelWorkflowMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(vec![])
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionCanceled
-    }
 }
 
 impl Cancellable for CancelWorkflowMachine {}

package/sdk-core/core/src/worker/workflow/machines/child_workflow_state_machine.rs

@@ -38,7 +38,7 @@ use temporal_sdk_core_protos::{
         history::v1::{
             history_event, ChildWorkflowExecutionCompletedEventAttributes,
             ChildWorkflowExecutionFailedEventAttributes,
-            ChildWorkflowExecutionStartedEventAttributes, HistoryEvent,
+            ChildWorkflowExecutionStartedEventAttributes,
             StartChildWorkflowExecutionFailedEventAttributes,
         },
     },
@@ -98,7 +98,7 @@ fsm! {
     Completed --(Cancel) --> Completed;
 }
 
-pub struct ChildWorkflowExecutionStartedEvent {
+pub(super) struct ChildWorkflowExecutionStartedEvent {
     workflow_execution: WorkflowExecution,
     started_event_id: i64,
 }
@@ -283,7 +283,7 @@ impl StartEventRecorded {
         event: ChildWorkflowExecutionStartedEvent,
     ) -> ChildWorkflowMachineTransition<Started> {
         state.started_event_id = event.started_event_id;
-        state.run_id = event.workflow_execution.run_id.clone();
+        state.run_id.clone_from(&event.workflow_execution.run_id);
         ChildWorkflowMachineTransition::commands(vec![ChildWorkflowCommand::Start(
             event.workflow_execution,
         )])
@@ -498,8 +498,8 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
     fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
         let last_task_in_history = e.current_task_is_last_in_history;
         let e = e.event;
-        Ok(match EventType::from_i32(e.event_type) {
-            Some(EventType::StartChildWorkflowExecutionInitiated) => {
+        Ok(match EventType::try_from(e.event_type) {
+            Ok(EventType::StartChildWorkflowExecutionInitiated) => {
                 if let Some(
                     history_event::Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(
                         attrs,
@@ -518,7 +518,7 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                     ));
                 }
             }
-            Some(EventType::StartChildWorkflowExecutionFailed) => {
+            Ok(EventType::StartChildWorkflowExecutionFailed) => {
                 if let Some(
                     history_event::Attributes::StartChildWorkflowExecutionFailedEventAttributes(
                         StartChildWorkflowExecutionFailedEventAttributes { cause, .. },
@@ -526,13 +526,11 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                 ) = e.attributes
                 {
                     Self::StartChildWorkflowExecutionFailed(
-                        StartChildWorkflowExecutionFailedCause::from_i32(cause).ok_or_else(
-                            || {
-                                WFMachinesError::Fatal(
-                                    "Invalid StartChildWorkflowExecutionFailedCause".to_string(),
-                                )
-                            },
-                        )?,
+                        StartChildWorkflowExecutionFailedCause::try_from(cause).map_err(|_| {
+                            WFMachinesError::Fatal(
+                                "Invalid StartChildWorkflowExecutionFailedCause".to_string(),
+                            )
+                        })?,
                     )
                 } else {
                     return Err(WFMachinesError::Fatal(
@@ -540,7 +538,7 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                     ));
                 }
             }
-            Some(EventType::ChildWorkflowExecutionStarted) => {
+            Ok(EventType::ChildWorkflowExecutionStarted) => {
                 if let Some(
                     history_event::Attributes::ChildWorkflowExecutionStartedEventAttributes(
                         ChildWorkflowExecutionStartedEventAttributes {
@@ -561,7 +559,7 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                     ));
                 }
             }
-            Some(EventType::ChildWorkflowExecutionCompleted) => {
+            Ok(EventType::ChildWorkflowExecutionCompleted) => {
                 if let Some(
                     history_event::Attributes::ChildWorkflowExecutionCompletedEventAttributes(
                         ChildWorkflowExecutionCompletedEventAttributes { result, .. },
@@ -576,7 +574,7 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                     ));
                 }
             }
-            Some(EventType::ChildWorkflowExecutionFailed) => {
+            Ok(EventType::ChildWorkflowExecutionFailed) => {
                 if let Some(
                     history_event::Attributes::ChildWorkflowExecutionFailedEventAttributes(attrs),
                 ) = e.attributes
@@ -588,7 +586,7 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                     ));
                 }
             }
-            Some(EventType::ChildWorkflowExecutionTimedOut) => {
+            Ok(EventType::ChildWorkflowExecutionTimedOut) => {
                 if let Some(
                     history_event::Attributes::ChildWorkflowExecutionTimedOutEventAttributes(atts),
                 ) = e.attributes
@@ -601,12 +599,10 @@ impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
                     ));
                 }
             }
-            Some(EventType::ChildWorkflowExecutionTerminated) => {
+            Ok(EventType::ChildWorkflowExecutionTerminated) => {
                 Self::ChildWorkflowExecutionTerminated
             }
-            Some(EventType::ChildWorkflowExecutionCanceled) => {
-                Self::ChildWorkflowExecutionCancelled
-            }
+            Ok(EventType::ChildWorkflowExecutionCanceled) => Self::ChildWorkflowExecutionCancelled,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
                     "Child workflow machine does not handle this event: {e:?}"
@@ -708,20 +704,6 @@ impl WFMachinesAdapter for ChildWorkflowMachine {
             }
         })
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(
-            event.event_type(),
-            EventType::StartChildWorkflowExecutionInitiated
-                | EventType::StartChildWorkflowExecutionFailed
-                | EventType::ChildWorkflowExecutionStarted
-                | EventType::ChildWorkflowExecutionCompleted
-                | EventType::ChildWorkflowExecutionFailed
-                | EventType::ChildWorkflowExecutionTimedOut
-                | EventType::ChildWorkflowExecutionTerminated
-                | EventType::ChildWorkflowExecutionCanceled
-        )
-    }
 }
 
 impl TryFrom<CommandType> for ChildWorkflowMachineEvents {

package/sdk-core/core/src/worker/workflow/machines/complete_workflow_state_machine.rs

@@ -10,7 +10,6 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         command::v1::Command,
         enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
     },
 };
 
@@ -103,9 +102,6 @@ impl Created {
     }
 }
 
-#[derive(thiserror::Error, Debug)]
-pub(super) enum CompleteWorkflowMachineError {}
-
 #[derive(Default, Clone)]
 pub(super) struct CompleteWorkflowCommandCreated {}
 
@@ -126,10 +122,6 @@ impl WFMachinesAdapter for CompleteWorkflowMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(vec![])
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionCompleted
-    }
 }
 
 impl Cancellable for CompleteWorkflowMachine {}

package/sdk-core/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs

@@ -1,5 +1,5 @@
 use super::{
-    Cancellable, EventInfo, HistoryEvent, MachineResponse, NewMachineWithCommand, OnEventWrapper,
+    Cancellable, EventInfo, MachineResponse, NewMachineWithCommand, OnEventWrapper,
     WFMachinesAdapter, WFMachinesError,
 };
 use crate::worker::workflow::machines::HistEventData;
@@ -107,10 +107,6 @@ impl WFMachinesAdapter for ContinueAsNewWorkflowMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(vec![])
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionContinuedAsNew
-    }
 }
 
 impl Cancellable for ContinueAsNewWorkflowMachine {}

package/sdk-core/core/src/worker/workflow/machines/fail_workflow_state_machine.rs

@@ -10,7 +10,6 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         command::v1::Command as ProtoCommand,
         enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
     },
 };
 
@@ -117,10 +116,6 @@ impl WFMachinesAdapter for FailWorkflowMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(vec![])
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.event_type() == EventType::WorkflowExecutionFailed
-    }
 }
 
 impl Cancellable for FailWorkflowMachine {}

package/sdk-core/core/src/worker/workflow/machines/local_activity_state_machine.rs

@@ -34,7 +34,6 @@ use temporal_sdk_core_protos::{
         command::v1::{command, RecordMarkerCommandAttributes},
         enums::v1::{CommandType, EventType, RetryState},
         failure::v1::{failure::FailureInfo, Failure},
-        history::v1::HistoryEvent,
     },
     utilities::TryIntoOrNone,
 };
@@ -799,10 +798,6 @@ impl WFMachinesAdapter for LocalActivityMachine {
             }
         }
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.is_local_activity_marker()
-    }
 }
 
 impl TryFrom<CommandType> for LocalActivityMachineEvents {

package/sdk-core/core/src/worker/workflow/machines/mod.rs

@@ -84,11 +84,6 @@ trait TemporalStateMachine {
         command_type: CommandType,
     ) -> Result<Vec<MachineResponse>, WFMachinesError>;
 
-    /// Returns true if this machine is compatible with the provided event. Provides a way to know
-    /// ahead of time if it's worth trying to call [TemporalStateMachine::handle_event] without
-    /// requiring mutable access.
-    fn matches_event(&self, event: &HistoryEvent) -> bool;
-
     /// Tell the state machine to handle some event. Returns a list of responses that can be used
     /// to update the overall state of the workflow. EX: To issue outgoing WF activations.
     fn handle_event(
@@ -150,10 +145,6 @@ where
         }
     }
 
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        self.matches_event(event)
-    }
-
     fn handle_event(
         &mut self,
         event_dat: HistEventData,
@@ -240,11 +231,6 @@ trait WFMachinesAdapter: StateMachine {
         my_command: Self::Command,
         event_info: Option<EventInfo>,
     ) -> Result<Vec<MachineResponse>, WFMachinesError>;
-
-    /// Returns true if this machine is compatible with the provided event. Provides a way to know
-    /// ahead of time if it's worth trying to call [TemporalStateMachine::handle_event] without
-    /// requiring mutable access.
-    fn matches_event(&self, event: &HistoryEvent) -> bool;
 }
 
 /// Wraps a history event with extra relevant data that a machine might care about while the event

package/sdk-core/core/src/worker/workflow/machines/modify_workflow_properties_state_machine.rs

@@ -9,7 +9,6 @@ use temporal_sdk_core_protos::{
     temporal::api::{
         command::v1::Command,
         enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
     },
 };
 
@@ -63,10 +62,6 @@ impl WFMachinesAdapter for ModifyWorkflowPropertiesMachine {
             "ModifyWorkflowProperties does not use state machine commands".to_string(),
         ))
     }
-
-    fn matches_event(&self, event: &HistoryEvent) -> bool {
-        matches!(event.event_type(), EventType::WorkflowPropertiesModified)
-    }
 }
 
 impl Cancellable for ModifyWorkflowPropertiesMachine {}