temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/core/src/worker/workflow/machines/patch_state_machine.rs

@@ -18,10 +18,10 @@
 //! | replaying, no marker         | deprecate_patch | Call allowed                                                                       |
 
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use crate::protosext::HistoryEventExt;
+use crate::{protosext::HistoryEventExt, worker::workflow::machines::HistEventData};
 use rustfsm::{fsm, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
@@ -186,10 +186,6 @@ impl WFMachinesAdapter for PatchMachine {
     fn matches_event(&self, event: &HistoryEvent) -> bool {
         event.get_patch_marker_details().is_some()
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::Patch
-    }
 }
 
 impl Cancellable for PatchMachine {}
@@ -205,15 +201,15 @@ impl TryFrom<CommandType> for PatchMachineEvents {
     }
 }
 
-impl TryFrom<HistoryEvent> for PatchMachineEvents {
+impl TryFrom<HistEventData> for PatchMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         match e.get_patch_marker_details() {
             Some((id, _)) => Ok(Self::MarkerRecorded(id)),
             _ => Err(WFMachinesError::Nondeterminism(format!(
-                "Change machine cannot handle this event: {}",
-                e
+                "Change machine cannot handle this event: {e}"
             ))),
         }
     }
@@ -242,15 +238,14 @@ mod tests {
             common::v1::ActivityType,
             enums::v1::{CommandType, EventType},
             history::v1::{
-                history_event, ActivityTaskCompletedEventAttributes,
-                ActivityTaskScheduledEventAttributes, ActivityTaskStartedEventAttributes,
-                TimerFiredEventAttributes,
+                ActivityTaskCompletedEventAttributes, ActivityTaskScheduledEventAttributes,
+                ActivityTaskStartedEventAttributes, TimerFiredEventAttributes,
             },
         },
     };
 
     const MY_PATCH_ID: &str = "test_patch_id";
