@sproutboat/runtime 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @sproutboat/runtime
 
+## 0.9.2
+
+### Patch Changes
+
+- d8b7877: Add native standalone R2 direct-download tickets with bounded, backpressure-aware
+  file reads, including upgrades for existing patched Porffor caches.
+
+## 0.9.1
+
+### Patch Changes
+
+- e0944a4: Provide the native direct-transfer ABI in broker builds so the shared
+  uWebSockets patch does not introduce unresolved symbols outside standalone
+  mode.
+
 ## 0.9.0
 
 ### Minor Changes

package/package.json

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

package/src/transport-embedded.js

@@ -746,6 +746,62 @@ void sb_r2_transfer_abort(sb_r2_transfer_ctx* ctx) {
   free(ctx);
 }
 
+// Claims a download ticket and opens its immutable blob generation. The C++
+// socket shim reads this handle at its current write offset, so no object-sized
+// buffer is ever allocated in either the JS or C++ heap.
+int sb_r2_transfer_download_open(const char* bucket, const char* token, sb_r2_transfer_ctx** out) {
+  *out = 0;
+  if (!bucket || !token || strlen(bucket) >= 256 || strlen(token) != 24) return 404;
+  sb_r2_transfer_ctx* ctx = (sb_r2_transfer_ctx*)calloc(1, sizeof(*ctx));
+  if (!ctx) return 503;
+  sb_r2_transfer_store_path(ctx->store, sizeof(ctx->store));
+  int index = sb_db_for(ctx->store);
+  if (index < 0) { free(ctx); return 503; }
+  ctx->db = sb_dbs[index];
+  sqlite3_stmt* st = 0;
+  const char* ticket_sql = "SELECT key FROM r2_transfer WHERE token=?1 AND bucket=?2 AND method='download' AND used=0 AND expires>=?3";
+  if (sqlite3_prepare_v2(ctx->db, ticket_sql, -1, &st, 0) != 0 || !st) { free(ctx); return 503; }
+  sqlite3_bind_text(st, 1, token, -1, SB_SQLITE_TRANSIENT);
+  sqlite3_bind_text(st, 2, bucket, -1, SB_SQLITE_TRANSIENT);
+  sqlite3_bind_int64(st, 3, (int64_t)time(0) * 1000);
+  if (sqlite3_step(st) != SB_SQLITE_ROW) { sqlite3_finalize(st); free(ctx); return 410; }
+  const char* key = (const char*)sqlite3_column_text(st, 0);
+  if (!key || strlen(key) >= sizeof(ctx->key)) { sqlite3_finalize(st); free(ctx); return 404; }
+  snprintf(ctx->bucket, sizeof(ctx->bucket), "%s", bucket);
+  snprintf(ctx->key, sizeof(ctx->key), "%s", key);
+  sqlite3_finalize(st);
+  st = 0;
+  if (sqlite3_prepare_v2(ctx->db, "SELECT blob_id FROM r2 WHERE bucket=?1 AND key=?2", -1, &st, 0) != 0 || !st) { free(ctx); return 503; }
+  sqlite3_bind_text(st, 1, bucket, -1, SB_SQLITE_TRANSIENT);
+  sqlite3_bind_text(st, 2, ctx->key, -1, SB_SQLITE_TRANSIENT);
+  if (sqlite3_step(st) != SB_SQLITE_ROW) { sqlite3_finalize(st); free(ctx); return 404; }
+  const char* generation = (const char*)sqlite3_column_text(st, 0);
+  char blobpath[1024];
+  sb_r2_blob_path(blobpath, sizeof(blobpath), ctx->store, bucket, ctx->key, generation ? generation : "");
+  sqlite3_finalize(st);
+  ctx->file = fopen(blobpath, "rb");
+  if (!ctx->file) { free(ctx); return 404; }
+  fseek(ctx->file, 0, SEEK_END); long length = ftell(ctx->file); rewind(ctx->file);
+  if (length < 0) { fclose(ctx->file); free(ctx); return 500; }
+  ctx->size = (size_t)length;
+  st = 0;
+  if (sqlite3_prepare_v2(ctx->db, "UPDATE r2_transfer SET used=1 WHERE token=?1 AND used=0", -1, &st, 0) != 0 || !st) { fclose(ctx->file); free(ctx); return 503; }
+  sqlite3_bind_text(st, 1, token, -1, SB_SQLITE_TRANSIENT);
+  int claimed = sqlite3_step(st) == SB_SQLITE_DONE && sqlite3_changes(ctx->db) == 1;
+  sqlite3_finalize(st);
+  if (!claimed) { fclose(ctx->file); free(ctx); return 410; }
+  *out = ctx;
+  return 0;
+}
+
+size_t sb_r2_transfer_download_size(sb_r2_transfer_ctx* ctx) { return ctx ? ctx->size : 0; }
+size_t sb_r2_transfer_download_read(sb_r2_transfer_ctx* ctx, size_t offset, char* out, size_t cap) {
+  if (!ctx || !ctx->file || offset >= ctx->size || fseek(ctx->file, (long)offset, SEEK_SET) != 0) return 0;
+  size_t wanted = ctx->size - offset < cap ? ctx->size - offset : cap;
+  return fread(out, 1, wanted, ctx->file);
+}
+void sb_r2_transfer_download_close(sb_r2_transfer_ctx* ctx) { if (ctx) { if (ctx->file) fclose(ctx->file); free(ctx); } }
+
 // Run a script: one or more statements separated by semicolons. sqlite3_exec
 // handles the whole string, which prepare/step does not — it compiles the first
 // statement and silently ignores the rest, so a schema built from one exec call

