@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core → crates/sdk-core}/Cargo.toml

@@ -1,10 +1,7 @@
 [package]
-name = "temporal-sdk-core"
+name = "temporalio-sdk-core"
 version = "0.1.0"
-authors = [
-    "Spencer Judge <spencer@temporal.io>",
-    "Vitaly Arbuzov <vitaly@temporal.io>",
-]
+authors = ["Temporal Technologies Inc. <sdk@temporal.io>"]
 edition = "2024"
 license-file = { workspace = true }
 description = "Library for building new Temporal SDKs"
@@ -30,9 +27,11 @@ tokio-console = ["console-subscriber"]
 ephemeral-server = ["dep:flate2", "dep:reqwest", "dep:tar", "dep:zip"]
 debug-plugin = ["dep:reqwest"]
 test-utilities = ["dep:assert_matches", "dep:bimap"]
+antithesis_assertions = ["dep:antithesis_sdk"]
 
 [dependencies]
 anyhow = "1.0"
+antithesis_sdk = { version = "0.2.1", optional = true, default-features = false, features = ["full"] }
 assert_matches = { version = "1.5", optional = true }
 bimap = { version = "0.6.3", optional = true }
 async-trait = "0.1"
@@ -120,19 +119,15 @@ uuid = { version = "1.18", features = ["v4"] }
 zip = { version = "4.6", optional = true, default-features = false, features = ["deflate", "bzip2", "zstd"] }
 
 # 1st party local deps
-[dependencies.temporal-sdk-core-api]
-path = "../core-api"
-features = ["otel_impls"]
-
-[dependencies.temporal-sdk-core-protos]
-path = "../sdk-core-protos"
-features = ["history_builders", "test-utilities"]
+[dependencies.temporalio-common]
+path = "../common"
+features = ["otel_impls", "history_builders", "test-utilities"]
 
-[dependencies.temporal-client]
+[dependencies.temporalio-client]
 path = "../client"
 
-[dependencies.rustfsm]
-path = "../fsm"
+[dependencies.temporalio-macros]
+path = "../macros"
 
 [dev-dependencies]
 assert_matches = "1.5"
@@ -142,7 +137,7 @@ clap = { version = "4.5", features = ["derive"] }
 criterion = { version = "0.7", features = ["async", "async_tokio"] }
 rstest = "0.26"
 semver = "1.0"
