@sproutboat/runtime 0.33.0 → 0.34.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @sproutboat/runtime
 
+## 0.34.1
+
+### Patch Changes
+
+- e62b72d: An unhandled promise rejection no longer ends the process. A D1 call that failed and was never awaited (`db.prepare("INSERT ...").run()` that broke a foreign key) threw its error out of Porffor's promise job loop into the host's "Uncaught ..." exit, taking every in-flight request down even with a try/catch around the call. As on Workers it is now reported: a log line (`Uncaught (in promise) ...`) and an `unhandledrejection` event (`PromiseRejectionEvent` with `promise` and `reason`) on the global scope when `addEventListener("unhandledrejection", ...)` has a listener, and the process and other requests carry on. This applies at every compatibility date, because a crash is a bug rather than a behaviour an app can depend on. The toolchain's `patchUnhandledRejections` calls the runtime's `globalThis.__sbOnUnhandledRejection`; plain Porffor without it keeps the throw. Applies to every binding call that returns a rejecting Promise (D1, KV, R2, Durable Objects, Queues, fetch). An un-awaited `async function` that throws is reported the same way (it used to be dropped silently): the C runtime that rejects it now hands the promise to the same check.
+
+## 0.34.0
+
+### Minor Changes
+
+- 85ec3fe: WebSockets on every host, and outbound WebSockets, from compatibility date `2026-11-01`:
+  
+  - **Client sockets on standalone and platform sprouts.** The native server (toolchain) carries the client end of a 101 response: it upgrades the connection, passes text and binary messages both ways, applies the 1 MiB read window, caps messages at 32 MiB (1009), and answers a close with the code and reason. A message the app sent before the 101 goes out right after it, and the app's `Sec-WebSocket-Protocol` is the one the client gets. Before 2026-11-01 these sprouts still answer a 101 with 501 (sproutd, which sets `sb_ws_hook` itself, carries them from 2026-10-30). The toolchain needs `@sproutboat/runtime` 0.33 or later.
+  - **Outbound WebSockets.** `new WebSocket(url, protocols)` (CONNECTING, then `open`, as in a browser) and `fetch(url, { headers: { Upgrade: "websocket" } })`, whose Response carries the connected socket as `response.webSocket` (call `accept()`); a server that answers the upgrade with another status is the Response. `ws`, `wss`, `http` and `https` URLs. Returning that Response from a handler relays the client's socket to the upstream. One I/O thread per socket (up to 64) connects through the egress policy, does TLS with BearSSL, and wakes the loop through the async pipe (sproutd) or the server's waker (standalone). On the embedded transport (standalone, sproutd); the broker transport (platform, `sproutboat dev`) answers `fetch` upgrades with a rejection for now.
+  - `validateHttpSyncSource(source, compatibilityDate)` accepts `WebSocket(` from 2026-11-01 and keeps refusing it before.
+  - **Hibernation, on a host that keeps client sockets open while the worker is gone (sproutd).** A Durable Object's hibernatable socket (`ctx.acceptWebSocket`) is recorded in storage scoped to the object (its id, tags, attachment, and the object's auto-response, kept current by `serializeAttachment` and `setWebSocketAutoResponse`), so the host may stop the worker while the socket is idle. When a message or close arrives, a new worker constructs the object again with `ctx.getWebSockets()` listing its sockets (tags and attachments intact) from the start of the constructor, and the event runs as `webSocketMessage` or `webSocketClose`. Socket ids are random. A host without this (standalone, platform) keeps every socket resident, as before.
+
 ## 0.33.0
 
 ### Minor Changes

package/package.json

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

package/src/entry-crash.test.js

@@ -18,10 +18,7 @@ const load = new Function(
 // Every Porffor.c`...` block in the prelude only runs inside a function body
 // (never at load time), so a no-op tag covers all of them: __sbCpuMs and
 // __sbEnv just see an empty result, same as "native op returned nothing."
-const H = load(
-  { c: () => "" },
-  new Proxy({}, { get: () => undefined }),
-);
+const H = load({ c: () => "" }, new Proxy({}, { get: () => undefined }));
 
 const req = (overrides = {}) => ({
   headers: { get: (k) => (overrides.headers && overrides.headers[k.toLowerCase()]) ?? null },
@@ -61,3 +58,55 @@ test("a throwing fetch handler doesn't stop the next request from being served",
   const second = await H.__sbEntry(handlers, req({ boom: false }));
   expect(await second.text()).toBe("ok");
 });
+
+// A promise that rejects with nobody waiting on it (an un-awaited D1 run() that broke a
+// foreign key) must be reported, not end the process: Porffor's promise job loop calls
+// globalThis.__sbOnUnhandledRejection (toolchain patchUnhandledRejections).
+test("an unhandled rejection is logged and fires an unhandledrejection event", () => {
+  const logged = [];
+  const consoleError = console.error;
+  const dispatch = globalThis.dispatchEvent;
+  const Ctor = globalThis.PromiseRejectionEvent;
+  const events = [];
+  console.error = (line) => logged.push(String(line));
+  globalThis.PromiseRejectionEvent = class {
+    constructor(type, init) {
+      this.type = type;
+      this.reason = init.reason;
+      this.promise = init.promise;
+    }
+  };
+  globalThis.dispatchEvent = (event) => events.push(event);
+  try {
+    const promise = Promise.reject(new Error("D1_ERROR: FOREIGN KEY constraint failed"));
+    promise.catch(() => {});
+    globalThis.__sbOnUnhandledRejection(new Error("D1_ERROR: FOREIGN KEY constraint failed"), promise);
+  } finally {
+    console.error = consoleError;
+    globalThis.dispatchEvent = dispatch;
+    globalThis.PromiseRejectionEvent = Ctor;
+  }
+  expect(logged.join("\n")).toContain("Uncaught (in promise)");
+  expect(logged.join("\n")).toContain("FOREIGN KEY");
+  expect(events).toHaveLength(1);
+  expect(events[0].type).toBe("unhandledrejection");
+  expect(events[0].reason.message).toContain("FOREIGN KEY");
+});
+
+test("a throwing unhandledrejection listener does not escape the hook", () => {
+  const consoleError = console.error;
+  const dispatch = globalThis.dispatchEvent;
+  const Ctor = globalThis.PromiseRejectionEvent;
+  console.error = () => {};
+  globalThis.PromiseRejectionEvent = class {};
+  globalThis.dispatchEvent = () => {
+    throw new Error("listener broke");
+  };
+  try {
+    expect(() => globalThis.__sbOnUnhandledRejection(new Error("x"), undefined)).not.toThrow();
+  } finally {
+    console.error = consoleError;
+    globalThis.dispatchEvent = dispatch;
+    globalThis.PromiseRejectionEvent = Ctor;
+  }
+});