@temporalio/core-bridge 1.5.2 → 1.6.0

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

@@ -184,8 +184,7 @@ impl TryFrom<HistoryEvent> for ActivityMachineEvents {
                     Self::ActivityTaskCompleted(attrs)
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Activity completion attributes were unset: {}",
-                        e
+                        "Activity completion attributes were unset: {e}"
                     )));
                 }
             }
@@ -196,8 +195,7 @@ impl TryFrom<HistoryEvent> for ActivityMachineEvents {
                     Self::ActivityTaskFailed(attrs)
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Activity failure attributes were unset: {}",
-                        e
+                        "Activity failure attributes were unset: {e}"
                     )));
                 }
             }
@@ -208,8 +206,7 @@ impl TryFrom<HistoryEvent> for ActivityMachineEvents {
                     Self::ActivityTaskTimedOut(attrs)
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Activity timeout attributes were unset: {}",
-                        e
+                        "Activity timeout attributes were unset: {e}"
                     )));
                 }
             }
@@ -221,15 +218,13 @@ impl TryFrom<HistoryEvent> for ActivityMachineEvents {
                     Self::ActivityTaskCanceled(attrs)
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Activity cancellation attributes were unset: {}",
-                        e
+                        "Activity cancellation attributes were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Activity machine does not handle this event: {}",
-                    e
+                    "Activity machine does not handle this event: {e}"
                 )))
             }
         })
@@ -339,7 +334,7 @@ impl Cancellable for ActivityMachine {
                         )
                         .into()]
                 }
-                x => panic!("Invalid cancel event response {:?}", x),
+                x => panic!("Invalid cancel event response {x:?}"),
             })
             .collect();
         Ok(res)
@@ -648,8 +643,7 @@ impl Canceled {
         } else {
             TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
                 "Non-Abandon cancel mode activities cannot be started after being cancelled. \
-                 Seq: {:?}",
-                seq_num
+                 Seq: {seq_num:?}"
             )))
         }
     }
@@ -663,8 +657,7 @@ impl Canceled {
             TransitionResult::default()
         } else {
             TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
-                "Non-Abandon cancel mode activities cannot be completed after being cancelled: {:?}",
-                attrs
+                "Non-Abandon cancel mode activities cannot be completed after being cancelled: {attrs:?}"
             )))
         }
     }
@@ -769,8 +762,7 @@ fn convert_payloads(
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
         WFMachinesError::Fatal(format!(
-            "Not exactly one payload in activity result ({}) for event: {:?}",
-            pe, event_info
+            "Not exactly one payload in activity result ({pe}) for event: {event_info:?}"
         ))
     })
 }

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

@@ -161,15 +161,13 @@ impl TryFrom<HistoryEvent> for CancelExternalMachineEvents {
                     Self::RequestCancelExternalWorkflowExecutionFailed(attrs.cause())
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Cancelworkflow failed attributes were unset: {}",
-                        e
+                        "Cancelworkflow failed attributes were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Cancel external WF machine does not handle this event: {}",
-                    e
+                    "Cancel external WF machine does not handle this event: {e}"
                 )))
             }
         })
@@ -199,7 +197,7 @@ impl WFMachinesAdapter for CancelExternalMachine {
                 vec![ResolveRequestCancelExternalWorkflow {
                     seq: self.shared_state.seq,
                     failure: Some(Failure {
-                        message: format!("Unable to cancel external workflow because {}", reason),
+                        message: format!("Unable to cancel external workflow because {reason}"),
                         failure_info: Some(FailureInfo::ApplicationFailureInfo(
                             ApplicationFailureInfo {
                                 r#type: f.to_string(),

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

@@ -80,8 +80,7 @@ impl TryFrom<HistoryEvent> for CancelWorkflowMachineEvents {
             Some(EventType::WorkflowExecutionCanceled) => Self::WorkflowExecutionCanceled,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Cancel workflow machine does not handle this event: {}",
-                    e
+                    "Cancel workflow machine does not handle this event: {e}"
                 )))
             }
         })

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

@@ -471,8 +471,7 @@ impl TryFrom<HistoryEvent> for ChildWorkflowMachineEvents {
             }
             _ => {
                 return Err(WFMachinesError::Fatal(format!(
-                    "Child workflow machine does not handle this event: {:?}",
-                    e
+                    "Child workflow machine does not handle this event: {e:?}"
                 )))
             }
         })
@@ -612,7 +611,7 @@ impl Cancellable for ChildWorkflowMachine {
                 | c @ ChildWorkflowCommand::IssueCancelAfterStarted { .. } => {
                     self.adapt_response(c, None)
                 }
-                x => panic!("Invalid cancel event response {:?}", x),
+                x => panic!("Invalid cancel event response {x:?}"),
             })
             .collect::<Result<Vec<_>, _>>()?
             .into_iter()
