@sproutboat/toolchain 0.4.16 → 0.4.18

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/toolchain
 
+## 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
+
+- 2cda218: Fix async handlers failing permanently with `TypeError: Cannot get property of null` after a few requests (baronunread/sproutboat#168). Porffor represents `null` as an object-typed value with pointer 0, so a promise resolving to `null` went through the `then` probe and looked `then` up at memory offset 0. Once `Date.prototype.toISOString` had written there, the probe matched, read `null.then` and rejected, and every later async function returning `null` failed the same way. A patch to `compiler/builtins/promise.ts` keeps `null` out of the probe.
+
 ## 0.4.16
 
 ### Patch Changes

package/package.json

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

package/src/acquire.test.ts

@@ -29,7 +29,8 @@ 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":
+      "      '-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" +
@@ -119,6 +120,7 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
     "compiler/builtins/promise.ts":
       "export const __Porffor_promise_resolve = (value: any, promise: any): void => {\n" +
       "  if (Porffor.type(value) == Porffor.TYPES.object) {\n" +
+      "    // cheap prototype-chain probe for 'then' before the expensive Get below, does not invoke getters\n" +
       "    const thenHash: i32 = __Porffor_object_hash('then');\n" +
       "    let probe: any = value;\n" +
       "    while (Porffor.type(probe) == Porffor.TYPES.object) {\n" +
@@ -197,6 +199,12 @@ test("the default call (no url/expectedSha256 override) never touches the networ
     },
   });
   expect(await readFile(join(dir, "runtime/index.js"), "utf8")).not.toBe("");
+  // #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) {",
+  );
 });
 
 test("a corrupted warm cache is replaced from the verified archive", async () => {

package/src/patch.ts

@@ -192,6 +192,29 @@ 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#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
+// 0. Once something (Date.prototype.toISOString's scratch writes, in practice)
+// left bytes there that hash-match, the probe "found" a then, read null.then,
+// and rejected with "Cannot get property of null". Every later async function
+// resolving to null then failed, permanently. Only non-null objects can be
+// thenables (ECMA-262 Promise Resolve Functions step 8), so exclude null.
+const PROMISE_NULL_ANCHOR =
+  "  if (Porffor.type(value) == Porffor.TYPES.object) {\n    // cheap prototype-chain probe for 'then'";
+const PROMISE_NULL_INJECT =
+  "  // sproutboat #168: null is object-typed with pointer 0, never a thenable.\n" +
+  "  if (Porffor.type(value) == Porffor.TYPES.object && value != null) {\n    // cheap prototype-chain probe for 'then'";
+const PROMISE_NULL_MARKER = "sproutboat #168: null is object-typed";
+
 // Porffor's TypedArray.from only handles iterables. An array-like input such
 // as { length: 16 } silently becomes an empty typed array, including HMAC
 // keys made with Uint8Array.from({ length: 16 }, mapFn). The compiler uses a
@@ -944,6 +967,7 @@ async function patchCompilerArgs(root: string): Promise<void> {
   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"],
   ] as const) {
     if (src.includes(marker)) continue;
     const at = src.indexOf(anchor);
@@ -956,7 +980,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;
@@ -977,6 +1001,16 @@ export async function patchDateParser(root: string): Promise<void> {
   await writeFile(file, src.slice(0, start) + parser.replace(DATE_PARSER_ANCHOR, DATE_PARSER_INJECT) + src.slice(end));
 }
 
+/** #168: keep a promise resolving to null out of the `then` probe. Precompiled by patchTypedArrayFrom. */
+export async function patchPromiseResolveNull(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/promise.ts");
+  const src = await readFile(file, "utf8");
+  if (src.includes(PROMISE_NULL_MARKER)) return;
+  if (!src.includes(PROMISE_NULL_ANCHOR))
+    throw new Error(`could not patch Porffor's promise resolve for null: anchor not found in ${file}`);
+  await writeFile(file, src.replace(PROMISE_NULL_ANCHOR, PROMISE_NULL_INJECT));
+}
+
 export async function patchTypedArrayFrom(root: string): Promise<void> {
   const file = resolve(root, "compiler/builtins/typedarray.js");
   const src = await readFile(file, "utf8");
@@ -1052,6 +1086,9 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchUwebsockets(root);
   await patchRenderJs(root);
   await patchDateParser(root);
+  await patchPromiseResolveNull(root);
+  // Last of the builtin edits: its precompile picks up the date and promise
+  // patches above too.
   await patchTypedArrayFrom(root);
   await patchUnicode(root);
   done.add(root);