@sproutboat/runtime 0.34.0 → 0.34.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.34.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;
+  }
+});

package/src/native-fetch-prelude.js

@@ -3789,6 +3789,22 @@ if (typeof globalThis.EventTarget !== "function") {
   globalThis.EventTarget = EventTarget;
   globalThis.AbortSignal = AbortSignal;
   globalThis.AbortController = AbortController;
+  // Workers' global event target: `addEventListener("unhandledrejection", fn)` hears every
+  // promise that rejected with nobody waiting on it (see __sbOnUnhandledRejection).
+  class PromiseRejectionEvent extends Event {
+    constructor(type, init) {
+      super(type, init);
+      this.promise = init ? init.promise : undefined;
+      this.reason = init ? init.reason : undefined;
+    }
+  }
+  const globalTarget = new EventTarget();
+  globalThis.PromiseRejectionEvent = PromiseRejectionEvent;
+  if (typeof globalThis.addEventListener !== "function") {
+    globalThis.addEventListener = (type, listener, options) => globalTarget.addEventListener(type, listener, options);
+    globalThis.removeEventListener = (type, listener, options) => globalTarget.removeEventListener(type, listener, options);
+    globalThis.dispatchEvent = (event) => globalTarget.dispatchEvent(event);
+  }
 }
 
 // TextEncoderStream and TextDecoderStream over the Web Streams ponyfill (W2 conformance).
@@ -8983,6 +8999,21 @@ function __sbLogUncaught(where, error) {
   }
 }
 
+// A promise rejected and nothing was waiting on it (an un-awaited `db.prepare(...).run()`
+// that failed, say). As on Workers the request, the process and every other request go on:
+// the rejection is logged, and an "unhandledrejection" event fires on the global scope when
+// something listens. Porffor's promise job loop calls this hook (patchUnhandledRejections);
+// without it, it throws the reason out of the event loop and the process exits.
+globalThis.__sbOnUnhandledRejection = function (reason, promise) {
+  __sbLogUncaught("promise", reason);
+  try {
+    if (__sbIsFn(globalThis.PromiseRejectionEvent) && __sbIsFn(globalThis.dispatchEvent))
+      globalThis.dispatchEvent(new globalThis.PromiseRejectionEvent("unhandledrejection", { promise, reason, cancelable: true }));
+  } catch (error) {
+    __sbLogUncaught("unhandledrejection listener", error);
+  }
+};
+
 // Shared by alarm and scheduled: both reply with an empty 204 once their
 // handler (and anything it queued via `waitUntil`) has settled.
 async function __sb204WithDrain(res, tasks) {

package/test/native-unhandled-rejection.ts

@@ -0,0 +1,133 @@
+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";
+
+// A promise that rejects with nobody waiting on it (a binding call that failed and was never
+// awaited, say a D1 run() that broke a foreign key) must not take the process down, whatever
+// the compatibility date. As on Workers it is logged, an "unhandledrejection" listener hears
+// it, and the next request is served.
+const handler = `addEventListener("unhandledrejection", (event) => {
+  globalThis.__heard = (globalThis.__heard || []).concat(String(event.reason && event.reason.message));
+});
+export default {async fetch(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/reject") {
+    try {
+      Promise.reject(new Error("D1_ERROR: FOREIGN KEY constraint failed"));
+    } catch (error) {
+      return new Response("caught", { status: 500 });
+    }
+    return new Response("fired");
+  }
+  if (path === "/promise") {
+    try {
+      new Promise(function (resolve, reject) { reject(new Error("kv failed")); });
+    } catch (error) {
+      return new Response("caught", { status: 500 });
+    }
+    return new Response("fired");
+  }
+  if (path === "/async") {
+    async function failNow() { throw new Error("async function failed"); }
+    failNow();
+    return new Response("fired");
+  }
+  if (path === "/heard") return new Response(JSON.stringify(globalThis.__heard || []));
+  return new Response("pong");
+}};`;
+
+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;
+}
+
+for (const date of ["2026-09-28", "2026-10-24"]) {
+  const workdir = await mkdtemp(join(tmpdir(), "sb-native-unhandled-"));
+  let server: ReturnType<typeof Bun.spawn> | undefined;
+  try {
+    const porffor = await ensurePorffor();
+    const node = Bun.which("node");
+    if (!node) throw new Error("native unhandled rejection 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 generated = join(workdir, "unhandled.generated.js");
+    const binary = join(workdir, "unhandled-native");
+    await writeFile(
+      generated,
+      wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker), undefined, undefined, undefined, date),
+    );
+    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_TOKEN: "native-test-token" },
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    let ready = false;
+    for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+      try {
+        await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+        ready = true;
+      } catch {
+        if (server.exitCode !== null) break;
+        await Bun.sleep(100);
+      }
+    }
+    assert(ready, `compiled handler did not start (${date})`);
+    const get = async (path: string) => (await fetch(`http://127.0.0.1:${port}${path}`)).text();
+
+    assert.equal(await get("/reject"), "fired");
+    assert.equal(await get("/pong"), "pong", `the request after an unhandled rejection failed (${date})`);
+    assert.equal(await get("/promise"), "fired");
+    assert.equal(await get("/async"), "fired");
+    await Bun.sleep(300);
+    assert.equal(await get("/pong"), "pong", `the request after a rejected promise failed (${date})`);
+    assert.equal(server.exitCode, null, `the server exited on an unhandled rejection (${date})`);
+    assert.equal(await get("/pong"), "pong", `the request after an unawaited async function threw failed (${date})`);
+    const heard = JSON.parse(await get("/heard"));
+    assert(
+      heard.some((message: string) => message.includes("FOREIGN KEY")),
+      `no unhandledrejection event for the rejected promise (${date}): ${JSON.stringify(heard)}`,
+    );
+    assert(
+      heard.some((message: string) => message.includes("async function failed")),
+      `no unhandledrejection event for the async function (${date}): ${JSON.stringify(heard)}`,
+    );
+    server.kill(9);
+    await server.exited;
+    const log = await new Response(server.stderr).text();
+    assert(log.includes("Uncaught (in promise)"), `the rejection was not logged (${date}): ${log}`);
+    server = undefined;
+    console.log(`Native unhandled rejections are reported, not fatal (${date})`);
+  } finally {
+    if (server) {
+      server.kill(9);
+      await server.exited;
+    }
+    await rm(workdir, { recursive: true, force: true });
+  }
+}