@@ -650,8 +649,7 @@ fn convert_payloads(
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
         WFMachinesError::Fatal(format!(
-            "Not exactly one payload in child workflow result ({}) for event: {:?}",
-            pe, event_info
+            "Not exactly one payload in child workflow result ({pe}) for event: {event_info:?}"
         ))
     })
 }

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

@@ -69,8 +69,7 @@ impl TryFrom<HistoryEvent> for CompleteWorkflowMachineEvents {
             EventType::WorkflowExecutionCompleted => Self::WorkflowExecutionCompleted,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Complete workflow machine does not handle this event: {}",
-                    e
+                    "Complete workflow machine does not handle this event: {e}"
                 )))
             }
         })

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

@@ -77,8 +77,7 @@ impl TryFrom<HistoryEvent> for ContinueAsNewWorkflowMachineEvents {
             EventType::WorkflowExecutionContinuedAsNew => Self::WorkflowExecutionContinuedAsNew,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Continue as new workflow machine does not handle this event: {}",
-                    e
+                    "Continue as new workflow machine does not handle this event: {e}"
                 )))
             }
         })

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

@@ -93,8 +93,7 @@ impl TryFrom<HistoryEvent> for FailWorkflowMachineEvents {
             EventType::WorkflowExecutionFailed => Self::WorkflowExecutionFailed,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Fail workflow machine does not handle this event: {}",
-                    e
+                    "Fail workflow machine does not handle this event: {e}"
                 )))
             }
         })

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

@@ -59,15 +59,17 @@ fsm! {
       --> MarkerCommandRecorded;
 
     // Replay path ================================================================================
-    // LAs on the replay path should never have handle result explicitly called on them, but do need
-    // to eventually see the marker
+    // LAs on the replay path always need to eventually see the marker
     WaitingMarkerEvent --(MarkerRecorded(CompleteLocalActivityData), shared on_marker_recorded)
       --> MarkerCommandRecorded;
     // If we are told to cancel while waiting for the marker, we still need to wait for the marker.
-    WaitingMarkerEvent --(Cancel, on_cancel_requested) --> WaitingMarkerEventCancelled;
+    WaitingMarkerEvent --(Cancel, on_cancel_requested) --> WaitingMarkerEvent;
+    // Because there could be non-heartbeat WFTs (ex: signals being received) between scheduling
+    // the LA and the marker being recorded, peekahead might not always resolve the LA *before*
+    // scheduling it. This transition accounts for that.
+    WaitingMarkerEvent --(HandleKnownResult(ResolveDat), on_handle_result) --> WaitingMarkerEvent;
     WaitingMarkerEvent --(NoWaitCancel(ActivityCancellationType),
-                          on_no_wait_cancel) --> WaitingMarkerEventCancelled;
-    WaitingMarkerEventCancelled --(HandleResult(ResolveDat), on_handle_result) --> WaitingMarkerEvent;
+                          on_no_wait_cancel) --> WaitingMarkerEvent;
 
     // It is entirely possible to have started the LA while replaying, only to find that we have
     // reached a new WFT and there still was no marker. In such cases we need to execute the LA.