-    #[derive(Eq, PartialEq, Copy, Clone)]
+    #[derive(Eq, PartialEq, Copy, Clone, Debug)]
     enum MarkerType {
         Deprecated,
         NotDeprecated,
@@ -271,7 +266,11 @@ mod tests {
     /// EVENT_TYPE_WORKFLOW_TASK_STARTED
     /// EVENT_TYPE_WORKFLOW_TASK_COMPLETED
     /// EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
-    fn patch_marker_single_activity(marker_type: MarkerType) -> TestHistoryBuilder {
+    fn patch_marker_single_activity(
+        marker_type: MarkerType,
+        version: usize,
+        replay: bool,
+    ) -> TestHistoryBuilder {
         let mut t = TestHistoryBuilder::default();
         t.add_by_type(EventType::WorkflowExecutionStarted);
         t.add_full_wf_task();
@@ -281,41 +280,41 @@ mod tests {
             MarkerType::NoMarker => {}
         };
 
-        let scheduled_event_id = t.add_get_event_id(
-            EventType::ActivityTaskScheduled,
-            Some(
-                history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                    ActivityTaskScheduledEventAttributes {
-                        activity_id: "0".to_string(),
-                        activity_type: Some(ActivityType {
-                            name: "".to_string(),
-                        }),
-                        ..Default::default()
-                    },
-                ),
-            ),
-        );
-        let started_event_id = t.add_get_event_id(
-            EventType::ActivityTaskStarted,
-            Some(
-                history_event::Attributes::ActivityTaskStartedEventAttributes(
-                    ActivityTaskStartedEventAttributes {
-                        scheduled_event_id,
-                        ..Default::default()
-                    },
-                ),
-            ),
-        );
-        t.add(
-            EventType::ActivityTaskCompleted,
-            history_event::Attributes::ActivityTaskCompletedEventAttributes(
-                ActivityTaskCompletedEventAttributes {
-                    scheduled_event_id,
-                    started_event_id,
-                    ..Default::default()
-                },
-            ),
-        );
+        let activity_id = if replay {
+            match (marker_type, version) {
+                (_, 1) => "no_change",
+                (MarkerType::NotDeprecated, 2) => "had_change",
+                (MarkerType::Deprecated, 2) => "had_change",
+                (MarkerType::NoMarker, 2) => "no_change",
+                (_, 3) => "had_change",
+                (_, 4) => "had_change",
+                v => panic!("Nonsense marker / version combo {v:?}"),
+            }
+        } else {
+            // If the workflow isn't replaying (we're creating history here for a workflow which
+            // wasn't replaying at the time of scheduling the activity, and has done that, and now
+            // we're feeding back the history it would have produced) then it always has the change,
+            // except in v1.
+            if version > 1 {
+                "had_change"
+            } else {
+                "no_change"
+            }
+        };
+
+        let scheduled_event_id = t.add(ActivityTaskScheduledEventAttributes {
+            activity_id: activity_id.to_string(),
+            ..Default::default()
+        });
+        let started_event_id = t.add(ActivityTaskStartedEventAttributes {
+            scheduled_event_id,
+            ..Default::default()
+        });
+        t.add(ActivityTaskCompletedEventAttributes {
+            scheduled_event_id,
+            started_event_id,
+            ..Default::default()
+        });
         t.add_full_wf_task();
         t.add_workflow_execution_completed();
         t
@@ -388,7 +387,7 @@ mod tests {
             Ok(().into())
         });
 
-        let t = patch_marker_single_activity(marker_type);
+        let t = patch_marker_single_activity(marker_type, workflow_version, replaying);
         let histinfo = if replaying {
             t.get_full_history_info()
         } else {
@@ -426,7 +425,7 @@ mod tests {
         } else {
             // Feed more history
             wfm.new_history(
-                patch_marker_single_activity(marker_type)
+                patch_marker_single_activity(marker_type, wf_version, replaying)
                     .get_full_history_info()
                     .unwrap()
                     .into(),
@@ -520,7 +519,7 @@ mod tests {
             // and the history should have the has-change timer. v3 of course always has the change
             // regardless.
             wfm.new_history(
-                patch_marker_single_activity(marker_type)
+                patch_marker_single_activity(marker_type, wf_version, replaying)
                     .get_full_history_info()
                     .unwrap()
                     .into(),
@@ -569,118 +568,66 @@ mod tests {
         t.add_full_wf_task();
         if have_marker_in_hist {
             t.add_has_change_marker(MY_PATCH_ID, false);
-            let scheduled_event_id = t.add_get_event_id(
-                EventType::ActivityTaskScheduled,
-                Some(
-                    history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                        ActivityTaskScheduledEventAttributes {
-                            activity_id: "1".to_owned(),
-                            activity_type: Some(ActivityType {
-                                name: "".to_string(),
-                            }),
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            );
-            let started_event_id = t.add_get_event_id(
-                EventType::ActivityTaskStarted,
-                Some(
-                    history_event::Attributes::ActivityTaskStartedEventAttributes(
-                        ActivityTaskStartedEventAttributes {
-                            scheduled_event_id,
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            );
-            t.add(
-                EventType::ActivityTaskCompleted,
-                history_event::Attributes::ActivityTaskCompletedEventAttributes(
-                    ActivityTaskCompletedEventAttributes {
-                        scheduled_event_id,
-                        started_event_id,
-                        // TODO result: Some(Payloads { payloads: vec![Payload{ metadata: Default::default(), data: vec![] }] }),
-                        ..Default::default()
-                    },
-                ),
-            );
-            t.add_full_wf_task();
-            let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-            t.add(
-                EventType::TimerFired,
-                history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                    started_event_id: timer_started_event_id,
-                    timer_id: "1".to_owned(),
+            let scheduled_event_id = t.add(ActivityTaskScheduledEventAttributes {
+                activity_id: "1".to_owned(),
+                activity_type: Some(ActivityType {
+                    name: "".to_string(),
                 }),
-            );
+                ..Default::default()
+            });
+            let started_event_id = t.add(ActivityTaskStartedEventAttributes {
+                scheduled_event_id,
+                ..Default::default()
+            });
+            t.add(ActivityTaskCompletedEventAttributes {
+                scheduled_event_id,
+                started_event_id,
+                ..Default::default()
+            });
+            t.add_full_wf_task();
+            let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
+            t.add(TimerFiredEventAttributes {
+                started_event_id: timer_started_event_id,
+                timer_id: "1".to_owned(),
+            });
         } else {
-            let started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-            t.add(
-                EventType::TimerFired,
-                history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                    started_event_id,
-                    timer_id: "1".to_owned(),
-                }),
-            );
+            let started_event_id = t.add_by_type(EventType::TimerStarted);
+            t.add(TimerFiredEventAttributes {
+                started_event_id,
+                timer_id: "1".to_owned(),
+            });
             t.add_full_wf_task();
-            let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-            t.add(
-                EventType::TimerFired,
-                history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                    started_event_id: timer_started_event_id,
-                    timer_id: "2".to_owned(),
-                }),
-            );
+            let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
+            t.add(TimerFiredEventAttributes {
+                started_event_id: timer_started_event_id,
+                timer_id: "2".to_owned(),
+            });
         }
         t.add_full_wf_task();
 
         if have_marker_in_hist {
-            let scheduled_event_id = t.add_get_event_id(
-                EventType::ActivityTaskScheduled,
-                Some(
-                    history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                        ActivityTaskScheduledEventAttributes {
-                            activity_id: "2".to_string(),
-                            activity_type: Some(ActivityType {
-                                name: "".to_string(),
-                            }),
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            );
-            let started_event_id = t.add_get_event_id(
-                EventType::ActivityTaskStarted,
-                Some(
-                    history_event::Attributes::ActivityTaskStartedEventAttributes(
-                        ActivityTaskStartedEventAttributes {
-                            scheduled_event_id,
-                            ..Default::default()
-                        },
-                    ),
-                ),
-            );
-            t.add(
-                EventType::ActivityTaskCompleted,
-                history_event::Attributes::ActivityTaskCompletedEventAttributes(
-                    ActivityTaskCompletedEventAttributes {
-                        scheduled_event_id,
-                        started_event_id,
-                        // TODO result: Some(Payloads { payloads: vec![Payload{ metadata: Default::default(), data: vec![] }] }),
-                        ..Default::default()
-                    },
-                ),
-            );
-        } else {
-            let started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-            t.add(
-                EventType::TimerFired,
-                history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                    started_event_id,
-                    timer_id: "3".to_owned(),
+            let scheduled_event_id = t.add(ActivityTaskScheduledEventAttributes {
+                activity_id: "2".to_string(),
+                activity_type: Some(ActivityType {
+                    name: "".to_string(),
                 }),
-            );
+                ..Default::default()
+            });
+            let started_event_id = t.add(ActivityTaskStartedEventAttributes {
+                scheduled_event_id,
+                ..Default::default()
+            });
+            t.add(ActivityTaskCompletedEventAttributes {
+                scheduled_event_id,
+                started_event_id,
+                ..Default::default()
+            });
+        } else {
+            let started_event_id = t.add_by_type(EventType::TimerStarted);
+            t.add(TimerFiredEventAttributes {
+                started_event_id,
+                timer_id: "3".to_owned(),
+            });
         }
         t.add_full_wf_task();
         t.add_workflow_execution_completed();

data/bridge/sdk-core/core/src/worker/workflow/machines/signal_external_state_machine.rs

@@ -1,7 +1,8 @@
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
+use crate::worker::workflow::machines::HistEventData;
 use rustfsm::{fsm, MachineError, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
@@ -183,10 +184,11 @@ impl TryFrom<CommandType> for SignalExternalMachineEvents {
         })
     }
 }
-impl TryFrom<HistoryEvent> for SignalExternalMachineEvents {
+impl TryFrom<HistEventData> for SignalExternalMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::ExternalWorkflowExecutionSignaled => Self::ExternalWorkflowExecutionSignaled,
             EventType::SignalExternalWorkflowExecutionInitiated => {
@@ -202,15 +204,13 @@ impl TryFrom<HistoryEvent> for SignalExternalMachineEvents {
                     Self::SignalExternalWorkflowExecutionFailed(attrs.cause())
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Signal workflow failed attributes were unset: {}",
-                        e
+                        "Signal workflow failed attributes were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Signal external WF machine does not handle this event: {}",
-                    e
+                    "Signal external WF machine does not handle this event: {e}"
                 )))
             }
         })
@@ -242,7 +242,7 @@ impl WFMachinesAdapter for SignalExternalMachine {
                     seq: self.shared_state.seq,
                     // TODO: Create new failure type upstream for this
                     failure: Some(Failure {
-                        message: format!("Unable to signal external workflow because {}", reason),
+                        message: format!("Unable to signal external workflow because {reason}"),
                         failure_info: Some(FailureInfo::ApplicationFailureInfo(
                             ApplicationFailureInfo {
                                 r#type: f.to_string(),
@@ -268,10 +268,6 @@ impl WFMachinesAdapter for SignalExternalMachine {
                 | EventType::SignalExternalWorkflowExecutionFailed
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::SignalExternalWorkflow
-    }
 }
 
 impl Cancellable for SignalExternalMachine {

data/bridge/sdk-core/core/src/worker/workflow/machines/timer_state_machine.rs

@@ -1,9 +1,10 @@
 #![allow(clippy::large_enum_variant)]
 
 use super::{
-    workflow_machines::{MachineResponse, WFMachinesError},
-    Cancellable, EventInfo, MachineKind, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter,
 };
+use crate::worker::workflow::{machines::HistEventData, WFMachinesError};
 use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
@@ -93,10 +94,11 @@ impl TimerMachine {
     }
 }
 
-impl TryFrom<HistoryEvent> for TimerMachineEvents {
+impl TryFrom<HistEventData> for TimerMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::TimerStarted => Self::TimerStarted(e.event_id),
             EventType::TimerCanceled => Self::TimerCanceled,
@@ -107,15 +109,13 @@ impl TryFrom<HistoryEvent> for TimerMachineEvents {
                     Self::TimerFired(attrs)
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Timer fired attribs were unset: {}",
-                        e
+                        "Timer fired attribs were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Timer machine does not handle this event: {}",
-                    e
+                    "Timer machine does not handle this event: {e}"
                 )))
             }
         })
@@ -246,10 +246,6 @@ impl WFMachinesAdapter for TimerMachine {
             EventType::TimerStarted | EventType::TimerCanceled | EventType::TimerFired
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::Timer
-    }
 }
 
 impl Cancellable for TimerMachine {
@@ -260,7 +256,7 @@ impl Cancellable for TimerMachine {
                     vec![MachineResponse::IssueNewCommand(cmd)]
                 }
                 None => vec![],
-                x => panic!("Invalid cancel event response {:?}", x),
+                x => panic!("Invalid cancel event response {x:?}"),
             },
         )
     }

data/bridge/sdk-core/core/src/worker/workflow/machines/transition_coverage.rs

@@ -75,8 +75,10 @@ mod machine_coverage_report {
         complete_workflow_state_machine::CompleteWorkflowMachine,
         continue_as_new_workflow_state_machine::ContinueAsNewWorkflowMachine,
         fail_workflow_state_machine::FailWorkflowMachine,
-        local_activity_state_machine::LocalActivityMachine, patch_state_machine::PatchMachine,
-        signal_external_state_machine::SignalExternalMachine, timer_state_machine::TimerMachine,
+        local_activity_state_machine::LocalActivityMachine,
+        modify_workflow_properties_state_machine::ModifyWorkflowPropertiesMachine,
+        patch_state_machine::PatchMachine, signal_external_state_machine::SignalExternalMachine,
+        timer_state_machine::TimerMachine,
         upsert_search_attributes_state_machine::UpsertSearchAttributesMachine,
         workflow_task_state_machine::WorkflowTaskMachine,
     };
@@ -115,6 +117,7 @@ mod machine_coverage_report {
         let mut cancel_ext = CancelExternalMachine::visualizer().to_owned();
         let mut la_mach = LocalActivityMachine::visualizer().to_owned();
         let mut upsert_search_attr = UpsertSearchAttributesMachine::visualizer().to_owned();
+        let mut modify_wf_props = ModifyWorkflowPropertiesMachine::visualizer().to_owned();
 
         // This isn't at all efficient but doesn't need to be.
         // Replace transitions in the vizzes with green color if they are covered.
@@ -138,7 +141,10 @@ mod machine_coverage_report {
                 m @ "UpsertSearchAttributesMachine" => {
                     cover_transitions(m, &mut upsert_search_attr, coverage)
                 }
-                m => panic!("Unknown machine {}", m),
+                m @ "ModifyWorkflowPropertiesMachine" => {
+                    cover_transitions(m, &mut modify_wf_props, coverage)
+                }
+                m => panic!("Unknown machine {m}"),
             }
         }
     }
@@ -162,7 +168,7 @@ mod machine_coverage_report {
         let mut d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         d.push("machine_coverage");
         std::fs::create_dir_all(&d).unwrap();
-        d.push(format!("{}_Coverage.puml", machine));
+        d.push(format!("{machine}_Coverage.puml"));
         let mut file = File::create(d).unwrap();
         file.write_all(viz.as_bytes()).unwrap();
     }

data/bridge/sdk-core/core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs

@@ -1,8 +1,8 @@
-use super::{
-    workflow_machines::{MachineResponse, WFMachinesError},
-    NewMachineWithCommand,
+use super::{workflow_machines::MachineResponse, NewMachineWithCommand};
+use crate::worker::workflow::{
+    machines::{Cancellable, EventInfo, HistEventData, WFMachinesAdapter},
+    WFMachinesError,
 };
-use crate::worker::workflow::machines::{Cancellable, EventInfo, MachineKind, WFMachinesAdapter};
 use rustfsm::{fsm, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
@@ -102,10 +102,6 @@ impl WFMachinesAdapter for UpsertSearchAttributesMachine {
             EventType::UpsertWorkflowSearchAttributes
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::UpsertSearchAttributes
-    }
 }
 
 impl Cancellable for UpsertSearchAttributesMachine {}
@@ -113,10 +109,11 @@ impl Cancellable for UpsertSearchAttributesMachine {}
 // Converts the generic history event with type EventType::UpsertWorkflowSearchAttributes into the
 // UpsertSearchAttributesMachine-specific event type
 // UpsertSearchAttributesMachineEvents::CommandRecorded.
-impl TryFrom<HistoryEvent> for UpsertSearchAttributesMachineEvents {
+impl TryFrom<HistEventData> for UpsertSearchAttributesMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         match e.event_type() {
             EventType::UpsertWorkflowSearchAttributes => {
                 Ok(UpsertSearchAttributesMachineEvents::CommandRecorded)
@@ -233,7 +230,13 @@ mod tests {
             ..Default::default()
         };
         assert!(sm.matches_event(&recorded_history_event));
-        let cmd_recorded_sm_event = recorded_history_event.try_into().unwrap();
+        let cmd_recorded_sm_event = HistEventData {
+            event: recorded_history_event,
+            replaying: false,
+            current_task_is_last_in_history: true,
+        }
+        .try_into()
+        .unwrap();
 
         OnEventWrapper::on_event_mut(&mut sm, cmd_scheduled_sm_event)
             .expect("CommandScheduled should transition Created -> CommandIssued");

data/bridge/sdk-core/core/src/worker/workflow/machines/workflow_machines/local_acts.rs

@@ -1,15 +1,13 @@
-use super::super::{local_activity_state_machine::ResolveDat, WFMachinesError};
+use super::super::local_activity_state_machine::ResolveDat;
 use crate::{
-    protosext::{HistoryEventExt, ValidScheduleLA},
+    protosext::{CompleteLocalActivityData, ValidScheduleLA},
     worker::{ExecutingLAId, LocalActRequest, NewLocalAct},
 };
 use std::{
     collections::{HashMap, HashSet},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::temporal::api::{
-    common::v1::WorkflowExecution, history::v1::HistoryEvent,
-};
+use temporal_sdk_core_protos::temporal::api::common::v1::WorkflowExecution;
 
 #[derive(Default)]
 pub(super) struct LocalActivityData {
@@ -53,7 +51,7 @@ impl LocalActivityData {
             .chain(self.new_requests.drain(..).map(|sa| {
                 self.executing.insert(sa.seq);
                 LocalActRequest::New(NewLocalAct {
-                    schedule_time: sa.original_schedule_time.unwrap_or_else(SystemTime::now),
+                    schedule_time: SystemTime::now(),
                     schedule_cmd: sa,
                     workflow_type: wf_type.to_string(),
                     workflow_exec_info: WorkflowExecution {
@@ -70,17 +68,8 @@ impl LocalActivityData {
         self.executing.len() + self.new_requests.len()
     }
 
-    pub(super) fn process_peekahead_marker(&mut self, e: &HistoryEvent) -> super::Result<()> {
-        if let Some(la_dat) = e.clone().into_local_activity_marker_details() {
-            self.preresolutions
-                .insert(la_dat.marker_dat.seq, la_dat.into());
-        } else {
-            return Err(WFMachinesError::Fatal(format!(
-                "Local activity marker was unparsable: {:?}",
-                e
-            )));
-        }
-        Ok(())
+    pub(super) fn insert_peeked_marker(&mut self, dat: CompleteLocalActivityData) {
+        self.preresolutions.insert(dat.marker_dat.seq, dat.into());
     }
 
     pub(super) fn take_preresolution(&mut self, seq: u32) -> Option<ResolveDat> {