Deliver a bacloud response bigger than one SmartSocket message.

Three size limits along the bacloud path disagreed and nothing owned
the disagreement: the client inherited websockets' 1 MiB receive
default, the relay inherited aiohttp's 4 MB, and the relay gated a
single send on its 4 MB resend-buffer cap -- a whole-direction budget
rather than a per-message one. A message in that gap was accepted,
buffered for resume, and retained and retried forever, since the relay
never learns the far socket refused it.

MAX_MESSAGE_BYTES and MAX_PAYLOAD_BYTES are now the single source for
all three, and ChunkedResponse (bacloud v29) splits an over-cap
response above the transport.

Author: efroemling

.efrocachemap

@@ -1,4 +1,4 @@
-### 1.8.0 (build 22995, api 9, 2026-08-21)
+### 1.8.0 (build 22996, api 9, 2026-08-21)
 - Fully implemented asset packages (more on this soon)
 - App-config committing (dirty-tracking, debounced disk writes, and
   suspend/shutdown flushes) now lives fully in `babase` instead of routing

CHANGELOG.md

@@ -23,7 +23,7 @@
     "bauiv1lib": "buil"
   },
   "efrocache_repository_url": "https://files.ballistica.net/cache/ba1",
-  "engine_build_number": 22995,
+  "engine_build_number": 22996,
   "name": "BallisticaKit",
   "public": true,
   "python_paths": [
@@ -43,5 +43,5 @@
     "tests",
     "config"
   ],
-  "version": "1.8.0a98"
+  "version": "1.8.0a99"
 }

pconfig/projectconfig.json

@@ -55,8 +55,8 @@
 
 # Build number and version of the ballistica binary we expect to be
 # using.
-TARGET_BALLISTICA_BUILD = 22995
-TARGET_BALLISTICA_VERSION = '1.8.0a98'
+TARGET_BALLISTICA_BUILD = 22996
+TARGET_BALLISTICA_VERSION = '1.8.0a99'
 
 
 @dataclass

src/assets/ba_data/python/baenv.py

