@sproutboat/toolchain 0.4.17 → 0.4.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/toolchain
 
+## 0.4.19
+
+### Patch Changes
+
+- 872198d: Standalone binaries accept HTTP/1.0 requests instead of answering 505 (baronunread/sproutboat#236), so they work behind nginx's default `proxy_http_version 1.0`. uWebSockets only parsed `HTTP/1.1` request lines. A helper now edits its `HttpParser.h` before each native-fetch compile to accept `HTTP/1.0` and mark the request as ancient, which makes uWebSockets close the connection after the response, as HTTP/1.0 expects.
+
+## 0.4.18
+
+### Patch Changes
+
+- e0d0e17: Compile every unit with `-ffp-contract=off` (baronunread/sproutboat#235). On arm64, clang fused `a * b + c` into a single FMA that rounds once, where JavaScript rounds after the multiply and again after the add, so native sprouts could compute different doubles from V8 for the same code. A seeded LCG diverged at step 23.
+
 ## 0.4.17
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.4.17",
+  "version": "0.4.19",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/acquire.test.ts

@@ -29,7 +29,10 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "  return -1;\n" +
       "}\n" +
       "#define PORF_CORO_STACK_SIZE (256u * 1024u)\n",
-    "compiler/index.js": "      ...darwinReleaseCompileArgs,\n        uSocketsArchive,\n        '-lm'\n",
+    "compiler/index.js":
+      "import { hashId } from './modules.js';\n" +
+      "      const uwsDir = uwebsockets.ensureUWebSockets();\n" +
+      "      '-fno-ident', '-ffunction-sections', '-fdata-sections',\n      ...darwinReleaseCompileArgs,\n        uSocketsArchive,\n        '-lm'\n",
     "compiler/precompile.js":
       "const fs = require('node:fs');\n" +
       "const path = require('node:path');\n" +
@@ -46,6 +49,7 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "    len = i;\n" +
       "  }\n\n  arr.length = len;\n\n  return new ${name}(arr);\n};\n",
     "compiler/uwebsockets.js":
+      'export const makeUWebSocketsShimSource = () => `\n#include "App.h"\n' +
       "static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;\n" +
       "int porf_native_fetch_read_value(struct jsval value, const char** out_buf, size_t* out_len, char** out_owned);\n" +
       "static std::string_view lookup_status_line(i32 status) {\n" +
@@ -198,6 +202,13 @@ test("the default call (no url/expectedSha256 override) never touches the networ
     },
   });
   expect(await readFile(join(dir, "runtime/index.js"), "utf8")).not.toBe("");
