Enable --js-base-64 V8 flag (#42731)

This enables:
- `Uint8Array.fromBase64`
- `Uint8Array.fromHex`
- `Uint8Array.prototype.setFromBase64`
- `Uint8Array.prototype.setFromHex`
- `Uint8Array.prototype.toBase64`
- `Uint8Array.prototype.toHex`

GitOrigin-RevId: bb258d9938c75ae35af80804bf0f2a051846d46f

Author: goffrie

crates/isolate/src/client.rs

@@ -586,6 +586,7 @@ pub fn initialize_v8() {
             // tell V8 it can use up to 2MiB of stack space itself. The
             // default is 1MiB. Note that the flag is in KiB (https://github.com/v8/v8/blob/master/src/flags/flag-definitions.h#L1594).
             "--stack-size=2048".to_string(),
+            "--js-base-64".to_string(),
         ];
         if let Ok(flags) = env::var("ISOLATE_V8_FLAGS") {
             argv.extend(

npm-packages/udf-tests/convex/esnext.typedarrays.d.ts

@@ -0,0 +1,97 @@
+/*
+Copied from https://github.com/microsoft/TypeScript/blob/6f4fb0145845db22791188c4d38e3a1a0edfd449/src/lib/esnext.typedarrays.d.ts
+Remove this when we update to a TypeScript version including https://github.com/microsoft/TypeScript/pull/61696
+
+Copyright (c) 2025 Microsoft Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+interface Uint8Array<_TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> {
+  /**
+   * Converts the `Uint8Array` to a base64-encoded string.
+   * @param options If provided, sets the alphabet and padding behavior used.
+   * @returns A base64-encoded string.
+   */
+  toBase64(options?: {
+    alphabet?: "base64" | "base64url" | undefined;
+    omitPadding?: boolean | undefined;
+  }): string;
+
+  /**
+   * Sets the `Uint8Array` from a base64-encoded string.
+   * @param string The base64-encoded string.
+   * @param options If provided, specifies the alphabet and handling of the last chunk.
+   * @returns An object containing the number of bytes read and written.
+   * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
+   * chunk is inconsistent with the `lastChunkHandling` option.
+   */
+  setFromBase64(
+    string: string,
+    options?: {
+      alphabet?: "base64" | "base64url" | undefined;
+      lastChunkHandling?:
+        | "loose"
+        | "strict"
+        | "stop-before-partial"
+        | undefined;
+    },
+  ): {
+    read: number;
+    written: number;
+  };
+
+  /**
+   * Converts the `Uint8Array` to a base16-encoded string.
+   * @returns A base16-encoded string.
+   */
+  toHex(): string;
+
+  /**
+   * Sets the `Uint8Array` from a base16-encoded string.
+   * @param string The base16-encoded string.
+   * @returns An object containing the number of bytes read and written.
+   */
+  setFromHex(string: string): {
+    read: number;
+    written: number;
+  };
+}
+
+interface Uint8ArrayConstructor {
+  /**
+   * Creates a new `Uint8Array` from a base64-encoded string.
+   * @param string The base64-encoded string.
+   * @param options If provided, specifies the alphabet and handling of the last chunk.
+   * @returns A new `Uint8Array` instance.
+   * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
+   * chunk is inconsistent with the `lastChunkHandling` option.
+   */
+  fromBase64(
+    string: string,
+    options?: {
+      alphabet?: "base64" | "base64url" | undefined;
+      lastChunkHandling?:
+        | "loose"
+        | "strict"
+        | "stop-before-partial"
+        | undefined;
+    },
+  ): Uint8Array<ArrayBuffer>;
+
+  /**
+   * Creates a new `Uint8Array` from a base16-encoded string.
+   * @returns A new `Uint8Array` instance.
+   */
+  fromHex(string: string): Uint8Array<ArrayBuffer>;
+}

npm-packages/udf-tests/convex/js_builtins/crypto.ts

@@ -468,11 +468,7 @@ async function importRsaPkcs8() {
     pemHeader.length,
     keyFile.length - pemFooter.length,
   );
-  const binaryDerString = atob(pemContents);
-  const binaryDer = new Uint8Array(binaryDerString.length);
-  for (let i = 0; i < binaryDerString.length; i++) {
-    binaryDer[i] = binaryDerString.charCodeAt(i);
-  }
+  const binaryDer = Uint8Array.fromBase64(pemContents);
 
   const key = await crypto.subtle.importKey(
     "pkcs8",
@@ -514,11 +510,7 @@ async function importRsaSpki() {
     pemHeader.length,
     keyFile.length - pemFooter.length,
   );
-  const binaryDerString = atob(pemContents);
-  const binaryDer = new Uint8Array(binaryDerString.length);
-  for (let i = 0; i < binaryDerString.length; i++) {
-    binaryDer[i] = binaryDerString.charCodeAt(i);
-  }
+  const binaryDer = Uint8Array.fromBase64(pemContents);
 
   const key = await crypto.subtle.importKey(
     "spki",
@@ -755,11 +747,7 @@ async function importNonInteroperableRsaPkcs8() {
       pemHeader.length,
       keyFile.length - pemFooter.length,
     );
-    const binaryDerString = atob(pemContents);
-    const binaryDer = new Uint8Array(binaryDerString.length);
-    for (let i = 0; i < binaryDerString.length; i++) {
-      binaryDer[i] = binaryDerString.charCodeAt(i);
-    }
+    const binaryDer = Uint8Array.fromBase64(pemContents);
 
     await expect(
       crypto.subtle.importKey(
@@ -1745,9 +1733,7 @@ async function testHMACSign() {
     cryptoKey,
     new Uint8Array(8),
   );
-  const actualBase64String = btoa(
-    String.fromCharCode(...new Uint8Array(actual)),
-  );
+  const actualBase64String = new Uint8Array(actual).toBase64();
   // This value is from running the above code in a browser
   const expected = "SdJ6jecfYHT1LzY/Vh03WauHRbzWZeVjDFL4ietJNCw=";
   assert.strictEqual(actualBase64String, expected);
@@ -1771,12 +1757,7 @@ async function testHMACVerify() {
     ["verify"],
   );
 
-  // Convert the base64 signature back to Uint8Array
-  const signature = new Uint8Array(
-    atob(base64Signature)
-      .split("")
-      .map((c) => c.charCodeAt(0)),
-  );
+  const signature = Uint8Array.fromBase64(base64Signature);
 
   const isVerified = await subtle.verify(
     { name: "HMAC" },
@@ -1810,9 +1791,7 @@ async function testHMACSignAlternativeSyntax() {
   await subtle.importKey("raw", key.buffer, importParams, false, ["sign"]);
 
   const actual = await subtle.sign("hmac", cryptoKey, new Uint8Array(8));
-  const actualBase64String = btoa(
-    String.fromCharCode(...new Uint8Array(actual)),
-  );
+  const actualBase64String = new Uint8Array(actual).toBase64();
   // This value is from running the above code in a browser
   const expected = "SdJ6jecfYHT1LzY/Vh03WauHRbzWZeVjDFL4ietJNCw=";
   assert.strictEqual(actualBase64String, expected);
@@ -1914,7 +1893,7 @@ async function testDigest() {
     "SHA-256",
     new TextEncoder().encode("hello"),
   );
-  const digestBase64 = btoa(String.fromCharCode(...new Uint8Array(digest)));
+  const digestBase64 = new Uint8Array(digest).toBase64();
   assert.strictEqual(
     digestBase64,
     "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=",