@sproutboat/runtime 0.11.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @sproutboat/runtime
 
+## 0.12.1
+
+### Patch Changes
+
+- ed9640a: Point Porffor patch diagnostics, runtime comments, and historical notes to the
+  shared upstream notes in the Sproutboat platform repository.
+
+## 0.12.0
+
+### Minor Changes
+
+- 4a7fe62: Cache API: `caches.default` / `caches.open(name)` (baronunread/sproutboat#59), with `match()`/`put()`/`delete()` backed by both transports (broker's `cache.*` ops and the standalone embedded transport, so behavior matches whichever way the app deploys). Keyed on method+URL for v1 (no `Vary` support yet). `put()` throws for a non-GET request, matching the spec; a 206 status or an explicit `no-store`/`private` `Cache-Control` is a silent no-op rather than an error, matching Workers' own `caches.default`. TTL derives from `s-maxage` (preferred) or `max-age`; entries with neither have no expiry.
+  
+  Deliberately synchronous, not Promise-returning: every other buffered-body method this runtime already ships (`text()`/`json()`/`arrayBuffer()`/`blob()`/`formData()`) is sync too, and this runtime's own coroutine machinery has a known, still-open memory-corruption issue tied specifically to nested `async function` calls accumulating across many requests (baronunread/sproutboat#168) — no reason to add more async surface here. `await caches.default.match(...)` still reads correctly: awaiting a non-promise value resolves to it immediately.
+- 96f97e2: `Request`/`Response` gain `formData()` (baronunread/sproutboat#60), parsing the buffered body synchronously — `application/x-www-form-urlencoded` via the existing `URLSearchParams` shim, `multipart/form-data` by hand (RFC 7578 boundary parsing, file fields come back as `Blob`s). Also adds `bytes()` (the `Uint8Array` shorthand over `arrayBuffer()`) to both classes. Everything is feature-detected, so this is a no-op the moment Porffor ships either natively.
+
+### Patch Changes
+
+- 81dc1f7: Preserve raw bytes in `crypto.subtle.digest`, HMAC signing, and `crypto.scryptVerify`. The runtime's byte conversion already produces UTF-8 bytes for text and copies BufferSource inputs exactly, so the native bridge must pass those bytes through without encoding them again. This fixes repeated HMAC signing with digest bytes above `0x7f`.
+
 ## 0.11.0
 
 ### Minor Changes
@@ -118,11 +138,11 @@
   
   Verified end-to-end against both transports (kitchen-sink's full conformance suite, 24/24 standalone + 27/27 broker) and with new unit tests for file-backed persistence, the `:memory:` fallback, and a real binary round-trip over the v1 wire protocol.
   
-  **Known limitation found while verifying this, not fixed here:** a binary `put()` body (bytes ≥ 0x80) is corrupted on the way *in*, before it ever reaches storage — `porf_native_fetch_read_value` (the function every inline-C string read in the runtime goes through) always UTF-8-encodes a Latin-1-range string on read, which is correct for genuine text but wrong for opaque bytes coming off a raw HTTP body. This predates this change (the old SQLite-blob path had the identical corruption) and is not something the storage backend can fix — it needs an input-side counterpart to `#176`'s `x-sb-raw-body` marker, or real `ArrayBuffer`/`Uint8Array` body support (the upstream ask already filed as Draft G in `patches/UPSTREAM.md`).
+  **Known limitation found while verifying this, not fixed here:** a binary `put()` body (bytes ≥ 0x80) is corrupted on the way *in*, before it ever reaches storage: `porf_native_fetch_read_value` (the function every inline-C string read in the runtime goes through) always UTF-8-encodes a Latin-1-range string on read, which is correct for genuine text but wrong for opaque bytes coming off a raw HTTP body. This predates this change (the old SQLite-blob path had the identical corruption) and is not something the storage backend can fix. It needs an input-side counterpart to `#176`'s `x-sb-raw-body` marker, or real `ArrayBuffer`/`Uint8Array` body support (the upstream ask was filed as Porffor #386 and later retracted; see `https://github.com/baronunread/sproutboat/blob/main/patches/upstream/request-body-report-386.md`).
 
 ### Patch Changes
 
-- 188d8e4: Fix (baronunread/sproutboat#184): a `put()` body (R2, both transports) with bytes ≥ 0x80 was corrupted on the way *in*, before storage — `porf_native_fetch_read_value` (the one function every inline-C string read in the runtime funnels through) always UTF-8-encodes a Latin-1-range value, correct for genuine text, wrong for opaque bytes off a raw HTTP upload. A 256-byte binary upload landed as 384 stored bytes.
+- 188d8e4: Fix (baronunread/sproutboat#184): a `put()` body (R2, both transports) with bytes ≥ 0x80 was corrupted on the way *in*, before storage: `porf_native_fetch_read_value` (the one function every inline-C string read in the runtime funnels through) always UTF-8-encodes a Latin-1-range value, correct for genuine text, wrong for opaque bytes off a raw HTTP upload. A 256-byte binary upload landed as 384 stored bytes.
   
   `__sbR2PutRaw` (embedded) and `__sbCallBin` (broker, the only caller that ever passes it a real body) now try `porf_native_fetch_read_raw_bytes` first, falling back to the normal encoding path only for a genuine multi-byte JS string (which isn't a "bytestring" and so isn't eligible for the raw read anyway). This predates the #56 storage change — the old SQLite-blob `put()` called the identical `read_value`, so it was equally corrupted; the existing R2 conformance check never caught it because it only ever exercises a plain ASCII string.
   

package/package.json

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

package/src/form-data.test.js

@@ -0,0 +1,81 @@
+// #60 — the FormData parsing helpers live inline in native-fetch-prelude.js
+// (the prelude is prepended as text and cannot import), so this test lifts
+// that block out and exercises it directly. Bun already provides real
+// FormData/Blob/URLSearchParams globals, so the lifted parser functions run
+// against those rather than the prelude's own guarded shims (which no-op
+// here since Bun already has the globals they'd otherwise install) — the
+// parsing logic itself is what's under test, and it's spec surface either way.
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const src = readFileSync(fileURLToPath(new URL("./native-fetch-prelude.js", import.meta.url)), "utf8");
+const start = src.indexOf("function __sbParseUrlencodedFormData(");
+const end = src.indexOf('if (!("formData" in Request.prototype))');
+if (start === -1 || end === -1 || end < start) throw new Error("FormData parsing block not found in prelude");
+
+// oxlint-disable-next-line no-function-constructor -- lifting a pure block out of the text-only prelude for test
+const load = new Function(
+  `${src.slice(start, end)}\n   return { __sbParseUrlencodedFormData, __sbParseMultipartFormData, __sbFormDataFromBody };`,
+);
+const { __sbParseUrlencodedFormData, __sbParseMultipartFormData, __sbFormDataFromBody } = load();
+
+const headers = (contentType) => ({ get: (k) => (k.toLowerCase() === "content-type" ? contentType : null) });
+
+test("urlencoded: decodes fields, including repeated keys and +/percent escapes", () => {
+  const fd = __sbParseUrlencodedFormData("name=Ren%C3%A9&tag=a&tag=b&note=hi+there");
+  expect(fd.get("name")).toBe("René");
+  expect(fd.getAll("tag")).toEqual(["a", "b"]);
+  expect(fd.get("note")).toBe("hi there");
+});
+
+test("urlencoded: empty body yields an empty FormData", () => {
+  const fd = __sbParseUrlencodedFormData("");
+  expect(fd.get("anything")).toBeNull();
+});
+
+test("multipart: parses a text field and a file field from a real boundary", () => {
+  const boundary = "----sbTestBoundary123";
+  const body =
+    `--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="title"\r\n\r\n` +
+    `hello world\r\n` +
+    `--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="upload"; filename="a.txt"\r\n` +
+    `Content-Type: text/plain\r\n\r\n` +
+    `file contents\r\n` +
+    `--${boundary}--\r\n`;
+  const fd = __sbParseMultipartFormData(body, boundary);
+  expect(fd.get("title")).toBe("hello world");
+  const file = fd.get("upload");
+  expect(file instanceof Blob).toBe(true);
+});
+
+test("multipart: a part with no name= is skipped rather than throwing", () => {
+  const boundary = "B";
+  const body = `--B\r\nContent-Disposition: form-data\r\n\r\nignored\r\n--B\r\nContent-Disposition: form-data; name="k"\r\n\r\nv\r\n--B--\r\n`;
+  const fd = __sbParseMultipartFormData(body, boundary);
+  expect(fd.get("k")).toBe("v");
+  expect(fd.has("")).toBe(false);
+});
+
+test("__sbFormDataFromBody: dispatches on content-type, quoted or bare boundary", () => {
+  const urlencoded = __sbFormDataFromBody(headers("application/x-www-form-urlencoded"), "a=1");
+  expect(urlencoded.get("a")).toBe("1");
+
+  const bareBoundary = __sbFormDataFromBody(
+    headers("multipart/form-data; boundary=XYZ"),
+    `--XYZ\r\nContent-Disposition: form-data; name="a"\r\n\r\n1\r\n--XYZ--\r\n`,
+  );
+  expect(bareBoundary.get("a")).toBe("1");
+
+  const quotedBoundary = __sbFormDataFromBody(
+    headers('multipart/form-data; boundary="XYZ"'),
+    `--XYZ\r\nContent-Disposition: form-data; name="a"\r\n\r\n1\r\n--XYZ--\r\n`,
+  );
+  expect(quotedBoundary.get("a")).toBe("1");
+});
+
+test("__sbFormDataFromBody: multipart with no boundary throws instead of silently misparsing", () => {
+  expect(() => __sbFormDataFromBody(headers("multipart/form-data"), "")).toThrow(/boundary/);
+});

package/src/native-fetch-prelude.js

@@ -1,17 +1,20 @@
 // Prepended to every handler by tools/compile.ts, before Porffor's native-fetch
-// esbuild bundle. Porffor's runtime/fetch-globals.js (checked through alpha-4)
+// 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
 // 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
-// sign/verify, #133), and structuredClone. Each is feature-detected; delete a
-// block once Porffor ships that global. crypto.scryptVerify (#153) is a
-// Sproutboat extension, not WHATWG, and stays.
-// Tracked upstream in patches/UPSTREAM.md.
+// sign/verify, #133), structuredClone, and FormData + Request/Response
+// formData()/bytes() (#60). Each is feature-detected; delete a block once
+// Porffor ships that global. crypto.scryptVerify (#153) is a Sproutboat
+// extension, not WHATWG, and stays.
+// Tracked in the platform's upstream notes:
+// https://github.com/baronunread/sproutboat/blob/main/patches/upstream/whatwg-fetch-globals.md
 //
 // Declared before it is referenced: a getter body that names a later top-level
-// class throws ReferenceError in Porffor (see patches/UPSTREAM.md draft B).
+// class throws ReferenceError in Porffor. See:
+// https://github.com/baronunread/sproutboat/blob/main/patches/upstream/class-declaration-scope.md
 
 // 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
@@ -201,10 +204,192 @@ if (Response.json == null) {
   };
 }
 
+// #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
+// (text/json/arrayBuffer/blob, formData above) is sync too, and #168's own
+// investigation found real coroutine-state corruption tied specifically to
+// nested `async function` calls accumulating across many requests — no
+// reason to add more async surface to that here. `await`ing a non-promise
+// still resolves immediately, so `await caches.default.match(...)` reads
+// exactly like the spec's Promise-returning version to calling code.
+if (globalThis.caches == null) {
+  function __sbCacheKey(request) {
+    return "GET " + (__sbIsStr(request) ? request : request.url);
+  }
+  class __SproutboatCache {
+    constructor(name) {
+      this._name = name;
+    }
+    match(request) {
+      const r = __sbRpc("cache.match", { name: this._name, key: __sbCacheKey(request) });
+      if (!r.found) return undefined;
+      return new Response(r.body, { status: r.status, headers: r.headers });
+    }
+    put(request, response) {
+      const method = __sbIsStr(request) ? "GET" : request.method;
+      if (method !== "GET") throw new TypeError("Cache.put: request method must be GET");
+      const headers = {};
+      response.headers.forEach((value, name) => {
+        headers[name] = value;
+      });
+      __sbRpc("cache.put", {
+        name: this._name,
+        key: __sbCacheKey(request),
+        status: response.status,
+        headers,
+        body: response.text(),
+      });
+      return undefined;
+    }
+    delete(request) {
+      return !!__sbRpc("cache.delete", { name: this._name, key: __sbCacheKey(request) }).deleted;
+    }
+  }
+  const __sbCacheInstances = new Map();
+  globalThis.caches = {
+    default: new __SproutboatCache("default"),
+    open(name) {
+      const key = String(name);
+      let instance = __sbCacheInstances.get(key);
+      if (!instance) {
+        instance = new __SproutboatCache(key);
+        __sbCacheInstances.set(key, instance);
+      }
+      return instance;
+    },
+  };
+}
+
+// #60 — Porffor's Request/Response give text()/json()/arrayBuffer()/blob()
+// synchronously (buffered body, fine under http-sync-v0) but no FormData at
+// all. Parses the same buffered body, synchronously, into a FormData-like
+// object; url-encoded via the URLSearchParams shim above, multipart by hand
+// (RFC 7578: boundary-delimited parts, each a header block then a blank line
+// then the part body — one pass, no nested multipart).
+if (globalThis.FormData == null) {
+  class __SproutboatFormData {
+    constructor() {
+      this._entries = [];
+    }
+    append(name, value, filename) {
+      this._entries.push([String(name), value, filename]);
+    }
+    set(name, value, filename) {
+      name = String(name);
+      let replaced = false;
+      this._entries = this._entries.filter((e) => {
+        if (e[0] !== name) return true;
+        if (replaced) return false;
+        e[1] = value;
+        e[2] = filename;
+        replaced = true;
+        return true;
+      });
+      if (!replaced) this.append(name, value, filename);
+    }
+    get(name) {
+      for (let i = 0; i < this._entries.length; i++) if (this._entries[i][0] === name) return this._entries[i][1];
+      return null;
+    }
+    getAll(name) {
+      const out = [];
+      for (let i = 0; i < this._entries.length; i++) if (this._entries[i][0] === name) out.push(this._entries[i][1]);
+      return out;
+    }
+    has(name) {
+      for (let i = 0; i < this._entries.length; i++) if (this._entries[i][0] === name) return true;
+      return false;
+    }
+    delete(name) {
+      this._entries = this._entries.filter((e) => e[0] !== name);
+    }
+    forEach(cb) {
+      for (let i = 0; i < this._entries.length; i++) cb(this._entries[i][1], this._entries[i][0], this);
+    }
+    keys() {
+      return this._entries.map((e) => e[0]);
+    }
+    values() {
+      return this._entries.map((e) => e[1]);
+    }
+    entries() {
+      return this._entries.map((e) => [e[0], e[1]]);
+    }
+  }
+  globalThis.FormData = __SproutboatFormData;
+}
+
+function __sbParseUrlencodedFormData(text) {
+  const fd = new FormData();
+  // forEach, not keys()/values() — those are spec'd as iterators, not
+  // arrays, and this shim's own URLSearchParams.keys()/values() return
+  // arrays as an implementation shortcut, so relying on either shape here
+  // would break against whichever kind actually ends up installed.
+  new URLSearchParams(text).forEach((value, key) => fd.append(key, value));
+  return fd;
+}
+
+function __sbParseMultipartFormData(text, boundary) {
+  const fd = new FormData();
+  const delim = "--" + boundary;
+  const segments = text.split(delim);
+  // segments[0] is the preamble, the last is the closing "--" epilogue.
+  for (let i = 1; i < segments.length - 1; i++) {
+    let part = segments[i];
+    if (part.slice(0, 2) === "\r\n") part = part.slice(2);
+    if (part.slice(-2) === "\r\n") part = part.slice(0, -2);
+    const headerEnd = part.indexOf("\r\n\r\n");
+    if (headerEnd === -1) continue;
+    const headerText = part.slice(0, headerEnd);
+    const body = part.slice(headerEnd + 4);
+    const nameMatch = /name="([^"]*)"/i.exec(headerText);
+    if (!nameMatch) continue;
+    const filenameMatch = /filename="([^"]*)"/i.exec(headerText);
+    if (filenameMatch) fd.append(nameMatch[1], new Blob([body]), filenameMatch[1]);
+    else fd.append(nameMatch[1], body);
+  }
+  return fd;
+}
+
+function __sbFormDataFromBody(headers, text) {
+  const contentType = headers.get("content-type") || "";
+  if (contentType.indexOf("multipart/form-data") !== -1) {
+    const boundaryMatch = /boundary=(?:"([^"]*)"|([^;]+))/i.exec(contentType);
+    const boundary = boundaryMatch ? (boundaryMatch[1] || boundaryMatch[2]).trim() : null;
+    if (!boundary) throw new TypeError("multipart/form-data body has no boundary");
+    return __sbParseMultipartFormData(text, boundary);
+  }
+  return __sbParseUrlencodedFormData(text);
+}
+
+if (!("formData" in Request.prototype)) {
+  Request.prototype.formData = function () {
+    return __sbFormDataFromBody(this.headers, this.text());
+  };
+}
+if (!("formData" in Response.prototype)) {
+  Response.prototype.formData = function () {
+    return __sbFormDataFromBody(this.headers, this.text());
+  };
+}
+// #60 — the newer Uint8Array shorthand, trivial on top of arrayBuffer().
+if (!("bytes" in Request.prototype)) {
+  Request.prototype.bytes = function () {
+    return new Uint8Array(this.arrayBuffer());
+  };
+}
+if (!("bytes" in Response.prototype)) {
+  Response.prototype.bytes = function () {
+    return new Uint8Array(this.arrayBuffer());
+  };
+}
+
 // Porffor's URL exposes href / origin / pathname / search only. Add the rest of
 // the WHATWG read surface, derived from `origin` (scheme://host[:port]).
 // `hash` is always '' server-side — browsers strip the fragment before the
