[Bridge] Served read_range and added the ExecuteSyncNexusOperation client.

crates/client/src/grpc.rs

@@ -1942,6 +1942,15 @@ proxier! {
             r.extensions_mut().insert(IsUserLongPoll);
         }
     );
+    (
+        execute_sync_nexus_operation,
+        ExecuteSyncNexusOperationRequest,
+        ExecuteSyncNexusOperationResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
 }
 
 proxier! {

crates/common/build.rs

@@ -761,6 +761,7 @@ const BLOB_FIELDS: &[&str] = &[
     "temporal.api.protocol.v1.Message.body", // whole Any body; see EXTRA_WHOLE_MESSAGE_LEAVES
     "temporal.api.query.v1.WorkflowQuery.query_args",
     "temporal.api.workflow.v1.NewWorkflowExecutionInfo.input",
+    "temporal.api.workflowservice.v1.ExecuteSyncNexusOperationRequest.input",
     "temporal.api.workflowservice.v1.NotifyStreamRequest.close_failure",
     "temporal.api.workflowservice.v1.NotifyStreamRequest.close_result",
     "temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest.details",

crates/protos/protos/local/temporal/sdk/core/streams/nexus.proto

@@ -19,6 +19,8 @@ service StreamNexusService {
   rpc NexusAppend(NexusCall) returns (NexusStep);
   // The stream service's Nexus `read` operation, over its JSON transfer form.
   rpc NexusRead(NexusCall) returns (NexusStep);
+  // The stream service's Nexus `read_range` operation, over its JSON transfer form.
+  rpc NexusReadRange(NexusCall) returns (NexusStep);
   // Goes on with a call that asked for codec work.
   rpc NexusResume(NexusResumeRequest) returns (NexusStep);
   // Attaches the caller of a stream-returning Nexus operation's start to the stream's notifier,

crates/protos/src/protos/mod.rs

@@ -3071,6 +3071,22 @@ mod sdk_helpers {
         };
         use anyhow::anyhow;
 
+        mod nexus_handler_callback {
+            use crate::protos::temporal::api::common::v1::callback::NexusHandler;
+            use prost::Message;
+
+            // The server reads the progress operation by its field number, so a renumbered field
+            // would send progress to an operation the Worker never named.
+            #[test]
+            fn the_progress_operation_keeps_its_field_number() {
+                let handler = NexusHandler {
+                    progress_operation: "p".to_string(),
+                    ..Default::default()
+                };
+                assert_eq!(handler.encode_to_vec(), vec![0x2a, 0x01, b'p']);
+            }
+        }
+
         mod stream_record_envelope {
             use crate::protos::temporal::{
                 api::common::v1::Payload,

crates/sdk-core-c-bridge/src/client.rs

@@ -722,6 +722,9 @@ async fn call_workflow_service(
         "ExecuteMultiOperation" => {
             rpc_call_on_trait!(client, call, WorkflowService, execute_multi_operation)
         }
+        "ExecuteSyncNexusOperation" => {
+            rpc_call_on_trait!(client, call, WorkflowService, execute_sync_nexus_operation)
+        }
         "FetchWorkerConfig" => {
             rpc_call_on_trait!(client, call, WorkflowService, fetch_worker_config)
         }

crates/sdk-core/CHANGELOG.md

@@ -176,6 +176,18 @@ relevant information.
   the Nexus calls, so lang's handler raises it as it is. A mistake in the stream, an empty callback
   URL or request id, and a token that names no stream are `BAD_REQUEST`. An attach for the latest
   run describes the Workflow fresh, so it never lands on a chain that already ended.
+* Experimental: with `notify_on_append`, `AttachCaller` tells the stream's notifier about the
+  newest record after the attach, so a caller that only waits for progress hears of the records
+  already there. An empty stream needs nothing, since every append notifies. The API protos carry the
+  `NexusHandler` progress fields and `nexus/notification-service.wit`.
+* Experimental: the Nexus `read` takes `floor_holder`. With it the read holds the floor and
+  answers `replay`, the range of the records that crossed after the byte cut, with Core's digest
+  over them. The new Nexus `read_range` operation, `NexusReadRange` for lang, reads that range
+  again through the codec step and checks the digest. Its answer has no byte budget and carries
+  only the records and `next_token`. It checks that the chain it names is one of the Workflow's.
+* Experimental: the API protos carry `WorkflowService.ExecuteSyncNexusOperation`, which runs one
+  synchronous Nexus operation for a caller namespace and persists nothing. The client and the C
+  bridge call it, and its `input` counts against the blob size limit.
 * Experimental: a Workflow publishes stream records with `WorkflowOutputStreamCommit` in its
   activation completion. The Worker appends them to its `stream_store` before it reports the
   completion, so readers see them while the Workflow Task runs, and nothing goes to History. The