@sproutboat/runtime 0.27.1 → 0.29.0

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # @sproutboat/runtime
 
+## 0.29.0
+
+### Minor Changes
+
+- 8df17ef: Durable Objects like workerd from compatibility date `2026-10-28`:
+  
+  - **Input gate.** While an object's storage read is in flight, no other event
+    (`stub.fetch()`, an alarm) enters it, so `const v = await storage.get("n"); await
+    storage.put("n", v + 1)` is safe under concurrent calls. Ten concurrent increments used
+    to end at 1. An event that awaits anything else (a fetch, a timer) lets the next one
+    in, as in workerd. `blockConcurrencyWhile()` and `transaction()` hold the gate until
+    they settle, and `stub.fetch()` always returns a Promise.
+  - **Storage returns Promises** (`get`, `put`, `delete`, `deleteAll`, `list`, the alarm
+    methods), and adds `sync()` and `transaction()` (with `txn.rollback()`; a throw rolls
+    back; a transaction reads its own writes).
+  - **Structured values.** Date, Map, Set, RegExp, ArrayBuffer and typed arrays, BigInt,
+    `undefined` inside containers, NaN, the infinities and -0 round-trip.
+    `put(k, undefined)` throws a TypeError and a function throws a DataCloneError, before
+    anything is written.
+  - `list()` takes `start`, `startAfter`, `end` and `reverse`, and `limit: 0` throws.
+    `setAlarm()` refuses a value that is not a Date or a number. `deleteAll()` also drops
+    the alarm.
+  
+  Earlier dates keep synchronous JSON storage and no gate. Values written from
+  `2026-10-28` start with `#sb1:`, and every date reads both formats.
+  
+  Both transports' `do.storage.list` take `start`, `startAfter`, `end` and `reverse`, and
+  match the prefix exactly (SQL `LIKE` also matched `_` and `%` as wildcards, ignoring
+  case, so a prefix such as `user_` listed other keys).
+
+### Patch Changes
+
+- 8df17ef: Queues fixes at every compatibility date (data loss, so not gated):
+  
+  - On the embedded transport (standalone sprouts and sproutd), `sendBatch()` stored every
+    body as the text `"[object Object]"`. It now stores the body it was given, and both
+    `send()` and `sendBatch()` honour `delaySeconds` there, as the broker already did.
+  - A consumer whose `queue()` throws now retries every message it had not explicitly
+    acked or retried, as on Workers. The embedded transport used to ack the whole batch,
+    so a failing consumer lost its messages. Explicit `ack()` / `ackAll()` calls made
+    before the throw still count (Cloudflare's documented behaviour; miniflare retries
+    those too).
+  
+  From compatibility date `2026-10-28`, `sendBatch(messages, { delaySeconds })` delays
+  every message whose own `delaySeconds` is unset or 0. Earlier dates ignore the batch
+  option.
+
+## 0.28.0
+
+### Minor Changes
+
+- 829ed12: Request bodies stream, from compatibility date `2026-10-27`, as in workerd:
+  
+  - **Ingress.** The native server runs the handler as soon as a request's headers arrive. `request.body` hands out the bytes as they come in, and the server pauses the socket while more than 1 MiB waits unread, so a large upload read through the stream keeps memory flat (a 128 MiB upload peaks at 38 MiB RSS). `text()`, `json()`, `arrayBuffer()` and `bytes()` read the whole body and return Promises.
+  - **Limit.** `SB_REQUEST_BODY_MAX` defaults to 100 MiB for streamed bodies (it stays 1 MiB before the date, where the body is held in memory whole). A larger `Content-Length` gets `413 Payload Too Large` before the handler runs; a chunked body that grows past it closes the connection, and the handler's stream fails.
+  - **Service bindings and `fetch()`.** On the broker transport, a `ReadableStream` request body goes out as it is read, in `FRAME_V1_MORE` frames after the request's head, instead of being read to the end first. The broker feeds them to the upstream request as a stream (with backpressure) and says so in its `ping` reply (`bodyStream: true`); against an older broker, bodies are sent whole as before. A streamed body can't follow a 307 or 308 redirect.
+  
+  Internal trigger and RPC calls keep buffered bodies. Before `2026-10-27` nothing changes: the handler gets the whole body at once and `request.text()` answers synchronously, which a deployed handler may rely on, hence the new date.
+
 ## 0.27.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.27.1",
+  "version": "0.29.0",
   "license": "MIT",
   "repository": {
     "type": "git",