-// request, so there is nothing to recover. Tracked upstream (patches/UPSTREAM.md).
+// request, so there is nothing to recover. See:
+// https://github.com/baronunread/sproutboat/blob/main/patches/upstream/whatwg-fetch-globals.md
 function __sbDefineURLAccessor(name, get) {
   if (!(name in URL.prototype)) Object.defineProperty(URL.prototype, name, { configurable: true, get });
 }
@@ -586,6 +771,7 @@ Porffor.c`
 
 u32 porf_native_fetch_alloc_bytestring(const char* input, size_t len);
 int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned);
+int porf_native_fetch_read_raw_bytes(jsval value, const char** out_buf, size_t* out_len);
 
 // --- #133: SHA-2 + HMAC ---------------------------------------------------
 // Standalone links BearSSL, but a deployed sprout does not, and this inline C
@@ -917,8 +1103,8 @@ function __sbRandomBytes(nStr) {
   return out;
 }
 
-// #133 — one-shot SHA-2 digest. `algoStr` is "256"|"384"|"512"; `data` is a
-// latin1 string (one char per byte). Returns the raw digest as a bytestring.
+// #133: one-shot SHA-2 digest. `algoStr` is "256"|"384"|"512"; `data` is a
+// bytestring (one char per byte). Returns the raw digest as a bytestring.
 // oxlint-disable-next-line no-unused-vars -- read inside the RawC block, not by JS.
 function __sbDigestRaw(algoStr, data) {
   let out = "";
@@ -931,17 +1117,17 @@ function __sbDigestRaw(algoStr, data) {
     if (__aso) free(__aso);
     int __algo = atoi(__ab);
 
-    const char* __d; size_t __dl; char* __do = 0;
-    porf_native_fetch_read_value(data, &__d, &__dl, &__do);
+    const char* __d = 0; size_t __dl = 0;
+    // __sbToBytes has already encoded text. The generic reader would encode high bytes again.
+    int __raw = porf_native_fetch_read_raw_bytes(data, &__d, &__dl);
     unsigned char __out[64];
-    size_t __n = sb_digest(__algo, (const unsigned char*)__d, __dl, __out);
-    if (__do) free(__do);
+    size_t __n = __raw == 0 ? sb_digest(__algo, (const unsigned char*)__d, __dl, __out) : 0;
     if (__n) out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__out, __n), 195);
   `;
   return out;
 }
 
