Merge branch 'main' into 2025-10-27_js-tokens

Author: camillobruni

.github/workflows/test.yml

@@ -10,63 +10,95 @@ on:
     workflow_dispatch:
 
 jobs:
-    test:
-        name: Test
+    browser-macos:
+        name: Test Browser on macOS
         runs-on: macos-latest
         env:
             GITHUB_ACTIONS_OUTPUT: ""
         strategy:
             fail-fast: false
             matrix:
-                browser: [chrome, firefox, jsc, safari, spidermonkey, v8]
+                browser: [safari]
+                suite: [default, disabled, main]
         steps:
-            - name: Extract Week Number
-              run: echo "WEEK_NUMBER=$(date +%W)" >> $GITHUB_ENV
-
-            - name: Install Firefox
-              if: ${{ matrix.browser == 'firefox' }}
-              run: brew install --cask firefox
 
-            - name: Checkout Branch
+            - &checkout-branch
+              name: Checkout Branch
               uses: actions/checkout@v5
 
-            - name: Setup Node
+            - &setup-node
+              name: Setup Node
               uses: actions/setup-node@v5
               with:
                   node-version-file: package.json
                   cache: npm
 
-            - name: Install Node Packages
+            - &install-node-packages
+              name: Install Node Packages
               run: npm ci
 
+            - name: Run Tests
+              run: |
+                  echo "Running in $BROWSER"
+                  npm run test:${{ matrix.browser }} -- ${{ matrix.suite }}
+
+    browser-linux:
+        name: Test Browser on Linux
+        runs-on: ubuntu-latest
+        env:
+            GITHUB_ACTIONS_OUTPUT: ""
+        strategy:
+            fail-fast: false
+            matrix:
+                browser: [chrome, firefox]
+                suite: [default, disabled, main]
+        steps:
+            - *checkout-branch
+            - *setup-node
+            - *install-node-packages
+            - name: Run Tests
+              run: |
+                  echo "Running in $BROWSER"
+                  npm run test:${{ matrix.browser }} -- ${{ matrix.suite }}
+    shell:
+        name: Test Shell
+        runs-on: ubuntu-latest
+        env:
+            GITHUB_ACTIONS_OUTPUT: ""
+        strategy:
+            fail-fast: false
+            matrix:
+                shell: [jsc, spidermonkey, v8]
+                suite: [default, disabled, main]
+        steps:
+            - *checkout-branch
+            - *setup-node
+            - *install-node-packages
+
+            - name: Extract Week Number
+              run: echo "WEEK_NUMBER=$(date +%W)" >> $GITHUB_ENV
+
             - name: Cache jsvu Binaries 
               uses: actions/cache@v4
               with:
                 path: ~/.jsvu
-                key: ${{ runner.os }}-jsvu-${{ matrix.browser }}-week-${{ env.WEEK_NUMBER }}
+                key: ${{ runner.os }}-jsvu-${{ matrix.shell }}-week-${{ env.WEEK_NUMBER }}
 
             - name: Run Tests
               run: |
                   echo "Running in $BROWSER"
-                  npm run test:${{ matrix.browser }}
-
+                  npm run test:${{ matrix.shell }} -- ${{ matrix.suite }}
     build:
-        name: Build
+        name: Test Build 
         runs-on: ubuntu-latest
         steps:
             - name: Checkout Branch
               uses: actions/checkout@v4
               with:
                 fetch-depth: ${{ github.event_name == 'pull_request' && 2 || 0 }}
 
-            - name: Setup Node
-              uses: actions/setup-node@v4
-              with:
-                  node-version-file: package.json
-                  cache: npm
-
-            - name: Install Node Packages
-              run: npm ci
+            - *setup-node
+            - *install-node-packages
 
             - name: Run Build
               run: |

JetStreamDriver.js

