@sproutboat/runtime 0.12.1 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/runtime
 
+## 0.13.1
+
+### Patch Changes
+
+- ebee2ad: Non-ASCII text read back from bindings no longer comes back garbled (baronunread/sproutboat#189). D1 rows, KV values, cached bodies, R2 metadata and SQLite error messages returned "café" as "café" in both standalone builds and broker-backed deployments: the reply JSON is UTF-8, but it reached the handler one char per byte. Replies are now escaped to ASCII before parsing. Outbound `fetch()` bodies and BLOB columns keep their raw bytes.
+
+## 0.13.0
+
+### Minor Changes
+
+- 34083e1: Pass `(request, env, ctx)` to handlers built with compatibility dates from 2026-09-28. Older builds retain `(request, ctx)`. Add `Response.redirect()` for native fetch and decode request text as UTF-8 while preserving raw body bytes. The matching compiler Unicode fix shipped in `@sproutboat/toolchain@0.4.14`.
+
 ## 0.12.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/ingress-utf8.test.js

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+const src = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
+const decoder = src.slice(src.indexOf("function __sbFromUtf8("), src.indexOf("// sproutboat #181"));
+const ingress = src.slice(
+  src.indexOf("function __sbDecodeIngress("),
+  src.indexOf("globalThis.__sbEntry ="),
+);
+if (!decoder || !ingress) throw new Error("Ingress decoder source not found");
+// oxlint-disable-next-line no-function-constructor -- Exercise the text-only runtime prelude.
+const load = new Function(`${decoder}\n${ingress}\nreturn __sbDecodeIngress;`);
+const decode = load();
+const raw = (text) =>
+  Array.from(new TextEncoder().encode(text), (byte) => String.fromCharCode(byte)).join("");
+
+test("native ingress text and JSON decode Unicode without changing raw bytes", async () => {
+  const body = raw('{"id":"caffè-🚤"}');
+  const request = { body };
+  decode(request);
+  expect(await request.text()).toBe('{"id":"caffè-🚤"}');
+  expect(await request.json()).toEqual({ id: "caffè-🚤" });
+  expect(await request.text()).toBe('{"id":"caffè-🚤"}');
+  expect(request.body).toBe(body);
+});
+
+test("native ingress retains empty bodies and JSON parse errors", () => {
+  const empty = { body: "" };
+  decode(empty);
+  expect(empty.text()).toBe("");
+  expect(() => empty.json()).toThrow();
+  const invalid = { body: "{" };
+  decode(invalid);
+  expect(() => invalid.json()).toThrow();
+});
+
+test("a bodyless request keeps its existing methods", () => {
+  const text = () => "";
+  const request = { body: null, text };
+  decode(request);
+  expect(request.text).toBe(text);
+});

package/src/native-fetch-prelude.js

@@ -1,7 +1,7 @@
 // Prepended to every handler by tools/compile.ts, before Porffor's native-fetch
-// bundled handler. Porffor's runtime/fetch-globals.js (checked through alpha-4)
-// gives URL (href/origin/pathname/search only) and Response without a static
-// json(). This adds, additively, the rest of the WHATWG surface Worker code
+// bundled handler. Porffor's runtime/fetch-globals.js (checked through alpha-10)
+// gives URL (href/origin/pathname/search only) and Response without static
+// json() or redirect(). This adds, additively, the rest of the WHATWG surface Worker code
 // expects: URLSearchParams (read + write), URL.prototype.searchParams and the
 // protocol/host/hostname/port/hash accessors, static Response.json,
 // crypto.randomUUID / crypto.getRandomValues, crypto.subtle (digest + HMAC
@@ -18,7 +18,7 @@
 
 // Duck-typing helpers, `typeof`-free (the repo's anti-slop lint bans `typeof`;
 // these express the same spec-mandated checks and are verified under Porffor
-// alpha-4 by examples/kitchen-sink/harness.ts).
+// alpha-10 by examples/kitchen-sink/harness.ts).
 function __sbIsStr(v) {
   return Object(v) !== v && v === String(v);
 }
@@ -68,7 +68,7 @@ function __sbCpuMs() {
   return res === "" ? 0 : parseFloat(res);
 }
 
-// #28 — stamp `x-sb-cpu-ms` onto a handler Response. Porffor alpha-4's
+// #28 — stamp `x-sb-cpu-ms` onto a handler Response. Porffor alpha-10's
 // native-fetch serializer only reads headers from the plain object passed to
 // `new Response(body, { headers })` — a later `.set()` or a `Headers` instance
 // is ignored on the wire — so the metric is carried by rebuilding the Response
@@ -204,6 +204,16 @@ if (Response.json == null) {
   };
 }
 