-// #133 — HMAC-SHA-2. `algoStr` "256"|"384"|"512"; `key` and `data` latin1.
+// #133: HMAC-SHA-2. `algoStr` "256"|"384"|"512"; `key` and `data` are bytestrings.
 // Returns the raw MAC as a bytestring.
 // oxlint-disable-next-line no-unused-vars -- read inside the RawC block, not by JS.
 function __sbHmacRaw(algoStr, key, data) {
@@ -955,17 +1141,15 @@ function __sbHmacRaw(algoStr, key, data) {
     if (__aso) free(__aso);
     int __algo = atoi(__ab);
 
-    const char* __k; size_t __kl; char* __ko = 0;
-    porf_native_fetch_read_value(key, &__k, &__kl, &__ko);
-    unsigned char* __kc = (unsigned char*)malloc(__kl ? __kl : 1);
+    const char* __k = 0; size_t __kl = 0;
+    int __key_raw = porf_native_fetch_read_raw_bytes(key, &__k, &__kl);
+    unsigned char* __kc = __key_raw == 0 ? (unsigned char*)malloc(__kl ? __kl : 1) : 0;
     if (__kc) memcpy(__kc, __k, __kl);
-    if (__ko) free(__ko);
 
-    const char* __d; size_t __dl; char* __do = 0;
-    porf_native_fetch_read_value(data, &__d, &__dl, &__do);
+    const char* __d = 0; size_t __dl = 0;
+    int __data_raw = porf_native_fetch_read_raw_bytes(data, &__d, &__dl);
     unsigned char __out[64];
-    size_t __n = __kc ? sb_hmac(__algo, __kc, __kl, (const unsigned char*)__d, __dl, __out) : 0;
-    if (__do) free(__do);
+    size_t __n = __kc && __data_raw == 0 ? sb_hmac(__algo, __kc, __kl, (const unsigned char*)__d, __dl, __out) : 0;
     if (__kc) free(__kc);
     if (__n) out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__out, __n), 195);
   `;
@@ -979,17 +1163,15 @@ function __sbScryptRaw(pw, salt, nStr, rStr, pStr, dkLenStr) {
   let out = "";
   // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
   Porffor.c`