+  // #236: the native-fetch build edits uWebSockets to accept HTTP/1.0.
+  const index = await readFile(join(dir, "compiler/index.js"), "utf8");
+  expect(index).toContain("import { sbPatchHttp10 } from './sb-http10.js';");
+  expect(index).toContain("const uwsDir = uwebsockets.ensureUWebSockets();\n      sbPatchHttp10(uwsDir);");
+  expect(await readFile(join(dir, "compiler/sb-http10.js"), "utf8")).toContain("export const sbPatchHttp10");
+  // #235: every compiled unit keeps JavaScript's separate float roundings.
+  expect(await readFile(join(dir, "compiler/index.js"), "utf8")).toContain("'-ffp-contract=off',");
   // #168: the real vendored source takes the null guard on the `then` probe.
   expect(await readFile(join(dir, "compiler/builtins/promise.ts"), "utf8")).toContain(
     "if (Porffor.type(value) == Porffor.TYPES.object && value != null) {",

package/src/patch.test.ts

@@ -44,7 +44,9 @@ int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_
 // body limit (#56), the #156 status-line switch, #163's collect_headers, and
 // #176's read_value forward decl / is_forbidden_response_header /
 // write_response_value.
-const SHIM = `static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;
+const SHIM = `export const makeUWebSocketsShimSource = () => \`
+#include "App.h"
+static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;
 
 int porf_native_fetch_read_value(struct jsval value, const char** out_buf, size_t* out_len, char** out_owned);
 

package/src/patch.ts

@@ -192,6 +192,69 @@ const CFLAGS_INJECT =
   "      ...(process.env.SB_EXTRA_CFLAGS ? process.env.SB_EXTRA_CFLAGS.split(' ').filter(Boolean) : []),\n";
 const CFLAGS_MARKER = "SB_EXTRA_CFLAGS";
 
+// baronunread/sproutboat#235: clang's default -ffp-contract=on fuses `a * b + c`
+// into one FMA on arm64, rounding once where JavaScript rounds twice. A seeded
+// LCG (seed * 1103515245 + 12345, past 2^53) diverged from V8 at step 23.
+// Every compiled unit keeps JS's separate roundings with contraction off.
+const FP_CONTRACT_ANCHOR = "      '-fno-ident', '-ffunction-sections', '-fdata-sections',\n";
+const FP_CONTRACT_INJECT = "      '-ffp-contract=off', // sproutboat #235: JS rounds a * b + c twice\n";
+const FP_CONTRACT_MARKER = "sproutboat #235";
+
+// baronunread/sproutboat#236: uWebSockets answers any request line that isn't
+// HTTP/1.1 with 505, so a standalone sprout behind nginx's default
+// `proxy_http_version 1.0` failed every request. Its HttpRequest already has
+// isAncient(), which closes the connection after the response; the parser just
+// never sets it. uWebSockets is header-only and lives in Porffor's deps cache,
+// not in the Porffor checkout, so a helper written next to compiler/index.js
+// edits HttpParser.h right before each native-fetch compile (marker-guarded).
+const HTTP10_HELPER = String.raw`// sproutboat #236: accept HTTP/1.0 request lines in uWebSockets.
+import fs from 'node:fs';
+
+const MARK = 'sb_http10_request';
+const edits = [
+  [
+    'struct HttpParser {',
+    '/* sproutboat #236: set by consumeRequestLine for an HTTP/1.0 request line. */\ninline thread_local bool sb_http10_request = false;\n\nstruct HttpParser {'
+  ],
+  [
+    '/* Scan until single SP, assume next is / (origin request) */\n        char *start = data;',
+    '/* Scan until single SP, assume next is / (origin request) */\n        sb_http10_request = false;\n        char *start = data;'
+  ],
+  [
+    'if (memcmp(" HTTP/1.1\\r\\n", data, std::min<unsigned int>(11, (unsigned int) (end - data))) == 0) {\n                            return nullptr;\n                        }',
+    'if (memcmp(" HTTP/1.1\\r\\n", data, std::min<unsigned int>(11, (unsigned int) (end - data))) == 0) {\n                            return nullptr;\n                        }\n                        if (memcmp(" HTTP/1.0\\r\\n", data, std::min<unsigned int>(11, (unsigned int) (end - data))) == 0) {\n                            return nullptr;\n                        }'
+  ],
+  [
+    'if (memcmp(" HTTP/1.1\\r\\n", data, 11) == 0) {\n                        return data + 11;\n                    }',
+    'if (memcmp(" HTTP/1.1\\r\\n", data, 11) == 0) {\n                        return data + 11;\n                    }\n                    if (memcmp(" HTTP/1.0\\r\\n", data, 11) == 0) {\n                        sb_http10_request = true;\n                        return data + 11;\n                    }'
+  ],
+  [ 'req->ancientHttp = false;', 'req->ancientHttp = sb_http10_request;' ]
+];
+
+export const sbPatchHttp10 = uwsDir => {
+  const file = uwsDir + '/src/HttpParser.h';
+  let src = fs.readFileSync(file, 'utf8');
+  if (src.includes(MARK)) return;
+  for (const [ from, to ] of edits) {
+    if (!src.includes(from)) throw new Error('sproutboat #236: uWebSockets HttpParser.h changed, anchor not found: ' + from.slice(0, 60));
+    src = src.replace(from, to);
+  }
+  fs.writeFileSync(file, src);
+};
+`;
+const HTTP10_IMPORT_ANCHOR = "import { hashId } from './modules.js';\n";
+const HTTP10_IMPORT_INJECT = "import { sbPatchHttp10 } from './sb-http10.js'; // sproutboat #236\n";
+const HTTP10_IMPORT_MARKER = "./sb-http10.js";
+const HTTP10_CALL_ANCHOR = "      const uwsDir = uwebsockets.ensureUWebSockets();\n";
+const HTTP10_CALL_INJECT = "      sbPatchHttp10(uwsDir);\n";
+const HTTP10_CALL_MARKER = "sbPatchHttp10(uwsDir)";
+// The shim is content-cached, so a header edit alone would never recompile it.
+// This line changes the shim once, which rebuilds it against the edited header.
+const HTTP10_SHIM_ANCHOR = 'export const makeUWebSocketsShimSource = () => `\n#include "App.h"\n';
+const HTTP10_SHIM_INJECT =
+  'export const makeUWebSocketsShimSource = () => `\n#include "App.h"\n// sproutboat #236: built against an HttpParser.h that accepts HTTP/1.0\n';
+const HTTP10_SHIM_MARKER = "sproutboat #236: built against";
+
 // baronunread/sproutboat#168: Porffor represents null as an object-typed value
 // with pointer 0, so __Porffor_promise_resolve's cheap `then` probe treated a
 // promise resolving to null as an object and looked `then` up at memory offset
@@ -767,6 +830,7 @@ const done = new Set<string>();
 
 /** Edits to Porffor's uWebSockets shim: `[marker, anchor, inject, what]`. */
 const UWS_EDITS = [
+  [HTTP10_SHIM_MARKER, HTTP10_SHIM_ANCHOR, HTTP10_SHIM_INJECT, "shim rebuild for HTTP/1.0 (#236)"],
   [BODY_MARKER, BODY_ANCHOR, BODY_INJECT, "request body limit"],
   [STATUS_SIG_MARKER, STATUS_SIG_ANCHOR, STATUS_SIG_INJECT, "status-line return type (#156)"],
   [STATUS_303_MARKER, STATUS_303_ANCHOR, STATUS_303_INJECT, "status-line 303 case (#156)"],
@@ -953,12 +1017,16 @@ export async function patchUwebsockets(root: string): Promise<void> {
 }
 
 async function patchCompilerArgs(root: string): Promise<void> {
+  await writeFile(resolve(root, "compiler/sb-http10.js"), HTTP10_HELPER);
   const file = resolve(root, "compiler/index.js");
   let src = await readFile(file, "utf8");
   let changed = false;
   for (const [marker, anchor, inject, what] of [
     [LINK_MARKER, LINK_ANCHOR, LINK_INJECT, "extra link args"],
     [CFLAGS_MARKER, CFLAGS_ANCHOR, CFLAGS_INJECT, "extra compiler flags"],
+    [FP_CONTRACT_MARKER, FP_CONTRACT_ANCHOR, FP_CONTRACT_INJECT, "floating-point contraction"],
+    [HTTP10_IMPORT_MARKER, HTTP10_IMPORT_ANCHOR, HTTP10_IMPORT_INJECT, "HTTP/1.0 helper import (#236)"],
+    [HTTP10_CALL_MARKER, HTTP10_CALL_ANCHOR, HTTP10_CALL_INJECT, "HTTP/1.0 parser edit (#236)"],
   ] as const) {
     if (src.includes(marker)) continue;
     const at = src.indexOf(anchor);
@@ -971,7 +1039,7 @@ async function patchCompilerArgs(root: string): Promise<void> {
     // Add flags to compileOnlyArgs so every generated C unit sees them and
     // Porffor's module-build cache includes them in its compiler command.
     src =
-      marker === CFLAGS_MARKER
+      marker !== LINK_MARKER
         ? src.slice(0, at + anchor.length) + inject + src.slice(at + anchor.length)
         : src.slice(0, at) + inject + src.slice(at);
     changed = true;