@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/core-c-bridge/src/worker.rs

@@ -2,9 +2,11 @@ use crate::{
     ByteArray, ByteArrayRef, ByteArrayRefArray, UserDataHandle, client::Client, runtime::Runtime,
 };
 use anyhow::{Context, bail};
+use crossbeam_utils::atomic::AtomicCell;
 use prost::Message;
 use std::{
     collections::{HashMap, HashSet},
+    num::NonZero,
     sync::Arc,
     time::Duration,
 };
@@ -22,14 +24,14 @@ use temporal_sdk_core_api::{
 };
 use temporal_sdk_core_protos::{
     coresdk::{
-        ActivityHeartbeat, ActivityTaskCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
         workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::history::v1::History,
 };
 use tokio::sync::{
+    Notify,
     mpsc::{Sender, channel},
-    oneshot,
 };
 use tokio_stream::wrappers::ReceiverStream;
 
@@ -51,6 +53,7 @@ pub struct WorkerOptions {
     pub workflow_task_poller_behavior: PollerBehavior,
     pub nonsticky_to_sticky_poll_ratio: f32,
     pub activity_task_poller_behavior: PollerBehavior,
+    pub nexus_task_poller_behavior: PollerBehavior,
     pub nondeterminism_as_workflow_fail: bool,
     pub nondeterminism_as_workflow_fail_for_types: ByteArrayRefArray,
 }
@@ -130,6 +133,7 @@ pub struct TunerHolder {
     pub workflow_slot_supplier: SlotSupplier,
     pub activity_slot_supplier: SlotSupplier,
     pub local_activity_slot_supplier: SlotSupplier,
+    pub nexus_task_slot_supplier: SlotSupplier,
 }
 
 #[repr(C)]
@@ -163,14 +167,24 @@ struct CustomSlotSupplier<SK> {
 unsafe impl<SK> Send for CustomSlotSupplier<SK> {}
 unsafe impl<SK> Sync for CustomSlotSupplier<SK> {}
 
-pub type CustomReserveSlotCallback =
-    unsafe extern "C" fn(ctx: *const SlotReserveCtx, sender: *mut libc::c_void);
-pub type CustomCancelReserveCallback = unsafe extern "C" fn(token_source: *mut libc::c_void);
-/// Must return C#-tracked id for the permit. A zero value means no permit was reserved.
-pub type CustomTryReserveSlotCallback = unsafe extern "C" fn(ctx: *const SlotReserveCtx) -> usize;
-pub type CustomMarkSlotUsedCallback = unsafe extern "C" fn(ctx: *const SlotMarkUsedCtx);
-pub type CustomReleaseSlotCallback = unsafe extern "C" fn(ctx: *const SlotReleaseCtx);
-pub type CustomSlotImplFreeCallback =
+pub type CustomSlotSupplierReserveCallback = unsafe extern "C" fn(
+    ctx: *const SlotReserveCtx,
+    completion_ctx: *const SlotReserveCompletionCtx,
+    user_data: *mut libc::c_void,
+);
+pub type CustomSlotSupplierCancelReserveCallback = unsafe extern "C" fn(
+    completion_ctx: *const SlotReserveCompletionCtx,
+    user_data: *mut libc::c_void,
+);
+pub type CustomSlotSupplierTryReserveCallback =
+    unsafe extern "C" fn(ctx: *const SlotReserveCtx, user_data: *mut libc::c_void) -> usize;
+pub type CustomSlotSupplierMarkUsedCallback =
+    unsafe extern "C" fn(ctx: *const SlotMarkUsedCtx, user_data: *mut libc::c_void);
+pub type CustomSlotSupplierReleaseCallback =
+    unsafe extern "C" fn(ctx: *const SlotReleaseCtx, user_data: *mut libc::c_void);
+pub type CustomSlotSupplierAvailableSlotsCallback =
+    Option<unsafe extern "C" fn(available_slots: *mut usize, user_data: *mut libc::c_void) -> bool>;
+pub type CustomSlotSupplierFreeCallback =
     unsafe extern "C" fn(userimpl: *const CustomSlotSupplierCallbacks);
 
 #[repr(C)]
@@ -179,12 +193,46 @@ pub struct CustomSlotSupplierCallbacksImpl(pub *const CustomSlotSupplierCallback
 
 #[repr(C)]
 pub struct CustomSlotSupplierCallbacks {
-    pub reserve: CustomReserveSlotCallback,
-    pub cancel_reserve: CustomCancelReserveCallback,
-    pub try_reserve: CustomTryReserveSlotCallback,
-    pub mark_used: CustomMarkSlotUsedCallback,
-    pub release: CustomReleaseSlotCallback,
-    pub free: CustomSlotImplFreeCallback,
+    /// Called to initiate asynchronous slot reservation. `ctx` contains information about
+    /// reservation request. The pointer is only valid for the duration of the function call; the
+    /// implementation should copy the data out of it for later use, and return as soon as possible.
+    ///
+    /// When slot is reserved, the implementation should call [`temporal_core_complete_async_reserve`]
+    /// with the same `completion_ctx` as passed to this function. Reservation cannot be cancelled
+    /// by Lang, but it can be cancelled by Core through [`cancel_reserve`](Self::cancel_reserve)
+    /// callback. If reservation was cancelled, [`temporal_core_complete_async_cancel_reserve`]
+    /// should be called instead.
+    ///
+    /// Slot reservation cannot error. The implementation should recover from errors and keep trying
+    /// to reserve a slot until it eventually succeeds, or until reservation is cancelled by Core.
+    pub reserve: CustomSlotSupplierReserveCallback,
+    /// Called to cancel slot reservation. `completion_ctx` specifies which reservation is being
+    /// cancelled; the matching [`reserve`](Self::reserve) call was made with the same `completion_ctx`.
+    /// After cancellation, the implementation should call [`temporal_core_complete_async_cancel_reserve`]
+    /// with the same `completion_ctx`. Calling [`temporal_core_complete_async_reserve`] is not
+    /// needed after cancellation.
+    pub cancel_reserve: CustomSlotSupplierCancelReserveCallback,
+    /// Called to try an immediate slot reservation. The callback should return 0 if immediate
+    /// reservation is not currently possible, or permit ID if reservation was successful. Permit ID
+    /// is arbitrary, but must be unique among live reservations as it's later used for [`mark_used`](Self::mark_used)
+    /// and [`release`](Self::release) callbacks.
+    pub try_reserve: CustomSlotSupplierTryReserveCallback,
+    /// Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporal_sdk_core_api::worker::SlotSupplier)
+    /// trait for details.
+    pub mark_used: CustomSlotSupplierMarkUsedCallback,
+    /// Called to free a previously reserved slot.
+    pub release: CustomSlotSupplierReleaseCallback,
+    /// Called to retrieve the number of available slots if known. If the implementation knows how
+    /// many slots are available at the moment, it should set the value behind the `available_slots`
+    /// pointer and return true. If that number is unknown, it should return false.
+    ///
+    /// This function pointer can be set to null. It will be treated as if the number of available
+    /// slots is never known.
+    pub available_slots: CustomSlotSupplierAvailableSlotsCallback,
+    /// Called when the slot supplier is being dropped. All resources should be freed.
+    pub free: CustomSlotSupplierFreeCallback,
+    /// Passed as an extra argument to the callbacks.
+    pub user_data: *mut libc::c_void,
 }
 
 impl CustomSlotSupplierCallbacksImpl {
@@ -221,8 +269,6 @@ pub struct SlotReserveCtx {
     pub worker_identity: ByteArrayRef,
     pub worker_build_id: ByteArrayRef,
     pub is_sticky: bool,
-    // The C# side will store a pointer here to the cancellation token source
-    pub token_src: *mut libc::c_void,
 }
 unsafe impl Send for SlotReserveCtx {}
 
@@ -247,31 +293,67 @@ pub enum SlotInfo {
 #[repr(C)]
 pub struct SlotMarkUsedCtx {
     pub slot_info: SlotInfo,
-    /// C# id for the slot permit.
+    /// Lang-issued permit ID.
     pub slot_permit: usize,
 }
 
 #[repr(C)]
 pub struct SlotReleaseCtx {
     pub slot_info: *const SlotInfo,
-    /// C# id for the slot permit.
+    /// Lang-issued permit ID.
     pub slot_permit: usize,
 }
 
-struct CancelReserveGuard {
-    token_src: *mut libc::c_void,
-    callback: CustomCancelReserveCallback,
+pub struct SlotReserveCompletionCtx {
+    state: AtomicCell<SlotReserveOperationState>,
+    notify: Notify,
 }
-impl Drop for CancelReserveGuard {
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SlotReserveOperationState {
+    Pending,
+    Cancelled,
+    Completed(NonZero<usize>),
+}
+
+struct CancelReserveGuard<'a, SK: SlotKind + Send + Sync> {
+    slot_supplier: &'a CustomSlotSupplier<SK>,
+    completion_ctx: Arc<SlotReserveCompletionCtx>,
+    completed: bool,
+}
+
+impl<'a, SK: SlotKind + Send + Sync> Drop for CancelReserveGuard<'a, SK> {
     fn drop(&mut self) {
-        if !self.token_src.is_null() {
+        // do not cancel if already completed
+        if !self.completed {
+            let state = self
+                .completion_ctx
+                .state
+                .swap(SlotReserveOperationState::Cancelled);
             unsafe {
-                (self.callback)(self.token_src);
+                let inner = &*self.slot_supplier.inner.0;
+                match state {
+                    SlotReserveOperationState::Cancelled => {
+                        // This situation should never happen, but on the other hand, it doesn't
+                        // result in any unsafety, deadlock or leak. It's safe to ignore it, but in
+                        // debug builds we'd like to know it happened.
+                        debug_assert!(false, "slot reservation cancelled twice")
+                    }
+                    SlotReserveOperationState::Pending => {
+                        (inner.cancel_reserve)(Arc::as_ptr(&self.completion_ctx), inner.user_data)
+                    }
+                    SlotReserveOperationState::Completed(slot_permit) => (inner.release)(
+                        &SlotReleaseCtx {
+                            slot_info: std::ptr::null(),
+                            slot_permit: slot_permit.into(),
+                        },
+                        inner.user_data,
+                    ),
+                }
             }
         }
     }
 }
-unsafe impl Send for CancelReserveGuard {}
 
 #[async_trait::async_trait]
 impl<SK: SlotKind + Send + Sync> temporal_sdk_core_api::worker::SlotSupplier
@@ -280,36 +362,53 @@ impl<SK: SlotKind + Send + Sync> temporal_sdk_core_api::worker::SlotSupplier
     type SlotKind = SK;
 
     async fn reserve_slot(&self, ctx: &dyn SlotReservationContext) -> SlotSupplierPermit {
-        let (tx, rx) = oneshot::channel();
         let ctx = Self::convert_reserve_ctx(ctx);
-        let tx = Box::into_raw(Box::new(tx)) as *mut libc::c_void;
+        let completion_ctx = Arc::new(SlotReserveCompletionCtx {
+            state: AtomicCell::new(SlotReserveOperationState::Pending),
+            notify: Notify::new(),
+        });
         unsafe {
-            let _drop_guard = CancelReserveGuard {
-                token_src: ctx.token_src,
-                callback: (*self.inner.0).cancel_reserve,
-            };
-            ((*self.inner.0).reserve)(&ctx, tx);
-            rx.await.expect("reserve channel is not closed")
+            let inner = &*self.inner.0;
+            (inner.reserve)(&ctx, Arc::into_raw(completion_ctx.clone()), inner.user_data);
+        }
+        let mut guard = CancelReserveGuard {
+            slot_supplier: self,
+            completion_ctx,
+            completed: false,
+        };
+        // if the future is dropped before this await resolves, the guard is dropped which triggers cancellation
+        guard.completion_ctx.notify.notified().await;
+        guard.completed = true;
+        match guard.completion_ctx.state.load() {
+            SlotReserveOperationState::Completed(permit_id) => {
+                SlotSupplierPermit::with_user_data::<usize>(permit_id.get())
+            }
+            other => panic!("Unexpected slot reservation state: expected Completed, got {other:?}"),
         }
     }
 
     fn try_reserve_slot(&self, ctx: &dyn SlotReservationContext) -> Option<SlotSupplierPermit> {
         let ctx = Self::convert_reserve_ctx(ctx);
-        let permit_id = unsafe { ((*self.inner.0).try_reserve)(&ctx) };
+        let permit_id = unsafe { ((*self.inner.0).try_reserve)(&ctx, (*self.inner.0).user_data) };
         if permit_id == 0 {
             None
         } else {
-            Some(SlotSupplierPermit::with_user_data(permit_id))
+            Some(SlotSupplierPermit::with_user_data::<usize>(permit_id))
         }
     }
 
     fn mark_slot_used(&self, ctx: &dyn SlotMarkUsedContext<SlotKind = Self::SlotKind>) {
         let ctx = SlotMarkUsedCtx {
             slot_info: Self::convert_slot_info(ctx.info().downcast()),
-            slot_permit: ctx.permit().user_data::<usize>().copied().unwrap_or(0),
+            slot_permit: ctx
+                .permit()
+                .user_data::<usize>()
+                .copied()
+                .expect("permit user data should be usize"),
         };
         unsafe {
-            ((*self.inner.0).mark_used)(&ctx);
+            let inner = &*self.inner.0;
+            (inner.mark_used)(&ctx, inner.user_data);
         }
     }
 
@@ -321,15 +420,26 @@ impl<SK: SlotKind + Send + Sync> temporal_sdk_core_api::worker::SlotSupplier
         }
         let ctx = SlotReleaseCtx {
             slot_info: info_ptr,
-            slot_permit: ctx.permit().user_data::<usize>().copied().unwrap_or(0),
+            slot_permit: ctx
+                .permit()
+                .user_data::<usize>()
+                .copied()
+                .expect("permit user data should be usize"),
         };
         unsafe {
-            ((*self.inner.0).release)(&ctx);
+            let inner = &*self.inner.0;
+            (inner.release)(&ctx, inner.user_data);
         }
     }
 
     fn available_slots(&self) -> Option<usize> {
-        None
+        unsafe {
+            let inner = &*self.inner.0;
+            inner.available_slots.and_then(|f| {
+                let mut available_slots = 0;
+                f(&mut available_slots, inner.user_data).then_some(available_slots)
+            })
+        }
     }
 }
 
@@ -358,7 +468,6 @@ impl<SK: SlotKind + Send + Sync> CustomSlotSupplier<SK> {
                 ByteArrayRef::empty()
             },
             is_sticky: ctx.is_sticky(),
-            token_src: std::ptr::null_mut(),
         }
     }
 
@@ -378,7 +487,7 @@ impl<SK: SlotKind + Send + Sync> CustomSlotSupplier<SK> {
             }
             temporal_sdk_core_api::worker::SlotInfo::Nexus(n) => SlotInfo::NexusSlotInfo {
                 operation: n.operation.as_str().into(),
-                service: n.operation.as_str().into(),
+                service: n.service.as_str().into(),
             },
         }
     }