-    const char* __p; size_t __pl; char* __po = 0;
-    porf_native_fetch_read_value(pw, &__p, &__pl, &__po);
-    unsigned char* __pc = (unsigned char*)malloc(__pl ? __pl : 1);
+    const char* __p = 0; size_t __pl = 0;
+    int __pw_raw = porf_native_fetch_read_raw_bytes(pw, &__p, &__pl);
+    unsigned char* __pc = __pw_raw == 0 ? (unsigned char*)malloc(__pl ? __pl : 1) : 0;
     if (__pc) memcpy(__pc, __p, __pl);
-    if (__po) free(__po);
 
-    const char* __s; size_t __sl; char* __so = 0;
-    porf_native_fetch_read_value(salt, &__s, &__sl, &__so);
-    unsigned char* __sc = (unsigned char*)malloc(__sl ? __sl : 1);
+    const char* __s = 0; size_t __sl = 0;
+    int __salt_raw = porf_native_fetch_read_raw_bytes(salt, &__s, &__sl);
+    unsigned char* __sc = __salt_raw == 0 ? (unsigned char*)malloc(__sl ? __sl : 1) : 0;
     if (__sc) memcpy(__sc, __s, __sl);
-    if (__so) free(__so);
 
     long __N = 0, __r = 0, __pp = 0, __dk = 0;
     { const char* q; size_t ql; char* qo = 0; char nb[24];
@@ -1637,7 +1819,8 @@ function __sbTriggerAuthed(request) {
 // #163 — the connection's remote address, for `request.cf.clientIp`.
 //
 // `x-sb-remote-addr` is the TCP peer, appended by the server (see
-// patches/UPSTREAM.md #163) and stripped from anything a client sends, so it
+// https://github.com/baronunread/sproutboat/blob/main/patches/upstream/remote-address.md)
+// and stripped from anything a client sends, so it
 // cannot be forged. With no proxy in front, that is the client. Behind one, set
 // `SB_TRUSTED_PROXIES` to a comma-separated list of trusted CIDRs (or bare IPs):
 // when the peer is trusted, the client is the rightmost `x-forwarded-for` entry

package/src/transport-embedded.js

@@ -1854,6 +1854,11 @@ function __sbEnsureSchema() {
     s,
     "CREATE TABLE IF NOT EXISTS ratelimit (name TEXT NOT NULL, key TEXT NOT NULL, window_start INTEGER NOT NULL, count INTEGER NOT NULL, PRIMARY KEY (name, key))",
   );
+  // #59 — caches.default, ambient like the broker's copy of this table.
+  __sbSql(
+    s,
+    "CREATE TABLE IF NOT EXISTS cache (name TEXT NOT NULL, cache_key TEXT NOT NULL, status INTEGER NOT NULL, headers_json TEXT NOT NULL, body TEXT NOT NULL, expires_at INTEGER, PRIMARY KEY (name, cache_key))",
+  );
 }
 
 function __sbHex(n) {
@@ -2426,6 +2431,48 @@ function __sbEmbeddedDispatch(msg) {
     return { ok: true, success: count <= limit, resetAt: (windowStart + period) * 1000 };
   }
 
+  if (op === "cache.match") {
+    const name = msg.name || "default";
+    const r = __sbSql(store, "SELECT status, headers_json, body, expires_at FROM cache WHERE name = ? AND cache_key = ?", [
+      name,
+      msg.key,
+    ]);
+    if (!r.rows.length) return { ok: true, found: false };
+    const [status, headersJson, body, expiresAt] = r.rows[0];
+    if (expiresAt != null && expiresAt <= Date.now()) {
+      __sbSql(store, "DELETE FROM cache WHERE name = ? AND cache_key = ?", [name, msg.key]);
+      return { ok: true, found: false };
+    }
+    return { ok: true, found: true, status, headers: JSON.parse(headersJson), body };
+  }
+  if (op === "cache.put") {
+    const name = msg.name || "default";
+    const status = Number(msg.status) || 200;
+    const headers = msg.headers || {};
+    const cacheControl = String(headers["cache-control"] || headers["Cache-Control"] || "").toLowerCase();
+    // Mirrors Workers' own caches.default.put(): a 206 or an explicit
+    // no-store/private is a silent no-op, not an error.
+    if (status === 206 || cacheControl.indexOf("no-store") !== -1 || cacheControl.indexOf("private") !== -1) {
+      return { ok: true, stored: false };
+    }
+    const sMaxAge = /s-maxage=(\d+)/.exec(cacheControl);
+    const maxAge = /max-age=(\d+)/.exec(cacheControl);
+    const ttlSeconds = sMaxAge ? Number(sMaxAge[1]) : maxAge ? Number(maxAge[1]) : null;
+    const expiresAt = ttlSeconds != null ? Date.now() + ttlSeconds * 1000 : null;
+    __sbSql(
+      store,
+      "INSERT INTO cache (name, cache_key, status, headers_json, body, expires_at) VALUES (?1,?2,?3,?4,?5,?6) " +
+        "ON CONFLICT (name, cache_key) DO UPDATE SET status = ?3, headers_json = ?4, body = ?5, expires_at = ?6",
+      [name, msg.key, status, JSON.stringify(headers), msg.body, expiresAt],
+    );
+    return { ok: true, stored: true };
+  }
+  if (op === "cache.delete") {
+    const name = msg.name || "default";
+    const r = __sbSql(store, "DELETE FROM cache WHERE name = ? AND cache_key = ?", [name, msg.key]);
+    return { ok: true, deleted: r.changes > 0 };
+  }
+
   throw new Error("unknown op: " + op);
 }
 

package/test/native-crypto.ts

@@ -0,0 +1,128 @@
+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 { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// These values come from Bun WebCrypto and node:crypto, not from the runtime
+// under test. A sign/verify round trip would miss a shared input corruption.
+const expected = {
+  rounds: [
+    "e94df4f03406bc36299dd6e6961b22b50fc963fbbf8aeb773f8d7960a77e741e",
+    "1321aaf34d2ad833bd0c8af3ab6c3a91f2be090fd9631538c88ec3986b6eac28",
+  ],
+  digest: "89273d2f70b93285bb7ddb4bcee86a5347ca7159352e3cbdd20c23e9d1e507d3",
+  keyed: "ae70bbf366f791b87ae2c2642bf5bee0e7115f09ec9d15d407b8e5fb60ae933c",
+  scrypt: true,
+};
+
+const handler = `
+import { keyBytes } from "./crypto-helper.js";
+const hex = (buffer) => {
+  const bytes = new Uint8Array(buffer);
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += (bytes[i] + 0x100).toString(16).slice(1);
+  return out;
+};
+export default {
+  async fetch() {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      keyBytes(),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"],
+    );
+    let data = new TextEncoder().encode("h1-regression-password-0001");
+    const rounds = [];
+    for (let i = 0; i < 2; i++) {
+      data = new Uint8Array(await crypto.subtle.sign("HMAC", key, data));
+      rounds.push(hex(data));
+    }
+    const binary = new Uint8Array([0x00, 0x7f, 0x80, 0xff]);
+    const binaryKey = await crypto.subtle.importKey(
+      "raw", new Uint8Array([0x80, 0xff]), { name: "HMAC", hash: "SHA-256" }, false, ["sign"],
+    );
+    const digest = hex(await crypto.subtle.digest("SHA-256", binary));
+    const keyed = hex(await crypto.subtle.sign("HMAC", binaryKey, binary));
+    const scrypt = crypto.scryptVerify(
+      "café",
+      binary,
+      "4459ed251d645d761e6d111db6bedeb64a8e3e8a9ad2b30dce4550ae9fc35049",
+      { N: 16, r: 1, p: 1 },
+    );
+    return Response.json({ rounds, digest, keyed, scrypt });
+  },
+};
+`;
+
+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-crypto-"));
+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 crypto test needs node on PATH");
+
+  const [core, broker] = await Promise.all([
+    readFile(preludePath, "utf8"),
+    readFile(transportPath("broker"), "utf8"),
+  ]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "crypto.generated.js");
+  const binary = join(workdir, "crypto-native");
+  // This is a direct ESM import into Porffor, with no bundler in front of it.
+  await writeFile(join(workdir, "crypto-helper.js"),
+    "export const keyBytes = () => Uint8Array.from({ length: 16 }, (_, index) => index + 1);\n");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+  await rm(binary, { force: true });
+
+  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) },
+    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(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled crypto handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  console.log("Native crypto vectors match Bun WebCrypto and node:crypto");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}