Merge branch 'master' into ja/payload-visitor

Author: jmaeagle99

.github/workflows/ci.yml

@@ -119,7 +119,10 @@ jobs:
               --dynamic-config-value nexusoperation.enableStandalone=true \
               --dynamic-config-value history.enableChasm=true \
               --dynamic-config-value history.enableCHASMSignalBacklinks=true \
-              --dynamic-config-value history.enableTransitionHistory=true &
+              --dynamic-config-value history.enableTransitionHistory=true \
+              --dynamic-config-value frontend.enableCancelWorkerPollsOnShutdown=true \
+              --dynamic-config-value frontend.workerCommandsEnabled=true \
+              --dynamic-config-value system.enableCancelActivityWorkerCommand=true &
           sleep 10s
 
       # Can't actually run tests against Java 8 because Mockito 5 requires Java 11+.

AGENTS.md

@@ -17,7 +17,7 @@
 - The SDK code is written for Java 8.
 
 ## Building and Testing
-1. Format the code before committing:
+1. Format the code before committing (and don't bother running spotlessCheck, just run apply):
    ```bash
    ./gradlew --offline spotlessApply
    ```

releases/v1.36.0

@@ -0,0 +1,69 @@
+# **Highlights**
+
+## Standalone Activities (Public Preview)
+
+Support for Standalone Activities is now in [Public Preview](https://docs.temporal.io/evaluate/development-production-features/release-stages#public-preview).
+Telemetry support has been expanded with improved `OpenTracingClientInterceptor` and a new `OpenTracingActivityClientInterceptor`.
+
+## Standalone Nexus Operations (Experimental)
+
+This release adds `NexusClient` interface for interacting with Nexus services outside of workflows. The `NexusServiceClient`
+generic interface can be used to execute operations of a specific Nexus service in a type-safe manner. 
+
+##  GZIP transport-level compression
+
+Client connections now use GZIP transport-level gRPC compression by default.
+Use `setGrpcCompression(GrpcCompression.NONE)` when building `ServiceStubsOptions` to disable it.
+
+## Continue-as-New USE_RAMPING_VERSION versioning behaviour
+
+Continue-as-New now supports `USE_RAMPING_VERSION` as an initial versioning behavior.
+It pins the workflow to its task queue's Ramping Version at start time, ignoring the workflow's Target Version.
+
+## Activity cancellation without heartbeating
+
+Activities can receive cancellation requests without waiting for a heartbeat response if running against a recent enough version of the server.
+You can use the `ActivityExecutionContext.getCancellationToken()` method to detect such cancellations when not using the `heartbeat()` API.
+
+## Additional worker shutdown options
+
+Enabling `WorkerOptions.Builder.setAllowActivityHeartbeatDuringShutdown` removes the limitation on activity heartbeats during
+graceful worker shutdown, matching the behavior of other SDKs. Note that this will make it impossible to detect graceful shutdown
+via `ActivityWorkerShutdownException`, so if the detection is desired, an alternative method is needed.
+
+`WorkerFactoryOptions.Builder.setShutdownCheckInterval` can be used to speed up worker shutdown in certain testing scenarios.
+Changing this setting in production environment is discouraged.
+
+# What's Changed
+
+2026-05-04 - 5a765b17 - CaN USE_RAMPING_VERSION versioning behaviour (#2868)
+2026-05-07 - 20afdcb4 - Expose Nexus Endpoint on Nexus Info (#2837)
+2026-05-14 - 1e110b28 - Fixed a bug with spaces in WorkflowIds when creating links in the UI. (#2874)
+2026-05-18 - b19042bf - Expose ShutdownManager poll interval via WorkerFactoryOptions (#2876)
+2026-05-19 - 1386d4b3 - Add banner like other SDKs have (#2877)
+2026-05-19 - 73560d3a - remove stale nightly tps omes test (#2879)
+2026-05-19 - caba3510 - Upgrade cloud-api to v0.16.0 (#2873)
+2026-05-21 - 7a8e6845 - Improve CONTRIBUTING guide and streamline local dev requirements (#2871)
+2026-05-22 - 44bb6034 - Shutdown task loss prevention (#2820)
+2026-05-22 - d45886cd - Fixed flaky test WorkerFactoryRegistryTest.testRandomOrder (#2886)
+2026-05-27 - 187421b0 - Upgrade temporal-api to v1.62.12 (#2892)
+2026-05-27 - f71f93b0 - remove dead omes job (#2891)
+2026-06-01 - e947cc23 - Add history hints to workflow task started attributes (#2865)
+2026-06-02 - 3ed49850 - Add cooldown on dependabot config (#2888)
+2026-06-08 - 4d539760 - Wait for MARKER_RECORDED to fire version callback on replay (#2821)
+2026-06-10 - 62a7f08a - Fix flaky test `NexusWorkflowTest.testNexusOperationTimeout_AfterStart` (#2908)
+2026-06-11 - 27cfa7dc - Add Temporal Nexus Operation Handler (#2842)
+2026-06-11 - 5f25aad6 - Standalone operations for Nexus (#2872)
+2026-06-12 - 2bc7d9b3 - Use constants for all failure_reason metrics (#2914)
+2026-06-12 - c9c4bdc0 - Add tests for temporal-kotlin extension APIs (#2905)
+2026-06-15 - 3c2d9382 - Standalone Activities start delay (#2906)
+2026-06-15 - 7390e05b - feat(extstore): add initial extstore types (#2900)
+2026-06-15 - 78d0fee1 - Add backoff start for CAN (#2913)
+2026-06-15 - f3edb105 - Add GZIP compression defaulting to on (#2911)
+2026-06-16 - a1b6fff2 - Add OpenTracing interceptor for standalone activities (#2909)
+2026-06-16 - aeac5b19 - Grant explicit actions:read to features reusable-workflow caller (#2919)
+2026-06-18 - 8d8ca1b5 - Nexus Signal links (#2889)
+2026-06-18 - 8e5ee336 - Support Standalone Activity client in temporal-testing (#2916)
+2026-06-18 - dae5e0b1 - Add option to let activities heartbeat during worker shutdown (#2903)
+2026-06-22 - 85e12a38 - feat(otel): add tracing for startWithUpdate. fixes #2620. (#2925)
+2026-06-23 - e9761137 - Implement nexus-based activity cancels (#2917)

temporal-sdk/src/main/java/io/temporal/activity/ActivityCancellationToken.java

@@ -0,0 +1,51 @@
+package io.temporal.activity;
+
+import io.temporal.client.ActivityCanceledException;
+import io.temporal.common.Experimental;
+import java.util.concurrent.CompletableFuture;
+
+/** Token that allows an Activity implementation to observe cancellation requests. */
+@Experimental
+public interface ActivityCancellationToken {
+
+  ActivityCancellationToken NONE =
+      new ActivityCancellationToken() {
+        @Override
+        public boolean isCancellationRequested() {
+          return false;
+        }
+
+        @Override
+        public void throwIfCancellationRequested() throws ActivityCanceledException {}
+
+        @Override
+        public CompletableFuture<Void> getCancellationFuture() {
+          return new CompletableFuture<>();
+        }
+      };
+
+  /**
+   * Returns true after cancellation has been requested for this Activity Execution.
+   *
+   * <p>If this method returns true, the Activity implementation should stop its work and usually
+   * call {@link #throwIfCancellationRequested()} to report successful cancellation to Temporal.
+   */
+  boolean isCancellationRequested();
+
+  /**
+   * Throws {@link ActivityCanceledException} if cancellation has been requested for this Activity
+   * Execution.
+   *
+   * <p>Rethrowing this exception from Activity code reports successful cancellation to Temporal.
+   */
+  void throwIfCancellationRequested() throws ActivityCanceledException;
+
+  /**
+   * Future that completes exceptionally with {@link ActivityCanceledException} when cancellation
+   * has been requested for this Activity Execution.
+   *
+   * <p>Activity code should still call {@link #throwIfCancellationRequested()} or otherwise report
+   * cancellation if it wants the Activity Execution to complete as canceled.
+   */
+  CompletableFuture<Void> getCancellationFuture();
+}

temporal-sdk/src/main/java/io/temporal/activity/ActivityExecutionContext.java

@@ -3,6 +3,7 @@
 import com.uber.m3.tally.Scope;
 import io.temporal.client.ActivityCompletionException;
 import io.temporal.client.WorkflowClient;
+import io.temporal.common.Experimental;
 import io.temporal.serviceclient.WorkflowServiceStubsOptions;
 import io.temporal.worker.WorkerOptions;
 import java.lang.reflect.Type;
@@ -89,10 +90,17 @@ public interface ActivityExecutionContext {
    */
   byte[] getTaskToken();
 
+  /**
+   * Returns a token that can be used by Activity code to observe cancellation requests without
+   * recording Heartbeats.
+   */
+  @Experimental
+  ActivityCancellationToken getCancellationToken();
+
   /**
    * If this method is called during an Activity Execution then the Activity Execution is not going
-   * to complete when it's method returns. It is expected to be completed asynchronously using
-   * {@link io.temporal.client.ActivityCompletionClient}.
+   * to complete when its method returns. It is expected to be completed asynchronously using {@link
+   * io.temporal.client.ActivityCompletionClient}.
    *
    * <p>Async Activity Executions that have {@link #isUseLocalManualCompletion()} set to false will
    * not respect the limit defined by {@link WorkerOptions#getMaxConcurrentActivityExecutionSize()}.

temporal-sdk/src/main/java/io/temporal/common/interceptors/ActivityExecutionContextBase.java

@@ -1,6 +1,7 @@
 package io.temporal.common.interceptors;
 
 import com.uber.m3.tally.Scope;
+import io.temporal.activity.ActivityCancellationToken;
 import io.temporal.activity.ActivityExecutionContext;
 import io.temporal.activity.ActivityInfo;
 import io.temporal.activity.ManualActivityCompletionClient;
@@ -52,6 +53,11 @@ public byte[] getTaskToken() {
     return next.getTaskToken();
   }
 
+  @Override
+  public ActivityCancellationToken getCancellationToken() {
+    return next.getCancellationToken();
+  }
+
   @Override
   public void doNotCompleteOnReturn() {
     next.doNotCompleteOnReturn();

temporal-sdk/src/main/java/io/temporal/internal/activity/ActivityCancellationTokenImpl.java

@@ -0,0 +1,51 @@
+package io.temporal.internal.activity;
+
+import io.temporal.activity.ActivityCancellationToken;
+import io.temporal.client.ActivityCanceledException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+
+final class ActivityCancellationTokenImpl implements ActivityCancellationToken {
+  private final CompletableFuture<Void> cancellationFuture = new CompletableFuture<>();
+  private volatile ActivityCanceledException cancellationException;
+
+  @Override
+  public boolean isCancellationRequested() {
+    return cancellationException != null;
+  }
+
+  @Override
+  public void throwIfCancellationRequested() throws ActivityCanceledException {
+    ActivityCanceledException exception = cancellationException;
+    if (exception != null) {
+      throw exception;
+    }
+  }
+
+  @Override
+  public CompletableFuture<Void> getCancellationFuture() {
+    CompletableFuture<Void> result = new CompletableFuture<>();
+    cancellationFuture.whenComplete(
+        (ignored, exception) -> {
+          if (exception == null) {
+            result.complete(null);
+          } else {
+            result.completeExceptionally(unwrapCompletionException(exception));
+          }
+        });
+    return result;
+  }
+
+  synchronized void requestCancel(ActivityCanceledException exception) {
+    if (cancellationException == null) {
+      cancellationException = exception;
+      cancellationFuture.completeExceptionally(exception);
+    }
+  }
+
+  private static Throwable unwrapCompletionException(Throwable exception) {
+    return exception instanceof CompletionException && exception.getCause() != null
+        ? exception.getCause()
+        : exception;
+  }
+}

temporal-sdk/src/main/java/io/temporal/internal/activity/ActivityExecutionContextFactory.java

@@ -5,4 +5,12 @@
 public interface ActivityExecutionContextFactory {
   InternalActivityExecutionContext createContext(
       ActivityInfoInternal info, Object activity, Scope metricsScope);
+
+  /**
+   * Removes a context for a currently running activity identified by task token and optionally
+   * requests cancellation.
+   *
+   * @return true if the activity was found and cleaned up.
+   */
+  boolean cleanupContext(byte[] taskToken, boolean cancel);
 }

temporal-sdk/src/main/java/io/temporal/internal/activity/ActivityExecutionContextFactoryImpl.java

@@ -4,8 +4,12 @@
 import io.temporal.client.WorkflowClient;
 import io.temporal.common.converter.DataConverter;
 import io.temporal.internal.client.external.ManualActivityCompletionClientFactory;
+import java.nio.ByteBuffer;
 import java.time.Duration;
+import java.util.Arrays;
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ScheduledExecutorService;
 
 public class ActivityExecutionContextFactoryImpl implements ActivityExecutionContextFactory {
@@ -17,6 +21,8 @@ public class ActivityExecutionContextFactoryImpl implements ActivityExecutionCon
   private final DataConverter dataConverter;
   private final ScheduledExecutorService heartbeatExecutor;
   private final ManualActivityCompletionClientFactory manualCompletionClientFactory;
+  private final ConcurrentMap<ByteBuffer, ActivityExecutionContextImpl> activeContexts =
+      new ConcurrentHashMap<>();
 
   public ActivityExecutionContextFactoryImpl(
       WorkflowClient client,
@@ -42,18 +48,39 @@ public ActivityExecutionContextFactoryImpl(
   @Override
   public InternalActivityExecutionContext createContext(
       ActivityInfoInternal info, Object activity, Scope metricsScope) {
-    return new ActivityExecutionContextImpl(
-        client,
-        namespace,
-        activity,
-        info,
-        dataConverter,
-        heartbeatExecutor,
-        manualCompletionClientFactory,
-        info.getCompletionHandle(),
-        metricsScope,
-        identity,
-        maxHeartbeatThrottleInterval,
-        defaultHeartbeatThrottleInterval);
+    ByteBuffer taskToken = taskTokenKey(info.getTaskToken());
+    ActivityExecutionContextImpl context =
+        new ActivityExecutionContextImpl(
+            client,
+            namespace,
+            activity,
+            info,
+            dataConverter,
+            heartbeatExecutor,
+            manualCompletionClientFactory,
+            info.getCompletionHandle(),
+            metricsScope,
+            identity,
+            maxHeartbeatThrottleInterval,
+            defaultHeartbeatThrottleInterval,
+            () -> cleanupContext(info.getTaskToken(), false));
+    activeContexts.put(taskToken, context);
+    return context;
+  }
+
+  @Override
+  public boolean cleanupContext(byte[] taskToken, boolean cancel) {
+    ActivityExecutionContextImpl context = activeContexts.remove(taskTokenKey(taskToken));
+    if (context == null) {
+      return false;
+    }
+    if (cancel) {
+      context.cancelFromWorkerCommand();
+    }
+    return true;
+  }
+
+  private static ByteBuffer taskTokenKey(byte[] taskToken) {
+    return ByteBuffer.wrap(Arrays.copyOf(taskToken, taskToken.length)).asReadOnlyBuffer();
   }
 }

temporal-sdk/src/main/java/io/temporal/internal/activity/ActivityExecutionContextImpl.java

@@ -1,6 +1,7 @@
 package io.temporal.internal.activity;
 
 import com.uber.m3.tally.Scope;
+import io.temporal.activity.ActivityCancellationToken;
 import io.temporal.activity.ActivityExecutionContext;
 import io.temporal.activity.ActivityInfo;
 import io.temporal.activity.ManualActivityCompletionClient;
@@ -32,6 +33,7 @@ class ActivityExecutionContextImpl implements InternalActivityExecutionContext {
   private final ManualActivityCompletionClientFactory manualCompletionClientFactory;
   private final Functions.Proc completionHandle;
   private final HeartbeatContext heartbeatContext;
+  private final Functions.Proc closeCallback;
 
   private final Scope metricsScope;
   private final ActivityInfo info;
@@ -51,12 +53,14 @@ class ActivityExecutionContextImpl implements InternalActivityExecutionContext {
       Scope metricsScope,
       String identity,
       Duration maxHeartbeatThrottleInterval,
-      Duration defaultHeartbeatThrottleInterval) {
+      Duration defaultHeartbeatThrottleInterval,
+      Functions.Proc closeCallback) {
     this.client = client;
     this.activity = activity;
     this.metricsScope = metricsScope;
     this.info = info;
     this.completionHandle = completionHandle;
+    this.closeCallback = closeCallback;
     this.manualCompletionClientFactory = manualCompletionClientFactory;
     this.heartbeatContext =
         new HeartbeatContextImpl(
@@ -105,6 +109,11 @@ public byte[] getTaskToken() {
     return info.getTaskToken();
   }
 
+  @Override
+  public ActivityCancellationToken getCancellationToken() {
+    return heartbeatContext.getCancellationToken();
+  }
+
   @Override
   public void doNotCompleteOnReturn() {
     lock.lock();
@@ -170,6 +179,16 @@ public Object getLastHeartbeatValue() {
   @Override
   public void cancelOutstandingHeartbeat() {
     heartbeatContext.cancelOutstandingHeartbeat();
+    closeCallback.apply();
+  }
+
+  @Override
+  public void asyncCompletionStarted() {
+    heartbeatContext.asyncCompletionStarted();
+  }
+
+  void cancelFromWorkerCommand() {
+    heartbeatContext.cancelFromWorkerCommand();
   }
 
   @Override