sproutboat 0.35.0 → 0.37.0

package/CHANGELOG.md

@@ -10,6 +10,53 @@ maintained going forward by the `release` skill.
 
 ## Unreleased
 
+## [0.37.0] - 2026-10-27
+
+Built on `@sproutboat/runtime` 0.34.1, `@sproutboat/toolchain` 0.19.1 and
+`@sproutboat/wire` 0.20.2.
+
+### Fixed
+
+- **A failed binding call you do not await no longer ends the process.** An un-awaited
+  `db.prepare("INSERT ...").run()` that broke a foreign key used to take the whole binary down, even
+  with a `try` / `catch` around the call. As on Workers, an unhandled rejection is now logged
+  (`Uncaught (in promise) ...`), fires `unhandledrejection` when the app has a listener
+  (`addEventListener("unhandledrejection", ...)`), and the process and other requests keep going. An
+  un-awaited `async function` that throws is reported the same way. At every compatibility date.
+
+### Changed
+
+- **Types for the Promise bindings.** `sproutboat types` gives D1 (from compatibility date 2026-10-24),
+  KV (2026-10-25) and R2 (2026-10-26) bindings the Promise types (`D1DatabaseAsync`,
+  `KVNamespaceAsync`, `R2BucketAsync`); earlier dates keep the synchronous ones.
+- Docs, examples and type comments no longer say binding calls are synchronous at every date.
+
+## [0.36.0] - 2026-10-26
+
+Built on `@sproutboat/runtime` 0.34.0, `@sproutboat/toolchain` 0.19.0 and
+`@sproutboat/wire` 0.20.2.
+
+### Added
+
+- **WebSockets everywhere, from compatibility date 2026-11-01.** Standalone executables and the
+  platform carry the client end of a 101 response (before the date they answer 501), and the
+  platform edge proxies the upgrade.
+- **Outbound WebSockets, from 2026-11-01.** `new WebSocket(url, protocols)` and
+  `fetch(url, { headers: { Upgrade: "websocket" } })` (the Response's `webSocket`, then
+  `accept()`); returning that Response from a handler relays the client's socket to the upstream.
+  `ws`, `wss`, `http` and `https` URLs. `sproutboat check` and `build` accept `WebSocket(` from
+  that date and refuse it before. They run on standalone executables and sproutd; `sproutboat dev`
+  and the platform (broker transport) reject `fetch` upgrades for now.
+- **Hibernation on sproutd, from 2026-11-01.** A Durable Object's hibernatable socket no longer
+  keeps its worker running: the worker is reaped while the socket idles, the auto-response is
+  answered without waking it, and a message or close starts a worker that constructs the object
+  again with `getWebSockets()` as it was.
+
+### Changed
+
+- `types/sproutboat.d.ts` and the README describe the above. The toolchain moves to 0.19.0, so
+  compiled apps get a new fingerprint and rebuild once.
+
 ## [0.35.0] - 2026-10-26
 
 Built on `@sproutboat/runtime` 0.33.0, `@sproutboat/toolchain` 0.18.0 and

package/README.md

@@ -146,7 +146,9 @@ store instead.
 The handler is `export default { fetch(request) }`. It may import from other
 files in the project and from its own `node_modules`, and may also export
 `scheduled(event)` / `queue(batch)` handlers and Durable Object classes. `env`
-is a global, not a parameter, and every binding call is synchronous.
+is a global, not a parameter. Binding calls are synchronous until the compatibility
+date that makes each one return a Promise, as on Workers (D1 from 2026-10-24, KV from
+2026-10-25, R2 from 2026-10-26); `await` works at every date, so always await them.
 [`examples/kitchen-sink/`](examples/kitchen-sink) uses every binding.
 
 For objects larger than one request, use resumable R2 multipart uploads. The
@@ -168,8 +170,9 @@ Windows, build from WSL.
 ## Limits
 
 Capability profile `http-sync-v0`: one synchronous `fetch` handler, optional
-`scheduled` / `queue` handlers. WebSockets (from compatibility date 2026-10-30) need
-a host that carries them (sproutd). Binding values are
+`scheduled` / `queue` handlers. WebSockets (from compatibility date 2026-10-30; standalone
+and platform sprouts from 2026-11-01) and outbound `new WebSocket(url)` (2026-11-01) are
+supported. Binding values are
 text/JSON, one at a time over a 32 MiB loopback frame. Sprout uploads cap at
 16 MiB, assets at 64 MiB / 4096 files.
 

package/SURFACE.md

@@ -3,7 +3,7 @@
 > Generated by `src/surface.test.ts` from `src/surface.ts` + the pinned
 > toolchain constants. Do not edit by hand — run `UPDATE_SURFACE=1 bun test`.
 