@@ -560,20 +560,35 @@ const BenchmarkState = Object.freeze({
 
 
 class Scripts {
-    constructor() {
+    constructor(preloads) {
         this.scripts = [];
+
+        let preloadsCode = "";
+        let resourcesCode = "";
+        for (let { name, resource, blobURLOrPath } of preloads) {
+            console.assert(name?.length > 0, "Invalid preload name.");
+            console.assert(resource?.length > 0, "Invalid preload resource.");
+            console.assert(blobURLOrPath?.length > 0, "Invalid preload data.");
+            preloadsCode += `${JSON.stringify(name)}: "${blobURLOrPath}",\n`;
+            resourcesCode += `${JSON.stringify(resource)}: "${blobURLOrPath}",\n`;
+        }
         // Expose a globalThis.JetStream object to the workload. We use
         // a proxy to prevent prototype access and throw on unknown properties.
         this.add(`
             const throwOnAccess = (name) => new Proxy({},  {
                 get(target, property, receiver) {
                     throw new Error(name + "." + property + " is not defined.");
                 }
-            }); 
+            });
             globalThis.JetStream = {
                 __proto__: throwOnAccess("JetStream"),
                 preload: {
                     __proto__: throwOnAccess("JetStream.preload"),
+                    ${preloadsCode}
+                },
+                resources: {
+                    __proto__: throwOnAccess("JetStream.preload"),
+                    ${resourcesCode}
                 },
             };
             `);
@@ -631,8 +646,8 @@ class Scripts {
 }
 
 class ShellScripts extends Scripts {
-    constructor() {
-        super();
+    constructor(preloads) {
+        super(preloads);
         this.prefetchedResources = Object.create(null);;
     }
 
@@ -698,8 +713,8 @@ class ShellScripts extends Scripts {
 }
 
 class BrowserScripts extends Scripts {
-    constructor() {
-        super();
+    constructor(preloads) {
+        super(preloads);
         this.add("window.onerror = top.currentReject;");
     }
 
@@ -738,7 +753,7 @@ class Benchmark {
         this.isAsync = !!plan.isAsync;
         this.allowUtf16 = !!plan.allowUtf16;
         this.scripts = null;
-        this.preloads = null;
+        this.preloads = [];
         this.shellPrefetchedResources = null;
         this.results = [];
         this._state = BenchmarkState.READY;
@@ -842,8 +857,9 @@ class Benchmark {
 
     get prerunCode() { return null; }
 
+
     get preIterationCode() {
-        let code = `benchmark.prepareForNextIteration?.();`;
+        let code = this.prepareForNextIterationCode ;
         if (this.plan.deterministicRandom)
             code += `Math.random.__resetSeed();`;
 
@@ -853,6 +869,10 @@ class Benchmark {
         return code;
     }
 
+    get prepareForNextIterationCode() {
+        return "benchmark.prepareForNextIteration?.();"
+    }
+
     get postIterationCode() {
         let code = "";
 
@@ -893,7 +913,7 @@ class Benchmark {
         if (this.isDone)
             throw new Error(`Cannot run Benchmark ${this.name} twice`);
         this._state = BenchmarkState.PREPARE;
-        const scripts = isInBrowser ? new BrowserScripts() : new ShellScripts();
+        const scripts = isInBrowser ? new BrowserScripts(this.preloads) : new ShellScripts(this.preloads);
 
         if (!!this.plan.deterministicRandom)
             scripts.addDeterministicRandom()
@@ -903,15 +923,6 @@ class Benchmark {
         if (this.shellPrefetchedResources) {
             scripts.addPrefetchedResources(this.shellPrefetchedResources);
         }
-        if (this.plan.preload) {
-            let preloadCode = "";
-            for (let [ variableName, blobURLOrPath ] of this.preloads) {
-                console.assert(variableName?.length > 0, "Invalid preload name.");
-                console.assert(blobURLOrPath?.length > 0, "Invalid preload data.");
-                preloadCode += `JetStream.preload[${JSON.stringify(variableName)}] = "${blobURLOrPath}";\n`;
-            }
-            scripts.add(preloadCode);
-        }
 
         const prerunCode = this.prerunCode;
         if (prerunCode)
@@ -1062,12 +1073,11 @@ class Benchmark {
             }));
 
         if (this.plan.preload) {
-            this.preloads = [];
             for (const [name, resource] of Object.entries(this.plan.preload)) {
                 promises.push(this.loadBlob("preload", name, resource).then((blobData) => {
                     if (!globalThis.allIsGood)
                         return;
-                    this.preloads.push([ blobData.prop, blobData.blobURL ]);
+                    this.preloads.push({ name: blobData.prop, resource: blobData.resource, blobURLOrPath: blobData.blobURL });
                     this.updateCounter();
                 }).catch((error) => {
                     // We'll try again later in retryPrefetchResourceForBrowser(). Don't throw an error.
@@ -1094,7 +1104,7 @@ class Benchmark {
             if (type == "preload") {
                 if (this.failedPreloads && this.failedPreloads[blobData.prop]) {
                     this.failedPreloads[blobData.prop] = false;
-                    this.preloads.push([ blobData.prop, blobData.blobURL ]);
+                    this.preloads.push({ name: blobData.prop, resource: blobData.resource, blobURLOrPath: blobData.blobURL });
                     counter.failedPreloadResources--;
                 }
             }
@@ -1107,7 +1117,7 @@ class Benchmark {
             if (!globalThis.allIsGood)
                 return;
             if (blobData.type == "preload")
-                this.preloads.push([ blobData.prop, blobData.blobURL ]);
+                this.preloads.push({ name: blobData.prop, resource: blobData.resource, blobURLOrPath: blobData.blobURL });
             this.updateCounter();
         });
 
@@ -1145,8 +1155,7 @@ class Benchmark {
         console.assert(this.scripts === null, "This initialization should be called only once.");
         this.scripts = this.plan.files.map(file => shellFileLoader.load(file));
 
-        console.assert(this.preloads === null, "This initialization should be called only once.");
-        this.preloads = [];
+        console.assert(this.preloads.length === 0, "This initialization should be called only once.");
         this.shellPrefetchedResources = Object.create(null);
         if (!this.plan.preload) {
             return;
@@ -1165,7 +1174,7 @@ class Benchmark {
                 this.shellPrefetchedResources[resource] = bytes;
             }
 
-            this.preloads.push([name, resource]);
+            this.preloads.push({ name, resource, blobURLOrPath: resource });
         }
     }
 
@@ -1519,6 +1528,10 @@ class AsyncBenchmark extends DefaultBenchmark {
         return str;
     }
 
+    get prepareForNextIterationCode() {
+        return "await benchmark.prepareForNextIteration?.();"
+    }
+
     get runnerCode() {
         return `
         async function doRun() {
@@ -2510,8 +2523,8 @@ let BENCHMARKS = [
             inputFontItalic: "./Kotlin-compose/build/jetbrainsmono_italic.ttf",
             inputFontRegular: "./Kotlin-compose/build/jetbrainsmono_regular.ttf"
         },
-        iterations: 15,
-        worstCaseCount: 2,
+        iterations: 5,
+        worstCaseCount: 1,
         tags: ["default", "Wasm"],
     }),
     new AsyncBenchmark({