@sproutboat/runtime 0.12.1 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/runtime
 
+## 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.0",
   "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
@@ -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/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");
+});