@sproutboat/toolchain 0.4.18 → 0.4.20

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/toolchain
 
+## 0.4.20
+
+### Patch Changes
+
+- 0cdd803: `String.prototype.replaceAll` is linear instead of quadratic (baronunread/sproutboat#237). Porffor grew the result with one full-copy `strcat` per match; a patch to `compiler/builtins/string.ts` collects the pieces and joins them once. Replacing in a 2.1 MB string went from about 42 s to 71 ms (Node: 36 ms), with identical output.
+
+## 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

package/package.json

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

package/src/acquire.test.ts

@@ -30,6 +30,8 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "}\n" +
       "#define PORF_CORO_STACK_SIZE (256u * 1024u)\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" +
@@ -47,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" +
@@ -117,6 +120,12 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "}\n",
     "compiler/builtins/json.ts": "// sb_json_utf16_v1\n",
     "runtime/fetch-globals.js": "// sb_text_encoder_scalar_v1\n",
+    "compiler/builtins/string.ts":
+      "export const __Porffor_string_replaceAll = (str: any, searchValue: any, replaceValue: any) => {\n" +
+      "  let out: any = __Porffor_string_emptyLike(str);\n  let appendIndex: i32 = 0;\n  let searchIndex: i32 = 0;\n  let matched: boolean = false;\n" +
+      "    out = __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, matchIndex));\n    out = __Porffor_strcat(out, __Porffor_string_applyReplacer(str, match, matchIndex, replaceValue));\n" +
+      "  if (!matched) return str;\n  return __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, thisLen));\n};\n" +
+      "export const __String_prototype_replaceAll = function (this: string, searchValue: any, replaceValue: any) {};\n",
     "compiler/builtins/promise.ts":
       "export const __Porffor_promise_resolve = (value: any, promise: any): void => {\n" +
       "  if (Porffor.type(value) == Porffor.TYPES.object) {\n" +
@@ -199,6 +208,15 @@ test("the default call (no url/expectedSha256 override) never touches the networ
     },
   });
   expect(await readFile(join(dir, "runtime/index.js"), "utf8")).not.toBe("");
+  // #237: replaceAll joins its pieces once instead of a strcat per match.
+  expect(await readFile(join(dir, "compiler/builtins/string.ts"), "utf8")).toContain(
+    "return Porffor.callThis(__Array_prototype_join, pieces, '');",
+  );
+  // #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.

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

@@ -200,6 +200,61 @@ const FP_CONTRACT_ANCHOR = "      '-fno-ident', '-ffunction-sections', '-fdata-s
 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
@@ -215,6 +270,27 @@ const PROMISE_NULL_INJECT =
   "  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";
 
+// baronunread/sproutboat#237: String.prototype.replaceAll grew its result with
+// one __Porffor_strcat per match, and each strcat copies everything so far, so
+// a 2.7 MB string with many matches took ~22 s (Node: 17 ms). Collect the
+// pieces and join once: Array.prototype.join sizes the result up front and
+// copies each piece a single time.
+const REPLACE_ALL_EDITS = [
+  [
+    "  let out: any = __Porffor_string_emptyLike(str);\n  let appendIndex: i32 = 0;\n  let searchIndex: i32 = 0;\n  let matched: boolean = false;",
+    "  // sproutboat #237: pieces joined once, not a strcat (full copy) per match.\n  const pieces: any[] = Porffor.array.new(0);\n  let appendIndex: i32 = 0;\n  let searchIndex: i32 = 0;\n  let matched: boolean = false;",
+  ],
+  [
+    "    out = __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, matchIndex));\n    out = __Porffor_strcat(out, __Porffor_string_applyReplacer(str, match, matchIndex, replaceValue));",
+    "    Porffor.array.fastPush(pieces, __Porffor_string_substringLike(str, appendIndex, matchIndex));\n    Porffor.array.fastPush(pieces, __Porffor_string_applyReplacer(str, match, matchIndex, replaceValue));",
+  ],
+  [
+    "  if (!matched) return str;\n  return __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, thisLen));\n};",
+    "  if (!matched) return str;\n  Porffor.array.fastPush(pieces, __Porffor_string_substringLike(str, appendIndex, thisLen));\n  return Porffor.callThis(__Array_prototype_join, pieces, '');\n};",
+  ],
+] as const;
+const REPLACE_ALL_MARKER = "sproutboat #237: pieces joined once";
+
 // 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
@@ -775,6 +851,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)"],
@@ -961,6 +1038,7 @@ 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;
@@ -968,6 +1046,8 @@ async function patchCompilerArgs(root: string): Promise<void> {
     [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);
@@ -1011,6 +1091,23 @@ export async function patchPromiseResolveNull(root: string): Promise<void> {
   await writeFile(file, src.replace(PROMISE_NULL_ANCHOR, PROMISE_NULL_INJECT));
 }
 
+/** #237: linear String.prototype.replaceAll. Precompiled by patchTypedArrayFrom. */
+export async function patchReplaceAll(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/string.ts");
+  let src = await readFile(file, "utf8");
+  if (src.includes(REPLACE_ALL_MARKER)) return;
+  const start = src.indexOf("export const __Porffor_string_replaceAll = ");
+  const end = src.indexOf("export const __String_prototype_replaceAll = ", start);
+  if (start < 0 || end < 0) throw new Error(`could not find Porffor's replaceAll in ${file}`);
+  let body = src.slice(start, end);
+  for (const [anchor, inject] of REPLACE_ALL_EDITS) {
+    if (!body.includes(anchor)) throw new Error(`could not patch Porffor's replaceAll: anchor not found in ${file}`);
+    body = body.replace(anchor, inject);
+  }
+  src = src.slice(0, start) + body + src.slice(end);
+  await writeFile(file, src);
+}
+
 export async function patchTypedArrayFrom(root: string): Promise<void> {
   const file = resolve(root, "compiler/builtins/typedarray.js");
   const src = await readFile(file, "utf8");
@@ -1087,8 +1184,9 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   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 patchReplaceAll(root);
+  // Last of the builtin edits: its precompile picks up the date, promise and
+  // replaceAll patches above too.
   await patchTypedArrayFrom(root);
   await patchUnicode(root);
   done.add(root);