@sproutboat/toolchain 0.4.19 → 0.4.21

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/toolchain
 
+## 0.4.21
+
+### Patch Changes
+
+- 1b80c4b: Integer typed-array stores wrap modulo 2^n as the spec requires, instead of saturating (part of baronunread/sproutboat#238). Porffor converted the stored value with a saturating float-to-int conversion, so `uint32[i] = x | 0` stored 0 for any negative `x`, `int32[i] = 4e9` stored 2147483647, and `fill`/`set`/`from` had the same bug. This broke pure-JS hashing such as @noble/hashes' SHA-256, which now matches Node.
+
+## 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

package/package.json

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

package/src/acquire.test.ts

@@ -120,6 +120,14 @@ 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/codegen.js":
+      "      stmt(scope, Store(ctype, addr, 4, ctype === 'f64' || ctype === 'f32' ? f : signed ? Convert(T.i32, f) : Convert(T.u32, f, 0)));\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" +
@@ -202,6 +210,14 @@ test("the default call (no url/expectedSha256 override) never touches the networ
     },
   });
   expect(await readFile(join(dir, "runtime/index.js"), "utf8")).not.toBe("");
+  // #238: integer typed-array stores wrap modulo 2^n instead of saturating.
+  expect(await readFile(join(dir, "compiler/codegen.js"), "utf8")).toContain(
+    "signed ? Convert(T.i32, toUint32(scope, f), CONVERT_RANGE_KNOWN | CONVERT_SIGNED) : toUint32(scope, f)",
+  );
+  // #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';");

package/src/patch.ts

@@ -270,6 +270,42 @@ 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";
+
+// baronunread/sproutboat#238: an integer typed-array element store converted
+// its value with a saturating f64 -> int Convert, so a negative value stored
+// into a Uint32Array became 0 and 4e9 into an Int32Array became 2147483647.
+// ECMA-262 (IntegerIndexedElementSet -> ToUint32 / ToInt32 / ToUint16 ...) wraps
+// modulo 2^n instead. noble-hashes' SHA-256 stores `x | 0` into a Uint32Array,
+// so every negative schedule word was zeroed and the digest came out wrong.
+// Route the store through codegen's own modular toUint32 (what bitwise ops use);
+// narrower stores keep the low bits, which is exactly the modular result.
+const TA_STORE_ANCHOR =
+  "      stmt(scope, Store(ctype, addr, 4, ctype === 'f64' || ctype === 'f32' ? f : signed ? Convert(T.i32, f) : Convert(T.u32, f, 0)));";
+const TA_STORE_INJECT =
+  "      // sproutboat #238: typed-array stores wrap modulo 2^n (ToUint32), not saturate.\n" +
+  "      stmt(scope, Store(ctype, addr, 4, ctype === 'f64' || ctype === 'f32' ? f : signed ? Convert(T.i32, toUint32(scope, f), CONVERT_RANGE_KNOWN | CONVERT_SIGNED) : toUint32(scope, f)));";
+const TA_STORE_MARKER = "sproutboat #238: typed-array stores wrap";
+
 // 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
@@ -1070,6 +1106,33 @@ 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);
+}
+
+/** #238: modular typed-array stores. Before the precompile so builtins get it too. */
+export async function patchTypedArrayStore(root: string): Promise<void> {
+  const file = resolve(root, "compiler/codegen.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(TA_STORE_MARKER)) return;
+  if (!src.includes(TA_STORE_ANCHOR))
+    throw new Error(`could not patch Porffor's typed-array store conversion: anchor not found in ${file}`);
+  await writeFile(file, src.replace(TA_STORE_ANCHOR, TA_STORE_INJECT));
+}
+
 export async function patchTypedArrayFrom(root: string): Promise<void> {
   const file = resolve(root, "compiler/builtins/typedarray.js");
   const src = await readFile(file, "utf8");
@@ -1146,8 +1209,10 @@ 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);
+  await patchTypedArrayStore(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);