@@ -558,7 +667,7 @@ pub extern "C" fn temporal_core_worker_poll_workflow_activation(
                 worker
                     .runtime
                     .clone()
-                    .alloc_utf8(&format!("Poll failure: {err}"))
+                    .alloc_utf8(&format!("Workflow polling failure: {err}"))
                     .into_raw()
                     .cast_const(),
             ),
@@ -592,7 +701,41 @@ pub extern "C" fn temporal_core_worker_poll_activity_task(
                 worker
                     .runtime
                     .clone()
-                    .alloc_utf8(&format!("Poll failure: {err}"))
+                    .alloc_utf8(&format!("Activity polling failure: {err}"))
+                    .into_raw()
+                    .cast_const(),
+            ),
+        };
+        unsafe {
+            callback(user_data.into(), success, fail);
+        }
+    });
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_worker_poll_nexus_task(
+    worker: *mut Worker,
+    user_data: *mut libc::c_void,
+    callback: WorkerPollCallback,
+) {
+    let worker = unsafe { &*worker };
+    let user_data = UserDataHandle(user_data);
+    let core_worker = worker.worker.as_ref().unwrap().clone();
+    worker.runtime.core.tokio_handle().spawn(async move {
+        let (success, fail) = match core_worker.poll_nexus_task().await {
+            Ok(task) => (
+                ByteArray::from_vec(task.encode_to_vec())
+                    .into_raw()
+                    .cast_const(),
+                std::ptr::null(),
+            ),
+            Err(PollError::ShutDown) => (std::ptr::null(), std::ptr::null()),
+            Err(err) => (
+                std::ptr::null(),
+                worker
+                    .runtime
+                    .clone()
+                    .alloc_utf8(&format!("Nexus polling failure: {err}"))
                     .into_raw()
                     .cast_const(),
             ),
@@ -620,7 +763,7 @@ pub extern "C" fn temporal_core_worker_complete_workflow_activation(
                     worker
                         .runtime
                         .clone()
-                        .alloc_utf8(&format!("Decode failure: {err}"))
+                        .alloc_utf8(&format!("Workflow task decode failure: {err}"))
                         .into_raw(),
                 );
             }
@@ -635,7 +778,7 @@ pub extern "C" fn temporal_core_worker_complete_workflow_activation(
             Err(err) => worker
                 .runtime
                 .clone()
-                .alloc_utf8(&format!("Completion failure: {err}"))
+                .alloc_utf8(&format!("Workflow completion failure: {err}"))
                 .into_raw()
                 .cast_const(),
         };
@@ -662,7 +805,7 @@ pub extern "C" fn temporal_core_worker_complete_activity_task(
                     worker
                         .runtime
                         .clone()
-                        .alloc_utf8(&format!("Decode failure: {err}"))
+                        .alloc_utf8(&format!("Activity task decode failure: {err}"))
                         .into_raw(),
                 );
             }
@@ -677,7 +820,49 @@ pub extern "C" fn temporal_core_worker_complete_activity_task(
             Err(err) => worker
                 .runtime
                 .clone()
-                .alloc_utf8(&format!("Completion failure: {err}"))
+                .alloc_utf8(&format!("Activity completion failure: {err}"))
+                .into_raw()
+                .cast_const(),
+        };
+        unsafe {
+            callback(user_data.into(), fail);
+        }
+    });
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn temporal_core_worker_complete_nexus_task(
+    worker: *mut Worker,
+    completion: ByteArrayRef,
+    user_data: *mut libc::c_void,
+    callback: WorkerCallback,
+) {
+    let worker = unsafe { &*worker };
+    let completion = match NexusTaskCompletion::decode(completion.to_slice()) {
+        Ok(completion) => completion,
+        Err(err) => {
+            unsafe {
+                callback(
+                    user_data,
+                    worker
+                        .runtime
+                        .clone()
+                        .alloc_utf8(&format!("Nexus task decode failure: {err}"))
+                        .into_raw(),
+                );
+            }
+            return;
+        }
+    };
+    let user_data = UserDataHandle(user_data);
+    let core_worker = worker.worker.as_ref().unwrap().clone();
+    worker.runtime.core.tokio_handle().spawn(async move {
+        let fail = match core_worker.complete_nexus_task(completion).await {
+            Ok(_) => std::ptr::null(),
+            Err(err) => worker
+                .runtime
+                .clone()
+                .alloc_utf8(&format!("Nexus completion failure: {err}"))
                 .into_raw()
                 .cast_const(),
         };
@@ -707,7 +892,7 @@ pub extern "C" fn temporal_core_worker_record_activity_heartbeat(
         Err(err) => worker
             .runtime
             .clone()
-            .alloc_utf8(&format!("Decode failure: {err}"))
+            .alloc_utf8(&format!("Activity heartbeat decode failure: {err}"))
             .into_raw(),
     }
 }
@@ -861,29 +1046,88 @@ pub extern "C" fn temporal_core_worker_replay_push(
     }
 }
 
+/// Completes asynchronous slot reservation started by a call to [`CustomSlotSupplierCallbacks::reserve`].
+///
+/// `completion_ctx` must be the same as the one passed to the matching [`reserve`](CustomSlotSupplierCallbacks::reserve)
+/// call. `permit_id` is arbitrary, but must be unique among live reservations as it's later used
+/// for [`mark_used`](CustomSlotSupplierCallbacks::mark_used) and [`release`](CustomSlotSupplierCallbacks::release)
+/// callbacks.
+///
+/// This function returns true if the reservation was completed successfully, or false if the
+/// reservation was cancelled before completion. If this function returns false, the implementation
+/// should call [`temporal_core_complete_async_cancel_reserve`] with the same `completion_ctx`.
+///
+/// **Caution:** if this function returns true, `completion_ctx` gets freed. Afterwards, calling
+/// either [`temporal_core_complete_async_reserve`] or [`temporal_core_complete_async_cancel_reserve`]
+/// with the same `completion_ctx` will cause **memory corruption!**
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_complete_async_reserve(
-    sender: *mut libc::c_void,
+    completion_ctx: *const SlotReserveCompletionCtx,
     permit_id: usize,
-) {
-    if !sender.is_null() {
-        unsafe {
-            let sender = Box::from_raw(sender as *mut oneshot::Sender<SlotSupplierPermit>);
-            let permit = SlotSupplierPermit::with_user_data(permit_id);
-            let _ = sender.send(permit);
+) -> bool {
+    if completion_ctx.is_null() {
+        panic!("completion_ctx is null");
+    }
+    let permit_id =
+        NonZero::new(permit_id).expect("permit_id cannot be 0 on successful reservation");
+    let prev_state = unsafe {
+        // Not turning completion_ctx into Arc yet as we only want to deallocate it on success
+        (*completion_ctx).state.compare_exchange(
+            SlotReserveOperationState::Pending,
+            SlotReserveOperationState::Completed(permit_id),
+        )
+    };
+    match prev_state {
+        Ok(_) => {
+            let completion_ctx = unsafe { Arc::from_raw(completion_ctx) };
+            completion_ctx.notify.notify_one();
+            true
         }
-    } else {
-        panic!("ReserveSlot sender must not be null!");
+        Err(SlotReserveOperationState::Cancelled) => false,
+        Err(SlotReserveOperationState::Completed(prev_permit_id)) => {
+            panic!(
+                "temporal_core_complete_async_reserve called twice for the same reservation - first permit ID {prev_permit_id}, second permit ID {permit_id}"
+            )
+        }
+        Err(SlotReserveOperationState::Pending) => unreachable!(),
     }
 }
 
+/// Completes cancellation of asynchronous slot reservation.
+///
+/// Cancellation can only be initiated by Core. It's done by calling [`CustomSlotSupplierCallbacks::cancel_reserve`]
+/// after an earlier call to [`CustomSlotSupplierCallbacks::reserve`].
+///
+/// `completion_ctx` must be the same as the one passed to the matching [`cancel_reserve`](CustomSlotSupplierCallbacks::cancel_reserve)
+/// call.
+///
+/// This function returns true on successful cancellation, or false if cancellation was not
+/// requested for the given `completion_ctx`. A false value indicates there's likely a logic bug in
+/// the implementation where it doesn't correctly wait for [`cancel_reserve`](CustomSlotSupplierCallbacks::cancel_reserve)
+/// callback to be called.
+///
+/// **Caution:** if this function returns true, `completion_ctx` gets freed. Afterwards, calling
+/// either [`temporal_core_complete_async_reserve`] or [`temporal_core_complete_async_cancel_reserve`]
+/// with the same `completion_ctx` will cause **memory corruption!**
 #[unsafe(no_mangle)]
-pub extern "C" fn temporal_core_set_reserve_cancel_target(
-    ctx: *mut SlotReserveCtx,
-    token_ptr: *mut libc::c_void,
-) {
-    if let Some(ctx) = unsafe { ctx.as_mut() } {
-        ctx.token_src = token_ptr;
+pub extern "C" fn temporal_core_complete_async_cancel_reserve(
+    completion_ctx: *const SlotReserveCompletionCtx,
+) -> bool {
+    if completion_ctx.is_null() {
+        panic!("completion_ctx is null");
+    }
+    let state = unsafe { (*completion_ctx).state.load() };
+    match state {
+        SlotReserveOperationState::Cancelled => {
+            drop(unsafe { Arc::from_raw(completion_ctx) });
+            true
+        }
+        SlotReserveOperationState::Pending => false,
+        SlotReserveOperationState::Completed(permit_id) => {
+            panic!(
+                "temporal_core_complete_async_cancel_reserve called on completed reservation - permit ID {permit_id}"
+            )
+        }
     }
 }
 
@@ -958,6 +1202,7 @@ impl TryFrom<&WorkerOptions> for temporal_sdk_core::WorkerConfig {
             .workflow_task_poller_behavior(temporal_sdk_core_api::worker::PollerBehavior::try_from(&opt.workflow_task_poller_behavior)?)
             .nonsticky_to_sticky_poll_ratio(opt.nonsticky_to_sticky_poll_ratio)
             .activity_task_poller_behavior(temporal_sdk_core_api::worker::PollerBehavior::try_from(&opt.activity_task_poller_behavior)?)
+            .nexus_task_poller_behavior(temporal_sdk_core_api::worker::PollerBehavior::try_from(&opt.nexus_task_poller_behavior)?)
             .workflow_failure_errors(if opt.nondeterminism_as_workflow_fail {
                 HashSet::from([WorkflowErrorType::Nondeterminism])
             } else {
@@ -1003,10 +1248,17 @@ impl TryFrom<&TunerHolder> for temporal_sdk_core::TunerHolder {
             } else {
                 None
             };
+        let maybe_nexus_resource_opts =
+            if let SlotSupplier::ResourceBased(ref ss) = holder.nexus_task_slot_supplier {
+                Some(&ss.tuner_options)
+            } else {
+                None
+            };
         let all_resource_opts = [
             maybe_wf_resource_opts,
             maybe_act_resource_opts,
             maybe_local_act_resource_opts,
+            maybe_nexus_resource_opts,
         ];
         let mut set_resource_opts = all_resource_opts.iter().flatten();
         let first = set_resource_opts.next();
@@ -1033,6 +1285,7 @@ impl TryFrom<&TunerHolder> for temporal_sdk_core::TunerHolder {
             .workflow_slot_options(holder.workflow_slot_supplier.try_into()?)
             .activity_slot_options(holder.activity_slot_supplier.try_into()?)
             .local_activity_slot_options(holder.local_activity_slot_supplier.try_into()?)
+            .nexus_slot_options(holder.nexus_task_slot_supplier.try_into()?)
             .build()
             .context("Invalid tuner holder options")?
             .build_tuner_holder()

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -434,6 +434,7 @@ impl StateMachineDefinition {
             }
         };
         let mut multi_dest_enums = vec![];
+        let mut multi_dest_enum_names = HashSet::new();
         let state_branches: Vec<_> = statemap.into_iter().map(|(from, transitions)| {
             let occupied_current_state = quote! { Some(#state_enum_name::#from(state_data)) };
             // Merge transition dest states with the same handler
@@ -468,7 +469,11 @@ impl StateMachineDefinition {
                                         }
                                     }
                                 };
-                                multi_dest_enums.push(multi_dest_enum);
+                                // Deduplicate; two different events may each result in a transition
+                                // set with the same set of dest states
+                                if multi_dest_enum_names.insert(enum_ident.clone()) {
+                                    multi_dest_enums.push(multi_dest_enum);
+                                }
                                 quote! {
                                     #transition_result_name<#enum_ident>
                                 }

package/sdk-core/fsm/rustfsm_procmacro/tests/trybuild/dupe_transitions_fail.stderr

@@ -1,11 +1,11 @@
 error: Duplicate transitions are not allowed!
   --> $DIR/dupe_transitions_fail.rs:5:1
    |
-5  | / fsm! {
-6  | |     name SimpleMachine; command SimpleMachineCommand; error Infallible;
-7  | |
-8  | |     One --(A)--> Two;
-9  | |     One --(A)--> Two;
+ 5 | / fsm! {
+ 6 | |     name SimpleMachine; command SimpleMachineCommand; error Infallible;
+ 7 | |
+ 8 | |     One --(A)--> Two;
+ 9 | |     One --(A)--> Two;
 10 | | }
    | |_^
    |

package/sdk-core/sdk/Cargo.toml

@@ -16,9 +16,15 @@ anyhow = "1.0"
 derive_more = { workspace = true }
 futures-util = { version = "0.3", default-features = false }
 parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = { version = "0.6", package = "prost-wkt-types" }
+prost-types = { workspace = true }
 serde = "1.0"
-tokio = { version = "1.26", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio = { version = "1.47", features = [
+    "rt",
+    "rt-multi-thread",
+    "parking_lot",
+    "time",
+    "fs",
+] }
 tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tracing = "0.1"

package/sdk-core/sdk/src/activity_context.rs

@@ -56,7 +56,7 @@ pub struct ActivityInfo {
 impl ActContext {
     /// Construct new Activity Context, returning the context and the first argument to the activity
     /// (which may be a default [Payload]).
-    pub(crate) fn new(
+    pub fn new(
         worker: Arc<dyn Worker>,
         app_data: Arc<AppData>,
         cancellation_token: CancellationToken,