From 35b2242a322406af6b6120c9f500c9a072a81ac3 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:38:52 +0000
Subject: [PATCH 1/3] React: add flow control to reactive readers

Keeps a client of a reactive read on the latest state even when
the state changes faster than the client can consume the
updates. Before this change the backend produced a response per
state change and pushed it at the client regardless of whether
the client had consumed the previous one, so responses queued up
in the gRPC stream or in the browser's websocket buffer: a
client that couldn't keep up worked its way through every state
it had missed, and fell arbitrarily far behind while still
receiving a steady stream of (old) responses.

`React.Query` now stamps every response with a
`query_response_id` and produces no further response until the
client acknowledges that ID. Acknowledgements travel back over
the websocket that carries the responses when there is one -- a
`QueryRequest` with `acknowledge_query_response_id` set, which
costs no extra round trip -- and over the new unary
`AcknowledgeQueryResponse` RPC otherwise. Between an
acknowledgement and the next response the backend catches up to
the _latest_ state, so a slow client skips the states it missed
instead of replaying them.

- A client only acknowledges a response that carries an ID, so a
  frontend built from this version keeps working against an
  older backend, which sends none.
- Transitive reactive reads acknowledge only once the response
  they hold has been used, so a reader that reads through
  another reader also gets the latest state rather than the next
  one in line.

BREAKING CHANGE: a frontend that doesn't acknowledge responses
receives one reactive response and then never updates again, so
frontends must be redeployed alongside (or before) this backend
change.

TESTED: `//tests/reboot:reactivity_test_py` gains
  `test_skip_to_latest` and `test_transitive_skip_to_latest`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FMgyLgRtZXNAerHpSguK9k
---
 rbt/v1alpha1/react.proto                      |  39 ++-
 reboot/aio/contexts.py                        |  56 ++--
 reboot/aio/react.py                           | 226 ++++++++++++----
 .../next/reactive-reader-acknowledgements.md  |  14 +
 reboot/templates/reboot.py.j2                 |  32 ++-
 reboot/web/index.ts                           | 112 +++++++-
 tests/reboot/echo_rbt.golden.py               |  64 +++--
 tests/reboot/greeter_rbt.golden.js            |   2 +-
 tests/reboot/greeter_rbt.golden.py            | 256 +++++++++++++-----
 tests/reboot/ping_api_rbt.golden.py           | 224 ++++++++++-----
 tests/reboot/reactivity_test.py               | 141 +++++++++-
 11 files changed, 917 insertions(+), 249 deletions(-)
 create mode 100644 reboot/plugin/skills/upgrade/migrations/next/reactive-reader-acknowledgements.md

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 0b770b655..879e38776 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -18,6 +18,12 @@ message QueryRequest {
 
   // Authorization bearer token.
   optional string bearer_token = 3;
+
+  // ID of the `QueryResponse` that this request acknowledges; see
+  // `AcknowledgeQueryResponse`. Only meaningful on transports where a
+  // client can send more than one message per query, i.e. websockets.
+  // When this is set the other fields are ignored.
+  string acknowledge_query_response_id = 4;
 }
 
 message QueryResponse {
@@ -40,8 +46,20 @@ message QueryResponse {
   //
   // TODO(benh): send these as bytes?
   repeated string idempotency_keys = 2;
+
+  // Unique ID of this response, used to acknowledge it.
+  string query_response_id = 4;
+}
+
+////////////////////////////////////////////////////////////////////////
+
+message AcknowledgeQueryResponseRequest {
+  // ID of the `QueryResponse` being acknowledged.
+  string query_response_id = 1;
 }
 
+message AcknowledgeQueryResponseResponse {}
+
 ////////////////////////////////////////////////////////////////////////
 
 // TODO(benh): support batch, e.g., create a `MutateRequests` which
@@ -90,8 +108,15 @@ message WebSocketsConnectionResponse {}
 service React {
   // Allows users to "watch" the response of a unary reader method for
   // changes. The current response of the method is sent when the
-  // stream is opened, then a new response is sent whenever the
-  // state changes in a way that causes the method's response to change.
+  // stream is opened. Every response must be acknowledged by the
+  // client before a next one is produced, and that next response
+  // reflects the _latest_ state, skipping any states that came and
+  // went while the client was busy.
+  //
+  // A client acknowledges either by calling
+  // `AcknowledgeQueryResponse`, or, when its responses arrive over a
+  // websocket, by sending a `QueryRequest` with
+  // `acknowledge_query_response_id` set on that same websocket.
   //
   // NOTE: the service name and state ID is expected to be part of the
   // gRPC metadata, exactly like any other reboot requests.
@@ -101,6 +126,16 @@ service React {
     };
   }
 
+  // Acknowledges that a client has processed a response from `Query`
+  // and is ready for a next one. Must be called on the same server
+  // that produced the response.
+  rpc AcknowledgeQueryResponse(AcknowledgeQueryResponseRequest)
+      returns (AcknowledgeQueryResponseResponse) {
+    option (google.api.http) = {
+      post: "/rbt.v1alpha1.React/AcknowledgeQueryResponse"
+    };
+  }
+
   // All connections must be HTTP/2 (h2), but the WebSocket protocol
   // is inherently HTTP/1.1. RFC 8441
   // (https://datatracker.ietf.org/doc/html/rfc8441) introduced
diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py
index b814275c2..93df686d1 100644
--- a/reboot/aio/contexts.py
+++ b/reboot/aio/contexts.py
@@ -474,7 +474,9 @@ async def query():
                         self._state_type_name, self._state_ref
                     )
 