+// Porffor alpha-10 has no static Response.redirect().
+if (Response.redirect == null) {
+  Response.redirect = function (url, status = 302) {
+    if (status !== 301 && status !== 302 && status !== 303 && status !== 307 && status !== 308) {
+      throw new RangeError("invalid redirect status");
+    }
+    return new Response("", { status, headers: { location: String(url) } });
+  };
+}
+
 // #59 — caches.default / caches.open(name), backed by the broker's cache.*
 // ops (a sibling SQLite table, key on method+URL for v1 — no Vary yet).
 // Deliberately NOT async: every other buffered-body method on this runtime
@@ -1262,9 +1272,9 @@ function __sbMakeD1(dbName) {
       return { count: (String(sql).match(/;/g) || []).length, duration: 0 };
     },
     // Sproutboat extension (not in CF Workers D1): an online, integrity-checked
-    // snapshot of this database. Standalone only for now — the broker transport
-    // returns an error until hosted backup (#139) covers it. `name` lands under
-    // `<data-dir>/backups/`; omit it for a timestamped default. See #164.
+    // snapshot of this database. Both transports implement it: standalone writes
+    // under `<data-dir>/backups/`, the broker under the resource directory's
+    // `backups/`. Omit `name` for a timestamped default. See #164.
     backup(name) {
       const r = __sbRpc("d1.backup", { db: dbName, name: name == null ? "" : String(name) });
       return { path: r.path, bytes: r.bytes };
@@ -2015,7 +2025,26 @@ async function __sbQueueWithDrain(result, tasks) {
   return new Response(JSON.stringify(r), { headers: { "content-type": "application/json" } });
 }
 
+// Native HTTP ingress stores the body as one character per raw byte. Keep
+// that representation for binary consumers, but decode text lazily before
+// handing the request to user code. Request.text() in Porffor otherwise treats
+// the raw bytes as already-decoded characters and corrupts Unicode/HMAC input.
+function __sbDecodeIngress(request) {
+  const raw = request.body;
+  if (raw == null) return;
+  let decoded = null;
+  request.text = function () {
+    if (decoded === null) decoded = __sbFromUtf8(raw);
+    return decoded;
+  };
+  request.json = function () {
+    if (decoded === null) decoded = __sbFromUtf8(raw);
+    return JSON.parse(decoded);
+  };
+}
+
 globalThis.__sbEntry = function (handlers, request) {
+  __sbDecodeIngress(request);
   const trigger = request.headers.get("x-sb-trigger");
   if (!trigger) {
     // #163/#128 — expose the request metadata the edge already has, the
@@ -2037,7 +2066,7 @@ globalThis.__sbEntry = function (handlers, request) {
     // concurrent in-process requests.
     //
     // Sync handlers only. An async handler's promise is handed straight back:
-    // Porffor alpha-4's native-fetch server resolves the promise the handler
+    // Porffor alpha-10's native-fetch server resolves the promise the handler
     // itself returned, but never one derived from `.then()`, so chaining the
     // tag on hangs the request forever. cpuMs is documented as absent for
     // async handlers (see LogEvent in services/edge) — that is this.
@@ -2050,7 +2079,9 @@ globalThis.__sbEntry = function (handlers, request) {
     };
     let __res;
     try {
-      __res = handlers.fetch(request, ctx);
+      __res = globalThis.__sbCompat >= "2026-09-28"
+        ? handlers.fetch(request, globalThis.env, ctx)
+        : handlers.fetch(request, ctx);
     } catch {
       // #179 — a synchronous throw anywhere in the handler must not take the
       // whole process (and every other in-flight request) down with it.
@@ -2077,10 +2108,10 @@ globalThis.__sbEntry = function (handlers, request) {
     };
     let __sres;
     try {
-      __sres = handlers.scheduled(
-        { cron: body.cron || "", scheduledTime: body.scheduledTime || Date.now(), noRetry() {} },
-        ctx,
-      );
+      const event = { cron: body.cron || "", scheduledTime: body.scheduledTime || Date.now(), noRetry() {} };
+      __sres = globalThis.__sbCompat >= "2026-09-28"
+        ? handlers.scheduled(event, globalThis.env, ctx)
+        : handlers.scheduled(event, ctx);
     } catch {
       // #179 — same rule as fetch: don't let a throw here crash the process.
       return new Response("", { status: 204 });
@@ -2167,7 +2198,9 @@ async function __sbRunQueueBatch(handlers, body, ctx) {
     },
   };
   try {
-    const __qres = handlers.queue(batch, ctx);
+    const __qres = globalThis.__sbCompat >= "2026-09-28"
+      ? handlers.queue(batch, globalThis.env, ctx)
+      : handlers.queue(batch, ctx);
     // Was fire-and-forget: an async `queue()` had this default-ack pass run (and
     // the response go out) before its own `await`s did, so any ack()/retry()
     // past the first one never counted.

package/src/source.ts

@@ -25,7 +25,7 @@ const alwaysForbidden: Array<[RegExp, string]> = [
   // match would also flag it appearing in an ordinary string a dependency
   // happens to construct (a doc link, a log message).
   [/['"`]node:/, "Node, Bun, and Deno APIs are not supported"],
-  // Porffor alpha-4 compiles `new Proxy(...)` and then ignores the handler: a
+  // The Porffor pin compiles `new Proxy(...)` and then ignores the handler: a
   // trapped property reads back as `undefined`, with no throw. Rejecting it
   // here is the difference between a build error and a 502 nobody can explain.
   // It is why itty-router and other Proxy-based routers do not work yet.

package/src/transport-broker.js

@@ -147,6 +147,66 @@ static int sb_broker_roundtrip(const char* req, size_t req_len, char** resp_out,
   return rc;
 }
 
+// baronunread/sproutboat#189 -- the broker writes its reply JSON as UTF-8,
+// but it reaches JS as a bytestring, one char per byte, so any non-ASCII text
+// (a D1 row, a KV value, a cached body) came back as Latin-1 mojibake. Non-ASCII
+// bytes only ever sit inside JSON strings, so rewriting each UTF-8 sequence as
+// \uXXXX gives the same JSON in pure ASCII, and JSON.parse rebuilds the real
+// strings. A byte that starts no valid sequence passes through as \u00XX.
+// Returns a malloc'd copy, or 0 when the reply is already ASCII.
+static char* sb_json_ascii(const char* s, size_t n, size_t* out_len) {
+  size_t high = 0;
+  for (size_t i = 0; i < n; i++) if ((unsigned char)s[i] >= 0x80) high++;
+  if (!high) return 0;
+  char* out = (char*)malloc(n + high * 12 + 1);
+  if (!out) return 0;
+  size_t o = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned char c = (unsigned char)s[i];
+    if (c < 0x80) { out[o++] = (char)c; continue; }
+    unsigned int cp = 0, min = 0;
+    size_t len = 0;
+    if ((c & 0xe0) == 0xc0) { cp = c & 0x1f; len = 2; min = 0x80; }
+    else if ((c & 0xf0) == 0xe0) { cp = c & 0x0f; len = 3; min = 0x800; }
+    else if ((c & 0xf8) == 0xf0) { cp = c & 0x07; len = 4; min = 0x10000; }
+    int ok = len > 0 && i + len <= n;
+    for (size_t k = 1; ok && k < len; k++) {
+      unsigned char cc = (unsigned char)s[i + k];
+      if ((cc & 0xc0) != 0x80) ok = 0;
+      else cp = (cp << 6) | (cc & 0x3f);
+    }
+    if (ok && (cp < min || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff))) ok = 0;
+    if (!ok) { o += (size_t)sprintf(out + o, "\\u%04x", c); continue; }
+    if (cp >= 0x10000) {
+      cp -= 0x10000;
+      o += (size_t)sprintf(out + o, "\\u%04x\\u%04x", 0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff));
+    } else {
+      o += (size_t)sprintf(out + o, "\\u%04x", cp);
+    }
+    i += len - 1;
+  }
+  out[o] = 0;
+  *out_len = o;
+  return out;
+}
+
+// fetch and service.fetch are the exception: their body is the upstream's
+// bytes, which the prelude keeps one char per byte (x-sb-raw-body) and decodes
+// itself. __sbRpc always writes {"v":1,"id":N,"op":... first, so the op is a
+// fixed-position prefix, not a search through user data.
+static int sb_req_is_fetch(const char* req, size_t n) {
+  const char* head = "{\"v\":1,\"id\":";
+  size_t hl = strlen(head);
+  if (n < hl || memcmp(req, head, hl) != 0) return 0;
+  size_t i = hl;
+  while (i < n && req[i] >= '0' && req[i] <= '9') i++;
+  const char* a = ",\"op\":\"fetch\"";
+  const char* b = ",\"op\":\"service.fetch\"";
+  if (n - i >= strlen(a) && memcmp(req + i, a, strlen(a)) == 0) return 1;
+  if (n - i >= strlen(b) && memcmp(req + i, b, strlen(b)) == 0) return 1;
+  return 0;
+}
+
 // A v1 exchange: marker, json length, json, then the body bytes. The reply is
 // split the same way, its JSON returned and its bytes stashed for __sbTakeBin.
 static int sb_broker_roundtrip_v1(const char* json, size_t json_len, const char* body, size_t body_len,
@@ -215,8 +275,12 @@ function __sbCall(reqJson) {
     porf_native_fetch_read_value(reqJson, &__req, &__reqlen, &__reqowned);
     char* __resp = 0; size_t __resplen = 0;
     int __rc = sb_broker_roundtrip(__req, __reqlen, &__resp, &__resplen);
+    int __raw = sb_req_is_fetch(__req, __reqlen);
     if (__reqowned) free(__reqowned);
     if (__rc == 0) {
+      size_t __al = 0;
+      char* __ascii = __raw ? 0 : sb_json_ascii(__resp, __resplen, &__al);
+      if (__ascii) { free(__resp); __resp = __ascii; __resplen = __al; }
       res = porf_box((f64)porf_native_fetch_alloc_bytestring(__resp, __resplen), 195);
       free(__resp);
     } else {
@@ -258,6 +322,9 @@ function __sbCallBin(reqJson, body) {
     if (__jo) free(__jo);
     if (__bo) free(__bo);
     if (__rc == 0) {
+      size_t __al = 0;
+      char* __ascii = sb_json_ascii(__resp, __resplen, &__al);
+      if (__ascii) { free(__resp); __resp = __ascii; __resplen = __al; }
       res = porf_box((f64)porf_native_fetch_alloc_bytestring(__resp, __resplen), 195);
       free(__resp);
     } else {

package/src/transport-embedded.js

@@ -184,6 +184,53 @@ static void sb_putjson(sb_buf* b, const char* s, size_t n) {
   }
   sb_put(b, "\"", 1);
 }
+// baronunread/sproutboat#189 -- sb_putjson for bytes that are UTF-8 text
+// (SQLite TEXT, its error messages). The reply reaches JS as a bytestring, one
+// char per byte, so a raw multi-byte sequence came back as Latin-1 mojibake
+// ("café" as "café"). Escaping every code point >= 0x80 as \uXXXX keeps the
+// reply pure ASCII and lets JSON.parse rebuild the real string. A byte that
+// doesn't start a valid sequence passes through as \u00XX, the same rule as
+// the prelude's __sbFromUtf8. Raw byte producers (the HTTP client's body,
+// BLOB columns) keep sb_putjson.
+static void sb_putjson_text(sb_buf* b, const char* s, size_t n) {
+  sb_put(b, "\"", 1);
+  for (size_t i = 0; i < n; i++) {
+    unsigned char c = (unsigned char)s[i];
+    if (c < 0x80) {
+      if (c == '"' || c == '\\') { char e[2] = { '\\', (char)c }; sb_put(b, e, 2); }
+      else if (c == '\n') sb_put(b, "\\n", 2);
+      else if (c == '\r') sb_put(b, "\\r", 2);
+      else if (c == '\t') sb_put(b, "\\t", 2);
+      else if (c < 0x20) { char e[8]; int k = snprintf(e, 8, "\\u%04x", c); sb_put(b, e, (size_t)k); }
+      else sb_put(b, (const char*)&c, 1);
+      continue;
+    }
+    unsigned int cp = 0, min = 0;
+    size_t len = 0;
+    if ((c & 0xe0) == 0xc0) { cp = c & 0x1f; len = 2; min = 0x80; }
+    else if ((c & 0xf0) == 0xe0) { cp = c & 0x0f; len = 3; min = 0x800; }
+    else if ((c & 0xf8) == 0xf0) { cp = c & 0x07; len = 4; min = 0x10000; }
+    int ok = len > 0 && i + len <= n;
+    for (size_t k = 1; ok && k < len; k++) {
+      unsigned char cc = (unsigned char)s[i + k];
+      if ((cc & 0xc0) != 0x80) ok = 0;
+      else cp = (cp << 6) | (cc & 0x3f);
+    }
+    if (ok && (cp < min || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff))) ok = 0;
+    char e[16];
+    int k;
+    if (!ok) { k = snprintf(e, sizeof(e), "\\u%04x", c); sb_put(b, e, (size_t)k); continue; }
+    if (cp >= 0x10000) {
+      cp -= 0x10000;
+      k = snprintf(e, sizeof(e), "\\u%04x\\u%04x", 0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff));
+    } else {
+      k = snprintf(e, sizeof(e), "\\u%04x", cp);
+    }
+    sb_put(b, e, (size_t)k);
+    i += len - 1;
+  }
+  sb_put(b, "\"", 1);
+}
 
 // --- the narrow JSON reader: a flat array of null | number | string ----------
 // Only ever fed __sbSql's own params, which JS builds; anything unexpected
@@ -495,7 +542,7 @@ static char* sb_r2_put_c(const char* path, const char* bucket, const char* key,
     if (strcmp(previous, etag) != 0) unlink(blobpath);
     sb_puts(&out, "{\"ok\":false,\"error\":");
     const char* m = sqlite3_errmsg(db);
-    sb_putjson(&out, m, strlen(m));
+    sb_putjson_text(&out, m, strlen(m));
     sb_puts(&out, "}");
     return out.p;
   }
@@ -817,7 +864,7 @@ static char* sb_sql_script(const char* path, const char* sql) {
   char* err = 0;
   if (sqlite3_exec(sb_dbs[idx], sql, 0, 0, &err) != 0) {
     sb_puts(&b, "{\"ok\":false,\"error\":");
-    sb_putjson(&b, err ? err : "exec failed", err ? strlen(err) : 11);
+    sb_putjson_text(&b, err ? err : "exec failed", err ? strlen(err) : 11);
     sb_puts(&b, "}");
     return b.p;
   }
@@ -837,7 +884,7 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
   if (!st) {
     sb_puts(&b, "{\"ok\":false,\"error\":");
     const char* m = sqlite3_errmsg(db);
-    sb_putjson(&b, m, strlen(m));
+    sb_putjson_text(&b, m, strlen(m));
     sb_puts(&b, "}");
     return b.p;
   }
@@ -848,7 +895,7 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
   for (int i = 0; i < ncol; i++) {
     if (i) sb_puts(&b, ",");
     const char* name = sqlite3_column_name(st, i);
-    sb_putjson(&b, name ? name : "", name ? strlen(name) : 0);
+    sb_putjson_text(&b, name ? name : "", name ? strlen(name) : 0);
   }
   sb_puts(&b, "],\"rows\":[");
   int rc, first = 1;
@@ -868,7 +915,9 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
       }
       const unsigned char* txt = sqlite3_column_text(st, i);
       int n = sqlite3_column_bytes(st, i);
-      sb_putjson(&b, txt ? (const char*)txt : "", txt ? (size_t)n : 0);
+      // TEXT is UTF-8 and decodes (#189); a BLOB stays one char per byte.
+      if (t == 4) sb_putjson(&b, txt ? (const char*)txt : "", txt ? (size_t)n : 0);
+      else sb_putjson_text(&b, txt ? (const char*)txt : "", txt ? (size_t)n : 0);
     }
     sb_puts(&b, "]");
   }
@@ -883,7 +932,7 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
     sb_buf e = { 0, 0, 0 };
     sb_puts(&e, "{\"ok\":false,\"error\":");
     const char* m = sqlite3_errmsg(db);
-    sb_putjson(&e, m, strlen(m));
+    sb_putjson_text(&e, m, strlen(m));
     sb_puts(&e, "}");
     return e.p;
   }
@@ -909,7 +958,7 @@ static char* sb_sql_backup(const char* src_path, const char* dest_path) {
   if (sqlite3_prepare_v2(db, "VACUUM INTO ?1", -1, &st, 0) != 0 || !st) {
     sb_puts(&b, "{\"ok\":false,\"error\":");
     const char* m = sqlite3_errmsg(db);
-    sb_putjson(&b, m, strlen(m));
+    sb_putjson_text(&b, m, strlen(m));
     sb_puts(&b, "}");
     return b.p;
   }
@@ -919,7 +968,7 @@ static char* sb_sql_backup(const char* src_path, const char* dest_path) {
   if (rc != SB_SQLITE_DONE) {
     sb_puts(&b, "{\"ok\":false,\"error\":");
     const char* m = sqlite3_errmsg(db);
-    sb_putjson(&b, m, strlen(m));
+    sb_putjson_text(&b, m, strlen(m));
     sb_puts(&b, "}");
     return b.p;
   }
@@ -1097,7 +1146,7 @@ static char* sb_error_json(const char* prefix, const char* detail) {
   sb_buf msg = { 0, 0, 0 };
   sb_puts(&msg, prefix);
   if (detail) { sb_puts(&msg, detail); }
-  sb_putjson(&out, msg.p ? msg.p : "", msg.len);
+  sb_putjson_text(&out, msg.p ? msg.p : "", msg.len);
   sb_puts(&out, "}");
   free(msg.p);
   return out.p;

package/src/workers-handler.test.js

@@ -0,0 +1,59 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+
+const source = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
+// oxlint-disable-next-line no-function-constructor -- the prelude is prepended as text in production too
+const load = new Function(
+  "Porffor",
+  `${source}\n__sbTriggerAuthed = () => true; return { entry: __sbEntry, queue: __sbRunQueueBatch };`,
+);
+const { entry, queue } = load({ c: () => "" });
+const request = () => ({ headers: { get: () => null }, body: null });
+
+test("the Workers compatibility date passes env and ctx in their standard positions", async () => {
+  globalThis.__sbCompat = "2026-09-28";
+  globalThis.env = { GREETING: "hello" };
+  const response = entry({ fetch(_request, env, ctx) {
+    return new Response(env.GREETING + ":" + (ctx.waitUntil instanceof Function));
+  } }, request());
+  expect(await response.text()).toBe("hello:true");
+});
+
+test("earlier compatibility dates retain ctx as the second argument", async () => {
+  globalThis.__sbCompat = "2026-09-07";
+  const response = entry({ fetch(_request, ctx) {
+    return new Response(String(ctx.waitUntil instanceof Function));
+  } }, request());
+  expect(await response.text()).toBe("true");
+});
+
+test("Response.redirect produces a Location header and empty body", async () => {
+  const response = Response.redirect("https://example.com/next", 301);
+  expect(response.status).toBe(301);
+  expect(response.headers.get("location")).toBe("https://example.com/next");
+  expect(await response.text()).toBe("");
+});
+
+test("queue handlers receive env and ctx with the Workers compatibility date", async () => {
+  globalThis.__sbCompat = "2026-09-28";
+  globalThis.env = { GREETING: "hello" };
+  let seen = "";
+  await queue({ queue(_batch, env, ctx) {
+    seen = env.GREETING + ":" + (ctx.waitUntil instanceof Function);
+  } }, { messages: [] }, { waitUntil() {} });
+  expect(seen).toBe("hello:true");
+});
+
+test("scheduled handlers receive env and ctx with the Workers compatibility date", () => {
+  globalThis.__sbCompat = "2026-09-28";
+  globalThis.env = { GREETING: "hello" };
+  let seen = "";
+  const response = entry({ scheduled(_event, env, ctx) {
+    seen = env.GREETING + ":" + (ctx.waitUntil instanceof Function);
+  } }, {
+    headers: { get: (name) => name === "x-sb-trigger" ? "scheduled" : null },
+    body: "{}",
+  });
+  expect(response.status).toBe(204);
+  expect(seen).toBe("hello:true");
+});

package/test/native-utf8.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { createBroker, listen } from "../../wire/src/broker";
+import { EMPTY_BINDINGS, preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// baronunread/sproutboat#189: text read back through the broker came back as
+// Latin-1 mojibake ("café" as "café"), because the reply JSON is UTF-8 and the
+// sprout holds it one char per byte. Covers 2-, 3- and 4-byte sequences on the
+// two hot paths (KV, D1) and a non-ASCII SQLite error message.
+const text = "/café/日本/😀/x";
+
+const handler = `
+export default {
+  async fetch() {
+    await env.KV.put("k", ${JSON.stringify(text)});
+    const kv = await env.KV.get("k");
+    await env.DB.prepare("CREATE TABLE t (v TEXT)").run();
+    await env.DB.prepare("INSERT INTO t (v) VALUES (?)").bind(${JSON.stringify(text)}).run();
+    const d1 = (await env.DB.prepare("SELECT v FROM t").first()).v;
+    let error = "";
+    try { await env.DB.prepare("SELECT * FROM tabellà").first(); } catch (e) { error = String(e.message); }
+    return Response.json({ kv, kvLength: kv.length, d1, d1Length: d1.length, error });
+  },
+};
+`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-utf8-"));
+const bindings = { ...EMPTY_BINDINGS, kv: ["KV"], d1: ["DB"] };
+const broker = createBroker({
+  db: ":memory:",
+  token: "native-utf8",
+  bindings: { ...bindings, resources: {} },
+});
+const brokerServer = listen(broker, "127.0.0.1", 0);
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor({ cacheRoot: workdir });
+  const node = Bun.which("node");
+  if (!node) throw new Error("native UTF-8 test needs node on PATH");
+
+  const [core, transport] = await Promise.all([
+    readFile(preludePath, "utf8"),
+    readFile(transportPath("broker"), "utf8"),
+  ]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const generated = join(workdir, "utf8.generated.js");
+  const binary = join(workdir, "utf8-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, transport), {}, bindings));
+
+  const compile = Bun.spawn([node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"], {
+    cwd: workdir,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    compile.exited,
+    new Response(compile.stdout).text(),
+    new Response(compile.stderr).text(),
+  ]);
+  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+
+  const port = freePort();
+  server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: {
+      ...process.env,
+      PORT: String(port),
+      SB_BROKER_PORT: String(brokerServer.port),
+      SB_BROKER_TOKEN: "native-utf8",
+    },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(2000) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled UTF-8 handler did not start");
+  assert.equal(response.status, 200);
+  // SAFETY: the handler above is the only producer of this body and always
+  // returns exactly these five fields; deepEqual below checks every one.
+  const body = (await response.json()) as { kv: string; kvLength: number; d1: string; d1Length: number; error: string };
+  assert.deepEqual(
+    { kv: body.kv, kvLength: body.kvLength, d1: body.d1, d1Length: body.d1Length },
+    { kv: text, kvLength: text.length, d1: text, d1Length: text.length },
+  );
+  assert.match(body.error, /tabellà/);
+  console.log("Non-ASCII KV, D1 and error text round-trip through the broker");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  brokerServer.stop();
+  broker.close();
+  await rm(workdir, { recursive: true, force: true });
+}