@@ -51,8 +51,8 @@ auto main(int argc, char** argv) -> int {
 namespace ballistica {
 
 // These are set automatically via script; don't modify them here.
-const int kEngineBuildNumber = 22995;
-const char* kEngineVersion = "1.8.0a98";
+const int kEngineBuildNumber = 22996;
+const char* kEngineVersion = "1.8.0a99";
 const int kEngineApiVersion = 9;
 
 #if BA_MONOLITHIC_BUILD

src/ballistica/shared/ballistica.cc

@@ -208,7 +208,21 @@
 #               hop and basn's streamcall WS fan-out. ``MIN_VERSION``
 #               tracks ``BACLOUD_VERSION`` as usual; prod and
 #               push-public land together.
-BACLOUD_VERSION = 28
+# 29 (2026-08): Responses larger than one SmartSocket message are
+#               split across several. Adds ``ResponseTypeID.CHUNK``
+#               and ``ChunkedResponse``: the session sender slices a
+#               too-large serialized response into ordered pieces and
+#               the client rejoins them before decoding. The transport
+#               caps a single message deliberately (they are
+#               load-bearing for the relay's resend-buffer and linger
+#               math), so a big response has to be split *above* it --
+#               previously nothing did, and a ~1.5 MB vendored asset
+#               package was simply retained and retried by the relay
+#               forever, presenting as a half-hour hang. ``MIN_VERSION``
+#               tracks ``BACLOUD_VERSION`` as usual, so older clients
+#               get the standard "please update" rejection rather than
+#               an undecodable type id.
+BACLOUD_VERSION = 29
 
 
 def asset_file_cache_path(filehash: str) -> str:
@@ -281,6 +295,7 @@ class ResponseTypeID(Enum):
     STANDARD = 's'
     SESSION_HANDLE = 'sh'
     STREAM_OUTPUT = 'so'
+    CHUNK = 'ch'
 
 
 class ResponseData(IOMultiType[ResponseTypeID]):
@@ -320,6 +335,9 @@ def get_type(cls, type_id: ResponseTypeID) -> type[ResponseData]:
         if type_id is ResponseTypeID.STREAM_OUTPUT:
             out = StreamOutputResponse
             return out
+        if type_id is ResponseTypeID.CHUNK:
+            out = ChunkedResponse
+            return out
         raise ValueError(f'Unrecognized type-id {type_id}.')
 
 
@@ -962,6 +980,44 @@ def get_type_id(cls) -> ResponseTypeID:
         return ResponseTypeID.STREAM_OUTPUT
 
 
+@ioprepped
+@dataclass
+class ChunkedResponse(ResponseData):
+    """One ordered slice of a response too large for a single message.
+
+    The transport caps a single message on purpose -- that cap is what
+    the relay's resend-buffer and linger math are sized against, so it
+    does not grow to fit one caller's payload. A response past it is
+    therefore split here, above the transport, and rejoined by the
+    reader before it decodes anything.
+
+    No correlation id and no total-length field: the session delivers
+    gaplessly and in order (that is its whole invariant), and a sender
+    finishes one response before starting the next, so "collect until
+    ``index == count - 1``" is sufficient and cannot interleave. A
+    reader that sees a gap has already lost the session.
+
+    ``data`` is a slice of the *serialized* response, not a serialized
+    slice -- rejoining is string concatenation, and the result decodes
+    exactly as it would have unsplit. That keeps every existing
+    response type carryable with no per-type awareness here.
+    """
+
+    #: Position of this slice, from zero.
+    index: Annotated[int, IOAttrs('i')]
+
+    #: How many slices the whole response was split into.
+    count: Annotated[int, IOAttrs('n')]
+
+    #: This slice of the serialized response.
+    data: Annotated[str, IOAttrs('d')]
+
+    @override
+    @classmethod
+    def get_type_id(cls) -> ResponseTypeID:
+        return ResponseTypeID.CHUNK
+
+
 @ioprepped
 @dataclass
 class SessionHandleResponse(ResponseData):

tools/bacommon/bacloud.py

@@ -56,11 +56,14 @@
 
 from efro.error import CleanError
 from efro.smartsocket import (
+    MAX_MESSAGE_BYTES,
     SmartSocketClosed,
     SmartSocketEndpoint,
 )
+from efro.dataclassio import dataclass_from_json
 from bacommon.bacloud import (
     BACLOUD_VERSION,
+    ChunkedResponse,
     RequestData,
     ResponseData,
     SessionHandleResponse,
@@ -132,6 +135,12 @@ def __init__(self, ws_url: str, bearer: str | None) -> None:
             SmartSocketEndpoint[RequestData, ResponseData] | None
         ) = None
         self._inbox: queue.Queue[ResponseData | None] = queue.Queue()
+
+        # Slices of a response being reassembled. The session is
+        # gapless and in order and a sender finishes one response
+        # before starting the next, so a plain list is enough -- there
+        # is nothing to interleave with.
+        self._chunks: list[str] = []
         #: Set once a connection has actually completed its hello.
         #: Until then a dial failure means 'no session here', not 'a
         #: session to recover'.
@@ -356,6 +365,21 @@ async def _await_connected(
             await asyncio.sleep(0.05)
 
     async def _on_message(self, response: ResponseData) -> None:
+        if isinstance(response, ChunkedResponse):
+            # A response too large for one message, arriving in
+            # ordered slices. Collect, and decode only once the last
+            # one lands -- nothing above this layer ever learns the
+            # response was split.
+            self._chunks.append(response.data)
+            if response.index + 1 < response.count:
+                return
+            joined = ''.join(self._chunks)
+            self._chunks.clear()
+            # Slices are of the serialized response, so rejoining
+            # yields exactly what an unsplit send would have.
+            self._inbox.put(dataclass_from_json(ResponseData, joined))
+            return
+
         if isinstance(response, SessionHandleResponse):
             # Not an answer to anything -- the node telling us how to
             # get back in. Hold it; don't hand it to a waiting caller.
@@ -426,6 +450,13 @@ async def _dial(self, headers: dict[str, str]) -> ClientConnection:
             # policy-driven interval; a second liveness mechanism
             # would only add ways to disagree.
             ping_interval=None,
+            # Pin the receive limit to the protocol's own cap rather
+            # than inheriting whatever this library defaults to. They
+            # happened to match, but only by luck -- and the relay had
+            # no matching per-message limit, so a response between this
+            # and the relay's 4 MB buffer cap was sent and never
+            # received, presenting as an unexplained hang.
+            max_size=MAX_MESSAGE_BYTES,
         )
 
 

tools/bacommontools/bacloudsession.py

@@ -394,6 +394,39 @@ def action_for_close_code(code: int) -> SmartSocketAction:
 #: every window to run the recovery matrix in seconds).
 LOSS_DETECTION_FLOOR_SECONDS = 15.0
 
+#: Largest WebSocket message the protocol puts on the wire, in bytes.
+#:
+#: Every leg's socket-level receive limit is configured to exactly
+#: this, explicitly. Left to library defaults they disagree --
+#: ``websockets`` caps incoming messages at 1 MiB, ``aiohttp`` at 4 MB
+#: -- and a disagreement here does not surface as an error: the relay
+#: buffers each frame for resume, so a message the far socket refuses
+#: is *retained and retried*, not dropped. A ~1.5 MB bacloud response
+#: landed in exactly that gap and presented as a 30-minute hang with
+#: the server-side work done in 13 seconds.
+MAX_MESSAGE_BYTES = 1024 * 1024
+
+#: Room reserved for the frame envelope around a payload (seq, type
+#: id, JSON punctuation). Tiny next to the cap; explicit so the
+#: subtraction below is not a mystery constant.
+_FRAME_OVERHEAD_BYTES = 1024
+
+#: Largest app payload a single message may carry, in bytes.
+#:
+#: Smaller than :data:`MAX_MESSAGE_BYTES` because a payload is
+#: JSON-escaped *into* its frame, and the payloads here are themselves
+#: JSON -- every ``"`` becomes ``\\"``. Measured inflation is ~1.03x
+#: for typical bodies and ~1.0x for base64, but the worst case (a
+#: payload that is all quotes) is 2.02x, so the halving is what makes
+#: "this payload fits" true regardless of content rather than true for
+#: the bodies we happen to send today.
+#:
+#: This is the number a sender checks and a chunker splits on. It is
+#: load-bearing for the relay's resend-buffer and linger math, so it
+#: does not grow to fit one caller's message: anything larger must be
+#: split *above* this layer.
+MAX_PAYLOAD_BYTES = MAX_MESSAGE_BYTES // 2 - _FRAME_OVERHEAD_BYTES
+
 
 class SmartSocketClosed(Exception):
     """Raised by a transport when its connection has closed.
@@ -494,7 +527,7 @@ def __init__(
         recv_type: type[RecvT],
         on_message: Callable[[RecvT], Awaitable[None]] | None = None,
         refresh: Callable[[], Awaitable[None]] | None = None,
-        in_flight_cap_bytes: int = 1024 * 1024,
+        in_flight_cap_bytes: int = MAX_PAYLOAD_BYTES,
         attach_timeout_seconds: float = 10.0,
         loss_detection_floor_seconds: float = (LOSS_DETECTION_FLOOR_SECONDS),
         logger: logging.Logger | None = None,