-**Package:** `sproutboat` 0.35.0
+**Package:** `sproutboat` 0.37.0
 
 ## Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sproutboat",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "Wrangler-shaped CLI for Sproutboat. Deploys workers to any control plane via --api-url / SPROUTBOAT_API_URL.",
   "keywords": [
     "cli",
@@ -64,9 +64,9 @@
     "@sproutboat/artifact": "^0.3.0",
     "@sproutboat/assets": "^0.3.0",
     "@sproutboat/config": "^0.6.0",
-    "@sproutboat/runtime": "^0.33.0",
-    "@sproutboat/toolchain": "^0.18.0",
-    "@sproutboat/wire": "^0.20.1"
+    "@sproutboat/runtime": "^0.34.1",
+    "@sproutboat/toolchain": "^0.19.1",
+    "@sproutboat/wire": "^0.20.2"
   },
   "devDependencies": {
     "@oxlint/plugins": "1.85.0",
@@ -78,10 +78,10 @@
     "typescript": "7.0.2"
   },
   "optionalDependencies": {
-    "@sproutboat/cli-darwin-arm64": "0.35.0",
-    "@sproutboat/cli-darwin-x64": "0.35.0",
-    "@sproutboat/cli-linux-arm64": "0.35.0",
-    "@sproutboat/cli-linux-x64": "0.35.0"
+    "@sproutboat/cli-darwin-arm64": "0.37.0",
+    "@sproutboat/cli-darwin-x64": "0.37.0",
+    "@sproutboat/cli-linux-arm64": "0.37.0",
+    "@sproutboat/cli-linux-x64": "0.37.0"
   },
   "engines": {
     "node": ">=18"

package/src/main.ts

@@ -235,7 +235,7 @@ async function readProject(directory = process.cwd()) {
   } catch (cause) {
     fail(cause instanceof BundleError ? cause.message : String(cause));
   }
-  const supported = validateHttpSyncSource(bundle.code);
+  const supported = validateHttpSyncSource(bundle.code, project.config.compatibility_date);
   if (!supported.ok) fail(supported.errors.join("\n"));
   return { ...project, sourcePath, source, bundle };
 }

package/src/types-gen.ts