@@ -135,7 +137,7 @@ impl From<CompleteLocalActivityData> for ResolveDat {
 /// must resolve before we send a record marker command. A [MachineResponse] may be produced,
 /// to queue the LA for execution if it needs to be.
 pub(super) fn new_local_activity(
-    attrs: ValidScheduleLA,
+    mut attrs: ValidScheduleLA,
     replaying_when_invoked: bool,
     maybe_pre_resolved: Option<ResolveDat>,
     wf_time: Option<SystemTime>,
@@ -155,6 +157,11 @@ pub(super) fn new_local_activity(
         Executing {}.into()
     };
 
+    // If the scheduled LA doesn't already have an "original" schedule time, assign one.
+    attrs
+        .original_schedule_time
+        .get_or_insert(SystemTime::now());
+
     let mut machine = LocalActivityMachine {
         state: initial_state,
         shared_state: SharedState {
@@ -197,6 +204,12 @@ impl LocalActivityMachine {
         }
     }
 
+    /// Returns true if the machine will willingly accept data from a marker in its current state.
+    /// IE: Calling [Self::try_resolve_with_dat] makes sense.
+    pub(super) fn will_accept_resolve_marker(&self) -> bool {
+        matches!(self.state, LocalActivityMachineState::WaitingMarkerEvent(_))
+    }
+
     /// Must be called if the workflow encounters a non-replay workflow task
     pub(super) fn encountered_non_replay_wft(
         &mut self,
@@ -235,28 +248,45 @@ impl LocalActivityMachine {
         backoff: Option<prost_types::Duration>,
         original_schedule_time: Option<SystemTime>,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        self.try_resolve_with_dat(ResolveDat {
-            result,
-            complete_time: self.shared_state.wf_time_when_started.map(|t| t + runtime),
-            attempt,
-            backoff,
-            original_schedule_time,
-        })
+        self._try_resolve(
+            ResolveDat {
+                result,
+                complete_time: self.shared_state.wf_time_when_started.map(|t| t + runtime),
+                attempt,
+                backoff,
+                original_schedule_time,
+            },
+            false,
+        )
     }
+
     /// Attempt to resolve the local activity with already known data, ex pre-resolved data
     pub(super) fn try_resolve_with_dat(
         &mut self,
         dat: ResolveDat,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
-        let res = OnEventWrapper::on_event_mut(self, LocalActivityMachineEvents::HandleResult(dat))
-            .map_err(|e| match e {
-                MachineError::InvalidTransition => WFMachinesError::Fatal(format!(
-                    "Invalid transition resolving local activity (seq {}) in {}",
-                    self.shared_state.attrs.seq,
-                    self.state(),
-                )),
-                MachineError::Underlying(e) => e,
-            })?;
+        self._try_resolve(dat, true)
+    }
+
+    fn _try_resolve(
+        &mut self,
+        dat: ResolveDat,
+        from_marker: bool,
+    ) -> Result<Vec<MachineResponse>, WFMachinesError> {
+        let evt = if from_marker {
+            LocalActivityMachineEvents::HandleKnownResult(dat)
+        } else {
+            LocalActivityMachineEvents::HandleResult(dat)
+        };
+        let res = OnEventWrapper::on_event_mut(self, evt).map_err(|e| match e {
+            MachineError::InvalidTransition => WFMachinesError::Fatal(format!(
+                "Invalid transition resolving local activity (seq {}, from marker: {}) in {}",
+                self.shared_state.attrs.seq,
+                from_marker,
+                self.state(),
+            )),
+            MachineError::Underlying(e) => e,
+        })?;
 
         Ok(res
             .into_iter()
@@ -505,6 +535,17 @@ impl WaitingMarkerEvent {
             })
         )
     }
+    fn on_handle_result(
+        self,
+        dat: ResolveDat,
+    ) -> LocalActivityMachineTransition<WaitingMarkerEvent> {
+        TransitionResult::ok(
+            [LocalActivityCommand::Resolved(dat)],
+            WaitingMarkerEvent {
+                already_resolved: true,
+            },
+        )
+    }
     pub(super) fn on_started_non_replay_wft(
         self,
         mut dat: SharedState,
@@ -520,41 +561,22 @@ impl WaitingMarkerEvent {
         )
     }
 
-    fn on_cancel_requested(self) -> LocalActivityMachineTransition<WaitingMarkerEventCancelled> {
+    fn on_cancel_requested(self) -> LocalActivityMachineTransition<WaitingMarkerEvent> {
         // We still "request a cancel" even though we know the local activity should not be running
         // because the data might be in the pre-resolved list.
-        TransitionResult::ok(
-            [LocalActivityCommand::RequestCancel],
-            WaitingMarkerEventCancelled {},
-        )
+        TransitionResult::ok([LocalActivityCommand::RequestCancel], self)
     }
 
     fn on_no_wait_cancel(
         self,
         _: ActivityCancellationType,
-    ) -> LocalActivityMachineTransition<WaitingMarkerEventCancelled> {
+    ) -> LocalActivityMachineTransition<WaitingMarkerEvent> {
         // Markers are always recorded when cancelling, so this is the same as a normal cancel on
         // the replay path
         self.on_cancel_requested()
     }
 }
 
-#[derive(Default, Clone)]
-pub(super) struct WaitingMarkerEventCancelled {}
-impl WaitingMarkerEventCancelled {
-    fn on_handle_result(
-        self,
-        dat: ResolveDat,
-    ) -> LocalActivityMachineTransition<WaitingMarkerEvent> {
-        TransitionResult::ok(
-            [LocalActivityCommand::Resolved(dat)],
-            WaitingMarkerEvent {
-                already_resolved: true,
-            },
-        )
-    }
-}
-
 #[derive(Default, Clone)]
 pub(super) struct WaitingMarkerEventPreResolved {}
 impl WaitingMarkerEventPreResolved {
@@ -733,8 +755,7 @@ impl TryFrom<HistoryEvent> for LocalActivityMachineEvents {
     fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
         if e.event_type() != EventType::MarkerRecorded {
             return Err(WFMachinesError::Nondeterminism(format!(
-                "Local activity machine cannot handle this event: {}",
-                e
+                "Local activity machine cannot handle this event: {e}"
             )));
         }
 
@@ -1403,8 +1424,9 @@ mod tests {
             assert_eq!(commands[1].command_type, CommandType::StartTimer as i32);
         }
 
-        if replay {
-            wfm.get_next_activation().await.unwrap()
+        let commands = if replay {
+            wfm.get_next_activation().await.unwrap();
+            wfm.get_server_commands().commands
         } else {
             // On non replay, there's an additional activation, because completing with the cancel
             // wants to wake up the workflow to see if resolving the LA as cancelled did anything.
@@ -1429,11 +1451,11 @@ mod tests {
 
             wfm.new_history(t.get_history_info(3).unwrap().into())
                 .await
-                .unwrap()
+                .unwrap();
+            wfm.get_next_activation().await.unwrap();
+            wfm.get_server_commands().commands
         };
 
-        wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,

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

@@ -18,9 +18,9 @@ mod workflow_task_state_machine;
 #[cfg(test)]
 mod transition_coverage;
 
-pub(crate) use workflow_machines::{WFMachinesError, WorkflowMachines};
+pub(crate) use workflow_machines::WorkflowMachines;
 
-use crate::telemetry::VecDisplayer;
+use crate::{telemetry::VecDisplayer, worker::workflow::WFMachinesError};
 use activity_state_machine::ActivityMachine;
 use cancel_external_state_machine::CancelExternalMachine;
 use cancel_workflow_state_machine::CancelWorkflowMachine;
@@ -217,7 +217,7 @@ where
     <SM as StateMachine>::State: Display,
 {
     if !commands.is_empty() {
-        debug!(commands=%commands.display(), state=%machine.state(),
+        trace!(commands=%commands.display(), state=%machine.state(),
                machine_name=%TemporalStateMachine::name(machine), "Machine produced commands");
     }
     let mut machine_responses = vec![];

package/sdk-core/core/src/worker/workflow/machines/modify_workflow_properties_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, WFMachinesAdapter},
+    WFMachinesError,
 };
-use crate::worker::workflow::machines::{Cancellable, EventInfo, WFMachinesAdapter};
 use rustfsm::{fsm, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::ModifyWorkflowProperties,

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

@@ -208,8 +208,7 @@ impl TryFrom<HistoryEvent> for PatchMachineEvents {
         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}"
             ))),
         }
     }

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

@@ -202,15 +202,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 +240,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(),

package/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, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter,
 };
+use crate::worker::workflow::WFMachinesError;
 use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
@@ -107,15 +108,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}"
                 )))
             }
         })
@@ -256,7 +255,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:?}"),
             },
         )
     }

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

@@ -144,7 +144,7 @@ mod machine_coverage_report {
                 m @ "ModifyWorkflowPropertiesMachine" => {
                     cover_transitions(m, &mut modify_wf_props, coverage)
                 }
-                m => panic!("Unknown machine {}", m),
+                m => panic!("Unknown machine {m}"),
             }
         }
     }
@@ -168,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();
     }

package/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, WFMachinesAdapter},
+    WFMachinesError,
 };
-use crate::worker::workflow::machines::{Cancellable, EventInfo, WFMachinesAdapter};
 use rustfsm::{fsm, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,

package/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> {