-                    call = react_pb2_grpc.ReactStub(channel).Query(
+                    stub = react_pb2_grpc.ReactStub(channel)
+
+                    call = stub.Query(
                         react_pb2.QueryRequest(
                             method=self._method,
                             request=serialized_request,
@@ -498,25 +500,39 @@ async def loop():
                         assert task is not None
 
                         async for query_response in call:
-                            if not query_response.HasField('response'):
-                                continue
-
-                            response = self._response_type()
-                            response.ParseFromString(query_response.response)
-
-                            self._used_response[task].clear()
-
-                            self._calls[task] = call
-
-                            self._responses[task] = asyncio.Future()
-                            self._responses[task].set_result(response)
-
-                            if not have_first_response.is_set():
-                                have_first_response.set()
-                            else:
-                                self._event.set()
-
-                            await self._used_response[task].wait()
+                            if query_response.HasField('response'):
+                                response = self._response_type()
+                                response.ParseFromString(
+                                    query_response.response
+                                )
+
+                                self._used_response[task].clear()
+
+                                self._calls[task] = call
+
+                                self._responses[task] = asyncio.Future()
+                                self._responses[task].set_result(response)
+
+                                if not have_first_response.is_set():
+                                    have_first_response.set()
+                                else:
+                                    self._event.set()
+
+                                await self._used_response[task].wait()
+
+                            # Only now that the response has been used
+                            # do we ask for a next one, so that it
+                            # reflects the latest state rather than a
+                            # state that has already been superseded.
+                            await stub.AcknowledgeQueryResponse(
+                                react_pb2.AcknowledgeQueryResponseRequest(
+                                    query_response_id=query_response.
+                                    query_response_id,
+                                ),
+                                # The same metadata ensures we're
+                                # routed to the same server.
+                                metadata=metadata,
+                            )
 
                         raise RuntimeError('React.Query should be infinite')
 
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index d1039e986..ebf7abf25 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -73,6 +73,10 @@ def __init__(
             self._state_name_by_state_tag[state_tag] = state_type_name
             self._middleware_by_state_type[state_type_name] = middleware
 
+        # Events, keyed by the ID of a response sent by `Query`, that
+        # are set once the client acknowledges that response.
+        self._query_response_acknowledgements: dict[str, asyncio.Event] = {}
+
         self._stop_websockets_serve = asyncio.Event()
 
     def _state_type_name_for_state_ref(
@@ -338,16 +342,34 @@ async def _websocket_query(
         query_task = asyncio.current_task()
         assert query_task is not None
 
-        async def consume_heartbeats():
+        # Events, keyed by query response ID, that are set once the
+        # client acknowledges the response with that ID.
+        acknowledgements: dict[str, asyncio.Event] = {}
+
+        async def consume_requests():
             try:
                 while True:
-                    _ = await websocket.recv()
+                    request_bytes = await websocket.recv()
+
+                    # Everything the client sends after its initial
+                    # request is either an acknowledgement or a
+                    # heartbeat; a heartbeat is an empty
+                    # `QueryRequest`, which acknowledges nothing.
+                    acknowledgement = react_pb2.QueryRequest()
+                    acknowledgement.ParseFromString(request_bytes)
+
+                    acknowledged = acknowledgements.pop(
+                        acknowledgement.acknowledge_query_response_id,
+                        None,
+                    )
+                    if acknowledged is not None:
+                        acknowledged.set()
             except Exception:
                 # WebSocket closed (or errored); cancel the main query
                 # task to unblock `_query()` and trigger cleanup.
                 query_task.cancel()
 
-        heartbeats_task = asyncio.create_task(consume_heartbeats())
+        requests_task = asyncio.create_task(consume_requests())
 
         try:
             async for response in self._query(
@@ -355,14 +377,125 @@ async def consume_heartbeats():
                 headers=headers,
                 middleware=middleware,
             ):
-                await websocket.send(response.SerializeToString())
+                response.query_response_id = str(uuid.uuid4())
+
+                acknowledged = asyncio.Event()
+                acknowledgements[response.query_response_id] = acknowledged
+
+                try:
+                    await websocket.send(response.SerializeToString())
+
+                    # Wait for the client to tell us that it is ready
+                    # for a next response. This is what stops us from
+                    # producing responses faster than the client can
+                    # consume them; while we wait here the state may
+                    # change any number of times, and the next
+                    # response we produce will reflect the latest of
+                    # those states.
+                    await acknowledged.wait()
+                finally:
+                    acknowledgements.pop(response.query_response_id, None)
         finally:
-            heartbeats_task.cancel()
-            await asyncio.gather(heartbeats_task, return_exceptions=True)
+            requests_task.cancel()
+            await asyncio.gather(requests_task, return_exceptions=True)
 
     def add_to_server(self, server: grpc.aio.Server) -> None:
         react_pb2_grpc.add_ReactServicer_to_server(self, server)
 
+    async def _middleware_for(
+        self,
+        grpc_context: grpc.aio.ServicerContext,
+        headers: Headers,
+    ) -> Middleware:
+        """Returns the middleware for the state that the given headers
+        address, after confirming that this server is authoritative for
+        that state."""
+        state_ref = headers.state_ref
+
+        state_type_name = self._state_type_name_for_state_ref(state_ref)
+
+        if state_type_name is None:
+            log_at_most_once_per(
+                seconds=60,
+                log_method=logger.error,
+                message=_unknown_query_or_mutation_error_message(
+                    is_query=True,
+                    state_type=state_ref.state_type,
+                ),
+            )
+            raise SystemAborted(UnknownService())
+
+        middleware = self._middleware_by_state_type[state_type_name]
+
+        try:
+            assert headers.application_id is not None  # Guaranteed by `Headers`.
+            authoritative_server = middleware.placement_client.server_for_actor(
+                headers.application_id,
+                state_ref,
+            )
+        except reboot.aio.placement.UnknownApplicationError:
+            # It's possible that the user did indeed type an application ID
+            # that doesn't exist, but it's also quite possible that this
+            # request reached us before the placement planner had gossipped
+            # out the information about which applications exist (we see
+            # this e.g. after `rbt dev`'s chaos monkey restarts). For that
+            # reason, abort with a retryable error.
+            raise SystemAborted(
+                Unavailable(),
+                message=
+                f"Application '{headers.application_id}' not found. If you "
+                "are confident the application exists, this may be because "
+                "the system is still starting.",
+            ) from None
+
+        if authoritative_server != middleware.server_id:
+            # This is NOT the correct server. Fail.
+            await grpc_context.abort(
+                grpc.StatusCode.UNAVAILABLE,
+                f"Server '{middleware.server_id}' is not "
+                "authoritative for this request; server "
+                f"'{authoritative_server}' is.",
+            )
+            raise  # Unreachable but necessary for mypy.
+
+        return middleware
+
+    async def AcknowledgeQueryResponse(
+        self,
+        request: react_pb2.AcknowledgeQueryResponseRequest,
+        grpc_context: grpc.aio.ServicerContext,
+    ) -> react_pb2.AcknowledgeQueryResponseResponse:
+        """Implements the React.AcknowledgeQueryResponse RPC that lets a
+        client tell us it has processed a response from `Query` and is
+        ready for a next one."""
+        # Confirm that we are the server that produced the response.
+        await self._middleware_for(
+            grpc_context,
+            Headers.from_grpc_context(grpc_context),
+        )
+
+        acknowledged = self._query_response_acknowledgements.pop(
+            request.query_response_id,
+            None,
+        )
+
+        if acknowledged is None:
+            # There are several valid reasons why we may not know this
+            # response:
+            # 1. The server may have restarted and lost its memory of
+            #    the response. The client's `Query` call will have been
+            #    broken by that same restart, and it will get a fresh
+            #    response once it reconnects.
+            # 2. The client may have sent its acknowledgement twice
+            #    (e.g. retried the request), in which case we have
+            #    already produced a next response.
+            # Either way there is nothing left to do.
+            return react_pb2.AcknowledgeQueryResponseResponse()
+
+        acknowledged.set()
+
+        return react_pb2.AcknowledgeQueryResponseResponse()
+
     async def _query(
         self,
         *,
@@ -425,61 +558,44 @@ def done_callback(_) -> None:
         try:
             headers = Headers.from_grpc_context(grpc_context)
 
-            state_ref = headers.state_ref
-
-            state_type_name = self._state_type_name_for_state_ref(state_ref)
-
-            if state_type_name is None:
-                log_at_most_once_per(
-                    seconds=60,
-                    log_method=logger.error,
-                    message=_unknown_query_or_mutation_error_message(
-                        is_query=True,
-                        state_type=state_ref.state_type,
-                    ),
-                )
-                raise SystemAborted(UnknownService())
-
-            middleware = self._middleware_by_state_type[state_type_name]
-
-            # Confirm whether this is the right server to be serving this
-            # request.
-            try:
-                assert headers.application_id is not None  # Guaranteed by `Headers`.
-                authoritative_server = middleware.placement_client.server_for_actor(
-                    headers.application_id,
-                    state_ref,
-                )
-            except reboot.aio.placement.UnknownApplicationError:
-                # It's possible that the user did indeed type an application ID
-                # that doesn't exist, but it's also quite possible that this
-                # request reached us before the placement planner had gossipped
-                # out the information about which applications exist (we see
-                # this e.g. after `rbt dev`'s chaos monkey restarts). For that
-                # reason, abort with a retryable error.
-                raise SystemAborted(
-                    Unavailable(),
-                    message=
-                    f"Application '{headers.application_id}' not found. If you "
-                    "are confident the application exists, this may be because "
-                    "the system is still starting.",
-                ) from None
-            if authoritative_server != middleware.server_id:
-                # This is NOT the correct server. Fail.
-                await grpc_context.abort(
-                    grpc.StatusCode.UNAVAILABLE,
-                    f"Server '{middleware.server_id}' is not "
-                    "authoritative for this request; server "
-                    f"'{authoritative_server}' is.",
-                )
-                raise  # Unreachable but necessary for mypy.
+            middleware = await self._middleware_for(grpc_context, headers)
 
             async for response in self._query(
                 request=request,
                 headers=headers,
                 middleware=middleware,
             ):
-                yield response
+                response.query_response_id = str(uuid.uuid4())
+
+                acknowledged = asyncio.Event()
+                self._query_response_acknowledgements[
+                    response.query_response_id] = acknowledged
+
+                try:
+                    yield response
+
+                    # Wait for the client to tell us, via
+                    # `AcknowledgeQueryResponse`, that it is ready for
+                    # a next response. This is what stops us from
+                    # producing responses faster than the client can
+                    # consume them; while we wait here the state may
+                    # change any number of times, and the next
+                    # response we produce will reflect the latest of
+                    # those states.
+                    #
+                    # TODO: consider more advanced flow control
+                    #       mechanisms than "one-ack-per-response";
+                    #       e.g. if we could measure the throughput to
+                    #       the client we could proactively send
+                    #       multiple responses without waiting for an
+                    #       ack for each one, which would reduce the
+                    #       user-visible latency of updates.
+                    await acknowledged.wait()
+                finally:
+                    self._query_response_acknowledgements.pop(
+                        response.query_response_id,
+                        None,
+                    )
         except asyncio.CancelledError:
             # It's pretty normal for a query to be cancelled; it's not useful to
             # print a stack trace.
diff --git a/reboot/plugin/skills/upgrade/migrations/next/reactive-reader-acknowledgements.md b/reboot/plugin/skills/upgrade/migrations/next/reactive-reader-acknowledgements.md
new file mode 100644
index 000000000..db1eac22f
--- /dev/null
+++ b/reboot/plugin/skills/upgrade/migrations/next/reactive-reader-acknowledgements.md
@@ -0,0 +1,14 @@
+## Reactive readers now acknowledge every response
+
+A backend from this version stops producing responses for a reactive
+read until the client acknowledges the previous one, so that a client
+that can't keep up skips ahead to the latest state instead of working
+through every state it missed. A frontend built against an older
+version doesn't send those acknowledgements, so it receives one
+reactive response and then never updates again.
+
+Clients from this version work against both an old and a new backend,
+so if the application deploys its frontend separately from its backend,
+deploy the frontend first (or deploy both at once). If the backend goes
+out first, any already-running browser tab keeps showing stale data
+until it is reloaded against the new frontend.
diff --git a/reboot/templates/reboot.py.j2 b/reboot/templates/reboot.py.j2
index f11446176..40ae3f38e 100644
--- a/reboot/templates/reboot.py.j2
+++ b/reboot/templates/reboot.py.j2
@@ -5283,9 +5283,11 @@ class {{ client.proto.state_name }}:
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='{{ method.proto.name }}',
                                     request={{ client.proto.state_name }}{{ method.proto.name }}RequestToProto(
@@ -5308,13 +5310,25 @@ class {{ client.proto.state_name }}:
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = {{ method.output_type }}()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = {{ method.output_type }}()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index cac6e9a99..11e3d9d68 100644
--- a/reboot/web/index.ts
+++ b/reboot/web/index.ts
@@ -418,6 +418,60 @@ export function reactively<
   return [responses(), setRequest];
 }
 
+// Tells the backend that we have processed the response with the given
+// ID and are ready for a next one. Retries until the backend confirms,
+// since a lost acknowledgement would leave the `Query` stream waiting
+// forever.
+async function acknowledgeQueryResponse({
+  endpoint,
+  headers,
+  queryResponseId,
+  signal,
+}: {
+  endpoint: string;
+  headers: Headers;
+  queryResponseId: string;
+  signal?: AbortSignal;
+}): Promise<void> {
+  const url = new URL(
+    `${endpoint}/rbt.v1alpha1.React/AcknowledgeQueryResponse`
+  );
+
+  const backoff = new Backoff();
+
+  while (true) {
+    try {
+      const response = await guardedFetch(
+        new Request(url.toString(), {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ queryResponseId }),
+          signal,
+        })
+      );
+      // A `fetch()` only throws on network errors; an HTTP error
+      // response resolves successfully, so we have to check for it
+      // ourselves.
+      if (!response.ok) {
+        throw new Error(
+          `Acknowledging query response '${queryResponseId}' failed ` +
+            `with HTTP status ${response.status}`
+        );
+      }
+      return;
+    } catch (e) {
+      if (signal?.aborted) {
+        throw e;
+      }
+      console.warn(
+        `[Reboot] Failed to acknowledge query response ` +
+          `'${queryResponseId}', retrying after backoff ...`
+      );
+      await backoff.wait();
+    }
+  }
+}
+
 export async function* reactiveReader({
   endpoint,
   request,
@@ -430,14 +484,18 @@ export async function* reactiveReader({
   websockets: boolean;
 }): AsyncGenerator<react_pb.QueryResponse, void, unknown> {
   const url = new URL(`${endpoint}/rbt.v1alpha1.React/Query`);
-  if (url.protocol === "https:" && !websockets) {
-    const headers = new Headers();
 
-    if (request.bearerToken !== undefined) {
-      headers.set("Authorization", `Bearer ${request.bearerToken}`);
-    }
+  const headers = new Headers();
+
+  if (request.bearerToken !== undefined) {
+    headers.set("Authorization", `Bearer ${request.bearerToken}`);
+  }
+
+  if (url.protocol === "https:" && !websockets) {
+    const acknowledgeHeaders = new Headers(headers);
+    acknowledgeHeaders.set("Content-Type", "application/json");
 
-    yield* grpcServerStream({
+    const responses = grpcServerStream({
       endpoint: url.toString(),
       method: "POST",
       headers,
@@ -445,6 +503,24 @@ export async function* reactiveReader({
       responseType: react_pb.QueryResponse,
       signal,
     });
+
+    for await (const response of responses) {
+      yield response;
+
+      // Only now that our consumer has processed the response do we
+      // ask the backend for a next one, so that it reflects the
+      // latest state rather than a state that has already been
+      // superseded. An older backend doesn't send an ID and doesn't
+      // expect an acknowledgement.
+      if (response.queryResponseId !== "") {
+        await acknowledgeQueryResponse({
+          endpoint,
+          headers: acknowledgeHeaders,
+          queryResponseId: response.queryResponseId,
+          signal,
+        });
+      }
+    }
   } else {
     // TODO: while technically we could `await
     // grpcWebsocketServerStream(...)` doing so will leak websockets
@@ -458,6 +534,14 @@ export async function* reactiveReader({
       heartbeatRequest: new react_pb.QueryRequest(),
       responseType: react_pb.QueryResponse,
       signal,
+      // Acknowledgements go back over the same websocket, so that a
+      // reactive read costs no extra round trips.
+      acknowledgeRequest: (response: react_pb.QueryResponse) =>
+        response.queryResponseId !== ""
+          ? new react_pb.QueryRequest({
+              acknowledgeQueryResponseId: response.queryResponseId,
+            })
+          : undefined,
     });
     for await (const response of responses) {
       if (response.responseOrStatus.case == "status") {
@@ -753,12 +837,16 @@ export async function* grpcWebsocketServerStream<
   heartbeatRequest,
   responseType,
   signal,
+  acknowledgeRequest,
 }: {
   url: URL;
   request: RequestType;
   heartbeatRequest: RequestType;
   responseType: MessageType<ResponseType>;
   signal: AbortSignal;
+  // Produces the request, if any, to send back once the consumer has
+  // processed a response.
+  acknowledgeRequest?: (response: ResponseType) => RequestType | undefined;
 }): AsyncGenerator<ResponseType, void, unknown> {
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 
@@ -846,7 +934,17 @@ export async function* grpcWebsocketServerStream<
       // suspended at `yield`; the loop re-checks after each one).
       let data: ArrayBuffer | undefined = undefined;
       while ((data = messages.shift()) !== undefined) {
-        yield responseType.fromBinary(new Uint8Array(data));
+        const response = responseType.fromBinary(new Uint8Array(data));
+
+        yield response;
+
+        const acknowledgement = acknowledgeRequest?.(response);
+        if (
+          acknowledgement !== undefined &&
+          websocket.readyState === WebSocket.OPEN
+        ) {
+          websocket.send(acknowledgement.toBinary());
+        }
       }
 
       if (error !== undefined) {
diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py
index ee0d4e1df..38f00d44f 100755
--- a/tests/reboot/echo_rbt.golden.py
+++ b/tests/reboot/echo_rbt.golden.py
@@ -20844,9 +20844,11 @@ async def Replay( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='Replay',
                                     request=EchoReplayRequestToProto(
@@ -20867,13 +20869,25 @@ async def Replay( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = tests.reboot.echo_pb2.ReplayResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield EchoReplayResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = tests.reboot.echo_pb2.ReplayResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield EchoReplayResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21021,9 +21035,11 @@ async def WaitFor( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='WaitFor',
                                     request=EchoWaitForRequestToProto(
@@ -21044,13 +21060,25 @@ async def WaitFor( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = tests.reboot.echo_pb2.WaitForResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield EchoWaitForResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = tests.reboot.echo_pb2.WaitForResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield EchoWaitForResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js
index 0a064c8d2..0dc714af2 100755
--- a/tests/reboot/greeter_rbt.golden.js
+++ b/tests/reboot/greeter_rbt.golden.js
@@ -5509,6 +5509,6 @@ Greeter._ConstructIdempotently = (_j = class {
 export function importPys() {
     reboot_native.importPy("tests.reboot.greeter_pb2", "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");
     reboot_native.importPy("tests.reboot.greeter_pb2_grpc", "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");
-    reboot_native.importPy("tests.reboot.greeter_rbt", "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");
+    reboot_native.importPy("tests.reboot.greeter_rbt", "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");
 }
 importPys();
diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py
index 52eac3f55..e2ff69eb3 100755
--- a/tests/reboot/greeter_rbt.golden.py
+++ b/tests/reboot/greeter_rbt.golden.py
@@ -21735,9 +21735,11 @@ async def Greet( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='Greet',
                                     request=GreeterGreetRequestToProto(
@@ -21758,13 +21760,25 @@ async def Greet( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = tests.reboot.greeter_pb2.GreetResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterGreetResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = tests.reboot.greeter_pb2.GreetResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterGreetResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21906,9 +21920,11 @@ async def TryToConstructContext( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='TryToConstructContext',
                                     request=GreeterTryToConstructContextRequestToProto(
@@ -21929,13 +21945,25 @@ async def TryToConstructContext( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = google.protobuf.empty_pb2.Empty()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterTryToConstructContextResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = google.protobuf.empty_pb2.Empty()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterTryToConstructContextResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22077,9 +22105,11 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='TryToConstructExternalContext',
                                     request=GreeterTryToConstructExternalContextRequestToProto(
@@ -22100,13 +22130,25 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = google.protobuf.empty_pb2.Empty()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterTryToConstructExternalContextResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = google.protobuf.empty_pb2.Empty()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterTryToConstructExternalContextResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22254,9 +22296,11 @@ async def TestLongRunningFetch( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='TestLongRunningFetch',
                                     request=GreeterTestLongRunningFetchRequestToProto(
@@ -22277,13 +22321,25 @@ async def TestLongRunningFetch( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = google.protobuf.empty_pb2.Empty()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterTestLongRunningFetchResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = google.protobuf.empty_pb2.Empty()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterTestLongRunningFetchResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22425,9 +22481,11 @@ async def GetWholeState( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='GetWholeState',
                                     request=GreeterGetWholeStateRequestToProto(
@@ -22448,13 +22506,25 @@ async def GetWholeState( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = tests.reboot.greeter_pb2.Greeter()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterGetWholeStateResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = tests.reboot.greeter_pb2.Greeter()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterGetWholeStateResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22596,9 +22666,11 @@ async def FailWithException( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='FailWithException',
                                     request=GreeterFailWithExceptionRequestToProto(
@@ -22619,13 +22691,25 @@ async def FailWithException( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = google.protobuf.empty_pb2.Empty()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterFailWithExceptionResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = google.protobuf.empty_pb2.Empty()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterFailWithExceptionResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22767,9 +22851,11 @@ async def FailWithAborted( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='FailWithAborted',
                                     request=GreeterFailWithAbortedRequestToProto(
@@ -22790,13 +22876,25 @@ async def FailWithAborted( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = google.protobuf.empty_pb2.Empty()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterFailWithAbortedResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = google.protobuf.empty_pb2.Empty()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterFailWithAbortedResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22938,9 +23036,11 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='ReadRecursiveMessage',
                                     request=GreeterReadRecursiveMessageRequestToProto(
@@ -22961,13 +23061,25 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = tests.reboot.greeter_pb2.ReadRecursiveMessageResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield GreeterReadRecursiveMessageResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = tests.reboot.greeter_pb2.ReadRecursiveMessageResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield GreeterReadRecursiveMessageResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py
index 679663ba1..6ec6bb3fb 100755
--- a/tests/reboot/ping_api_rbt.golden.py
+++ b/tests/reboot/ping_api_rbt.golden.py
@@ -21331,9 +21331,11 @@ async def Describe( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='Describe',
                                     request=PingDescribeRequestToProto(
@@ -21353,13 +21355,25 @@ async def Describe( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.PingDescribeResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield PingDescribeResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.PingDescribeResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield PingDescribeResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21466,9 +21480,11 @@ async def NumPings( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='NumPings',
                                     request=PingNumPingsRequestToProto(
@@ -21488,13 +21504,25 @@ async def NumPings( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.PingNumPingsResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield PingNumPingsResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.PingNumPingsResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield PingNumPingsResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -24116,9 +24144,11 @@ async def NumPongs( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='NumPongs',
                                     request=PongNumPongsRequestToProto(
@@ -24138,13 +24168,25 @@ async def NumPongs( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.PongNumPongsResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield PongNumPongsResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.PongNumPongsResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield PongNumPongsResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -26852,9 +26894,11 @@ async def ListCounters( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='ListCounters',
                                     request=UserListCountersRequestToProto(
@@ -26874,13 +26918,25 @@ async def ListCounters( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.UserListCountersResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield UserListCountersResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.UserListCountersResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield UserListCountersResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -26987,9 +27043,11 @@ async def Whoami( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='Whoami',
                                     request=UserWhoamiRequestToProto(
@@ -27009,13 +27067,25 @@ async def Whoami( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.UserWhoamiResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield UserWhoamiResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.UserWhoamiResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield UserWhoamiResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -30632,9 +30702,11 @@ async def Value( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='Value',
                                     request=CounterValueRequestToProto(
@@ -30654,13 +30726,25 @@ async def Value( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.CounterValueResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield CounterValueResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.CounterValueResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield CounterValueResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -30767,9 +30851,11 @@ async def Description( # type: ignore[misc]
                             __this__._state_ref,
                         ) as __channel__:
 
-                            __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
+                            __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub(
                                 __channel__
-                            ).Query(
+                            )
+
+                            __call__ = __stub__.Query(
                                 IMPORT_rbt_v1alpha1.react_pb2.QueryRequest(
                                     method='Description',
                                     request=CounterDescriptionRequestToProto(
@@ -30789,13 +30875,25 @@ async def Description( # type: ignore[misc]
                                 # idempotency key has been recorded; there may
                                 # not be a new response. Python callers don't
                                 # (currently) care about such an event, so we
-                                # simply ignore it.
-                                if not __query_response__.HasField("response"):
-                                    continue
-
-                                __response__ = reboot.ping.ping_api_pb2.CounterDescriptionResponse()
-                                __response__.ParseFromString(__query_response__.response)
-                                yield CounterDescriptionResponseFromProto(__response__)
+                                # simply ignore any message without a response.
+                                if __query_response__.HasField("response"):
+                                    __response__ = reboot.ping.ping_api_pb2.CounterDescriptionResponse()
+                                    __response__.ParseFromString(__query_response__.response)
+                                    yield CounterDescriptionResponseFromProto(__response__)
+
+                                # Only now that the caller has processed the
+                                # response do we ask the server for a next one,
+                                # so that it reflects the latest state rather
+                                # than a state that has already been
+                                # superseded.
+                                await __stub__.AcknowledgeQueryResponse(
+                                    IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                        query_response_id=__query_response__.query_response_id,
+                                    ),
+                                    # The same metadata ensures we're routed to
+                                    # the same server.
+                                    metadata=__metadata__,
+                                )
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index 488b1cf11..e63194b55 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -1,17 +1,44 @@
 import asyncio
 import unittest
 from reboot.aio.applications import Application
+from reboot.aio.contexts import ReaderContext
 from reboot.aio.external import ExternalContext
 from reboot.aio.tests import Reboot
+from tests.reboot import greeter_rbt
 from tests.reboot.greeter_rbt import Greeter
 from tests.reboot.greeter_servicers import MyGreeterServicer
 from typing import Optional
 
+# `title` that marks a `Greeter` as one whose `Greet` reads another
+# `Greeter`, named by its own `name`, rather than its own state.
+PROXY_TITLE = 'proxy'
+
+
+class ProxyingGreeterServicer(MyGreeterServicer):
+    """A `Greeter` whose `Greet` returns the greeting of the `Greeter`
+    named by its own `name` when its `title` is `PROXY_TITLE`. Reading
+    such a `Greeter` reactively therefore transitively reads the other
+    `Greeter` reactively."""
+
+    async def Greet(
+        self,
+        context: ReaderContext,
+        request: greeter_rbt.GreetRequest,
+    ) -> greeter_rbt.GreetResponse:
+        if self.state.title != PROXY_TITLE:
+            return await super().Greet(context, request)
+
+        return await Greeter.ref(self.state.name).Greet(
+            context,
+            name=request.name,
+        )
+
 
 class ReactivityTestCase(unittest.IsolatedAsyncioTestCase):
 
     async def asyncSetUp(self) -> None:
         self._accumulate_task: Optional[asyncio.Task] = None
+        self._can_accumulate_next_adjective = asyncio.Event()
         self._accumulated_adjective = asyncio.Event()
         self._accumulated_adjectives: list[str] = []
 
@@ -20,7 +47,7 @@ async def asyncSetUp(self) -> None:
 
     async def asyncTearDown(self) -> None:
         if self._accumulate_task is not None:
-            await self._stop_accumulating_adjectives()
+            await self._stop_accumulating()
         await self.rbt.stop()
 
     async def start_accumulating_adjectives(
@@ -32,10 +59,13 @@ async def _do():
             ).GetWholeState(context):
                 self._accumulated_adjectives.append(greeter_state.adjective)
                 self._accumulated_adjective.set()
+                # Hold up the reactive reader until the test says we
+                # may consume a next response.
+                await self._can_accumulate_next_adjective.wait()
 
         self._accumulate_task = asyncio.create_task(_do())
 
-    async def _stop_accumulating_adjectives(self):
+    async def _stop_accumulating(self):
         assert self._accumulate_task is not None
         self._accumulate_task.cancel()
         try:
@@ -54,6 +84,8 @@ async def test_reactive_get_all_state(self) -> None:
         """
         Regression test for https://github.com/reboot-dev/mono/issues/3135
         """
+        self._can_accumulate_next_adjective.set()
+
         await self.rbt.up(Application(servicers=[MyGreeterServicer]))
         context = self.rbt.create_external_context(name=f"test-{self.id()}")
         greeter, _ = await Greeter.Create(
@@ -83,6 +115,111 @@ async def test_reactive_get_all_state(self) -> None:
             await self.get_adjectives(2),
         )
 
+    async def test_skip_to_latest(self) -> None:
+        """
+        Tests that a reactive reader that can't keep up with the rate of
+        state changes skips straight to the latest state, instead of
+        working its way through every state that it missed.
+        """
+        await self.rbt.up(Application(servicers=[MyGreeterServicer]))
+        context = self.rbt.create_external_context(name=f"test-{self.id()}")
+        greeter, _ = await Greeter.Create(
+            context,
+            "my-greeter",
+            title="Mr.",
+            name="Robot",
+            adjective="reactive",
+        )
+
+        # Get the first response, then leave the reactive reader
+        # blocked; it hasn't asked for a next response yet.
+        await self.start_accumulating_adjectives(greeter, context)
+        self.assertEqual(["reactive"], await self.get_adjectives(1))
+
+        # Change the state several times while the reader is blocked.
+        await greeter.SetAdjective(context, adjective="realistic")
+        await greeter.SetAdjective(context, adjective="impressive")
+        await greeter.SetAdjective(context, adjective="marvelous")
+        await greeter.SetAdjective(context, adjective="fantastic")
+
+        # Now let the reactive reader consume a next response. It must
+        # be the latest state, not the oldest state it missed.
+        self._can_accumulate_next_adjective.set()
+        self.assertEqual(
+            ["reactive", "fantastic"],
+            await self.get_adjectives(2),
+        )
+
+    async def test_transitive_skip_to_latest(self) -> None:
+        """
+        Tests that a reactive reader that reads through another reactive
+        reader also doesn't work its way through every state that it
+        missed while it couldn't keep up.
+        """
+        await self.rbt.up(Application(servicers=[ProxyingGreeterServicer]))
+        context = self.rbt.create_external_context(name=f"test-{self.id()}")
+
+        greeter, _ = await Greeter.Create(
+            context,
+            "my-greeter",
+            title="Mr.",
+            name="Robot",
+            adjective="reactive",
+        )
+
+        proxy, _ = await Greeter.Create(
+            context,
+            "my-proxy",
+            title=PROXY_TITLE,
+            name="my-greeter",
+            adjective="unused",
+        )
+
+        greetings: list[str] = []
+        greeted = asyncio.Event()
+        can_greet_again = asyncio.Event()
+
+        async def accumulate_greetings():
+            async for response in proxy.reactively().Greet(
+                context,
+                name="Alice",
+            ):
+                greetings.append(response.message)
+                greeted.set()
+                await can_greet_again.wait()
+
+        self._accumulate_task = asyncio.create_task(accumulate_greetings())
+
+        async def get_greetings(expected_number: int) -> list[str]:
+            while len(greetings) < expected_number:
+                await greeted.wait()
+                greeted.clear()
+            return greetings
+
+        # Get the first greeting, then leave the reader blocked.
+        self.assertEqual(
+            ["Hi Alice, I am Mr. Robot the reactive"],
+            await get_greetings(1),
+        )
+
+        adjectives = [f"adjective-{index}" for index in range(10)]
+        for adjective in adjectives:
+            await greeter.SetAdjective(context, adjective=adjective)
+
+        # Now let the reader consume responses again. It must arrive at
+        # the latest state without seeing every state it missed; the
+        # transitive read costs it at most one extra response, since the
+        # response it already had in hand for the underlying `Greeter`
+        # was produced before the last of the changes above.
+        can_greet_again.set()
+
+        latest = f"Hi Alice, I am Mr. Robot the {adjectives[-1]}"
+        while greetings[-1] != latest:
+            await greeted.wait()
+            greeted.clear()
+
+        self.assertLessEqual(len(greetings), 3, greetings)
+
 
 if __name__ == '__main__':
     unittest.main()

From 5da44e1aa00499f7613ba635507f6d7c38bb6299 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:39:25 +0000
Subject: [PATCH 2/3] React: observe every mutation that a query response
 reports

Stops a mutation from staying pending forever now that the
backend skips states. Before this commit the generated React
client compared each query response only against the oldest of
the idempotency keys it was expecting. That was enough while
every state change produced its own response, but a response now
reports the aggregated idempotency keys of every state the
backend skipped on its way to the state that response reflects,
so a single response can be the only word a client ever gets
about several of its mutations -- and the ones it didn't compare
stayed `pending` forever.

Observe every expected mutation whose idempotency key the
response reports, rather than only the oldest one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FMgyLgRtZXNAerHpSguK9k
---
 reboot/templates/reboot_react.ts.j2      | 35 ++++++++++++++++--------
 tests/reboot/greeter_rbt_react.golden.js | 27 ++++++++++++------
 2 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/reboot/templates/reboot_react.ts.j2 b/reboot/templates/reboot_react.ts.j2
index 4802aaba7..513cb0536 100644
--- a/reboot/templates/reboot_react.ts.j2
+++ b/reboot/templates/reboot_react.ts.j2
@@ -909,21 +909,32 @@ class {{ client.proto.state_name | to_camel }}Instance {
             // orphans list with a length greater than 0. In this case, we don't
             // want to skip checking the expecteds list just because we have
             // already checked the orphans list.
-            if (
-              expecteds.length > 0 &&
-              queryResponse.idempotencyKeys.includes(
-                expecteds[0].idempotencyKey
+            //
+            // A single query response can report the idempotency keys of
+            // several mutations at once, because the backend aggregates the
+            // keys of every state it skipped over on its way to the state this
+            // response reflects. Two mutations may also share an idempotency
+            // key. So observe _every_ mutation whose key this response
+            // reports, not just the oldest one.
+            const observeds = expecteds.filter(
+              expected => queryResponse.idempotencyKeys.includes(
+                expected.idempotencyKey
               )
-            ) {
-              await expecteds[0].observed(() => {
-                if (response !== undefined) {
-                  reader.setResponse(response);
-                }
-                expecteds.shift();
-              });
+            );
+            if (observeds.length > 0) {
+              expecteds = expecteds.filter(
+                expected => !observeds.includes(expected)
+              );
+              for (const observed of observeds) {
+                await observed.observed(() => {
+                  if (response !== undefined) {
+                    reader.setResponse(response);
+                  }
+                });
+              }
             }
             // If we don't have any orphans to observe and we don't have any expecteds to observe,
-	          // or at least, the first expecteds _is not observed_ by this response, then go ahead and
+	          // or at least, none of the expecteds _is observed_ by this response, then go ahead and
 	          // pass on the response because it might contain new data that should get shown to the
 	          // user (e.g., in a chat app this could be a new chat message from a different user).
             else if (response !== undefined && !haveOrphans) {
diff --git a/tests/reboot/greeter_rbt_react.golden.js b/tests/reboot/greeter_rbt_react.golden.js
index 91174eb0c..34ec86140 100755
--- a/tests/reboot/greeter_rbt_react.golden.js
+++ b/tests/reboot/greeter_rbt_react.golden.js
@@ -1981,17 +1981,26 @@ class GreeterInstance {
                         // orphans list with a length greater than 0. In this case, we don't
                         // want to skip checking the expecteds list just because we have
                         // already checked the orphans list.
-                        if (expecteds.length > 0 &&
-                            queryResponse.idempotencyKeys.includes(expecteds[0].idempotencyKey)) {
-                            await expecteds[0].observed(() => {
-                                if (response !== undefined) {
-                                    reader.setResponse(response);
-                                }
-                                expecteds.shift();
-                            });
+                        //
+                        // A single query response can report the idempotency keys of
+                        // several mutations at once, because the backend aggregates the
+                        // keys of every state it skipped over on its way to the state this
+                        // response reflects. Two mutations may also share an idempotency
+                        // key. So observe _every_ mutation whose key this response
+                        // reports, not just the oldest one.
+                        const observeds = expecteds.filter(expected => queryResponse.idempotencyKeys.includes(expected.idempotencyKey));
+                        if (observeds.length > 0) {
+                            expecteds = expecteds.filter(expected => !observeds.includes(expected));
+                            for (const observed of observeds) {
+                                await observed.observed(() => {
+                                    if (response !== undefined) {
+                                        reader.setResponse(response);
+                                    }
+                                });
+                            }
                         }
                         // If we don't have any orphans to observe and we don't have any expecteds to observe,
-                        // or at least, the first expecteds _is not observed_ by this response, then go ahead and
+                        // or at least, none of the expecteds _is observed_ by this response, then go ahead and
                         // pass on the response because it might contain new data that should get shown to the
                         // user (e.g., in a chat app this could be a new chat message from a different user).
                         else if (response !== undefined && !haveOrphans) {

From 866d309afffe9e45bae266a5b3c60271e97de38a Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:39:30 +0000
Subject: [PATCH 3/3] Add a browser test for a reactive reader with a busy
 consumer

Covers the failure that got the first attempt at reactive read
flow control reverted: an update that arrives while the browser
is too busy to consume it must not be lost, or the page shows
old data forever.

The app under test blocks the browser's main thread for a second
on every response it renders, so each round of state changes this
test makes lands on a client that cannot process it and has not
yet asked for it. The browser must still end each round showing
the last state written in that round. The test runs against a
local Envoy both with TLS, where responses arrive over an HTTP
stream and acknowledgements are requests of their own, and
without, where responses and acknowledgements share one
websocket.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FMgyLgRtZXNAerHpSguK9k
---
 .../BUILD.bazel                               | 67 +++++++++++++++++
 .../index.tsx                                 | 46 ++++++++++++
 .../test_reactive_reader_flow_control/test.py | 75 +++++++++++++++++++
 .../test_against_local_envoy.py               | 12 +++
 4 files changed, 200 insertions(+)
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/index.tsx
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/test.py
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py

diff --git a/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel b/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
new file mode 100644
index 000000000..8f9a459a7
--- /dev/null
+++ b/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
@@ -0,0 +1,67 @@
+load("@aspect_rules_esbuild//esbuild:defs.bzl", "esbuild")
+load("@aspect_rules_ts//ts:defs.bzl", "ts_project")
+load("@rules_python//python:defs.bzl", "py_library")
+load("//tests/reboot/react:py_web_test_suite_env.bzl", "py_web_test_suite_env")
+
+ts_project(
+    name = "index_ts",
+    srcs = [
+        "index.tsx",
+    ],
+    tsconfig = "//tests/reboot/react:tsconfig",
+    deps = [
+        "//:node_modules/@reboot-dev/reboot-react",
+        "//:node_modules/@reboot-dev/reboot-web",
+        "//:node_modules/react",
+        "//:node_modules/react-dom",
+        "//rbt/v1alpha1:tasks_js_proto",
+        "//tests/reboot:greeter_js_reboot_react",
+    ],
+)
+
+esbuild(
+    name = "bundle",
+    srcs = [
+        ":index_ts",
+    ],
+    entry_point = "index.js",
+    format = "esm",
+    platform = "browser",
+)
+
+py_library(
+    name = "test_py",
+    testonly = True,
+    srcs = ["test.py"],
+    data = [
+        ":bundle",
+    ],
+    visibility = ["//tests:__subpackages__"],
+    deps = [
+        "//reboot/aio:external_py",
+        "//tests/reboot:greeter_servicers_py",
+        "//tests/reboot/react:web_driver_runner",
+    ],
+)
+
+py_web_test_suite_env(
+    name = "test_against_local_envoy_py",
+    srcs = ["test_against_local_envoy.py"],
+    browsers = [
+        "@io_bazel_rules_webtesting//browsers:chromium-local",
+    ],
+    main = "test_against_local_envoy.py",
+    # This test is not supported on macOS.
+    py_test_tags = [
+        "macos_not_supported",
+        "requires-linux-x86",
+    ],
+    tags = [
+        "macos_not_supported",
+        "requires-linux-x86",
+    ],
+    deps = [
+        ":test_py",
+        "//tests/reboot/react:test_against_local_envoy_py",
+    ],
+)
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/index.tsx b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
new file mode 100644
index 000000000..b8b16f605
--- /dev/null
+++ b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
@@ -0,0 +1,46 @@
+import { RebootClientProvider } from "@reboot-dev/reboot-react";
+import { useEffect } from "react";
+import ReactDOM from "react-dom/client";
+import { useGreeter } from "../../greeter_rbt_react";
+
+const ID = "greeter-flow-control-test";
+
+// How long the browser is busy with every response it renders. During
+// this time the main thread — and with it the reactive read loop — is
+// blocked, so responses the backend produces meanwhile have to wait
+// for us.
+const RENDER_MILLISECONDS = 1000;
+
+const App = () => {
+  const greeter = useGreeter({ id: ID });
+
+  const { response } = greeter.useGreet({ name: "Jonathan" });
+
+  useEffect(() => {
+    if (response === undefined) {
+      return;
+    }
+    const until = Date.now() + RENDER_MILLISECONDS;
+    while (Date.now() < until) {
+      // Deliberately spinning to occupy the main thread.
+    }
+  }, [response]);
+
+  if (response === undefined) return <>Loading...</>;
+
+  return (
+    <div className="App">
+      <h1 id="render">{response.message}</h1>
+    </div>
+  );
+};
+
+export const render = (url: string) => {
+  const root = ReactDOM.createRoot(document.getElementById("root"));
+
+  root.render(
+    <RebootClientProvider url={url}>
+      <App />
+    </RebootClientProvider>
+  );
+};
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test.py b/tests/reboot/react/test_reactive_reader_flow_control/test.py
new file mode 100644
index 000000000..218199919
--- /dev/null
+++ b/tests/reboot/react/test_reactive_reader_flow_control/test.py
@@ -0,0 +1,75 @@
+import asyncio
+import os
+import time
+from reboot.aio.external import ExternalContext
+from selenium.webdriver.common.by import By
+from tests.reboot.greeter_rbt import Greeter
+from tests.reboot.react.web_driver_runner import web_driver
+
+STATE_ID = 'greeter-flow-control-test'
+
+# Adjectives to write, in rounds. Every round is written while the
+# browser is still busy with the first response of that round.
+ROUNDS = [
+    [f'round-{round}-adjective-{index}'
+     for index in range(10)]
+    for round in range(3)
+]
+
+
+async def test(context: ExternalContext, uri: str):
+    """Tests that a reactive reader whose consumer can't keep up with
+    the rate of state changes still ends up showing the latest state.
+
+    The app in `index.tsx` blocks the browser's main thread for a
+    second on every response it renders, so the state changes this test
+    makes land on a client that is busy: the backend's next response
+    arrives while nothing in the browser can process it, and while the
+    reactive read loop hasn't yet asked for it. The browser must
+    nonetheless end each round showing the last state written in that
+    round."""
+    await Greeter.idempotently(f"Create '{STATE_ID}'").Create(
+        context,
+        STATE_ID,
+        title='Count',
+        name='Chocula',
+        adjective='tasty',
+    )
+
+    greeter = Greeter.ref(STATE_ID)
+
+    def wait_for_render_text(driver, text: str):
+
+        def text_is_present():
+            try:
+                return text in driver.find_element(By.ID, 'render').text
+            except Exception:
+                return False
+
+        while not text_is_present():
+            time.sleep(0.1)
+
+    with web_driver(
+        uri=uri,
+        bundle_js_path=os.path.join(os.path.dirname(__file__), 'bundle.js'),
+    ) as (driver, port):
+        # Selenium calls block, so run each of them in a separate
+        # thread to keep this event loop free for the Reboot calls
+        # interleaved between them.
+        await asyncio.to_thread(driver.get, f'http://127.0.0.1:{port}/')
+
+        await asyncio.to_thread(
+            wait_for_render_text,
+            driver,
+            'Hi Jonathan, I am Count Chocula the tasty',
+        )
+
+        for adjectives in ROUNDS:
+            for adjective in adjectives:
+                await greeter.SetAdjective(context, adjective=adjective)
+
+            await asyncio.to_thread(
+                wait_for_render_text,
+                driver,
+                f'Hi Jonathan, I am Count Chocula the {adjectives[-1]}',
+            )
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py b/tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py
new file mode 100644
index 000000000..2862e082b
--- /dev/null
+++ b/tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py
@@ -0,0 +1,12 @@
+from reboot.aio.applications import Application
+from tests.reboot.greeter_servicers import MyGreeterServicer
+from tests.reboot.react.test_against_local_envoy import (
+    web_test_against_local_envoy,
+)
+from tests.reboot.react.test_reactive_reader_flow_control.test import test
+
+if __name__ == '__main__':
+    web_test_against_local_envoy(
+        test=test,
+        application=Application(servicers=[MyGreeterServicer]),
+    )