@@ -26,6 +26,11 @@ const HEADER = `// Generated by \`sproutboat types\`. Do not edit.
 
 type Entry = { name: string; type: string; note?: string };
 
+/** Whether the binding's calls return Promises at the project's compatibility date. */
+function asyncAt(config: SproutboatConfig, date: string): boolean {
+  return config.compatibility_date >= date;
+}
+
 function entries(config: SproutboatConfig): Entry[] {
   const out: Entry[] = [];
 
@@ -35,9 +40,12 @@ function entries(config: SproutboatConfig): Entry[] {
   for (const name of config.secrets ?? []) {
     out.push({ name, type: "string", note: "secret, set with `sproutboat secrets put`" });
   }
-  for (const { binding } of resourceRefs(config.kv_namespaces)) out.push({ name: binding, type: "KVNamespace" });
-  for (const { binding } of resourceRefs(config.d1_databases)) out.push({ name: binding, type: "D1Database" });
-  for (const { binding } of resourceRefs(config.r2_buckets)) out.push({ name: binding, type: "R2Bucket" });
+  for (const { binding } of resourceRefs(config.kv_namespaces))
+    out.push({ name: binding, type: asyncAt(config, "2026-10-25") ? "KVNamespaceAsync" : "KVNamespace" });
+  for (const { binding } of resourceRefs(config.d1_databases))
+    out.push({ name: binding, type: asyncAt(config, "2026-10-24") ? "D1DatabaseAsync" : "D1Database" });
+  for (const { binding } of resourceRefs(config.r2_buckets))
+    out.push({ name: binding, type: asyncAt(config, "2026-10-26") ? "R2BucketAsync" : "R2Bucket" });
   for (const { binding } of resourceRefs(config.queues)) out.push({ name: binding, type: "Queue" });
   for (const name of config.analytics_engine_datasets ?? []) {
     out.push({ name, type: "AnalyticsEngineDataset" });
@@ -87,8 +95,9 @@ declare global {
    * Bindings from sproutboat.jsonc, for project "${config.name}".
    *
    * ${handlerNote}
-   * Every call on these is synchronous, so \`await\` is allowed and does
-   * nothing.
+   * D1 (from 2026-10-24), KV (2026-10-25) and R2 (2026-10-26) return Promises, as on
+   * Workers, so a project at or after those dates gets the *Async types; before them
+   * the calls are synchronous. \`await\` works at every date.
    */
   const env: {
 ${body}

package/types/sproutboat.d.ts

@@ -6,7 +6,11 @@
  * generates a project's `sproutboat-env.d.ts`, which references this file and
  * declares `env` with that project's bindings.
  *
- * Bindings are synchronous. Before compatibility date 2026-09-28, `env` is a
+ * KV, D1 and R2 are synchronous before the compatibility date that makes each one return a
+ * Promise (D1 2026-10-24, KV 2026-10-25, R2 2026-10-26): `KVNamespace`, `D1Database` and
+ * `R2Bucket` are the synchronous types, `KVNamespaceAsync`, `D1DatabaseAsync` and
+ * `R2BucketAsync` the Promise types, and `sproutboat types` gives each binding the one for the
+ * project's date. `await` works at every date. Before compatibility date 2026-09-28, `env` is a
  * global only and `ctx` is the second handler argument. From that date, `env`
  * is also passed as the second argument and `ctx` as the third.
  */
@@ -22,7 +26,7 @@ declare global {
   }
 
   interface KVNamespace {
-    /** The stored string, or `null`. Synchronous: no `await`. An expired key reads as absent. */
+    /** The stored string, or `null`. Synchronous before 2026-10-25 (a Promise from then). An expired key reads as absent. */
     get(key: string): string | null;
     put(key: string, value: string, options?: KVPutOptions): void;
     delete(key: string): void;
@@ -30,6 +34,33 @@ declare global {
     list(prefix?: string): string[];
   }
 
+  /**
+   * KV from compatibility date 2026-10-25: every method returns a Promise, as on Workers.
+   * `sproutboat types` picks this type for a project at or after that date.
+   */
+  interface KVNamespaceAsync {
+    get(key: string, type?: "text"): Promise<string | null>;
+    get<T = unknown>(key: string, type: "json"): Promise<T | null>;
+    get(key: string, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
+    get(key: string, type: "stream"): Promise<ReadableStream | null>;
+    getWithMetadata<M = unknown>(
+      key: string,
+      type?: "text" | "json" | "arrayBuffer" | "stream",
+    ): Promise<{ value: unknown; metadata: M | null; cacheStatus: string | null }>;
+    put(
+      key: string,
+      value: string | ArrayBuffer | ArrayBufferView | ReadableStream,
+      options?: KVPutOptions & { metadata?: unknown },
+    ): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: { prefix?: string; limit?: number; cursor?: string }): Promise<{
+      keys: Array<{ name: string; expiration?: number; metadata?: unknown }>;
+      list_complete: boolean;
+      cursor?: string;
+      cacheStatus: string | null;
+    }>;
+  }
+
   // ---------------------------------------------------------------- D1
 
   interface D1Meta {
@@ -63,6 +94,48 @@ declare global {
     exec(sql: string): void;
   }
 
+  /** D1 from compatibility date 2026-10-24: workerd's meta, with D1's keys. */
+  interface D1MetaAsync {
+    served_by: string;
+    duration: number;
+    changes: number;
+    last_row_id: number;
+    changed_db: boolean;
+    size_after: number;
+    rows_read: number;
+    rows_written: number;
+  }
+
+  interface D1ResultAsync<T = Record<string, unknown>> {
+    results: T[];
+    success: boolean;
+    meta: D1MetaAsync;
+  }
+
+  /**
+   * From compatibility date 2026-10-24 `all()`, `run()`, `first()` and `raw()` return Promises, as
+   * on Workers. `sproutboat types` picks this type for a project at or after that date.
+   */
+  interface D1PreparedStatementAsync {
+    /** Positional `?` parameters, in order. Bytes bind as a BLOB. */
+    bind(...values: Array<string | number | boolean | null | ArrayBuffer | ArrayBufferView>): D1PreparedStatementAsync;
+    all<T = Record<string, unknown>>(): Promise<D1ResultAsync<T>>;
+    run<T = Record<string, unknown>>(): Promise<D1ResultAsync<T>>;
+    first<T = Record<string, unknown>>(): Promise<T | null>;
+    first<T = unknown>(column: string): Promise<T | null>;
+    raw<T = unknown[]>(options?: { columnNames?: false }): Promise<T[]>;
+    raw<T = unknown[]>(options: { columnNames: true }): Promise<[string[], ...T[]]>;
+  }
+
+  interface D1DatabaseAsync {
+    prepare(sql: string): D1PreparedStatementAsync;
+    batch<T = Record<string, unknown>>(statements: D1PreparedStatementAsync[]): Promise<D1ResultAsync<T>[]>;
+    /** Runs a script line by line and counts the lines. */
+    exec(sql: string): Promise<{ count: number; duration: number }>;
+    /** A Sproutboat addition: an online, integrity-checked copy of the database. */
+    backup(name?: string): Promise<{ path: string; bytes: number }>;
+  }
+
   // ---------------------------------------------------------------- R2
 
   interface R2HttpMetadata {
@@ -172,6 +245,65 @@ declare global {
     list(options?: R2ListOptions): R2Objects;
   }
 
+  /**
+   * R2 from compatibility date 2026-10-26: every method returns a Promise, as on Workers, and
+   * `uploaded` is a Date. `sproutboat types` picks these types for a project at or after that date.
+   */
+  interface R2ObjectAsync {
+    key: string;
+    size: number;
+    etag: string;
+    httpEtag: string;
+    checksums: { md5?: ArrayBuffer };
+    uploaded: Date;
+    httpMetadata?: R2HttpMetadata;
+    customMetadata?: Record<string, string>;
+    range?: { offset: number; length: number };
+  }
+
+  interface R2ObjectBodyAsync extends R2ObjectAsync {
+    body: ReadableStream;
+    bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    blob(): Promise<Blob>;
+  }
+
+  interface R2MultipartUploadAsync {
+    key: string;
+    uploadId: string;
+    uploadPart(
+      partNumber: number,
+      value: string | ArrayBuffer | ArrayBufferView | ReadableStream | Blob,
+    ): Promise<R2UploadedPart>;
+    complete(parts: R2UploadedPart[]): Promise<R2ObjectAsync>;
+    abort(): Promise<void>;
+  }
+
+  interface R2BucketAsync extends Pick<R2Bucket, "createUploadUrl" | "createDownloadUrl"> {
+    head(key: string): Promise<R2ObjectAsync | null>;
+    get(
+      key: string,
+      options?: { range?: { offset?: number; length?: number; suffix?: number }; onlyIf?: unknown },
+    ): Promise<R2ObjectBodyAsync | null>;
+    put(
+      key: string,
+      value: string | ArrayBuffer | ArrayBufferView | ReadableStream | Blob | null,
+      options?: { httpMetadata?: R2HttpMetadata | Headers; customMetadata?: Record<string, string>; onlyIf?: unknown },
+    ): Promise<R2ObjectAsync | null>;
+    delete(keys: string | string[]): Promise<void>;
+    list(options?: {
+      prefix?: string;
+      limit?: number;
+      cursor?: string;
+      delimiter?: string;
+      include?: Array<"httpMetadata" | "customMetadata">;
+    }): Promise<{ objects: R2ObjectAsync[]; truncated: boolean; cursor?: string; delimitedPrefixes: string[] }>;
+    createMultipartUpload(key: string, options?: R2PutOptions): Promise<R2MultipartUploadAsync>;
+    resumeMultipartUpload(key: string, uploadId: string): R2MultipartUploadAsync;
+  }
+
   // ------------------------------------------------------------ Queues
 
   type QueuesContentType = "json" | "text" | "bytes" | "v8";
@@ -275,7 +407,10 @@ declare global {
     /**
      * The WebSocket hibernation API, from compatibility date 2026-10-30. Messages and
      * closes on an accepted socket go to the class's `webSocketMessage` and
-     * `webSocketClose`. On sproutd an open socket keeps the app's worker running.
+     * `webSocketClose`. On sproutd an open socket keeps the app's worker running before
+     * compatibility date 2026-11-01; from it the worker is reaped while the socket idles and
+     * the object is constructed again (with `getWebSockets()` as it was) when a message or
+     * close arrives.
      */
     acceptWebSocket(ws: WebSocket, tags?: string[]): void;
     getWebSockets(tag?: string): WebSocket[];
@@ -289,9 +424,12 @@ declare global {
   /**
    * From compatibility date 2026-10-30, as in workerd. Return the client end in a
    * `new Response(null, { status: 101, webSocket: client })` and talk on the server end.
-   * Client sockets are carried by sproutd; a standalone or platform sprout answers a 101
-   * with 501 for now. Inbound messages are capped at 32 MiB (1009 above it). Outbound
-   * WebSockets (`new WebSocket(url)`) are not supported.
+   * Client sockets are carried by sproutd, and from compatibility date 2026-11-01 by
+   * standalone and platform sprouts too (before it they answer a 101 with 501). Inbound
+   * messages are capped at 32 MiB (1009 above it). From 2026-11-01 `new WebSocket(url,
+   * protocols)` and `fetch(url, { headers: { Upgrade: "websocket" } })` connect out; the
+   * Response's `webSocket` needs `accept()`, and returning it from a handler relays the client.
+   * Outbound sockets need the embedded transport (standalone, sproutd), not `sproutboat dev`.
    */
   class WebSocketPair {
     0: WebSocket;