-temporal-sdk = { path = "../sdk" }
+temporalio-sdk = { path = "../sdk" }
 tokio = { version = "1.47", features = [
     "rt",
     "rt-multi-thread",
@@ -153,46 +148,58 @@ tokio = { version = "1.47", features = [
     "test-util",
 ] }
 tokio-stream = { version = "0.1", features = ["net"] }
+trybuild = { version = "1.0", features = ["diff"] }
+
+[[bin]]
+name = "histfetch"
+path = "src/histfetch.rs"
+required-features = ["test-utilities"]
 
 [[test]]
 name = "integ_tests"
-path = "../tests/main.rs"
+path = "tests/main.rs"
 # Prevents autodiscovery, and hence these getting run with `cargo test`. Run with
 # `cargo test --test integ_tests`
 test = false
 required-features = [
-    "temporal-sdk-core-protos/serde_serialize",
+    "temporalio-common/serde_serialize",
     "test-utilities",
     "ephemeral-server",
 ]
 
 [[test]]
 name = "heavy_tests"
-path = "../tests/heavy_tests.rs"
+path = "tests/heavy_tests.rs"
 test = false
 required-features = ["test-utilities"]
 
 [[test]]
 name = "manual_tests"
-path = "../tests/manual_tests.rs"
+path = "tests/manual_tests.rs"
 test = false
 required-features = ["test-utilities"]
 
 [[test]]
 name = "global_metric_tests"
-path = "../tests/global_metric_tests.rs"
+path = "tests/global_metric_tests.rs"
 test = false
 required-features = ["test-utilities"]
 
 [[test]]
 name = "cloud_tests"
-path = "../tests/cloud_tests.rs"
+path = "tests/cloud_tests.rs"
 test = false
 required-features = ["test-utilities"]
 
+[[test]]
+name = "fsm_procmacro"
+path = "tests/fsm_procmacro.rs"
+required-features = ["temporalio-common/serde_serialize"]
+
 [[bench]]
 name = "workflow_replay"
-path = "../tests/workflow_replay_bench.rs"
+path = "benches/workflow_replay_bench.rs"
+test = false
 harness = false
 
 # The integration test runner should compile with the same configuration as the
@@ -201,11 +208,11 @@ harness = false
 # tests directly.
 [[test]]
 name = "integ_runner"
-path = "../tests/runner.rs"
+path = "tests/runner.rs"
 harness = false
 test = false
 required-features = [
-    "temporal-sdk-core-protos/serde_serialize",
+    "temporalio-common/serde_serialize",
     "test-utilities",
     "ephemeral-server",
 ]

package/sdk-core/{tests → crates/sdk-core/benches}/workflow_replay_bench.rs

@@ -1,11 +1,11 @@
-//! This bench lives outside of the traditional /benches directory so it can share common code with
-//! integration tests.
-
 // All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
 #[allow(dead_code)]
+#[path = "../tests/common/mod.rs"]
 mod common;
 
-use crate::common::{DONT_AUTO_INIT_INTEG_TELEM, prom_metrics, replay_sdk_worker};
+use crate::common::{
+    DONT_AUTO_INIT_INTEG_TELEM, get_integ_runtime_options, prom_metrics, replay_sdk_worker,
+};
 use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 use futures_util::StreamExt;
 use std::{
@@ -13,12 +13,12 @@ use std::{
     thread,
     time::Duration,
 };
-use temporal_sdk::{WfContext, WorkflowFunction};
-use temporal_sdk_core::{CoreRuntime, replay::HistoryForReplay};
-use temporal_sdk_core_api::telemetry::metrics::{
-    MetricKeyValue, MetricParametersBuilder, NewAttributes,
+use temporalio_common::{
+    protos::{DEFAULT_WORKFLOW_TYPE, canned_histories},
+    telemetry::metrics::{MetricKeyValue, MetricParametersBuilder, NewAttributes},
 };
-use temporal_sdk_core_protos::{DEFAULT_WORKFLOW_TYPE, canned_histories};
+use temporalio_sdk::{WfContext, WorkflowFunction};
+use temporalio_sdk_core::{CoreRuntime, replay::HistoryForReplay};
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     let tokio_runtime = tokio::runtime::Builder::new_current_thread()
@@ -80,7 +80,7 @@ pub fn bench_metrics(c: &mut Criterion) {
     let _tokio = tokio_runtime.enter();
     let (mut telemopts, _addr, _aborter) = prom_metrics(None);
     telemopts.logging = None;
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let meter = rt.telemetry().get_metric_meter().unwrap();
 
     c.bench_function("Record with new attributes on each call", move |b| {

package/sdk-core/crates/sdk-core/machine_coverage/ActivityMachine_Coverage.puml

@@ -0,0 +1,32 @@
+@startuml
+Created -[#blue]-> ScheduleCommandCreated: Schedule
+ScheduleCommandCreated -[#blue]-> ScheduleCommandCreated: CommandScheduleActivityTask
+ScheduleCommandCreated -[#blue]-> ScheduledEventRecorded: ActivityTaskScheduled
+ScheduleCommandCreated -[#blue]-> Canceled: Cancel
+ScheduleCommandCreated -[#blue]-> Canceled: Abandon
+ScheduledEventRecorded -[#blue]-> Started: ActivityTaskStarted
+ScheduledEventRecorded -[#blue]-> TimedOut: ActivityTaskTimedOut
+ScheduledEventRecorded -[#blue]-> ScheduledActivityCancelCommandCreated: Cancel
+ScheduledEventRecorded -[#blue]-> Canceled: Abandon
+Started -[#blue]-> Completed: ActivityTaskCompleted
+Started -[#blue]-> Failed: ActivityTaskFailed
+Started -[#blue]-> TimedOut: ActivityTaskTimedOut
+Started -[#blue]-> StartedActivityCancelCommandCreated: Cancel
+Started -[#blue]-> Canceled: Abandon
+ScheduledActivityCancelCommandCreated -[#blue]-> ScheduledActivityCancelCommandCreated: CommandRequestCancelActivityTask
+ScheduledActivityCancelCommandCreated -[#blue]-> ScheduledActivityCancelEventRecorded: ActivityTaskCancelRequested
+ScheduledActivityCancelEventRecorded -[#blue]-> Canceled: ActivityTaskCanceled
+ScheduledActivityCancelEventRecorded -[#blue]-> StartedActivityCancelEventRecorded: ActivityTaskStarted
+ScheduledActivityCancelEventRecorded -[#blue]-> TimedOut: ActivityTaskTimedOut
+StartedActivityCancelCommandCreated -[#blue]-> StartedActivityCancelCommandCreated: CommandRequestCancelActivityTask
+StartedActivityCancelCommandCreated -[#blue]-> StartedActivityCancelEventRecorded: ActivityTaskCancelRequested
+StartedActivityCancelEventRecorded --> Failed: ActivityTaskFailed
+StartedActivityCancelEventRecorded -[#blue]-> Completed: ActivityTaskCompleted
+StartedActivityCancelEventRecorded -[#blue]-> TimedOut: ActivityTaskTimedOut
+StartedActivityCancelEventRecorded -[#blue]-> Canceled: ActivityTaskCanceled
+Canceled -[#blue]-> Canceled: ActivityTaskStarted
+Canceled -[#blue]-> Canceled: ActivityTaskCompleted
+TimedOut --> [*]
+Failed --> [*]
+Completed --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/CancelExternalMachine_Coverage.puml

@@ -0,0 +1,9 @@
+@startuml
+Created -[#blue]-> RequestCancelExternalCommandCreated: Schedule
+RequestCancelExternalCommandCreated -[#blue]-> RequestCancelExternalCommandCreated: CommandRequestCancelExternalWorkflowExecution
+RequestCancelExternalCommandCreated -[#blue]-> RequestCancelExternalCommandRecorded: RequestCancelExternalWorkflowExecutionInitiated
+RequestCancelExternalCommandRecorded -[#blue]-> CancelRequested: ExternalWorkflowExecutionCancelRequested
+RequestCancelExternalCommandRecorded -[#blue]-> RequestCancelFailed: RequestCancelExternalWorkflowExecutionFailed
+CancelRequested --> [*]
+RequestCancelFailed --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/CancelWorkflowMachine_Coverage.puml

@@ -0,0 +1,6 @@
+@startuml
+Created -[#blue]-> CancelWorkflowCommandCreated: Schedule
+CancelWorkflowCommandCreated -[#blue]-> CancelWorkflowCommandCreated: CommandCancelWorkflowExecution
+CancelWorkflowCommandCreated -[#blue]-> CancelWorkflowCommandRecorded: WorkflowExecutionCanceled
+CancelWorkflowCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/ChildWorkflowMachine_Coverage.puml

@@ -0,0 +1,27 @@
+@startuml
+Created -[#blue]-> StartCommandCreated: Schedule
+StartCommandCreated -[#blue]-> StartCommandCreated: CommandStartChildWorkflowExecution
+StartCommandCreated --> StartEventRecorded: StartChildWorkflowExecutionInitiated
+StartCommandCreated --> Cancelled: Cancel
+StartEventRecorded --> Started: ChildWorkflowExecutionStarted
+StartEventRecorded --> StartFailed: StartChildWorkflowExecutionFailed
+Started --> Completed: ChildWorkflowExecutionCompleted
+Started --> Failed: ChildWorkflowExecutionFailed
+Started --> TimedOut: ChildWorkflowExecutionTimedOut
+Started --> Cancelled: ChildWorkflowExecutionCancelled
+Started --> Terminated: ChildWorkflowExecutionTerminated
+Started --> Started: Cancel
+Started --> Cancelled: Cancel
+Started --> Started: CommandRequestCancelExternalWorkflowExecution
+Cancelled -[#blue]-> Cancelled: Cancel
+Cancelled --> Cancelled: ChildWorkflowExecutionCancelled
+Cancelled --> Cancelled: ChildWorkflowExecutionCompleted
+Cancelled --> Cancelled: ChildWorkflowExecutionFailed
+Cancelled --> Cancelled: ChildWorkflowExecutionTimedOut
+Cancelled --> Cancelled: ChildWorkflowExecutionTerminated
+Failed -[#blue]-> Failed: Cancel
+StartFailed -[#blue]-> StartFailed: Cancel
+TimedOut -[#blue]-> TimedOut: Cancel
+Completed -[#blue]-> Completed: Cancel
+Terminated --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/CompleteWorkflowMachine_Coverage.puml

@@ -0,0 +1,6 @@
+@startuml
+Created -[#blue]-> CompleteWorkflowCommandCreated: Schedule
+CompleteWorkflowCommandCreated -[#blue]-> CompleteWorkflowCommandCreated: CommandCompleteWorkflowExecution
+CompleteWorkflowCommandCreated -[#blue]-> CompleteWorkflowCommandRecorded: WorkflowExecutionCompleted
+CompleteWorkflowCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/ContinueAsNewWorkflowMachine_Coverage.puml

@@ -0,0 +1,6 @@
+@startuml
+Created -[#blue]-> ContinueAsNewWorkflowCommandCreated: Schedule
+ContinueAsNewWorkflowCommandCreated -[#blue]-> ContinueAsNewWorkflowCommandCreated: CommandContinueAsNewWorkflowExecution
+ContinueAsNewWorkflowCommandCreated --> ContinueAsNewWorkflowCommandRecorded: WorkflowExecutionContinuedAsNew
+ContinueAsNewWorkflowCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/FailWorkflowMachine_Coverage.puml

@@ -0,0 +1,6 @@
+@startuml
+Created -[#blue]-> FailWorkflowCommandCreated: Schedule
+FailWorkflowCommandCreated -[#blue]-> FailWorkflowCommandCreated: CommandFailWorkflowExecution
+FailWorkflowCommandCreated -[#blue]-> FailWorkflowCommandRecorded: WorkflowExecutionFailed
+FailWorkflowCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/LocalActivityMachine_Coverage.puml

@@ -0,0 +1,23 @@
+@startuml
+Executing -[#blue]-> RequestSent: Schedule
+Replaying -[#blue]-> WaitingMarkerEvent: Schedule
+ReplayingPreResolved -[#blue]-> WaitingMarkerEventPreResolved: Schedule
+RequestSent -[#blue]-> MarkerCommandCreated: HandleResult
+RequestSent -[#blue]-> RequestSent: Cancel
+RequestSent -[#blue]-> MarkerCommandCreated: NoWaitCancel
+MarkerCommandCreated -[#blue]-> ResultNotified: CommandRecordMarker
+ResultNotified -[#blue]-> MarkerCommandRecorded: MarkerRecorded
+WaitingMarkerEvent -[#blue]-> MarkerCommandRecorded: MarkerRecorded
+WaitingMarkerEvent -[#blue]-> WaitingMarkerEvent: Cancel
+WaitingMarkerEvent -[#blue]-> WaitingMarkerEvent: HandleKnownResult
+WaitingMarkerEvent -[#blue]-> WaitingMarkerEvent: NoWaitCancel
+WaitingMarkerEvent -[#blue]-> RequestSent: StartedNonReplayWFT
+WaitingMarkerEventPreResolved -[#blue]-> MarkerCommandRecorded: MarkerRecorded
+WaitingMarkerEventPreResolved --> WaitingMarkerEventPreResolved: Cancel
+WaitingMarkerEventPreResolved --> WaitingMarkerEventPreResolved: NoWaitCancel
+MarkerCommandRecorded --> MarkerCommandRecorded: Cancel
+MarkerCommandRecorded --> MarkerCommandRecorded: NoWaitCancel
+MarkerCommandCreated -[#blue]-> MarkerCommandCreated: HandleResult
+ResultNotified -[#blue]-> ResultNotified: HandleResult
+MarkerCommandRecorded --> MarkerCommandRecorded: HandleResult
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/ModifyWorkflowPropertiesMachine_Coverage.puml

@@ -0,0 +1,5 @@
+@startuml
+Created -[#blue]-> CommandIssued: CommandScheduled
+CommandIssued --> Done: CommandRecorded
+Done --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/PatchMachine_Coverage.puml

@@ -0,0 +1,8 @@
+@startuml
+Executing -[#blue]-> MarkerCommandCreated: Schedule
+Replaying -[#blue]-> MarkerCommandCreatedReplaying: Schedule
+MarkerCommandCreated -[#blue]-> Notified: CommandRecordMarker
+MarkerCommandCreatedReplaying -[#blue]-> Notified: CommandRecordMarker
+Notified -[#blue]-> MarkerCommandRecorded: MarkerRecorded
+MarkerCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/SignalExternalMachine_Coverage.puml

@@ -0,0 +1,12 @@
+@startuml
+Created -[#blue]-> SignalExternalCommandCreated: Schedule
+SignalExternalCommandCreated -[#blue]-> SignalExternalCommandCreated: CommandSignalExternalWorkflowExecution
+SignalExternalCommandCreated -[#blue]-> Cancelled: Cancel
+SignalExternalCommandCreated -[#blue]-> SignalExternalCommandRecorded: SignalExternalWorkflowExecutionInitiated
+SignalExternalCommandRecorded --> SignalExternalCommandRecorded: Cancel
+SignalExternalCommandRecorded -[#blue]-> Signaled: ExternalWorkflowExecutionSignaled
+SignalExternalCommandRecorded -[#blue]-> Failed: SignalExternalWorkflowExecutionFailed
+Cancelled -[#blue]-> Cancelled: Cancel
+Signaled -[#blue]-> Signaled: Cancel
+Failed --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/TimerMachine_Coverage.puml

@@ -0,0 +1,13 @@
+@startuml
+Created -[#blue]-> StartCommandCreated: Schedule
+StartCommandCreated -[#blue]-> StartCommandCreated: CommandStartTimer
+StartCommandCreated -[#blue]-> StartCommandRecorded: TimerStarted
+StartCommandCreated -[#blue]-> Canceled: Cancel
+StartCommandRecorded -[#blue]-> Fired: TimerFired
+StartCommandRecorded -[#blue]-> CancelTimerCommandCreated: Cancel
+CancelTimerCommandCreated --> CancelTimerCommandCreated: Cancel
+CancelTimerCommandCreated -[#blue]-> CancelTimerCommandSent: CommandCancelTimer
+CancelTimerCommandSent --> Canceled: TimerCanceled
+Canceled -[#blue]-> Canceled: Cancel
+Fired -[#blue]-> Fired: Cancel
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/UpdateMachine_Coverage.puml

@@ -0,0 +1,19 @@
+@startuml
+RequestInitiated --> Accepted: Accept
+RequestInitiated --> Rejected: Reject
+Accepted --> CompletedImmediately: Complete
+Accepted --> CompletedImmediately: Reject
+Accepted -[#blue]-> AcceptCommandCreated: CommandProtocolMessage
+AcceptCommandCreated -[#blue]-> AcceptCommandRecorded: WorkflowExecutionUpdateAccepted
+AcceptCommandCreated --> CompletedImmediatelyAcceptCreated: Complete
+AcceptCommandCreated --> CompletedImmediatelyAcceptCreated: Reject
+AcceptCommandRecorded --> Completed: Complete
+AcceptCommandRecorded --> Completed: Reject
+Completed -[#blue]-> CompletedCommandCreated: CommandProtocolMessage
+CompletedCommandCreated -[#blue]-> CompletedCommandRecorded: WorkflowExecutionUpdateCompleted
+CompletedImmediately -[#blue]-> CompletedImmediatelyAcceptCreated: CommandProtocolMessage
+CompletedImmediatelyAcceptCreated -[#blue]-> CompletedImmediatelyCompleteCreated: CommandProtocolMessage
+CompletedImmediatelyCompleteCreated -[#blue]-> CompletedCommandCreated: WorkflowExecutionUpdateAccepted
+Rejected --> [*]
+CompletedCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/UpsertSearchAttributesMachine_Coverage.puml

@@ -0,0 +1,5 @@
+@startuml
+Created -[#blue]-> CommandIssued: CommandScheduled
+CommandIssued -[#blue]-> Done: CommandRecorded
+Done --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/WorkflowTaskMachine_Coverage.puml

@@ -0,0 +1,11 @@
+@startuml
+Created -[#blue]-> Scheduled: WorkflowTaskScheduled
+Scheduled -[#blue]-> Started: WorkflowTaskStarted
+Scheduled --> TimedOut: WorkflowTaskTimedOut
+Started -[#blue]-> Completed: WorkflowTaskCompleted
+Started -[#blue]-> Failed: WorkflowTaskFailed
+Started -[#blue]-> TimedOut: WorkflowTaskTimedOut
+TimedOut --> [*]
+Completed --> [*]
+Failed --> [*]
+@enduml

package/sdk-core/{core → crates/sdk-core}/src/abstractions.rs

@@ -10,7 +10,7 @@ use std::{
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
 };
-use temporal_sdk_core_api::{
+use temporalio_common::{
     telemetry::metrics::TemporalMeter,
     worker::{
         SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
@@ -25,6 +25,7 @@ use tokio_util::sync::CancellationToken;
 #[derive(Clone)]
 pub(crate) struct MeteredPermitDealer<SK: SlotKind> {
     supplier: Arc<dyn SlotSupplier<SlotKind = SK> + Send + Sync>,
+    slot_supplier_kind: SlotSupplierKind,
     /// The number of permit owners who have acquired a permit, but are not yet meaningfully using
     /// that permit. This is useful for giving a more semantically accurate count of used task
     /// slots, since we typically wait for a permit first before polling, but that slot isn't used
@@ -54,6 +55,35 @@ pub(crate) struct PermitDealerContextData {
     pub(crate) worker_deployment_version: Option<WorkerDeploymentVersion>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum SlotSupplierKind {
+    Fixed,
+    ResourceBased,
+    Custom(String),
+}
+
+impl SlotSupplierKind {
+    fn from_label(label: &str) -> Self {
+        if label == "Fixed" {
+            SlotSupplierKind::Fixed
+        } else if label == "ResourceBased" {
+            SlotSupplierKind::ResourceBased
+        } else {
+            SlotSupplierKind::Custom(label.to_string())
+        }
+    }
+}
+
+impl std::fmt::Display for SlotSupplierKind {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SlotSupplierKind::Fixed => f.write_str("Fixed"),
+            SlotSupplierKind::ResourceBased => f.write_str("ResourceBased"),
+            SlotSupplierKind::Custom(name) => f.write_str(name.as_str()),
+        }
+    }
+}
+
 impl<SK> MeteredPermitDealer<SK>
 where
     SK: SlotKind + 'static,
@@ -65,8 +95,11 @@ where
         context_data: Arc<PermitDealerContextData>,
         meter: Option<TemporalMeter>,
     ) -> Self {
+        let supplier_kind_label = supplier.slot_supplier_kind();
+        let slot_supplier_kind = SlotSupplierKind::from_label(supplier_kind_label.as_ref());
         Self {
             supplier,
+            slot_supplier_kind,
             unused_claimants: Arc::new(AtomicUsize::new(0)),
             extant_permits: watch::channel(0),
             metrics_ctx,
@@ -81,6 +114,10 @@ where
         self.supplier.available_slots()
     }
 
+    pub(crate) fn slot_supplier_kind(&self) -> &SlotSupplierKind {
+        &self.slot_supplier_kind
+    }
+
     #[cfg(test)]
     pub(crate) fn unused_permits(&self) -> Option<usize> {
         self.available_permits()
@@ -386,10 +423,23 @@ impl<SK: SlotKind> OwnedMeteredSemPermit<SK> {
 pub(crate) struct UsedMeteredSemPermit<SK: SlotKind>(#[allow(dead_code)] OwnedMeteredSemPermit<SK>);
 
 macro_rules! dbg_panic {
-  ($($arg:tt)*) => {
-      error!($($arg)*);
-      debug_assert!(false, $($arg)*);
-  };
+    ($($arg:tt)*) => {{
+        let message = format!($($arg)*);
+        error!("{}", message);
+
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_always!(
+            false,
+            "dbg_panic invariant triggered",
+            ::serde_json::json!({
+                "message": message,
+                "file": file!(),
+                "line": line!(),
+                "module": module_path!(),
+            })
+        );
+        debug_assert!(false, "{}", message);
+    }};
 }
 pub(crate) use dbg_panic;
 
@@ -427,7 +477,7 @@ pub(crate) mod tests {
     use super::*;
     use crate::{advance_fut, worker::tuner::FixedSizeSlotSupplier};
     use futures_util::FutureExt;
-    use temporal_sdk_core_api::worker::WorkflowSlotKind;
+    use temporalio_common::worker::WorkflowSlotKind;
 
     pub(crate) fn fixed_size_permit_dealer<SK: SlotKind + Send + Sync + 'static>(
         size: usize,
@@ -492,4 +542,10 @@ pub(crate) mod tests {
         // Now it'll proceed
         acquire_fut.await;
     }
+
+    #[test]
+    fn captures_slot_supplier_kind() {
+        let dealer = fixed_size_permit_dealer::<WorkflowSlotKind>(1);
+        assert_eq!(*dealer.slot_supplier_kind(), SlotSupplierKind::Fixed);
+    }
 }

package/sdk-core/crates/sdk-core/src/antithesis.rs

@@ -0,0 +1,60 @@
+//! Antithesis SDK integration for invariant testing.
+//!
+//! This module provides assertion macros that integrate with the Antithesis
+//! testing platform to detect invariant violations during fuzz testing.
+
+use std::sync::OnceLock;
+
+/// Ensure Antithesis is initialized exactly once.
+pub(crate) fn ensure_init() {
+    static INIT: OnceLock<()> = OnceLock::new();
+    INIT.get_or_init(|| {
+        ::antithesis_sdk::antithesis_init();
+    });
+}
+
+/// Assert that a condition is always true during Antithesis fuzz testing.
+/// Use `false` as the condition to log an invariant violation.
+macro_rules! assert_always {
+    ($condition:expr, $message:literal, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_always!($condition, $message, &details);
+    }};
+    ($condition:expr, $message:literal) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_always!($condition, $message);
+    }};
+}
+
+/// Assert that a condition is sometimes true during Antithesis fuzz testing.
+/// This checks that the condition occurs at least once across the entire test session.
+macro_rules! assert_sometimes {
+    ($condition:expr, $message:literal, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_sometimes!($condition, $message, &details);
+    }};
+    ($condition:expr, $message:literal) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_sometimes!($condition, $message);
+    }};
+}
+
+/// Assert that a code location is unreachable during Antithesis fuzz testing.
+/// Use this for code paths that should never be reached (bugs, invariant violations).
+macro_rules! assert_unreachable {
+    ($message:literal, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_unreachable!($message, &details);
+    }};
+    ($message:literal) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_unreachable!($message);
+    }};
+}
+
+pub(crate) use assert_always;
+pub(crate) use assert_sometimes;
+pub(crate) use assert_unreachable;