package/src/wrap.ts

@@ -175,6 +175,8 @@ export function wrapNativeFetchHandler(
   appName: string = "app",
   /** #15 — assets baked into the module for a binary that has no files beside it. */
   assets?: { manifest: unknown; files: Record<string, string> },
+  /** The selected transport determines whether the direct-transfer C ABI is real or stubbed. */
+  transport: Transport = "broker",
 ): string {
   const neutralised = neutraliseExports(source);
   if (neutralised === null || !/\bfetch\s*\(/.test(source)) {
@@ -191,9 +193,14 @@ export function wrapNativeFetchHandler(
     // #15 — and enforces the outbound allowlist itself, with no broker to do it.
     `globalThis.__sbOutbound = ${JSON.stringify(bindings.outbound)};\n` +
     (assets ? `globalThis.__sbAssets = ${JSON.stringify(assets)};\n` : "");
-  // The native transfer hook runs before JavaScript receives its Request, so
-  // it needs the same default data-directory name as the embedded transport.
-  const nativeAppName = `Porffor.c\`const char* sb_standalone_app_name(void) { return ${JSON.stringify(appName)}; }\`;\n`;
+  // The native transfer hook runs before JavaScript receives its Request. It
+  // has a real file-backed implementation only in embedded builds. The broker
+  // transport supplies ABI-compatible stubs because its separate transfer
+  // listener owns these URLs, while the shared uWebSockets patch is global.
+  const nativeTransferAbi =
+    transport === "embedded"
+      ? `Porffor.c\`const char* sb_standalone_app_name(void) { return ${JSON.stringify(appName)}; }\`;\n`
+      : "Porffor.c`typedef struct sb_r2_transfer_ctx { int unused; } sb_r2_transfer_ctx; int sb_r2_transfer_open(const char* a, const char* b, size_t c, sb_r2_transfer_ctx** d) { if (d) *d = 0; return 404; } int sb_r2_transfer_write(sb_r2_transfer_ctx* a, const char* b, size_t c) { return 404; } int sb_r2_transfer_finish(sb_r2_transfer_ctx* a) { return 404; } void sb_r2_transfer_abort(sb_r2_transfer_ctx* a) {} int sb_r2_transfer_download_open(const char* a, const char* b, sb_r2_transfer_ctx** c) { if (c) *c = 0; return 404; } size_t sb_r2_transfer_download_size(sb_r2_transfer_ctx* a) { return 0; } size_t sb_r2_transfer_download_read(sb_r2_transfer_ctx* a, size_t b, char* c, size_t d) { return 0; } void sb_r2_transfer_download_close(sb_r2_transfer_ctx* a) {}`;\n";
   const wire = hasBindings(bindings)
     ? `__sbInstallBindings(env, ${JSON.stringify(bindings)});\n`
     : "";
@@ -208,7 +215,7 @@ export function wrapNativeFetchHandler(
     : "";
 
   return (
-    `${prelude}\n${nativeAppName}${compat}${env}${wire}` +
+    `${prelude}\n${nativeTransferAbi}${compat}${env}${wire}` +
     `${neutralised}\n` +
     `${registerDO}${triggers}` +
     `export default {\n  port: ${port},\n  fetch(request) { return __sbEntry(__sbHandlers, request); }\n};\n`