porffor 0.58.14 → 0.58.16

package/compiler/opt.js

@@ -22,12 +22,8 @@ export default (funcs, globals, pages, tags, exceptions) => {
     while (runs > 0) {
       runs--;
 
-      // main pass
       for (let i = 0; i < wasm.length; i++) {
-        let inst = wasm[i];
-        inst = [ ...inst ];
-        wasm[i] = inst;
-
+        const inst = wasm[i];
         if (inst[0] === Opcodes.block) {
           // remove unneeded blocks (no brs inside)
           // block
@@ -53,23 +49,22 @@ export default (funcs, globals, pages, tags, exceptions) => {
           if (!hasBranch) {
             wasm.splice(i, 1); // remove this inst (block)
             if (i > 0) i--;
-            inst = wasm[i];
 
             wasm.splice(j - 1, 1); // remove end of this block
 
             if (Prefs.optLog) log('opt', `removed unneeded block in for loop`);
+            continue;
           }
         }
 
         // remove setting last type if it is never gotten
         if (!f.internal && !f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType) {
           // replace this inst with drop
-          wasm.splice(i, 1, [ Opcodes.drop ]); // remove this and last inst
-          if (i > 0) i--;
+          wasm[i] = [ Opcodes.drop ];
         }
 
         if (i < 1) continue;
-        let lastInst = wasm[i - 1];
+        const lastInst = wasm[i - 1];
 
         if (lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_set && inst[0] === Opcodes.local_get) {
           // replace set, get -> tee (sets and returns)
@@ -78,8 +73,8 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // -->
           // local.tee 0
 
-          lastInst[0] = Opcodes.local_tee; // replace last inst opcode (set -> tee)
           wasm.splice(i, 1); // remove this inst (get)
+          wasm[i - 1] = [ Opcodes.local_tee, ...lastInst.slice(1) ]; // replace last inst opcode (set -> tee)
 
           i--;
           // if (Prefs.optLog) log('opt', `consolidated set, get -> tee`);
@@ -105,8 +100,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // -->
           // local.set 0
 
-          lastInst[0] = Opcodes.local_set; // change last op
-
+          wasm[i - 1] = [ Opcodes.local_set, lastInst[1] ]; // change last op
           wasm.splice(i, 1); // remove this inst
           i--;
           continue;
@@ -131,7 +125,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // -->
           // i32.eqz
 
-          inst[0] = Opcodes.eqz[0][0]; // eq -> eqz
+          wasm[i] = [ Opcodes.eqz[0][0] ]; // eq -> eqz
           wasm.splice(i - 1, 1); // remove const 0
           i--;
           continue;
@@ -213,7 +207,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // -->
           // return_call X
 
-          lastInst[0] = Opcodes.return_call; // change last inst return -> return_call
+          wasm[i - 1] = [ Opcodes.return_call, ...lastInst.slice(1) ]; // change last inst return -> return_call
 
           wasm.splice(i, 1); // remove this inst (return)
           i--;

package/compiler/parse.js

@@ -36,6 +36,7 @@ export default input => {
       next: true,
       module: Prefs.module,
       webcompat: true,
+      raw: true,
 
       // babel
       plugins: types ? ['estree', 'typescript'] : ['estree'],
@@ -46,10 +47,11 @@ export default input => {
       ranges: false,
       tokens: false,
       comments: false,
+      preserveParens: false,
 
       // oxc
       lang: types ? 'ts' : 'js',
-      showSemanticErrors: true // sorry oxc pals but this default is bad
+      showSemanticErrors: true
     };
 
     let ast = parser === 'oxc-parser' ? parse('js', input, options) : parse(input, options);

package/compiler/precompile.js

@@ -249,7 +249,7 @@ ${funcs.map(x => {
       .replace(/\"local","(.*?)",(.*?)\]/g, (_, name, valtype) => `loc('${name}',${valtype})]`)
       .replace(/\[16,"(.*?)"]/g, (_, name) => `[16,builtin('${name}')]`)
       .replace(/\["funcref",(.*?),"(.*?)"]/g, (_1, op, name) => op === '65' ? `...i32ify(funcRef('${name}'))` : `...funcRef('${name}')`)
-      .replace(/\["str",(.*?),"(.*?)",(.*?)]/g, (_1, op, str, forceBytestring) => op === '65' ? `...i32ify(makeString(_,"${str}",${forceBytestring ? 1 : 0}))` : `...makeString(_,"${str}",${forceBytestring ? 1 : 0})`)
+      .replace(/\["str",(.*?),"(.*?)",(.*?)]/g, (_1, op, str, bytestring) => op === '65' ? `...i32ify(makeString(_,"${str}",${bytestring}))` : `...makeString(_,"${str}",${bytestring === 'true' ? 1 : 0})`)
       .replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(_,'${constructor}',\`${message}\`)`)
       .replace(/\["get object","(.*?)"\]/g, (_, objName) => `...generateIdent(_,{name:'${objName}'})`)
       .replace(/\[null,"typeswitch case start",\[(.*?)\]\],/g, (_, types) => `...t([${types}],()=>[`)
@@ -284,7 +284,7 @@ params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.retu
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},
 ${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && Object.keys(x.data).length > 0 ? `data:${JSON.stringify(x.data)},` : ''}
 ${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}${x.usesTag ? `usesTag:1,` : ''}${x.usesImports ? `usesImports:1,` : ''}
-}`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
+}`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll(',\n}', '\n}');
 }).join('\n')}
 }`;
 };

package/compiler/prototype.js

@@ -14,54 +14,6 @@ export const PrototypeFuncs = function() {
     else zeroChecks = {};
 
   this[TYPES.array] = {
-    // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    at: ({ pointer, length, arg, iTmp, setType }) => [
-      ...arg,
-      Opcodes.i32_to,
-      [ Opcodes.local_tee, iTmp ],
-
-      // if index < 0: access index + array length
-      number(0, Valtype.i32),
-      [ Opcodes.i32_lt_s ],
-      [ Opcodes.if, Blocktype.void ],
-        [ Opcodes.local_get, iTmp ],
-        ...length.getCachedI32(),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_set, iTmp ],
-      [ Opcodes.end ],
-
-      // if still < 0 or >= length: return undefined
-      [ Opcodes.local_get, iTmp ],
-      number(0, Valtype.i32),
-      [ Opcodes.i32_lt_s ],
-
-      [ Opcodes.local_get, iTmp ],
-      ...length.getCachedI32(),
-      [ Opcodes.i32_ge_s ],
-      [ Opcodes.i32_or ],
-
-      [ Opcodes.if, Blocktype.void ],
-        number(UNDEFINED),
-        ...setType(TYPES.undefined),
-        [ Opcodes.br, 1 ],
-      [ Opcodes.end ],
-
-      [ Opcodes.local_get, iTmp ],
-      number(ValtypeSize[valtype] + 1, Valtype.i32),
-      [ Opcodes.i32_mul ],
-      ...pointer,
-      [ Opcodes.i32_add ],
-      [ Opcodes.local_set, iTmp ],
-
-      // read from memory
-      [ Opcodes.local_get, iTmp ],
-      [ Opcodes.load, 0, ValtypeSize.i32 ],
-
-      [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
-      ...setType()
-    ],
-
     pop: ({ pointer, length, iTmp, unusedValue, setType }) => [
       // if length == 0, noop
       ...length.getCachedI32(),
@@ -177,7 +129,6 @@ export const PrototypeFuncs = function() {
     ]
   };
 
-  this[TYPES.array].at.local = Valtype.i32;
   this[TYPES.array].pop.local = Valtype.i32;
 
   this[TYPES.string] = {

package/compiler/wrap.js

@@ -6,8 +6,6 @@ import './prefs.js';
 
 const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs')) : undefined);
 
-const checkOOB = (memory, ptr) => ptr >= memory.buffer.byteLength;
-
 let dv;
 const read = (ta, memory, ptr, length) => {
   if (ta === Uint8Array) return new Uint8Array(memory.buffer, ptr, length);
@@ -43,7 +41,7 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type, override = undefin
     case TYPES.booleanobject: return new Boolean(value);
 
     case TYPES.object: {
-      if (value === 0 || checkOOB(memory, value)) return null;
+      if (value === 0) return null;
 
       const size = read(Uint16Array, memory, value, 1)[0];
 

package/fuzz/generator.js

@@ -0,0 +1,201 @@
+// Track declared variables to avoid undefined references
+let declaredVars = [];
+
+const generators = {
+  // Literals - wrap in parens to avoid identifier issues like 9.prototype
+  number: () => {
+    const num = Math.random() < 0.5 ? Math.floor(Math.random() * 100) : Math.random() * 100;
+    return `(${num})`;
+  },
+  string: () => {
+    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    const len = Math.floor(Math.random() * 8) + 1;
+    return `'${Array.from({length: len}, () => chars[Math.floor(Math.random() * chars.length)]).join('')}'`;
+  },
+  boolean: () => Math.random() < 0.5 ? 'true' : 'false',
+  null: () => 'null',
+  undefined: () => 'undefined',
+
+  // Arrays - simple arrays only
+  array: (depth = 0) => {
+    if (depth > 2) return '[]';
+    const len = Math.floor(Math.random() * 3);
+    if (len === 0) return '[]';
+    const items = Array.from({length: len}, () => generateSimple());
+    return `[${items.join(', ')}]`;
+  },
+
+  // Objects - simple objects only
+  object: (depth = 0) => {
+    if (depth > 2) return '{}';
+    const len = Math.floor(Math.random() * 3);
+    if (len === 0) return '{}';
+    const props = Array.from({length: len}, () => {
+      const key = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+      // Ensure valid property syntax
+      return `'${key}': ${generateSimple()}`;
+    });
+    return `({${props.join(', ')}})`;
+  },
+
+  // Variables - only use declared ones
+  variable: () => {
+    if (declaredVars.length === 0) return '42';
+    return declaredVars[Math.floor(Math.random() * declaredVars.length)];
+  }
+};
+
+// Generate simple expressions (no complex nesting)
+function generateSimple() {
+  const simpleTypes = ['number', 'string', 'boolean', 'null', 'undefined'];
+  if (declaredVars.length > 0 && Math.random() < 0.3) {
+    simpleTypes.push('variable');
+  }
+  const type = simpleTypes[Math.floor(Math.random() * simpleTypes.length)];
+  const result = generators[type]();
+  // Ensure we never return undefined/null that could cause syntax issues
+  return result || '42';
+}
+
+// Generate expressions with controlled complexity
+function generateExpression(depth = 0) {
+  if (depth > 2) return generateSimple();
+
+  const roll = Math.random();
+
+  if (roll < 0.4) {
+    // Simple value
+    return generateSimple();
+  } else if (roll < 0.6) {
+    // Binary operation
+    const ops = ['+', '-', '*', '/', '%', '===', '!==', '>', '<', '>=', '<=', '&&', '||'];
+    const op = ops[Math.floor(Math.random() * ops.length)];
+    return `(${generateExpression(depth + 1)} ${op} ${generateExpression(depth + 1)})`;
+  } else if (roll < 0.75) {
+    // Unary operation
+    const ops = ['!', '-', '+', 'typeof'];
+    const op = ops[Math.floor(Math.random() * ops.length)];
+    return `(${op} ${generateExpression(depth + 1)})`;
+  } else if (roll < 0.85) {
+    // Function call
+    const builtins = ['Math.abs', 'Math.floor', 'Math.ceil', 'String', 'Number', 'Boolean'];
+    const func = builtins[Math.floor(Math.random() * builtins.length)];
+    const argCount = Math.floor(Math.random() * 2);
+    const args = Array.from({length: argCount}, () => generateExpression(depth + 1));
+    return `${func}(${args.join(', ')})`;
+  } else if (roll < 0.95) {
+    // Conditional
+    return `(${generateExpression(depth + 1)} ? ${generateExpression(depth + 1)} : ${generateExpression(depth + 1)})`;
+  } else {
+    // Array or object
+    return Math.random() < 0.5 ? generators.array(depth) : generators.object(depth);
+  }
+}
+
+function generateStatement(depth = 0, inFunction = false) {
+  if (depth > 2) return `${generateSimple()};`;
+
+  const roll = Math.random();
+
+  if (roll < 0.3) {
+    // Variable declaration
+    const varName = `var${declaredVars.length}`;
+    declaredVars.push(varName);
+    return `var ${varName} = ${generateExpression()};`;
+  } else if (roll < 0.5 && declaredVars.length > 0) {
+    // Variable assignment
+    const varName = declaredVars[Math.floor(Math.random() * declaredVars.length)];
+    const ops = ['=', '+=', '-=', '*='];
+    const op = ops[Math.floor(Math.random() * ops.length)];
+    return `${varName} ${op} ${generateExpression()};`;
+  } else if (roll < 0.65) {
+    // If statement
+    if (Math.random() < 0.5) {
+      return `if (${generateExpression()}) { ${generateStatement(depth + 1, inFunction)} }`;
+    } else {
+      return `if (${generateExpression()}) { ${generateStatement(depth + 1, inFunction)} } else { ${generateStatement(depth + 1, inFunction)} }`;
+    }
+  } else if (roll < 0.75) {
+    // Loop
+    if (Math.random() < 0.5) {
+      const limit = Math.floor(Math.random() * 5) + 1;
+      return `for (let i = 0; i < ${limit}; i++) { ${generateStatement(depth + 1, inFunction)} }`;
+    } else {
+      return `while (${generateExpression(depth + 1)}) { ${generateStatement(depth + 1, inFunction)} break; }`;
+    }
+  } else if (roll < 0.85) {
+    // Try/catch
+    return `try { ${generateStatement(depth + 1, inFunction)} } catch (e) { ${generateStatement(depth + 1, inFunction)} }`;
+  } else if (roll < 0.95 && inFunction) {
+    // Return (only in functions)
+    return `return ${generateExpression()};`;
+  } else {
+    // Expression statement
+    return `${generateExpression()};`;
+  }
+}
+
+function generateFunction() {
+  const name = `func${Math.floor(Math.random() * 100)}`;
+  const paramCount = Math.floor(Math.random() * 3);
+  const params = Array.from({length: paramCount}, (_, i) => `param${i}`);
+
+  // Save current variables and add parameters
+  const savedVars = [...declaredVars];
+  params.forEach(p => declaredVars.push(p));
+
+  const stmtCount = Math.floor(Math.random() * 3) + 1;
+  const statements = [];
+  for (let i = 0; i < stmtCount; i++) {
+    statements.push('  ' + generateStatement(0, true));
+  }
+
+  // Always add a simple return to avoid syntax issues
+  statements.push('  return ' + generateSimple() + ';');
+
+  // Restore variables
+  declaredVars = savedVars;
+
+  return `function ${name}(${params.join(', ')}) {\n${statements.join('\n')}\n}`;
+}
+
+function generateProgram(options = {}) {
+  const {
+    maxStatements = 8,
+    maxFunctions = 2,
+    includeStrictMode = false
+  } = options;
+
+  declaredVars = [];
+
+  let code = '';
+
+  if (includeStrictMode) {
+    code += "'use strict';\n";
+  }
+
+  // Always declare some initial variables
+  const varCount = Math.floor(Math.random() * 3) + 2;
+  for (let i = 0; i < varCount; i++) {
+    const varName = `var${i}`;
+    declaredVars.push(varName);
+    code += `var ${varName} = ${generateExpression()};\n`;
+  }
+
+  const funcCount = Math.floor(Math.random() * maxFunctions) + 1;
+  for (let i = 0; i < funcCount; i++) {
+    code += generateFunction() + '\n\n';
+  }
+
+  const stmtCount = Math.floor(Math.random() * maxStatements) + 2;
+  for (let i = 0; i < stmtCount; i++) {
+    code += generateStatement() + '\n';
+  }
+
+  // Always end with a result
+  code += `var result = ${generateExpression()};\n`;
+
+  return code;
+}
+
+export { generateExpression as generate, generateStatement, generateFunction, generateProgram };

package/fuzz/index.js

@@ -0,0 +1,270 @@
+import cluster from 'node:cluster';
+import fs from 'node:fs';
+import os from 'node:os';
+import process from 'node:process';
+import { generateProgram } from './generator.js';
+
+const workerDataPath = '/tmp/fuzzWorkerData.json';
+
+if (cluster.isPrimary) {
+  const veryStart = performance.now();
+
+  // Parse CLI arguments
+  let threads = parseInt(process.argv.find(x => x.startsWith('--threads='))?.split('=')?.[1]);
+  if (Number.isNaN(threads)) {
+    threads = Math.max(1, os.cpus().length - 1);
+    console.log(`Using ${threads} threads (detected ${os.cpus().length} CPUs)`);
+  }
+
+  const duration = parseFloat(process.argv.find(x => x.startsWith('--duration='))?.split('=')?.[1]) || 60; // seconds
+  const maxStatements = parseInt(process.argv.find(x => x.startsWith('--max-statements='))?.split('=')?.[1]) || 8;
+  const maxFunctions = parseInt(process.argv.find(x => x.startsWith('--max-functions='))?.split('=')?.[1]) || 2;
+  const verbose = process.argv.includes('--verbose');
+  const saveFailures = process.argv.includes('--save-failures');
+  const plainResults = process.argv.includes('--plain-results');
+
+  console.log(`Starting fuzzer for ${duration}s with ${threads} threads`);
+  console.log(`Max statements: ${maxStatements}, Max functions: ${maxFunctions}`);
+
+  const table = (...arr) => {
+    let out = '';
+    const total = arr[0];
+    for (let i = 0; i < arr.length; i++) {
+      let icon = [ '🧪', '🤠', '❌', '💀', '🏗️', '💥', '⏰', '📝' ][i];
+      let iconDesc = [ 'total', 'pass', 'fail', 'runtime error', 'wasm compile error', 'compile error', 'timeout', 'todo' ][i];
+
+      let data = arr[i];
+      if (i > 0) data = ((data / total) * 100).toPrecision(2) + '%';
+      let str = `${plainResults ? iconDesc : icon} ${data}`;
+      if (i !== arr.length - 1) str += plainResults ? ' | ' : '\u001b[90m | \u001b[0m';
+      out += str;
+    }
+    return out;
+  };
+
+  // Stats tracking - same order as test262
+  let totalTests = 0;
+  let passes = 0;
+  let fails = 0;
+  let runtimeErrors = 0;
+  let wasmErrors = 0;
+  let compileErrors = 0;
+  let timeouts = 0;
+  let todos = 0;
+
+  const errorCounts = new Map();
+  const failureFiles = [];
+
+  const startTime = performance.now();
+  const endTime = startTime + (duration * 1000);
+
+  // Worker data
+  const workerData = {
+    maxStatements,
+    maxFunctions,
+    verbose,
+    saveFailures,
+    endTime
+  };
+  fs.writeFileSync(workerDataPath, JSON.stringify(workerData));
+
+  // Stats display
+  let lastUpdate = 0;
+  const updateInterval = 100;
+  let spinner = ['-', '\\', '|', '/'], spin = 0;
+
+  const updateStats = () => {
+    const now = performance.now();
+    if (now - lastUpdate < updateInterval) return;
+    lastUpdate = now;
+
+    const elapsed = (now - startTime) / 1000;
+    const remaining = Math.max(0, (endTime - now) / 1000);
+    const rate = totalTests / elapsed;
+
+    const tab = ` \u001b[90m${spinner[spin++ % 4]}\u001b[0m  ` +
+      table(totalTests, passes, fails, runtimeErrors, wasmErrors, compileErrors, timeouts, todos);
+
+    process.stdout.write(`\r\u001b[K${tab} | ${rate.toFixed(0)}/s | ${remaining.toFixed(1)}s left`);
+  };
+
+  // Spawn workers with timeout handling like test262
+  const workers = [];
+
+  const spawn = (index) => {
+    const worker = cluster.fork();
+    workers[index] = worker;
+
+    let timeout;
+    const enqueue = () => {
+      if (performance.now() >= endTime) {
+        worker.kill();
+        return;
+      }
+
+      if (timeout) clearTimeout(timeout);
+
+      worker.send(null);
+      timeout = setTimeout(() => {
+        worker.kill();
+
+        totalTests++;
+        timeouts++;
+        errorCounts.set('timeout', (errorCounts.get('timeout') || 0) + 1);
+
+        if (saveFailures) {
+          const timestamp = Date.now();
+          const filename = `fuzz/failure_${timestamp}_timeout.js`;
+          fs.writeFileSync(filename, 'timeout');
+          failureFiles.push(filename);
+        }
+
+        updateStats();
+        spawn(index); // Respawn worker
+      }, 1000);
+    };
+
+    worker.on('message', msg => {
+      if (msg === null) {
+        enqueue();
+        return;
+      }
+
+      if (timeout) clearTimeout(timeout);
+
+      totalTests++;
+
+      // result encoding: pass=0, todo=1, wasmError=2, compileError=3, fail=4, timeout=5, runtimeError=6
+      const result = msg.result;
+
+      if (msg.error) {
+        const error = `${msg.error.name}: ${msg.error.message}`
+          .replace(/\([0-9]+:[0-9]+\)/, '')
+          .replace(/@\+[0-9]+/, '');
+        errorCounts.set(error, (errorCounts.get(error) || 0) + 1);
+      }
+
+      if (result === 0) {
+        passes++;
+      } else if (result === 1) {
+        todos++;
+      } else if (result === 2) {
+        wasmErrors++;
+      } else if (result === 3) {
+        compileErrors++;
+      } else if (result === 4) {
+        fails++;
+      } else if (result === 6) {
+        runtimeErrors++;
+      }
+
+      if (msg.code && (result !== 0 || verbose)) {
+        if (saveFailures && result !== 0) {
+          const timestamp = Date.now();
+          const resultNames = ['pass', 'todo', 'wasmError', 'compileError', 'fail', 'timeout', 'runtimeError'];
+          const filename = `fuzz/failure_${timestamp}_${resultNames[result]}.js`;
+          fs.writeFileSync(filename, msg.code);
+          failureFiles.push(filename);
+        }
+
+        if (verbose && result !== 0) {
+          const resultNames = ['PASS', 'TODO', 'WASM_ERROR', 'COMPILE_ERROR', 'FAIL', 'TIMEOUT', 'RUNTIME_ERROR'];
+          console.log('---');
+          console.log(`\n[${resultNames[result]}] ${msg.error?.message || 'Unknown error'}`);
+          console.log(msg.code);
+          console.log('---');
+        }
+      }
+
+      updateStats();
+      enqueue();
+    });
+  };
+
+  for (let i = 0; i < threads; i++) {
+    spawn(i);
+  }
+
+  // Handle cleanup
+  const cleanup = () => {
+    workers.forEach(worker => worker.kill());
+
+    console.log('\u001b[2F\u001b[0J\u001b[1m\u001b[4mfuzzing complete\u001b[0m');
+
+    console.log(table(totalTests, passes, fails, runtimeErrors, wasmErrors, compileErrors, timeouts, todos) + '\n\n');
+
+    if (errorCounts.size > 0) {
+      const sortedErrors = [...errorCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+      sortedErrors.forEach(([error, count]) => {
+        console.log(`\u001b[90m${((count / totalTests) * 100).toPrecision(2).padStart(6, ' ')}%\u001b[0m \u001b[1m${error}\u001b[0m`);
+      });
+    }
+
+    if (failureFiles.length > 0) {
+      console.log(`\nFailure files saved: ${failureFiles.length}`);
+      failureFiles.slice(0, 5).forEach(file => console.log(`  ${file}`));
+      if (failureFiles.length > 5) console.log(`  ... and ${failureFiles.length - 5} more`);
+    }
+
+    const elapsed = (performance.now() - startTime) / 1000;
+    console.log(`\n\u001b[90mtook ${elapsed.toFixed(1)}s (${(totalTests / elapsed).toFixed(0)} tests/s)\u001b[0m`);
+
+    process.exit(0);
+  };
+
+  // Auto-stop after duration
+  if (duration !== Infinity) setTimeout(cleanup, duration * 1000);
+
+  // Handle Ctrl+C
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+} else {
+  // Worker process
+  let { maxStatements, maxFunctions, verbose, saveFailures, endTime } = JSON.parse(fs.readFileSync(workerDataPath, 'utf8'));
+  endTime ??= Infinity;
+  const compile = (await import('../compiler/wrap.js')).default;
+
+  process.on('message', () => {
+    if (performance.now() >= endTime) {
+      process.exit(0);
+    }
+
+    const code = generateProgram({ maxStatements, maxFunctions });
+
+    let result = 0; // pass
+    let error = null;
+    let stage = 0;
+
+    try {
+      const out = compile(code, false, {});
+
+      try {
+        out.exports.main();
+        stage = 2;
+        result = 0; // pass
+      } catch (runtimeError) {
+        stage = 1;
+        error = runtimeError;
+        result = 6; // runtime error
+      }
+    } catch (compileError) {
+      stage = 0;
+      error = compileError;
+
+      // Classify compile errors same as test262
+      if (compileError.name === 'CompileError') {
+        result = 2; // wasm compile error
+      } else {
+        result = 3; // compile error
+      }
+    }
+
+    process.send({
+      result,
+      error: error ? { name: error.name, message: error.message } : null,
+      code: verbose || saveFailures ? code : null
+    });
+  });
+
+  process.send(null);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.58.14",
+  "version": "0.58.16",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.58.14';
+globalThis.version = '0.58.16';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {