diff --git a/examples/demo/fibonacci_memo.js b/examples/demo/fibonacci_memo.js
index 300a514..8e8df54 100644
--- a/examples/demo/fibonacci_memo.js
+++ b/examples/demo/fibonacci_memo.js
@@ -6,8 +6,8 @@ function fibonacci(n, memo = {}) {
 }
 
 const start = performance.now();
-const result = fibonacci(621);
+const result = fibonacci(30);
 const end = performance.now();
 
-console.log(`fibonacci(621) = ${result}`);
+console.log(`fibonacci(30) = ${result}`);
 console.log(`Time: ${(end - start).toFixed(4)} ms (${((end - start) * 1000).toFixed(2)} µs)`);
diff --git a/examples/demo/nancoding.js b/examples/demo/nancoding.js
new file mode 100644
index 0000000..27d8215
--- /dev/null
+++ b/examples/demo/nancoding.js
@@ -0,0 +1,40 @@
+const e = new TextEncoder();
+const d = new TextDecoder();
+
+function NaNcode(string) {
+  const encoded = Array.from(e.encode(string));
+  encoded.unshift(0, 0, 0, 0, 0, 0);
+  while (encoded.length % 6) encoded.push(0);
+
+  const bytes = [];
+  let i = 0;
+
+  while (encoded.length) {
+    bytes.push(encoded.shift());
+    i++;
+    if (!(i % 6)) bytes.push(248, 127);
+  }
+
+  return Array.from(new Float64Array(new Uint8Array(bytes).buffer));
+}
+
+function unNaNcode(NaNs) {
+  const raw = new Uint8Array(new Float64Array(NaNs).buffer);
+  let count = 0;
+
+  for (let i = 0; i < raw.length; i++) {
+    if (i % 8 < 6 && raw[i] !== 0) count++;
+  }
+
+  const bytes = new Uint8Array(count);
+
+  let j = 0;
+  for (let i = 0; i < raw.length; i++) {
+    if (i % 8 < 6 && raw[i] !== 0) bytes[j++] = raw[i];
+  }
+
+  return d.decode(bytes);
+}
+
+const NaNcoded = NaNcode('Hello, World! :D');
+console.log(NaNcoded, unNaNcode(NaNcoded));
diff --git a/tests/sym_id.js b/examples/demo/symbols.js
similarity index 63%
rename from tests/sym_id.js
rename to examples/demo/symbols.js
index 7080628..0d4c038 100644
--- a/tests/sym_id.js
+++ b/examples/demo/symbols.js
@@ -1,5 +1,3 @@
-console.log('=== SYMBOL KEY STRINGIFICATION TEST ===\n');
-
 const obj = {};
 
 obj[Symbol.iterator] = 'iter-value';
@@ -19,17 +17,11 @@ console.log('\nIndividual access:');
 console.log('  [Symbol.iterator]: ' + obj[Symbol.iterator]);
 console.log('  [Symbol.toStringTag]: ' + obj[Symbol.toStringTag]);
 
-console.log('\nObject.keys (should NOT include symbols):');
+console.log('\nObject.keys:');
 console.log(Object.keys(obj));
 
-console.log('\nObject.getOwnPropertySymbols (if supported):');
-try {
-  console.log(Object.getOwnPropertySymbols(obj));
-} catch (e) {
-  console.log('  Not supported: ' + e.message);
-}
+console.log('\nObject.getOwnPropertySymbols:');
+console.log(Object.getOwnPropertySymbols(obj));
 
-console.log('\nJSON.stringify (symbols should be skipped):');
+console.log('\nJSON.stringify:');
 console.log(JSON.stringify(obj));
-
-console.log('\n=== DONE ===');
diff --git a/examples/embed/embed.c b/examples/embed/embed.c
index 82cca43..357bb33 100644
--- a/examples/embed/embed.c
+++ b/examples/embed/embed.c
@@ -24,8 +24,8 @@ static void print_header(int num, const char *title) {
   printf("%s\n\n", SUBSEP);
 }
 
-static struct js *create_js_runtime(void *stack_base) {
-  struct js *js = js_create_dynamic();
+static ant_t *create_js_runtime(void *stack_base) {
+  ant_t *js = js_create_dynamic();
   if (!js) {
     fprintf(stderr, "Failed to create JS runtime\n");
     return NULL;
@@ -43,13 +43,13 @@ static void example_basic_eval(void) {
   print_header(1, "Basic Evaluation");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
+
 
   const char *code = "1 + 2 * 3";
-  jsval_t result = js_eval(js, code, strlen(code));
+  jsval_t result = js_eval_bytecode_eval(js, code, strlen(code));
 
   if (vtype(result) == T_NUM) {
     printf("  Result: %g\n", js_getnum(result));
@@ -60,7 +60,7 @@ static void example_basic_eval(void) {
   js_destroy(js);
 }
 
-static jsval_t my_add(struct js *js, jsval_t *args, int nargs) {
+static jsval_t my_add(ant_t *js, jsval_t *args, int nargs) {
   if (!js_chkargs(args, nargs, "dd")) {
     return js_mkerr(js, "add() expects two numbers");
   }
@@ -71,7 +71,7 @@ static jsval_t my_add(struct js *js, jsval_t *args, int nargs) {
   return js_mknum(a + b);
 }
 
-static jsval_t my_greet(struct js *js, jsval_t *args, int nargs) {
+static jsval_t my_greet(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "greet() expects a string");
   }
@@ -85,7 +85,7 @@ static jsval_t my_greet(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, buf, strlen(buf));
 }
 
-static jsval_t my_create_point(struct js *js, jsval_t *args, int nargs) {
+static jsval_t my_create_point(ant_t *js, jsval_t *args, int nargs) {
   if (!js_chkargs(args, nargs, "dd")) {
     return js_mkerr(js, "createPoint() expects two numbers");
   }
@@ -101,10 +101,10 @@ static void example_c_functions(void) {
   print_header(2, "C Functions");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
+
 
   jsval_t global = js_glob(js);
   js_set(js, global, "add", js_mkfun(my_add));
@@ -112,15 +112,15 @@ static void example_c_functions(void) {
   js_set(js, global, "createPoint", js_mkfun(my_create_point));
 
   const char *code1 = "add(10, 32)";
-  jsval_t r1 = js_eval(js, code1, strlen(code1));
+  jsval_t r1 = js_eval_bytecode_eval(js, code1, strlen(code1));
   printf("  add(10, 32) = %g\n", js_getnum(r1));
 
   const char *code2 = "greet('World')";
-  jsval_t r2 = js_eval(js, code2, strlen(code2));
+  jsval_t r2 = js_eval_bytecode_eval(js, code2, strlen(code2));
   printf("  greet('World') = %s\n", js_str(js, r2));
 
   const char *code3 = "let p = createPoint(3, 4); p.x * p.x + p.y * p.y";
-  jsval_t r3 = js_eval(js, code3, strlen(code3));
+  jsval_t r3 = js_eval_bytecode_eval(js, code3, strlen(code3));
   printf("  distance² = %g\n", js_getnum(r3));
 
   js_destroy(js);
@@ -130,10 +130,10 @@ static void example_objects_arrays(void) {
   print_header(3, "Objects and Arrays");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
+
   jsval_t global = js_glob(js);
 
   jsval_t config = js_mkobj(js);
@@ -149,7 +149,7 @@ static void example_objects_arrays(void) {
   js_set(js, global, "numbers", arr);
 
   const char *code = "config.name + ' v' + config.version + ' - sum: ' + numbers.reduce((a,b) => a+b, 0)";
-  jsval_t result = js_eval(js, code, strlen(code));
+  jsval_t result = js_eval_bytecode_eval(js, code, strlen(code));
   printf("  Result: %s\n", js_str(js, result));
 
   jsval_t name_val = js_get(js, config, "name");
@@ -165,19 +165,19 @@ static void example_error_handling(void) {
   print_header(4, "Error Handling");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
+
 
   const char *bad_code = "let x = {";
-  jsval_t r1 = js_eval(js, bad_code, strlen(bad_code));
+  jsval_t r1 = js_eval_bytecode_eval(js, bad_code, strlen(bad_code));
   if (vtype(r1) == T_ERR) {
     printf("  Syntax error:    %s\n", js_str(js, r1));
   }
 
   const char *ref_err = "undefinedVariable + 1";
-  jsval_t r2 = js_eval(js, ref_err, strlen(ref_err));
+  jsval_t r2 = js_eval_bytecode_eval(js, ref_err, strlen(ref_err));
   if (vtype(r2) == T_ERR) {
     printf("  Reference error: %s\n", js_str(js, r2));
   }
@@ -186,7 +186,7 @@ static void example_error_handling(void) {
   js_set(js, global, "add", js_mkfun(my_add));
 
   const char *type_err = "add('not', 'numbers')";
-  jsval_t r3 = js_eval(js, type_err, strlen(type_err));
+  jsval_t r3 = js_eval_bytecode_eval(js, type_err, strlen(type_err));
   if (vtype(r3) == T_ERR) {
     printf("  Type error:      %s\n", js_str(js, r3));
   }
@@ -198,11 +198,9 @@ static void example_call_js_from_c(void) {
   print_header(5, "Calling JS from C");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  jsval_t scope = js_mkscope(js);
-
   const char *code =
     "function multiply(a, b) {"
     "    return a * b;"
@@ -211,13 +209,14 @@ static void example_call_js_from_c(void) {
     "    return last + ', ' + first;"
     "}";
 
-  js_eval(js, code, strlen(code));
+  js_eval_bytecode_eval(js, code, strlen(code));
 
-  jsval_t multiply_fn = js_get(js, scope, "multiply");
-  jsval_t format_fn = js_get(js, scope, "formatName");
+  jsval_t glob = js_glob(js);
+  jsval_t multiply_fn = js_get(js, glob, "multiply");
+  jsval_t format_fn = js_get(js, glob, "formatName");
 
   jsval_t args1[] = { js_mknum(6), js_mknum(7) };
-  jsval_t result1 = js_call(js, multiply_fn, args1, 2);
+  jsval_t result1 = sv_vm_call(js->vm, js, multiply_fn, js_mkundef(), args1, 2, NULL, false);
   printf("  multiply(6, 7) = %g\n", js_getnum(result1));
 
   jsval_t args2[] = {
@@ -225,7 +224,7 @@ static void example_call_js_from_c(void) {
     js_mkstr(js, "Doe", 3)
   };
 
-  jsval_t result2 = js_call(js, format_fn, args2, 2);
+  jsval_t result2 = sv_vm_call(js->vm, js, format_fn, js_mkundef(), args2, 2, NULL, false);
   printf("  formatName('John', 'Doe') = %s\n", js_str(js, result2));
 
   js_destroy(js);
@@ -235,13 +234,11 @@ static void example_iterate_properties(void) {
   print_header(6, "Iterating Properties");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
-
   const char *code = "({ name: 'Alice', age: 30, city: 'NYC' })";
-  jsval_t obj = js_eval(js, code, strlen(code));
+  jsval_t obj = js_eval_bytecode_eval(js, code, strlen(code));
 
   ant_iter_t iter = js_prop_iter_begin(js, obj);
   const char *key;
@@ -257,7 +254,7 @@ static void example_iterate_properties(void) {
   js_destroy(js);
 }
 
-static jsval_t method_get_full_name(struct js *js, jsval_t *args, int nargs) {
+static jsval_t method_get_full_name(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 
   jsval_t this_obj = js_getthis(js);
@@ -279,10 +276,10 @@ static void example_this_context(void) {
   print_header(7, "'this' Context");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
+
 
   jsval_t person = js_mkobj(js);
   js_set(js, person, "firstName", js_mkstr(js, "Jane", 4));
@@ -292,7 +289,7 @@ static void example_this_context(void) {
   js_set(js, js_glob(js), "person", person);
 
   const char *code = "person.getFullName()";
-  jsval_t result = js_eval(js, code, strlen(code));
+  jsval_t result = js_eval_bytecode_eval(js, code, strlen(code));
   printf("  person.getFullName() = %s\n", js_str(js, result));
 
   js_destroy(js);
@@ -302,10 +299,10 @@ static void example_stateful_session(void) {
   print_header(8, "Stateful Session");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
-  js_mkscope(js);
+
 
   const char *scripts[] = {
     "let counter = 0;",
@@ -317,7 +314,7 @@ static void example_stateful_session(void) {
 
   jsval_t result = js_mkundef();
   for (int i = 0; i < 5; i++) {
-    result = js_eval(js, scripts[i], strlen(scripts[i]));
+    result = js_eval_bytecode_eval(js, scripts[i], strlen(scripts[i]));
     if (vtype(result) == T_ERR) {
       printf("  Error in script %d: %s\n", i, js_str(js, result));
       break;
@@ -333,15 +330,13 @@ static void example_async_event_loop(void) {
   print_header(9, "Async & Event Loop");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   init_symbol_module();
   init_builtin_module();
   init_timer_module();
 
-  jsval_t scope = js_mkscope(js);
-
   const char *code =
     "let results = [];"
     ""
@@ -363,7 +358,7 @@ static void example_async_event_loop(void) {
     ""
     "results.push('sync');";
 
-  jsval_t result = js_eval(js, code, strlen(code));
+  jsval_t result = js_eval_bytecode_eval(js, code, strlen(code));
   if (vtype(result) == T_ERR) {
     printf("  Error: %s\n", js_str(js, result));
     js_destroy(js);
@@ -372,7 +367,7 @@ static void example_async_event_loop(void) {
 
   js_run_event_loop(js);
 
-  jsval_t results = js_get(js, scope, "results");
+  jsval_t results = js_get(js, js_glob(js), "results");
 
   printf("  Execution order:\n");
   jsoff_t len = js_arr_len(js, results);
@@ -388,11 +383,11 @@ static void example_console_logging(void) {
   print_header(10, "Console Logging");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   init_console_module();
-  js_mkscope(js);
+
 
   const char *code =
     "console.log('Hello from JavaScript!');"
@@ -403,7 +398,7 @@ static void example_console_logging(void) {
     "console.error('This is an error');"
     "'done'";
 
-  jsval_t result = js_eval(js, code, strlen(code));
+  jsval_t result = js_eval_bytecode_eval(js, code, strlen(code));
   if (vtype(result) == T_ERR) {
     printf("  Error: %s\n", js_str(js, result));
   }
@@ -415,11 +410,11 @@ static void example_global_this(void) {
   print_header(11, "GlobalThis");
 
   volatile char stack_base;
-  struct js *js = create_js_runtime((void *)&stack_base);
+  ant_t *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   init_console_module();
-  js_mkscope(js);
+
 
   jsval_t global = js_glob(js);
   js_set(js, global, "myNumber", js_mknum(42));
@@ -448,7 +443,7 @@ static void example_global_this(void) {
     "console.log('  addedFromJS:', addedFromJS);"
     "console.log(this)";
 
-  jsval_t result = js_eval(js, code, strlen(code));
+  jsval_t result = js_eval_bytecode_eval(js, code, strlen(code));
   if (vtype(result) == T_ERR) {
     printf("  Error: %s\n", js_str(js, result));
   }
diff --git a/examples/jit/bailout.js b/examples/jit/bailout.js
new file mode 100644
index 0000000..840364b
--- /dev/null
+++ b/examples/jit/bailout.js
@@ -0,0 +1,21 @@
+function add(a, b) {
+  return a + b;
+}
+
+let numSum = 0;
+for (let i = 0; i < 110; i++) {
+  numSum = add(numSum, i);
+}
+console.log('numeric sum (JIT):', numSum);
+
+let s = add('hello', ' world');
+console.log('string concat (deopt):', s);
+console.log('bailout correct:', s === 'hello world');
+
+let n = add(10, 32);
+console.log('post-deopt numeric:', n);
+console.log('post-deopt correct:', n === 42);
+
+console.log('mixed types:', add(1, 'px'));
+console.log('mixed types:', add('$', 99));
+console.log('all ok:', true);
diff --git a/examples/jit/closures.js b/examples/jit/closures.js
new file mode 100644
index 0000000..c2e65d8
--- /dev/null
+++ b/examples/jit/closures.js
@@ -0,0 +1,86 @@
+function test1() {
+  function inner() {
+    return 42;
+  }
+  return inner();
+}
+for (let i = 0; i < 110; i++) test1();
+console.log('[test1] simple inner fn:', test1(), 'ok:', test1() === 42);
+
+function test2(x) {
+  function inner() {
+    return x;
+  }
+  return inner();
+}
+for (let i = 0; i < 110; i++) test2(i);
+console.log('[test2] capture param:', test2(99), 'ok:', test2(99) === 99);
+
+function test3() {
+  let val = 100;
+  function inner() {
+    return val;
+  }
+  return inner();
+}
+for (let i = 0; i < 110; i++) test3();
+console.log('[test3] capture local:', test3(), 'ok:', test3() === 100);
+
+function test4() {
+  let count = 0;
+  function inc() {
+    count = count + 1;
+  }
+  inc();
+  inc();
+  inc();
+  return count;
+}
+for (let i = 0; i < 110; i++) test4();
+console.log('[test4] mutate upval:', test4(), 'ok:', test4() === 3);
+
+function test5() {
+  let n = 0;
+  function next() {
+    n = n + 1;
+    return n;
+  }
+  next();
+  next();
+  return next();
+}
+for (let i = 0; i < 110; i++) test5();
+console.log('[test5] counter:', test5(), 'ok:', test5() === 3);
+
+function test6() {
+  let x = 10;
+  return function () {
+    return x;
+  };
+}
+let fn6 = test6();
+console.log('[test6] returned closure:', fn6(), 'ok:', fn6() === 10);
+
+function test7() {
+  let fns = [];
+  for (let i = 0; i < 5; i++) {
+    fns.push(function () {
+      return i;
+    });
+  }
+  return fns[0]() + fns[1]() + fns[2]() + fns[3]() + fns[4]();
+}
+console.log('[test7] loop closures:', test7(), 'ok:', test7() === 10);
+
+function test8(n) {
+  let sum = 0;
+  function addTo(x) {
+    sum = sum + x;
+  }
+  for (let i = 0; i < n; i++) addTo(i);
+  return sum;
+}
+for (let i = 0; i < 110; i++) test8(10);
+let r8 = test8(1000);
+let e8 = (999 * 1000) / 2;
+console.log('[test8] hot closure call:', r8, 'ok:', r8 === e8);
diff --git a/examples/jit/exceptions.js b/examples/jit/exceptions.js
new file mode 100644
index 0000000..8fd2e96
--- /dev/null
+++ b/examples/jit/exceptions.js
@@ -0,0 +1,238 @@
+function test1() {
+  try {
+    throw 'error';
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test1();
+console.log('[test1] throw string:', test1(), 'ok:', test1() === 'error');
+
+function test2() {
+  try {
+    return 42;
+  } catch (e) {
+    return -1;
+  }
+}
+for (let i = 0; i < 110; i++) test2();
+console.log('[test2] no throw:', test2(), 'ok:', test2() === 42);
+
+function test3() {
+  try {
+    throw 99;
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test3();
+console.log('[test3] throw number:', test3(), 'ok:', test3() === 99);
+
+function thrower() {
+  throw 'boom';
+}
+function test4() {
+  try {
+    return thrower();
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test4();
+console.log('[test4] catch from call:', test4(), 'ok:', test4() === 'boom');
+
+function test5() {
+  let result = 0;
+  try {
+    throw 'err';
+  } catch (e) {
+    result = 10;
+  }
+  return result + 5;
+}
+for (let i = 0; i < 110; i++) test5();
+console.log('[test5] code after catch:', test5(), 'ok:', test5() === 15);
+
+function test6() {
+  try {
+    try {
+      throw 'inner';
+    } catch (e) {
+      return 'caught: ' + e;
+    }
+  } catch (e) {
+    return 'outer: ' + e;
+  }
+}
+for (let i = 0; i < 110; i++) test6();
+console.log('[test6] nested catch:', test6(), 'ok:', test6() === 'caught: inner');
+
+function test7() {
+  try {
+    try {
+      throw 'propagate';
+    } catch (e) {
+      throw 're: ' + e;
+    }
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test7();
+console.log('[test7] re-throw:', test7(), 'ok:', test7() === 're: propagate');
+
+function test8(x) {
+  try {
+    let a = x + 1;
+    let b = a * 2;
+    return b;
+  } catch (e) {
+    return -1;
+  }
+}
+for (let i = 0; i < 110; i++) test8(i);
+console.log('[test8] complex try body:', test8(5), 'ok:', test8(5) === 12);
+
+function test9() {
+  try {
+    throw 10;
+  } catch (e) {
+    return e + 32;
+  }
+}
+for (let i = 0; i < 110; i++) test9();
+console.log('[test9] catch computation:', test9(), 'ok:', test9() === 42);
+
+function test10(doThrow) {
+  try {
+    if (doThrow) throw 'thrown';
+    return 'ok';
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test10(i % 2 === 0);
+console.log('[test10a] throw path:', test10(true), 'ok:', test10(true) === 'thrown');
+console.log('[test10b] no-throw path:', test10(false), 'ok:', test10(false) === 'ok');
+
+function test11() {
+  try {
+    throw true;
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test11();
+console.log('[test11] throw bool:', test11(), 'ok:', test11() === true);
+
+function safe() {
+  return 1;
+}
+function unsafe() {
+  throw 'fail';
+}
+function test12() {
+  try {
+    let a = safe();
+    let b = safe();
+    let c = unsafe();
+    return a + b + c;
+  } catch (e) {
+    return e;
+  }
+}
+for (let i = 0; i < 110; i++) test12();
+console.log('[test12] multi-call catch:', test12(), 'ok:', test12() === 'fail');
+
+function test13() {
+  try {
+    let x = undefined;
+    x.foo;
+  } catch (e) {
+    return 'caught';
+  }
+  return 'missed';
+}
+for (let i = 0; i < 110; i++) test13();
+console.log('[test13] throw_error:', test13(), 'ok:', test13() === 'caught');
+
+function test14() {
+  let obj = {
+    greet() {
+      return 'hello';
+    }
+  };
+  return obj.greet();
+}
+for (let i = 0; i < 110; i++) test14();
+console.log('[test14] get_field2:', test14(), 'ok:', test14() === 'hello');
+
+function test15() {
+  let obj = {
+    say() {
+      return 'hi';
+    }
+  };
+  let key = 'say';
+  return obj[key]();
+}
+for (let i = 0; i < 110; i++) test15();
+console.log('[test15] get_elem2:', test15(), 'ok:', test15() === 'hi');
+
+function test16() {
+  let base = { x: 10 };
+  let child = { __proto__: base, y: 20 };
+  return child.x + child.y;
+}
+for (let i = 0; i < 110; i++) test16();
+console.log('[test16] set_proto:', test16(), 'ok:', test16() === 30);
+
+function test17() {
+  try {
+    let x = null;
+    return x.foo;
+  } catch (e) {
+    return 'caught';
+  }
+}
+for (let i = 0; i < 110; i++) test17();
+console.log('[test17] get_field err:', test17(), 'ok:', test17() === 'caught');
+
+function test18() {
+  try {
+    let x = undefined;
+    return x[0];
+  } catch (e) {
+    return 'caught';
+  }
+}
+for (let i = 0; i < 110; i++) test18();
+console.log('[test18] get_elem err:', test18(), 'ok:', test18() === 'caught');
+
+function test19() {
+  let arr = [1, 2, 3];
+  return arr['join']('-');
+}
+for (let i = 0; i < 110; i++) test19();
+console.log('[test19] elem2 arr:', test19(), 'ok:', test19() === '1-2-3');
+
+function test20() {
+  let obj = {
+    val: 0,
+    add(n) {
+      return {
+        val: this.val + n,
+        add: this.add,
+        get() {
+          return this.val;
+        }
+      };
+    },
+    get() {
+      return this.val;
+    }
+  };
+  return obj.add(1).add(2).get();
+}
+for (let i = 0; i < 110; i++) test20();
+console.log('[test20] chain calls:', test20(), 'ok:', test20() === 3);
diff --git a/examples/jit/generate_jit.js b/examples/jit/generate_jit.js
new file mode 100644
index 0000000..30dcf09
--- /dev/null
+++ b/examples/jit/generate_jit.js
@@ -0,0 +1,782 @@
+let pass = 0,
+  fail = 0;
+function check(name, got, expected) {
+  if (got === expected) {
+    pass++;
+    console.log('PASS', name, 'got:', got, 'expected:', expected);
+  } else {
+    fail++;
+    console.log('FAIL', name, 'got:', got, 'expected:', expected);
+  }
+}
+
+function warm(fn) {
+  for (let i = 0; i < 110; i++) fn();
+}
+function warm1(fn) {
+  for (let i = 0; i < 110; i++) fn(i);
+}
+function warm2(fn) {
+  for (let i = 0; i < 110; i++) fn(i, i + 1);
+}
+
+function testConstI8() {
+  return 7;
+}
+warm(testConstI8);
+check('CONST_I8', testConstI8(), 7);
+
+function testConst() {
+  return 123456789;
+}
+warm(testConst);
+check('CONST', testConst(), 123456789);
+
+function testConst8() {
+  return 3.14;
+}
+warm(testConst8);
+check('CONST8', testConst8(), 3.14);
+
+function testUndef() {
+  return undefined;
+}
+warm(testUndef);
+check('UNDEF', testUndef(), undefined);
+
+function testNull() {
+  return null;
+}
+warm(testNull);
+check('NULL', testNull(), null);
+
+function testTrue() {
+  return true;
+}
+function testFalse() {
+  return false;
+}
+warm(testTrue);
+warm(testFalse);
+check('TRUE', testTrue(), true);
+check('FALSE', testFalse(), false);
+
+function testThis() {
+  return this;
+}
+warm(testThis);
+check('THIS', testThis() === undefined || typeof testThis() === 'object', true);
+
+function testPop() {
+  let x = 1;
+  2;
+  return x;
+}
+warm(testPop);
+check('POP', testPop(), 1);
+
+function testDup() {
+  let x;
+  return (x = 42);
+}
+warm(testDup);
+check('DUP', testDup(), 42);
+
+function testDup2() {
+  let a = 1,
+    b = 2;
+  return a + b + a + b;
+}
+warm(testDup2);
+check('DUP2', testDup2(), 6);
+
+function testSwap(a, b) {
+  return [b, a];
+}
+warm2(testSwap);
+let sw = testSwap(1, 2);
+check('SWAP', sw[0] === 2 && sw[1] === 1, true);
+
+function testRot3l() {
+  let o = {};
+  o.x = 5;
+  return o.x;
+}
+warm(testRot3l);
+check('ROT3L', testRot3l(), 5);
+
+function testInsert2() {
+  let o = { x: 10 };
+  o.x += 5;
+  return o.x;
+}
+warm(testInsert2);
+check('INSERT2', testInsert2(), 15);
+
+function testInsert3() {
+  let o = { x: 10 };
+  let k = 'x';
+  o[k] += 3;
+  return o[k];
+}
+warm(testInsert3);
+check('INSERT3', testInsert3(), 13);
+
+function testGetArg(a, b, c) {
+  return a + b + c;
+}
+warm(function () {
+  testGetArg(1, 2, 3);
+});
+check('GET_ARG', testGetArg(10, 20, 30), 60);
+
+function testSetArg(a) {
+  a = 99;
+  return a;
+}
+warm1(testSetArg);
+check('SET_ARG', testSetArg(0), 99);
+
+function testLocals() {
+  let x = 10;
+  let y = x + 5;
+  x = y * 2;
+  return x;
+}
+warm(testLocals);
+check('GET/PUT/SET_LOCAL', testLocals(), 30);
+
+function testLocal8() {
+  let a = 1;
+  return a;
+}
+warm(testLocal8);
+check('LOCAL8', testLocal8(), 1);
+
+function testSetLocalUndef() {
+  let x = 42;
+  return x;
+}
+warm(testSetLocalUndef);
+check('SET_LOCAL_UNDEF', testSetLocalUndef(), 42);
+
+function testIncLocal() {
+  let x = 0;
+  x++;
+  x++;
+  x++;
+  return x;
+}
+warm(testIncLocal);
+check('INC_LOCAL', testIncLocal(), 3);
+
+function testDecLocal() {
+  let x = 10;
+  x--;
+  x--;
+  return x;
+}
+warm(testDecLocal);
+check('DEC_LOCAL', testDecLocal(), 8);
+
+function testAddLocal() {
+  let x = 0;
+  x += 10;
+  x += 32;
+  return x;
+}
+warm(testAddLocal);
+check('ADD_LOCAL', testAddLocal(), 42);
+
+function testGetUpval() {
+  let v = 77;
+  function inner() {
+    return v;
+  }
+  return inner();
+}
+warm(testGetUpval);
+check('GET_UPVAL', testGetUpval(), 77);
+
+function testPutUpval() {
+  let v = 0;
+  function inc() {
+    v = v + 1;
+  }
+  inc();
+  inc();
+  return v;
+}
+warm(testPutUpval);
+check('PUT_UPVAL', testPutUpval(), 2);
+
+function testSetUpval() {
+  let v = 0;
+  function set() {
+    return (v = 42);
+  }
+  return set();
+}
+warm(testSetUpval);
+check('SET_UPVAL', testSetUpval(), 42);
+
+function testClosure() {
+  function inner(x) {
+    return x + 1;
+  }
+  return inner(41);
+}
+warm(testClosure);
+check('CLOSURE', testClosure(), 42);
+
+function testCloseUpval() {
+  let fns = [];
+  for (let i = 0; i < 3; i++) {
+    fns.push(function () {
+      return i;
+    });
+  }
+  return fns[0]() + fns[1]() + fns[2]();
+}
+check('CLOSE_UPVAL', testCloseUpval(), 3);
+
+function testSetName() {
+  let fn = function myName() {
+    return 1;
+  };
+  return fn.name;
+}
+warm(testSetName);
+check('SET_NAME', testSetName(), 'myName');
+
+function testGetGlobal() {
+  return Math;
+}
+warm(testGetGlobal);
+check('GET_GLOBAL', typeof testGetGlobal(), 'object');
+
+function testGetGlobalUndef() {
+  return typeof nonExistentVar123;
+}
+warm(testGetGlobalUndef);
+check('GET_GLOBAL_UNDEF', testGetGlobalUndef(), 'undefined');
+
+var gval = 0;
+function testPutGlobal() {
+  gval = 42;
+  return gval;
+}
+warm(testPutGlobal);
+check('PUT_GLOBAL', testPutGlobal(), 42);
+
+function testAdd(a, b) {
+  return a + b;
+}
+warm2(testAdd);
+check('ADD', testAdd(20, 22), 42);
+check('ADD str', testAdd('a', 'b'), 'ab');
+
+function testSub(a, b) {
+  return a - b;
+}
+warm2(testSub);
+check('SUB', testSub(50, 8), 42);
+
+function testMul(a, b) {
+  return a * b;
+}
+warm2(testMul);
+check('MUL', testMul(6, 7), 42);
+
+function testDiv(a, b) {
+  return a / b;
+}
+warm2(testDiv);
+check('DIV', testDiv(84, 2), 42);
+
+function testMod(a, b) {
+  return a % b;
+}
+warm2(testMod);
+check('MOD', testMod(47, 5), 2);
+
+function testNeg(a) {
+  return -a;
+}
+warm1(testNeg);
+check('NEG', testNeg(42), -42);
+check('NEG zero', testNeg(0), -0);
+
+function testLt(a, b) {
+  return a < b;
+}
+warm2(testLt);
+check('LT true', testLt(1, 2), true);
+check('LT false', testLt(2, 1), false);
+check('LT eq', testLt(1, 1), false);
+
+function testLe(a, b) {
+  return a <= b;
+}
+warm2(testLe);
+check('LE true', testLe(1, 1), true);
+check('LE false', testLe(2, 1), false);
+
+function testGt(a, b) {
+  return a > b;
+}
+warm2(testGt);
+check('GT true', testGt(2, 1), true);
+check('GT false', testGt(1, 2), false);
+
+function testGe(a, b) {
+  return a >= b;
+}
+warm2(testGe);
+check('GE true', testGe(1, 1), true);
+check('GE false', testGe(0, 1), false);
+
+function testEq(a, b) {
+  return a == b;
+}
+warm2(testEq);
+check('EQ', testEq(1, 1), true);
+check('EQ coerce', testEq(1, '1'), true);
+check('EQ null/undef', testEq(null, undefined), true);
+
+function testNe(a, b) {
+  return a != b;
+}
+warm2(testNe);
+check('NE', testNe(1, 2), true);
+check('NE false', testNe(1, 1), false);
+
+function testSeq(a, b) {
+  return a === b;
+}
+warm2(testSeq);
+check('SEQ true', testSeq(42, 42), true);
+check('SEQ false', testSeq(1, '1'), false);
+
+function testSne(a, b) {
+  return a !== b;
+}
+warm2(testSne);
+check('SNE true', testSne(1, '1'), true);
+check('SNE false', testSne(1, 1), false);
+
+function testIsUndef(v) {
+  return v === undefined;
+}
+warm1(testIsUndef);
+check('IS_UNDEF true', testIsUndef(undefined), true);
+check('IS_UNDEF false', testIsUndef(0), false);
+
+function testIsNull(v) {
+  return v === null;
+}
+warm1(testIsNull);
+check('IS_NULL true', testIsNull(null), true);
+check('IS_NULL false', testIsNull(0), false);
+
+function Ctor() {}
+function testInstanceof(v) {
+  return v instanceof Ctor;
+}
+warm(function () {
+  testInstanceof(new Ctor());
+});
+check('INSTANCEOF true', testInstanceof(new Ctor()), true);
+check('INSTANCEOF false', testInstanceof({}), false);
+
+function testIn(k, o) {
+  return k in o;
+}
+warm(function () {
+  testIn('x', { x: 1 });
+});
+check('IN true', testIn('x', { x: 1 }), true);
+check('IN false', testIn('y', { x: 1 }), false);
+
+function testBand(a, b) {
+  return a & b;
+}
+warm2(testBand);
+check('BAND', testBand(0xff, 0x0f), 15);
+
+function testBor(a, b) {
+  return a | b;
+}
+warm2(testBor);
+check('BOR', testBor(0x0f, 0xf0), 255);
+
+function testBxor(a, b) {
+  return a ^ b;
+}
+warm2(testBxor);
+check('BXOR', testBxor(0xff, 0x0f), 240);
+
+function testBnot(a) {
+  return ~a;
+}
+warm1(testBnot);
+check('BNOT 0', testBnot(0), -1);
+check('BNOT -1', testBnot(-1), 0);
+
+function testShl(a, b) {
+  return a << b;
+}
+warm2(testShl);
+check('SHL', testShl(1, 4), 16);
+
+function testShr(a, b) {
+  return a >> b;
+}
+warm2(testShr);
+check('SHR', testShr(-16, 2), -4);
+
+function testUshr(a, b) {
+  return a >>> b;
+}
+warm2(testUshr);
+check('USHR', testUshr(-1, 28), 15);
+
+function testNot(a) {
+  return !a;
+}
+warm1(testNot);
+check('NOT 0', testNot(0), true);
+check('NOT 1', testNot(1), false);
+check('NOT null', testNot(null), true);
+check('NOT str', testNot('hi'), false);
+
+function testTypeof(a) {
+  return typeof a;
+}
+warm1(testTypeof);
+check('TYPEOF num', testTypeof(1), 'number');
+check('TYPEOF str', testTypeof('x'), 'string');
+check('TYPEOF bool', testTypeof(true), 'boolean');
+check('TYPEOF undef', testTypeof(undefined), 'undefined');
+check('TYPEOF obj', testTypeof({}), 'object');
+check(
+  'TYPEOF fn',
+  testTypeof(function () {}),
+  'function'
+);
+
+function testVoid(a) {
+  return void a;
+}
+warm1(testVoid);
+check('VOID', testVoid(42), undefined);
+
+function testDelete() {
+  let o = { x: 1, y: 2 };
+  delete o.x;
+  return o.x;
+}
+warm(testDelete);
+check('DELETE', testDelete(), undefined);
+
+function testJmp(x) {
+  if (x) return 1;
+  else return 2;
+}
+warm1(testJmp);
+check('JMP true', testJmp(true), 1);
+check('JMP false', testJmp(false), 2);
+
+function testJmpFalse(x) {
+  if (x) {
+    return 'yes';
+  }
+  return 'no';
+}
+warm1(testJmpFalse);
+check('JMP_FALSE', testJmpFalse(false), 'no');
+check('JMP_TRUE', testJmpFalse(true), 'yes');
+
+function testJmp8(x) {
+  return x ? 1 : 0;
+}
+warm1(testJmp8);
+check('JMP8', testJmp8(true), 1);
+
+function testLoop(n) {
+  let s = 0;
+  for (let i = 0; i < n; i++) s += i;
+  return s;
+}
+warm1(testLoop);
+check('LOOP', testLoop(10), 45);
+
+function helper(x) {
+  return x * 2;
+}
+function testCall(x) {
+  return helper(x);
+}
+warm1(testCall);
+check('CALL', testCall(21), 42);
+
+function testCallMethod() {
+  let o = {
+    f(x) {
+      return x + 1;
+    }
+  };
+  return o.f(41);
+}
+warm(testCallMethod);
+check('CALL_METHOD', testCallMethod(), 42);
+
+function tailHelper(n, acc) {
+  if (n <= 0) return acc;
+  return tailHelper(n - 1, acc + n);
+}
+function testTailCall(n) {
+  return tailHelper(n, 0);
+}
+warm(function () {
+  testTailCall(10);
+});
+check('TAIL_CALL', testTailCall(100), 5050);
+
+function testTailCallMethod() {
+  let o = {
+    count(n, acc) {
+      if (n <= 0) return acc;
+      return this.count(n - 1, acc + n);
+    }
+  };
+  return o.count(10, 0);
+}
+warm(testTailCallMethod);
+check('TAIL_CALL_METHOD', testTailCallMethod(), 55);
+
+function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+function testNew() {
+  let p = new Point(3, 4);
+  return p.x + p.y;
+}
+warm(testNew);
+check('NEW', testNew(), 7);
+
+function testReturn() {
+  return 42;
+}
+warm(testReturn);
+check('RETURN', testReturn(), 42);
+
+function testReturnUndef() {
+  let x = 1;
+}
+warm(testReturnUndef);
+check('RETURN_UNDEF', testReturnUndef(), undefined);
+
+function testField() {
+  let o = {};
+  o.x = 42;
+  return o.x;
+}
+warm(testField);
+check('GET/PUT_FIELD', testField(), 42);
+
+function testGetField2() {
+  let o = {
+    m() {
+      return 42;
+    }
+  };
+  return o.m();
+}
+warm(testGetField2);
+check('GET_FIELD2', testGetField2(), 42);
+
+function testElem() {
+  let a = [0];
+  a[0] = 42;
+  return a[0];
+}
+warm(testElem);
+check('GET/PUT_ELEM', testElem(), 42);
+
+function testGetElem2() {
+  let o = {
+    f() {
+      return 42;
+    }
+  };
+  return o['f']();
+}
+warm(testGetElem2);
+check('GET_ELEM2', testGetElem2(), 42);
+
+function testDefineField() {
+  let o = { x: 42 };
+  return o.x;
+}
+warm(testDefineField);
+check('DEFINE_FIELD', testDefineField(), 42);
+
+function testGetLength() {
+  return [1, 2, 3].length;
+}
+warm(testGetLength);
+check('GET_LENGTH', testGetLength(), 3);
+
+function testObject() {
+  let o = {};
+  return typeof o;
+}
+warm(testObject);
+check('OBJECT', testObject(), 'object');
+
+function testArray() {
+  let a = [1, 2, 3];
+  return a[0] + a[1] + a[2];
+}
+warm(testArray);
+check('ARRAY', testArray(), 6);
+
+function testSetProto() {
+  let p = { x: 10 };
+  let c = { __proto__: p, y: 20 };
+  return c.x + c.y;
+}
+warm(testSetProto);
+check('SET_PROTO', testSetProto(), 30);
+
+function testToPropkey() {
+  let o = {};
+  let k = 42;
+  o[k] = 'v';
+  return o['42'];
+}
+warm(testToPropkey);
+check('TO_PROPKEY', testToPropkey(), 'v');
+
+function testTryCatch() {
+  try {
+    throw 'err';
+  } catch (e) {
+    return e;
+  }
+}
+warm(testTryCatch);
+check('TRY/CATCH', testTryCatch(), 'err');
+
+function testTryNoThrow() {
+  try {
+    return 42;
+  } catch (e) {
+    return -1;
+  }
+}
+warm(testTryNoThrow);
+check('TRY no throw', testTryNoThrow(), 42);
+
+function testThrowError() {
+  try {
+    let x = null;
+    x.foo;
+    return 'miss';
+  } catch (e) {
+    return 'caught';
+  }
+}
+warm(testThrowError);
+check('THROW_ERROR', testThrowError(), 'caught');
+
+function testNestedTry() {
+  try {
+    try {
+      throw 'inner';
+    } catch (e) {
+      return 'got: ' + e;
+    }
+  } catch (e) {
+    return 'outer';
+  }
+}
+warm(testNestedTry);
+check('NESTED TRY', testNestedTry(), 'got: inner');
+
+function testRethrow() {
+  try {
+    try {
+      throw 'a';
+    } catch (e) {
+      throw 'b' + e;
+    }
+  } catch (e) {
+    return e;
+  }
+}
+warm(testRethrow);
+check('RETHROW', testRethrow(), 'ba');
+
+function tfbNumAdd(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 200; i++) tfbNumAdd(i, i);
+check('TFB num_only ADD', tfbNumAdd(20, 22), 42);
+
+function tfbBailout(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 200; i++) tfbBailout(i, i);
+check('TFB bailout', tfbBailout('x', 'y'), 'xy');
+check('TFB post-bailout', tfbBailout(1, 2), 3);
+
+function tfbStrAdd(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 200; i++) tfbStrAdd('a', 'b');
+check('TFB never_num ADD', tfbStrAdd('hello', ' world'), 'hello world');
+
+function tfbStrLt(a, b) {
+  return a < b;
+}
+for (let i = 0; i < 200; i++) tfbStrLt('a', 'b');
+check('TFB never_num LT', tfbStrLt('a', 'b'), true);
+check('TFB never_num LT 2', tfbStrLt('b', 'a'), false);
+
+function tfbMixed(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 100; i++) tfbMixed(i, i);
+for (let i = 0; i < 100; i++) tfbMixed('a', 'b');
+check('TFB mixed num', tfbMixed(1, 2), 3);
+check('TFB mixed str', tfbMixed('x', 'y'), 'xy');
+
+function tfbLoop(n) {
+  let s = 0;
+  for (let i = 0; i < n; i++) s = s + i;
+  return s;
+}
+for (let i = 0; i < 200; i++) tfbLoop(10);
+check('TFB loop', tfbLoop(1000), 499500);
+
+function tfbCmpLoop(n) {
+  let c = 0;
+  for (let i = 0; i < n; i++) {
+    if (i > 50) c++;
+  }
+  return c;
+}
+for (let i = 0; i < 200; i++) tfbCmpLoop(100);
+check('TFB cmp loop', tfbCmpLoop(100), 49);
+
+function testSpecialObj() {
+  return new.target;
+}
+warm(testSpecialObj);
+check('SPECIAL_OBJ', testSpecialObj(), undefined);
+
+console.log('passed:', pass, 'failed:', fail, 'total:', pass + fail);
+console.log('all tests passed:', fail === 0);
diff --git a/examples/jit/objects.js b/examples/jit/objects.js
new file mode 100644
index 0000000..c8b300e
--- /dev/null
+++ b/examples/jit/objects.js
@@ -0,0 +1,92 @@
+function test1() {
+  let obj = {};
+  obj.x = 10;
+  obj.y = 20;
+  return obj.x + obj.y;
+}
+for (let i = 0; i < 110; i++) test1();
+console.log('[test1] object put/get field:', test1(), 'ok:', test1() === 30);
+
+function test2() {
+  let obj = {};
+  let key = 'hello';
+  obj[key] = 42;
+  return obj[key];
+}
+for (let i = 0; i < 110; i++) test2();
+console.log('[test2] computed prop access:', test2(), 'ok:', test2() === 42);
+
+function test3(a, b, c) {
+  let arr = [a, b, c];
+  return arr[0] + arr[1] + arr[2];
+}
+for (let i = 0; i < 110; i++) test3(1, 2, 3);
+console.log('[test3] array literal:', test3(10, 20, 30), 'ok:', test3(10, 20, 30) === 60);
+
+var globalVal = 0;
+function test4(n) {
+  globalVal = n;
+  return globalVal;
+}
+for (let i = 0; i < 110; i++) test4(i);
+console.log('[test4] put global:', test4(99), 'ok:', test4(99) === 99);
+
+function test5(n) {
+  let obj = {};
+  for (let i = 0; i < n; i++) {
+    obj['k' + i] = i;
+  }
+  return obj.k0 + obj.k1 + obj.k2;
+}
+for (let i = 0; i < 110; i++) test5(5);
+console.log('[test5] loop object build:', test5(5), 'ok:', test5(5) === 3);
+
+function test6(n) {
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    let pair = [i, i + 1];
+    sum = sum + pair[0] + pair[1];
+  }
+  return sum;
+}
+for (let i = 0; i < 110; i++) test6(10);
+let r6 = test6(100);
+console.log('[test6] array in loop:', r6, 'ok:', r6 === 10000);
+
+function test7() {
+  let arr = [0, 0, 0];
+  arr[0] = 10;
+  arr[1] = 20;
+  arr[2] = 30;
+  return arr[0] + arr[1] + arr[2];
+}
+for (let i = 0; i < 110; i++) test7();
+console.log('[test7] put_elem numeric:', test7(), 'ok:', test7() === 60);
+
+function test8() {
+  let arr = [];
+  return arr.length;
+}
+for (let i = 0; i < 110; i++) test8();
+console.log('[test8] empty array:', test8(), 'ok:', test8() === 0);
+
+function test9() {
+  let outer = {};
+  outer.inner = {};
+  outer.inner.val = 42;
+  return outer.inner.val;
+}
+for (let i = 0; i < 110; i++) test9();
+console.log('[test9] nested objects:', test9(), 'ok:', test9() === 42);
+
+function reader(obj) {
+  return obj.a + obj.b;
+}
+function test10() {
+  let o = {};
+  o.a = 3;
+  o.b = 7;
+  return reader(o);
+}
+for (let i = 0; i < 110; i++) test10();
+console.log('[test10] obj as arg:', test10(), 'ok:', test10() === 10);
diff --git a/examples/jit/ops.js b/examples/jit/ops.js
new file mode 100644
index 0000000..307ce7d
--- /dev/null
+++ b/examples/jit/ops.js
@@ -0,0 +1,172 @@
+function testBand(a, b) {
+  return a & b;
+}
+for (let i = 0; i < 110; i++) testBand(i, 0xff);
+console.log('[BAND]', testBand(0xff, 0x0f), 'ok:', testBand(0xff, 0x0f) === 15);
+
+function testBor(a, b) {
+  return a | b;
+}
+for (let i = 0; i < 110; i++) testBor(i, 0);
+console.log('[BOR]', testBor(0x0f, 0xf0), 'ok:', testBor(0x0f, 0xf0) === 255);
+
+function testBxor(a, b) {
+  return a ^ b;
+}
+for (let i = 0; i < 110; i++) testBxor(i, i);
+console.log('[BXOR]', testBxor(0xff, 0x0f), 'ok:', testBxor(0xff, 0x0f) === 240);
+
+function testBnot(a) {
+  return ~a;
+}
+for (let i = 0; i < 110; i++) testBnot(i);
+console.log('[BNOT]', testBnot(0), 'ok:', testBnot(0) === -1);
+console.log('[BNOT]', testBnot(-1), 'ok:', testBnot(-1) === 0);
+
+function testShl(a, b) {
+  return a << b;
+}
+for (let i = 0; i < 110; i++) testShl(1, i % 31);
+console.log('[SHL]', testShl(1, 4), 'ok:', testShl(1, 4) === 16);
+
+function testShr(a, b) {
+  return a >> b;
+}
+for (let i = 0; i < 110; i++) testShr(256, i % 8);
+console.log('[SHR]', testShr(-16, 2), 'ok:', testShr(-16, 2) === -4);
+
+function testUshr(a, b) {
+  return a >>> b;
+}
+for (let i = 0; i < 110; i++) testUshr(256, i % 8);
+console.log('[USHR]', testUshr(-1, 28), 'ok:', testUshr(-1, 28) === 15);
+
+function testBandBailout(a, b) {
+  return a & b;
+}
+for (let i = 0; i < 110; i++) testBandBailout(i, 0xff);
+let bbr = testBandBailout('3', 0xff);
+console.log('[BAND bailout]', bbr, 'ok:', bbr === 3);
+
+function testNot(a) {
+  return !a;
+}
+for (let i = 0; i < 110; i++) testNot(i);
+console.log('[NOT] !0:', testNot(0), 'ok:', testNot(0) === true);
+console.log('[NOT] !1:', testNot(1), 'ok:', testNot(1) === false);
+console.log('[NOT] !null:', testNot(null), 'ok:', testNot(null) === true);
+console.log("[NOT] !'':", testNot(''), 'ok:', testNot('') === true);
+console.log("[NOT] !'hi':", testNot('hi'), 'ok:', testNot('hi') === false);
+
+function testTypeof(a) {
+  return typeof a;
+}
+for (let i = 0; i < 110; i++) testTypeof(i);
+console.log('[TYPEOF] number:', testTypeof(42), 'ok:', testTypeof(42) === 'number');
+console.log('[TYPEOF] string:', testTypeof('hi'), 'ok:', testTypeof('hi') === 'string');
+console.log('[TYPEOF] boolean:', testTypeof(true), 'ok:', testTypeof(true) === 'boolean');
+console.log('[TYPEOF] undefined:', testTypeof(undefined), 'ok:', testTypeof(undefined) === 'undefined');
+
+function testGt(a, b) {
+  return a > b;
+}
+for (let i = 0; i < 110; i++) testGt(i, 30);
+console.log('[GT] 5>3:', testGt(5, 3), 'ok:', testGt(5, 3) === true);
+console.log('[GT] 3>5:', testGt(3, 5), 'ok:', testGt(3, 5) === false);
+console.log('[GT] 3>3:', testGt(3, 3), 'ok:', testGt(3, 3) === false);
+
+function testGe(a, b) {
+  return a >= b;
+}
+for (let i = 0; i < 110; i++) testGe(i, 30);
+console.log('[GE] 5>=3:', testGe(5, 3), 'ok:', testGe(5, 3) === true);
+console.log('[GE] 3>=5:', testGe(3, 5), 'ok:', testGe(3, 5) === false);
+console.log('[GE] 3>=3:', testGe(3, 3), 'ok:', testGe(3, 3) === true);
+
+function testNe(a, b) {
+  return a != b;
+}
+for (let i = 0; i < 110; i++) testNe(i, 30);
+console.log('[NE] 1!=2:', testNe(1, 2), 'ok:', testNe(1, 2) === true);
+console.log('[NE] 1!=1:', testNe(1, 1), 'ok:', testNe(1, 1) === false);
+console.log('[NE] null!=undefined:', testNe(null, undefined), 'ok:', testNe(null, undefined) === false);
+
+function testSne(a, b) {
+  return a !== b;
+}
+for (let i = 0; i < 110; i++) testSne(i, 30);
+console.log('[SNE] 1!==2:', testSne(1, 2), 'ok:', testSne(1, 2) === true);
+console.log('[SNE] 1!==1:', testSne(1, 1), 'ok:', testSne(1, 1) === false);
+console.log('[SNE] null!==undefined:', testSne(null, undefined), 'ok:', testSne(null, undefined) === true);
+
+function testDecLocal(n) {
+  let count = n;
+  let sum = 0;
+  while (count > 0) {
+    sum = sum + count;
+    count--;
+  }
+  return sum;
+}
+for (let i = 0; i < 110; i++) testDecLocal(10);
+let dl = testDecLocal(100);
+console.log('[DEC_LOCAL]', dl, 'ok:', dl === 5050);
+
+function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+function testNew(a, b) {
+  let p = new Point(a, b);
+  return p.x + p.y;
+}
+for (let i = 0; i < 110; i++) testNew(i, i + 1);
+console.log('[NEW]', testNew(10, 32), 'ok:', testNew(10, 32) === 42);
+
+function testNewProto() {
+  let p = new Point(3, 4);
+  return p instanceof Point;
+}
+for (let i = 0; i < 110; i++) testNewProto();
+console.log('[NEW instanceof]', testNewProto(), 'ok:', testNewProto() === true);
+
+function countdown(n) {
+  let result = 0;
+  for (let i = n; i >= 1; i--) {
+    if (i > 50) result = result + 2;
+    else result = result + 1;
+  }
+  return result;
+}
+let cd = countdown(100);
+console.log('[GT/GE loop]', cd, 'ok:', cd === 150);
+
+function bitMix(n) {
+  let acc = 0;
+  for (let i = 0; i < n; i++) {
+    acc = (acc | (i & 0xff)) ^ ((i << 1) >>> 24);
+  }
+  return acc;
+}
+let bm = bitMix(1000);
+console.log('[bitwise loop]', bm, 'ok:', typeof bm === 'number');
+
+function Animal(name) {
+  this.name = name;
+}
+function Dog(name) {
+  Animal.call(this, name);
+}
+Dog.prototype = Object.create(Animal.prototype);
+Dog.prototype.constructor = Dog;
+
+function testInstanceof(obj) {
+  return obj instanceof Animal;
+}
+for (let i = 0; i < 110; i++) testInstanceof(new Dog('d'));
+console.log('[INSTANCEOF] Dog instanceof Animal:', testInstanceof(new Dog('Rex')), 'ok:', testInstanceof(new Dog('Rex')) === true);
+console.log('[INSTANCEOF] {} instanceof Animal:', testInstanceof({}), 'ok:', testInstanceof({}) === false);
+console.log('[INSTANCEOF] 42 instanceof Animal:', testInstanceof(42), 'ok:', testInstanceof(42) === false);
+
+console.log('all ops tests done');
diff --git a/examples/jit/osr.js b/examples/jit/osr.js
new file mode 100644
index 0000000..8f46b57
--- /dev/null
+++ b/examples/jit/osr.js
@@ -0,0 +1,130 @@
+const N = 500000;
+
+function bench(name, fn) {
+  let start = Date.now();
+  let result = fn();
+  let elapsed = Date.now() - start;
+  return { name, result, elapsed };
+}
+
+let t1_start = Date.now();
+let sum = 0;
+for (let i = 0; i < N; i++) {
+  sum = sum + i;
+}
+let t1_ms = Date.now() - t1_start;
+let t1_expected = ((N - 1) * N) / 2;
+console.log(`[test1] top-level loop:       ${t1_ms}ms  sum=${sum}  ok=${sum === t1_expected}`);
+
+function computeOnce(n) {
+  let total = 0;
+  for (let j = 0; j < n; j++) {
+    total = total + j;
+  }
+  return total;
+}
+
+let t2 = bench('once-called fn', () => computeOnce(N));
+let t2_expected = ((N - 1) * N) / 2;
+console.log(`[test2] ${t2.name}:    ${t2.elapsed}ms  result=${t2.result}  ok=${t2.result === t2_expected}`);
+
+function nestedLoops(outer, inner) {
+  let acc = 0;
+  for (let a = 0; a < outer; a++) {
+    for (let b = 0; b < inner; b++) acc = acc + 1;
+  }
+  return acc;
+}
+
+let t3 = bench('nested loops', () => nestedLoops(20, N / 20));
+let t3_expected = 20 * (N / 20);
+console.log(`[test3] ${t3.name}:       ${t3.elapsed}ms  result=${t3.result}  ok=${t3.result === t3_expected}`);
+
+function add(a, b) {
+  return a + b;
+}
+
+function loopWithCall(n) {
+  let s = 0;
+  for (let k = 0; k < n; k++) {
+    s = add(s, k);
+  }
+  return s;
+}
+
+let t4 = bench('loop + JIT callee', () => loopWithCall(N));
+let t4_expected = ((N - 1) * N) / 2;
+console.log(`[test4] ${t4.name}: ${t4.elapsed}ms  result=${t4.result}  ok=${t4.result === t4_expected}`);
+
+function whileLoop(n) {
+  let count = 0;
+  let x = 0;
+  while (x < n) {
+    count = count + 1;
+    x = x + 1;
+  }
+  return count;
+}
+
+let t5 = bench('while loop', () => whileLoop(N));
+console.log(`[test5] ${t5.name}:        ${t5.elapsed}ms  result=${t5.result}  ok=${t5.result === N}`);
+
+function localPreservation(n) {
+  let a = 42;
+  let b = 99;
+  let c = 0;
+  for (let i = 0; i < n; i++) {
+    c = c + 1;
+  }
+  return a + b + c;
+}
+
+let t6 = bench('local preservation', () => localPreservation(N));
+let t6_expected = 42 + 99 + N;
+console.log(`[test6] ${t6.name}: ${t6.elapsed}ms  result=${t6.result}  ok=${t6.result === t6_expected}`);
+
+function hotAdd(a, b) {
+  return a + b;
+}
+
+for (let w = 0; w < 110; w++) hotAdd(w, w);
+let t7_call = bench('hot fn (call_count JIT)', () => {
+  let s = 0;
+  for (let i = 0; i < N; i++) s = hotAdd(s, i);
+  return s;
+});
+
+let t7_osr = bench('cold fn (OSR JIT)', () => {
+  function coldLoop(n) {
+    let s = 0;
+    for (let i = 0; i < n; i++) s = s + i;
+    return s;
+  }
+  return coldLoop(N);
+});
+
+console.log(`[test7] ${t7_call.name}:  ${t7_call.elapsed}ms`);
+console.log(`[test7] ${t7_osr.name}:         ${t7_osr.elapsed}ms`);
+console.log(`[test7] results match: ${t7_call.result === t7_osr.result}`);
+
+let allOk =
+  sum === t1_expected &&
+  t2.result === t2_expected &&
+  t3.result === t3_expected &&
+  t4.result === t4_expected &&
+  t5.result === N &&
+  t6.result === t6_expected &&
+  t7_call.result === t7_osr.result;
+
+console.log('');
+console.log('=== timing summary ===');
+console.log(`  top-level loop:       ${t1_ms}ms`);
+console.log(`  once-called fn:       ${t2.elapsed}ms`);
+console.log(`  nested loops:         ${t3.elapsed}ms`);
+console.log(`  loop + JIT callee:    ${t4.elapsed}ms`);
+console.log(`  while loop:           ${t5.elapsed}ms`);
+console.log(`  local preservation:   ${t6.elapsed}ms`);
+console.log(`  hot fn (call JIT):    ${t7_call.elapsed}ms`);
+console.log(`  cold fn (OSR JIT):    ${t7_osr.elapsed}ms`);
+console.log('');
+console.log('all OSR tests passed:', allOk);
diff --git a/examples/jit/stress.js b/examples/jit/stress.js
new file mode 100644
index 0000000..232160f
--- /dev/null
+++ b/examples/jit/stress.js
@@ -0,0 +1,42 @@
+function testA() {
+  function inner(x) {
+    return x + 1;
+  }
+  return inner(41);
+}
+for (let i = 0; i < 110; i++) testA();
+let rA = testA();
+console.log('[testA] non-inlined closure call:', rA, 'ok:', rA === 42);
+
+function testB(val) {
+  function reader() {
+    return val;
+  }
+  return reader();
+}
+for (let i = 0; i < 110; i++) testB(i);
+let rB = testB(77);
+console.log('[testB] upval read via call:', rB, 'ok:', rB === 77);
+
+function makeAdder(x) {
+  return function (y) {
+    return x + y;
+  };
+}
+for (let i = 0; i < 110; i++) makeAdder(i);
+let add5 = makeAdder(5);
+let rC = add5(10);
+console.log('[testC] returned closure:', rC, 'ok:', rC === 15);
+
+function apply(fn, x) {
+  return fn(x);
+}
+function testD(n) {
+  function double_(x) {
+    return x + x;
+  }
+  return apply(double_, n);
+}
+for (let i = 0; i < 110; i++) testD(i);
+let rD = testD(21);
+console.log('[testD] closure as argument:', rD, 'ok:', rD === 42);
diff --git a/examples/jit/type_feedback.js b/examples/jit/type_feedback.js
new file mode 100644
index 0000000..9861493
--- /dev/null
+++ b/examples/jit/type_feedback.js
@@ -0,0 +1,164 @@
+function addNums(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 200; i++) addNums(i, i + 1);
+let r1 = addNums(100, 42);
+console.log('[fb_num_only ADD]', r1, 'ok:', r1 === 142);
+
+function subNums(a, b) {
+  return a - b;
+}
+for (let i = 0; i < 200; i++) subNums(i * 2, i);
+let r2 = subNums(100, 58);
+console.log('[fb_num_only SUB]', r2, 'ok:', r2 === 42);
+
+function mulNums(a, b) {
+  return a * b;
+}
+for (let i = 0; i < 200; i++) mulNums(i, 2);
+let r3 = mulNums(21, 2);
+console.log('[fb_num_only MUL]', r3, 'ok:', r3 === 42);
+
+function divNums(a, b) {
+  return a / b;
+}
+for (let i = 0; i < 200; i++) divNums(i * 3, 3);
+let r4 = divNums(84, 2);
+console.log('[fb_num_only DIV]', r4, 'ok:', r4 === 42);
+
+function ltNums(a, b) {
+  return a < b;
+}
+for (let i = 0; i < 200; i++) ltNums(i, 100);
+console.log('[fb_num_only LT] 3<5:', ltNums(3, 5), 'ok:', ltNums(3, 5) === true);
+console.log('[fb_num_only LT] 5<3:', ltNums(5, 3), 'ok:', ltNums(5, 3) === false);
+
+function leNums(a, b) {
+  return a <= b;
+}
+for (let i = 0; i < 200; i++) leNums(i, 100);
+console.log('[fb_num_only LE] 3<=3:', leNums(3, 3), 'ok:', leNums(3, 3) === true);
+console.log('[fb_num_only LE] 4<=3:', leNums(4, 3), 'ok:', leNums(4, 3) === false);
+
+function gtNums(a, b) {
+  return a > b;
+}
+for (let i = 0; i < 200; i++) gtNums(i, 100);
+console.log('[fb_num_only GT] 5>3:', gtNums(5, 3), 'ok:', gtNums(5, 3) === true);
+console.log('[fb_num_only GT] 3>3:', gtNums(3, 3), 'ok:', gtNums(3, 3) === false);
+
+function geNums(a, b) {
+  return a >= b;
+}
+for (let i = 0; i < 200; i++) geNums(i, 100);
+console.log('[fb_num_only GE] 3>=3:', geNums(3, 3), 'ok:', geNums(3, 3) === true);
+console.log('[fb_num_only GE] 2>=3:', geNums(2, 3), 'ok:', geNums(2, 3) === false);
+
+function addStrs(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 200; i++) addStrs('x', 'y');
+let r5 = addStrs('hello', ' world');
+console.log('[fb_never_num ADD]', r5, 'ok:', r5 === 'hello world');
+
+function ltStrs(a, b) {
+  return a < b;
+}
+for (let i = 0; i < 200; i++) ltStrs('abc', 'def');
+console.log("[fb_never_num LT] 'a'<'b':", ltStrs('a', 'b'), 'ok:', ltStrs('a', 'b') === true);
+console.log("[fb_never_num LT] 'b'<'a':", ltStrs('b', 'a'), 'ok:', ltStrs('b', 'a') === false);
+console.log("[fb_never_num LT] 'z'<'a':", ltStrs('z', 'a'), 'ok:', ltStrs('z', 'a') === false);
+
+function addMixed(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 100; i++) addMixed(i, i);
+for (let i = 0; i < 100; i++) addMixed('a', 'b');
+let r6 = addMixed(20, 22);
+let r7 = addMixed('foo', 'bar');
+console.log('[mixed ADD] num:', r6, 'ok:', r6 === 42);
+console.log('[mixed ADD] str:', r7, 'ok:', r7 === 'foobar');
+
+function addTrainedNum(a, b) {
+  return a + b;
+}
+for (let i = 0; i < 200; i++) addTrainedNum(i, i);
+
+let r8 = addTrainedNum('bail', 'out');
+console.log('[fb_num_only bailout]', r8, 'ok:', r8 === 'bailout');
+
+let r9 = addTrainedNum(10, 32);
+console.log('[post-bailout num]', r9, 'ok:', r9 === 42);
+
+function numericLoop(n) {
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    sum = sum + i;
+  }
+  return sum;
+}
+for (let i = 0; i < 200; i++) numericLoop(10);
+let r10 = numericLoop(10000);
+let expected = (9999 * 10000) / 2;
+console.log('[numeric loop]', r10, 'ok:', r10 === expected);
+
+function mathChain(a, b, c) {
+  let x = a + b;
+  let y = x * c;
+  let z = y - a;
+  return z / b;
+}
+for (let i = 1; i < 200; i++) mathChain(i, i + 1, 2);
+let r11 = mathChain(10, 5, 3);
+console.log('[math chain]', r11, 'ok:', r11 === 7);
+
+function countAbove(arr, threshold) {
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] > threshold) count = count + 1;
+  }
+  return count;
+}
+let nums = [];
+for (let i = 0; i < 100; i++) nums[i] = i;
+for (let i = 0; i < 200; i++) countAbove(nums, 50);
+let r12 = countAbove(nums, 50);
+console.log('[comparison loop]', r12, 'ok:', r12 === 49);
+
+function concatLoop(prefix, n) {
+  let s = prefix;
+  for (let i = 0; i < n; i++) {
+    s = s + '.';
+  }
+  return s;
+}
+for (let i = 0; i < 200; i++) concatLoop('x', 3);
+let r13 = concatLoop('start', 5);
+console.log('[string concat loop]', r13, 'ok:', r13 === 'start.....');
+
+let allOk =
+  r1 === 142 &&
+  r2 === 42 &&
+  r3 === 42 &&
+  r4 === 42 &&
+  ltNums(3, 5) === true &&
+  ltNums(5, 3) === false &&
+  leNums(3, 3) === true &&
+  leNums(4, 3) === false &&
+  gtNums(5, 3) === true &&
+  gtNums(3, 3) === false &&
+  geNums(3, 3) === true &&
+  geNums(2, 3) === false &&
+  r5 === 'hello world' &&
+  ltStrs('a', 'b') === true &&
+  r6 === 42 &&
+  r7 === 'foobar' &&
+  r8 === 'bailout' &&
+  r9 === 42 &&
+  r10 === expected &&
+  r11 === 7 &&
+  r12 === 49 &&
+  r13 === 'start.....';
+
+console.log('');
+console.log('all type feedback tests passed:', allOk);
diff --git a/examples/npm/esbuild/ant.lockb b/examples/npm/esbuild/ant.lockb
new file mode 100644
index 0000000000000000000000000000000000000000..9cd75eb4e1d73b0d49e6e285bb4b942ff765e1b9
GIT binary patch
literal 744
zcmeZq_YPoWU|?WoU|;~z4h#$ocNrKM6c`y8b}%t8oM2*LU}3-w@)Gm%GgC53N(zdt
z^!1BU(=&@piYoQ;3UafG_413-^&txMb)gJhQ$0gHGrf}ZDu>kKq|(fs6#bOMqVmi<
z-Nd3?GZQ=pVO6iMi=tiEK+nir&lqGp)O0)sLRIMN>O)ybx*_I3z0JnJz`zP+gTe^J
z1c`xY7%tww+m(N=fn2OT57YAYdDnkT{kOLN<)W=K&0^~II{H0LJ(-`V+R<aLc9Qet
z!KvJNUMVLcuFpD`|9QnNNl!&pHjsHHFvF1O00stzB(vf~D+UGzQ6zC`C>s=SP$rmi
zeP?^k@8C((z|-F40!wH0UOKVf!}yj{SH0Q%NjEB-4_MBR36|TbmBw_sCy+hFz9IH1
zTO+g9k1W}`b(S--oV5HI7#O_3CSek~CZ*{!85kJYk)&|B<6{iZe8nb<OFA!)uB%Rx
zT~gydhvW0H8nd*0XC}rt-um&(Ib;2b#OMbb+3qT<?{}PiBmUU`oQBV)QXP8}PBR?h
zTEM`-V2)%DhzSaNP<WK2rWb+O*BKZXK;Z^TpApqsO(3yeomZty3=9nOe)aQ%^nmdH
I|Ns930Q|VX*8l(j

literal 0
HcmV?d00001

diff --git a/examples/npm/esbuild/app.jsx b/examples/npm/esbuild/app.jsx
new file mode 100644
index 0000000..807c1a1
--- /dev/null
+++ b/examples/npm/esbuild/app.jsx
@@ -0,0 +1,7 @@
+export const TestElement = (
+  <div>
+    <p>I am a paragraph.</p>
+    <p>I am a paragraph too.</p>
+    <span>I am a id: {import.meta.env.id}</span>
+  </div>
+);
diff --git a/examples/npm/esbuild/index.ts b/examples/npm/esbuild/index.ts
new file mode 100644
index 0000000..7603350
--- /dev/null
+++ b/examples/npm/esbuild/index.ts
@@ -0,0 +1,27 @@
+import { nanoid } from 'nanoid';
+import { join } from 'node:path';
+import * as esbuild from 'esbuild';
+
+const args = [`id=${nanoid()}`];
+const replacements: Record<string, string> = {};
+
+for (const arg of args) {
+  const pivot = arg.indexOf('=');
+  if (pivot === -1) continue;
+
+  const key = arg.slice(0, pivot);
+  const value = arg.slice(pivot + 1);
+
+  replacements[`import.meta.env.${key}`] = JSON.stringify(value);
+}
+
+const result = await esbuild.build({
+  entryPoints: [join(import.meta.dirname, 'app.jsx')],
+  bundle: true,
+  write: false,
+  define: replacements
+});
+
+if (result.outputFiles?.length) {
+  console.log(result.outputFiles[0].text);
+}
diff --git a/examples/npm/esbuild/package.json b/examples/npm/esbuild/package.json
new file mode 100644
index 0000000..e6d4ff5
--- /dev/null
+++ b/examples/npm/esbuild/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "esbuild",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "start": "ant index.ts"
+  },
+  "dependencies": {
+    "nanoid": "^5.1.6",
+    "esbuild": "^0.27.3"
+  },
+  "devDependencies": {}
+}
diff --git a/examples/npm/react/ant.lockb b/examples/npm/react/ant.lockb
new file mode 100644
index 0000000000000000000000000000000000000000..9164ae32ea9fdc166c82cc6f4c363d986139c900
GIT binary patch
literal 744
zcmeZq_YPoWU|?WoU|;~z4h#$ow;3216c`y8b}%t8oM2*LU}3-wic%AkOEOAI3W}}t
z^@~!|GmA@#D)sUTa<hu{@{7{-!SedL5L(yJQqM@wM6V>h$|1ElsWdYuML#96s5~=I
zH?b(!%mj})Sk>$6qG;DO&@(dEGX@zCH64$EP!;;R`cM{<ZiqQ>PqQ*GFbG3=Oi&s<
zOum)Byd|c|&Agc5{vO|nZf#dv4sl<Tt!nY8*YZE_;QuphQk1vF-EF$(HHB`z+&JfV
zSlWinEmJNrES_gC#qGXM7G#Gp)NEu56d#63mSz?V3=E=364FpMDBhq<Fy;Er_L|?p
zlcs^Ey~_ob&g#8%V!em)EvK$}v-y*5R5%~7oF5Y`w^J*P>2yyZdx(8Q>{Yf#X00Dt
zvUTe$XJk2P`7$stc!5pAB&?JS^rkZ~Ft8&@;c~~v7@qlxO%|7QULIXnog}-Y#(fUQ
z=VLWyY5UGhjB&j6<C$~D`W1=M4>q#hRaW2cIQvHYvHv*@pG~DY_9mQWIK(xNfq}ss
z$sQ0Bls*F(7#LD?6N^CXs|*YbYz&a}x#g>y07y+lwN?{Iu2<((DJ-u3|Ns9V0NLuj
AoB#j-

literal 0
HcmV?d00001

diff --git a/examples/npm/react/app.jsx b/examples/npm/react/app.jsx
new file mode 100644
index 0000000..33d76ce
--- /dev/null
+++ b/examples/npm/react/app.jsx
@@ -0,0 +1,17 @@
+import { renderToHTML } from './client';
+
+const App = () => (
+  <div id="root">
+    <h1>Hello from React!</h1>
+    <p style={{ color: 'red', fontSize: 16 }}>Styled text</p>
+    <input type="text" disabled />
+    <ul>
+      <li>No Babel</li>
+      <li>No Webpack</li>
+      <li>Just React</li>
+    </ul>
+  </div>
+);
+
+const html = renderToHTML(<App />);
+console.log(html);
diff --git a/examples/npm/react/client.js b/examples/npm/react/client.js
new file mode 100644
index 0000000..be4ab7a
--- /dev/null
+++ b/examples/npm/react/client.js
@@ -0,0 +1,124 @@
+const VOID = new Set(['br', 'hr', 'img', 'input', 'meta', 'link', 'area', 'base', 'col', 'embed', 'source', 'track', 'wbr']);
+
+const ESCAPE_MAP = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;'
+};
+
+const ATTR_MAP = {
+  className: 'class',
+  htmlFor: 'for',
+  tabIndex: 'tabindex',
+  readOnly: 'readonly',
+  maxLength: 'maxlength',
+  cellSpacing: 'cellspacing',
+  cellPadding: 'cellpadding',
+  rowSpan: 'rowspan',
+  colSpan: 'colspan',
+  encType: 'enctype',
+  contentEditable: 'contenteditable',
+  crossOrigin: 'crossorigin',
+  accessKey: 'accesskey',
+  autoComplete: 'autocomplete',
+  autoFocus: 'autofocus',
+  autoPlay: 'autoplay',
+  formAction: 'formaction',
+  noValidate: 'novalidate'
+};
+
+const UNITLESS = new Set([
+  'animationIterationCount',
+  'columns',
+  'columnCount',
+  'flex',
+  'flexGrow',
+  'flexShrink',
+  'fontWeight',
+  'gridColumn',
+  'gridRow',
+  'lineHeight',
+  'opacity',
+  'order',
+  'orphans',
+  'tabSize',
+  'widows',
+  'zIndex'
+]);
+
+function camelToKebab(str) {
+  return str.replace(/[A-Z]/g, ch => `-${ch.toLowerCase()}`);
+}
+
+function escapeHTML(str) {
+  return String(str).replace(/[&<>"']/g, ch => ESCAPE_MAP[ch]);
+}
+
+function formatValue(key, val) {
+  if (typeof val === 'number' && val !== 0 && !UNITLESS.has(key)) return `${val}px`;
+  return val;
+}
+
+function styleToString(style) {
+  return Object.entries(style)
+    .filter(([, v]) => v != null && v !== '')
+    .map(([k, v]) => `${camelToKebab(k)}:${formatValue(k, v)}`)
+    .join(';');
+}
+
+function renderAttrs(props) {
+  let result = '';
+  for (const [key, val] of Object.entries(props)) {
+    if (key === 'children' || key === 'dangerouslySetInnerHTML') continue;
+    if (key.startsWith('on') && key[2] >= 'A' && key[2] <= 'Z') continue;
+    if (val == null || val === false) continue;
+
+    if (key === 'style' && typeof val === 'object') {
+      result += ` style="${escapeHTML(styleToString(val))}"`;
+      continue;
+    }
+
+    const attr = ATTR_MAP[key] || key;
+    if (val === true) result += ` ${attr}`;
+    else result += ` ${attr}="${escapeHTML(val)}"`;
+  }
+  return result;
+}
+
+export function renderToHTML(element) {
+  if (element == null || typeof element === 'boolean') return '';
+  if (typeof element === 'string') return escapeHTML(element);
+  if (typeof element === 'number') return String(element);
+  if (Array.isArray(element)) return element.map(renderToHTML).join('');
+
+  const { type, props } = element;
+
+  if (type === Symbol.for('react.fragment') || type === undefined) {
+    return renderChildren(props?.children);
+  }
+
+  if (typeof type === 'function') {
+    if (type.prototype && type.prototype.isReactComponent) {
+      const instance = new type(props);
+      return renderToHTML(instance.render());
+    }
+    return renderToHTML(type(props));
+  }
+
+  const attrStr = renderAttrs(props || {});
+  if (VOID.has(type)) return `<${type}${attrStr}>`;
+
+  if (props?.dangerouslySetInnerHTML) {
+    return `<${type}${attrStr}>${props.dangerouslySetInnerHTML.__html}</${type}>`;
+  }
+
+  return `<${type}${attrStr}>${renderChildren(props?.children)}</${type}>`;
+}
+
+function renderChildren(children) {
+  if (children == null) return '';
+  if (Array.isArray(children)) return children.map(renderToHTML).join('');
+  return renderToHTML(children);
+}
diff --git a/examples/npm/react/index.js b/examples/npm/react/index.js
new file mode 100644
index 0000000..ceed62c
--- /dev/null
+++ b/examples/npm/react/index.js
@@ -0,0 +1,12 @@
+import { build } from 'esbuild';
+
+const { outputFiles } = await build({
+  entryPoints: ['app.jsx'],
+  bundle: true,
+  write: false,
+  jsx: 'automatic',
+  platform: 'node'
+});
+
+const code = outputFiles[0].text;
+await import(`data:text/javascript,${encodeURIComponent(code)}`);
diff --git a/examples/npm/react/package.json b/examples/npm/react/package.json
new file mode 100644
index 0000000..5909011
--- /dev/null
+++ b/examples/npm/react/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "react",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "ant index.js"
+  },
+  "dependencies": {
+    "react": "^19.2.4",
+    "esbuild": "^0.27.3"
+  },
+  "devDependencies": {}
+}
diff --git a/examples/npm/rolldown/ant.lockb b/examples/npm/rolldown/ant.lockb
new file mode 100644
index 0000000000000000000000000000000000000000..c862534b8adf3edf4073068fa87583718cf0f73f
GIT binary patch
literal 1504
zcmeZq_YPoWU|?WlU|?WoU|?`yU|{&q$iU#h#K2I%%D}LIm4ShS0XHbh&&f&2FVD*;
zDJdwn($_CaP0uVYDXP@VE6B|%*2^zS*M}+5*M&264fPE440MZ<_0052(yKr;Ld4cU
z&(P3R&!8wZF}VbvxgdFvp&(k<&{EGx&je(e1Kh%boYM5nywZ})oMJrYU{$ZLtB<4`
z&AoYvdHI<sc#MQ7(AU+6Fmz4z3?V*6*p-x-my(&6uA7orRGyiqn^=@<W`f5={2KLj
z^|6_U=4^-jie%k_qWrAX<P!ao%7Rq9p@N}UUl*cD7aBjHum&d#Q2GF+AutDxaAja%
zU}0cjU_X7-Hr9b(eZj)^hs_VIUAX5Ytp0NJYU;r@9fcY4HrE$<i@8PI$=!S<t6gz3
zcWj8x`m32wKWV->#?9r^QO~s<WQQ%9*`V|qz`(%Z;v60l&A`CG%D})N3{}Gfr9pN>
znPBQ$`O8~kn%vBb8Sd}#o#@tfwdD}^HQA~bk9sZt^A7$$!zM*}Tio5IdtOuM=F5$9
zeut%P$lNmJ62szo_EOyL>tquc7#NJfCP4_08$c{jzEQHOR+`Mfz#z)Nz(6QGlKngV
z4=Y{EoOb!pE;;qK`*Go>(mV9Mp44bL++WAOT|2o+YsQ>of+fLsj!M?CvS^vs+$-2S
z>08C3pQ4)9cdsj~U|?YI1z8NmFn55spv?Cbnx{cw0uqC{2b9l2d>Ag?zuT36u7O;v
zJrC3J_IcNTO#QdE|K*~sGtFY^_B#4KO+A^PsM^tEuXd92<iV-jd0r_eBCgLmm;ZUi
zElE#BRkq&@3=AeP!=Pmdhzp7rBi$-veMSZbIU>U2*QG@MT(3RJxk0<U<F*A%wO{<C
z%&Wsk@Yd>>)V=Rbo@(xE`Rin8G-=<@)cjNHUH5$B(y9J<HP&zY^XRE5_5%BT85tPj
zK^8+Xa(Ec08YZq`WMB}2%7Lh25P=0hsxRePc`w&x$0<|x=^5sK_fG!ND$DtEMM_56
zp;P)P3b$0X?VMa4jNdY>TJlj=o4xi$&#vc_-%pp!oG$z?SJQhRBLjmYlDWw4FtRW;
z2c=6-1_lN$s2WiG1T!GYSWtR}$%EMC_jx-&YC8Sa$bk4DZU6uO{|}?Le0385#cir}
V+;NcEV#|C$$&X>)uYP`z-2kLnm(&0N

literal 0
HcmV?d00001

diff --git a/examples/npm/rolldown/app.jsx b/examples/npm/rolldown/app.jsx
new file mode 100644
index 0000000..807c1a1
--- /dev/null
+++ b/examples/npm/rolldown/app.jsx
@@ -0,0 +1,7 @@
+export const TestElement = (
+  <div>
+    <p>I am a paragraph.</p>
+    <p>I am a paragraph too.</p>
+    <span>I am a id: {import.meta.env.id}</span>
+  </div>
+);
diff --git a/examples/npm/rolldown/index.ts b/examples/npm/rolldown/index.ts
new file mode 100644
index 0000000..602c724
--- /dev/null
+++ b/examples/npm/rolldown/index.ts
@@ -0,0 +1,24 @@
+import { nanoid } from 'nanoid';
+import { join } from 'node:path';
+import { rolldown } from 'rolldown';
+
+const args = [`id=${nanoid()}`];
+const replacements: Record<string, string> = {};
+
+for (const arg of args) {
+  const pivot = arg.indexOf('=');
+  if (pivot === -1) continue;
+
+  const key = arg.slice(0, pivot);
+  const value = arg.slice(pivot + 1);
+
+  replacements[`import.meta.env.${key}`] = JSON.stringify(value);
+}
+
+const bundle = await rolldown({
+  input: join(import.meta.dirname, 'app.jsx'),
+  transform: { define: replacements }
+});
+
+const { output } = await bundle.generate({});
+if (output.length) console.log(output[0].code);
diff --git a/examples/npm/rolldown/package.json b/examples/npm/rolldown/package.json
new file mode 100644
index 0000000..cbcc174
--- /dev/null
+++ b/examples/npm/rolldown/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "esbuild",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "start": "ant index.ts"
+  },
+  "dependencies": {
+    "nanoid": "^5.1.6",
+    "rolldown": "^1.0.0-rc.6",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {}
+}
diff --git a/examples/npm/smoke/ant.lockb b/examples/npm/smoke/ant.lockb
new file mode 100644
index 0000000000000000000000000000000000000000..d748246c373e613dd3475b6d8b6f5f79210ed5d6
GIT binary patch
literal 12432
zcmeZq_YPoWU|=v|U|=v~U|?`yU|{&i$H3sg&%p3Ni-EyGkAcC90XN9a%*)KpEH23?
zDJdwn($_CaP0uVYDXP@VE6B|%*2^zS*M}+5*M&264fTxlEc8m!tBO-|%TkN*=!PiJ
z*VTtGbj|h5^-MrI3lfWpQ%!X<N^*0+%pxP*lA_d9-Ncl{f)cz&f|cXesjsU~K!vWk
zo}r!r$Psa-dIoyNaprmkdIm{FiOH$DsTBo@dBvIed3gMUrcz&5A5BCTWGvX1aVB~O
zdPXVvC8>F3cua&S(AU+6Fmw&g^^EllK`t!MFG?vdN-V&m8Ky*ES0BdI1^Ex`!_v~s
z6g+xC()zmkAWGNJ7!(X3ODhv|bMR;aN$czCgD724Ixqt1$tupz(=ATUNX<>uEh$PY
zOD!r+#bX9G<@&n%*n|<DsmjOam#X{}eO>*k{1jaiJ!3sHkfZVv^YZcfAEH2CS0BRA
zHPthO=qydo$xN%%%__#@2e=wg2*T9s8tWNa>KTJ<&&8)Xw-}V6igk_j3?Zu15{pZ8
zQ&Lk4bW;mU6Y+&Vno50LeKZk}8z6?J<mYB2=B4D|%}@wM;1mec0ZzqWkHi`28S5D&
zXC&ri;|UJ1yuPkJnASDbGt&bnjFkLb-Qv`u%*33`DniacQV4Mhl7OxeEP2M6=o#r5
zfb*_VN@7W>Zdx9`kcKG%nFv*_YXU0)$}<v6%F}gI^OEyZGV{{$cn?h_D7T^N1&2B~
z(;DcR=^5uH7G<a6ORo?Gpi}@>3Ci>akXXx1&d)2;&B-jmmxB<B^mX+S99^*GpyX#~
zs{l$|MhZ3x;GA7hlv+|!shd<;l8P_5kd=YTQY2l7f)f^Ay2W{!X=!+)6<w*mu0Fbu
zu7MuNr6uWAabVZSfeJsvl>FS%lFS@@ZiOiUMJ-gduCbmGB;mz@6HIb(nJ&0Kz!SA_
zHK5cBQ?F|VOC#VKFtH>#1CJ4KHK6zeRjMHMx`rT+fh&U2yp+u3Ogsia6o5(+uu5HX
zJtL6&OVX=S^GY&HGV#V4ObIw_A*yvjl^QrTB2}@_G@P56n_5y?fG>5SsYIl9m|k5_
z%?7Swl8cLVi&Jw_lkv485Q@NI4AY@&3Xd&taD(H_Fb-UO#eq^SC>5mUq~@mPl@M@o
zN`5YqLP&~063_*gVW4~gatg?Mcp?L)1nO3hYF$uq1}@Nw6Vp<QbdyR6q<ds#p!N@v
zE^wg_HY+JVKPM>>Z%qkP0%~SJRU>M|ywrT%#Nx`lWIUdMs{vJWF!j1du=2S$r!+k?
ztrCv`P!%9gK-B7jDoJn!Ta=iRSd1@UKoscf>O&a1hM<fNPL_#T_*z7XS!MdV`iWU(
zx)yqd7SPrjC_@;53kT!mjMUVk%zQkqhN=KXAw(^>)e26raUe$+#DSZEaiA<}7zZvj
zKq8iUAPHkVgE&J2PyqlE(=!6M;|y~0LB7?+n-$?|^mX;&Y*2k;u4e?UOu>bbDISMI
z6o86eND~><7KAw43{(T+(TSAP^>y`;c%Xs^l&3%?EVx|2V+gjg#6%C&qAf|U$}7px
zP0mP7#@7yjs{y4qn0j!M2giF+YGG++QL1iQ5vXBMQiQ+O#iAONm@v%%HxIyh3L5c5
zlu6KZ0V%wY5(-2B>|{v5gPMf~Nr^d$dC93My1AgT9Zv|NDg@<Q6rJFb6I>}kVj5CC
z73mh26s0ES;xQMSazru#%fd_n*VN$9fHeP-5{vNFqX<QybOUZMf^_Jb=$S+Md2yf~
zpD8%&nSkqP!#HpO0&aMg7U8SdU`k-k)Y76%a7zgsvUq%pEgga~05}m9=a&{Gr|Rb7
z?HC~xfr>7;4sZ(zYzm}b%)!9G0O~`7cuXLIfq?-e24#Y&+d2*Iry3{Ry|GKYGpkfH
zLNDa*wx5d*d^&KU#@*oR6dPvQT`~-_@2y(#b@%y6A$E@^ru;bdo1JUws+Cy{NB0_Y
zfXuT1n}kV#I^3XsI~xN713Oe2MzcWqFltXw(~U-5r_#iwc7NK#G(YovSo@#J__49Z
z!DFh^4{o=JG*=fCD}5v9*YecHW0JE@!<F4LuYPAps6L*;bMwZIDQ?iQ0+@L)I)H(J
z0o2*AVqjp9M{)-&Twv;8^tv~e$CcK+ih8;DPVE}Ctkjt&f~q~ZOc=^t*UXyx_oZj;
zl=}~VsXqvfExg9&-hF&smE8v4Us>@d{;`A@iaQ7Wo5{eykOnghO2fiFG1=0Bn~{Nm
zpMima6)Fd#(8Hts!I61W^N*!pt^Bs5C+txD#Jlp-cz8>4W-NcY^lzrZwlJ5-;G9{7
zm420TW>$D*SIV-ro#V}TDR|UoTHmV5Mm{M<1_n@=z|04^0p@4WfJho60|O{t1fdF;
zp)^bll*^#-p6TzMBl(NBi{F2Hh;OED&DYm$+v-G~3#R>jQoEfmk8j8Qy*F;QFonF{
zHTiF7Ugzv;zT2w<rmb0jN{?w%nXN<)BLjme%rFK92ADmdbODN&g^Z9iiEb~F7BI8v
zYq3hC|H(sho?i2Pto+3Oj5Y7s-)xt^o;-78?&H~yUTuFg^=8qpx2~4c!jJ9?O5Ycw
z<JGw1%&+qGlNJ4q)$TrA$;iNfoK9ix02%I;n_u;ik%57Qfq{V+B!CCUvM*3v5FF}p
zNiL#m<;kNfdsZ^u6Z)AjWBX)}N@=UZUm4cxeg4>={B(|>%RZHJ>qG7x__hDNWz~My
zeU4IWGalW3%E-WAh-5y@9iVh-5n^O0#sqN(D84|-K=}(q!}uUJ2+x{XG-uVEE4mAP
z!wk!vuiO@4D9)X%9DS*Ujcw9_rh2jGe=ioyDLLC6_CD!A@FejNvx^<|b9}A%%RlY9
z<k@}cixd+Bg8|4OC`NXNRkc!?7ZU@62vYe0Rfa*CoVT~X`903`q2kQ1Q+A|?E@1L`
zD(F~otu>C3`AfRhf5UxTYgbJW|I)l;rih`pY~Zv$-PPu+^1b<{?Ve?=dv{kH69WUt
z?=XX5?f~)Ai!w{rF+tJ{C~iPvFnLhg1@U2c?eEle9_}g6mH9c@rj_cZ&eYHNcxZ!x
z@bWIVWsmy|%qEu@To=DvuruJ~!Yuv`OaI?(zVP(pJMogqy~m8S_D^Wr$i%>)2Qv&U
zoth+>8sBGv<QG`Jg{4<?cNFj6?aDvbKrYsvhiQ5Hyz4)v{#)Dsa?#eAW-)bp9sQoB
zp3F~F?dY*rJIQ(S;8gBBuapxJ*Jqu}|GeUsq^F`P+fydUm?z9BF#m$W2$WwWnHd;3
zk=!Q?RR~iD<udFqefL{?18c>a<x3=d5B><;`0r>__^PUHvp>Cc4DE_Glewn8FsbO#
zu@+|Yi|(&~{QcK6yY}9+FBt`s;_U(sP1aOmW?-;}8HQw^00RR<NO)>wEHeWGC{2Pe
zNEs|V(B1JOvUul~(<!+pZ>~QZqM%ygk$i4l#xcfE8LGA?Ti+M#)?XObuD1TobI}v8
zzh1XrUHn$Qkm0raT;=^+t6lG=1W$=)W?;|(SpdZ_^Fif@m6EYuH#4L>g^A;GM}5_V
zZ!JdOY#Um{_sd^(`X0kQV}TQ={{x<vr%c$`o=F>6Z}8T#wUs^Ro^a=HL6Y5X$xI$4
z1>O~F!_JyBn$$d;#f(~>!t4V%%hb#}<N-4S0~eNZ9a$YnZ4r;^{=Z409IbQxt70nz
zt>g`TpRe6il*D)B&Ra7ko$%V<UwbEX_4`Zo{67^`e$-=~=rP~FzNe$MwymDJ!pQOY
zD`o};8<0Uz3^E_)XG0~cY8@6x-2zLeu=ELwC#W`tH+K%|d!2pxStR=TZ{|fBkK{~N
za=QH%T(;#*d|u&y?JWnk-RE>n4bXnK;G*j(!>68$RV#%&c{g}n_%zk|?xy28hAa#W
zMliz|AY~Sa3yPN<Kd-c876t}B21ptKiQ~ctIvLh$tlIwb>Jt~Pm0THjRbF^JtyOn;
zo-=EM_SW@(t?qo!Il<UgAr`FnWAf4Hfcp~BHCLw`l43ZLx&40ZqfcsuEDQ`TNQQ&T
z2~e1TgpBo!Ob@a^>KBkWNDLNMAT}}%^4hYP?LxfR{@_BkZO22|TuKjb>T{mK!M5D}
zmZbiqnwz%W2aoQ*mA%kLe|K6>bjraAd3Rk8<{2s2^&dIk6J>Ui1+{*GwR1q>VQ6Sz
z%E*d6oua$v)#8el={^U)F>dj_!D@26t$kh4hJ&^<XFIM5V_MRn8-J$4^Wt;c!t$eB
zJMT_pa?G&vZ2Tpebk!_qzQ&%%GGF%!u%f0@kUL;@fW`=-Ss~>Ztlo!(0W8d5{Jy*S
zH=eyb@o3_wdE%K)p_9wRT;`?!(z9D<qOn~1>iw)sbFZ9?`((V+JuISU|Fww$MlNc5
zO>Z4GIJ@HEe@@ShFA`Z%>wQ=~7Qn#3U}|AtJdG8SUtspZ(kZ$-9)4Kz{*F$|@nWO7
ztL6PxMQw6<q@}uIhf_d(U)Ljr;P(^R{r5h&>8yV?YRkK0@$>QmR?l1PT_|%qUs%bC
zf9qW11+1v~1>_D`c!1`F-mo$-@DR~1ob%xGUW*x_f)iITuNOWiI(d?_z0SssktTn?
z9r(Lzx7*6}HgC3N$JbuIdim(Cd|e~ug$t{-kJa$x8_8X2^Z7Ev{Rb;#4h!aAPACJE
zK7zA-O)c0M7(it!R2W>gg4i&(g4iJZjQiDXmtT8-#Z8RPTHB)Ip%{6cQQ`R;vCChi
zQjRVW+t;|l_H4~+lQkPQKH7D4s%mHDw4WwI2_d@;wEvhHrrJq+urV-rfDD3SkUL;y
zgR!2G*&H@Veu2dUOb$jvwK2SM^E&Cac#8F^DMeG`W2~FCRr@dVE7qJ4)A_$9d;7Bo
zTMwMrH{nFUfsE8g(Y3n@_J;2FFe|f7ufNG$-`c{`oxOw&HNS8p)iD`~riPE$AoUz9
zU7&{p%pDw#cKuuldi6cCF02ea{I)|aGwecDdUBVo)%Qnp<|KA;zdI9a<$Ac3Pt{Gw
zs;gnk>IL4b#H|X}$Z<x$&Wbl`f6d0gU<EUb0a9jxxS)7RF)*-HWrw%}RJMb}Vc`HP
zPe5WIyinru;s4c{2EG>sZzrhdiU$kS{a)kI5Mb;iDa7;ib?>g<CoXY&9=*E$*sN0T
zr5|cfYyE0o7`!rTQEJ%7b=R7d^w?4BTTs~v@-xUCpy{7Xc1XSj<!6w6Vjuzwc3Z6)
zo~rXi>gg2u&MLKZ?XI}>s=;&b?B%Ok^*Uwy$(BGrTU}9x4MG)DPUlv=J1HyiX8XP+
z#X>(z`SNtaQ{wpY*-`T?sILOErYI>fX9+tbeZbrSlLNUG#s<;8Sr2p`hBzAj{oW>W
zDz?bKdsEgo%Q+V+XFb3FQ#vebaVQ7Vj?2e>rd8fHVP%Qfa%kDhy@!{r_TQ^?wLIXV
zd!Nl3c1Zeo!p^_|N*l=Ta1RI#ea{XlPtoH6WH&N)T(q&>y;n(hneeT$J?_P|EBG`D
z=JZE-K3~WplfoA+RkQy7qs>NF0^{C)zEf)*Rqy{e)#qH;JJVf1&-@Tu8xi)89ko0~
zc87(Mj*<%pq#T3Qx3Kg9qhW6G)46=sJy!Zpgbwf7xOP`#_e(i9HpdxvwXK-o%>8iM
zsi@LfD)WPyPdi77>Kg3uo~_s*`uw};zX0uvX0t>K#n1b3pq67Gcfjm)FLl>n!~sdW
zFneM77iK?<w%91lX1C$OYpDhq*|_4n=I-i-A8Qv)uKIe)?(MAGH6K@(O}=U(s(d+H
zvwK0Q`5va0ElPHEOdj>0)xLgszCulY0|#n-3+f}l%q}X<%>TjxNguF$3v&;QhN<2C
zdHa60m)k9THWz)ZWwg0DrCXLoep_F{$vGdkKJ^e*pOri@=B=D;*2H?YFBzVVaVtNh
zJjxZl8a99R<j4E-3ikZrfTRzYc_{A4EU7f%gp}(rdtvDl#)s)koMo<kb`t-Vq*J;q
zS6uiP8GU}|6}PNpg7PIJ+l|MYL$AlazWwx)$Gcla<_XM4(gkt~ckewjQO;K;pKFfO
zjw#z5I8n=WWOpPRSy(o3Lc#-PKg?cqT6OXy=FJ-44!g0RpVF&gT(Uc3VuH%)nA_(r
zn@0*A%ANP+f4MNj%?UG}2fo)`@MEsr&D2kab&I_F_H6C%Sof;sa0e&u@JP%{EIPmm
zDaT;`M~@$vdlK(n5!6eIP+8^vs@MPSrMq4dL0%2%H@%yW?QXvHXx7nX2}yejLtZfV
zzY#CV-XvZWUd<qJ^lDI+Pr@6!l3jkgPjaG`r^w-vYHX6o%mo<>f`tdn9WWZ^j`lad
zWftCuv)iER-!NDIpF+Jz`}MnpwchI_O#cSU)?faxKtx>h=p)A4Mz^kXUHG>^o5?$F
zuG#v#QmqcF<ovVOb8$h|jlj%<xdT+5f|i6ha6!sbP~8tw19K0I28n@idtIlo(8N_6
z3`6YAE(d0F&6#KRRN`x2aXR<n^||sQ?|yHasw=s!CEfhg;lJ0i6vDqxfA#*c=BCHo
zrdO6*3K)2}aiNx{$nNlS@o=r?g7j}e?GliELLdSQwhKL9;o1{(ta`&YKDm|6CzOf{
zKW7K+y)SWTZMEsw$C~06PWmU-o0h-YR4#9;+2{8@(97W4gj*ltS%NH0N~-SEaWOFH
zBbf_w2dL}>g@;wOQprxVc!8x8BrRZOgw?0q^A9wlf)lydYBcQ%`hI7(#A3ziXKKr4
z%s%Y1;ftYX_x<0o_hX$Z)?2$tZi->$KPEmeVc)hA*0a+6KUeKLfEF(j43P32<c|En
zL=!!3NIC_%4P+s#ohlCEAmNEY7N6dpPuu%P_L}kcqiQujuTM|7zHWNVmR(16)XOKl
zDLv}RH*2E*@f}Q&$(9B`x&MCnb9R4!yNhv8V$S0i?osC4sO70L)NGJD^o-2(in$@_
z16I%BDo+(U-v@8Ml^6SCRmR@NesRl~#AIco9km++Zbjc(Z=d|`=kuhcRhEMLRv*58
z^UOlm{W}@k@)l<@FL_t@&Q*UxWOF4qYJVT(4p<sYOf<2C)qk+|2TTs?TsReKmSTKy
znhUqfvhNGu9BF;2@p#?jP?M{kHPI{Ii`=;D<+?3zcU{k38Po8&kKT$#S1dX6bK>j-
z)6<9MDZA!JqzZ24W?-;~o5sMPg4CxAsz~;L)%&n`fz>@oTENV3k7W6FH#>QU#j{F`
zS|VPEW^HF!+-|pCdD7(%OqEaScQoJsv3KLgD}5EUy5c)edbb!JSo4Lc<HX@(X5Ak@
ze{BE34JpT9{YMS3sSv`@QmNK}2a-Nu=@S+nFdCwgfnnN;*L`Vy3plUUoNTn&Ki#Zm
zd7A9L%{)o*rBj5xElxO|c$MF9Xw$a9$%|&Rq~5Ln;dnZ9r9MOFjH9cS+twVt{oj%Y
zwHyPv17-(kCcc=5fdMr30&@q<UUYu!U-ig$6F0tjByxHm)BNZzRq0tXvtH`gFMs#p
zZR`0z6WrUjGV^*AWWPROu04C#@|%&?_k#Z)P7GYblXp>L|9jy!9tH+KnBfcz44O!6
z567&?D?F(6KFp0s%D~KT|5K!$-k;kUv#UaP&g@KyI}tzs9N}bIsNKk>TDzWIeR0Rp
zKMxN2I`fGf`ILHhW3<m1JKo>sZ_7F+=m@8NdidxO4{E&+atEx;2Cb&k;f1&ZmOj9i
zBBdcXf7b)SBf$r2SG;1}DDj~8#OY&RbAKkaze~2UZ4ct{mF!w|+aYyo$m?x)^Dn=?
z^_89Z{Nj7MYgK=od!e`QQBIqW6)&ngkjpeB9i`$rUdXs5EZ@Sy13g~U)h86+*dVg=
zr|<6fD;PS&zlKXMn{8p<cqc|}|CeJWJI!>zU7NUOl4Revtb2C;dPgRFOa44h?}63{
zuEi<07D+Fj#LIv(ZV7S+%q}IXYNbcKkai&~JYepDmGiLh*t`6e*lHWYnSyIoe{Tp4
zDeJwp{CjW5&f5>#mTZ!FZ$EGPlUrXqk{Xnjhrhb4I(y+AQz4c03k<Di92IIRJ~!o0
z<{Mtratt)43yK#|KfA==EXsio(*A&zUobbq?1#}E-{<ix3X1&4A@FQXXw;LrRZ*<5
z987cmH_f|rbKCFqrl-9-%M6kNS9IR&^tx~`wyJ2(hd;KLp4oZsium7XSH|GM2g$cE
z^FV7hVQkPi46OVBxeX=`qS4)xalhKMwDkpRqwk9NkVo3=pM%<b9zCf$`fYE{w}kHn
z7C*H5;%}`;3~S@*+<Np)ruW`w|M@dkM6TI0UC8!r`0{%Vc-&!D=4-x#4-zjRyFnP{
z9&~pESx7B=Ic@4@#R(F|{@YZFr-=vJS&4ge?LN{Lw^q8C`DeNP!wWx?U%ouK%I0h8
zu5Ht&&RW^|I&_biWwMcYVa2;ce5mn)93G(b0qWoVXMof(Aa{Vu7gp$;42TaJi%vk|
z%P}x8sIef_qw_&yaa)n(LFVs9;)Ck@FjmOeAjo_L1_p*ZtcWoOko*KTg!!O$$TTEA
zx_uz?k=+j(ySRg-9+cjY?FY@hb#Wlf*JfZ~n1IArWME*JhQtTe_j8c=Ap4Nb1C0r<
zg|^{9{sGOYAgkwPU|`scBoE4W$mZ)ZFfe>Wk_VL!e~|c~{xuV{4FED9<Q@(rz7%Mz
zfE&`51<8ZrPZUWWR6a^0$%D!VB_w%}fAEE$3<Cp$29kPE{H{gfqsIqG{u7csy7}nt
zM-Ojw_2}`1ZXddSkom~rFAGYqyomS)g%5K228S6RLLSt|*F)li+84<2Wel3%MUq!y
zU|_I9;v?$^mAT7eJGfOD7#I#;u(1cFg_gNhhtwDt7(RB`?*jP+WdHyF|3Oi}0HQN=
zEcrowYIO0V6_Mca!4pd9j-WX7e>ZO(NX^fWHoTzvU%%d^78F+BxHf(RrLk4^Ww)gn
z7#Kjb76Svr)?OPCkl!c$R$>FWxv@M;2b9)4+NRC{we@yBbl?HCfyFj$)&Yg#{P2n<
zNd^Xnn}UVYKxH||98laUhKTF{g#pNJkb7~_^%Ebofbud-{_1U;pP=yIsnv}D#hGh$
zTeCVyl7Rv2Zx9pNJjN^L>7on_3^nHSYd~e=I|mnOP+I)E^^_#2%=qXVaR`)m(DkA7
zD?}F7!0J3?^UHtmvw_<563_2RfZCYR#e4@qaeZs9%VAKN@O*ZQ87Ob3^=8ij<-x}N
zClx?>P18oO4pb&G*KQXErPY>*1X)lSGxNmSQ=q(7py_uPR0eF{(I^co%aQG!bfSYB
rG}g&2SEvjs+vff1=ZCeak=5PjDFiiz8G2;8VnAhD^@rQnKxr8O`}l9D

literal 0
HcmV?d00001

diff --git a/examples/npm/smoke/formatter.js b/examples/npm/smoke/formatter.js
new file mode 100644
index 0000000..8911d6d
--- /dev/null
+++ b/examples/npm/smoke/formatter.js
@@ -0,0 +1,25 @@
+export function printTable(rows) {
+  const normalize = r => r?.map(v => (v != null ? (typeof v === 'object' ? JSON.stringify(v) : String(v)) : ''));
+  const normalized = rows.map(normalize);
+
+  const widths = [0, 0];
+  for (const r of normalized) if (r) for (let i = 0; i < 2; i++) widths[i] = Math.max(widths[i], r[i]?.length || 0);
+
+  const totalWidth = widths[0] + widths[1] + 3;
+  const border = (l, m, r) => l + '─'.repeat(widths[0] + 2) + m + '─'.repeat(widths[1] + 2) + r;
+  const lines = [border('┌', '┬', '┐')];
+  let lastRowSpanned = false;
+
+  for (let i = 0; i < normalized.length; i++) {
+    const r = normalized[i];
+    lastRowSpanned = !r || !r[0] || !r[1];
+    if (!r) lines.push('│' + ' '.repeat(totalWidth + 2) + '│');
+    else if (!r[0]) lines.push('│ ' + r[1].padStart(totalWidth) + ' │');
+    else if (!r[1]) lines.push('│ ' + r[0].padEnd(totalWidth) + ' │');
+    else lines.push('│ ' + r[0].padEnd(widths[0]) + ' │ ' + r[1].padEnd(widths[1]) + ' │');
+    if (i === 0) lines.push(border('├', '┼', '┤'));
+  }
+
+  lines.push(lastRowSpanned ? '└' + '─'.repeat(totalWidth + 2) + '┘' : border('└', '┴', '┘'));
+  process.stdout.write(lines.join('\n') + '\n');
+}
diff --git a/examples/npm/smoke/package.json b/examples/npm/smoke/package.json
new file mode 100644
index 0000000..96887d2
--- /dev/null
+++ b/examples/npm/smoke/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "smoke",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "ant index.js"
+  },
+  "dependencies": {
+    "uuid": "^13.0.0",
+    "ms": "^2.1.3",
+    "pretty-bytes": "^7.1.0",
+    "slugify": "^1.6.6",
+    "lodash-es": "^4.17.23",
+    "nanoid": "^5.1.6",
+    "zod": "^4.3.6",
+    "marked": "^17.0.3",
+    "radash": "^12.1.1",
+    "chalk": "^5.6.2",
+    "semver": "^7.7.4",
+    "minimatch": "^10.2.4",
+    "yaml": "^2.8.2",
+    "csv-parse": "^6.1.0",
+    "dotenv": "^17.3.1",
+    "date-fns": "^4.1.0",
+    "ajv": "^8.18.0",
+    "cheerio": "^1.2.0",
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {}
+}
\ No newline at end of file
diff --git a/examples/npm/smoke/tests/real-world.js b/examples/npm/smoke/tests/real-world.js
new file mode 100644
index 0000000..070e261
--- /dev/null
+++ b/examples/npm/smoke/tests/real-world.js
@@ -0,0 +1,41 @@
+import { printTable } from '../formatter.js';
+
+import Ajv from 'ajv';
+import Handlebars from 'handlebars';
+import { format, addDays, differenceInDays, formatDistance } from 'date-fns';
+
+const now = new Date('2026-02-27T12:00:00Z');
+const later = addDays(now, 10);
+const formatted = format(now, 'yyyy-MM-dd');
+const distance = formatDistance(now, later);
+const daysDiff = differenceInDays(later, now);
+
+const ajv = new Ajv();
+const schema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    age: { type: 'integer', minimum: 0 }
+  },
+  required: ['name', 'age']
+};
+
+const validate = ajv.compile(schema);
+const valid = validate({ name: 'alice', age: 30 });
+const invalid = validate({ name: 'bob', age: -1 });
+
+const template = Handlebars.compile('Hello {{name}}, you have {{count}} messages');
+const rendered = template({ name: 'Alice', count: 5 });
+
+const rows = [
+  ['Real world tools', 'output'],
+  ['date-fns format', formatted],
+  ['date-fns addDays', format(later, 'yyyy-MM-dd')],
+  ['date-fns distance', distance],
+  ['date-fns diffDays', daysDiff],
+  ['ajv valid', valid],
+  ['ajv invalid', `${invalid} — ${validate.errors?.[0]?.message}`],
+  ['handlebars', rendered]
+];
+
+printTable(rows);
diff --git a/examples/npm/smoke/tests/small-logic.js b/examples/npm/smoke/tests/small-logic.js
new file mode 100644
index 0000000..8223ba4
--- /dev/null
+++ b/examples/npm/smoke/tests/small-logic.js
@@ -0,0 +1,34 @@
+import { printTable } from '../formatter.js';
+
+import chalk from 'chalk';
+import semver from 'semver';
+import dotenv from 'dotenv';
+
+import { marked } from 'marked';
+import { minimatch } from 'minimatch';
+import { stringify as stringifyYaml } from 'yaml';
+import { parse as parseCsv } from 'csv-parse/sync';
+
+const yaml = stringifyYaml({
+  name: 'test',
+  version: '1.0.0',
+  tags: ['runtime', 'modules']
+}).trim();
+
+const env = dotenv.parse('HOST=localhost\nPORT=3000');
+const csv = parseCsv('name,age\nalice,30\nbob,25', { columns: true });
+
+const rows = [
+  ['Small dependency trees', 'output'],
+  ['semver.valid', semver.valid('1.2.3')],
+  ['semver.gt', semver.gt('2.0.0', '1.0.0')],
+  ['minimatch', minimatch('/foo/bar.js', '/foo/**/*.js')],
+  ['dotenv', `HOST=${env.HOST} PORT=${env.PORT}`],
+  ['csv-parse', `${csv[0].name}(${csv[0].age}), ${csv[1].name}(${csv[1].age})`],
+  ['marked', marked('**bold** and _italic_').trim()]
+];
+
+printTable(rows);
+
+console.log(yaml);
+console.log(chalk.green('green') + ' ' + chalk.bold.red('bold red'));
diff --git a/examples/npm/smoke/tests/zero-dep.js b/examples/npm/smoke/tests/zero-dep.js
new file mode 100644
index 0000000..3e17a13
--- /dev/null
+++ b/examples/npm/smoke/tests/zero-dep.js
@@ -0,0 +1,30 @@
+import { printTable } from '../formatter.js';
+
+import { z } from 'zod';
+import { diff } from 'radash';
+import { nanoid } from 'nanoid';
+import { marked } from 'marked';
+import { merge } from 'lodash-es';
+import { v4 as uuidv4 } from 'uuid';
+
+import ms from 'ms';
+import slugify from 'slugify';
+import prettyBytes from 'pretty-bytes';
+
+const oldWorldGods = ['ra', 'zeus'];
+const newWorldGods = ['vishnu', 'zeus'];
+
+const rows = [
+  ['Zero dependencies', 'output'],
+  ['uuid', uuidv4()],
+  ['zod', z.string().parse('it works')],
+  ["ms('2 days')", ms('2 days')],
+  ['prettyBytes', prettyBytes(1337)],
+  ['slugify', slugify('Hello World!')],
+  ['deepmerge', merge({ a: 1 }, { b: 2 })],
+  ['diff', diff(oldWorldGods, newWorldGods)],
+  ['nanoid', nanoid()],
+  ['marked', marked('# Hello').trim()]
+];
+
+printTable(rows);
diff --git a/examples/quirks.txt b/examples/quirks.txt
index 7ddf7c8..eaf56b4 100644
--- a/examples/quirks.txt
+++ b/examples/quirks.txt
@@ -10,7 +10,7 @@ void function f(i){i<5&&setTimeout(f,0,i+1,console.log(i))}(0)
 comma:
 (f=i=>(i<5&&(console.log(i),f(i+1)),0))(0)
 
-getter (has to be run twice?):
+getter:
 ({get n(){for(var i=0;i<5;)console.log(i++)}}).n
 
 proxy:
@@ -41,4 +41,10 @@ promise:
 void async function f(i){i<5&&await f(i+1,console.log(i))}(0)
 
 sloppy with:
-with({i:0}){while(i<5)console.log(i++)}
\ No newline at end of file
+with({i:0}){while(i<5)console.log(i++)}
+
+batman:
+Array(16).join('wat' - 1) + ' Batman!';
+
+banana:
+('b' + 'a' + + 'a' + 'a').toLowerCase()
\ No newline at end of file
diff --git a/examples/spec/ant.js b/examples/spec/ant.js
index 55ac745..3fbdfe2 100644
--- a/examples/spec/ant.js
+++ b/examples/spec/ant.js
@@ -45,10 +45,6 @@ test('typeof null', Ant.typeof(null), 'null');
 test('typeof undefined', Ant.typeof(undefined), 'undefined');
 test('typeof boolean', Ant.typeof(true), 'boolean');
 
-test('gc is function', typeof Ant.gc, 'function');
-const gcResult = Ant.gc();
-test('gc returns undefined', gcResult, undefined);
-
 test('stats is function', typeof Ant.stats, 'function');
 test('raw is object', typeof Ant.raw, 'object');
 test('raw.typeof is function', typeof Ant.raw.typeof, 'function');
diff --git a/examples/spec/async_loops.js b/examples/spec/async_loops.js
index a6939d4..e4d1b9f 100644
--- a/examples/spec/async_loops.js
+++ b/examples/spec/async_loops.js
@@ -16,7 +16,7 @@ async function testForLetClosure() {
   }
   return fns.map(f => f()).join(',');
 }
-testForLetClosure().then(v => {
+const p1 = testForLetClosure().then(v => {
   results.forLetClosure = v;
 });
 
@@ -29,7 +29,7 @@ async function testBlockScopedCapture() {
   }
   return fns.map(f => f()).join(',');
 }
-testBlockScopedCapture().then(v => {
+const p2 = testBlockScopedCapture().then(v => {
   results.blockScopedCapture = v;
 });
 
@@ -44,7 +44,7 @@ async function testNestedLoops() {
   }
   return fns.map(f => f()).join(',');
 }
-testNestedLoops().then(v => {
+const p3 = testNestedLoops().then(v => {
   results.nestedLoops = v;
 });
 
@@ -59,7 +59,7 @@ async function testWhileLoop() {
   }
   return values.join(',');
 }
-testWhileLoop().then(v => {
+const p4 = testWhileLoop().then(v => {
   results.whileLoop = v;
 });
 
@@ -73,7 +73,7 @@ async function testMultipleAwaits() {
   }
   return fns.map(f => f()).join(',');
 }
-testMultipleAwaits().then(v => {
+const p5 = testMultipleAwaits().then(v => {
   results.multipleAwaits = v;
 });
 
@@ -92,7 +92,7 @@ async function testSequentialTasks() {
   const b = await loopTask('B');
   return { a: a.join(','), b: b.join(',') };
 }
-testSequentialTasks().then(v => {
+const p6 = testSequentialTasks().then(v => {
   results.sequentialTasks = v;
 });
 
@@ -108,7 +108,7 @@ async function testAsyncArrowInLoop() {
   const values = await Promise.all(fns.map(f => f()));
   return values.join(',');
 }
-testAsyncArrowInLoop().then(v => {
+const p7 = testAsyncArrowInLoop().then(v => {
   results.asyncArrowInLoop = v;
 });
 
@@ -125,7 +125,7 @@ async function testTryCatchInLoop() {
   }
   return values.join(',');
 }
-testTryCatchInLoop().then(v => {
+const p8 = testTryCatchInLoop().then(v => {
   results.tryCatchInLoop = v;
 });
 
@@ -140,7 +140,7 @@ async function testDoWhile() {
   } while (i < 3);
   return values.join(',');
 }
-testDoWhile().then(v => {
+const p9 = testDoWhile().then(v => {
   results.doWhile = v;
 });
 
@@ -155,7 +155,7 @@ async function testConditionalAwait() {
   }
   return fns.map(f => f()).join(',');
 }
-testConditionalAwait().then(v => {
+const p10 = testConditionalAwait().then(v => {
   results.conditionalAwait = v;
 });
 
@@ -178,13 +178,13 @@ async function outer(id) {
   return taskResults;
 }
 
-Promise.all([outer('A'), outer('B'), outer('C')]).then(([a, b, c]) => {
+const p11 = Promise.all([outer('A'), outer('B'), outer('C')]).then(([a, b, c]) => {
   results.nestedAsyncA = a.join(',');
   results.nestedAsyncB = b.join(',');
   results.nestedAsyncC = c.join(',');
 });
 
-setTimeout(() => {
+Promise.all([p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11]).then(() => {
   test('for-let with async closure', results.forLetClosure, '0,1,2');
   test('block-scoped capture', results.blockScopedCapture, '0,10,20');
   test('nested loops', results.nestedLoops, '0-0,0-1,1-0,1-1');
@@ -200,4 +200,4 @@ setTimeout(() => {
   test('nested async calls B', results.nestedAsyncB, 'B:0:0,B:0:1,B:1:0,B:1:1');
   test('nested async calls C', results.nestedAsyncC, 'C:0:0,C:0:1,C:1:0,C:1:1');
   summary();
-}, 200);
+});
diff --git a/examples/spec/child_process.js b/examples/spec/child_process.js
index a57e7a0..c3f4da6 100644
--- a/examples/spec/child_process.js
+++ b/examples/spec/child_process.js
@@ -27,14 +27,14 @@ const inputSync = spawnSync('cat', [], { input: 'test input' });
 test('spawnSync with input', inputSync.stdout, 'test input');
 
 let execDone = false;
-exec('echo async').then(result => {
+const execDoneP = exec('echo async').then(result => {
   test('exec resolves with stdout', result.stdout.trim(), 'async');
   test('exec exitCode', result.exitCode, 0);
   execDone = true;
 });
 
 let execFailDone = false;
-exec('exit 1').catch(err => {
+const execFailDoneP = exec('exit 1').catch(err => {
   test('exec rejects on non-zero exit', typeof err, 'string');
   execFailDone = true;
 });
@@ -59,23 +59,21 @@ child.on('exit', code => {
   spawnExitCode = code;
 });
 
-child.on('close', () => {
+const childClosedP = new Promise(resolve => child.on('close', () => {
   spawnClosed = true;
   test('spawn collects stdout', spawnStdout.trim(), 'line1\nline2');
   test('spawn exit code', spawnExitCode, 0);
   test('spawn close event fired', spawnClosed, true);
+  resolve();
+}));
 
+const shellChildDoneP = childClosedP.then(() => new Promise(resolve => {
   const shellChild = spawn('echo $HOME', [], { shell: true });
   shellChild.on('close', () => {
     test('spawn with shell option', shellChild.stdout.length > 0, true);
-
-    setTimeout(() => {
-      test('exec async completed', execDone, true);
-      test('exec fail async completed', execFailDone, true);
-      summary();
-    }, 100);
+    resolve();
   });
-});
+}));
 
 const stderrChild = spawn('sh', ['-c', 'echo err >&2']);
 let stderrData = '';
@@ -90,3 +88,9 @@ const longChild = spawn('sleep', ['10']);
 longChild.on('close', () => {});
 const killResult = longChild.kill('SIGTERM');
 test('spawn kill returns true', killResult, true);
+
+Promise.all([execDoneP, execFailDoneP, shellChildDoneP]).then(() => {
+  test('exec async completed', execDone, true);
+  test('exec fail async completed', execFailDone, true);
+  summary();
+});
diff --git a/examples/spec/fs_async.js b/examples/spec/fs_async.js
index b5fb9da..8b900da 100644
--- a/examples/spec/fs_async.js
+++ b/examples/spec/fs_async.js
@@ -8,7 +8,7 @@ async function run() {
   const testDir = '/tmp/ant-spec-test-async';
   const testFile = path.join(testDir, 'test.txt');
 
-  await fs.mkdir(testDir);
+  await fs.mkdir(testDir, { recursive: true });
   test('mkdir creates dir', await fs.exists(testDir), true);
 
   await fs.writeFile(testFile, 'hello world');
diff --git a/examples/spec/helpers.js b/examples/spec/helpers.js
index d83c66b..e657f68 100644
--- a/examples/spec/helpers.js
+++ b/examples/spec/helpers.js
@@ -4,31 +4,60 @@ const RESET = '\x1b[0m';
 
 let passed = 0;
 let failed = 0;
+let failures = [];
+
+function specHook() {
+  return globalThis.__ANT_SPEC_HOOK__ || null;
+}
+
+function specState() {
+  const hook = specHook();
+  if (hook && hook.current) return hook.current;
+  return null;
+}
+
+function incPassed() {
+  const s = specState();
+  if (s) s.passed++;
+  else passed++;
+}
+
+function incFailed(name) {
+  const s = specState();
+  if (s) {
+    s.failed++;
+    if (name) s.failures.push(`${RED}✗${RESET} ${name}`);
+  } else {
+    failed++;
+    if (name) failures.push(`${RED}✗${RESET} ${name}`);
+  }
+}
 
 export function test(name, actual, expected) {
   if (actual === expected) {
     console.log(`${GREEN}✓${RESET} ${name}`);
-    passed++;
+    incPassed();
   } else {
     console.log(`${RED}✗${RESET} ${name}`);
     console.log(`  Expected: ${expected}`);
     console.log(`  Actual:   ${actual}`);
-    failed++;
+    incFailed(name);
   }
 }
 
 export function testApprox(name, actual, expected, epsilon = 1e-10) {
-  const pass = (Number.isNaN(actual) && Number.isNaN(expected)) ||
+  const pass =
+    (Number.isNaN(actual) && Number.isNaN(expected)) ||
     (!Number.isFinite(actual) && !Number.isFinite(expected) && actual === expected) ||
     Math.abs(actual - expected) < epsilon;
   if (pass) {
     console.log(`${GREEN}✓${RESET} ${name}`);
-    passed++;
+    incPassed();
   } else {
     console.log(`${RED}✗${RESET} ${name}`);
     console.log(`  Expected: ${expected}`);
     console.log(`  Actual:   ${actual}`);
-    failed++;
+    incFailed(name);
   }
 }
 
@@ -36,10 +65,10 @@ export function testThrows(name, fn) {
   try {
     fn();
     console.log(`${RED}✗${RESET} ${name} (expected to throw)`);
-    failed++;
+    incFailed(`${name} (expected to throw)`);
   } catch (e) {
     console.log(`${GREEN}✓${RESET} ${name}`);
-    passed++;
+    incPassed();
   }
 }
 
@@ -47,17 +76,32 @@ export function testDeep(name, actual, expected) {
   const pass = JSON.stringify(actual) === JSON.stringify(expected);
   if (pass) {
     console.log(`${GREEN}✓${RESET} ${name}`);
-    passed++;
+    incPassed();
   } else {
     console.log(`${RED}✗${RESET} ${name}`);
     console.log(`  Expected: ${JSON.stringify(expected)}`);
     console.log(`  Actual:   ${JSON.stringify(actual)}`);
-    failed++;
+    incFailed(name);
   }
 }
 
 export function summary() {
-  console.log(`\nPassed: ${passed}`);
-  console.log(`Failed: ${failed}`);
-  if (failed > 0) process.exit(1);
+  const s = specState();
+  const p = s ? s.passed : passed;
+  const f = s ? s.failed : failed;
+
+  console.log(`\nPassed: ${p}`);
+  console.log(`Failed: ${f}`);
+
+  const hook = specHook();
+  if (hook && hook.current && typeof hook.onSummary === 'function') {
+    hook.onSummary({
+      passed: p,
+      failed: f,
+      failures: hook.current.failures.slice()
+    });
+    return;
+  }
+
+  if (f > 0) process.exit(1);
 }
diff --git a/examples/spec/import_abs_target.js b/examples/spec/import_abs_target.js
new file mode 100644
index 0000000..78f2b4d
--- /dev/null
+++ b/examples/spec/import_abs_target.js
@@ -0,0 +1 @@
+export const marker = 'abs-import-ok';
diff --git a/examples/spec/map.js b/examples/spec/map.js
index b07ddfa..e3ee713 100644
--- a/examples/spec/map.js
+++ b/examples/spec/map.js
@@ -8,7 +8,7 @@ map.set('key1', 'value1');
 map.set('key2', 42);
 map.set('key3', true);
 
-test('map size after set', map.size(), 3);
+test('map size after set', map.size, 3);
 test('map get string', map.get('key1'), 'value1');
 test('map get number', map.get('key2'), 42);
 test('map get boolean', map.get('key3'), true);
@@ -18,13 +18,13 @@ test('map has missing', map.has('missing'), false);
 
 test('map delete returns true', map.delete('key2'), true);
 test('map has after delete', map.has('key2'), false);
-test('map size after delete', map.size(), 2);
+test('map size after delete', map.size, 2);
 
 map.set('key1', 'newvalue1');
 test('map get after overwrite', map.get('key1'), 'newvalue1');
 
 map.clear();
-test('map size after clear', map.size(), 0);
+test('map size after clear', map.size, 0);
 test('map has after clear', map.has('key1'), false);
 
 map.set(123, 'number key');
@@ -34,11 +34,11 @@ map.set(null, 'null key');
 test('map get number key', map.get(123), 'number key');
 test('map get boolean key', map.get(true), 'boolean key');
 test('map get null key', map.get(null), 'null key');
-test('map size with varied keys', map.size(), 3);
+test('map size with varied keys', map.size, 3);
 
 map.clear();
 map.set('a', 1).set('b', 2).set('c', 3);
-test('map chaining size', map.size(), 3);
+test('map chaining size', map.size, 3);
 test('map chaining get', map.get('b'), 2);
 
 test('map get undefined key', map.get('nonexistent'), undefined);
diff --git a/examples/spec/modules.js b/examples/spec/modules.js
index 38273d2..f43b400 100644
--- a/examples/spec/modules.js
+++ b/examples/spec/modules.js
@@ -13,7 +13,8 @@ console.log('Module Tests\n');
 
 test('import.meta exists', typeof import.meta, 'object');
 test('import.meta.url exists', typeof import.meta.url, 'string');
-test('import.meta.url is file', import.meta.url.startsWith('file://'), true);
+test('import.meta.url is file', import.meta.url.startsWith('file:'), true);
+test('import.meta.url points to modules.js', /\/modules\.js$/.test(import.meta.url), true);
 
 test('module imported test', typeof test, 'function');
 test('module imported summary', typeof summary, 'function');
@@ -41,4 +42,21 @@ test('JSON named import count', count, 42);
 test('text default import type', typeof textContent, 'string');
 test('text default import value', textContent, 'Hello from text file\n');
 
+const absTargetUrl = typeof import.meta.resolve === 'function'
+  ? import.meta.resolve('./import_abs_target.js')
+  : import.meta.url.replace(/\/modules\.js$/, '/import_abs_target.js');
+const absTargetLooksRight = /\/import_abs_target\.js$/.test(absTargetUrl);
+test('absolute file URL target resolves to fixture', absTargetLooksRight, true);
+
+if (absTargetLooksRight) {
+  try {
+    const absMod = await import(absTargetUrl);
+    test('dynamic import absolute file URL marker', absMod.marker, 'abs-import-ok');
+  } catch (e) {
+    const msg = String(e && (e.stack || e.message || e));
+    test('dynamic import absolute file URL works', false, true);
+    test('dynamic import absolute file URL error message', typeof msg, 'string');
+  }
+} else test('dynamic import absolute file URL works', false, true);
+
 summary();
diff --git a/examples/spec/performance.js b/examples/spec/performance.js
index 941bf60..54aa11c 100644
--- a/examples/spec/performance.js
+++ b/examples/spec/performance.js
@@ -16,6 +16,9 @@ test('now advances', t2 >= t1, true);
 
 test('timeOrigin exists', typeof performance.timeOrigin, 'number');
 test('timeOrigin positive', performance.timeOrigin > 0, true);
-test('timeOrigin before now', performance.timeOrigin <= Date.now(), true);
+
+const wallNow = Date.now();
+const perfNowEpoch = performance.timeOrigin + performance.now();
+test('timeOrigin aligns with now', Math.abs(perfNowEpoch - wallNow) < 1000, true);
 
 summary();
diff --git a/examples/spec/private_classes.js b/examples/spec/private_classes.js
index d2a19b8..9ea7777 100644
--- a/examples/spec/private_classes.js
+++ b/examples/spec/private_classes.js
@@ -2,7 +2,6 @@ import { test, summary } from './helpers.js';
 
 console.log('Private Class Tests\n');
 
-// Private instance fields
 class Counter {
   #count = 0;
   increment() { this.#count++; }
@@ -14,7 +13,6 @@ counter.increment();
 counter.increment();
 test('private field after increment', counter.value, 2);
 
-// Private field with constructor
 class Box {
   #content;
   constructor(val) { this.#content = val; }
@@ -23,7 +21,6 @@ class Box {
 test('private field via constructor', new Box(42).unwrap(), 42);
 test('private field string', new Box('hello').unwrap(), 'hello');
 
-// Private field does not collide with public
 class Dual {
   #x = 'private';
   x = 'public';
@@ -34,7 +31,6 @@ const dual = new Dual();
 test('private vs public field', dual.getPrivate(), 'private');
 test('public field unaffected', dual.getPublic(), 'public');
 
-// Private instance methods
 class Formatter {
   #prefix;
   constructor(prefix) { this.#prefix = prefix; }
@@ -43,14 +39,12 @@ class Formatter {
 }
 test('private method', new Formatter('LOG').display('test'), 'LOG: test');
 
-// Private method does not collide with public
 class Methods {
   #x() { return 'private'; }
   x() { return this.#x(); }
 }
 test('private method call', new Methods().x(), 'private');
 
-// Private getters and setters
 class Temperature {
   #celsius = 0;
   get #c() { return this.#celsius; }
@@ -63,14 +57,12 @@ test('private getter initial', temp.fahrenheit, 32);
 temp.fahrenheit = 212;
 test('private setter', temp.fahrenheit, 212);
 
-// Private static methods
 class MathHelper {
   static #square(n) { return n * n; }
   static calc(n) { return MathHelper.#square(n); }
 }
 test('private static method', MathHelper.calc(5), 25);
 
-// Private static accessors
 class Config {
   static #data = null;
   static get #config() { return Config.#data || 'default'; }
@@ -82,7 +74,6 @@ test('private static getter default', Config.get(), 'default');
 Config.set('custom');
 test('private static setter', Config.get(), 'custom');
 
-// Private static fields
 class IdGen {
   static #next = 1;
   static generate() { return IdGen.#next++; }
@@ -91,7 +82,6 @@ test('private static field 1', IdGen.generate(), 1);
 test('private static field 2', IdGen.generate(), 2);
 test('private static field 3', IdGen.generate(), 3);
 
-// Computed instance fields
 class Computed {
   ['x'] = 10;
   ['y'] = 20;
@@ -100,7 +90,6 @@ const comp = new Computed();
 test('computed instance field x', comp.x, 10);
 test('computed instance field y', comp.y, 20);
 
-// Computed static fields
 class ComputedStatic {
   static ['a'] = 100;
   static ['b'] = 200;
@@ -108,7 +97,6 @@ class ComputedStatic {
 test('computed static field a', ComputedStatic.a, 100);
 test('computed static field b', ComputedStatic.b, 200);
 
-// Static initialization blocks
 let staticVal = 0;
 class WithStaticBlock {
   static { staticVal = 42; }
@@ -122,7 +110,6 @@ class MultiBlock {
 }
 test('multiple static blocks', staticSum, 30);
 
-// Inheritance with private fields
 class Animal {
   #name;
   constructor(name) { this.#name = name; }
diff --git a/examples/spec/run.js b/examples/spec/run.js
index a43ee72..7800aea 100644
--- a/examples/spec/run.js
+++ b/examples/spec/run.js
@@ -1,21 +1,62 @@
 import fs from 'ant:fs';
 import path from 'ant:path';
-import { $ } from 'ant:shell';
 
 const GREEN = '\x1b[32m';
 const RED = '\x1b[31m';
 const CYAN = '\x1b[36m';
-const PINK = '\x1b[35m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
 const specDir = path.dirname(import.meta.url.replace('file://', ''));
-const files = fs
+const nonSpecFiles = new Set(['run.js', 'helpers.js', 'import_abs_target.js']);
+
+const allFiles = fs
   .readdirSync(specDir)
-  .filter(f => f.endsWith('.js') && f !== 'run.js' && f !== 'helpers.js')
+  .filter(f => f.endsWith('.js') && !nonSpecFiles.has(f))
   .sort();
 
+const cliArgs = process.argv.slice(2);
+const runAll = cliArgs.includes('--all');
+const requestedSpecs = cliArgs.filter(arg => arg !== '--all');
+
+function normalizeSpecName(arg) {
+  const base = path.basename(arg);
+  return base.endsWith('.js') ? base.slice(0, -3) : base;
+}
+
+const fileByName = new Map(allFiles.map(file => [path.basename(file, '.js'), file]));
+const files = (() => {
+  if (!runAll && requestedSpecs.length === 0) {
+    console.log(`${RED}No specs selected.${RESET} Use ${BOLD}--all${RESET} or pass one or more spec names.`);
+    process.exit(1);
+  }
+  if (runAll) return allFiles;
+
+  const selected = [];
+  const seen = new Set();
+  const missing = [];
+
+  for (const raw of requestedSpecs) {
+    const name = normalizeSpecName(raw);
+    const file = fileByName.get(name);
+
+    if (!file) {
+      missing.push(raw);
+      continue;
+    }
+
+    if (seen.has(file)) continue;
+    seen.add(file);
+    selected.push(file);
+  }
+
+  if (missing.length > 0) console.log(`${RED}Unknown spec file(s):${RESET} ${missing.join(', ')}`);
+  if (selected.length === 0) process.exit(1);
+
+  return selected;
+})();
+
 let totalPassed = 0;
 let totalFailed = 0;
 
@@ -23,44 +64,67 @@ let filesPassed = 0;
 let filesFailed = 0;
 
 const fileTimes = [];
+const failedTests = [];
 
 console.log(`\n${BOLD}${CYAN}Running ${files.length} spec files...${RESET}\n`);
-
 const totalStart = performance.now();
 
-for (const file of files) {
-  const filePath = path.join(specDir, file);
-  const name = path.basename(file, '.js');
-
-  const start = performance.now();
-  try {
-    const result = $`./build/ant ${filePath}`;
-    const elapsed = performance.now() - start;
-    const output = result.text();
-    console.log(output);
-
-    const passedMatch = output.match(/Passed:\s*(\d+)/);
-    const failedMatch = output.match(/Failed:\s*(\d+)/);
-
-    if (passedMatch) totalPassed += parseInt(passedMatch[1], 10);
-    if (failedMatch) totalFailed += parseInt(failedMatch[1], 10);
-
-    if (result.exitCode === 0) {
-      console.log(`${GREEN}✓${RESET} ${name} ${DIM}(${elapsed.toFixed(0)}ms)${RESET}\n`);
-      filesPassed++;
-    } else {
-      console.log(`${RED}✗${RESET} ${name} ${DIM}(${elapsed.toFixed(0)}ms)${RESET}\n`);
+async function runInProcessMode() {
+  const hook = {
+    current: null,
+    onSummary: null
+  };
+  globalThis.__ANT_SPEC_HOOK__ = hook;
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const name = path.basename(file, '.js');
+    const fileUrl = `./${file}`;
+    const start = performance.now();
+
+    hook.current = { passed: 0, failed: 0, failures: [] };
+    let summaryResolve;
+    const summaryP = new Promise(resolve => {
+      summaryResolve = resolve;
+    });
+    hook.onSummary = summaryResolve;
+
+    try {
+      await import(fileUrl);
+      const result = await summaryP;
+      const elapsed = performance.now() - start;
+
+      totalPassed += result.passed;
+      totalFailed += result.failed;
+      if (result.failures.length > 0) {
+        failedTests.push({ name, failures: result.failures });
+      }
+
+      if (result.failed === 0) {
+        console.log(`${GREEN}✓${RESET} ${name} ${DIM}(${elapsed.toFixed(0)}ms)${RESET}\n`);
+        filesPassed++;
+      } else {
+        console.log(`${RED}✗${RESET} ${name} ${DIM}(${elapsed.toFixed(0)}ms)${RESET}\n`);
+        filesFailed++;
+      }
+      fileTimes.push({ name, elapsed });
+    } catch (e) {
+      const elapsed = performance.now() - start;
+      console.log(`${RED}✗${RESET} ${name} ${DIM}(error, ${elapsed.toFixed(0)}ms)${RESET}\n`);
+      if (e && e.stack) console.log(String(e.stack));
+      else console.log(String(e));
       filesFailed++;
+      totalFailed++;
+      failedTests.push({ name, failures: [`${RED}✗${RESET} import/exec error`] });
+      fileTimes.push({ name, elapsed });
+    } finally {
+      hook.onSummary = null;
+      hook.current = null;
     }
-    fileTimes.push({ name, elapsed });
-  } catch (e) {
-    const elapsed = performance.now() - start;
-    console.log(`${RED}✗${RESET} ${name} ${DIM}(error, ${elapsed.toFixed(0)}ms)${RESET}\n`);
-    filesFailed++;
-    fileTimes.push({ name, elapsed });
   }
 }
 
+await runInProcessMode();
 const totalElapsed = performance.now() - totalStart;
 
 console.log(`\n${BOLD}Results:${RESET}`);
@@ -70,10 +134,16 @@ console.log(`  ${GREEN}${filesPassed} files passed${RESET}`);
 console.log(`  ${RED}${filesFailed} files failed${RESET}`);
 
 console.log(`\n${BOLD}Timing:${RESET}`);
-for (const { name, elapsed } of fileTimes) {
-  console.log(`  ${DIM}${name.padEnd(30)}${RESET} ${elapsed.toFixed(0)}ms`);
-}
+for (const { name, elapsed } of fileTimes) console.log(`  ${DIM}${name.padEnd(30)}${RESET} ${elapsed.toFixed(0)}ms`);
 console.log(`\n  ${BOLD}Total${RESET}${' '.padEnd(26)}${totalElapsed.toFixed(0)}ms\n`);
-console.log(`${PINK}Welcome to ES6!${RESET}`);
+
+if (failedTests.length > 0) {
+  console.log(`${BOLD}${RED}Failed Tests:${RESET}`);
+  for (const { name, failures } of failedTests) {
+    console.log(`\n  ${BOLD}${name}${RESET}`);
+    for (const line of failures) console.log(`    ${line.trim()}`);
+  }
+  console.log();
+}
 
 process.exit(totalFailed > 0 ? 1 : 0);
diff --git a/examples/spec/set.js b/examples/spec/set.js
index 8fc2587..192db42 100644
--- a/examples/spec/set.js
+++ b/examples/spec/set.js
@@ -9,7 +9,7 @@ set.add('value2');
 set.add(42);
 set.add(true);
 
-test('set size after add', set.size(), 4);
+test('set size after add', set.size, 4);
 test('set has string', set.has('value1'), true);
 test('set has number', set.has(42), true);
 test('set has boolean', set.has(true), true);
@@ -17,24 +17,24 @@ test('set has missing', set.has('missing'), false);
 
 test('set delete returns true', set.delete('value2'), true);
 test('set has after delete', set.has('value2'), false);
-test('set size after delete', set.size(), 3);
+test('set size after delete', set.size, 3);
 
 set.add('value1');
-test('set size after duplicate', set.size(), 3);
+test('set size after duplicate', set.size, 3);
 
 set.add(123);
 set.add(null);
 
 test('set has 123', set.has(123), true);
 test('set has null', set.has(null), true);
-test('set size after more adds', set.size(), 5);
+test('set size after more adds', set.size, 5);
 
 set.clear();
-test('set size after clear', set.size(), 0);
+test('set size after clear', set.size, 0);
 test('set has after clear', set.has('value1'), false);
 
 set.add('a').add('b').add('c');
-test('set chaining size', set.size(), 3);
+test('set chaining size', set.size, 3);
 test('set chaining has a', set.has('a'), true);
 test('set chaining has b', set.has('b'), true);
 test('set chaining has c', set.has('c'), true);
diff --git a/examples/spec/strings.js b/examples/spec/strings.js
index 5efebd5..eb0584c 100644
--- a/examples/spec/strings.js
+++ b/examples/spec/strings.js
@@ -81,12 +81,31 @@ test('concat', 'hello'.concat(' ', 'world'), 'hello world');
 test('lastIndexOf', 'hello world world'.lastIndexOf('world'), 12);
 
 test('String.fromCharCode', String.fromCharCode(65, 66, 67), 'ABC');
+test('String.raw tagged template', String.raw`line1\nline2`, 'line1\\nline2');
+test('String.raw substitutions', String.raw({ raw: ['a', 'b', 'c'] }, 1, 2), 'a1b2c');
 
 test('empty string length', ''.length, 0);
 test('empty indexOf', ''.indexOf('x'), -1);
 test('empty includes empty', ''.includes(''), true);
 test('empty startsWith empty', ''.startsWith(''), true);
 
+let nfc = '\u0041\u006d\u0065\u0301\u006c\u0069\u0065';
+test('normalize default (NFC)', nfc.normalize(), 'Am\u00E9lie');
+test('normalize NFC explicit', nfc.normalize('NFC'), 'Am\u00E9lie');
+
+let composed = 'Am\u00E9lie';
+test('normalize NFD', composed.normalize('NFD'), 'Ame\u0301lie');
+
+test('normalize NFKC fi ligature', '\uFB01'.normalize('NFKC'), 'fi');
+test('normalize NFKC fullwidth', '\uFF21'.normalize('NFKC'), 'A');
+
+test('normalize NFKD fi ligature', '\uFB01'.normalize('NFKD'), 'fi');
+test('normalize NFKD fullwidth', '\uFF21'.normalize('NFKD'), 'A');
+
+test('normalize empty string', ''.normalize(), '');
+test('normalize ascii passthrough', 'hello'.normalize(), 'hello');
+test('normalize no arg same as NFC', '\u00E9'.normalize(), '\u00E9');
+
 let template = `Value: ${1 + 2}`;
 test('template literal', template, 'Value: 3');
 
diff --git a/examples/spec/timers.js b/examples/spec/timers.js
index be0d5ca..7f80e18 100644
--- a/examples/spec/timers.js
+++ b/examples/spec/timers.js
@@ -3,6 +3,10 @@ import { test, summary } from './helpers.js';
 console.log('Timer Tests\n');
 
 let results = {};
+let intervalDoneResolve;
+const intervalDone = new Promise(resolve => {
+  intervalDoneResolve = resolve;
+});
 
 setTimeout(() => {
   results.timeout = true;
@@ -14,6 +18,7 @@ const interval = setInterval(() => {
   if (count >= 3) {
     clearInterval(interval);
     results.interval = count;
+    intervalDoneResolve();
   }
 }, 10);
 
@@ -30,11 +35,14 @@ queueMicrotask(() => {
   results.microtask = true;
 });
 
-setTimeout(() => {
+Promise.all([
+  new Promise(resolve => setTimeout(resolve, 10)),
+  intervalDone,
+]).then(() => {
   test('setTimeout fired', results.timeout, true);
   test('setInterval count', results.interval, 3);
   test('clearTimeout worked', results.canceled, undefined);
   test('setImmediate fired', results.immediate, true);
   test('queueMicrotask fired', results.microtask, true);
   summary();
-}, 100);
+});
diff --git a/examples/spec/tla.js b/examples/spec/tla.js
new file mode 100644
index 0000000..d0427b3
--- /dev/null
+++ b/examples/spec/tla.js
@@ -0,0 +1,63 @@
+import { test, testDeep, summary } from './helpers.js';
+
+console.log('Top-Level Await Tests\n');
+
+// basic TLA with promise
+const basic = await Promise.resolve(42);
+test('basic TLA', basic, 42);
+
+// TLA with async function call
+async function getValue() { return 'hello'; }
+const fromAsync = await getValue();
+test('TLA await async function', fromAsync, 'hello');
+
+// TLA sequential awaits
+const a = await Promise.resolve(1);
+const b = await Promise.resolve(2);
+const c = await Promise.resolve(3);
+test('TLA sequential awaits', a + b + c, 6);
+
+// TLA with non-promise (should pass through)
+const plain = await 99;
+test('TLA await non-promise', plain, 99);
+
+// TLA with chained promise
+const chained = await Promise.resolve(1).then(v => v + 1).then(v => v + 1);
+test('TLA chained promise', chained, 3);
+
+// TLA preserves execution order
+const order = [];
+order.push(1);
+await Promise.resolve();
+order.push(2);
+await Promise.resolve();
+order.push(3);
+testDeep('TLA preserves order', order, [1, 2, 3]);
+
+// TLA with Promise.all
+const [x, y, z] = await Promise.all([
+  Promise.resolve('a'),
+  Promise.resolve('b'),
+  Promise.resolve('c'),
+]);
+test('TLA Promise.all destructuring', x + y + z, 'abc');
+
+// TLA error handling with try/catch
+let caught = null;
+try {
+  await Promise.reject('tla error');
+} catch (e) {
+  caught = e;
+}
+test('TLA try/catch rejection', caught, 'tla error');
+
+// TLA with setTimeout promise
+const delayed = await new Promise(resolve => setTimeout(() => resolve('delayed'), 10));
+test('TLA with setTimeout', delayed, 'delayed');
+
+// TLA in conditional
+const flag = true;
+const conditional = flag ? await Promise.resolve('yes') : 'no';
+test('TLA in conditional', conditional, 'yes');
+
+summary();
diff --git a/examples/spec/tty.js b/examples/spec/tty.js
new file mode 100644
index 0000000..8dbc51e
--- /dev/null
+++ b/examples/spec/tty.js
@@ -0,0 +1,90 @@
+import { test, testThrows, summary } from './helpers.js';
+import * as tty from 'node:tty';
+
+console.log('TTY Tests\n');
+
+test('tty module exists', typeof tty, 'object');
+test('tty toStringTag', Object.prototype.toString.call(tty), '[object tty]');
+test('tty.isatty is function', typeof tty.isatty, 'function');
+test('tty.ReadStream is function', typeof tty.ReadStream, 'function');
+test('tty.WriteStream is function', typeof tty.WriteStream, 'function');
+
+test('tty.isatty(-1) is false', tty.isatty(-1), false);
+test('tty.isatty(0) is boolean', typeof tty.isatty(0), 'boolean');
+test('tty.isatty(1) is boolean', typeof tty.isatty(1), 'boolean');
+test('tty.isatty(2) is boolean', typeof tty.isatty(2), 'boolean');
+
+test('stdin has fd', typeof process.stdin.fd, 'number');
+test('stdout has fd', typeof process.stdout.fd, 'number');
+test('stderr has fd', typeof process.stderr.fd, 'number');
+
+test('stdin toStringTag', Object.prototype.toString.call(process.stdin), '[object ReadStream]');
+test('stdout toStringTag', Object.prototype.toString.call(process.stdout), '[object WriteStream]');
+test('stderr toStringTag', Object.prototype.toString.call(process.stderr), '[object WriteStream]');
+
+test('stdin.setRawMode is function', typeof process.stdin.setRawMode, 'function');
+test('stdout.clearLine is function', typeof process.stdout.clearLine, 'function');
+test('stdout.clearScreenDown is function', typeof process.stdout.clearScreenDown, 'function');
+test('stdout.cursorTo is function', typeof process.stdout.cursorTo, 'function');
+test('stdout.moveCursor is function', typeof process.stdout.moveCursor, 'function');
+test('stdout.getWindowSize is function', typeof process.stdout.getWindowSize, 'function');
+test('stdout.getColorDepth is function', typeof process.stdout.getColorDepth, 'function');
+test('stdout.hasColors is function', typeof process.stdout.hasColors, 'function');
+
+const ws = process.stdout.getWindowSize();
+test('getWindowSize returns array', Array.isArray(ws), true);
+test('getWindowSize length is 2', ws.length, 2);
+test('getWindowSize cols is number', typeof ws[0], 'number');
+test('getWindowSize rows is number', typeof ws[1], 'number');
+
+const depthDefault = process.stdout.getColorDepth();
+test('getColorDepth returns number', typeof depthDefault, 'number');
+test('getColorDepth returns valid depth', [1, 4, 8, 24].includes(depthDefault), true);
+
+const depthForced = process.stdout.getColorDepth({ FORCE_COLOR: '3' });
+test('getColorDepth(force truecolor) = 24', depthForced, 24);
+const depthNoColor = process.stdout.getColorDepth({ NO_COLOR: '1' });
+test('getColorDepth(NO_COLOR) = 1', depthNoColor, 1);
+
+test('hasColors() returns boolean', typeof process.stdout.hasColors(), 'boolean');
+test('hasColors(force truecolor) supports 16m', process.stdout.hasColors(16777216, { FORCE_COLOR: '3' }), true);
+test('hasColors(NO_COLOR) rejects 16 colors', process.stdout.hasColors(16, { NO_COLOR: '1' }), false);
+
+const clearLineResult = process.stdout.clearLine(0);
+test('clearLine returns stream', clearLineResult, process.stdout);
+const clearDownResult = process.stdout.clearScreenDown();
+test('clearScreenDown returns stream', clearDownResult, process.stdout);
+const cursorToResult = process.stdout.cursorTo(0);
+test('cursorTo returns stream', cursorToResult, process.stdout);
+const moveCursorResult = process.stdout.moveCursor(0, 0);
+test('moveCursor returns stream', moveCursorResult, process.stdout);
+
+if (process.stdin.isTTY) {
+  const stdinCtor = new tty.ReadStream(0);
+  test('new ReadStream(0) returns stdin-like stream', Object.prototype.toString.call(stdinCtor), '[object ReadStream]');
+  test('ReadStream constructor reuses stdin stream', stdinCtor === process.stdin, true);
+
+  const rawResult = process.stdin.setRawMode(false);
+  test('stdin.setRawMode returns this', rawResult, process.stdin);
+  test('stdin.isRaw is boolean', typeof process.stdin.isRaw, 'boolean');
+} else {
+  testThrows('new ReadStream(0) throws when stdin is not TTY', () => new tty.ReadStream(0));
+}
+
+if (process.stdout.isTTY) {
+  const stdoutCtor = new tty.WriteStream(1);
+  test('new WriteStream(1) returns stdout-like stream', Object.prototype.toString.call(stdoutCtor), '[object WriteStream]');
+  test('WriteStream constructor reuses stdout stream', stdoutCtor === process.stdout, true);
+} else {
+  testThrows('new WriteStream(1) throws when stdout is not TTY', () => new tty.WriteStream(1));
+}
+
+if (process.stderr.isTTY) {
+  const stderrCtor = new tty.WriteStream(2);
+  test('new WriteStream(2) returns stderr-like stream', Object.prototype.toString.call(stderrCtor), '[object WriteStream]');
+  test('WriteStream constructor reuses stderr stream', stderrCtor === process.stderr, true);
+} else {
+  testThrows('new WriteStream(2) throws when stderr is not TTY', () => new tty.WriteStream(2));
+}
+
+summary();
diff --git a/examples/spec/worker_threads.js b/examples/spec/worker_threads.js
new file mode 100644
index 0000000..e7ce840
--- /dev/null
+++ b/examples/spec/worker_threads.js
@@ -0,0 +1,87 @@
+import { test, testDeep, summary } from './helpers.js';
+import {
+  Worker,
+  MessageChannel,
+  isMainThread,
+  parentPort,
+  workerData,
+  receiveMessageOnPort,
+  setEnvironmentData,
+  getEnvironmentData,
+  moveMessagePortToContext
+} from 'node:worker_threads';
+
+console.log('Worker Threads Tests\n');
+
+async function run() {
+  test('isMainThread in main context', isMainThread, true);
+  test('parentPort is null in main context', parentPort, null);
+  test('workerData is undefined in main context', workerData, undefined);
+
+  const ch1 = new MessageChannel();
+  test('MessageChannel has port1', typeof ch1.port1, 'object');
+  test('MessageChannel has port2', typeof ch1.port2, 'object');
+
+  ch1.port1.postMessage({ hello: 'queue' });
+  const queued = receiveMessageOnPort(ch1.port2);
+  testDeep('receiveMessageOnPort returns message envelope', queued, { message: { hello: 'queue' } });
+  test('receiveMessageOnPort returns undefined when empty', receiveMessageOnPort(ch1.port2), undefined);
+
+  const ch2 = new MessageChannel();
+  const seen = [];
+  ch2.port1.postMessage('queued-before-listener');
+  ch2.port2.on('message', msg => {
+    seen.push(`on:${msg}`);
+  });
+  ch2.port2.once('message', msg => {
+    seen.push(`once:${msg}`);
+  });
+  ch2.port1.postMessage('next');
+  ch2.port1.postMessage('final');
+  testDeep('MessagePort queue drains in FIFO order', seen, ['on:queued-before-listener', 'on:next', 'once:next', 'on:final']);
+
+  let onmessageData = undefined;
+  ch2.port2.onmessage = event => {
+    onmessageData = event.data;
+  };
+  ch2.port1.postMessage('event-data');
+  test('MessagePort onmessage receives event.data', onmessageData, 'event-data');
+
+  const moved = moveMessagePortToContext(ch2.port1, globalThis);
+  test('moveMessagePortToContext returns same port', moved, ch2.port1);
+
+  const shared = { answer: 42, ok: true };
+  setEnvironmentData('shared-key', shared);
+  testDeep('getEnvironmentData in main context', getEnvironmentData('shared-key'), shared);
+
+  const workerUrl = new URL('./worker_threads.worker.mjs', import.meta.url);
+  const payload = { hello: 'world', n: 42, arr: [1, 2, 3] };
+
+  const worker = new Worker(workerUrl, { workerData: payload });
+  test('Worker constructor returns object', typeof worker, 'object');
+  test('Worker has once method', typeof worker.once, 'function');
+  test('Worker has terminate method', typeof worker.terminate, 'function');
+
+  worker.unref();
+  worker.ref();
+
+  const message = await new Promise((resolve, reject) => {
+    worker.once('message', resolve);
+    worker.once('exit', code => {
+      if (code !== 0) reject(new Error(`worker exited early with code ${code}`));
+    });
+  });
+
+  test('worker replied success flag', message.ok, true);
+  test('worker isMainThread false in worker context', message.isMainThread, false);
+  test('worker has parentPort in worker context', message.hasParentPort, true);
+  testDeep('workerData round-trip', message.workerData, payload);
+  testDeep('worker getEnvironmentData snapshot', message.environmentData, shared);
+
+  const exitCode = await worker.terminate();
+  test('terminate resolves to numeric exit code', typeof exitCode, 'number');
+
+  summary();
+}
+
+void run();
diff --git a/examples/spec/worker_threads.worker.mjs b/examples/spec/worker_threads.worker.mjs
new file mode 100644
index 0000000..2f48a61
--- /dev/null
+++ b/examples/spec/worker_threads.worker.mjs
@@ -0,0 +1,12 @@
+import { parentPort, workerData, isMainThread, getEnvironmentData } from 'node:worker_threads';
+
+if (parentPort) {
+  parentPort.postMessage({
+    ok: true,
+    isMainThread,
+    hasParentPort: parentPort !== null,
+    workerData,
+    environmentData: getEnvironmentData('shared-key')
+  });
+  parentPort.unref();
+}
diff --git a/examples/test262/bench.js b/examples/test262/bench.js
new file mode 100644
index 0000000..3721a88
--- /dev/null
+++ b/examples/test262/bench.js
@@ -0,0 +1,10 @@
+import { readFileSync } from 'node:fs';
+import { performance } from 'node:perf_hooks';
+
+const t0 = performance.now();
+const raw = readFileSync(new URL('./ant.json', import.meta.url), 'utf-8');
+console.log('Load:', (performance.now() - t0).toFixed(2), 'ms');
+
+const t1 = performance.now();
+JSON.parse(raw);
+console.log('Parse:', (performance.now() - t1).toFixed(2), 'ms');
diff --git a/examples/test262/index.js b/examples/test262/index.js
index 2e7bbbf..4e7c06a 100755
--- a/examples/test262/index.js
+++ b/examples/test262/index.js
@@ -221,14 +221,12 @@ function buildScreen() {
     lines.push(`  Max:      ${c.bold}${fmt(mem.cstack)}${c.reset}`);
     lines.push('');
 
-    lines.push(`${c.dim}Press 'g' to run GC${c.reset}`);
-
     while (lines.length < rows - 2) {
       lines.push('');
     }
 
     lines.push('');
-    lines.push(`${c.dim}m browse · g gc · q quit${c.reset}  ${c.cyan}${fps.current} fps${c.reset}`);
+    lines.push(`${c.dim}m browse · q quit${c.reset}  ${c.cyan}${fps.current} fps${c.reset}`);
   }
 
   return lines.map(l => pad(l, cols)).join('\n');
@@ -309,11 +307,7 @@ function handleKey(key) {
       needsRender = true;
       break;
     case 'g':
-      if (state.mode === 'memory') {
-        Ant.gc();
-      } else {
-        state.index = 0;
-      }
+      state.index = 0;
       needsRender = true;
       break;
     case 'G':
diff --git a/examples/tui/index.js b/examples/tui/index.js
index cdbd31d..0796dad 100644
--- a/examples/tui/index.js
+++ b/examples/tui/index.js
@@ -1,4 +1,20 @@
-import { Screen, List, ProgressBar, Input, Table, colors, box, keys, codes, modal, confirm, pad, padCenter, truncate, visibleLength } from './tuey.js';
+import {
+  Screen,
+  List,
+  ProgressBar,
+  Input,
+  Table,
+  colors,
+  box,
+  keys,
+  codes,
+  modal,
+  confirm,
+  pad,
+  padCenter,
+  truncate,
+  visibleLength
+} from './tuey.js';
 
 const screen = new Screen({ fullscreen: true, hideCursor: true });
 
@@ -46,8 +62,8 @@ const settings = [
   { key: 'logInterval', label: 'Log Interval', type: 'cycle', options: [1000, 2000, 5000, 10000], value: 2000, format: v => `${v / 1000}s` },
   { key: 'logLevel', label: 'Min Log Level', type: 'cycle', options: ['DEBUG', 'INFO', 'WARN', 'ERROR'], value: 'DEBUG', format: v => v },
   { key: 'boxStyle', label: 'Box Style', type: 'cycle', options: ['rounded', 'light', 'heavy', 'double'], value: 'rounded', format: v => v },
-  { key: 'confirmQuit', label: 'Confirm on Quit', type: 'toggle', value: true, format: v => v ? 'On' : 'Off' },
-  { key: 'simulateStats', label: 'Simulate Stats', type: 'toggle', value: true, format: v => v ? 'On' : 'Off' },
+  { key: 'confirmQuit', label: 'Confirm on Quit', type: 'toggle', value: true, format: v => (v ? 'On' : 'Off') },
+  { key: 'simulateStats', label: 'Simulate Stats', type: 'toggle', value: true, format: v => (v ? 'On' : 'Off') },
   { key: 'maxLogs', label: 'Max Log Entries', type: 'cycle', options: [50, 100, 250, 500], value: 100, format: v => String(v) }
 ];
 
@@ -207,7 +223,11 @@ function drawDashboard() {
   for (let i = 0; i < recentLogs.length; i++) {
     const log = recentLogs[i];
     const levelColor = log.level === 'ERROR' ? colors.red : log.level === 'WARN' ? colors.yellow : log.level === 'DEBUG' ? colors.cyan : colors.green;
-    screen.write(4, 17 + i, `${colors.dim}${log.time}${codes.reset} ${levelColor}${pad(log.level, 5)}${codes.reset} ${truncate(log.message, rcw - 16)}`);
+    screen.write(
+      4,
+      17 + i,
+      `${colors.dim}${log.time}${codes.reset} ${levelColor}${pad(log.level, 5)}${codes.reset} ${truncate(log.message, rcw - 16)}`
+    );
   }
 
   const qw = 30;
@@ -378,10 +398,6 @@ function showMemoryModal() {
       if (key === 'm' || key === keys.ESCAPE) {
         screen.popModal('memory');
         render();
-      } else if (key === 'g') {
-        Ant.gc();
-        screen.popModal('memory');
-        showMemoryModal();
       }
       return false;
     },
@@ -421,7 +437,7 @@ function showMemoryModal() {
       buf.writeStyled(ox, oy + y++, `  Max:         ${colors.bold}${fmt(mem.cstack)}${codes.reset}`);
       y++;
 
-      buf.writeStyled(ox, oy + y, colors.dim + '  g: Run GC  m/Esc: Close' + codes.reset);
+      buf.writeStyled(ox, oy + y, colors.dim + '  m/Esc: Close' + codes.reset);
     }
   });
   screen.render();
diff --git a/include/ant.h b/include/ant.h
index 3659df4..d414403 100644
--- a/include/ant.h
+++ b/include/ant.h
@@ -33,24 +33,22 @@
 #define js_false   (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT))
 #define js_bool(x) (js_false | (jsval_t)!!(x))
 
-#define JS_DESC_W (1 << 0)
-#define JS_DESC_E (1 << 1)
-#define JS_DESC_C (1 << 2)
-
 ant_t *js_create(void *buf, size_t len);
 ant_t *js_create_dynamic();
 
 jsval_t js_glob(ant_t *);
-jsval_t js_mkscope(ant_t *);
-jsval_t js_getscope(ant_t *);
-jsval_t js_eval(ant_t *, const char *, size_t);
-jsval_t js_eval_cached(ant_t *, const char *, size_t);
+
+// TODO: improve naming
+jsval_t js_eval_bytecode(ant_t *, const char *, size_t);
+jsval_t js_eval_bytecode_module(ant_t *, const char *, size_t);
+jsval_t js_eval_bytecode_eval(ant_t *, const char *, size_t);
+jsval_t js_eval_bytecode_eval_with_strict(ant_t *, const char *, size_t, bool);
+jsval_t js_eval_bytecode_repl(ant_t *, const char *, size_t);
 
 void js_destroy(ant_t *);
-void js_delscope(ant_t *);
 bool js_truthy(ant_t *, jsval_t);
-void js_setstacklimit(ant_t *, size_t);
 void js_setstackbase(ant_t *, void *);
+void js_setstacklimit(ant_t *, size_t);
 
 uint32_t js_to_uint32(double d);
 int32_t js_to_int32(double d);
@@ -77,9 +75,10 @@ jsval_t js_getcurrentfunc(ant_t *);
 jsval_t js_get(ant_t *, jsval_t, const char *);
 jsval_t js_getprop_proto(ant_t *, jsval_t, const char *);
 jsval_t js_getprop_fallback(ant_t *js, jsval_t obj, const char *name);
+jsval_t js_getprop_super(ant_t *js, jsval_t super_obj, jsval_t receiver, const char *name);
 
-jsoff_t js_arr_len(struct js *js, jsval_t arr);
-jsval_t js_arr_get(struct js *js, jsval_t arr, jsoff_t idx);
+jsoff_t js_arr_len(ant_t *js, jsval_t arr);
+jsval_t js_arr_get(ant_t *js, jsval_t arr, jsoff_t idx);
 
 bool js_iter(
   ant_t *js, 
@@ -94,10 +93,11 @@ bool js_iter(
 
 uint64_t js_sym_id(jsval_t sym);
 const char *js_sym_desc(ant_t *js, jsval_t sym);
+const char *js_sym_key(jsval_t sym);
 
 jsval_t js_mksym_for(ant_t *, const char *key);
-jsval_t js_symbol_to_string(struct js *js, jsval_t sym);
-const char *js_sym_key(jsval_t sym);
+jsval_t js_symbol_to_string(ant_t *js, jsval_t sym);
+jsval_t js_get_sym(ant_t *, jsval_t obj, jsval_t sym);
 
 jsval_t js_mkobj(ant_t *);
 jsval_t js_newobj(ant_t *);
@@ -111,18 +111,16 @@ jsval_t js_heavy_mkfun(ant_t *js, jsval_t (*fn)(ant_t *, jsval_t *, int), jsval_
 jsval_t js_mkprop_fast(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v);
 jsoff_t js_mkprop_fast_off(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v);
 
-jsval_t js_call(ant_t *js, jsval_t func, jsval_t *args, int nargs);
-jsval_t js_call_with_this(ant_t *js, jsval_t func, jsval_t this_val, jsval_t *args, int nargs);
-
 void js_set(ant_t *, jsval_t, const char *, jsval_t);
+void js_set_sym(ant_t *, jsval_t obj, jsval_t sym, jsval_t val);
 void js_saveval(ant_t *js, jsoff_t off, jsval_t v);
 bool js_del(ant_t *, jsval_t obj, const char *key);
 void js_merge_obj(ant_t *, jsval_t dst, jsval_t src);
 void js_arr_push(ant_t *, jsval_t arr, jsval_t val);
+void js_set_proto(ant_t *, jsval_t obj, jsval_t proto);
 
 jsval_t js_setprop(ant_t *, jsval_t obj, jsval_t key, jsval_t val);
 jsval_t js_setprop_nonconfigurable(ant_t *, jsval_t obj, const char *key, size_t keylen, jsval_t val);
-void js_set_proto(ant_t *, jsval_t obj, jsval_t proto);
 
 jsval_t js_get_proto(ant_t *, jsval_t obj);
 jsval_t js_get_ctor_proto(ant_t *, const char *name, size_t len);
@@ -135,7 +133,7 @@ double js_getnum(jsval_t val);
 char *js_getstr(ant_t *js, jsval_t val, size_t *len);
 
 const char *js_str(ant_t *, jsval_t val);
-const char *get_str_prop(struct js *js, jsval_t obj, const char *key, jsoff_t klen, jsoff_t *out_len);
+const char *get_str_prop(ant_t *js, jsval_t obj, const char *key, jsoff_t klen, jsoff_t *out_len);
 
 typedef struct {
   void *ctx;
@@ -162,12 +160,6 @@ void js_check_unhandled_rejections(ant_t *js);
 void js_process_promise_handlers(ant_t *js, uint32_t promise_id);
 void js_setup_import_meta(ant_t *js, const char *filename);
 
-typedef jsval_t (*ant_library_init_fn)(ant_t *js);
-void ant_register_library(ant_library_init_fn init_fn, const char *name, ...);
-
-#define ant_standard_library(name, lib) \
-  ant_register_library(lib, name, "ant:" name, "node:" name, NULL)
-
 typedef jsval_t (*js_getter_fn)(ant_t *js, jsval_t obj, const char *key, size_t key_len);
 typedef bool (*js_setter_fn)(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t value);
 typedef bool (*js_deleter_fn)(ant_t *js, jsval_t obj, const char *key, size_t key_len);
@@ -178,11 +170,6 @@ void js_set_setter(ant_t *js, jsval_t obj, js_setter_fn setter);
 void js_set_deleter(ant_t *js, jsval_t obj, js_deleter_fn deleter);
 void js_set_keys(ant_t *js, jsval_t obj, js_keys_fn keys);
 
-void js_set_descriptor(ant_t *js, jsval_t obj, const char *key, size_t klen, int flags);
-void js_set_getter_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, int flags);
-void js_set_setter_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t setter, int flags);
-void js_set_accessor_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, jsval_t setter, int flags);
-
 jsval_t js_get_slot(ant_t *js, jsval_t obj, internal_slot_t slot);
 void js_set_slot(ant_t *js, jsval_t obj, internal_slot_t slot, jsval_t value);
 
diff --git a/include/arena.h b/include/arena.h
index 7497f48..9ac0123 100644
--- a/include/arena.h
+++ b/include/arena.h
@@ -21,11 +21,13 @@
 #define ARENA_GROW_INCREMENT (8ULL * 1024 * 1024)
 
 static inline void *mantissa_chk(void *p, const char *func) {
-  if (p && ((uintptr_t)p >> 48) != 0) {
-    fprintf(stderr, 
-      "FATAL: %s returned pointer %p outside 48-bit NaN-boxing range\n"
+  if (p && ((uintptr_t)p >> 47) != 0) {
+    fprintf(
+      stderr,
+      "FATAL: %s returned pointer %p outside 47-bit NaN-boxing range\n"
       "Please report this issue with your OS/architecture details.\n", func, p
-    ); abort();
+    );
+    abort();
   }
   
   return p;
diff --git a/include/cli/pkg.h b/include/cli/pkg.h
index 45361ca..34d1420 100644
--- a/include/cli/pkg.h
+++ b/include/cli/pkg.h
@@ -7,6 +7,7 @@ extern bool pkg_verbose;
 
 int pkg_cmd_init(int argc, char **argv);
 int pkg_cmd_install(int argc, char **argv);
+int pkg_cmd_update(int argc, char **argv);
 int pkg_cmd_add(int argc, char **argv);
 int pkg_cmd_remove(int argc, char **argv);
 int pkg_cmd_trust(int argc, char **argv);
diff --git a/include/common.h b/include/common.h
index f7f4635..ccd610d 100644
--- a/include/common.h
+++ b/include/common.h
@@ -12,13 +12,11 @@ typedef enum {
   SLOT_PID,
   SLOT_ASYNC,
   SLOT_WITH,
-  SLOT_SCOPE,
   SLOT_THIS,
   SLOT_NEW_TARGET,
   SLOT_BOUND_THIS,
   SLOT_BOUND_ARGS,
   SLOT_FIELD_COUNT,
-  SLOT_SOURCE,
   SLOT_FIELDS,
   SLOT_STRICT,
   SLOT_CODE,
@@ -52,13 +50,29 @@ typedef enum {
   SLOT_SUBSCRIPTION_CLEANUP,
   SLOT_HOISTED_VARS,
   SLOT_HOISTED_VARS_LEN,
-  SLOT_STRICT_EVAL_SCOPE,
-  SLOT_MODULE_SCOPE,
   SLOT_STRICT_ARGS,
   SLOT_NO_FUNC_DECLS,
   SLOT_ITER_STATE,
+  SLOT_BYTECODE,
   SLOT_ENTRIES,
   SLOT_DENSE_BUF,
+  SLOT_SETTLED,
+  SLOT_WT_ON_MESSAGE,
+  SLOT_WT_ONCE_MESSAGE,
+  SLOT_WT_ON_EXIT,
+  SLOT_WT_ONCE_EXIT,
+  SLOT_WT_PORT_TAG,
+  SLOT_WT_PORT_QUEUE,
+  SLOT_WT_PORT_HEAD,
+  SLOT_WT_PORT_PEER,
+  SLOT_WT_PORT_CLOSED,
+  SLOT_WT_PORT_STARTED,
+  SLOT_WT_PORT_ON_MESSAGE,
+  SLOT_WT_PORT_ONCE_MESSAGE,
+  SLOT_WT_PORT_PROTO,
+  SLOT_WT_ENV_STORE,
+  SLOT_NAPI_EXTERNAL_ID,
+  SLOT_NAPI_WRAP_ID,
   SLOT_MAX = 255
 } internal_slot_t;
 
diff --git a/include/debug.h b/include/debug.h
new file mode 100644
index 0000000..9b3bd83
--- /dev/null
+++ b/include/debug.h
@@ -0,0 +1,22 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <stdbool.h>
+
+typedef enum {
+  SV_DEBUG_DUMP_BYTECODE = 1u << 0,
+  SV_DEBUG_DUMP_JIT      = 1u << 1,
+  SV_DEBUG_JIT_WARN      = 1u << 2,
+} sv_debug_flag_t;
+
+bool sv_debug_enabled(sv_debug_flag_t flag);
+void sv_debug_enable(sv_debug_flag_t flag);
+void sv_debug_disable(sv_debug_flag_t flag);
+void sv_debug_set(sv_debug_flag_t flag, bool enabled);
+
+#define sv_debug_unlikely(flag)    __builtin_expect(sv_debug_enabled((flag)), 0)
+#define sv_dump_bytecode_unlikely  sv_debug_unlikely(SV_DEBUG_DUMP_BYTECODE)
+#define sv_dump_jit_unlikely       sv_debug_unlikely(SV_DEBUG_DUMP_JIT)
+#define sv_jit_warn_unlikely       sv_debug_unlikely(SV_DEBUG_JIT_WARN)
+
+#endif
diff --git a/include/descriptors.h b/include/descriptors.h
new file mode 100644
index 0000000..f9ed416
--- /dev/null
+++ b/include/descriptors.h
@@ -0,0 +1,43 @@
+#ifndef ANT_DESCRIPTORS_H
+#define ANT_DESCRIPTORS_H
+
+#include "types.h"
+#include <uthash.h>
+
+#define JS_DESC_W (1 << 0)
+#define JS_DESC_E (1 << 1)
+#define JS_DESC_C (1 << 2)
+
+typedef struct descriptor_entry {
+  uint64_t key;
+  jsoff_t obj_off;
+  jsoff_t sym_off;
+  char *prop_name;
+  size_t prop_len;
+  bool writable;
+  bool enumerable;
+  bool configurable;
+  bool has_getter;
+  bool has_setter;
+  jsval_t getter;
+  jsval_t setter;
+  UT_hash_handle hh;
+} descriptor_entry_t;
+
+extern descriptor_entry_t *desc_registry;
+
+descriptor_entry_t *lookup_descriptor(ant_t *js, jsoff_t obj_off, const char *key, size_t klen);
+descriptor_entry_t *lookup_sym_descriptor(jsoff_t obj_off, jsoff_t sym_off);
+
+uint64_t make_desc_key(jsoff_t obj_off, const char *key, size_t klen);
+uint64_t make_sym_desc_key(jsoff_t obj_off, jsoff_t sym_off);
+
+void js_set_descriptor(ant_t *js, jsval_t obj, const char *key, size_t klen, int flags);
+void js_set_getter_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, int flags);
+void js_set_setter_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t setter, int flags);
+void js_set_accessor_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, jsval_t setter, int flags);
+
+void js_set_sym_getter_desc(ant_t *js, jsval_t obj, jsval_t sym, jsval_t getter, int flags);
+void js_set_sym_setter_desc(ant_t *js, jsval_t obj, jsval_t sym, jsval_t setter, int flags);
+
+#endif
diff --git a/include/errors.h b/include/errors.h
index e2f8068..68ab4df 100644
--- a/include/errors.h
+++ b/include/errors.h
@@ -3,6 +3,9 @@
 
 #include "types.h"
 #include <stdio.h>
+#include <stdbool.h>
+
+typedef struct sv_func sv_func_t;
 
 #define ERR_FMT "\x1b[31m%.*s\x1b[0m: \x1b[1m%.*s\x1b[0m"
 #define ERR_NAME_ONLY "\x1b[31m%.*s\x1b[0m"
@@ -20,7 +23,24 @@ typedef enum {
 } js_err_type_t;
 
 js_err_type_t get_error_type(ant_t *js);
-void js_print_stack_trace(FILE *stream);
+
+bool print_uncaught_throw(ant_t *js);
+bool print_unhandled_promise_rejection(ant_t *js, jsval_t value);
+
+void js_clear_error_site(ant_t *js);
+void js_print_stack_trace_vm(ant_t *js, FILE *stream);
+void js_set_error_site_from_vm_top(ant_t *js);
+
+void js_set_error_site_from_bc(
+  ant_t *js, sv_func_t *func, 
+  int bc_offset, const char *filename
+);
+
+void js_set_error_site(
+  ant_t *js, const char *src,
+  jsoff_t src_len, const char *filename,
+  jsoff_t off, jsoff_t span_len
+);
 
 __attribute__((format(printf, 4, 5)))
 jsval_t js_create_error(ant_t *js, js_err_type_t err_type, jsval_t props, const char *fmt, ...);
@@ -30,4 +50,4 @@ jsval_t js_throw(ant_t *js, jsval_t value);
 #define js_mkerr_typed(js, err_type, ...) js_create_error(js, err_type, js_mkundef(), __VA_ARGS__)
 #define js_mkerr_props(js, err_type, props, ...) js_create_error(js, err_type, props, __VA_ARGS__)
 
-#endif
\ No newline at end of file
+#endif
diff --git a/include/esm/commonjs.h b/include/esm/commonjs.h
new file mode 100644
index 0000000..ff011a3
--- /dev/null
+++ b/include/esm/commonjs.h
@@ -0,0 +1,15 @@
+#ifndef ESM_COMMONJS_H
+#define ESM_COMMONJS_H
+
+#include "types.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+jsval_t esm_load_commonjs_module(
+  ant_t *js,
+  const char *module_path, const char *code,
+  size_t code_len, jsval_t ns
+);
+
+#endif
diff --git a/include/esm/library.h b/include/esm/library.h
new file mode 100644
index 0000000..f794452
--- /dev/null
+++ b/include/esm/library.h
@@ -0,0 +1,23 @@
+#ifndef ESM_LIBRARY_H
+#define ESM_LIBRARY_H
+
+#include "types.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef jsval_t (*ant_library_init_fn)(ant_t *js);
+typedef void (*ant_library_iter_fn)(const char *name, void *userdata);
+
+void ant_register_library(ant_library_init_fn init_fn, const char *name, ...);
+void ant_library_foreach(ant_library_iter_fn cb, void *userdata);
+
+#define ant_standard_library(name, lib) \
+  ant_register_library(lib, name, "ant:" name, "node:" name, NULL)
+
+jsval_t js_esm_load_registered_library(
+  ant_t *js, const char *specifier,
+  size_t spec_len, bool *loaded
+);
+
+#endif
diff --git a/include/esm/loader.h b/include/esm/loader.h
new file mode 100644
index 0000000..9046537
--- /dev/null
+++ b/include/esm/loader.h
@@ -0,0 +1,24 @@
+#ifndef ESM_LOADER_H
+#define ESM_LOADER_H
+
+#include "types.h"
+
+#include <stddef.h>
+#include <stdbool.h>
+
+void js_esm_cleanup_module_cache(void);
+void js_esm_gc_roots(void (*visit)(void *ctx, jsval_t *val), void *ctx);
+
+jsval_t js_esm_import_sync(ant_t *js, jsval_t specifier);
+jsval_t js_esm_make_file_url(ant_t *js, const char *path);
+
+jsval_t js_esm_eval_module_source(
+  ant_t *js,
+  const char *resolved_path, const char *js_code,
+  size_t js_len, jsval_t ns
+);
+
+jsval_t js_esm_import_sync_cstr(ant_t *js, const char *specifier, size_t spec_len);
+jsval_t js_esm_resolve_specifier(ant_t *js, jsval_t specifier, const char *base_path);
+
+#endif
diff --git a/include/esm/remote.h b/include/esm/remote.h
index 0c7fa7a..5b73437 100644
--- a/include/esm/remote.h
+++ b/include/esm/remote.h
@@ -5,6 +5,8 @@
 #include <stddef.h>
 
 bool esm_is_url(const char *spec);
+bool esm_is_data_url(const char *spec);
+char *esm_parse_data_url(const char *url, size_t *out_len);
 
 char *esm_fetch_url(const char *url, size_t *out_len, char **out_error);
 char *esm_resolve_url(const char *specifier, const char *base_url);
diff --git a/include/gc.h b/include/gc.h
index 66ba578..61a1133 100644
--- a/include/gc.h
+++ b/include/gc.h
@@ -32,17 +32,32 @@ typedef struct {
 #define GC_UPDATE_ARGS  ant_t *js, GC_FWD_OFF, GC_WEAK_OFF, GC_FWD_ARGS
 #define GC_OP_VAL_ARGS  GC_OP_VAL, GC_CTX
 
+#define FWD_EMPTY     ((jsoff_t)~0)
+#define FWD_TOMBSTONE ((jsoff_t)~1)
+
+#define GC_BIGINT_HEADER_SHIFT 4
+#define GC_SYM_HEADER_SHIFT    4
+
+#define GC_BIGINT_HEADER_LOW_MASK ((jsoff_t)((1u << GC_BIGINT_HEADER_SHIFT) - 1u))
+#define GC_SYM_HEADER_LOW_MASK    ((jsoff_t)((1u << GC_SYM_HEADER_SHIFT) - 1u))
+#define GC_SYM_HEAP_FIXED         (sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uintptr_t))
+
+#ifdef _WIN32
+#define RELEASE_PAGES(p, sz) VirtualAlloc(p, sz, MEM_RESET, PAGE_READWRITE)
+#elif defined(__APPLE__)
+#define RELEASE_PAGES(p, sz) madvise(p, sz, MADV_FREE)
+#else
+#define RELEASE_PAGES(p, sz) madvise(p, sz, MADV_DONTNEED)
+#endif
+
 #define GC_HEAP_TYPE_MASK ( \
-  (1u << T_OBJ) | (1u << T_PROP) | (1u << T_STR) | (1u << T_FUNC) | \
-  (1u << T_ARR) | (1u << T_PROMISE) | (1u << T_BIGINT) | (1u << T_GENERATOR))
+  (1u << T_OBJ) | (1u << T_PROP) | (1u << T_STR) | \
+  (1u << T_ARR) | (1u << T_PROMISE) | (1u << T_BIGINT) | (1u << T_GENERATOR) | \
+  (1u << T_SYMBOL))
+
+extern uint32_t gc_epoch_counter;
 
 void js_gc_maybe(ant_t *js);
 void js_gc_throttle(bool enabled);
 
-#define js_gc_safepoint(js) do { \
-  (js)->gc_safe = true;          \
-  js_gc_maybe(js);               \
-  (js)->gc_safe = false;          \
-} while (0)
-
 #endif
\ No newline at end of file
diff --git a/include/internal.h b/include/internal.h
index 5851ac4..18d5ac9 100644
--- a/include/internal.h
+++ b/include/internal.h
@@ -3,99 +3,168 @@
 
 #include "ant.h"
 #include "gc.h"
-#include <utarray.h>
 
-extern const UT_icd jsoff_icd;
-extern const UT_icd jsval_icd;
+#include <assert.h>
+#include <string.h>
+
+typedef struct sv_vm sv_vm_t;
+typedef struct sv_func sv_func_t;
+
+// An IEEE 754 double-precision float is a 64-bit value with bits laid out like:
+//
+// 1 Sign bit
+// | 11 Exponent bits
+// | |          52 Mantissa (i.e. fraction) bits
+// | |          |
+// S[Exponent-][Mantissa------------------------------------------]
+//
+// A NaN is any value where all exponent bits are set and the mantissa is
+// non-zero. That means there are a *lot* of bit patterns that all represent
+// NaN. NaN tagging takes advantage of this by repurposing those unused
+// patterns to encode non-numeric values.
+//
+// We define a NANBOX_PREFIX as the upper 12 bits all set (0xFFF0...):
+//
+// 1111 1111 1111 0000 0000 0000 ... 0000
+// [sign+exp all 1s  ] [mantissa all 0s  ]
+//
+// This corresponds to -Infinity in IEEE 754. Any 64-bit value strictly
+// greater than this prefix is a tagged (non-numeric) value. Any value less
+// than or equal to it is an unmodified double — so numeric math is free.
+//
+// For tagged values, we carve the remaining 52 mantissa bits into two fields:
+//
+// 1111 1111 1111 TTTTT DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
+// [-- prefix ---][type][--------------- 47-bit data --------------------]
+//
+// The 5-bit type tag (bits 51–47) encodes up to 31 distinct types: objects,
+// strings, booleans, undefined, null, functions, closures, errors, etc.
+// The 47-bit data field holds either a heap offset (for heap-resident types
+// like objects and strings) or an immediate value (e.g. 1 for true, 0 for
+// false).
+//
+// Encoding and decoding are simple:
+//
+//   mkval(type, data) = PREFIX | (type << 47) | (data & 0x7FFFFFFFFFFF)
+//   vtype(v)          = is_tagged(v) ? (v >> 47) & 0x1F : T_NUM
+//   vdata(v)          = v & 0x7FFFFFFFFFFF
+//   is_tagged(v)      = v > PREFIX
+
+#define NANBOX_TYPE_MASK   0x1F
+#define NANBOX_TYPE_SHIFT  0x2F
+#define NANBOX_HEAP_OFFSET 0x8
+#define NANBOX_PREFIX      0xFFF0000000000000ULL
+#define NANBOX_DATA_MASK   0x00007FFFFFFFFFFFULL
 
-extern UT_array *global_scope_stack;
-extern UT_array *saved_scope_stack;
+#define JS_ERR_NO_STACK      (1 << 8)
+#define JS_TYPE_FLAG(t)      (1u << (t))
+
+#define MAX_STRINGIFY_DEPTH   64
+#define MAX_PROTO_CHAIN_DEPTH 256
+#define MAX_MULTIREF_OBJS     128
+#define MAX_DENSE_INITIAL_CAP 8
+
+#define PROTO_WALK_F_OBJECT_ONLY (1u << 0)
+#define PROTO_WALK_F_LOOKUP      (1u << 1)
+
+#define T_EMPTY                (NANBOX_PREFIX | ((jsval_t)T_SENTINEL << NANBOX_TYPE_SHIFT) | 0xDEADULL)
+#define T_SPECIAL_OBJECT_MASK  (JS_TYPE_FLAG(T_OBJ)  | JS_TYPE_FLAG(T_ARR))
+#define T_NEEDS_PROTO_FALLBACK (JS_TYPE_FLAG(T_FUNC) | JS_TYPE_FLAG(T_ARR) | JS_TYPE_FLAG(T_PROMISE))
+#define T_OBJECT_MASK          (JS_TYPE_FLAG(T_OBJ)  | JS_TYPE_FLAG(T_ARR) | JS_TYPE_FLAG(T_FUNC) | JS_TYPE_FLAG(T_PROMISE))
+#define T_NON_NUMERIC_MASK     (JS_TYPE_FLAG(T_STR)  | JS_TYPE_FLAG(T_ARR) | JS_TYPE_FLAG(T_FUNC) | JS_TYPE_FLAG(T_CFUNC) | JS_TYPE_FLAG(T_OBJ))
+
+#define is_non_numeric(v)    ((1u << vtype(v)) & T_NON_NUMERIC_MASK)
+#define is_object_type(v)    ((1u << vtype(v)) & T_OBJECT_MASK)
+#define is_special_object(v) ((1u << vtype(v)) & T_SPECIAL_OBJECT_MASK)
+
+enum {
+  // heap-resident
+  T_OBJ  = 0,
+  T_PROP = 1,
+  T_STR  = 2,
+
+  // objects
+  T_ARR = 3,
+  T_FUNC,
+  T_CFUNC,
+  T_CLOSURE,
+  T_PROMISE,
+  T_GENERATOR,
+
+  // primitives
+  T_UNDEF,
+  T_NULL,
+  T_BOOL,
+  T_NUM,
+  T_BIGINT,
+  T_SYMBOL,
+
+  // internal
+  T_ERR,
+  T_TYPEDARRAY,
+  T_FFI,
+  T_NTARG,
 
-struct for_let_ctx {
-  const char *var_name;
-  jsoff_t var_len;
-  jsoff_t prop_off;
-  jsval_t body_scope;
+  T_SENTINEL = 31
 };
 
-struct js {
-  const char *code;       // currently parsed code snippet
-  char *errmsg;           // dynamic error message buffer
-  size_t errmsg_size;     // size of error message buffer
-  const char *filename;   // current filename for error reporting
-  uint8_t tok;            // last parsed token value
-  uint8_t consumed;       // indicator that last parsed token was consumed
-  uint8_t flags;          // execution flags, see F_* constants below
-  #define F_NOEXEC 1U     // parse code, but not execute
-  #define F_LOOP 2U       // we are inside the loop
-  #define F_CALL 4U       // we are inside a function call
-  #define F_BREAK 8U      // exit the loop
-  #define F_RETURN 16U    // return has been executed
-  #define F_THROW 32U     // throw has been executed
-  #define F_SWITCH 64U    // we are inside a switch statement
-  #define F_STRICT 128U   // strict mode is enabled
-  jsoff_t clen;           // code snippet length
-  jsoff_t pos;            // current parsing position
-  jsoff_t toff;           // offset of the last parsed token
-  jsoff_t tlen;           // length of the last parsed token
-  jsval_t tval;           // holds last parsed numeric or string literal value
-  jsval_t scope;          // current scope
-  jsval_t global;         // global root object
-  jsval_t object;         // global object prototype
-  jsval_t this_val;       // 'this' value for currently executing function
-  jsval_t super_val;      // 'super' value for class methods
-  jsval_t new_target;     // constructor called with 'new', undefined otherwise
-  jsval_t pending_ntg;    // staged new_target for next do_call_op
-  jsval_t module_ns;      // current ESM module namespace
-  uint8_t *mem;           // available JS memory
-  jsoff_t size;           // memory size
-  jsoff_t brk;            // current mem usage boundary
-  void *cstk;             // C stack pointer at the beginning of js_eval()
-  size_t stack_limit;     // max stack bytes allowed (0 = no limit)
-  jsval_t current_func;   // currently executing function (for native closures)
-  bool var_warning_shown; // flag to show var deprecation warning only once
-  bool owns_mem;          // true if js owns the memory buffer (dynamic allocation)
-  jsoff_t max_size;       // maximum allowed memory size (for dynamic growth)
-  bool had_newline;       // true if newline was crossed before current token
-  jsval_t thrown_value;   // stores the actual thrown value for catch blocks
-  bool is_hoisting;       // true during function declaration hoisting pass
-  uint64_t sym_counter;   // counter for generating unique symbol IDs
-  bool needs_gc;          // deferred GC flag, checked at statement boundaries
-  bool gc_safe;           // true when GC is allowed to run (at safe points only)
-  jsoff_t gc_alloc_since; // bytes allocated since last GC
-  int eval_depth;         // recursion depth of js_eval calls
-  int parse_depth;        // recursion depth of parser (for stack overflow protection)
-  bool skip_func_hoist;   // skip function declaration hoisting (pre-computed)
-  bool fatal_error;       // fatal error that should bypass promise rejection handling
-  bool tail_ctx;          // true when evaluating a return expression (for TCO)
-  bool has_tail_calls;    // cached: current function body has tail-call-eligible returns
-  
-  struct {
-    jsval_t func;
-    jsval_t closure_scope;
-    jsval_t this_val;
-    const char *code_str;
-    jsoff_t fnlen;
-    jsval_t *args;
-    int argc;
-    bool pending;
-  } tc;
+typedef struct {
+  const char *src;
+  const char *filename;
+  jsoff_t src_len;
+  jsoff_t off;
+  jsoff_t span_len;
+  bool valid;
+} js_error_site_t;
+
+struct ant {
+  sv_vm_t *vm;
   
-  struct for_let_ctx *for_let_stack;
-  int for_let_stack_len;
-  int for_let_stack_cap;
+  #ifdef ANT_JIT
+  void *jit_ctx;
+  #endif
+
+  const char *code;
+  const char *filename;
   
+  uint64_t sym_counter;
+  js_error_site_t errsite;
+
+  jsval_t global;
+  jsval_t object;
+  jsval_t this_val;
+  jsval_t new_target;
+  jsval_t current_func;
+
+  jsval_t module_ns;
+  jsval_t import_meta;
   jsval_t length_str;
+
+  uint8_t *mem;
+  jsoff_t size;
+  jsoff_t brk;
+  
+  struct {
+    void *base;
+    void *main_base;
+    void *main_lo;
+    size_t limit;
+  } cstk;
+
+  jsoff_t max_size;
+  jsval_t thrown_value;
+  jsval_t thrown_stack;
+  jsoff_t gc_alloc_since;
+
   jsval_t *gc_roots;
   jshdl_t gc_roots_len;
   jshdl_t gc_roots_cap;
+
+  bool owns_mem;
+  bool needs_gc;
   
-  jsval_t ascii_char_cache[128];
-  bool ascii_cache_init;
-  
-  void *token_stream;
-  int token_stream_pos;
-  const char *token_stream_code;
+  bool fatal_error;
+  bool thrown_exists;
 };
 
 typedef struct {
@@ -109,101 +178,117 @@ typedef struct {
   size_t bytes;
 } js_intern_stats_t;
 
-enum {
-  T_OBJ, T_PROP, T_STR, T_UNDEF, T_NULL, T_NUM, T_BOOL, T_FUNC,
-  T_CODEREF, T_CFUNC, T_ERR, T_ARR, T_PROMISE, T_TYPEDARRAY, 
-  T_BIGINT, T_PROPREF, T_SYMBOL, T_GENERATOR, T_FFI, T_NTARG,
-  T_SENTINEL = 31
-};
+typedef jsval_t 
+  (*js_cfunc_fn_t)(ant_t *, jsval_t *, int);
 
-#define JS_HASH_SIZE         512
-#define JS_MAX_PARSE_DEPTH   (1024 * 2)
-#define JS_ERR_NO_STACK      (1 << 8)
-#define JS_DENSE_INITIAL_CAP 8
+static inline js_cfunc_fn_t js_as_cfunc(jsval_t fn_val) {
+  return (js_cfunc_fn_t)(uintptr_t)vdata(fn_val);
+}
 
-#define PROPREF_STACK_SIZE      2048
-#define PRIM_PROPREF_STACK_SIZE 512
+static inline bool is_err(jsval_t v) { 
+  return vtype(v) == T_ERR; 
+}
 
-#define MAX_STRINGIFY_DEPTH   64
-#define MAX_PROTO_CHAIN_DEPTH 256
-#define MAX_MULTIREF_OBJS     128
+static inline bool is_null(jsval_t v) { 
+  return vtype(v) == T_NULL; 
+}
 
-#define PROTO_WALK_F_OBJECT_ONLY (1u << 0)
-#define PROTO_WALK_F_LOOKUP      (1u << 1)
+static inline bool is_undefined(jsval_t v) { 
+  return vtype(v) == T_UNDEF; 
+}
+
+static inline bool is_empty_slot(jsval_t v) { 
+  return v == T_EMPTY; 
+}
 
-#define NANBOX_PREFIX     0x7FC0000000000000ULL
-#define NANBOX_PREFIX_CHK 0x3FEULL
-#define NANBOX_TYPE_SHIFT 48
-#define NANBOX_TYPE_MASK  0x1F
-#define NANBOX_DATA_MASK  0x0000FFFFFFFFFFFFULL
+static inline jsoff_t loadoff(ant_t *js, jsoff_t off) {
+  assert(off + sizeof(jsoff_t) <= js->brk); jsoff_t val;
+  memcpy(&val, &js->mem[off], sizeof(val)); return val;
+}
 
-#define TYPE_FLAG(t) (1u << (t))
-#define T_EMPTY      (NANBOX_PREFIX | ((jsval_t)T_SENTINEL << NANBOX_TYPE_SHIFT) | 0xDEADULL)
-#define T_TAILCALL   (NANBOX_PREFIX | ((jsval_t)T_SENTINEL << NANBOX_TYPE_SHIFT) | 0x7A1CULL)
+static inline jsval_t loadval(ant_t *js, jsoff_t off) { 
+  return *(jsval_t *)(&js->mem[off]);
+}
 
-#define T_SPECIAL_OBJECT_MASK  (TYPE_FLAG(T_OBJ) | TYPE_FLAG(T_ARR))
-#define T_NEEDS_PROTO_FALLBACK (TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_PROMISE))
-#define T_OBJECT_MASK          (TYPE_FLAG(T_OBJ) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_PROMISE))
-#define T_NON_NUMERIC_MASK     (TYPE_FLAG(T_STR) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_CFUNC) | TYPE_FLAG(T_OBJ))
+static inline bool is_arr_off(ant_t *js, jsoff_t off) { 
+  return (loadoff(js, off) & ARRMASK) != 0; 
+}
 
 bool is_internal_prop(const char *key, jsoff_t klen);
 size_t uint_to_str(char *buf, size_t bufsize, uint64_t val);
 
 void js_gc_reserve_roots(GC_RESERVE_ARGS);
 void js_gc_update_roots(GC_UPDATE_ARGS);
+void js_gc_visit_frame_funcs(ant_t *js, void (*visitor)(void *, sv_func_t *), void *ctx);
 
 jsoff_t esize(jsoff_t w);
 jsval_t tov(double d);
+
 double tod(jsval_t v);
+double js_to_number(ant_t *js, jsval_t arg);
 
-jsval_t resolveprop(struct js *js, jsval_t v);
-jsval_t setprop_cstr(struct js *js, jsval_t obj, const char *key, size_t len, jsval_t v);
-jsval_t setprop_interned(struct js *js, jsval_t obj, const char *key, size_t len, jsval_t v);
+jsval_t resolveprop(ant_t *js, jsval_t v);
+jsval_t mkprop(ant_t *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t flags);
+jsval_t setprop_cstr(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v);
+jsval_t setprop_interned(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v);
+jsval_t js_define_own_prop(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t v);
 
-jsval_t coerce_to_str(struct js *js, jsval_t v);
-jsval_t coerce_to_str_concat(struct js *js, jsval_t v);
+jsval_t coerce_to_str(ant_t *js, jsval_t v);
+jsval_t coerce_to_str_concat(ant_t *js, jsval_t v);
+jsval_t get_ctor_species_value(ant_t *js, jsval_t ctor);
 
-jsval_t builtin_regexp_symbol_split(struct js *js, jsval_t *args, int nargs);
-jsval_t builtin_regexp_symbol_match(struct js *js, jsval_t *args, int nargs);
-jsval_t builtin_regexp_symbol_replace(struct js *js, jsval_t *args, int nargs);
-jsval_t builtin_regexp_symbol_search(struct js *js, jsval_t *args, int nargs);
-jsval_t builtin_regexp_flags_getter(struct js *js, jsval_t *args, int nargs);
+bool is_rope(ant_t *js, jsval_t value);
+bool proto_chain_contains(ant_t *js, jsval_t obj, jsval_t proto_target);
+bool same_ctor_identity(ant_t *js, jsval_t a, jsval_t b);
 
 js_intern_stats_t js_intern_stats(void);
-js_cstr_t js_to_cstr(struct js *js, jsval_t value, char *stack_buf, size_t stack_size);
-jsval_t js_instance_proto_from_new_target(struct js *js, jsval_t fallback_proto);
-
-jsoff_t lkp(struct js *js, jsval_t obj, const char *buf, size_t len);
-jsoff_t lkp_proto(struct js *js, jsval_t obj, const char *buf, size_t len);
-jsoff_t vstr(struct js *js, jsval_t value, jsoff_t *len);
-
-jsval_t mkarr(struct js *js);
+js_cstr_t js_to_cstr(ant_t *js, jsval_t value, char *stack_buf, size_t stack_size);
+jsval_t js_instance_proto_from_new_target(ant_t *js, jsval_t fallback_proto);
+
+jsoff_t lkp(ant_t *js, jsval_t obj, const char *buf, size_t len);
+jsoff_t lkp_proto(ant_t *js, jsval_t obj, const char *buf, size_t len);
+jsoff_t lkp_sym(ant_t *js, jsval_t obj, jsoff_t sym_off);
+jsoff_t lkp_sym_proto(ant_t *js, jsval_t obj, jsoff_t sym_off);
+jsoff_t vstr(ant_t *js, jsval_t value, jsoff_t *len);
+jsoff_t vstrlen(ant_t *js, jsval_t value);
+jsval_t rope_flatten(ant_t *js, jsval_t rope);
+jsoff_t str_len_fast(ant_t *js, jsval_t str);
+
+jsval_t mkarr(ant_t *js);
 jsval_t mkval(uint8_t type, uint64_t data);
-
-jsval_t call_js(ant_t *js, const char *fn, jsoff_t fnlen, jsval_t closure_scope);
-jsval_t call_js_internal(ant_t *js, const char *fn, jsoff_t fnlen, jsval_t closure_scope, jsval_t *bound_args, int bound_argc, jsval_t func_val);
-
-jsval_t call_js_with_args(ant_t *js, jsval_t fn, jsval_t *args, int nargs);
-jsval_t call_js_code_with_args(ant_t *js, const char *fn, jsoff_t fnlen, jsval_t closure_scope, jsval_t *args, int nargs, jsval_t func_val);
-
-#define is_non_numeric(v)    ((1u << vtype(v)) & T_NON_NUMERIC_MASK)
-#define is_object_type(v)    ((1u << vtype(v)) & T_OBJECT_MASK)
-#define is_special_object(v) ((1u << vtype(v)) & T_SPECIAL_OBJECT_MASK)
-
-static inline bool is_err(jsval_t v) { 
-  return vtype(v) == T_ERR; 
-}
-
-static inline bool is_null(jsval_t v) { 
-  return vtype(v) == T_NULL; 
-}
-
-static inline bool is_undefined(jsval_t v) { 
-  return vtype(v) == T_UNDEF; 
-}
-
-static inline bool is_empty_slot(jsval_t v) { 
-  return v == T_EMPTY; 
-}
+jsval_t mkobj(ant_t *js, jsoff_t parent);
+
+jsval_t js_for_in_keys(ant_t *js, jsval_t obj);
+jsval_t js_delete_prop(ant_t *js, jsval_t obj, const char *key, size_t len);
+jsval_t js_delete_sym_prop(ant_t *js, jsval_t obj, jsval_t sym);
+
+bool is_proxy(ant_t *js, jsval_t obj);
+bool strict_eq_values(ant_t *js, jsval_t l, jsval_t r);
+
+jsval_t js_proxy_apply(ant_t *js, jsval_t proxy, jsval_t this_arg, jsval_t *args, int argc);
+jsval_t js_proxy_construct(ant_t *js, jsval_t proxy, jsval_t *args, int argc, jsval_t new_target);
+jsval_t sv_call_native(ant_t *js, jsval_t func, jsval_t this_val, jsval_t *args, int nargs);
+
+const char *typestr(uint8_t t);
+jsval_t unwrap_primitive(ant_t *js, jsval_t val);
+jsval_t do_string_op(ant_t *js, uint8_t op, jsval_t l, jsval_t r);
+jsval_t js_to_primitive(ant_t *js, jsval_t value, int hint);
+
+jsval_t do_instanceof(ant_t *js, jsval_t l, jsval_t r);
+jsval_t do_in(ant_t *js, jsval_t l, jsval_t r);
+
+jsval_t bigint_add(ant_t *js, jsval_t a, jsval_t b);
+jsval_t bigint_sub(ant_t *js, jsval_t a, jsval_t b);
+jsval_t bigint_mul(ant_t *js, jsval_t a, jsval_t b);
+jsval_t bigint_div(ant_t *js, jsval_t a, jsval_t b);
+jsval_t bigint_mod(ant_t *js, jsval_t a, jsval_t b);
+jsval_t bigint_neg(ant_t *js, jsval_t a);
+jsval_t bigint_exp(ant_t *js, jsval_t base, jsval_t exp);
+int bigint_compare(ant_t *js, jsval_t a, jsval_t b);
+
+jsval_t bigint_shift_left(ant_t *js, jsval_t value, uint64_t shift);
+jsval_t bigint_shift_right(ant_t *js, jsval_t value, uint64_t shift);
+jsval_t bigint_shift_right_logical(ant_t *js, jsval_t value, uint64_t shift);
+jsval_t bigint_asint_bits(ant_t *js, jsval_t arg, uint64_t *bits_out);
 
 #endif
diff --git a/include/modules/async_hooks.h b/include/modules/async_hooks.h
new file mode 100644
index 0000000..77a6765
--- /dev/null
+++ b/include/modules/async_hooks.h
@@ -0,0 +1,8 @@
+#ifndef ANT_ASYNC_HOOKS_MODULE_H
+#define ANT_ASYNC_HOOKS_MODULE_H
+
+#include "types.h"
+
+jsval_t async_hooks_library(ant_t *js);
+
+#endif
diff --git a/include/modules/buffer.h b/include/modules/buffer.h
index e990f19..591c1bc 100644
--- a/include/modules/buffer.h
+++ b/include/modules/buffer.h
@@ -48,17 +48,19 @@ void free_array_buffer_data(ArrayBufferData *data);
 size_t buffer_get_external_memory(void);
 
 ArrayBufferData *create_array_buffer_data(size_t length);
-jsval_t create_arraybuffer_obj(struct js *js, ArrayBufferData *buffer);
+jsval_t create_arraybuffer_obj(ant_t *js, ArrayBufferData *buffer);
 
 jsval_t create_typed_array(
-  struct js *js, TypedArrayType type, ArrayBufferData *buffer,
+  ant_t *js, TypedArrayType type, ArrayBufferData *buffer,
   size_t byte_offset, size_t length, const char *type_name
 );
 
 jsval_t create_typed_array_with_buffer(
-  struct js *js, TypedArrayType type, ArrayBufferData *buffer,
+  ant_t *js, TypedArrayType type, ArrayBufferData *buffer,
   size_t byte_offset, size_t length, 
   const char *type_name, jsval_t arraybuffer_obj
 );
 
+jsval_t buffer_library(ant_t *js);
+
 #endif
diff --git a/include/modules/child_process.h b/include/modules/child_process.h
index 7b063ab..6df05b7 100644
--- a/include/modules/child_process.h
+++ b/include/modules/child_process.h
@@ -4,7 +4,7 @@
 #include "gc.h"
 #include "types.h"
 
-jsval_t child_process_library(struct js *js);
+jsval_t child_process_library(ant_t *js);
 
 int has_pending_child_processes(void);
 void child_process_gc_update_roots(GC_OP_VAL_ARGS);
diff --git a/include/modules/crypto.h b/include/modules/crypto.h
index d9f7652..0c6c3d0 100644
--- a/include/modules/crypto.h
+++ b/include/modules/crypto.h
@@ -4,6 +4,6 @@
 #include "types.h"
 
 void init_crypto_module();
-jsval_t crypto_library(struct js *js);
+jsval_t crypto_library(ant_t *js);
 
 #endif
\ No newline at end of file
diff --git a/include/modules/date.h b/include/modules/date.h
new file mode 100644
index 0000000..b424941
--- /dev/null
+++ b/include/modules/date.h
@@ -0,0 +1,79 @@
+#ifndef DATE_H
+#define DATE_H
+
+#include "types.h"
+
+#define DATE_METHOD_ENTRY(name_lit, fn_ptr) \
+  { name_lit, sizeof(name_lit) - 1, fn_ptr }
+  
+#define DATE_COUNT_OF(a) \
+  ((int)(sizeof(a) / sizeof((a)[0])))
+
+typedef struct {
+  double year;
+  double month;
+  double day;
+  double hour;
+  double minute;
+  double second;
+  double millisecond;
+  double weekday;
+  double tz_minutes;
+} date_fields_t;
+
+typedef enum {
+  DATE_FIELD_YEAR = 0,
+  DATE_FIELD_MONTH = 1,
+  DATE_FIELD_DAY_OF_MONTH = 2,
+  DATE_FIELD_HOUR = 3,
+  DATE_FIELD_MINUTE = 4,
+  DATE_FIELD_SECOND = 5,
+  DATE_FIELD_MILLISECOND = 6,
+  DATE_FIELD_DAY_OF_WEEK = 7,
+  DATE_FIELD_TZ_MINUTES = 8,
+} date_field_index_t;
+
+typedef enum {
+  DATE_STRING_FMT_UTC = 0,
+  DATE_STRING_FMT_LOCAL = 1,
+  DATE_STRING_FMT_ISO = 2,
+  DATE_STRING_FMT_LOCALE = 3,
+} date_string_fmt_t;
+
+typedef enum {
+  DATE_STRING_PART_DATE = 1,
+  DATE_STRING_PART_TIME = 2,
+  DATE_STRING_PART_ALL = 3,
+} date_string_part_t;
+
+typedef struct {
+  date_string_fmt_t fmt;
+  date_string_part_t part;
+} date_string_spec_t;
+
+typedef struct {
+  date_field_index_t field;
+  bool local_time;
+  bool legacy_get_year;
+} date_get_field_spec_t;
+
+typedef struct {
+  date_field_index_t first_field;
+  date_field_index_t end_field_exclusive;
+  bool local_time;
+} date_set_field_spec_t;
+
+typedef struct {
+  const char *name;
+  size_t len;
+  jsval_t (*fn)(ant_t *, jsval_t *, int);
+} date_method_entry_t;
+
+void init_date_module(void);
+
+jsval_t get_date_string(
+  ant_t *js, jsval_t this_val, 
+  date_string_spec_t spec
+);
+
+#endif
diff --git a/include/modules/dns.h b/include/modules/dns.h
new file mode 100644
index 0000000..46fda18
--- /dev/null
+++ b/include/modules/dns.h
@@ -0,0 +1,8 @@
+#ifndef ANT_DNS_MODULE_H
+#define ANT_DNS_MODULE_H
+
+#include "types.h"
+
+jsval_t dns_library(ant_t *js);
+
+#endif
diff --git a/include/modules/events.h b/include/modules/events.h
index 2089413..84e5b8a 100644
--- a/include/modules/events.h
+++ b/include/modules/events.h
@@ -6,6 +6,6 @@
 void init_events_module(void);
 void events_gc_update_roots(void (*op_val)(void *, jsval_t *), void *ctx);
 
-jsval_t events_library(struct js *js);
+jsval_t events_library(ant_t *js);
 
 #endif
\ No newline at end of file
diff --git a/include/modules/ffi.h b/include/modules/ffi.h
index a6e3676..16cfb97 100644
--- a/include/modules/ffi.h
+++ b/include/modules/ffi.h
@@ -4,8 +4,8 @@
 #include "gc.h"
 #include "types.h"
 
-jsval_t ffi_library(struct js *js);
-jsval_t ffi_call_by_index(struct js *js, unsigned int func_index, jsval_t *args, int nargs);
+jsval_t ffi_library(ant_t *js);
+jsval_t ffi_call_by_index(ant_t *js, unsigned int func_index, jsval_t *args, int nargs);
 
 void ffi_gc_update_roots(GC_OP_VAL_ARGS);
 
diff --git a/include/modules/fs.h b/include/modules/fs.h
index 5cf97b4..469e480 100644
--- a/include/modules/fs.h
+++ b/include/modules/fs.h
@@ -4,7 +4,9 @@
 #include "gc.h"
 #include "types.h"
 
-jsval_t fs_library(struct js *js);
+jsval_t fs_library(ant_t *js);
+jsval_t fs_promises_library(ant_t *js);
+
 int has_pending_fs_ops(void);
 
 void init_fs_module(void);
diff --git a/include/modules/io.h b/include/modules/io.h
index 03865d5..3dbce06 100644
--- a/include/modules/io.h
+++ b/include/modules/io.h
@@ -17,6 +17,7 @@ typedef struct {
 #define C_RESET   C("\x1b[0m")
 #define C_BOLD    C("\x1b[1m")
 #define C_DIM     C("\x1b[2m")
+#define C_GRAY    C("\x1b[90m")
 #define C_UL      C("\x1b[4m")
 #define C_UL_OFF  C("\x1b[24m")
 #define C_GREEN   C("\x1b[32m")
@@ -30,6 +31,7 @@ typedef struct {
 void init_console_module(void);
 void print_value_colored(const char *str, FILE *stream);
 void print_repl_value(ant_t *js, jsval_t val, FILE *stream);
+bool print_uncaught_throw(ant_t *js);
 
 void inspect_object(
   ant_t *js, jsval_t obj,
diff --git a/include/modules/json.h b/include/modules/json.h
index a1a6d52..6c39bdd 100644
--- a/include/modules/json.h
+++ b/include/modules/json.h
@@ -6,7 +6,7 @@
 
 void init_json_module(void);
 
-jsval_t js_json_parse(struct js *js, jsval_t *args, int nargs);
-jsval_t js_json_stringify(struct js *js, jsval_t *args, int nargs);
+jsval_t js_json_parse(ant_t *js, jsval_t *args, int nargs);
+jsval_t js_json_stringify(ant_t *js, jsval_t *args, int nargs);
 
 #endif
diff --git a/include/modules/lmdb.h b/include/modules/lmdb.h
index 60850a0..7540240 100644
--- a/include/modules/lmdb.h
+++ b/include/modules/lmdb.h
@@ -22,7 +22,7 @@ typedef struct {
   bool ready;
 } lmdb_js_types_t;
 
-jsval_t lmdb_library(struct js *js);
+jsval_t lmdb_library(ant_t *js);
 void lmdb_gc_update_roots(GC_OP_VAL_ARGS);
 void cleanup_lmdb_module(void);
 
diff --git a/include/modules/module.h b/include/modules/module.h
new file mode 100644
index 0000000..0452ac5
--- /dev/null
+++ b/include/modules/module.h
@@ -0,0 +1,8 @@
+#ifndef ANT_MODULE_MODULE_H
+#define ANT_MODULE_MODULE_H
+
+#include "types.h"
+
+jsval_t module_library(ant_t *js);
+
+#endif
diff --git a/include/modules/napi.h b/include/modules/napi.h
new file mode 100644
index 0000000..97707ab
--- /dev/null
+++ b/include/modules/napi.h
@@ -0,0 +1,174 @@
+#ifndef ANT_NAPI_H
+#define ANT_NAPI_H
+
+#include "types.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifndef NAPI_AUTO_LENGTH
+#define NAPI_AUTO_LENGTH SIZE_MAX
+#endif
+
+#ifndef NAPI_CDECL
+#ifdef _WIN32
+#define NAPI_CDECL __cdecl
+#else
+#define NAPI_CDECL
+#endif
+#endif
+
+#ifndef NAPI_EXTERN
+#if defined(_WIN32)
+#define NAPI_EXTERN __declspec(dllexport)
+#else
+#define NAPI_EXTERN __attribute__((visibility("default"), used))
+#endif
+#endif
+
+typedef jsval_t napi_value;
+#define NAPI_MODULE_VERSION 1
+
+typedef struct ant_napi_env__* napi_env;
+typedef napi_env node_api_basic_env;
+
+typedef struct napi_ref__* napi_ref;
+typedef struct napi_handle_scope__* napi_handle_scope;
+typedef struct napi_escapable_handle_scope__* napi_escapable_handle_scope;
+typedef struct napi_callback_info__* napi_callback_info;
+typedef struct napi_deferred__* napi_deferred;
+
+typedef struct napi_callback_scope__* napi_callback_scope;
+typedef struct napi_async_context__* napi_async_context;
+typedef struct napi_async_work__* napi_async_work;
+typedef struct napi_threadsafe_function__* napi_threadsafe_function;
+
+typedef enum {
+  napi_default = 0,
+  napi_writable = 1 << 0,
+  napi_enumerable = 1 << 1,
+  napi_configurable = 1 << 2,
+  napi_static = 1 << 10,
+} napi_property_attributes;
+
+typedef enum {
+  napi_undefined,
+  napi_null,
+  napi_boolean,
+  napi_number,
+  napi_string,
+  napi_symbol,
+  napi_object,
+  napi_function,
+  napi_external,
+  napi_bigint,
+} napi_valuetype;
+
+typedef enum {
+  napi_int8_array,
+  napi_uint8_array,
+  napi_uint8_clamped_array,
+  napi_int16_array,
+  napi_uint16_array,
+  napi_int32_array,
+  napi_uint32_array,
+  napi_float32_array,
+  napi_float64_array,
+  napi_bigint64_array,
+  napi_biguint64_array,
+} napi_typedarray_type;
+
+typedef enum {
+  napi_ok,
+  napi_invalid_arg,
+  napi_object_expected,
+  napi_string_expected,
+  napi_name_expected,
+  napi_function_expected,
+  napi_number_expected,
+  napi_boolean_expected,
+  napi_array_expected,
+  napi_generic_failure,
+  napi_pending_exception,
+  napi_cancelled,
+  napi_escape_called_twice,
+  napi_handle_scope_mismatch,
+  napi_callback_scope_mismatch,
+  napi_queue_full,
+  napi_closing,
+  napi_bigint_expected,
+  napi_date_expected,
+  napi_arraybuffer_expected,
+  napi_detachable_arraybuffer_expected,
+  napi_would_deadlock,
+  napi_no_external_buffers_allowed,
+  napi_cannot_run_js,
+} napi_status;
+
+typedef napi_value(NAPI_CDECL* napi_callback)(napi_env env, napi_callback_info info);
+typedef void(NAPI_CDECL* napi_finalize)(napi_env env, void* finalize_data, void* finalize_hint);
+typedef napi_finalize node_api_basic_finalize;
+
+typedef struct {
+  const char* utf8name;
+  napi_value name;
+  napi_callback method;
+  napi_callback getter;
+  napi_callback setter;
+  napi_value value;
+  napi_property_attributes attributes;
+  void* data;
+} napi_property_descriptor;
+
+typedef struct {
+  const char* error_message;
+  void* engine_reserved;
+  uint32_t engine_error_code;
+  napi_status error_code;
+} napi_extended_error_info;
+
+typedef struct {
+  uint32_t major;
+  uint32_t minor;
+  uint32_t patch;
+  const char* release;
+} napi_node_version;
+
+typedef void(NAPI_CDECL* napi_cleanup_hook)(void* arg);
+typedef void(NAPI_CDECL* napi_async_execute_callback)(napi_env env, void* data);
+typedef void(NAPI_CDECL* napi_async_complete_callback)(napi_env env, napi_status status, void* data);
+
+typedef void(NAPI_CDECL* napi_threadsafe_function_call_js)(
+  napi_env env,
+  napi_value js_callback,
+  void* context,
+  void* data
+);
+
+typedef enum {
+  napi_tsfn_release,
+  napi_tsfn_abort
+} napi_threadsafe_function_release_mode;
+
+typedef enum {
+  napi_tsfn_nonblocking,
+  napi_tsfn_blocking
+} napi_threadsafe_function_call_mode;
+
+typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env, napi_value exports);
+
+typedef struct napi_module {
+  int nm_version;
+  unsigned int nm_flags;
+  const char* nm_filename;
+  napi_addon_register_func nm_register_func;
+  const char* nm_modname;
+  void* nm_priv;
+  void* reserved[4];
+} napi_module;
+
+napi_env ant_napi_get_env(ant_t *js);
+jsval_t napi_process_dlopen_js(ant_t *js, jsval_t *args, int nargs);
+jsval_t napi_load_native_module(ant_t *js, const char *module_path, jsval_t ns);
+
+#endif
diff --git a/include/modules/net.h b/include/modules/net.h
new file mode 100644
index 0000000..c602e0e
--- /dev/null
+++ b/include/modules/net.h
@@ -0,0 +1,8 @@
+#ifndef ANT_NET_MODULE_H
+#define ANT_NET_MODULE_H
+
+#include "types.h"
+
+jsval_t net_library(ant_t *js);
+
+#endif
diff --git a/include/modules/os.h b/include/modules/os.h
index 444b220..aff4316 100644
--- a/include/modules/os.h
+++ b/include/modules/os.h
@@ -3,6 +3,6 @@
 
 #include "types.h"
 
-jsval_t os_library(struct js *js);
+jsval_t os_library(ant_t *js);
 
 #endif
diff --git a/include/modules/path.h b/include/modules/path.h
index 3e00866..0f69bd0 100644
--- a/include/modules/path.h
+++ b/include/modules/path.h
@@ -3,6 +3,6 @@
 
 #include "types.h"
 
-jsval_t path_library(struct js *js);
+jsval_t path_library(ant_t *js);
 
 #endif
diff --git a/include/modules/performance.h b/include/modules/performance.h
index 356ce40..7db886a 100644
--- a/include/modules/performance.h
+++ b/include/modules/performance.h
@@ -1,6 +1,9 @@
 #ifndef PERFORMANCE_H
 #define PERFORMANCE_H
 
+#include "types.h"
+
 void init_performance_module(void);
+jsval_t perf_hooks_library(ant_t *js);
 
 #endif
diff --git a/include/modules/process.h b/include/modules/process.h
index 8297096..15a539f 100644
--- a/include/modules/process.h
+++ b/include/modules/process.h
@@ -10,4 +10,6 @@ void emit_process_event(const char *event_type, jsval_t *args, int nargs);
 void init_process_module(void);
 bool has_active_stdin(void);
 
+jsval_t process_library(ant_t *js);
+
 #endif
diff --git a/include/modules/readline.h b/include/modules/readline.h
index a28f396..e87211c 100644
--- a/include/modules/readline.h
+++ b/include/modules/readline.h
@@ -5,8 +5,8 @@
 #include "types.h"
 #include <stdbool.h>
 
-jsval_t readline_library(struct js *js);
-jsval_t readline_promises_library(struct js *js);
+jsval_t readline_library(ant_t *js);
+jsval_t readline_promises_library(ant_t *js);
 
 bool has_active_readline_interfaces(void);
 void readline_gc_update_roots(GC_OP_VAL_ARGS);
diff --git a/include/modules/regex.h b/include/modules/regex.h
new file mode 100644
index 0000000..1adee02
--- /dev/null
+++ b/include/modules/regex.h
@@ -0,0 +1,28 @@
+#ifndef REGEX_H
+#define REGEX_H
+
+#include "types.h"
+#include "gc.h"
+
+void init_regex_module(void);
+void cleanup_regex_module(void);
+
+void regex_gc_update_roots(jsoff_t (*weak_off)(void *ctx, jsoff_t old), GC_OP_VAL_ARGS);
+size_t js_to_pcre2_pattern(const char *src, size_t src_len, char *dst, size_t dst_size);
+
+jsval_t builtin_regexp_symbol_split(ant_t *js, jsval_t *args, int nargs);
+jsval_t builtin_regexp_symbol_match(ant_t *js, jsval_t *args, int nargs);
+jsval_t builtin_regexp_symbol_replace(ant_t *js, jsval_t *args, int nargs);
+jsval_t builtin_regexp_symbol_search(ant_t *js, jsval_t *args, int nargs);
+jsval_t builtin_regexp_flags_getter(ant_t *js, jsval_t *args, int nargs);
+
+jsval_t is_regexp_like(ant_t *js, jsval_t value);
+jsval_t reject_regexp_arg(ant_t *js, jsval_t value, const char *method_name);
+
+jsval_t do_regex_match_pcre2(
+  ant_t *js, const char *pattern_ptr, jsoff_t pattern_len,
+  const char *str_ptr, jsoff_t str_len,
+  bool global_flag, bool ignore_case, bool multiline
+);
+
+#endif
diff --git a/include/modules/shell.h b/include/modules/shell.h
index 4c840d3..3679045 100644
--- a/include/modules/shell.h
+++ b/include/modules/shell.h
@@ -3,6 +3,6 @@
 
 #include "types.h"
 
-jsval_t shell_library(struct js *js);
+jsval_t shell_library(ant_t *js);
 
 #endif
diff --git a/include/modules/symbol.h b/include/modules/symbol.h
index ac05834..88d78e7 100644
--- a/include/modules/symbol.h
+++ b/include/modules/symbol.h
@@ -1,32 +1,43 @@
 #ifndef SYMBOL_H
 #define SYMBOL_H
 
-#include <stddef.h>
 #include <stdbool.h>
-#include "types.h"
-
+#include "internal.h" // IWYU pragma: keep
 
 void init_symbol_module(void);
 void js_define_species_getter(ant_t *js, jsval_t ctor);
+void symbol_gc_update_roots(GC_OP_VAL_ARGS);
+
+jsval_t sym_lookup_by_id(uint32_t id);
+void sym_gc_update_all(void (*op_val)(void *, jsval_t *), void *ctx);
+
+jsval_t maybe_call_symbol_method(
+  ant_t *js, jsval_t target, jsval_t sym,
+  jsval_t this_arg, jsval_t *args,
+  int nargs, bool *called
+);
+
+#define WELLKNOWN_SYMBOLS(X)                           \
+  X(iterator,            "Symbol.iterator")            \
+  X(asyncIterator,       "Symbol.asyncIterator")       \
+  X(toStringTag,         "Symbol.toStringTag")         \
+  X(hasInstance,         "Symbol.hasInstance")         \
+  X(match,               "Symbol.match")               \
+  X(replace,             "Symbol.replace")             \
+  X(search,              "Symbol.search")              \
+  X(split,               "Symbol.split")               \
+  X(isConcatSpreadable,  "Symbol.isConcatSpreadable")  \
+  X(observable,          "Symbol.observable")          \
+  X(toPrimitive,         "Symbol.toPrimitive")         \
+  X(species,             "Symbol.species")             \
+  X(unscopables,         "Symbol.unscopables")
+
+#define DECL_GET_SYM(name, _desc) jsval_t get_##name##_sym(void);
+WELLKNOWN_SYMBOLS(DECL_GET_SYM)
+#undef DECL_GET_SYM
 
-bool is_symbol_key(const char *key, size_t key_len);
-int sym_to_prop_key(jsval_t sym, char *buf, size_t bufsz);
-
-const char *get_iterator_sym_key(void);
-const char *get_asyncIterator_sym_key(void);
-const char *get_toStringTag_sym_key(void);
-const char *get_observable_sym_key(void);
-const char *get_toPrimitive_sym_key(void);
-const char *get_hasInstance_sym_key(void);
-const char *get_match_sym_key(void);
-const char *get_replace_sym_key(void);
-const char *get_search_sym_key(void);
-const char *get_split_sym_key(void);
-const char *get_isConcatSpreadable_sym_key(void);
-const char *get_species_sym_key(void);
-const char *get_unscopables_sym_key(void);
-
-jsval_t get_wellknown_sym_by_key(const char *key, size_t key_len);
-const char *get_symbol_description_from_key(const char *sym_key, size_t key_len);
+static inline jsval_t sym_this_cb(ant_t *js, jsval_t *args, int nargs) {
+  return js->this_val;
+}
 
 #endif
diff --git a/include/modules/timer.h b/include/modules/timer.h
index aff60fb..9d9f593 100644
--- a/include/modules/timer.h
+++ b/include/modules/timer.h
@@ -5,9 +5,9 @@
 #include "types.h"
 
 void init_timer_module(void);
-void process_microtasks(struct js *js);
-void process_immediates(struct js *js);
-void queue_microtask(struct js *js, jsval_t callback);
+void process_microtasks(ant_t *js);
+void process_immediates(ant_t *js);
+void queue_microtask(ant_t *js, jsval_t callback);
 void queue_promise_trigger(uint32_t promise_id);
 void timer_gc_update_roots(GC_OP_VAL_ARGS);
 
diff --git a/include/modules/tty.h b/include/modules/tty.h
new file mode 100644
index 0000000..fd0ecdd
--- /dev/null
+++ b/include/modules/tty.h
@@ -0,0 +1,9 @@
+#ifndef ANT_TTY_MODULE_H
+#define ANT_TTY_MODULE_H
+
+#include "types.h"
+
+void init_tty_module(void);
+jsval_t tty_library(ant_t *js);
+
+#endif
diff --git a/include/modules/url.h b/include/modules/url.h
index 5fef088..4185432 100644
--- a/include/modules/url.h
+++ b/include/modules/url.h
@@ -1,6 +1,9 @@
 #ifndef URL_H
 #define URL_H
 
+#include "types.h"
+
 void init_url_module(void);
+jsval_t url_library(ant_t *js);
 
 #endif
diff --git a/include/modules/util.h b/include/modules/util.h
new file mode 100644
index 0000000..7cab6c2
--- /dev/null
+++ b/include/modules/util.h
@@ -0,0 +1,8 @@
+#ifndef ANT_UTIL_MODULE_H
+#define ANT_UTIL_MODULE_H
+
+#include "types.h"
+
+jsval_t util_library(ant_t *js);
+
+#endif
diff --git a/include/modules/worker_threads.h b/include/modules/worker_threads.h
new file mode 100644
index 0000000..98455f8
--- /dev/null
+++ b/include/modules/worker_threads.h
@@ -0,0 +1,8 @@
+#ifndef ANT_WORKER_THREADS_H
+#define ANT_WORKER_THREADS_H
+
+#include "types.h"
+
+jsval_t worker_threads_library(ant_t *js);
+
+#endif
diff --git a/include/oxc.h b/include/oxc.h
index 73307bb..48eafbb 100644
--- a/include/oxc.h
+++ b/include/oxc.h
@@ -9,11 +9,13 @@
 #define OXC_ERR_TRANSFORM_FAILED -4
 #define OXC_ERR_OUTPUT_TOO_LARGE -5
 
-int OXC_strip_types(
+char *OXC_strip_types_owned(
   const char *input,
   const char *filename,
-  char *output,
-  size_t output_len
+  size_t *out_len,
+  int *out_error,
+  char *error_output,
+  size_t error_output_len
 );
 
 char *OXC_get_hoisted_vars(
@@ -29,5 +31,6 @@ char *OXC_get_func_hoisted_vars(
 );
 
 void OXC_free_hoisted_vars(char *ptr, size_t len);
+void OXC_free_stripped_output(char *ptr, size_t len);
 
 #endif
diff --git a/include/pkg.h b/include/pkg.h
index 70b713b..20b9829 100644
--- a/include/pkg.h
+++ b/include/pkg.h
@@ -160,6 +160,14 @@ pkg_error_t pkg_get_added_package(
   pkg_added_package_t *out
 );
 
+int pkg_get_latest_available_version(
+  pkg_context_t *ctx,
+  const char *package_name,
+  const char *installed_version,
+  char *out_version,
+  size_t out_version_len
+);
+
 int pkg_get_bin_path(
   const char *node_modules_path,
   const char *bin_name,
diff --git a/include/roots.h b/include/roots.h
index 74a3756..af2461a 100644
--- a/include/roots.h
+++ b/include/roots.h
@@ -3,10 +3,10 @@
 
 #include "types.h"
 
-jshdl_t js_root(struct js *js, jsval_t val);
-jsval_t js_deref(struct js *js, jshdl_t h);
+jshdl_t js_root(ant_t *js, jsval_t val);
+jsval_t js_deref(ant_t *js, jshdl_t h);
 
-void js_unroot(struct js *js, jshdl_t h);
-void js_root_update(struct js *js, jshdl_t h, jsval_t val);
+void js_unroot(ant_t *js, jshdl_t h);
+void js_root_update(ant_t *js, jshdl_t h, jsval_t val);
 
 #endif
\ No newline at end of file
diff --git a/include/runtime.h b/include/runtime.h
index f2e2fb4..720dbd1 100644
--- a/include/runtime.h
+++ b/include/runtime.h
@@ -8,21 +8,31 @@ struct arg_file;
 #define CODE_ARENA_BLOCK_SIZE   (64 * 1024)
 
 struct ant_runtime {
-  struct js *js;
+  ant_t *js;
   char **argv;
   jsval_t ant_obj;
   int argc;
+  int pid;
   unsigned int flags;
   const char *ls_fp;
 };
 
+typedef struct {
+  void *block;
+  size_t used;
+} code_arena_mark_t;
+
 extern struct ant_runtime *const rt;
-struct ant_runtime *ant_runtime_init(struct js *js, int argc, char **argv, struct arg_file *ls_p);
+struct ant_runtime *ant_runtime_init(ant_t *js, int argc, char **argv, struct arg_file *ls_p);
 
-const char *code_arena_alloc(const char *code, size_t len);
 size_t code_arena_get_memory(void);
+const char *code_arena_alloc(const char *code, size_t len);
+
+code_arena_mark_t code_arena_mark(void);
+void code_arena_rewind(code_arena_mark_t mark);
 
 void code_arena_reset(void);
-void destroy_runtime(struct js *js);
+void destroy_runtime(ant_t *js);
+void *code_arena_bump(size_t size);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/include/silver/ast.h b/include/silver/ast.h
new file mode 100644
index 0000000..d2aa7e0
--- /dev/null
+++ b/include/silver/ast.h
@@ -0,0 +1,157 @@
+#ifndef SILVER_AST_H
+#define SILVER_AST_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "types.h"
+
+typedef enum {
+  N_NUMBER,
+  N_STRING,
+  N_BIGINT,
+  N_BOOL,
+  N_NULL,
+  N_UNDEF,
+  N_THIS,
+  N_GLOBAL_THIS,
+  N_TEMPLATE,
+  N_REGEXP,
+  N_IDENT,
+  N_BINARY,
+  N_UNARY,
+  N_UPDATE,
+  N_ASSIGN,
+  N_TERNARY,
+  N_CALL,
+  N_NEW,
+  N_MEMBER,
+  N_OPTIONAL,
+  N_ARRAY,
+  N_OBJECT,
+  N_PROPERTY,
+  N_SPREAD,
+  N_SEQUENCE,
+  N_ARROW,
+  N_YIELD,
+  N_AWAIT,
+  N_TYPEOF,
+  N_DELETE,
+  N_VOID,
+  N_TAGGED_TEMPLATE,
+  N_BLOCK,
+  N_VAR,
+  N_VARDECL,
+  N_IF,
+  N_WHILE,
+  N_DO_WHILE,
+  N_FOR,
+  N_FOR_IN,
+  N_FOR_OF,
+  N_FOR_AWAIT_OF,
+  N_RETURN,
+  N_BREAK,
+  N_CONTINUE,
+  N_THROW,
+  N_TRY,
+  N_SWITCH,
+  N_CASE,
+  N_LABEL,
+  N_DEBUGGER,
+  N_EMPTY,
+  N_WITH,
+  N_FUNC,
+  N_CLASS,
+  N_METHOD,
+  N_STATIC_BLOCK,
+  N_ARRAY_PAT,
+  N_OBJECT_PAT,
+  N_REST,
+  N_ASSIGN_PAT,
+  N_NEW_TARGET,
+  N_IMPORT,
+  N_IMPORT_DECL,
+  N_IMPORT_SPEC,
+  N_EXPORT,
+  N_PROGRAM,
+  N__COUNT
+} sv_node_type_t;
+
+typedef enum {
+  VAR_VAR,
+  VAR_LET,
+  VAR_CONST,
+} sv_var_kind_t;
+
+enum {
+  FN_ASYNC           = 1 << 0,
+  FN_GENERATOR       = 1 << 1,
+  FN_ARROW           = 1 << 2,
+  FN_GETTER          = 1 << 3,
+  FN_SETTER          = 1 << 4,
+  FN_STATIC          = 1 << 5,
+  FN_COMPUTED        = 1 << 6,
+  FN_METHOD          = 1 << 7,
+  FN_COLON           = 1 << 8,
+  FN_PAREN           = 1 << 9,
+  FN_USES_ARGS       = 1 << 10,
+  FN_INVALID_COOKED  = 1 << 11,
+  FN_PARSE_STRICT    = 1 << 12,
+};
+
+enum {
+  EX_DEFAULT   = 1 << 0,
+  EX_DECL      = 1 << 1,
+  EX_NAMED     = 1 << 2,
+  EX_FROM      = 1 << 3,
+  EX_STAR      = 1 << 4,
+  EX_NAMESPACE = 1 << 5,
+};
+
+typedef struct 
+  sv_ast sv_ast_t;
+
+typedef struct {
+  sv_ast_t **items;
+  int        count;
+  int        cap;
+} sv_ast_list_t;
+
+struct sv_ast {
+  sv_node_type_t  type;
+  uint8_t         op;
+  uint16_t        flags;
+  sv_var_kind_t   var_kind;
+
+  const char     *str;
+  uint32_t        len;
+  const char     *aux;
+  uint32_t        aux_len;
+  double          num;
+
+  sv_ast_t       *left;
+  sv_ast_t       *right;
+  sv_ast_t       *cond;
+  sv_ast_t       *body;
+  sv_ast_list_t   args;
+
+  sv_ast_t       *catch_param;
+  sv_ast_t       *catch_body;
+  sv_ast_t       *finally_body;
+
+  sv_ast_t       *init;
+  sv_ast_t       *update;
+
+  uint32_t        line;
+  uint32_t        col;
+  uint32_t        src_off;
+  uint32_t        src_end;
+};
+
+void sv_ast_list_push(sv_ast_list_t *list, sv_ast_t *node);
+bool sv_ast_can_be_expression_statement(const sv_ast_t *node);
+bool ast_references_arguments(const sv_ast_t *node);
+
+sv_ast_t *sv_ast_new(sv_node_type_t type);
+sv_ast_t *sv_parse(ant_t *js, const char *code, jsoff_t clen, bool strict);
+
+#endif
diff --git a/include/silver/compiler.h b/include/silver/compiler.h
new file mode 100644
index 0000000..31d1ad1
--- /dev/null
+++ b/include/silver/compiler.h
@@ -0,0 +1,31 @@
+#ifndef SILVER_COMPILER_H
+#define SILVER_COMPILER_H
+
+#include "silver/ast.h"
+#include "silver/vm.h"
+
+typedef enum {
+  SV_COMPILE_SCRIPT = 0,
+  SV_COMPILE_EVAL   = 1,
+  SV_COMPILE_MODULE = 2,
+  SV_COMPILE_REPL   = 3,
+} sv_compile_mode_t;
+
+sv_func_t *sv_compile(
+  ant_t *js, sv_ast_t *program,
+  sv_compile_mode_t mode,
+  const char *source, jsoff_t source_len
+);
+
+sv_func_t *sv_compile_function(
+  ant_t *js, const char *source,
+  size_t len, bool is_async
+);
+
+sv_func_t *sv_compile_function_parts(
+  ant_t *js, const char *params,
+  size_t params_len, const char *body,
+  size_t body_len, bool is_async
+);
+
+#endif
diff --git a/include/silver/directives.h b/include/silver/directives.h
new file mode 100644
index 0000000..bba7d6c
--- /dev/null
+++ b/include/silver/directives.h
@@ -0,0 +1,17 @@
+#ifndef SILVER_STRICT_H
+#define SILVER_STRICT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "ast.h"
+#include "types.h"
+
+bool sv_ast_is_directive(
+  ant_t *js, const sv_ast_t *node,
+  const char *directive, size_t directive_len
+);
+
+bool sv_ast_is_use_strict(ant_t *js, const sv_ast_t *node);
+
+#endif
diff --git a/include/silver/engine.h b/include/silver/engine.h
new file mode 100644
index 0000000..c3be8c9
--- /dev/null
+++ b/include/silver/engine.h
@@ -0,0 +1,571 @@
+#ifndef SILVER_ENGINE_H
+#define SILVER_ENGINE_H
+
+#include "silver/vm.h"
+#include "internal.h"
+#include "errors.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef enum {
+#define OP_DEF(name, size, n_pop, n_push, f) OP_##name,
+#include "silver/opcode.h"
+  OP__COUNT
+} sv_op_t;
+
+static const uint8_t sv_op_size[OP__COUNT] = {
+#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = (size),
+#include "silver/opcode.h"
+};
+
+typedef struct {
+  const char *str;
+  uint32_t    len;
+} sv_atom_t;
+
+typedef struct {
+  uint16_t  index;
+  bool      is_local;
+  bool      is_const;
+} sv_upval_desc_t;
+
+typedef struct {
+  uint32_t bc_offset;
+  uint32_t line;
+  uint32_t col;
+  uint32_t src_off;
+  uint32_t src_end;
+} sv_srcpos_t;
+
+bool sv_lookup_srcpos(sv_func_t *func, int bc_offset, uint32_t *line, uint32_t *col);
+bool sv_lookup_srcspan(sv_func_t *func, int bc_offset, uint32_t *src_off, uint32_t *src_end);
+
+struct sv_func {
+  uint8_t *code;
+  int code_len;
+  
+  jsval_t *constants;
+  int const_count;
+  
+  sv_atom_t *atoms;
+  int atom_count;
+  
+  sv_upval_desc_t *upval_descs;
+  int max_locals;
+  int max_stack;
+  int param_count;
+  int upvalue_count;
+  
+  bool is_strict;
+  bool is_arrow;
+  bool is_async;
+  bool is_generator;
+  bool is_method;
+  bool is_tla;
+  uint32_t gc_epoch;
+  
+  const char *name;
+  const char *filename;
+  
+  sv_srcpos_t *srcpos;
+  int srcpos_count;
+  int source_line;
+  
+  const char *source;
+  int source_len;
+  int source_start;
+  int source_end;
+  
+#ifdef ANT_JIT
+  void *jit_code;
+  
+  uint32_t call_count;
+  uint32_t back_edge_count;
+  
+  bool jit_compile_failed;
+  uint32_t tfb_version;
+  uint32_t jit_compiled_tfb_ver;
+  uint8_t *type_feedback;
+#endif
+};
+
+typedef enum {
+  SV_COMPLETION_NONE = 0,
+  SV_COMPLETION_THROW = 1,
+  SV_COMPLETION_RETURN = 2,
+} sv_completion_kind_t;
+
+typedef struct {
+  sv_completion_kind_t kind;
+  jsval_t              value;
+} sv_completion_t;
+
+typedef struct 
+  sv_upvalue sv_upvalue_t;
+
+typedef struct {
+  uint8_t *ip;
+  jsval_t *bp;
+  jsval_t *lp;
+  
+  sv_func_t *func;
+  jsval_t callee;
+  jsval_t this;
+  jsval_t new_target;
+  jsval_t super_val;
+  
+  int prev_sp;
+  int handler_base;
+  int handler_top;
+  int argc;
+  
+  sv_completion_t completion;
+  sv_upvalue_t **upvalues;
+  int upvalue_count;
+  jsval_t with_obj;
+} sv_frame_t;
+
+typedef enum {
+  SV_HANDLER_TRY = 1,
+  SV_HANDLER_FINALLY = 2,
+} sv_handler_kind_t;
+
+typedef struct {
+  uint8_t *ip;
+  int      saved_sp;
+  uint8_t  kind;
+} sv_handler_t;
+
+struct sv_upvalue {
+  jsval_t *location;
+  jsval_t closed;
+  struct sv_upvalue *next;
+  uint32_t gc_epoch;
+};
+
+#define SV_CALL_HAS_BOUND_ARGS  (1u << 0)
+#define SV_CALL_HAS_SUPER       (1u << 1)
+
+typedef struct sv_closure {
+  sv_func_t *func;
+  sv_upvalue_t **upvalues;
+  jsval_t bound_this;
+  jsval_t func_obj;
+  uint32_t gc_epoch;
+  uint8_t call_flags;
+} sv_closure_t;
+
+static inline sv_closure_t *js_func_closure(jsval_t func) {
+  return (sv_closure_t *)(uintptr_t)vdata(func);
+}
+
+static inline jsval_t js_func_obj(jsval_t func) {
+  return js_func_closure(func)->func_obj;
+}
+
+static inline jsval_t js_as_obj(jsval_t v) {
+  uint8_t t = vtype(v);
+  if (t == T_OBJ) return v;
+  if (t == T_FUNC) return js_func_obj(v);
+  return mkval(T_OBJ, vdata(v));
+}
+
+jsval_t sv_execute_closure_entry(
+  sv_vm_t *vm,sv_closure_t *closure,
+  jsval_t callee_func, jsval_t super_val,
+  jsval_t this_val, jsval_t *args,
+  int argc, jsval_t *out_this
+);
+
+#ifdef ANT_JIT
+typedef struct {
+  bool active;
+  int bc_offset;
+  jsval_t *locals;
+  int n_locals;
+  jsval_t *lp;
+} sv_jit_osr_t;
+#endif
+
+#define SV_TRY_MAX  64
+#define SV_TDZ      T_EMPTY
+#define SV_HANDLER_MAX (SV_TRY_MAX * 2)
+
+#define SV_FRAMES_HARD_MAX 65536
+#define SV_STACK_HARD_MAX  524288
+
+struct sv_vm {
+  ant_t *js;
+
+  jsval_t *stack;
+  int sp;
+  int stack_size;
+
+  sv_frame_t *frames;
+  int fp;
+  int max_frames;
+
+  sv_handler_t handler_stack[SV_HANDLER_MAX];
+  sv_upvalue_t *open_upvalues;
+  int handler_depth;
+
+#ifdef ANT_JIT
+  struct {
+    bool active;
+    int64_t ip_offset;
+    jsval_t *locals;
+    int64_t n_locals;
+    jsval_t *vstack;
+    int64_t vstack_sp;
+  } jit_resume;
+
+  sv_jit_osr_t jit_osr;
+#endif
+};
+
+static inline uint8_t sv_get_u8(const uint8_t *ip)  { return ip[0]; }
+static inline int8_t  sv_get_i8(const uint8_t *ip)  { return (int8_t)ip[0]; }
+
+static inline uint16_t sv_get_u16(const uint8_t *ip) {
+  uint16_t v; memcpy(&v, ip, 2); return v;
+}
+
+static inline int16_t sv_get_i16(const uint8_t *ip) {
+  int16_t v; memcpy(&v, ip, 2); return v;
+}
+
+static inline uint32_t sv_get_u32(const uint8_t *ip) {
+  uint32_t v; memcpy(&v, ip, 4); return v;
+}
+
+static inline int32_t sv_get_i32(const uint8_t *ip) {
+  int32_t v; memcpy(&v, ip, 4); return v;
+}
+
+static inline const char *sv_atom_cstr(sv_atom_t *a, char *buf, size_t bufsz) {
+  size_t n = a->len < bufsz - 1 ? a->len : bufsz - 1;
+  memcpy(buf, a->str, n);
+  buf[n] = '\0';
+  return buf;
+}
+
+static inline bool sv_frame_is_strict(const sv_frame_t *frame) {
+  return frame && frame->func && frame->func->is_strict;
+}
+
+static inline bool sv_is_nullish_this(jsval_t v) {
+  return 
+    vtype(v) == T_UNDEF || vtype(v) == T_NULL ||
+    (vtype(v) == T_OBJ && vdata(v) == 0);
+}
+
+static inline jsval_t sv_normalize_this_for_frame(ant_t *js, sv_func_t *func, jsval_t this_val) {
+  if (!func || func->is_arrow) return this_val;
+  if (func->is_strict) return sv_is_nullish_this(this_val) ? js_mkundef() : this_val;
+  return sv_is_nullish_this(this_val) ? js->global : this_val;
+}
+
+static inline bool sv_vm_is_strict(const sv_vm_t *vm) {
+  if (vm && vm->fp >= 0) {
+    const sv_frame_t *f = &vm->frames[vm->fp];
+    return f->func && f->func->is_strict;
+  }
+  return false;
+}
+
+static inline jsval_t sv_vm_get_new_target(const sv_vm_t *vm, ant_t *js) {
+  if (vm && vm->fp >= 0) return vm->frames[vm->fp].new_target;
+  return js->new_target;
+}
+
+static inline jsval_t sv_vm_get_super_val(const sv_vm_t *vm) {
+  if (vm && vm->fp >= 0) return vm->frames[vm->fp].super_val;
+  return js_mkundef();
+}
+
+static inline int sv_frame_arg_slots(const sv_frame_t *frame) {
+  if (!frame || !frame->func) return 0;
+  return frame->argc > frame->func->param_count ? frame->argc : frame->func->param_count;
+}
+
+static inline jsval_t sv_frame_get_arg_value(const sv_frame_t *frame, uint16_t idx) {
+  int arg_slots = sv_frame_arg_slots(frame);
+  if (!frame || !frame->bp || (int)idx >= arg_slots) return js_mkundef();
+  return frame->bp[idx];
+}
+
+static inline void sv_frame_set_arg_value(sv_frame_t *frame, uint16_t idx, jsval_t val) {
+  int arg_slots = sv_frame_arg_slots(frame);
+  if (!frame || !frame->bp || (int)idx >= arg_slots) return;
+  frame->bp[idx] = val;
+}
+
+static inline jsval_t *sv_frame_slot_ptr(sv_frame_t *frame, uint16_t slot_idx) {
+  if (!frame || !frame->func) return NULL;
+  int param_count = frame->func->param_count;
+  if ((int)slot_idx < param_count) {
+    int arg_slots = sv_frame_arg_slots(frame);
+    if ((int)slot_idx >= arg_slots || !frame->bp) return NULL;
+    return &frame->bp[slot_idx];
+  }
+  if (!frame->lp) return NULL;
+  return &frame->lp[slot_idx - param_count];
+}
+
+static inline jsval_t sv_vm_call(
+  sv_vm_t *vm, ant_t *js, jsval_t func,
+  jsval_t this_val, jsval_t *args, int argc,
+  jsval_t *out_this, bool is_construct_call
+);
+
+typedef struct {
+  jsval_t  this_val;
+  jsval_t  super_val;
+  jsval_t *args;
+  int      argc;
+  jsval_t *alloc;
+} sv_call_ctx_t;
+
+static inline jsval_t sv_call_cfunc(
+  ant_t *js, jsval_t func,
+  jsval_t this_val, jsval_t *args, int argc
+) {
+  js->this_val = this_val;
+  return js_as_cfunc(func)(js, args, argc);
+}
+
+static inline jsval_t sv_call_resolve_bound(ant_t *js, jsval_t func_obj, sv_call_ctx_t *ctx) {
+  jsval_t bound_this = js_get_slot(js, func_obj, SLOT_BOUND_THIS);
+  if (js_get_slot(js, func_obj, SLOT_ARROW) == js_true) {
+    ctx->this_val = bound_this;
+  } else if (vtype(bound_this) != T_UNDEF) ctx->this_val = bound_this;
+
+  jsval_t bound_arr = js_get_slot(js, func_obj, SLOT_BOUND_ARGS);
+  if (vtype(bound_arr) == T_ARR) {
+    int bound_argc = (int)js_arr_len(js, bound_arr);
+    if (bound_argc > 0) {
+      int total = bound_argc + ctx->argc;
+      jsval_t *combined = malloc(sizeof(jsval_t) * (size_t)total);
+      if (!combined) return js_mkerr(js, "out of memory");
+      for (int i = 0; i < bound_argc; i++)
+        combined[i] = js_arr_get(js, bound_arr, (jsoff_t)i);
+      for (int i = 0; i < ctx->argc; i++)
+        combined[bound_argc + i] = ctx->args[i];
+      ctx->args  = combined;
+      ctx->argc  = total;
+      ctx->alloc = combined;
+    }
+  }
+
+  jsval_t func_super = js_get_slot(js, func_obj, SLOT_SUPER);
+  if (vtype(func_super) != T_UNDEF) ctx->super_val = func_super;
+
+  return js_mkundef();
+}
+
+static inline void sv_call_cleanup(ant_t *js, sv_call_ctx_t *ctx) {
+  if (ctx->alloc) { free(ctx->alloc); ctx->alloc = NULL; }
+}
+
+static inline jsval_t sv_call_default_ctor(
+  sv_vm_t *vm, ant_t *js, jsval_t func_obj,
+  sv_call_ctx_t *ctx, jsval_t *out_this
+) {
+  if (vtype(js->new_target) == T_UNDEF) {
+    sv_call_cleanup(js, ctx);
+    return js_mkerr_typed(
+      js, JS_ERR_TYPE, 
+      "Class constructor cannot be invoked without 'new'"
+    );
+  }
+
+  jsval_t super_ctor = js_get_slot(js, func_obj, SLOT_SUPER);
+  uint8_t st = vtype(super_ctor);
+  if (st == T_FUNC || st == T_CFUNC) {
+    jsval_t super_this = ctx->this_val;
+    jsval_t result = sv_vm_call(
+      vm, js, super_ctor, ctx->this_val,
+      ctx->args, ctx->argc, &super_this, true
+    );
+    if (out_this) *out_this = super_this;
+    sv_call_cleanup(js, ctx);
+    return result;
+  }
+
+  sv_call_cleanup(js, ctx);
+  return js_mkundef();
+}
+
+jsval_t sv_call_async_closure_dispatch(
+  sv_vm_t *vm, ant_t *js, sv_closure_t *closure,
+  jsval_t callee_func, jsval_t super_val,
+  jsval_t this_val, jsval_t *args, int argc
+);
+
+static inline jsval_t sv_call_async_closure(
+  sv_vm_t *vm, ant_t *js, sv_closure_t *closure,
+  jsval_t callee_func, sv_call_ctx_t *ctx
+) {
+  jsval_t result = sv_call_async_closure_dispatch(
+    vm, js, closure, callee_func,
+    ctx->super_val, ctx->this_val, ctx->args, ctx->argc
+  );
+  sv_call_cleanup(js, ctx);
+  return result;
+}
+
+static inline jsval_t sv_call_closure(
+  sv_vm_t *vm, ant_t *js, sv_closure_t *closure,
+  jsval_t callee_func, sv_call_ctx_t *ctx, jsval_t *out_this
+) {
+  jsval_t result = sv_execute_closure_entry(
+    vm, closure, callee_func, ctx->super_val,
+    ctx->this_val, ctx->args, ctx->argc, out_this
+  );
+  sv_call_cleanup(js, ctx);
+  return result;
+}
+
+#ifdef ANT_JIT
+
+#define SV_TFB_NUM   (1 << 0)
+#define SV_TFB_STR   (1 << 1)
+#define SV_TFB_BOOL  (1 << 2)
+#define SV_TFB_OTHER (1 << 3)
+
+#define SV_JIT_THRESHOLD       100
+#define SV_JIT_RECOMPILE_DELAY 50
+#define SV_TFB_ALLOC_THRESHOLD 2
+#define SV_JIT_RETRY_INTERP    mkval(T_ERR, 1)
+#define SV_JIT_MAGIC           0xBA110ULL
+
+#define SV_JIT_BAILOUT \
+  (NANBOX_PREFIX \
+    | ((jsval_t)T_SENTINEL << NANBOX_TYPE_SHIFT) \
+    | SV_JIT_MAGIC)
+  
+static inline bool sv_is_jit_bailout(jsval_t v) { 
+  return v == SV_JIT_BAILOUT;
+}
+
+static inline void sv_jit_on_bailout(sv_func_t *fn) {
+  fn->jit_code = NULL;
+  fn->back_edge_count = 0;
+  fn->call_count = SV_JIT_THRESHOLD - SV_JIT_RECOMPILE_DELAY;
+}
+
+typedef jsval_t (*sv_jit_func_t)
+  (sv_vm_t *, jsval_t, jsval_t *, int, sv_closure_t *);
+
+jsval_t sv_jit_try_compile_and_call(sv_vm_t *vm, ant_t *js,
+  sv_closure_t *closure, jsval_t callee_func,
+  sv_call_ctx_t *ctx, jsval_t *out_this
+);
+
+static inline uint8_t sv_tfb_classify(jsval_t v) {
+  if (vtype(v) == T_NUM) return SV_TFB_NUM;
+  if (vtype(v) == T_STR) return SV_TFB_STR;
+  if (vtype(v) == T_BOOL) return SV_TFB_BOOL;
+  return SV_TFB_OTHER;
+}
+
+static inline void sv_tfb_record2(sv_func_t *func, uint8_t *ip, jsval_t l, jsval_t r) {
+if (func->type_feedback) {
+  int off = (int)(ip - func->code);
+  uint8_t old = func->type_feedback[off];
+  uint8_t neu = old | sv_tfb_classify(l) | sv_tfb_classify(r);
+  if (neu != old) { func->type_feedback[off] = neu; func->tfb_version++; }
+}}
+
+static inline void sv_tfb_record1(sv_func_t *func, uint8_t *ip, jsval_t v) {
+if (func->type_feedback) {
+  int off = (int)(ip - func->code);
+  uint8_t old = func->type_feedback[off];
+  uint8_t neu = old | sv_tfb_classify(v);
+  if (neu != old) { func->type_feedback[off] = neu; func->tfb_version++; }
+}}
+
+static inline void sv_tfb_ensure(sv_func_t *fn) {
+  if (!fn->type_feedback && fn->code_len > 0)
+    fn->type_feedback = calloc((size_t)fn->code_len, 1);
+}
+#endif
+
+static inline jsval_t sv_call_resolve_closure(
+  sv_vm_t *vm, ant_t *js, sv_closure_t *closure,
+  jsval_t callee_func, sv_call_ctx_t *ctx, jsval_t *out_this
+) {
+  if (closure->func->is_async)
+    return sv_call_async_closure(vm, js, closure, callee_func, ctx);
+#ifdef ANT_JIT
+  if (!closure->func->is_generator) {
+    sv_func_t *fn = closure->func;
+    if (fn->jit_code) {
+      jsval_t result = ((sv_jit_func_t)fn->jit_code)(vm, ctx->this_val, ctx->args, ctx->argc, closure);
+      if (sv_is_jit_bailout(result)) {
+        sv_jit_on_bailout(fn);
+      } else { sv_call_cleanup(js, ctx); return result; }
+    }
+    {
+      uint32_t cc = ++fn->call_count;
+      if (__builtin_expect(cc == SV_TFB_ALLOC_THRESHOLD, 0))
+        sv_tfb_ensure(fn);
+      if (cc > SV_JIT_THRESHOLD) {
+        jsval_t result = sv_jit_try_compile_and_call(vm, js, closure, callee_func, ctx, out_this);
+        if (result != SV_JIT_RETRY_INTERP) return result;
+      }
+    }
+  }
+#endif
+  return sv_call_closure(vm, js, closure, callee_func, ctx, out_this);
+}
+
+static inline jsval_t sv_vm_call(
+  sv_vm_t *vm, ant_t *js, jsval_t func,
+  jsval_t this_val, jsval_t *args, int argc,
+  jsval_t *out_this, bool is_construct_call
+) {
+  if (!is_construct_call) js->new_target = js_mkundef();
+  if (out_this) *out_this = this_val;
+
+  if (!is_construct_call && vtype(func) == T_OBJ && is_proxy(js, func))
+    return js_proxy_apply(js, func, this_val, args, argc);
+
+  if (vtype(func) == T_CFUNC) {
+    jsval_t cfunc_this = sv_is_nullish_this(this_val) ? js->global : this_val;
+    return sv_call_cfunc(js, func, cfunc_this, args, argc);
+  }
+
+  if (vtype(func) != T_FUNC)
+    return sv_call_native(js, func, this_val, args, argc);
+
+  sv_closure_t *closure = js_func_closure(func);
+  jsval_t func_obj = closure->func_obj;
+
+  sv_call_ctx_t ctx = {
+    .this_val = this_val, .super_val = js_mkundef(),
+    .args = args, .argc = argc, .alloc = NULL,
+  };
+
+  jsval_t err = sv_call_resolve_bound(js, func_obj, &ctx);
+  if (is_err(err)) return err;
+
+  if (is_construct_call) ctx.this_val = this_val;
+  if (out_this) *out_this = ctx.this_val;
+
+  if (js_get_slot(js, func_obj, SLOT_DEFAULT_CTOR) == js_true)
+    return sv_call_default_ctor(vm, js, func_obj, &ctx, out_this);
+
+  if (closure->func != NULL)
+    return sv_call_resolve_closure(vm, js, closure, func, &ctx, out_this);
+
+  jsval_t result = sv_call_native(js, func, ctx.this_val, ctx.args, ctx.argc);
+  sv_call_cleanup(js, &ctx);
+  
+  return result;
+}
+
+#endif
diff --git a/include/silver/glue.h b/include/silver/glue.h
new file mode 100644
index 0000000..3c1b039
--- /dev/null
+++ b/include/silver/glue.h
@@ -0,0 +1,143 @@
+#ifndef SILVER_GLUE_H
+#define SILVER_GLUE_H
+
+#ifdef ANT_JIT
+#include "silver/engine.h"
+
+double jit_helper_tod(jsval_t v);
+uint64_t jit_helper_vtype(jsval_t v);
+int64_t jit_helper_is_truthy(ant_t *js, jsval_t v);
+
+jsval_t jit_helper_tov(double d);
+jsval_t jit_helper_mkbool(int b);
+
+bool jit_helper_stack_overflow(ant_t *js);
+sv_closure_t *jit_helper_get_closure(jsval_t v);
+
+jsval_t jit_helper_add(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_sub(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_mul(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_div(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_mod(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+
+jsval_t jit_helper_object(sv_vm_t *vm, ant_t *js);
+jsval_t jit_helper_get_length(sv_vm_t *vm, ant_t *js, jsval_t obj);
+jsval_t jit_helper_catch_value(sv_vm_t *vm, ant_t *js, jsval_t err);
+jsval_t jit_helper_throw(sv_vm_t *vm, ant_t *js, jsval_t val);
+
+jsval_t jit_helper_lt(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_le(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_seq(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_eq(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_in(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_gt(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_ge(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_ne(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_sne(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+
+jsval_t jit_helper_band(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_bor(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_bxor(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_bnot(sv_vm_t *vm, ant_t *js, jsval_t v);
+jsval_t jit_helper_shl(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_shr(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_ushr(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_not(sv_vm_t *vm, ant_t *js, jsval_t v);
+
+jsval_t jit_helper_get_global(ant_t *js, const char *str, uint32_t len);
+jsval_t jit_helper_to_propkey(sv_vm_t *vm, ant_t *js, jsval_t v);
+jsval_t jit_helper_stack_overflow_error(sv_vm_t *vm, ant_t *js);
+jsval_t jit_helper_instanceof(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r);
+jsval_t jit_helper_delete(sv_vm_t *vm, ant_t *js, jsval_t obj, jsval_t key);
+jsval_t jit_helper_typeof(sv_vm_t *vm, ant_t *js, jsval_t v);
+
+jsval_t jit_helper_call(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t func, jsval_t this_val,
+  jsval_t *args, int argc
+);
+
+jsval_t jit_helper_get_field(
+  sv_vm_t *vm, ant_t *js, jsval_t obj,
+  const char *str, uint32_t len, 
+  sv_func_t *func, int32_t bc_off
+);
+
+jsval_t jit_helper_closure(
+  sv_vm_t *vm, ant_t *js,
+  sv_closure_t *parent_closure, jsval_t this_val,
+  jsval_t *args, int argc,
+  uint32_t const_idx, jsval_t *locals, int n_locals
+);
+
+jsval_t jit_helper_bailout_resume(
+  sv_vm_t *vm, sv_closure_t *closure,
+  jsval_t this_val, jsval_t *args, int argc,
+  jsval_t *vstack, int64_t vstack_sp,
+  jsval_t *locals, int64_t n_locals,
+  int64_t bc_offset
+);
+
+void jit_helper_close_upval(
+  sv_vm_t *vm, uint16_t slot_idx,
+  jsval_t *locals, int n_locals
+);
+
+void jit_helper_define_field(
+  sv_vm_t *vm, ant_t *js, jsval_t obj,
+  jsval_t val, const char *str, uint32_t len
+);
+
+void jit_helper_set_name(
+  sv_vm_t *vm, ant_t *js, jsval_t fn,
+  const char *str, uint32_t len
+);
+
+jsval_t jit_helper_put_field(
+  sv_vm_t *vm, ant_t *js, jsval_t obj,
+  jsval_t val, const char *str, uint32_t len
+);
+
+jsval_t jit_helper_get_elem(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t obj, jsval_t key, sv_func_t *func, int32_t bc_off
+);
+
+jsval_t jit_helper_put_elem(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t obj, jsval_t key, jsval_t val
+);
+
+jsval_t jit_helper_put_global(
+  sv_vm_t *vm, ant_t *js, jsval_t val,
+  const char *str, uint32_t len, int is_strict
+);
+
+jsval_t jit_helper_array(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t *elements, int count
+);
+
+jsval_t jit_helper_throw_error(
+  sv_vm_t *vm, ant_t *js,
+  const char *str, uint32_t len, int err_type
+);
+
+jsval_t jit_helper_get_elem2(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t obj, jsval_t key
+);
+
+jsval_t jit_helper_set_proto(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t obj, jsval_t proto
+);
+
+jsval_t jit_helper_new(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t func, jsval_t new_target,
+  jsval_t *args, int argc
+);
+
+#endif
+#endif
diff --git a/include/silver/lexer.h b/include/silver/lexer.h
new file mode 100644
index 0000000..dff4f27
--- /dev/null
+++ b/include/silver/lexer.h
@@ -0,0 +1,58 @@
+#ifndef SILVER_LEXER_H
+#define SILVER_LEXER_H
+
+#include <stdbool.h>
+#include "types.h"
+
+typedef struct {
+  jsoff_t pos;
+  jsoff_t toff;
+  jsoff_t tlen;
+  jsval_t tval;
+  uint8_t tok;
+  uint8_t consumed;
+  bool had_newline;
+} sv_lexer_state_t;
+
+typedef struct {
+  ant_t *js;
+  const char *code;
+  jsoff_t clen;
+  bool strict;
+  sv_lexer_state_t st;
+} sv_lexer_t;
+
+typedef struct {
+  const char *str;
+  uint32_t len;
+  bool ok;
+} sv_lex_string_t;
+
+typedef struct {
+  const char *code;
+  jsoff_t clen;
+  bool strict;
+  sv_lexer_state_t st;
+} sv_lexer_checkpoint_t;
+
+sv_lex_string_t sv_lexer_str_literal(sv_lexer_t *lx);
+
+void sv_lexer_init(sv_lexer_t *lx, ant_t *js, const char *code, jsoff_t clen, bool strict);
+void sv_lexer_set_error_site(sv_lexer_t *lx);
+
+void sv_lexer_save_state(const sv_lexer_t *lx, sv_lexer_state_t *st);
+void sv_lexer_restore_state(sv_lexer_t *lx, const sv_lexer_state_t *st);
+
+void sv_lexer_push_source(sv_lexer_t *lx, sv_lexer_checkpoint_t *cp, const char *code, jsoff_t clen);
+void sv_lexer_pop_source(sv_lexer_t *lx, const sv_lexer_checkpoint_t *cp);
+
+uint8_t sv_lexer_next(sv_lexer_t *lx);
+uint8_t sv_lexer_lookahead(sv_lexer_t *lx);
+
+bool is_space(int c);
+bool is_digit(int c);
+
+bool is_eval_or_arguments_name(const char *buf, size_t len);
+bool is_strict_reserved_name(const char *buf, size_t len);
+
+#endif
diff --git a/include/silver/opcode.h b/include/silver/opcode.h
new file mode 100644
index 0000000..bbf0501
--- /dev/null
+++ b/include/silver/opcode.h
@@ -0,0 +1,235 @@
+#ifdef OP_FMT
+OP_FMT(none)
+OP_FMT(u8)
+OP_FMT(i8)
+OP_FMT(u16)
+OP_FMT(i16)
+OP_FMT(u32)
+OP_FMT(i32)
+OP_FMT(atom)
+OP_FMT(atom_u8)
+OP_FMT(label)
+OP_FMT(label8)
+OP_FMT(loc)
+OP_FMT(loc8)
+OP_FMT(loc_atom)
+OP_FMT(arg)
+OP_FMT(const)
+OP_FMT(const8)
+OP_FMT(npop)
+OP_FMT(var_ref)
+#undef OP_FMT
+#endif
+
+#ifdef  OP_DEF
+#ifndef op_def
+#define op_def(name, size, n_pop, n_push, f) OP_DEF(name, size, n_pop, n_push, f)
+#endif
+
+OP_DEF(  INVALID,           1,   0,   0, none)
+OP_DEF(  CONST,             5,   0,   1, const)     /* push constant pool[idx] */
+OP_DEF(  CONST_I8,          2,   0,   1, i8)        /* push small integer */
+OP_DEF(  CONST8,            2,   0,   1, const8)    /* push constant pool[u8 idx] */
+OP_DEF(  UNDEF,             1,   0,   1, none)
+OP_DEF(  NULL,              1,   0,   1, none)
+OP_DEF(  TRUE,              1,   0,   1, none)
+OP_DEF(  FALSE,             1,   0,   1, none)
+OP_DEF(  THIS,              1,   0,   1, none)      /* push current 'this' */
+OP_DEF(  GLOBAL,            1,   0,   1, none)      /* push 'globalThis' (js->global) */
+OP_DEF(  OBJECT,            1,   0,   1, none)      /* push empty object {} */
+OP_DEF(  ARRAY,             3,   0,   1, npop)      /* push array from stack items */
+OP_DEF(  REGEXP,            1,   2,   1, none)      /* pattern flags -> regexp */
+OP_DEF(  CLOSURE,           5,   0,   1, const)     /* push closure from func pool */
+
+OP_DEF(  POP,               1,   1,   0, none)      /* a -> */
+OP_DEF(  DUP,               1,   1,   2, none)      /* a -> a a */
+OP_DEF(  DUP2,              1,   2,   4, none)      /* a b -> a b a b */
+OP_DEF(  SWAP,              1,   2,   2, none)      /* a b -> b a */
+OP_DEF(  ROT3L,             1,   3,   3, none)      /* x a b -> a b x */
+OP_DEF(  ROT3R,             1,   3,   3, none)      /* a b x -> x a b */
+OP_DEF(  NIP,               1,   2,   1, none)      /* a b -> b */
+OP_DEF(  NIP2,              1,   3,   1, none)      /* a b c -> c */
+OP_DEF(  INSERT2,           1,   2,   3, none)      /* obj a -> a obj a */
+OP_DEF(  INSERT3,           1,   3,   4, none)      /* obj prop a -> a obj prop a */
+OP_DEF(  SWAP_UNDER,        1,   3,   3, none)      /* a b c -> b a c */
+OP_DEF(  ROT4_UNDER,        1,   4,   4, none)      /* a b c d -> c a b d */
+
+OP_DEF(  GET_LOCAL,         3,   0,   1, loc)
+OP_DEF(  PUT_LOCAL,         3,   1,   0, loc)       /* store, consume */
+OP_DEF(  SET_LOCAL,         3,   1,   1, loc)       /* store, keep on stack */
+OP_DEF(  GET_LOCAL8,        2,   0,   1, loc8)      /* short encoding */
+OP_DEF(  PUT_LOCAL8,        2,   1,   0, loc8)
+OP_DEF(  SET_LOCAL8,        2,   1,   1, loc8)
+OP_DEF(  SET_LOCAL_UNDEF,   3,   0,   0, loc)       /* mark TDZ uninitialized */
+OP_DEF(  GET_LOCAL_CHK,     7,   0,   1, loc_atom)  /* get + TDZ check (u16 slot, u32 atom) */
+OP_DEF(  PUT_LOCAL_CHK,     7,   1,   0, loc_atom)  /* put + TDZ check (u16 slot, u32 atom) */
+
+OP_DEF(  GET_ARG,           3,   0,   1, arg)
+OP_DEF(  PUT_ARG,           3,   1,   0, arg)
+OP_DEF(  SET_ARG,           3,   1,   1, arg)
+OP_DEF(  REST,              3,   0,   1, u16)       /* collect rest params */
+
+OP_DEF(  GET_UPVAL,         3,   0,   1, var_ref)
+OP_DEF(  PUT_UPVAL,         3,   1,   0, var_ref)
+OP_DEF(  SET_UPVAL,         3,   1,   1, var_ref)
+OP_DEF(  CLOSE_UPVAL,       3,   0,   0, loc)       /* close upvalues >= loc */
+
+OP_DEF(  GET_GLOBAL,        5,   0,   1, atom)      /* push global[atom] */
+OP_DEF(  GET_GLOBAL_UNDEF,  5,   0,   1, atom)      /* push undefined if missing */
+OP_DEF(  PUT_GLOBAL,        5,   1,   0, atom)      /* global[atom] = TOS */
+
+OP_DEF(  GET_FIELD,         5,   1,   1, atom)      /* obj -> val */
+OP_DEF(  GET_FIELD2,        5,   1,   2, atom)      /* obj -> obj val */
+OP_DEF(  PUT_FIELD,         5,   2,   0, atom)      /* obj val -> */
+OP_DEF(  GET_ELEM,          1,   2,   1, none)      /* obj key -> val */
+OP_DEF(  GET_ELEM2,         1,   2,   2, none)      /* obj key -> obj val */
+OP_DEF(  PUT_ELEM,          1,   3,   0, none)      /* obj key val -> */
+OP_DEF(  DEFINE_FIELD,      5,   2,   1, atom)      /* obj val -> obj (own prop) */
+OP_DEF(  GET_LENGTH,        1,   1,   1, none)      /* obj -> length */
+
+OP_DEF(  GET_FIELD_OPT,    5,   1,   1, atom)       /* null-safe obj -> val */
+OP_DEF(  GET_ELEM_OPT,     1,   2,   1, none)       /* null-safe obj key -> val */
+
+OP_DEF(  GET_PRIVATE,      1,   2,   1, none)       /* obj prop -> value */
+OP_DEF(  PUT_PRIVATE,      1,   3,   0, none)       /* obj value prop -> */
+OP_DEF(  DEF_PRIVATE,      1,   3,   1, none)       /* obj prop value -> obj */
+
+OP_DEF(  GET_SUPER,         1,   1,   1, none)      /* obj -> super */
+OP_DEF(  GET_SUPER_VAL,     1,   3,   1, none)      /* this obj prop -> value */
+OP_DEF(  PUT_SUPER_VAL,     1,   4,   0, none)      /* this obj prop value -> */
+
+OP_DEF(  ADD,               1,   2,   1, none)
+OP_DEF(  SUB,               1,   2,   1, none)
+OP_DEF(  MUL,               1,   2,   1, none)
+OP_DEF(  DIV,               1,   2,   1, none)
+OP_DEF(  MOD,               1,   2,   1, none)
+OP_DEF(  EXP,               1,   2,   1, none)
+OP_DEF(  NEG,               1,   1,   1, none)      /* unary minus */
+OP_DEF(  UPLUS,             1,   1,   1, none)      /* unary plus (ToNumber) */
+OP_DEF(  INC,               1,   1,   1, none)      /* +1 */
+OP_DEF(  DEC,               1,   1,   1, none)      /* -1 */
+OP_DEF(  POST_INC,          1,   1,   2, none)      /* -> old new */
+OP_DEF(  POST_DEC,          1,   1,   2, none)      /* -> old new */
+OP_DEF(  INC_LOCAL,         2,   0,   0, loc8)      /* locals[i]++ in-place */
+OP_DEF(  DEC_LOCAL,         2,   0,   0, loc8)      /* locals[i]-- in-place */
+OP_DEF(  ADD_LOCAL,         2,   1,   0, loc8)      /* locals[i] += TOS */
+
+OP_DEF(  EQ,                1,   2,   1, none)      /* == (abstract) */
+OP_DEF(  NE,                1,   2,   1, none)      /* != */
+OP_DEF(  SEQ,               1,   2,   1, none)      /* === (strict, matches TOK_SEQ) */
+OP_DEF(  SNE,               1,   2,   1, none)      /* !== (strict, matches TOK_SNE) */
+OP_DEF(  LT,                1,   2,   1, none)
+OP_DEF(  LE,                1,   2,   1, none)
+OP_DEF(  GT,                1,   2,   1, none)
+OP_DEF(  GE,                1,   2,   1, none)
+OP_DEF(  INSTANCEOF,        1,   2,   1, none)
+OP_DEF(  IN,                1,   2,   1, none)
+OP_DEF(  IS_NULLISH,        1,   1,   1, none)      /* TOS is null|undefined? */
+OP_DEF(  IS_UNDEF_OR_NULL,  1,   1,   1, none)      /* same, for ?? chains */
+
+OP_DEF(  BAND,              1,   2,   1, none)      /* & (matches TOK_AND) */
+OP_DEF(  BOR,               1,   2,   1, none)      /* | (matches TOK_OR) */
+OP_DEF(  BXOR,              1,   2,   1, none)      /* ^ (matches TOK_XOR) */
+OP_DEF(  BNOT,              1,   1,   1, none)      /* ~ (matches TOK_TILDA) */
+OP_DEF(  SHL,               1,   2,   1, none)      /* << */
+OP_DEF(  SHR,               1,   2,   1, none)      /* >> (signed) */
+OP_DEF(  USHR,              1,   2,   1, none)      /* >>> (matches TOK_ZSHR) */
+
+OP_DEF(  NOT,               1,   1,   1, none)      /* ! */
+OP_DEF(  TYPEOF,            1,   1,   1, none)
+OP_DEF(  VOID,              1,   1,   1, none)      /* eval + push undefined */
+OP_DEF(  DELETE,            1,   2,   1, none)      /* obj key -> bool */
+OP_DEF(  DELETE_VAR,        5,   0,   1, atom)      /* delete unqualified name */
+
+OP_DEF(  JMP,               5,   0,   0, label)     /* unconditional */
+OP_DEF(  JMP_FALSE,         5,   1,   0, label)     /* pop + branch if falsy */
+OP_DEF(  JMP_TRUE,          5,   1,   0, label)     /* pop + branch if truthy */
+OP_DEF(  JMP_FALSE_PEEK,    5,   1,   1, label)     /* peek + branch if falsy */
+OP_DEF(  JMP_TRUE_PEEK,     5,   1,   1, label)     /* peek + branch if truthy */
+OP_DEF(  JMP_NOT_NULLISH,   5,   1,   1, label)     /* peek + branch if NOT null/undefined */
+OP_DEF(  JMP8,              2,   0,   0, label8)    /* short unconditional */
+OP_DEF(  JMP_FALSE8,        2,   1,   0, label8)    /* short conditional */
+OP_DEF(  JMP_TRUE8,         2,   1,   0, label8)    /* short conditional */
+
+OP_DEF(  CALL,              3,   1,   1, npop)      /* func args... -> result */
+OP_DEF(  CALL_METHOD,       3,   2,   1, npop)      /* this func args... -> result */
+OP_DEF(  TAIL_CALL,         3,   1,   0, npop)      /* tail-position call */
+OP_DEF(  TAIL_CALL_METHOD,  3,   2,   0, npop)
+OP_DEF(  NEW,               3,   2,   1, npop)      /* func new.target args -> obj */
+OP_DEF(  APPLY,             3,   3,   1, u16)       /* func this [args] -> result */
+OP_DEF(  EVAL,              5,   1,   1, npop)      /* direct eval */
+OP_DEF(  RETURN,            1,   1,   0, none)
+OP_DEF(  RETURN_UNDEF,      1,   0,   0, none)
+OP_DEF(  RETURN_ASYNC,      1,   1,   0, none)      /* return from async func */
+OP_DEF(  CHECK_CTOR,        1,   0,   0, none)      /* verify called with new */
+OP_DEF(  CHECK_CTOR_RET,    1,   1,   2, none)      /* validate constructor return */
+OP_DEF(  HALT,              1,   0,   0, none)      /* stop execution */
+
+OP_DEF(  THROW,             1,   1,   0, none)
+OP_DEF(  THROW_ERROR,       6,   0,   0, atom_u8)   /* throw built-in error */
+OP_DEF(  TRY_PUSH,          5,   0,   0, label)     /* push catch handler */
+OP_DEF(  TRY_POP,           1,   0,   0, none)      /* pop catch handler */
+OP_DEF(  CATCH,             5,   0,   1, label)     /* push caught value + finally addr */
+OP_DEF(  FINALLY,           5,   0,   0, label)     /* enter finally block */
+OP_DEF(  FINALLY_RET,       1,   1,   0, none)      /* return from finally */
+OP_DEF(  NIP_CATCH,         1,   2,   1, none)      /* catch ... a -> a */
+
+OP_DEF(  FOR_IN,            1,   1,   1, none)      /* obj -> iterator */
+OP_DEF(  FOR_OF,            1,   1,   3, none)      /* iterable -> iter next catch_off */
+OP_DEF(  FOR_AWAIT_OF,      1,   1,   3, none)      /* async iterable -> iter next catch_off */
+OP_DEF(  ITER_NEXT,         1,   3,   5, none)      /* advance iterator */
+OP_DEF(  ITER_GET_VALUE,    1,   2,   3, none)      /* catch_off obj -> catch_off value done */
+OP_DEF(  ITER_CLOSE,        1,   3,   0, none)      /* close iterator */
+OP_DEF(  ITER_CALL,         2,   4,   5, u8)        /* call iterator method */
+OP_DEF(  AWAIT_ITER_NEXT,   1,   3,   4, none)      /* async iterator next */
+
+OP_DEF(  AWAIT,             1,   1,   1, none)      /* promise -> resolved value */
+OP_DEF(  YIELD,             1,   1,   2, none)      /* val -> received */
+OP_DEF(  YIELD_STAR,        1,   1,   2, none)      /* delegate to sub-iterator */
+OP_DEF(  INITIAL_YIELD,     1,   0,   0, none)      /* generator entry point */
+OP_DEF(  SPREAD,            1,   1,   0, none)      /* arr iterable -> arr */
+
+OP_DEF(  DEFINE_METHOD,     6,   2,   1, atom_u8)   /* obj func -> obj (flags: get/set/static) */
+OP_DEF(  DEFINE_METHOD_COMP,2,   3,   1, u8)        /* obj key func -> obj (computed name) */
+OP_DEF(  SET_NAME,          5,   1,   1, atom)      /* set .name on function */
+OP_DEF(  SET_NAME_COMP,     1,   2,   2, none)      /* set .name from computed key */
+OP_DEF(  SET_PROTO,         1,   2,   1, none)      /* obj proto -> obj */
+OP_DEF(  SET_HOME_OBJ,      1,   2,   2, none)      /* func home -> func home */
+OP_DEF(  APPEND,            1,   3,   2, none)      /* append to array, update length */
+OP_DEF(  COPY_DATA_PROPS,   2,   3,   3, u8)        /* Object.assign-like */
+
+OP_DEF(  DEFINE_CLASS,      6,   2,   2, atom_u8)   /* parent ctor -> ctor proto */
+OP_DEF(  DEFINE_CLASS_COMP, 6,   3,   3, atom_u8)   /* computed name variant */
+OP_DEF(  ADD_BRAND,         1,   2,   0, none)      /* this_obj home_obj -> (private brand) */
+
+OP_DEF(  TO_OBJECT,         1,   1,   1, none)      /* coerce to object wrapper */
+OP_DEF(  TO_PROPKEY,        1,   1,   1, none)      /* coerce to string/symbol */
+OP_DEF(  IS_UNDEF,          1,   1,   1, none)      /* TOS === undefined */
+OP_DEF(  IS_NULL,           1,   1,   1, none)      /* TOS === null */
+
+OP_DEF(  IMPORT,            1,   2,   1, none)      /* dynamic import(specifier) */
+OP_DEF(  IMPORT_SYNC,       1,   1,   1, none)      /* sync module load for static import */
+OP_DEF(  IMPORT_DEFAULT,    1,   1,   1, none)      /* ns -> default (SLOT_DEFAULT or ns) */
+OP_DEF(  EXPORT,            5,   1,   0, atom)      /* value -> (module namespace[name] = value) */
+OP_DEF(  EXPORT_ALL,        1,   1,   0, none)      /* ns -> (export all properties) */
+
+OP_DEF(  ENTER_WITH,        1,   1,   0, none)      /* enter with(obj) block */
+OP_DEF(  EXIT_WITH,         1,   0,   0, none)      /* exit with(obj) block */
+
+OP_DEF(  WITH_GET_VAR,      8,   0,   1, atom)      /* -> val (check with-obj then fallback) */
+OP_DEF(  WITH_PUT_VAR,      8,   1,   0, atom)      /* val -> (check with-obj then fallback) */
+OP_DEF(  WITH_DEL_VAR,      5,   0,   1, atom)      /* -> bool (delete from with-obj/global) */
+
+OP_DEF(  SPECIAL_OBJ,       2,   0,   1, u8)        /* arguments, mapped args, etc. */
+OP_DEF(  EMPTY,             1,   0,   1, none)      /* push T_EMPTY (array hole) */
+OP_DEF(  DEBUGGER,          1,   0,   0, none)
+OP_DEF(  NOP,               1,   0,   0, none)
+OP_DEF(  PUT_CONST,         5,   1,   0, const)     /* constant pool[idx] = TOS */
+
+op_def(  LABEL,             5,   0,   0, label)
+op_def(  LINE_NUM,          5,   0,   0, u32)
+op_def(  COL_NUM,           5,   0,   0, u32)
+
+#undef OP_DEF
+#undef op_def
+#endif
diff --git a/include/silver/swarm.h b/include/silver/swarm.h
new file mode 100644
index 0000000..9f053a6
--- /dev/null
+++ b/include/silver/swarm.h
@@ -0,0 +1,24 @@
+#ifndef SILVER_JIT_H
+#define SILVER_JIT_H
+
+#ifdef ANT_JIT
+#include "silver/engine.h"
+
+#define SV_JIT_OSR_THRESHOLD 500
+
+void sv_jit_init(ant_t *js);
+void sv_jit_destroy(ant_t *js);
+
+sv_jit_func_t sv_jit_compile(
+  ant_t *js, sv_func_t *func, 
+  sv_closure_t *hint_closure
+);
+
+jsval_t sv_jit_try_osr(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame, sv_func_t *func,
+  int bc_offset
+);
+
+#endif
+#endif
diff --git a/include/silver/vm.h b/include/silver/vm.h
new file mode 100644
index 0000000..c5c097c
--- /dev/null
+++ b/include/silver/vm.h
@@ -0,0 +1,43 @@
+#ifndef SILVER_VM_H
+#define SILVER_VM_H
+
+#include "types.h"
+
+typedef struct sv_vm sv_vm_t;
+typedef struct sv_func sv_func_t;
+
+typedef enum {
+  SV_VM_MAIN,
+  SV_VM_ASYNC,
+} sv_vm_kind_t;
+
+extern int sv_user_stack_size_kb;
+sv_vm_t *sv_vm_create(ant_t *js, sv_vm_kind_t kind);
+
+void sv_vm_destroy(sv_vm_t *vm);
+void sv_vm_limits(sv_vm_kind_t kind, int *out_stack_size, int *out_max_frames);
+
+void sv_vm_gc_roots(sv_vm_t *vm, void (*op_val)(void *, jsval_t *), void *ctx);
+void sv_vm_gc_roots_pending(void (*op_val)(void *, jsval_t *), void *ctx);
+
+void sv_vm_visit_frame_funcs(sv_vm_t *vm, void (*visitor)(void *, sv_func_t *), void *ctx);
+void sv_disasm(ant_t *js, sv_func_t *func, const char *label);
+
+jsval_t sv_execute_frame(
+  sv_vm_t *vm, sv_func_t *func,
+  jsval_t this_val, jsval_t super_val,
+  jsval_t *args, int argc
+);
+
+jsval_t sv_execute_entry(
+  sv_vm_t *vm, sv_func_t *func,
+  jsval_t this_val,
+  jsval_t *args, int argc
+);
+
+jsval_t sv_execute_entry_tla(
+  ant_t *js, sv_func_t *func, 
+  jsval_t this_val
+);
+
+#endif
diff --git a/include/stack.h b/include/stack.h
deleted file mode 100644
index 1a8a72e..0000000
--- a/include/stack.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef ANT_STACK_H
-#define ANT_STACK_H
-
-#include <stdbool.h>
-#include <stdint.h>
-
-typedef struct call_frame {
-  const char *filename;
-  const char *function_name;
-  const char *code;
-  uint32_t pos; int line; int col;
-} call_frame_t;
-
-typedef struct {
-  call_frame_t *frames;
-  int depth; int capacity;
-} call_stack_t;
-
-extern call_stack_t global_call_stack;
-
-void pop_call_frame(void);
-
-bool push_call_frame(
-  const char *filename,
-  const char *function_name,
-  const char *code, 
-  uint32_t pos
-);
-
-#endif
diff --git a/include/sugar.h b/include/sugar.h
index 3cfd866..fcbaf9f 100644
--- a/include/sugar.h
+++ b/include/sugar.h
@@ -5,12 +5,28 @@
 
 #include <stddef.h>
 #include <stdlib.h>
-#include <utarray.h>
 #include <minicoro.h>
 
 #define CORO_MALLOC(size) calloc(1, size)
 #define CORO_FREE(ptr) free(ptr)
 
+#define MCO_RESUME_SAVE(js_, mco_, res_) do {    \
+  void *_saved_cstk = (js_)->cstk.base;          \
+  size_t _saved_limit = (js_)->cstk.limit;       \
+  volatile char _gc_stk_mark;                    \
+  if (!mco_running())                            \
+    (js_)->cstk.main_lo = (void *)&_gc_stk_mark; \
+  (res_) = mco_resume((mco_));                   \
+  (js_)->cstk.base = _saved_cstk;                \
+  (js_)->cstk.limit = _saved_limit;              \
+} while (0)
+
+#define MCO_CORO_STACK_ENTER(js_, mco_) do {     \
+  volatile char _coro_marker;                    \
+  (js_)->cstk.base = (void *)&_coro_marker;      \
+  (js_)->cstk.limit = (mco_)->stack_size;        \
+} while (0)
+
 #define CORO_PER_TICK_LIMIT 100000
 
 typedef enum {
@@ -20,31 +36,34 @@ typedef enum {
 } coroutine_type_t;
 
 typedef struct coroutine {
-  struct js *js;
-  coroutine_type_t type;
-  jsval_t scope;
+  ant_t *js;
+  
   jsval_t this_val;
   jsval_t super_val;
   jsval_t new_target;
-  jsval_t awaited_promise;
   jsval_t result;
   jsval_t async_func;
+  jsval_t yield_value;
   jsval_t *args;
+  
+  jsval_t awaited_promise;
+  jsval_t async_promise;
+  
+  struct coroutine *prev;
+  struct coroutine *next;
+  
+  mco_coro *mco;
+  struct sv_vm *sv_vm;
+  
+  jsoff_t resume_point;
+  coroutine_type_t type;
+  
   int nargs;
   bool is_settled;
   bool is_error;
   bool is_done;
-  jsoff_t resume_point;
-  jsval_t yield_value;
-  struct coroutine *prev;
-  struct coroutine *next;
-  mco_coro* mco;
   bool mco_started;
   bool is_ready;
-  struct for_let_ctx *for_let_stack;
-  int for_let_stack_len;
-  int for_let_stack_cap;
-  UT_array *scope_stack;
 } coroutine_t;
 
 typedef struct {
@@ -52,22 +71,6 @@ typedef struct {
   coroutine_t *tail;
 } coroutine_queue_t;
 
-typedef struct {
-  struct js *js;
-  const char *code;
-  size_t code_len;
-  jsval_t closure_scope;
-  jsval_t result;
-  jsval_t promise;
-  bool has_error;
-  coroutine_t *coro;
-} async_exec_context_t;
-
-typedef struct {
-  jsval_t scope;
-  UT_array *scope_stack;
-} coro_saved_state_t;
-
 extern coroutine_queue_t pending_coroutines;
 extern uint32_t coros_this_tick;
 
@@ -75,12 +78,9 @@ void enqueue_coroutine(coroutine_t *coro);
 void remove_coroutine(coroutine_t *coro);
 void free_coroutine(coroutine_t *coro);
 
-coro_saved_state_t coro_enter(struct js *js, coroutine_t *coro);
-void coro_leave(struct js *js, coroutine_t *coro, coro_saved_state_t saved);
-
-jsval_t start_async_in_coroutine(struct js *js, const char *code, size_t code_len, jsval_t closure_scope, jsval_t *args, int nargs);
-jsval_t resume_coroutine_wrapper(struct js *js, jsval_t *args, int nargs);
-jsval_t reject_coroutine_wrapper(struct js *js, jsval_t *args, int nargs);
+jsval_t start_async_in_coroutine(ant_t *js, const char *code, size_t code_len, jsval_t closure_scope, jsval_t *args, int nargs);
+jsval_t resume_coroutine_wrapper(ant_t *js, jsval_t *args, int nargs);
+jsval_t reject_coroutine_wrapper(ant_t *js, jsval_t *args, int nargs);
 
 bool has_ready_coroutines(void);
 bool has_pending_coroutines(void);
diff --git a/include/tokens.h b/include/tokens.h
index 7a21aa5..fc386af 100644
--- a/include/tokens.h
+++ b/include/tokens.h
@@ -26,7 +26,7 @@ enum {
   TOK_COLON, TOK_Q, TOK_ASSIGN, TOK_PLUS_ASSIGN, TOK_MINUS_ASSIGN,
   TOK_MUL_ASSIGN, TOK_DIV_ASSIGN, TOK_REM_ASSIGN, TOK_SHL_ASSIGN,
   TOK_SHR_ASSIGN, TOK_ZSHR_ASSIGN, TOK_AND_ASSIGN, TOK_XOR_ASSIGN,
-  TOK_OR_ASSIGN, TOK_LOR_ASSIGN, TOK_LAND_ASSIGN, TOK_NULLISH_ASSIGN,
+  TOK_OR_ASSIGN, TOK_EXP_ASSIGN, TOK_LOR_ASSIGN, TOK_LAND_ASSIGN, TOK_NULLISH_ASSIGN,
   TOK_COMMA, TOK_TEMPLATE, TOK_ARROW, TOK_HASH,
   TOK_MAX
 };
@@ -47,18 +47,4 @@ static const uint8_t prec_table[TOK_MAX] = {
   [TOK_EXP]        = 14,
 };
 
-static const uint8_t body_end_tok[TOK_MAX] = {
-  [TOK_RPAREN] = 1, [TOK_RBRACE] = 1, [TOK_RBRACKET] = 1,
-  [TOK_SEMICOLON] = 1, [TOK_COMMA] = 1, [TOK_EOF] = 1,
-};
-
-static const uint8_t expr_context_tok[TOK_MAX] = {
-  [TOK_ASSIGN] = 1, [TOK_LPAREN] = 1, [TOK_COLON] = 1, [TOK_LBRACKET] = 1,
-  [TOK_COMMA] = 1, [TOK_NOT] = 1, [TOK_Q] = 1, [TOK_OR] = 1, [TOK_AND] = 1,
-  [TOK_RETURN] = 1, [TOK_ARROW] = 1, [TOK_LAND] = 1, [TOK_LOR] = 1,
-  [TOK_PLUS_ASSIGN] = 1, [TOK_MINUS_ASSIGN] = 1, [TOK_MUL_ASSIGN] = 1,
-  [TOK_DIV_ASSIGN] = 1, [TOK_REM_ASSIGN] = 1, [TOK_AND_ASSIGN] = 1,
-  [TOK_OR_ASSIGN] = 1, [TOK_XOR_ASSIGN] = 1, [TOK_NULLISH] = 1,
-};
-
 #endif
\ No newline at end of file
diff --git a/include/types.h b/include/types.h
index 97b0ccd..d332ca5 100644
--- a/include/types.h
+++ b/include/types.h
@@ -4,13 +4,17 @@
 #include <stdint.h>
 #include <stddef.h>
 
-struct js;
+struct ant;
 
-typedef struct js ant_t;
+typedef struct ant ant_t;
 typedef unsigned long long u64;
 
 typedef size_t   jshdl_t;
 typedef uint64_t jsoff_t;
 typedef uint64_t jsval_t;
 
+typedef size_t   ant_handle_t;
+typedef uint64_t ant_offset_t;
+typedef uint64_t ant_value_t;
+
 #endif
\ No newline at end of file
diff --git a/include/utf8.h b/include/utf8.h
index 67b83d2..80930b3 100644
--- a/include/utf8.h
+++ b/include/utf8.h
@@ -3,10 +3,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
-
-int utf8_sequence_length(unsigned char first_byte);
-int utf8_encode(uint32_t codepoint, char *out);
-uint32_t utf8_decode(const unsigned char *buf, size_t len, int *seq_len);
+#include <utf8proc.h>
 
 size_t utf8_char_len_at(const char *str, size_t byte_len, size_t pos);
 size_t utf8_strlen(const char *str, size_t byte_len);
@@ -31,4 +28,27 @@ int utf16_range_to_byte_range(
 uint32_t utf16_code_unit_at(const char *str, size_t byte_len, size_t utf16_idx);
 uint32_t utf16_codepoint_at(const char *str, size_t byte_len, size_t utf16_idx);
 
+static inline int utf8_sequence_length(unsigned char first_byte) {
+  if ((first_byte & 0x80) == 0) return 1;
+  if ((first_byte & 0xE0) == 0xC0) return 2;
+  if ((first_byte & 0xF0) == 0xE0) return 3;
+  if ((first_byte & 0xF8) == 0xF0) return 4;
+  return -1;
+}
+
+static inline int utf8_encode(uint32_t cp, char *out) {
+  return (int)
+    utf8proc_encode_char((utf8proc_int32_t)cp, 
+    (utf8proc_uint8_t *)out);
+}
+
+static inline utf8proc_ssize_t utf8_next(
+  const utf8proc_uint8_t *p,
+  utf8proc_ssize_t len,
+  utf8proc_int32_t *cp
+) {
+  utf8proc_ssize_t n = utf8proc_iterate(p, len, cp);
+  return n > 0 ? n : 1;
+}
+
 #endif
diff --git a/include/utils.h b/include/utils.h
index 13c8641..54c48e7 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -11,13 +11,23 @@ typedef struct {
   char *heap;
 } cstr_buf_t;
 
-char *resolve_js_file(const char *filename);
+extern const char *const module_resolve_extensions[];
 uint64_t hash_key(const char *key, size_t len);
 
-int hex_digit(char c);
 char hex_char(int v);
+char *resolve_js_file(const char *filename);
+
+int hex_digit(char c);
 int is_typescript_file(const char *filename);
 
+int strip_typescript_inplace(
+  char **buffer,
+  size_t len,
+  const char *filename,
+  size_t *out_len,
+  const char **error_detail
+);
+
 void *try_oom(size_t size);
 void cstr_free(cstr_buf_t *buf);
 
@@ -36,4 +46,17 @@ char *cstr_init(
 #define CSTR_INIT(buf, src, len) \
   cstr_init(&(buf), buf##_stack, sizeof(buf##_stack), (src), (len))
 
+typedef struct {
+  const char *ptr;
+  size_t len;
+} repl_capture_t;
+
+void repl_template(
+  const char *repl, size_t repl_len,
+  const char *matched, size_t matched_len,
+  const char *str, size_t str_len, size_t position,
+  const repl_capture_t *caps, int ncaptures,
+  char **buf, size_t *buf_len, size_t *buf_cap
+);
+
 #endif
diff --git a/libant/meson_options.txt b/libant/meson_options.txt
index da52a30..f46fef7 100644
--- a/libant/meson_options.txt
+++ b/libant/meson_options.txt
@@ -1,3 +1,4 @@
+option('jit', type: 'boolean', value: true, description: 'enable JIT compiler')
 option('build_timestamp', type: 'string', value: '', description: 'build timestamp (defaults to current time if empty)')
 option('tls_library', type: 'combo', choices: ['openssl', 'mbedtls'], value: 'openssl', description: 'TLS library to use')
 option('deps_prefix_cmake', type: 'string', value: '', description: 'prefix path for finding dependencies in cmake subprojects')
diff --git a/libant/scripts/header.sh b/libant/scripts/header.sh
index 0ebed41..3f1857f 100755
--- a/libant/scripts/header.sh
+++ b/libant/scripts/header.sh
@@ -17,20 +17,22 @@ fi
 VENDOR_DIR="$SCRIPT_DIR/vendor"
 
 HEADERS=(
+  "debug.h:$INCLUDE_DIR/debug.h"
   "common.h:$INCLUDE_DIR/common.h"
   "types.h:$INCLUDE_DIR/types.h"
   "gc.h:$INCLUDE_DIR/gc.h"
   "roots.h:$INCLUDE_DIR/roots.h"
   "uthash.h:$VENDOR_DIR/uthash-2.3.0/src/uthash.h"
-  "utarray.h:$VENDOR_DIR/uthash-2.3.0/src/utarray.h"
+  "errors.h:$INCLUDE_DIR/errors.h"
   "ant.h:$INCLUDE_DIR/ant.h"
   "internal.h:$INCLUDE_DIR/internal.h"
+  "silver/vm.h:$INCLUDE_DIR/silver/vm.h"
+  "silver/engine.h:$INCLUDE_DIR/silver/engine.h"
   "minicoro.h:$VENDOR_DIR/minicoro/minicoro.h"
   "sugar.h:$INCLUDE_DIR/sugar.h"
   "reactor.h:$INCLUDE_DIR/reactor.h"
   "tokens.h:$INCLUDE_DIR/tokens.h"
   "stack.h:$INCLUDE_DIR/stack.h"
-  "errors.h:$INCLUDE_DIR/errors.h"
   "compat.h:$INCLUDE_DIR/compat.h"
   "utils.h:$INCLUDE_DIR/utils.h"
   "runtime.h:$INCLUDE_DIR/runtime.h"
@@ -106,8 +108,13 @@ for entry in "${HEADERS[@]}"; do
     if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*pragma[[:space:]]+once ]]; then
       continue
     fi
+
+    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"silver/opcode\.h\" ]]; then
+      cat "$INCLUDE_DIR/silver/opcode.h" >> "$OUTPUT"
+      continue
+    fi
     
-    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"(metadata\.h|common\.h|gc.\h|types\.h|compat\.h|ant\.h|utils\.h|arena\.h|runtime\.h|internal\.h)\" ]]; then
+    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"(metadata\.h|errors\.h|common\.h|gc.\h|types\.h|compat\.h|ant\.h|utils\.h|arena\.h|runtime\.h|internal\.h)\" ]]; then
       continue
     fi
     if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"esm/ ]]; then
@@ -116,8 +123,10 @@ for entry in "${HEADERS[@]}"; do
     if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"modules/ ]]; then
       continue
     fi
-    
-    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\<(metadata|common|uv|types|utarray|uthash|minicoro)\.h\> ]]; then
+    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"silver/ ]]; then
+      continue
+    fi
+    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\<(metadata|common|uv|types|uthash|minicoro)\.h\> ]]; then
       continue
     fi
     
@@ -129,4 +138,4 @@ done
 
 echo "#endif /* LIBANT_H */" >> "$OUTPUT"
 
-echo "Generated $OUTPUT"
\ No newline at end of file
+echo "Generated $OUTPUT"
diff --git a/maidfile.toml b/maidfile.toml
index 5e446ab..4625683 100644
--- a/maidfile.toml
+++ b/maidfile.toml
@@ -6,6 +6,10 @@ script = "meson compile"
 path = "src"
 target = ["build/ant"]
 
+[tasks.reconfigure]
+path = "build"
+script = "meson setup --reconfigure"
+
 [tasks.strip]
 path = "build"
 script = "strip ant"
@@ -16,18 +20,9 @@ script = [".github/download.sh", "open .github/artifacts"]
 [tasks.run]
 script = ["maid build -q", "./build/ant %{arg.1}"]
 
-[tasks.spec]
-script = ["maid build -q", "./build/ant examples/spec/%{arg.1}.js"]
-
 [tasks.amber]
 script = "amber build .github/install/install.ab install.sh"
 
-[tasks.save_spec]
-script = ['rm spec.txt', '''
-   bash -c 'ant examples/spec/run.js \
-   | sed "s/\x1b\[[0-9;]*[a-zA-Z]//g" > spec.txt'
-''']
-
 [tasks.setup]
 script = ['meson subprojects download', '''
    bash -c 'CC="ccache $(which clang)" \
@@ -35,6 +30,13 @@ script = ['meson subprojects download', '''
    meson setup build --wipe'
 ''']
 
+[tasks.no_jit]
+script = ['meson subprojects download', '''
+   bash -c 'CC="ccache $(which clang)" \
+   CC_LD="$(which ld64.lld)" \
+   meson setup build --wipe -Djit=false'
+''']
+
 [tasks.asan]
 script = ['meson subprojects download', '''
    bash -c 'CC="ccache $(which clang)" \
diff --git a/meson.build b/meson.build
index d0e5a20..921d487 100644
--- a/meson.build
+++ b/meson.build
@@ -79,5 +79,7 @@ endif
 executable(
   'ant',
   files('src/main.c', 'src/watch.c') + [messages_h],
-  dependencies: libant_dep, link_args: link_args
+  dependencies: libant_dep,
+  link_args: link_args,
+  export_dynamic: true
 )
diff --git a/meson/deps/meson.build b/meson/deps/meson.build
index 384e3ac..7e9f5a0 100644
--- a/meson/deps/meson.build
+++ b/meson/deps/meson.build
@@ -115,10 +115,12 @@ base64_dep = declare_dependency(
 
 uthash_dep = subproject('uthash').get_variable('uthash_dep')
 yyjson_dep = subproject('yyjson').get_variable('yyjson_dep')
+utf8proc_dep = subproject('utf8proc').get_variable('utf8proc_dep')
 uuidv7_dep = subproject('uuidv7').get_variable('uuidv7_dep')
 argtable3_dep = subproject('argtable3').get_variable('argtable3_dep')
 minicoro_dep = subproject('minicoro').get_variable('minicoro_dep')
 crprintf_dep = subproject('crprintf').get_variable('crprintf_dep')
+uriparser_dep = subproject('uriparser').get_variable('uriparser_dep')
 
 lmdb_dep = subproject('lmdb', default_options: [
   'warning_level=0',
@@ -170,7 +172,8 @@ oxc_lib = custom_target(
     '--target-dir "' + meson.project_build_root() / 'oxc-target' + '"' +
     ' && "' + cp.full_path() + '" "' + oxc_release_dir / oxc_lib_name + '" @OUTPUT@'
   ],
-  build_by_default: true
+  build_by_default: true,
+  build_always_stale: true
 )
 
 oxc_dep = declare_dependency(link_with: oxc_lib)
@@ -216,10 +219,17 @@ ant_deps = [
   libffi_dep, uuid_dep, crprintf_dep,
   llhttp, pcre2_dep, libuv_dep, base64_dep,
   argtable3_dep, tlsuv_dep, libsodium_dep,
-  yyjson_dep, minicoro_dep, uuidv7_dep,
-  openssl_dep, zlib_dep, uthash_dep, lmdb_dep,
+  yyjson_dep, minicoro_dep, uuidv7_dep, 
+  uriparser_dep, utf8proc_dep, openssl_dep,
+  zlib_dep, uthash_dep, lmdb_dep,
 ] + mbedtls_dep + win_deps
 
+if get_option('jit')
+  mir_dep = subproject('mir').get_variable('mir_dep')
+  ant_deps += [mir_dep]
+  add_project_arguments('-DANT_JIT', language: 'c')
+endif
+
 if host_machine.system() == 'darwin'
   ant_deps += [security_dep]
 endif
diff --git a/meson_options.txt b/meson_options.txt
index 41e4d61..0a726a4 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,4 +1,5 @@
+option('jit', type: 'boolean', value: true, description: 'enable JIT compiler')
 option('static_link', type: 'boolean', value: false, description: 'statically link the binary')
-option('build_timestamp', type: 'string', value: '', description: 'build timestamp (defaults to current time if empty)')
 option('tls_library', type: 'combo', choices: ['openssl', 'mbedtls'], value: 'openssl', description: 'TLS library to use')
+option('build_timestamp', type: 'string', value: '', description: 'build timestamp (defaults to current time if empty)')
 option('deps_prefix_cmake', type: 'string', value: '', description: 'prefix path for finding dependencies in cmake subprojects')
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..a5e57de
--- /dev/null
+++ b/package.json
@@ -0,0 +1,9 @@
+{
+  "name": "ant",
+  "type": "module",
+  "scripts": {
+    "spec": "./build/ant examples/spec/run.js"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}
diff --git a/sources.json b/sources.json
index 4080ecd..a7b7f7e 100644
--- a/sources.json
+++ b/sources.json
@@ -1,10 +1,10 @@
 {
   "engine": {
-    "patterns": ["src/*.c", "src/esm/*.c", "src/cli/*.c", "src/modules/*.c"],
+    "patterns": ["src/*.c", "src/esm/*.c", "src/cli/*.c", "src/modules/*.c", "src/silver/*.c"],
     "exclude": ["src/main.c", "src/watch.c"]
   },
   "library": {
-    "patterns": ["src/*.c", "src/esm/*.c", "src/modules/*.c"],
+    "patterns": ["src/*.c", "src/esm/*.c", "src/modules/*.c", "src/silver/*.c"],
     "exclude": ["src/main.c", "src/watch.c"]
   },
   "core": {
diff --git a/src/ant.c b/src/ant.c
index 30aa4a1..4f82f38 100644
--- a/src/ant.c
+++ b/src/ant.c
@@ -6,6 +6,8 @@
 
 #include "ant.h"
 #include "gc.h"
+#include "utf8.h"
+#include "debug.h"
 #include "tokens.h"
 #include "common.h"
 #include "arena.h"
@@ -14,17 +16,21 @@
 #include "runtime.h"
 #include "internal.h"
 #include "sugar.h"
-#include "stack.h"
 #include "errors.h"
-#include "utf8.h"
-#include "escape.h"
+#include "descriptors.h"
+
 #include "esm/remote.h"
+#include "esm/loader.h"
+
+#include "silver/ast.h"
+#include "silver/lexer.h"
+#include "silver/compiler.h"
+#include "silver/engine.h"
 
 #include <uv.h>
 #include <oxc.h>
 #include <assert.h>
 #include <pcre2.h>
-#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -52,13 +58,14 @@
 #include "modules/child_process.h"
 #include "modules/readline.h"
 #include "modules/process.h"
-#include "modules/json.h"
+#include "modules/date.h"
 #include "modules/buffer.h"
 #include "modules/collections.h"
 #include "modules/navigator.h"
 #include "modules/server.h"
 #include "modules/events.h"
 #include "modules/lmdb.h"
+#include "modules/regex.h"
 
 #define D(x) ((double)(x))
 
@@ -73,83 +80,6 @@ _Static_assert(sizeof(double) == sizeof(uint64_t), "double and uint64_t must hav
   #error "NaN-boxing requires IEEE 754 binary64 doubles"
 #endif
 
-typedef struct {
-  jsval_t *stack;
-  int depth;
-  int capacity;
-} this_stack_t;
-
-static this_stack_t global_this_stack = {NULL, 0, 0};
-
-const UT_icd jsoff_icd = {
-  .sz = sizeof(jsoff_t),
-  .init = NULL,
-  .copy = NULL,
-  .dtor = NULL,
-};
-
-const UT_icd jsval_icd = {
-  .sz = sizeof(jsval_t),
-  .init = NULL,
-  .copy = NULL,
-  .dtor = NULL,
-};
-
-UT_array *global_scope_stack = NULL;
-UT_array *saved_scope_stack = NULL;
-
-typedef struct {
-  const char *name;
-  jsoff_t name_len;
-  bool is_loop;
-  bool is_block;
-} label_entry_t;
-
-static const UT_icd label_entry_icd = {
-  .sz = sizeof(label_entry_t),
-  .init = NULL,
-  .copy = NULL,
-  .dtor = NULL,
-};
-
-static UT_array *label_stack = NULL;
-static const char *break_target_label = NULL;
-static jsoff_t break_target_label_len = 0;
-static const char *continue_target_label = NULL;
-static jsoff_t continue_target_label_len = 0;
-
-#define F_BREAK_LABEL 1U
-#define F_CONTINUE_LABEL 2U
-static uint8_t label_flags = 0;
-
-typedef struct esm_module {
-  char *path;
-  char *resolved_path;
-  jsval_t namespace_obj;
-  jsval_t default_export;
-  bool is_loaded;
-  bool is_loading;
-  bool is_json;
-  bool is_text;
-  bool is_image;
-  bool is_url;
-  char *url_content;
-  size_t url_content_len;
-  struct esm_module *next;
-  UT_hash_handle hh;
-} esm_module_t;
-
-typedef struct {
-  esm_module_t *modules;
-  int count;
-} esm_module_cache_t;
-
-typedef struct ant_library {
-  char name[256];
-  ant_library_init_fn init_fn;
-  UT_hash_handle hh;
-} ant_library_t;
-
 static const char *INTERN_LENGTH = NULL;
 static const char *INTERN_BUFFER = NULL;
 static const char *INTERN_PROTOTYPE = NULL;
@@ -175,30 +105,6 @@ static size_t intern_count = 0;
 static size_t intern_bytes = 0;
 static interned_string_t *intern_buckets[ANT_LIMIT_SIZE_CACHE];
 
-typedef struct {
-  jsoff_t obj_off;
-  const char *intern_ptr;
-  jsoff_t prop_off;
-  jsoff_t tail;
-  uint64_t generation;
-} intern_prop_cache_entry_t;
-
-typedef struct {
-  const char *code_ptr;
-  jsoff_t code_off;
-  jsoff_t cached_key_off;
-  uint64_t generation;
-} dot_ic_entry_t;
-
-static uint64_t intern_prop_cache_gen = 1;
-static dot_ic_entry_t dot_ic_table[ANT_LIMIT_SIZE_CACHE];
-static intern_prop_cache_entry_t intern_prop_cache[ANT_LIMIT_SIZE_CACHE];
-
-static inline size_t dot_ic_slot(const char *code, jsoff_t off) {
-  uint64_t h = (uintptr_t)code ^ (off * 0x9E3779B97F4A7C15ULL);
-  return (size_t)((h ^ (h >> 32)) & (ANT_LIMIT_SIZE_CACHE - 1));
-}
-
 typedef struct promise_handler {
   jsval_t onFulfilled;
   jsval_t onRejected;
@@ -212,6 +118,17 @@ static const UT_icd promise_handler_icd = {
   .dtor = NULL,
 };
 
+typedef struct {
+  jsoff_t obj_off;
+  const char *intern_ptr;
+  jsoff_t prop_off;
+  jsoff_t tail;
+  uint64_t generation;
+} intern_prop_cache_entry_t;
+
+static uint64_t intern_prop_cache_gen = 1;
+static intern_prop_cache_entry_t intern_prop_cache[ANT_LIMIT_SIZE_CACHE];
+
 typedef struct promise_data_entry {
   jsval_t value;
   UT_array *handlers;
@@ -230,8 +147,8 @@ static promise_data_entry_t *unhandled_rejections = NULL;
 static uint32_t next_promise_id = 1;
 
 static promise_data_entry_t *get_promise_data(uint32_t promise_id, bool create);
-static uint32_t get_promise_id(struct js *js, jsval_t p);
-static bool js_try_grow_memory(struct js *js, size_t needed);
+static uint32_t get_promise_id(ant_t *js, jsval_t p);
+static bool js_try_grow_memory(ant_t *js, size_t needed);
 
 typedef struct proxy_data {
   jsoff_t obj_offset;
@@ -250,225 +167,59 @@ typedef struct dynamic_accessors {
   UT_hash_handle hh;
 } dynamic_accessors_t;
 
-typedef struct descriptor_entry {
-  uint64_t key;
-  jsoff_t obj_off;
-  char *prop_name;
-  size_t prop_len;
-  bool writable;
-  bool enumerable;
-  bool configurable;
-  bool has_getter;
-  bool has_setter;
-  jsval_t getter;
-  jsval_t setter;
-  UT_hash_handle hh;
-} descriptor_entry_t;
-
-typedef struct {
-  jsoff_t obj_off;
-  jsoff_t key_off;
-} propref_data_t;
-
-static const UT_icd propref_icd = { sizeof(propref_data_t), NULL, NULL, NULL };
-static UT_array *propref_stack = NULL;
-
-typedef struct parsed_param {
-  jsoff_t name_off;
-  jsoff_t name_len;
-  jsoff_t default_start;
-  jsoff_t default_len;
-  jsoff_t pattern_off;
-  jsoff_t pattern_len;
-  bool is_destruct;
-} parsed_param_t;
-
-typedef struct cached_token {
-  uint8_t tok;
-  uint8_t had_newline;
-  jsoff_t toff;
-  jsoff_t tlen;
-  jsoff_t pos;
-  jsval_t tval;
-} cached_token_t;
-
-typedef struct token_stream {
-  cached_token_t *tokens;
-  int count;
-  int capacity;
-} token_stream_t;
-
-typedef struct parsed_func {
-  uint64_t code_hash;
-  jsoff_t body_start;
-  jsoff_t body_len;
-  int param_count;
-  bool has_rest;
-  bool is_strict;
-  bool is_expr;
-  bool uses_arguments;
-  bool has_tail_calls;
-  jsoff_t rest_param_start;
-  jsoff_t rest_param_len;
-  UT_array *params;
-  token_stream_t *tokens;
-  UT_hash_handle hh;
-} parsed_func_t;
-
-static const UT_icd parsed_param_icd = {
-  .sz = sizeof(parsed_param_t),
-  .init = NULL,
-  .copy = NULL,
-  .dtor = NULL,
-};
-
-static parsed_func_t *func_parse_cache = NULL;
-static ant_library_t *library_registry = NULL;
-static esm_module_cache_t global_module_cache = {NULL, 0};
 static proxy_data_t *proxy_registry = NULL;
+static proxy_data_t *get_proxy_data(jsval_t obj);
 static dynamic_accessors_t *accessor_registry = NULL;
-static descriptor_entry_t *desc_registry = NULL;
-
-void ant_register_library(ant_library_init_fn init_fn, const char *name, ...) {
-  va_list args;
-  const char *alias = name;
-  
-  va_start(args, name);
-  while (alias != NULL) {
-    ant_library_t *lib = (ant_library_t *)ant_calloc(sizeof(ant_library_t));
-    if (!lib) break;
-    
-    strncpy(lib->name, alias, sizeof(lib->name) - 1);
-    lib->name[sizeof(lib->name) - 1] = '\0';
-    lib->init_fn = init_fn;
-    
-    HASH_ADD_STR(library_registry, name, lib);
-    alias = va_arg(args, const char *);
-  }
-  va_end(args);
-}
-
-static ant_library_t* find_library(const char *specifier, size_t spec_len) {
-  ant_library_t *lib = NULL;
-  
-  char key[256];
-  if (spec_len >= sizeof(key)) return NULL;
-  memcpy(key, specifier, spec_len);
-  key[spec_len] = '\0';
-  
-  HASH_FIND_STR(library_registry, key, lib);
-  return lib;
-}
-
-static const char *typestr_raw(uint8_t t) {
-  const char *names[] = { 
-    "object", "prop", "string", "undefined", "null", "number",
-    "boolean", "function", "coderef", "cfunc", "err", "array", 
-    "promise", "typedarray", "bigint", "propref", "symbol", 
-    "generator", "ffi", "ntarg"
-  };
-  
-  return (t < sizeof(names) / sizeof(names[0])) ? names[t] : "??";
-}
 
-jsval_t tov(double d) { 
-  union { double d; jsval_t v; } u = {d}; return u.v; 
+jsval_t tov(double d) {
+  union { double d; jsval_t v; } u = {d};
+  if (__builtin_expect(isnan(d), 0)) 
+    return (u.v > NANBOX_PREFIX) 
+    ? 0x7FF8000000000000ULL : u.v; // canonical NaN
+  return u.v;
 }
 
-double tod(jsval_t v) { 
-  union { jsval_t v; double d; } u = {v}; return u.d; 
+double tod(jsval_t v) {
+  union { jsval_t v; double d; } u = {v}; return u.d;
 }
 
 static bool is_tagged(jsval_t v) {
-  return (v >> 53) == NANBOX_PREFIX_CHK;
-}
-
-size_t vdata(jsval_t v) { 
-  return (size_t)(v & NANBOX_DATA_MASK); 
-}
-
-#define PROPREF_STACK_FLAG  0x800000000000ULL
-#define PROPREF_PRIM_FLAG   0x400000000000ULL
-#define PROPREF_INDEX_MASK  0x3FFFFFFFFFFFULL
-#define PROPREF_OFF_MASK    0x7FFFFFULL
-#define PROPREF_PAYLOAD     0x7FFFFFULL
-#define PROPREF_SAFE_MASK   0x7FFFFFULL
-#define PROPREF_KEY_SHIFT   23U
-
-typedef struct {
-  jsval_t prim_val;
-  jsoff_t key_off;
-} prim_propref_data_t;
-
-static UT_icd prim_propref_icd = { sizeof(prim_propref_data_t), NULL, NULL, NULL };
-static UT_array *prim_propref_stack = NULL;
-
-static jsoff_t coderefoff(jsval_t v) { return v & PROPREF_OFF_MASK; }
-static jsoff_t codereflen(jsval_t v) { return (v >> PROPREF_KEY_SHIFT) & PROPREF_OFF_MASK; }
-
-static jsval_t get_slot(struct js *js, jsval_t obj, internal_slot_t slot);
-static void set_slot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t value);
-
-static jsval_t get_proto(struct js *js, jsval_t obj);
-static void set_proto(struct js *js, jsval_t obj, jsval_t proto);
-
-enum tail_scan { TAIL_NONE, TAIL_OK, TAIL_UNSAFE };
-static enum tail_scan scan_tail_span(const char *code, jsoff_t clen, jsoff_t start, jsoff_t end);
-
-static void clear_break_label(void) {
-  break_target_label = NULL;
-  break_target_label_len = 0;
-  label_flags &= ~F_BREAK_LABEL;
+  return v > NANBOX_PREFIX;
 }
 
-static void clear_continue_label(void) {
-  continue_target_label = NULL;
-  continue_target_label_len = 0;
-  label_flags &= ~F_CONTINUE_LABEL;
+size_t vdata(jsval_t v) {
+  return (size_t)(v & NANBOX_DATA_MASK);
 }
 
-static inline propref_data_t *propref_get_entry(jsval_t v) {
-  uint64_t data = v & NANBOX_DATA_MASK;
-  if (!(data & PROPREF_STACK_FLAG)) return NULL;
-  
-  int idx = (int)(data & PROPREF_INDEX_MASK);
-  if (!propref_stack || idx < 0 || idx >= (int)utarray_len(propref_stack)) return NULL;
-  
-  return (propref_data_t *)utarray_eltptr(propref_stack, (unsigned)idx);
-}
-
-static jsoff_t propref_obj(jsval_t v) {
-  propref_data_t *entry = propref_get_entry(v);
-  if (entry) return entry->obj_off;
-  
-  uint64_t data = v & NANBOX_DATA_MASK;
-  return (data & PROPREF_STACK_FLAG) ? 0 : (data & PROPREF_OFF_MASK);
-}
+static jsval_t get_slot(ant_t *js, jsval_t obj, internal_slot_t slot);
+static void set_slot(ant_t *js, jsval_t obj, internal_slot_t slot, jsval_t value);
 
-static jsoff_t propref_key(jsval_t v) {
-  propref_data_t *entry = propref_get_entry(v);
-  if (entry) return entry->key_off;
-  
-  uint64_t data = v & NANBOX_DATA_MASK;
-  return (data & PROPREF_STACK_FLAG) ? 0 : ((data >> PROPREF_KEY_SHIFT) & PROPREF_OFF_MASK);
-}
+static jsval_t get_proto(ant_t *js, jsval_t obj);
+static void set_proto(ant_t *js, jsval_t obj, jsval_t proto);
 
 static inline jsoff_t offtolen(jsoff_t off) { return (off >> 3) - 1; }
 static inline jsoff_t align64(jsoff_t v) { return (v + 7) & ~7ULL; }
 
-static void saveoff(struct js *js, jsoff_t off, jsoff_t val) { 
-  memcpy(&js->mem[off], &val, sizeof(val)); 
+static void saveoff(ant_t *js, jsoff_t off, jsoff_t val) {
+  memcpy(&js->mem[off], &val, sizeof(val));
 }
 
-static void saveval(struct js *js, jsoff_t off, jsval_t val) { 
-  memcpy(&js->mem[off], &val, sizeof(val)); 
+static void saveval(ant_t *js, jsoff_t off, jsval_t val) {
+  memcpy(&js->mem[off], &val, sizeof(val));
 }
 
-static const char *typestr(uint8_t t) {
-  if (t == T_CFUNC) return "function";
-  if (t == T_ARR) return "object";
-  if (t == T_NULL) return "object";
-  return typestr_raw(t);
+const char *typestr(uint8_t t) {
+  static const char *names[] = {
+    [T_UNDEF] = "undefined", [T_NULL] = "object", [T_BOOL] = "boolean",
+    [T_NUM] = "number", [T_BIGINT] = "bigint", [T_STR] = "string",
+    [T_SYMBOL] = "symbol", [T_OBJ] = "object", [T_ARR] = "object",
+    [T_FUNC] = "function", [T_CFUNC] = "function", [T_CLOSURE] = "closure",
+    [T_PROMISE] = "promise", [T_GENERATOR] = "generator",
+    [T_PROP] = "prop", [T_ERR] = "err", [T_TYPEDARRAY] = "typedarray",
+    [T_FFI] = "ffi", [T_NTARG] = "ntarg"
+  };
+
+  return (t < sizeof(names) / sizeof(names[0])) ? names[t] : "??";
 }
 
 uint8_t vtype(jsval_t v) { 
@@ -476,11 +227,15 @@ uint8_t vtype(jsval_t v) {
 }
 
 jsval_t mkval(uint8_t type, uint64_t data) { 
-  return NANBOX_PREFIX | ((jsval_t)(type & NANBOX_TYPE_MASK) << NANBOX_TYPE_SHIFT) | (data & NANBOX_DATA_MASK);
+  return NANBOX_PREFIX 
+    | ((jsval_t)(type & NANBOX_TYPE_MASK) << NANBOX_TYPE_SHIFT) 
+    | (data & NANBOX_DATA_MASK);
 }
 
 jsval_t js_obj_to_func(jsval_t obj) {
-  return mkval(T_FUNC, vdata(obj));
+  sv_closure_t *closure = calloc(1, sizeof(sv_closure_t));
+  closure->func_obj = (vtype(obj) == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  return mkval(T_FUNC, (uintptr_t)closure);
 }
 
 jsval_t js_mktypedarray(void *data) {
@@ -492,12 +247,12 @@ void *js_gettypedarray(jsval_t val) {
   return (void *)vdata(val);
 }
 
-jsval_t js_get_slot(struct js *js, jsval_t obj, internal_slot_t slot) { 
-  return get_slot(js, obj, slot); 
+jsval_t js_get_slot(ant_t *js, jsval_t obj, internal_slot_t slot) { 
+  return get_slot(js, js_as_obj(obj), slot); 
 }
 
-void js_set_slot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t value) { 
-  set_slot(js, obj, slot, value); 
+void js_set_slot(ant_t *js, jsval_t obj, internal_slot_t slot, jsval_t value) { 
+  set_slot(js, js_as_obj(obj), slot, value); 
 }
 
 jsval_t js_mkffi(unsigned int index) {
@@ -509,164 +264,16 @@ int js_getffi(jsval_t val) {
   return (int)vdata(val);
 }
 
-static jsval_t mkcoderef(jsval_t off, jsoff_t len) { 
-  return mkval(T_CODEREF, (off & PROPREF_OFF_MASK) | ((jsval_t)(len & PROPREF_OFF_MASK) << PROPREF_KEY_SHIFT));
-}
-
 typedef enum {
   NTARG_INVALID = 0,
   NTARG_NEW_TARGET = 1
 } ntarg_kind_t;
 
-static inline jsval_t mkntarg(ntarg_kind_t tag) {
-  return mkval(T_NTARG, (uint64_t)tag);
-}
-
-static inline bool is_new_target_ref(jsval_t v) {
-  return vtype(v) == T_NTARG && vdata(v) == (uint64_t)NTARG_NEW_TARGET;
-}
-
-static jsval_t mkpropref(jsoff_t obj_off, jsoff_t key_off) {
-  if (obj_off <= PROPREF_SAFE_MASK && key_off <= PROPREF_SAFE_MASK) return mkval(
-    T_PROPREF, (obj_off & PROPREF_OFF_MASK) | 
-    ((jsval_t)(key_off & PROPREF_OFF_MASK) << PROPREF_KEY_SHIFT)
-  );
-  
-  if (!propref_stack) utarray_new(propref_stack, &propref_icd);
-  
-  static unsigned propref_next_slot = 0;
-  static unsigned propref_high_water = 0;
-  
-  if (propref_next_slot == 0 && propref_high_water > 0) {
-    assert(propref_high_water <= PROPREF_STACK_SIZE && "propref_stack overflow");
-  }
-  
-  propref_data_t entry = { obj_off, key_off };
-  
-  if (propref_next_slot < utarray_len(propref_stack)) {
-    propref_data_t *slot = (propref_data_t *)utarray_eltptr(propref_stack, propref_next_slot);
-    *slot = entry;
-  } else utarray_push_back(propref_stack, &entry);
-  
-  int idx = (int)propref_next_slot;
-  propref_next_slot = (propref_next_slot + 1) % PROPREF_STACK_SIZE;
-  if ((unsigned)idx > propref_high_water) propref_high_water = (unsigned)idx;
-
-  return mkval(T_PROPREF, PROPREF_STACK_FLAG | (uint64_t)idx);
-}
-
-static jsval_t mkprim_propref(jsval_t prim_val, jsoff_t key_off) {
-  if (!prim_propref_stack) utarray_new(prim_propref_stack, &prim_propref_icd);
-  
-  static unsigned prim_propref_next_slot = 0;
-  static unsigned prim_propref_high_water = 0;
-  
-  if (prim_propref_next_slot == 0 && prim_propref_high_water > 0) {
-    assert(prim_propref_high_water <= PRIM_PROPREF_STACK_SIZE && "prim_propref_stack overflow");
-  }
-  
-  prim_propref_data_t entry = { prim_val, key_off };
-  
-  if (prim_propref_next_slot < utarray_len(prim_propref_stack)) {
-    prim_propref_data_t *slot = (prim_propref_data_t *)utarray_eltptr(prim_propref_stack, prim_propref_next_slot);
-    *slot = entry;
-  } else utarray_push_back(prim_propref_stack, &entry);
-  
-  int idx = (int)prim_propref_next_slot;
-  prim_propref_next_slot = (prim_propref_next_slot + 1) % PRIM_PROPREF_STACK_SIZE;
-  if ((unsigned)idx > prim_propref_high_water) prim_propref_high_water = (unsigned)idx;
-  
-  return mkval(T_PROPREF, PROPREF_PRIM_FLAG | (uint64_t)idx);
-}
-
-static inline bool is_prim_propref(jsval_t v) {
-  if (vtype(v) != T_PROPREF) return false;
-  uint64_t data = v & NANBOX_DATA_MASK;
-  return (data & PROPREF_PRIM_FLAG) != 0;
-}
-
-static inline prim_propref_data_t *prim_propref_get(jsval_t v) {
-  uint64_t data = v & NANBOX_DATA_MASK;
-  if (!(data & PROPREF_PRIM_FLAG)) return NULL;
-  
-  int idx = (int)(data & PROPREF_INDEX_MASK);
-  if (!prim_propref_stack || idx < 0 || idx >= (int)utarray_len(prim_propref_stack)) return NULL;
-  
-  return (prim_propref_data_t *)utarray_eltptr(prim_propref_stack, (unsigned)idx);
-}
-
-inline size_t js_getbrk(struct js *js) { 
+inline size_t js_getbrk(ant_t *js) { 
   return (size_t) js->brk;
 }
 
-static inline int is_body_end_tok(int tok) {
-  return body_end_tok[tok];
-}
-
-static inline bool is_assign(uint8_t tok) {
-  return tok >= TOK_ASSIGN && tok <= TOK_NULLISH_ASSIGN;
-}
-
-static inline bool is_identifier_like(uint8_t tok) {
-  return tok >= TOK_IDENTIFIER && tok < TOK_IDENT_LIKE_END;
-}
-
-static inline bool is_keyword_propname(uint8_t tok) { 
-  return (tok >= TOK_ASYNC && tok <= TOK_GLOBAL_THIS) || tok == TOK_TYPEOF; 
-}
-
-static inline bool is_contextual_keyword(uint8_t tok) {
-  return tok == TOK_FROM || tok == TOK_OF || tok == TOK_AS || tok == TOK_ASYNC;
-}
-
-static inline bool js_stack_overflow(struct js *js) {
-  volatile char marker;
-  uintptr_t curr = (uintptr_t)&marker;
-  
-  mco_coro *coro = mco_running();
-  if (coro != NULL) {
-    uintptr_t stack_top = (uintptr_t)coro->stack_base + coro->stack_size;
-    size_t limit = coro->stack_size / 2;
-    size_t used = (stack_top > curr) ? (stack_top - curr) : (curr - stack_top);
-    return used > limit;
-  }
-  
-  if (js->stack_limit == 0 || js->cstk == NULL) return false;
-  uintptr_t base = (uintptr_t)js->cstk;
-  size_t used = (base > curr) ? (base - curr) : (curr - base);
-  return used > js->stack_limit;
-}
-
-static inline bool is_valid_param_name(uint8_t tok) {
-  return tok == TOK_IDENTIFIER || is_contextual_keyword(tok);
-}
-
-static bool is_valid_arrow_param_tok(uint8_t tok) {
-  static const uint64_t bits[4] = {
-    0x000C000000000FCCull,
-    0x041CC0100BC00808ull,
-    0x0000000000800100ull,
-    0x0000000000000000ull
-  };
-  return (bits[tok >> 6] >> (tok & 63)) & 1;
-}
-
-static inline bool is_block_tok(uint8_t tok) {
-  static const uint64_t bits[4] = {
-    0x2108000000000110ull, 
-    0x0000000000124075ull, 0, 0
-  };
-  return (bits[tok >> 6] >> (tok & 63)) & 1;
-}
-
-static inline bool is_asi_ok_tok(uint8_t tok) {
-  static const uint64_t bits[4] = {
-    0x0000000000000212ull, 0, 0, 0
-  };
-  return (bits[tok >> 6] >> (tok & 63)) & 1;
-}
-
-static inline bool is_unboxed_obj(struct js *js, jsval_t val, jsval_t expected_proto) {
+static inline bool is_unboxed_obj(ant_t *js, jsval_t val, jsval_t expected_proto) {
   if (vtype(val) != T_OBJ) return false;
   if (vtype(get_slot(js, val, SLOT_PRIMITIVE)) != T_UNDEF) return false;
   jsval_t proto = get_slot(js, val, SLOT_PROTO);
@@ -688,65 +295,10 @@ int32_t js_to_int32(double d) {
   return (int32_t) uint32;
 }
 
-typedef struct {
-  const char *code;
-  jsoff_t clen, pos;
-  uint8_t tok, consumed;
-  int token_stream_pos;
-  void *token_stream;
-  const char *token_stream_code;
-} js_parse_state_t;
-
-#define JS_SAVE_STATE(js, state) do { \
-  (state).code = (js)->code; \
-  (state).clen = (js)->clen; \
-  (state).pos = (js)->pos; \
-  (state).tok = (js)->tok; \
-  (state).consumed = (js)->consumed; \
-  (state).token_stream_pos = (js)->token_stream_pos; \
-  (state).token_stream = (js)->token_stream; \
-  (state).token_stream_code = (js)->token_stream_code; \
-} while(0)
-
-#define JS_RESTORE_STATE(js, state) do { \
-  (js)->code = (state).code; \
-  (js)->clen = (state).clen; \
-  (js)->pos = (state).pos; \
-  (js)->tok = (state).tok; \
-  (js)->consumed = (state).consumed; \
-  (js)->token_stream_pos = (state).token_stream_pos; \
-  (js)->token_stream = (state).token_stream; \
-  (js)->token_stream_code = (state).token_stream_code; \
-} while(0)
-
-static size_t strstring(struct js *js, jsval_t value, char *buf, size_t len);
-static size_t strkey(struct js *js, jsval_t value, char *buf, size_t len);
-
-static inline jsoff_t loadoff(struct js *js, jsoff_t off) {
-  assert(off + sizeof(jsoff_t) <= js->brk); jsoff_t val;
-  memcpy(&val, &js->mem[off], sizeof(val)); return val;
-}
-
-static bool is_arr_off(struct js *js, jsoff_t off) { 
-  return (loadoff(js, off) & ARRMASK) != 0; 
-}
-
-static bool is_func_off(struct js *js, jsoff_t off) {
-  jsval_t obj = mkval(T_OBJ, off);
-  jsval_t code = get_slot(js, obj, SLOT_CODE);
-  jsval_t cfunc = get_slot(js, obj, SLOT_CFUNC);
-  return vtype(code) != T_UNDEF || vtype(cfunc) != T_UNDEF;
-}
-
-static inline jsval_t loadval(struct js *js, jsoff_t off) { 
-  return *(jsval_t *)(&js->mem[off]);
-}
-
-static jsval_t upper(struct js *js, jsval_t scope) { 
-  return mkval(T_OBJ, loadoff(js, (jsoff_t) (vdata(scope) + sizeof(jsoff_t)))); 
-}
+static size_t strstring(ant_t *js, jsval_t value, char *buf, size_t len);
+static size_t strkey(ant_t *js, jsval_t value, char *buf, size_t len);
 
-static jsoff_t vstrlen(struct js *js, jsval_t v) { 
+jsoff_t vstrlen(ant_t *js, jsval_t v) { 
   jsoff_t off = (jsoff_t) vdata(v);
   jsoff_t header = loadoff(js, off);
   if (header & ROPE_FLAG) {
@@ -755,90 +307,55 @@ static jsoff_t vstrlen(struct js *js, jsval_t v) {
   return offtolen(header);
 }
 
-#define EXPECT(_tok, ...)                                    \
-  if (next(js) != _tok) {                                    \
-    __VA_ARGS__;                                             \
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "parse error"); \
-  } else js->consumed = 1
+static jsval_t proxy_read_target(ant_t *js, jsval_t obj);
+static jsoff_t proxy_aware_length(ant_t *js, jsval_t obj);
+static jsval_t proxy_aware_get_elem(ant_t *js, jsval_t obj, const char *key, size_t key_len);
+static bool bigint_is_zero(ant_t *js, jsval_t v);
 
-#define EXPECT_IDENT(...) \
-  if (!is_valid_param_name(next(js))) {                              \
-    __VA_ARGS__;                                                     \
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected"); \
-  } else js->consumed = 1
-
-static bool is_digit(int c);
-static bool is_proxy(struct js *js, jsval_t obj);
-static jsval_t proxy_read_target(struct js *js, jsval_t obj);
-static jsoff_t proxy_aware_length(struct js *js, jsval_t obj);
-static jsval_t proxy_aware_get_elem(struct js *js, jsval_t obj, const char *key, size_t key_len);
-static bool bigint_is_zero(struct js *js, jsval_t v);
-
-static jsoff_t get_dense_buf(struct js *js, jsval_t arr);
-static jsoff_t dense_length(struct js *js, jsoff_t doff);
-static jsoff_t get_array_length(struct js *js, jsval_t arr);
-static jsval_t arr_get(struct js *js, jsval_t arr, jsoff_t idx);
-static bool arr_has(struct js *js, jsval_t arr, jsoff_t idx);
+static jsoff_t get_dense_buf(ant_t *js, jsval_t arr);
+static jsoff_t dense_length(ant_t *js, jsoff_t doff);
+static jsoff_t get_array_length(ant_t *js, jsval_t arr);
+static jsval_t arr_get(ant_t *js, jsval_t arr, jsoff_t idx);
+static bool arr_has(ant_t *js, jsval_t arr, jsoff_t idx);
 
 static bool streq(const char *buf, size_t len, const char *p, size_t n);
-static bool is_this_loop_continue_target(int depth_at_entry);
-static bool code_has_function_decl(const char *code, size_t len);
-static bool parse_func_params(struct js *js, uint8_t *flags, int *out_count);
-static bool try_dynamic_setter(struct js *js, jsval_t obj, const char *key, size_t key_len, jsval_t value);
-
-static size_t strbigint(struct js *js, jsval_t value, char *buf, size_t len);
-static size_t tostr(struct js *js, jsval_t value, char *buf, size_t len);
-static size_t strpromise(struct js *js, jsval_t value, char *buf, size_t len);
-static size_t js_to_pcre2_pattern(const char *src, size_t src_len, char *dst, size_t dst_size);
-static double js_to_number(struct js *js, jsval_t arg);
-
-static jsval_t js_stmt_impl(struct js *js);
-static jsval_t js_expr(struct js *js);
-static jsval_t js_call_valueOf(struct js *js, jsval_t value);
-static jsval_t js_call_toString(struct js *js, jsval_t value);
-static jsval_t js_eval_slice(struct js *js, jsoff_t off, jsoff_t len);
-static jsval_t js_eval_str(struct js *js, const char *code, jsoff_t len);
-static jsval_t js_stmt(struct js *js);
-static jsval_t js_assignment(struct js *js);
-static jsval_t js_arrow_func(struct js *js, jsoff_t params_start, jsoff_t params_end, bool is_async);
-static jsval_t js_async_arrow_paren(struct js *js);
-static jsval_t js_var_decl(struct js *js);
-
-static jsval_t do_op(struct js *, uint8_t op, jsval_t l, jsval_t r);
-static jsval_t do_instanceof(struct js *js, jsval_t l, jsval_t r);
-static jsval_t do_in(struct js *js, jsval_t l, jsval_t r);
+static bool parse_func_params(ant_t *js, uint8_t *flags, int *out_count);
+static bool try_dynamic_setter(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t value);
+static jsoff_t lkp_with_setter(ant_t *js, jsval_t obj, const char *buf, size_t len, jsval_t *setter_out, bool *has_setter_out);
+static jsval_t call_proto_accessor(ant_t *js, jsval_t prim, jsval_t accessor, bool has_accessor, jsval_t *arg, int arg_count, bool is_setter);
+static jsval_t get_prototype_for_type(ant_t *js, uint8_t type);
+
+static size_t strbigint(ant_t *js, jsval_t value, char *buf, size_t len);
+static size_t tostr(ant_t *js, jsval_t value, char *buf, size_t len);
+static size_t strpromise(ant_t *js, jsval_t value, char *buf, size_t len);
+static jsval_t js_call_valueOf(ant_t *js, jsval_t value);
+static jsval_t js_call_toString(ant_t *js, jsval_t value);
+static jsval_t js_call_method(ant_t *js, jsval_t obj, const char *method, size_t method_len, jsval_t *args, int nargs);
 
 static inline bool is_slot_prop(jsoff_t header);
 static inline jsoff_t next_prop(jsoff_t header);
 
-static jsval_t js_import_stmt(struct js *js);
-static jsval_t js_export_stmt(struct js *js);
-
-static jsval_t builtin_Object(struct js *js, jsval_t *args, int nargs);
-static jsval_t builtin_promise_then(struct js *js, jsval_t *args, int nargs);
-static jsval_t string_split_impl(struct js *js, jsval_t str, jsval_t *args, int nargs);
-static jsval_t is_regexp_like(struct js *js, jsval_t value);
-static jsval_t should_regexp_passthrough(struct js *js, jsval_t *args, int nargs);
-
-static jsval_t proxy_get(struct js *js, jsval_t proxy, const char *key, size_t key_len);
-static jsval_t proxy_set(struct js *js, jsval_t proxy, const char *key, size_t key_len, jsval_t value);
-static jsval_t proxy_has(struct js *js, jsval_t proxy, const char *key, size_t key_len);
-static jsval_t proxy_delete(struct js *js, jsval_t proxy, const char *key, size_t key_len);
+static jsval_t builtin_Object(ant_t *js, jsval_t *args, int nargs);
+static jsval_t builtin_promise_then(ant_t *js, jsval_t *args, int nargs);
+static jsval_t string_split_impl(ant_t *js, jsval_t str, jsval_t *args, int nargs);
 
-static uint8_t next_raw(struct js *js);
-static inline bool push_this(jsval_t this_value);
-static inline jsval_t pop_this(void);
+static jsval_t proxy_get(ant_t *js, jsval_t proxy, const char *key, size_t key_len);
+static jsval_t proxy_get_val(ant_t *js, jsval_t proxy, jsval_t key_val);
+static jsval_t proxy_set(ant_t *js, jsval_t proxy, const char *key, size_t key_len, jsval_t value);
+static jsval_t proxy_has(ant_t *js, jsval_t proxy, const char *key, size_t key_len);
+static jsval_t proxy_has_val(ant_t *js, jsval_t proxy, jsval_t key_val);
+static jsval_t proxy_delete(ant_t *js, jsval_t proxy, const char *key, size_t key_len);
+static jsval_t proxy_delete_val(ant_t *js, jsval_t proxy, jsval_t key_val);
 
-static jsval_t get_prototype_for_type(struct js *js, uint8_t type);
-static jsval_t get_ctor_proto(struct js *js, const char *name, size_t len);
-static jsoff_t lkp_interned(struct js *js, jsval_t obj, const char *search_intern, size_t len);
+static jsval_t get_prototype_for_type(ant_t *js, uint8_t type);
+static jsval_t get_ctor_proto(ant_t *js, const char *name, size_t len);
+static jsoff_t lkp_interned(ant_t *js, jsval_t obj, const char *search_intern, size_t len);
 
-static descriptor_entry_t *lookup_descriptor(struct js *js, jsoff_t obj_off, const char *key, size_t klen);
-static const char *bigint_digits(struct js *js, jsval_t v, size_t *len);
+static const char *bigint_digits(ant_t *js, jsval_t v, size_t *len);
 
 typedef struct { jsval_t handle; bool is_new; } ctor_t;
 
-static ctor_t get_constructor(struct js *js, const char *name, size_t len) {
+static ctor_t get_constructor(ant_t *js, const char *name, size_t len) {
   ctor_t ctor;
   
   ctor.handle = get_ctor_proto(js, name, len);
@@ -847,14 +364,14 @@ static ctor_t get_constructor(struct js *js, const char *name, size_t len) {
   return ctor;
 }
 
-static jsval_t unwrap_primitive(struct js *js, jsval_t val) {
+jsval_t unwrap_primitive(ant_t *js, jsval_t val) {
   if (vtype(val) != T_OBJ) return val;
   jsval_t prim = get_slot(js, val, SLOT_PRIMITIVE);
   if (vtype(prim) == T_UNDEF) return val;
   return prim;
 }
 
-static jsval_t to_string_val(struct js *js, jsval_t val) {
+static jsval_t to_string_val(ant_t *js, jsval_t val) {
   uint8_t t = vtype(val);
   if (t == T_STR) return val;
   if (t == T_OBJ) {
@@ -864,10 +381,11 @@ static jsval_t to_string_val(struct js *js, jsval_t val) {
   return js_call_toString(js, val);
 }
 
-bool js_truthy(struct js *js, jsval_t v) {
+bool js_truthy(ant_t *js, jsval_t v) {
   static const void *dispatch[] = {
     [T_OBJ]    = &&l_true,
     [T_FUNC]   = &&l_true,
+    [T_CFUNC]  = &&l_true,
     [T_ARR]    = &&l_true,
     [T_SYMBOL] = &&l_true,
     [T_BOOL]   = &&l_bool,
@@ -919,7 +437,7 @@ size_t uint_to_str(char *buf, size_t bufsize, uint64_t val) {
   return len;
 }
 
-static jsval_t bigint_from_u64(struct js *js, uint64_t value) {
+static jsval_t bigint_from_u64(ant_t *js, uint64_t value) {
   char buf[32];
   size_t len = uint_to_str(buf, sizeof(buf), value);
   return js_mkbigint(js, buf, len, false);
@@ -934,7 +452,7 @@ static int multiref_ids[MAX_MULTIREF_OBJS];
 static int multiref_count = 0;
 static int multiref_next_id = 0;
 
-static void scan_refs(struct js *js, jsval_t value);
+static void scan_refs(ant_t *js, jsval_t value);
 
 static int find_multiref(jsval_t obj) {
   for (int i = 0; i < multiref_count; i++) {
@@ -964,7 +482,7 @@ static void mark_multiref(jsval_t obj) {
   }
 }
 
-static void scan_obj_refs(struct js *js, jsval_t obj) {
+static void scan_obj_refs(ant_t *js, jsval_t obj) {
   if (is_on_stack(obj)) {
     mark_multiref(obj);
     return;
@@ -973,7 +491,7 @@ static void scan_obj_refs(struct js *js, jsval_t obj) {
   if (stringify_depth >= MAX_STRINGIFY_DEPTH) return;
   stringify_stack[stringify_depth++] = obj;
   
-  jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
+  jsoff_t next = loadoff(js, (jsoff_t) vdata(js_as_obj(obj))) & ~(3U | FLAGMASK);
   while (next < js->brk && next != 0) {
     jsoff_t header = loadoff(js, next);
     if (!is_slot_prop(header)) {
@@ -990,7 +508,7 @@ static void scan_obj_refs(struct js *js, jsval_t obj) {
   stringify_depth--;
 }
 
-static void scan_arr_refs(struct js *js, jsval_t obj) {
+static void scan_arr_refs(ant_t *js, jsval_t obj) {
   if (is_on_stack(obj)) {
     mark_multiref(obj);
     return;
@@ -999,7 +517,7 @@ static void scan_arr_refs(struct js *js, jsval_t obj) {
   if (stringify_depth >= MAX_STRINGIFY_DEPTH) return;
   stringify_stack[stringify_depth++] = obj;
   
-  jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
+  jsoff_t next = loadoff(js, (jsoff_t) vdata(js_as_obj(obj))) & ~(3U | FLAGMASK);
   while (next < js->brk && next != 0) {
     jsoff_t header = loadoff(js, next);
     if (!is_slot_prop(header)) {
@@ -1013,8 +531,8 @@ static void scan_arr_refs(struct js *js, jsval_t obj) {
   stringify_depth--;
 }
 
-static void scan_func_refs(struct js *js, jsval_t value) {
-  jsval_t func_obj = mkval(T_OBJ, vdata(value));
+static void scan_func_refs(ant_t *js, jsval_t value) {
+  jsval_t func_obj = js_func_obj(value);
   
   if (is_on_stack(func_obj)) {
     mark_multiref(func_obj);
@@ -1038,7 +556,7 @@ static void scan_func_refs(struct js *js, jsval_t value) {
   stringify_depth--;
 }
 
-static void scan_refs(struct js *js, jsval_t value) {
+static void scan_refs(ant_t *js, jsval_t value) {
   switch (vtype(value)) {
     case T_OBJ: scan_obj_refs(js, value); break;
     case T_ARR: scan_arr_refs(js, value); break;
@@ -1082,22 +600,27 @@ static size_t add_indent(char *buf, size_t len, int level) {
   return wanted;
 }
 
-static inline jsoff_t get_prop_koff(struct js *js, jsoff_t prop) {
+static inline jsoff_t get_prop_koff(ant_t *js, jsoff_t prop) {
   return loadoff(js, prop + (jsoff_t) sizeof(prop));
 }
 
-static void get_prop_key(struct js *js, jsoff_t prop, const char **key, jsoff_t *klen) {
+static inline bool is_sym_key_prop(ant_t *js, jsoff_t prop) {
+  jsoff_t koff = get_prop_koff(js, prop);
+  return koff < js->brk && (loadoff(js, koff) & 0xF) == 0;
+}
+
+static void get_prop_key(ant_t *js, jsoff_t prop, const char **key, jsoff_t *klen) {
   jsoff_t koff = get_prop_koff(js, prop);
   *klen = offtolen(loadoff(js, koff));
   *key = (char *) &js->mem[koff + sizeof(koff)];
 }
 
-static jsval_t get_prop_val(struct js *js, jsoff_t prop) {
+static jsval_t get_prop_val(ant_t *js, jsoff_t prop) {
   jsoff_t koff = get_prop_koff(js, prop);
   return loadval(js, prop + (jsoff_t) (sizeof(prop) + sizeof(koff)));
 }
 
-const char *get_str_prop(struct js *js, jsval_t obj, const char *key, jsoff_t klen, jsoff_t *out_len) {
+const char *get_str_prop(ant_t *js, jsval_t obj, const char *key, jsoff_t klen, jsoff_t *out_len) {
   jsoff_t off = lkp(js, obj, key, klen);
   if (off <= 0) return NULL;
   jsval_t v = resolveprop(js, mkval(T_PROP, off));
@@ -1105,7 +628,7 @@ const char *get_str_prop(struct js *js, jsval_t obj, const char *key, jsoff_t kl
   return (const char *)&js->mem[vstr(js, v, out_len)];
 }
 
-static bool is_small_array(struct js *js, jsval_t obj, int *elem_count) {
+static bool is_small_array(ant_t *js, jsval_t obj, int *elem_count) {
   jsoff_t length = get_array_length(js, obj);
   if (length > 64) { if (elem_count) *elem_count = (int)length; return false; }
   
@@ -1142,20 +665,21 @@ static inline bool parse_array_index(const char *key, size_t klen, jsoff_t max_l
   return true;
 }
 
-static jsoff_t get_array_length(struct js *js, jsval_t arr) {
-  jsoff_t dense_len = 0;
+static jsoff_t get_array_length(ant_t *js, jsval_t arr) {
   jsoff_t doff = get_dense_buf(js, arr);
-  if (doff) dense_len = dense_length(js, doff);
-  jsoff_t prop_len = 0;
+  jsoff_t dense_len = doff ? dense_length(js, doff) : 0;
   jsoff_t off = lkp_interned(js, arr, INTERN_LENGTH, 6);
   if (off) {
     jsval_t val = resolveprop(js, mkval(T_PROP, off));
-    if (vtype(val) == T_NUM) prop_len = (jsoff_t) tod(val);
+    if (vtype(val) == T_NUM) {
+      jsoff_t prop_len = (jsoff_t) tod(val);
+      return prop_len > dense_len ? prop_len : dense_len;
+    }
   }
-  return dense_len > prop_len ? dense_len : prop_len;
+  return dense_len;
 }
 
-static jsval_t get_obj_ctor(struct js *js, jsval_t obj) {
+static jsval_t get_obj_ctor(ant_t *js, jsval_t obj) {
   jsval_t ctor = get_slot(js, obj, SLOT_CTOR);
   if (vtype(ctor) == T_FUNC) return ctor;
   jsval_t proto = get_slot(js, obj, SLOT_PROTO);
@@ -1164,9 +688,9 @@ static jsval_t get_obj_ctor(struct js *js, jsval_t obj) {
   return off ? resolveprop(js, mkval(T_PROP, off)) : js_mkundef();
 }
 
-static const char *get_func_name(struct js *js, jsval_t func, jsoff_t *out_len) {
+static const char *get_func_name(ant_t *js, jsval_t func, jsoff_t *out_len) {
   if (vtype(func) != T_FUNC) return NULL;
-  jsoff_t off = lkp(js, mkval(T_OBJ, vdata(func)), "name", 4);
+  jsoff_t off = lkp(js, js_func_obj(func), "name", 4);
   if (!off) return NULL;
   jsval_t name = resolveprop(js, mkval(T_PROP, off));
   if (vtype(name) != T_STR) return NULL;
@@ -1174,24 +698,24 @@ static const char *get_func_name(struct js *js, jsval_t func, jsoff_t *out_len)
   return (const char *) &js->mem[str_off];
 }
 
-static const char *get_class_name(struct js *js, jsval_t obj, jsoff_t *out_len, const char *skip) {
+static const char *get_class_name(ant_t *js, jsval_t obj, jsoff_t *out_len, const char *skip) {
   const char *name = get_func_name(js, get_obj_ctor(js, obj), out_len);
   if (!name) return NULL;
   if (skip && *out_len == (jsoff_t)strlen(skip) && memcmp(name, skip, *out_len) == 0) return NULL;
   return name;
 }
 
-static inline jsoff_t dense_iterable_length(struct js *js, jsval_t obj) {
+static inline jsoff_t dense_iterable_length(ant_t *js, jsval_t obj) {
   jsoff_t doff = get_dense_buf(js, obj);
   return doff ? dense_length(js, doff) : 0;
 }
 
-static size_t strarr(struct js *js, jsval_t obj, char *buf, size_t len) {
+static size_t strarr(ant_t *js, jsval_t obj, char *buf, size_t len) {
   int ref = get_circular_ref(obj);
   if (ref) return ref > 0 ? (size_t) snprintf(buf, len, "[Circular *%d]", ref) : cpy(buf, len, "[Circular]", 10);
   
   push_stringify(obj);
-  jsoff_t first = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
+  jsoff_t first = loadoff(js, (jsoff_t) vdata(js_as_obj(obj))) & ~(3U | FLAGMASK);
   jsoff_t length = get_array_length(js, obj);
   jsoff_t d_len = dense_iterable_length(js, obj);
   jsoff_t iter_len = (d_len >= length) ? length : d_len;
@@ -1259,74 +783,18 @@ static size_t strarr(struct js *js, jsval_t obj, char *buf, size_t len) {
   return n;
 }
 
-static size_t array_to_string(struct js *js, jsval_t obj, char *buf, size_t len) {
-  if (is_circular(obj)) return cpy(buf, len, "", 0);
-  
-  push_stringify(obj); size_t n = 0;
-  jsoff_t length = get_array_length(js, obj);
-  jsoff_t d_len = dense_iterable_length(js, obj);
-  jsoff_t iter_len = (d_len >= length) ? length : d_len;
-  
-  for (jsoff_t i = 0; i < iter_len; i++) {
-    if (i > 0) n += cpy(buf + n, REMAIN(n, len), ",", 1);
-    jsval_t val = arr_get(js, obj, i);
-    
-    if (arr_has(js, obj, i)) {
-      uint8_t vt = vtype(val);
-      if (vt == T_STR) {
-        jsoff_t slen, soff = vstr(js, val, &slen);
-        n += cpy(buf + n, REMAIN(n, len), (const char *)&js->mem[soff], slen);
-      } else if (vt != T_UNDEF && vt != T_NULL) n += tostr(js, val, buf + n, REMAIN(n, len));
-    }
-  }
-  
-  jsoff_t first = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
-  for (jsoff_t p = first; p < js->brk && p != 0; p = next_prop(loadoff(js, p))) {
-    jsoff_t header = loadoff(js, p);
-    if (is_slot_prop(header)) continue;
-    const char *key; jsoff_t klen;
-    get_prop_key(js, p, &key, &klen);
-    if (streq(key, klen, "length", 6)) continue;
-    if (!is_array_index(key, klen)) continue;
-    if (n > 0) n += cpy(buf + n, REMAIN(n, len), ",", 1);
-    jsval_t val = get_prop_val(js, p);
-    uint8_t vt = vtype(val);
-    if (vt == T_STR) {
-      jsoff_t slen, soff = vstr(js, val, &slen);
-      n += cpy(buf + n, REMAIN(n, len), (const char *)&js->mem[soff], slen);
-    } else if (vt != T_UNDEF && vt != T_NULL) n += tostr(js, val, buf + n, REMAIN(n, len));
-  }
-  
-  pop_stringify();
-  return n;
-}
-
-static size_t strdate(struct js *js, jsval_t obj, char *buf, size_t len) {
+static size_t strdate(ant_t *js, jsval_t obj, char *buf, size_t len) {
   jsval_t time_val = js_get_slot(js, obj, SLOT_DATA);
   if (vtype(time_val) != T_NUM) return cpy(buf, len, "Invalid Date", 12);
+
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_ISO, DATE_STRING_PART_ALL};
+  jsval_t iso = get_date_string(js, obj, kSpec);
+  if (is_err(iso) || vtype(iso) != T_STR) return cpy(buf, len, "Invalid Date", 12);
+
+  jsoff_t slen;
+  jsoff_t soff = vstr(js, iso, &slen);
   
-  double timestamp_ms = tod(time_val);
-  time_t timestamp_sec = (time_t)(timestamp_ms / 1000.0);
-  struct tm *tm_local = localtime(&timestamp_sec);
-  
-  if (!tm_local) return cpy(buf, len, "Invalid Date", 12);
-  
-  char date_part[64];
-  strftime(date_part, sizeof(date_part), "%a %b %d %Y %H:%M:%S", tm_local);
-  
-  time_t now = timestamp_sec;
-  struct tm *gm = gmtime(&now);
-  struct tm local_copy = *tm_local;
-  time_t local_time = mktime(&local_copy);
-  time_t gmt_time = mktime(gm);
-  long offset_sec = (long)difftime(local_time, gmt_time);
-  int offset_hours = (int)(offset_sec / 3600);
-  int offset_mins = (int)(labs(offset_sec) % 3600) / 60;
-  
-  char tz_name[64];
-  strftime(tz_name, sizeof(tz_name), "%Z", tm_local);
-  
-  return (size_t) snprintf(buf, len, "%s GMT%+03d%02d (%s)", date_part, offset_hours, offset_mins, tz_name);
+  return cpy(buf, len, (const char *)&js->mem[soff], slen);
 }
 
 static bool is_valid_identifier(const char *str, jsoff_t slen) {
@@ -1340,52 +808,43 @@ static bool is_valid_identifier(const char *str, jsoff_t slen) {
   return true;
 }
 
-static size_t strkey(struct js *js, jsval_t value, char *buf, size_t len) {
+static size_t strkey(ant_t *js, jsval_t value, char *buf, size_t len) {
   jsoff_t slen, off = vstr(js, value, &slen);
   const char *str = (const char *) &js->mem[off];
   
-  const char *sym_desc = get_symbol_description_from_key(str, slen);
-  if (sym_desc) {
-    size_t n = 0;
-    n += cpy(buf + n, REMAIN(n, len), "[", 1);
-    n += cpy(buf + n, REMAIN(n, len), sym_desc, strlen(sym_desc));
-    n += cpy(buf + n, REMAIN(n, len), "]", 1);
-    return n;
-  }
-  
   if (is_valid_identifier(str, slen)) {
     return cpy(buf, len, str, slen);
   }
   return strstring(js, value, buf, len);
 }
 
-static bool is_small_object(struct js *js, jsval_t obj, int *prop_count) {
+static bool is_small_object(ant_t *js, jsval_t obj, int *prop_count) {
   int count = 0;
   bool has_nested = false;
   
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
   jsoff_t next = loadoff(js, obj_off) & ~(3U | FLAGMASK);
   
   while (next < js->brk && next != 0) {
     jsoff_t header = loadoff(js, next);
     if (is_slot_prop(header)) { next = next_prop(header); continue; }
     
+    if (is_sym_key_prop(js, next)) {
+      count++;
+      next = next_prop(header);
+      continue;
+    }
+    
     const char *key; jsoff_t klen;
     get_prop_key(js, next, &key, &klen);
-    const char *tag_sym_key = get_toStringTag_sym_key();
-    bool should_hide = streq(key, klen, STR_PROTO, STR_PROTO_LEN) || streq(key, klen, tag_sym_key, strlen(tag_sym_key));
     
-    if (!should_hide) {
-      descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, klen);
-      if (desc && !desc->enumerable) should_hide = true;
-    }
+    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, klen);
+    if (desc && !desc->enumerable) { next = next_prop(header); continue; }
     
-    if (!should_hide) {
-      jsval_t val = get_prop_val(js, next);
-      uint8_t t = vtype(val);
-      if (t == T_OBJ || t == T_ARR || t == T_FUNC) has_nested = true;
-      count++;
-    }
+    jsval_t val = get_prop_val(js, next);
+    uint8_t t = vtype(val);
+    if (t == T_OBJ || t == T_ARR || t == T_FUNC) has_nested = true;
+    count++;
     
     next = next_prop(header);
   }
@@ -1403,7 +862,7 @@ static bool is_small_object(struct js *js, jsval_t obj, int *prop_count) {
 }
 
 // todo: split into smaller functions
-static size_t strobj(struct js *js, jsval_t obj, char *buf, size_t len) {
+static size_t strobj(ant_t *js, jsval_t obj, char *buf, size_t len) {
   jsval_t obj_proto = js_get_proto(js, obj);
   jsval_t date_proto = js_get_ctor_proto(js, "Date", 4);
   if (obj_proto == date_proto) return strdate(js, obj, buf, len);
@@ -1419,8 +878,8 @@ static size_t strobj(struct js *js, jsval_t obj, char *buf, size_t len) {
     n += (size_t) snprintf(buf + n, REMAIN(n, len), "<ref *%d> ", self_ref);
   }
   
-  const char *tostring_tag_key = get_toStringTag_sym_key();
-  jsoff_t tag_off = lkp_proto(js, obj, tostring_tag_key, strlen(tostring_tag_key));
+  jsval_t tag_sym = get_toStringTag_sym();
+  jsoff_t tag_off = (vtype(tag_sym) == T_SYMBOL) ? lkp_sym_proto(js, obj, (jsoff_t)vdata(tag_sym)) : 0;
   bool is_map = false, is_set = false, is_arraybuffer = false;
   jsoff_t tlen = 0, toff = 0;
   const char *tag_str = NULL;
@@ -1714,10 +1173,10 @@ print_plain_object:
 continue_object_print:;
   
   if (!inline_mode) stringify_indent++;
-  jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
+  jsoff_t next = loadoff(js, (jsoff_t) vdata(js_as_obj(obj))) & ~(3U | FLAGMASK);
   bool first = true;
   
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
   int prop_capacity = 64;
   
   jsoff_t *prop_offsets = malloc(prop_capacity * sizeof(jsoff_t));
@@ -1727,29 +1186,24 @@ continue_object_print:;
     jsoff_t header = loadoff(js, next);
     if (is_slot_prop(header)) { next = next_prop(header); continue; }
     
+    if (is_sym_key_prop(js, next)) { next = next_prop(header); continue; }
+    
     jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
     jsoff_t klen = offtolen(loadoff(js, koff));
-    
     const char *key = (char *) &js->mem[koff + sizeof(koff)];
-    const char *tag_sym_key = get_toStringTag_sym_key();
-    bool should_hide = streq(key, klen, STR_PROTO, STR_PROTO_LEN) || streq(key, klen, tag_sym_key, strlen(tag_sym_key));
     
-    if (!should_hide) {
-      descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, klen);
-      if (desc && !desc->enumerable) should_hide = true;
-    }
+    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, klen);
+    if (desc && !desc->enumerable) { next = next_prop(header); continue; }
     
-    if (!should_hide) {
-      if (num_props >= prop_capacity) {
-        prop_capacity *= 2;
-        prop_offsets = realloc(prop_offsets, prop_capacity * sizeof(jsoff_t));
-      }
-      prop_offsets[num_props++] = next;
+    if (num_props >= prop_capacity) {
+      prop_capacity *= 2;
+      prop_offsets = realloc(prop_offsets, prop_capacity * sizeof(jsoff_t));
     }
+    prop_offsets[num_props++] = next;
     next = next_prop(header);
   }
   
-  for (int i = num_props - 1; i >= 0; i--) {
+  for (int i = 0; i < num_props; i++) {
     jsoff_t prop = prop_offsets[i];
     jsoff_t koff = loadoff(js, prop + (jsoff_t) sizeof(prop));
     jsoff_t klen = offtolen(loadoff(js, koff));
@@ -1780,6 +1234,32 @@ continue_object_print:;
   }
   free(prop_offsets);
   
+  next = loadoff(js, obj_off) & ~(3U | FLAGMASK);
+  while (next < js->brk && next != 0) {
+    jsoff_t header = loadoff(js, next);
+    if (is_slot_prop(header) || !is_sym_key_prop(js, next)) { 
+      next = next_prop(header); continue; 
+    }
+    
+    jsoff_t sym_off = get_prop_koff(js, next);
+    if (vtype(tag_sym) == T_SYMBOL && sym_off == (jsoff_t)vdata(tag_sym)) { 
+      next = next_prop(header); continue; 
+    }
+    
+    jsval_t sym = mkval(T_SYMBOL, sym_off);
+    jsval_t val = loadval(js, next + (jsoff_t)(sizeof(jsoff_t) * 2));
+    
+    if (!first) n += cpy(buf + n, REMAIN(n, len), inline_mode ? ", " : ",\n", 2);
+    first = false;
+    if (!inline_mode) n += add_indent(buf + n, REMAIN(n, len), stringify_indent);
+    n += cpy(buf + n, REMAIN(n, len), "[", 1);
+    n += tostr(js, sym, buf + n, REMAIN(n, len));
+    n += cpy(buf + n, REMAIN(n, len), "]: ", 3);
+    n += tostr(js, val, buf + n, REMAIN(n, len));
+    
+    next = next_prop(header);
+  }
+  
   descriptor_entry_t *desc, *tmp;
   HASH_ITER(hh, desc_registry, desc, tmp) {
     if (desc->obj_off != obj_off) continue;
@@ -1866,60 +1346,88 @@ static size_t strnum(jsval_t value, char *buf, size_t len) {
   return cpy(buf, len, temp, strlen(temp));
 }
 
-static inline bool is_rope(struct js *js, jsval_t value) {
+static inline jsoff_t assert_string_header(ant_t *js, jsval_t value, jsoff_t *out_off) {
+  assert(vtype(value) == T_STR);
   jsoff_t off = (jsoff_t) vdata(value);
+  assert(off + sizeof(jsoff_t) <= js->brk);
   jsoff_t header = loadoff(js, off);
+  assert((header & 3) == T_STR);
+  if (out_off) *out_off = off;
+  return header;
+}
+
+static inline jsoff_t assert_flat_string_len(ant_t *js, jsval_t value, jsoff_t *out_off) {
+  jsoff_t off;
+  jsoff_t header = assert_string_header(js, value, &off);
+  assert((header & ROPE_FLAG) == 0);
+  jsoff_t len = offtolen(header);
+  assert(off + sizeof(jsoff_t) + len <= js->brk);
+  if (out_off) *out_off = off;
+  return len;
+}
+
+static inline jsoff_t assert_rope_header(ant_t *js, jsval_t value, jsoff_t *out_off) {
+  jsoff_t off;
+  jsoff_t header = assert_string_header(js, value, &off);
+  assert((header & ROPE_FLAG) != 0);
+  assert(off + sizeof(rope_node_t) <= js->brk);
+  jsoff_t payload_header = header & ~(ROPE_FLAG | (ROPE_DEPTH_MASK << ROPE_DEPTH_SHIFT));
+  assert((payload_header >> 3) > 0);
+  if (out_off) *out_off = off;
+  return header;
+}
+
+bool is_rope(ant_t *js, jsval_t value) {
+  jsoff_t header = assert_string_header(js, value, NULL);
+  if ((header & ROPE_FLAG) != 0) assert_rope_header(js, value, NULL);
   return (header & ROPE_FLAG) != 0;
 }
 
-static inline jsoff_t rope_len(struct js *js, jsval_t value) {
-  jsoff_t off = (jsoff_t) vdata(value);
-  jsoff_t header = loadoff(js, off);
+static inline jsoff_t rope_len(ant_t *js, jsval_t value) {
+  jsoff_t header = assert_rope_header(js, value, NULL);
   return offtolen(header & ~(ROPE_FLAG | (ROPE_DEPTH_MASK << ROPE_DEPTH_SHIFT)));
 }
 
-static inline uint8_t rope_depth(struct js *js, jsval_t value) {
+static inline uint8_t rope_depth(ant_t *js, jsval_t value) {
   jsoff_t off = (jsoff_t) vdata(value);
   jsoff_t header = loadoff(js, off);
   return (uint8_t)((header >> ROPE_DEPTH_SHIFT) & ROPE_DEPTH_MASK);
 }
 
-static inline jsval_t rope_left(struct js *js, jsval_t value) {
+static inline jsval_t rope_left(ant_t *js, jsval_t value) {
   jsoff_t off = (jsoff_t) vdata(value);
   return loadval(js, off + offsetof(rope_node_t, left));
 }
 
-static inline jsval_t rope_right(struct js *js, jsval_t value) {
+static inline jsval_t rope_right(ant_t *js, jsval_t value) {
   jsoff_t off = (jsoff_t) vdata(value);
   return loadval(js, off + offsetof(rope_node_t, right));
 }
 
-static inline jsval_t rope_cached_flat(struct js *js, jsval_t value) {
+static inline jsval_t rope_cached_flat(ant_t *js, jsval_t value) {
   jsoff_t off = (jsoff_t) vdata(value);
   return loadval(js, off + offsetof(rope_node_t, cached));
 }
 
-static inline void rope_set_cached_flat(struct js *js, jsval_t rope, jsval_t flat) {
+static inline void rope_set_cached_flat(ant_t *js, jsval_t rope, jsval_t flat) {
   jsoff_t off = (jsoff_t) vdata(rope);
   saveval(js, off + offsetof(rope_node_t, cached), flat);
 }
 
-static void rope_flatten_into(struct js *js, jsval_t str, char *dest, jsoff_t *pos) {
-  if (vtype(str) != T_STR) return;
+static void rope_flatten_into(ant_t *js, jsval_t str, char *dest, jsoff_t *pos) {
+  assert(vtype(str) == T_STR);
   
   if (!is_rope(js, str)) {
-    jsoff_t slen;
-    jsoff_t soff = (jsoff_t) vdata(str);
-    slen = offtolen(loadoff(js, soff));
+    jsoff_t soff;
+    jsoff_t slen = assert_flat_string_len(js, str, &soff);
     memcpy(dest + *pos, &js->mem[soff + sizeof(jsoff_t)], slen);
     *pos += slen; return;
   }
   
   jsval_t cached = rope_cached_flat(js, str);
   if (vtype(cached) == T_STR && !is_rope(js, cached)) {
-    jsoff_t clen;
-    jsoff_t coff = (jsoff_t) vdata(cached);
-    clen = offtolen(loadoff(js, coff));
+    jsoff_t coff;
+    jsoff_t clen = assert_flat_string_len(js, cached, &coff);
     memcpy(dest + *pos, &js->mem[coff + sizeof(jsoff_t)], clen);
     *pos += clen; return;
   }
@@ -1929,21 +1437,19 @@ static void rope_flatten_into(struct js *js, jsval_t str, char *dest, jsoff_t *p
   
   while (sp > 0) {
     jsval_t node = stack[--sp];
-    if (vtype(node) != T_STR) continue;
+    assert(vtype(node) == T_STR);
     
     if (!is_rope(js, node)) {
-      jsoff_t slen;
-      jsoff_t soff = (jsoff_t) vdata(node);
-      slen = offtolen(loadoff(js, soff));
+      jsoff_t soff;
+      jsoff_t slen = assert_flat_string_len(js, node, &soff);
       memcpy(dest + *pos, &js->mem[soff + sizeof(jsoff_t)], slen);
       *pos += slen; continue;
     }
     
     jsval_t c = rope_cached_flat(js, node);
     if (vtype(c) == T_STR && !is_rope(js, c)) {
-      jsoff_t clen;
-      jsoff_t coff = (jsoff_t) vdata(c);
-      clen = offtolen(loadoff(js, coff));
+      jsoff_t coff;
+      jsoff_t clen = assert_flat_string_len(js, c, &coff);
       memcpy(dest + *pos, &js->mem[coff + sizeof(jsoff_t)], clen);
       *pos += clen; continue;
     }
@@ -1955,7 +1461,8 @@ static void rope_flatten_into(struct js *js, jsval_t str, char *dest, jsoff_t *p
   }
 }
 
-static jsval_t rope_flatten(struct js *js, jsval_t rope) {
+jsval_t rope_flatten(ant_t *js, jsval_t rope) {
+  assert(vtype(rope) == T_STR);
   if (!is_rope(js, rope)) return rope;
   
   jsval_t cached = rope_cached_flat(js, rope);
@@ -1980,25 +1487,22 @@ static jsval_t rope_flatten(struct js *js, jsval_t rope) {
   return flat;
 }
 
-jsoff_t vstr(struct js *js, jsval_t value, jsoff_t *len) {
-  jsoff_t off = (jsoff_t) vdata(value);
-  jsoff_t header = loadoff(js, off);
+jsoff_t vstr(ant_t *js, jsval_t value, jsoff_t *len) {
+  jsoff_t header = assert_string_header(js, value, NULL);
   
   if (header & ROPE_FLAG) {
     jsval_t flat = rope_flatten(js, value);
-    if (is_err(flat)) {
-      if (len) *len = 0;
-      return 0;
-    }
-    off = (jsoff_t) vdata(flat);
-    header = loadoff(js, off);
+    assert(!is_err(flat));
+    value = flat;
   }
   
-  if (len) *len = offtolen(header);
+  jsoff_t off;
+  jsoff_t slen = assert_flat_string_len(js, value, &off);
+  if (len) *len = slen;
   return (jsoff_t) (off + sizeof(off));
 }
 
-static size_t strstring(struct js *js, jsval_t value, char *buf, size_t len) {
+static size_t strstring(ant_t *js, jsval_t value, char *buf, size_t len) {
   jsoff_t slen, off = vstr(js, value, &slen);
   const char *str = (const char *) &js->mem[off];
   size_t n = 0;
@@ -2070,11 +1574,12 @@ static const struct func_format formats[] = {
   [1] = { "[AsyncFunction: ", 16, "[AsyncFunction (anonymous)]", 27 },
 };
 
-static size_t strfunc(struct js *js, jsval_t value, char *buf, size_t len) {
+// todo: make it work with bytecode NAME
+static size_t strfunc(ant_t *js, jsval_t value, char *buf, size_t len) {
   jsoff_t name_len = 0;
   const char *name = get_func_name(js, value, &name_len);
   
-  jsval_t func_obj = mkval(T_OBJ, vdata(value));
+  jsval_t func_obj = js_func_obj(value);
   jsval_t code_slot = get_slot(js, func_obj, SLOT_CODE);
   jsval_t builtin_slot = get_slot(js, func_obj, SLOT_BUILTIN);
   jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
@@ -2139,7 +1644,7 @@ static size_t strfunc(struct js *js, jsval_t value, char *buf, size_t len) {
   return cpy(buf, len, fmt->anon, fmt->anon_len);
 }
 
-static size_t tostr(struct js *js, jsval_t value, char *buf, size_t len) {
+static size_t tostr(ant_t *js, jsval_t value, char *buf, size_t len) {
   switch (vtype(value)) {
     case T_UNDEF:   return ANT_COPY(buf, len, "undefined");
     case T_NULL:    return ANT_COPY(buf, len, "null");
@@ -2161,9 +1666,17 @@ static size_t tostr(struct js *js, jsval_t value, char *buf, size_t len) {
     case T_FFI:     return ANT_COPY(buf, len, "[native code (ffi)]");
     
     case T_ERR: {
-      const char *msg = js->errmsg ? js->errmsg : "Error";
-      size_t mlen = strlen(msg);
-      return cpy(buf, len, msg, mlen);
+      uint64_t data = vdata(value);
+      if (data != 0) {
+        jsval_t obj = mkval(T_OBJ, data);
+        jsval_t stack = js_get(js, obj, "stack");
+        if (vtype(stack) == T_STR) {
+          jsoff_t slen;
+          jsoff_t off = vstr(js, stack, &slen);
+          return cpy(buf, len, (const char *)&js->mem[off], slen);
+        }
+      }
+      return ANT_COPY(buf, len, "Error");
     }
     
     case T_SYMBOL: {
@@ -2177,7 +1690,7 @@ static size_t tostr(struct js *js, jsval_t value, char *buf, size_t len) {
   }
 }
 
-static char *tostr_alloc(struct js *js, jsval_t value) {
+static char *tostr_alloc(ant_t *js, jsval_t value) {
   size_t cap = 64;
   char *buf = ant_calloc(cap);
   size_t n = tostr(js, value, buf, cap);
@@ -2189,12 +1702,24 @@ static char *tostr_alloc(struct js *js, jsval_t value) {
   return buf;
 }
 
-js_cstr_t js_to_cstr(struct js *js, jsval_t value, char *stack_buf, size_t stack_size) {
+js_cstr_t js_to_cstr(ant_t *js, jsval_t value, char *stack_buf, size_t stack_size) {
   js_cstr_t out = { .ptr = "", .len = 0, .needs_free = false };
 
   if (is_err(value)) {
-    out.ptr = js->errmsg ? js->errmsg : "";
-    out.len = strlen(out.ptr);
+    uint64_t data = vdata(value);
+    if (data != 0) {
+      jsval_t obj = mkval(T_OBJ, data);
+      jsval_t stack = js_get(js, obj, "stack");
+      if (vtype(stack) == T_STR) {
+        jsoff_t slen;
+        jsoff_t off = vstr(js, stack, &slen);
+        out.ptr = (const char *)&js->mem[off];
+        out.len = slen;
+        return out;
+      }
+    }
+    out.ptr = "Error";
+    out.len = 5;
     return out;
   }
 
@@ -2254,18 +1779,18 @@ js_cstr_t js_to_cstr(struct js *js, jsval_t value, char *stack_buf, size_t stack
   }
 }
 
-jsval_t js_tostring_val(struct js *js, jsval_t value) {
+jsval_t js_tostring_val(ant_t *js, jsval_t value) {
   uint8_t t = vtype(value);
   char *buf; size_t len, buflen;
   
   static const void *jump_table[] = {
     [T_OBJ] = &&L_OBJ, [T_PROP] = &&L_DEFAULT, [T_STR] = &&L_STR,
     [T_UNDEF] = &&L_UNDEF, [T_NULL] = &&L_NULL, [T_NUM] = &&L_NUM,
-    [T_BOOL] = &&L_BOOL, [T_FUNC] = &&L_OBJ, [T_CODEREF] = &&L_DEFAULT,
-    [T_CFUNC] = &&L_DEFAULT, [T_ERR] = &&L_DEFAULT, [T_ARR] = &&L_OBJ,
+    [T_BOOL] = &&L_BOOL, [T_FUNC] = &&L_OBJ, [T_CFUNC] = &&L_DEFAULT, 
+    [T_ERR] = &&L_DEFAULT, [T_ARR] = &&L_OBJ,
     [T_PROMISE] = &&L_DEFAULT, [T_TYPEDARRAY] = &&L_DEFAULT,
-    [T_BIGINT] = &&L_BIGINT, [T_PROPREF] = &&L_DEFAULT,
-    [T_SYMBOL] = &&L_DEFAULT, [T_GENERATOR] = &&L_DEFAULT, [T_FFI] = &&L_DEFAULT
+    [T_BIGINT] = &&L_BIGINT, [T_SYMBOL] = &&L_DEFAULT, 
+    [T_GENERATOR] = &&L_DEFAULT, [T_FFI] = &&L_DEFAULT
   };
   
   if (t < sizeof(jump_table) / sizeof(jump_table[0])) goto *jump_table[t];
@@ -2300,8 +1825,19 @@ jsval_t js_tostring_val(struct js *js, jsval_t value) {
   }
 }
 
-const char *js_str(struct js *js, jsval_t value) {
-  if (is_err(value)) return js->errmsg;
+const char *js_str(ant_t *js, jsval_t value) {
+  if (is_err(value)) {
+    uint64_t data = vdata(value);
+    if (data != 0) {
+      jsval_t obj = mkval(T_OBJ, data);
+      jsval_t stack = js_get(js, obj, "stack");
+      if (vtype(stack) == T_STR) {
+        jsoff_t slen, off = vstr(js, stack, &slen);
+        return (const char *)&js->mem[off];
+      }
+    }
+    return "Error";
+  }
   
   multiref_count = 0;
   multiref_next_id = 0;
@@ -2332,7 +1868,7 @@ const char *js_str(struct js *js, jsval_t value) {
   return (const char *)&js->mem[vdata(str) + sizeof(jsoff_t)];
 }
 
-static bool js_try_grow_memory(struct js *js, size_t needed) {
+static bool js_try_grow_memory(ant_t *js, size_t needed) {
   if (!js->owns_mem) return false;
   if (js->max_size == 0) return false;
   
@@ -2349,11 +1885,11 @@ static bool js_try_grow_memory(struct js *js, size_t needed) {
   return true;
 }
 
-static inline bool js_has_space(struct js *js, size_t size) {
+static inline bool js_has_space(ant_t *js, size_t size) {
   return js->brk + size <= js->size;
 }
 
-static bool js_ensure_space(struct js *js, size_t size) {
+static bool js_ensure_space(ant_t *js, size_t size) {
   if (js_has_space(js, size)) return true;
   if (js_try_grow_memory(js, size) && js_has_space(js, size)) return true;
 
@@ -2365,7 +1901,7 @@ static bool js_ensure_space(struct js *js, size_t size) {
   return false;
 }
 
-static void js_track_allocation(struct js *js, size_t size) {
+static void js_track_allocation(ant_t *js, size_t size) {
   js->brk += (jsoff_t) size;
   js->gc_alloc_since += (jsoff_t) size;
   
@@ -2374,7 +1910,7 @@ static void js_track_allocation(struct js *js, size_t size) {
   if (js->gc_alloc_since > threshold) js->needs_gc = true;
 }
 
-static inline jsoff_t js_alloc(struct js *js, size_t size) {
+static inline jsoff_t js_alloc(ant_t *js, size_t size) {
   size = align64((jsoff_t) size);
   if (!js_ensure_space(js, size)) return ~(jsoff_t) 0;
 
@@ -2384,7 +1920,7 @@ static inline jsoff_t js_alloc(struct js *js, size_t size) {
   return ofs;
 }
 
-static jsoff_t dense_alloc(struct js *js, jsoff_t capacity) {
+static jsoff_t dense_alloc(ant_t *js, jsoff_t capacity) {
   jsoff_t size = sizeof(jsoff_t) * 2 + sizeof(jsval_t) * capacity;
   jsoff_t off = js_alloc(js, size);
   if (off == (jsoff_t)~0) return 0;
@@ -2399,41 +1935,51 @@ static jsoff_t dense_alloc(struct js *js, jsoff_t capacity) {
   return off;
 }
 
-static inline jsoff_t get_dense_buf(struct js *js, jsval_t arr) {
+static inline jsoff_t get_dense_buf(ant_t *js, jsval_t arr) {
+  jsoff_t off = (jsoff_t) vdata(js_as_obj(arr));
+  if (__builtin_expect(off >= js->brk, 0)) return 0;
+  jsoff_t next = loadoff(js, off) & ~(3U | FLAGMASK);
+  if (__builtin_expect(next == 0 || next >= js->brk, 0)) return 0;
+  jsoff_t header = loadoff(js, next);
+  if ((header & SLOTMASK) &&
+      loadoff(js, next + sizeof(jsoff_t)) == (jsoff_t)SLOT_DENSE_BUF) {
+    jsval_t slot = loadval(js, next + sizeof(jsoff_t) * 2);
+    return (jsoff_t) tod(slot);
+  }
   jsval_t slot = get_slot(js, arr, SLOT_DENSE_BUF);
   if (vtype(slot) == T_UNDEF) return 0;
   return (jsoff_t) tod(slot);
 }
 
-static inline jsoff_t get_dense_buf_off(struct js *js, jsoff_t obj_off) {
+static inline jsoff_t get_dense_buf_off(ant_t *js, jsoff_t obj_off) {
   return get_dense_buf(js, mkval(T_ARR, (uint64_t)obj_off));
 }
 
-static inline jsoff_t dense_capacity(struct js *js, jsoff_t doff) {
+static inline jsoff_t dense_capacity(ant_t *js, jsoff_t doff) {
   return loadoff(js, doff);
 }
 
-static inline jsoff_t dense_length(struct js *js, jsoff_t doff) {
+static inline jsoff_t dense_length(ant_t *js, jsoff_t doff) {
   return loadoff(js, doff + sizeof(jsoff_t));
 }
 
-static inline void dense_set_length(struct js *js, jsoff_t doff, jsoff_t len) {
+static inline void dense_set_length(ant_t *js, jsoff_t doff, jsoff_t len) {
   saveoff(js, doff + sizeof(jsoff_t), len);
 }
 
-static inline jsval_t dense_get(struct js *js, jsoff_t doff, jsoff_t idx) {
+static inline jsval_t dense_get(ant_t *js, jsoff_t doff, jsoff_t idx) {
   return loadval(js, doff + sizeof(jsoff_t) * 2 + sizeof(jsval_t) * idx);
 }
 
-static inline void dense_set(struct js *js, jsoff_t doff, jsoff_t idx, jsval_t val) {
+static inline void dense_set(ant_t *js, jsoff_t doff, jsoff_t idx, jsval_t val) {
   saveval(js, doff + sizeof(jsoff_t) * 2 + sizeof(jsval_t) * idx, val);
 }
 
-static jsoff_t dense_grow(struct js *js, jsval_t arr, jsoff_t needed) {
+static jsoff_t dense_grow(ant_t *js, jsval_t arr, jsoff_t needed) {
   jsoff_t doff = get_dense_buf(js, arr);
   jsoff_t old_cap = doff ? dense_capacity(js, doff) : 0;
   jsoff_t old_len = doff ? dense_length(js, doff) : 0;
-  jsoff_t new_cap = old_cap ? old_cap : JS_DENSE_INITIAL_CAP;
+  jsoff_t new_cap = old_cap ? old_cap : MAX_DENSE_INITIAL_CAP;
   
   while (new_cap < needed) new_cap *= 2;
   jsoff_t new_doff = dense_alloc(js, new_cap);
@@ -2451,7 +1997,7 @@ static jsoff_t dense_grow(struct js *js, jsval_t arr, jsoff_t needed) {
   return new_doff;
 }
 
-static inline jsval_t arr_get(struct js *js, jsval_t arr, jsoff_t idx) {
+static inline jsval_t arr_get(ant_t *js, jsval_t arr, jsoff_t idx) {
   jsoff_t doff = get_dense_buf(js, arr);
   
   if (doff) {
@@ -2470,7 +2016,7 @@ static inline jsval_t arr_get(struct js *js, jsval_t arr, jsoff_t idx) {
   return prop ? resolveprop(js, mkval(T_PROP, prop)) : js_mkundef();
 }
 
-static inline void arr_set(struct js *js, jsval_t arr, jsoff_t idx, jsval_t val) {
+static inline void arr_set(ant_t *js, jsval_t arr, jsoff_t idx, jsval_t val) {
   jsoff_t doff = get_dense_buf(js, arr);
   
   if (doff) {
@@ -2507,7 +2053,7 @@ static inline void arr_set(struct js *js, jsval_t arr, jsoff_t idx, jsval_t val)
   js_setprop(js, arr, key, val);
 }
 
-static inline bool arr_has(struct js *js, jsval_t arr, jsoff_t idx) {
+static inline bool arr_has(ant_t *js, jsval_t arr, jsoff_t idx) {
   jsoff_t doff = get_dense_buf(js, arr);
   
   if (doff) {
@@ -2520,7 +2066,7 @@ static inline bool arr_has(struct js *js, jsval_t arr, jsoff_t idx) {
   return lkp(js, arr, idxstr, idxlen) != 0;
 }
 
-static inline void arr_del(struct js *js, jsval_t arr, jsoff_t idx) {
+static inline void arr_del(ant_t *js, jsval_t arr, jsoff_t idx) {
   jsoff_t doff = get_dense_buf(js, arr);
   
   if (doff) {
@@ -2534,13 +2080,7 @@ static inline void arr_del(struct js *js, jsval_t arr, jsoff_t idx) {
   js_del(js, arr, idxstr);
 }
 
-static inline jsoff_t dense_arr_length(struct js *js, jsval_t arr) {
-  jsoff_t doff = get_dense_buf(js, arr);
-  if (doff) return dense_length(js, doff);
-  return 0;
-}
-
-static jsval_t mkentity(struct js *js, jsoff_t b, const void *buf, size_t len) {
+static jsval_t mkentity(ant_t *js, jsoff_t b, const void *buf, size_t len) {
   jsoff_t ofs = js_alloc(js, len + sizeof(b));
   if (ofs == (jsoff_t) ~0) return js_mkerr(js, "oom");
   
@@ -2554,12 +2094,12 @@ static jsval_t mkentity(struct js *js, jsoff_t b, const void *buf, size_t len) {
   return mkval(b & 3, ofs);
 }
 
-jsval_t js_mkstr(struct js *js, const void *ptr, size_t len) {
+jsval_t js_mkstr(ant_t *js, const void *ptr, size_t len) {
   jsoff_t n = (jsoff_t) (len + 1);
   return mkentity(js, (jsoff_t) ((n << 3) | T_STR), ptr, n);
 }
 
-static jsval_t js_mkrope(struct js *js, jsval_t left, jsval_t right, jsoff_t total_len, uint8_t depth) {
+static jsval_t js_mkrope(ant_t *js, jsval_t left, jsval_t right, jsoff_t total_len, uint8_t depth) {
   jsoff_t ofs = js_alloc(js, sizeof(rope_node_t));
   if (ofs == (jsoff_t) ~0) return js_mkerr(js, "oom");
   
@@ -2574,7 +2114,7 @@ static jsval_t js_mkrope(struct js *js, jsval_t left, jsval_t right, jsoff_t tot
   return mkval(T_STR, ofs);
 }
 
-static bool bigint_parse_abs_u64(struct js *js, jsval_t value, uint64_t *out) {
+static bool bigint_parse_abs_u64(ant_t *js, jsval_t value, uint64_t *out) {
   size_t len = 0; const char *digits = bigint_digits(js, value, &len);
   uint64_t acc = 0;
 
@@ -2591,17 +2131,17 @@ static bool bigint_parse_abs_u64(struct js *js, jsval_t value, uint64_t *out) {
   return true;
 }
 
-static bool bigint_IsNegative(struct js *js, jsval_t v) {
+static bool bigint_IsNegative(ant_t *js, jsval_t v) {
   jsoff_t ofs = (jsoff_t) vdata(v);
   return js->mem[ofs + sizeof(jsoff_t)] == 1;
 }
 
-static bool bigint_parse_u64(struct js *js, jsval_t value, uint64_t *out) {
+static bool bigint_parse_u64(ant_t *js, jsval_t value, uint64_t *out) {
   if (bigint_IsNegative(js, value)) return false;
   return bigint_parse_abs_u64(js, value, out);
 }
 
-jsval_t js_mkbigint(struct js *js, const char *digits, size_t len, bool negative) {
+jsval_t js_mkbigint(ant_t *js, const char *digits, size_t len, bool negative) {
   size_t total = len + 2;
   jsoff_t ofs = js_alloc(js, total + sizeof(jsoff_t));
   if (ofs == (jsoff_t) ~0) return js_mkerr(js, "oom");
@@ -2613,7 +2153,7 @@ jsval_t js_mkbigint(struct js *js, const char *digits, size_t len, bool negative
   return mkval(T_BIGINT, ofs);
 }
 
-static const char *bigint_digits(struct js *js, jsval_t v, size_t *len) {
+static const char *bigint_digits(ant_t *js, jsval_t v, size_t *len) {
   jsoff_t ofs = (jsoff_t) vdata(v);
   jsoff_t header = loadoff(js, ofs);
   size_t total = (header >> 4) - 2;
@@ -2730,7 +2270,7 @@ static char *bigint_div_abs(const char *a, size_t alen, const char *b, size_t bl
   return result;
 }
 
-static jsval_t bigint_add(struct js *js, jsval_t a, jsval_t b) {
+jsval_t bigint_add(ant_t *js, jsval_t a, jsval_t b) {
   bool aneg = bigint_IsNegative(js, a), bneg = bigint_IsNegative(js, b);
   size_t alen, blen;
   const char *ad = bigint_digits(js, a, &alen), *bd = bigint_digits(js, b, &blen);
@@ -2749,7 +2289,7 @@ static jsval_t bigint_add(struct js *js, jsval_t a, jsval_t b) {
   return r;
 }
 
-static jsval_t bigint_sub(struct js *js, jsval_t a, jsval_t b) {
+jsval_t bigint_sub(ant_t *js, jsval_t a, jsval_t b) {
   bool aneg = bigint_IsNegative(js, a), bneg = bigint_IsNegative(js, b);
   size_t alen, blen;
   const char *ad = bigint_digits(js, a, &alen), *bd = bigint_digits(js, b, &blen);
@@ -2768,7 +2308,7 @@ static jsval_t bigint_sub(struct js *js, jsval_t a, jsval_t b) {
   return r;
 }
 
-static jsval_t bigint_mul(struct js *js, jsval_t a, jsval_t b) {
+jsval_t bigint_mul(ant_t *js, jsval_t a, jsval_t b) {
   bool aneg = bigint_IsNegative(js, a), bneg = bigint_IsNegative(js, b);
   size_t alen, blen;
   const char *ad = bigint_digits(js, a, &alen), *bd = bigint_digits(js, b, &blen);
@@ -2781,7 +2321,7 @@ static jsval_t bigint_mul(struct js *js, jsval_t a, jsval_t b) {
   return r;
 }
 
-static jsval_t bigint_div(struct js *js, jsval_t a, jsval_t b) {
+jsval_t bigint_div(ant_t *js, jsval_t a, jsval_t b) {
   bool aneg = bigint_IsNegative(js, a), bneg = bigint_IsNegative(js, b);
   size_t alen, blen;
   const char *ad = bigint_digits(js, a, &alen), *bd = bigint_digits(js, b, &blen);
@@ -2795,7 +2335,7 @@ static jsval_t bigint_div(struct js *js, jsval_t a, jsval_t b) {
   return r;
 }
 
-static jsval_t bigint_mod(struct js *js, jsval_t a, jsval_t b) {
+jsval_t bigint_mod(ant_t *js, jsval_t a, jsval_t b) {
   bool aneg = bigint_IsNegative(js, a);
   size_t alen, blen;
   const char *ad = bigint_digits(js, a, &alen), *bd = bigint_digits(js, b, &blen);
@@ -2810,7 +2350,7 @@ static jsval_t bigint_mod(struct js *js, jsval_t a, jsval_t b) {
   return r;
 }
 
-static jsval_t bigint_neg(struct js *js, jsval_t a) {
+jsval_t bigint_neg(ant_t *js, jsval_t a) {
   size_t len;
   const char *digits = bigint_digits(js, a, &len);
   bool neg = bigint_IsNegative(js, a);
@@ -2818,7 +2358,7 @@ static jsval_t bigint_neg(struct js *js, jsval_t a) {
   return js_mkbigint(js, digits, len, !neg);
 }
 
-static jsval_t bigint_exp(struct js *js, jsval_t base, jsval_t exp) {
+jsval_t bigint_exp(ant_t *js, jsval_t base, jsval_t exp) {
   if (bigint_IsNegative(js, exp)) return js_mkerr(js, "Exponent must be positive");
   size_t explen;
   const char *expd = bigint_digits(js, exp, &explen);
@@ -2844,7 +2384,7 @@ static jsval_t bigint_exp(struct js *js, jsval_t base, jsval_t exp) {
   return result;
 }
 
-static inline jsval_t bigint_pow2(struct js *js, uint64_t bits) {
+static inline jsval_t bigint_pow2(ant_t *js, uint64_t bits) {
   jsval_t two = js_mkbigint(js, "2", 1, false);
   if (is_err(two)) return two;
   jsval_t exp = bigint_from_u64(js, bits);
@@ -2852,7 +2392,7 @@ static inline jsval_t bigint_pow2(struct js *js, uint64_t bits) {
   return bigint_exp(js, two, exp);
 }
 
-static jsval_t bigint_shift_left(struct js *js, jsval_t value, uint64_t shift) {
+jsval_t bigint_shift_left(ant_t *js, jsval_t value, uint64_t shift) {
   if (shift == 0) return value;
   if (shift > 18446744073709551615ULL) return js_mkerr(js, "Shift count too large");
 
@@ -2868,7 +2408,7 @@ static jsval_t bigint_shift_left(struct js *js, jsval_t value, uint64_t shift) {
   return bigint_mul(js, value, pow);
 }
 
-static jsval_t bigint_shift_right(struct js *js, jsval_t value, uint64_t shift) {
+jsval_t bigint_shift_right(ant_t *js, jsval_t value, uint64_t shift) {
   if (shift == 0) return value;
   if (shift > 18446744073709551615ULL) return js_mkerr(js, "Shift count too large");
 
@@ -2900,11 +2440,11 @@ static jsval_t bigint_shift_right(struct js *js, jsval_t value, uint64_t shift)
   return bigint_div(js, value, pow);
 }
 
-static inline jsval_t bigint_shift_right_logical(struct js *js, jsval_t value, uint64_t shift) {
+jsval_t bigint_shift_right_logical(ant_t *js, jsval_t value, uint64_t shift) {
   return js_mkerr_typed(js, JS_ERR_TYPE, "BigInts have no unsigned right shift, use >> instead");
 }
 
-static int bigint_compare(struct js *js, jsval_t a, jsval_t b) {
+int bigint_compare(ant_t *js, jsval_t a, jsval_t b) {
   bool aneg = bigint_IsNegative(js, a), bneg = bigint_IsNegative(js, b);
   size_t alen, blen;
   const char *ad = bigint_digits(js, a, &alen), *bd = bigint_digits(js, b, &blen);
@@ -2914,13 +2454,13 @@ static int bigint_compare(struct js *js, jsval_t a, jsval_t b) {
   return aneg ? -cmp : cmp;
 }
 
-static bool bigint_is_zero(struct js *js, jsval_t v) {
+static bool bigint_is_zero(ant_t *js, jsval_t v) {
   size_t len;
   const char *digits = bigint_digits(js, v, &len);
   return len == 1 && digits[0] == '0';
 }
 
-static size_t strbigint(struct js *js, jsval_t value, char *buf, size_t len) {
+static size_t strbigint(ant_t *js, jsval_t value, char *buf, size_t len) {
   bool neg = bigint_IsNegative(js, value);
   size_t dlen;
   const char *digits = bigint_digits(js, value, &dlen);
@@ -2930,7 +2470,7 @@ static size_t strbigint(struct js *js, jsval_t value, char *buf, size_t len) {
   return n;
 }
 
-static jsval_t builtin_BigInt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_BigInt(ant_t *js, jsval_t *args, int nargs) {
   if (vtype(js->new_target) != T_UNDEF) return js_mkerr_typed(js, JS_ERR_TYPE, "BigInt is not a constructor");
   if (nargs < 1) return js_mkbigint(js, "0", 1, false);
   
@@ -2966,14 +2506,14 @@ static jsval_t builtin_BigInt(struct js *js, jsval_t *args, int nargs) {
   return js_mkerr(js, "Cannot convert to BigInt");
 }
 
-static jsval_t bigint_to_u64(struct js *js, jsval_t value, uint64_t *out) {
+static jsval_t bigint_to_u64(ant_t *js, jsval_t value, uint64_t *out) {
   if (!bigint_parse_u64(js, value, out)) {
     return js_mkerr_typed(js, JS_ERR_RANGE, "Invalid bits");
   }
   return js_mkundef();
 }
 
-static jsval_t bigint_asint_bits(struct js *js, jsval_t arg, uint64_t *bits_out) {
+jsval_t bigint_asint_bits(ant_t *js, jsval_t arg, uint64_t *bits_out) {
   if (vtype(arg) == T_BIGINT) {
     return bigint_to_u64(js, arg, bits_out);
   }
@@ -2988,7 +2528,7 @@ static jsval_t bigint_asint_bits(struct js *js, jsval_t arg, uint64_t *bits_out)
   return js_mkundef();
 }
 
-static jsval_t builtin_BigInt_asIntN(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_BigInt_asIntN(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "BigInt.asIntN requires 2 arguments");
   uint64_t bits = 0;
   jsval_t err = bigint_asint_bits(js, args[0], &bits);
@@ -3018,7 +2558,7 @@ static jsval_t builtin_BigInt_asIntN(struct js *js, jsval_t *args, int nargs) {
   return res;
 }
 
-static jsval_t builtin_BigInt_asUintN(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_BigInt_asUintN(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "BigInt.asUintN requires 2 arguments");
   uint64_t bits = 0;
   jsval_t err = bigint_asint_bits(js, args[0], &bits);
@@ -3040,7 +2580,7 @@ static jsval_t builtin_BigInt_asUintN(struct js *js, jsval_t *args, int nargs) {
   return res;
 }
 
-static jsval_t builtin_bigint_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_bigint_toString(ant_t *js, jsval_t *args, int nargs) {
   jsval_t val = js->this_val;
   if (vtype(val) != T_BIGINT) return js_mkerr(js, "toString called on non-BigInt");
   
@@ -3131,12 +2671,12 @@ static jsval_t builtin_bigint_toString(struct js *js, jsval_t *args, int nargs)
   free(result); return ret;
 }
 
-static jsval_t mkobj(struct js *js, jsoff_t parent) {
+jsval_t mkobj(ant_t *js, jsoff_t parent) {
   jsoff_t buf[2] = { parent, 0 };
   return mkentity(js, 0 | T_OBJ, buf, sizeof(buf));
 }
 
-jsval_t mkarr(struct js *js) {
+jsval_t mkarr(ant_t *js) {
   jsval_t arr = mkobj(js, 0);
   jsoff_t off = (jsoff_t) vdata(arr);
   jsoff_t header = loadoff(js, off);
@@ -3146,65 +2686,39 @@ jsval_t mkarr(struct js *js) {
   if (vtype(array_proto) == T_OBJ) set_proto(js, arr, array_proto);
   
   jsval_t arr_val = mkval(T_ARR, vdata(arr));
-  jsoff_t doff = dense_alloc(js, JS_DENSE_INITIAL_CAP);
+  jsoff_t doff = dense_alloc(js, MAX_DENSE_INITIAL_CAP);
   if (doff) set_slot(js, arr_val, SLOT_DENSE_BUF, tov((double)doff));
   
   return arr_val;
 }
 
-jsval_t js_mkarr(struct js *js) { 
+jsval_t js_mkarr(ant_t *js) { 
   return mkarr(js); 
 }
 
-jsval_t js_newobj(struct js *js) {
+jsval_t js_newobj(ant_t *js) {
   jsval_t obj = mkobj(js, 0);
   jsval_t proto = get_ctor_proto(js, "Object", 6);
   if (vtype(proto) == T_OBJ) set_proto(js, obj, proto);
   return obj;
 }
 
-jsoff_t js_arr_len(struct js *js, jsval_t arr) {
+jsoff_t js_arr_len(ant_t *js, jsval_t arr) {
   if (vtype(arr) != T_ARR) return 0;
-  jsoff_t doff = get_dense_buf(js, arr);
-  if (doff) return dense_length(js, doff);
-  
-  jsoff_t max_idx = 0;
-  bool found_length_prop = false;
-  jsoff_t length_prop_val = 0;
-  
-  jsoff_t scan = loadoff(js, (jsoff_t) vdata(arr)) & ~(3U | FLAGMASK);
-  while (scan < js->brk && scan != 0) {
-    const char *key; jsoff_t klen;
-    get_prop_key(js, scan, &key, &klen);
-    if (streq(key, klen, "length", 6)) {
-      jsval_t val = get_prop_val(js, scan);
-      if (vtype(val) == T_NUM) {
-        found_length_prop = true;
-        length_prop_val = (jsoff_t) tod(val);
-      }
-    } else if (klen > 0 && key[0] >= '0' && key[0] <= '9') {
-      char *endptr;
-      unsigned long idx = strtoul(key, &endptr, 10);
-      if (endptr == key + klen && idx + 1 > max_idx) max_idx = (jsoff_t)(idx + 1);
-    }
-    scan = loadoff(js, scan) & ~(3U | FLAGMASK);
-  }
-  
-  if (found_length_prop) return length_prop_val;
-  return max_idx;
+  return get_array_length(js, arr);
 }
 
-jsval_t js_arr_get(struct js *js, jsval_t arr, jsoff_t idx) {
+jsval_t js_arr_get(ant_t *js, jsval_t arr, jsoff_t idx) {
   if (vtype(arr) != T_ARR) return js_mkundef();
   return arr_get(js, arr, idx);
 }
 
-static inline bool is_const_prop(struct js *js, jsoff_t propoff) {
+static inline bool is_const_prop(ant_t *js, jsoff_t propoff) {
   jsoff_t v = loadoff(js, propoff);
   return (v & CONSTMASK) != 0;
 }
 
-static inline bool is_nonconfig_prop(struct js *js, jsoff_t propoff) {
+static inline bool is_nonconfig_prop(ant_t *js, jsoff_t propoff) {
   jsoff_t v = loadoff(js, propoff);
   return (v & NONCONFIGMASK) != 0;
 }
@@ -3234,7 +2748,7 @@ static void intern_init(void) {
   INTERN_IDX[9] = intern_string("9", 1);
 }
 
-static void invalidate_prop_cache(struct js *js, jsoff_t obj_off, jsoff_t prop_off) {
+static void invalidate_prop_cache(ant_t *js, jsoff_t obj_off, jsoff_t prop_off) {
   jsoff_t koff = loadoff(js, prop_off + sizeof(jsoff_t));
   jsoff_t klen = (loadoff(js, koff) >> 3) - 1;
   
@@ -3247,9 +2761,19 @@ static void invalidate_prop_cache(struct js *js, jsoff_t obj_off, jsoff_t prop_o
   if (ce->obj_off == obj_off && ce->intern_ptr == interned) ce->generation = 0;
 }
 
-static jsval_t mkprop(struct js *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t flags) {
-  jsoff_t klen; jsoff_t koff = vstr(js, k, &klen);
-  jsoff_t koff_entity = koff - sizeof(jsoff_t);
+jsval_t mkprop(ant_t *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t flags) {
+  obj = js_as_obj(obj);
+  jsoff_t koff_entity;
+  
+  if (vtype(k) == T_SYMBOL) {
+    koff_entity = (jsoff_t)vdata(k);
+  } else {
+    jsoff_t klen; jsoff_t koff = vstr(js, k, &klen);
+    koff_entity = koff - sizeof(jsoff_t);
+    const char *p = (char *) &js->mem[koff];
+    (void)intern_string(p, klen);
+  }
+  
   jsoff_t head = (jsoff_t) vdata(obj);
   char buf[sizeof(koff_entity) + sizeof(v)];
   
@@ -3260,9 +2784,6 @@ static jsval_t mkprop(struct js *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t
   memcpy(buf, &koff_entity, sizeof(koff_entity));
   memcpy(buf + sizeof(koff_entity), &v, sizeof(v));
   
-  const char *p = (char *) &js->mem[koff];
-  (void)intern_string(p, klen);
-  
   jsoff_t new_prop_off = js->brk;
   jsval_t prop = mkentity(js, 0 | T_PROP | flags, buf, sizeof(buf));
   if (is_err(prop)) return prop;
@@ -3280,9 +2801,15 @@ static jsval_t mkprop(struct js *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t
   return prop;
 }
 
-static inline jsval_t mkprop_fast(struct js *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t flags) {
-  jsoff_t klen; jsoff_t koff = vstr(js, k, &klen);
-  jsoff_t koff_entity = koff - sizeof(jsoff_t);
+static inline jsval_t mkprop_fast(ant_t *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t flags) {
+  obj = js_as_obj(obj);
+  jsoff_t koff_entity;
+  if (vtype(k) == T_SYMBOL) {
+    koff_entity = (jsoff_t)vdata(k);
+  } else {
+    jsoff_t klen; jsoff_t koff = vstr(js, k, &klen);
+    koff_entity = koff - sizeof(jsoff_t);
+  }
   jsoff_t head = (jsoff_t) vdata(obj);
   char buf[sizeof(koff_entity) + sizeof(v)];
   
@@ -3310,13 +2837,13 @@ static inline jsval_t mkprop_fast(struct js *js, jsval_t obj, jsval_t k, jsval_t
   return prop;
 }
 
-jsval_t js_mkprop_fast(struct js *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
+jsval_t js_mkprop_fast(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
   jsval_t k = js_mkstr(js, key, len);
   if (is_err(k)) return k;
   return mkprop_fast(js, obj, k, v, 0);
 }
 
-jsoff_t js_mkprop_fast_off(struct js *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
+jsoff_t js_mkprop_fast_off(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
   jsval_t k = js_mkstr(js, key, len);
   if (is_err(k)) return 0;
   jsoff_t prop_off = js->brk;
@@ -3324,9 +2851,10 @@ jsoff_t js_mkprop_fast_off(struct js *js, jsval_t obj, const char *key, size_t l
   return prop_off + sizeof(jsoff_t) * 2;
 }
 
-void js_saveval(struct js *js, jsoff_t off, jsval_t v) { saveval(js, off, v); }
+void js_saveval(ant_t *js, jsoff_t off, jsval_t v) { saveval(js, off, v); }
 
-static jsval_t mkslot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t v) {
+static jsval_t mkslot(ant_t *js, jsval_t obj, internal_slot_t slot, jsval_t v) {
+  obj = js_as_obj(obj);
   jsoff_t head = (jsoff_t) vdata(obj);
   char buf[sizeof(jsoff_t) + sizeof(v)];
   
@@ -3351,46 +2879,44 @@ static jsval_t mkslot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t
   return prop;
 }
 
-static inline jsoff_t search_slot(struct js *js, jsval_t obj, internal_slot_t slot) {
+static inline jsoff_t search_slot(ant_t *js, jsval_t obj, internal_slot_t slot) {
+  obj = js_as_obj(obj);
   jsoff_t off = (jsoff_t) vdata(obj);
   if (__builtin_expect(off >= js->brk, 0)) return 0;
   jsoff_t next = loadoff(js, off) & ~(3U | FLAGMASK);
-  jsoff_t header, koff;
-
-check:
-  if (__builtin_expect(next == 0 || next >= js->brk, 0)) return 0;
-  header = loadoff(js, next);
-  if ((header & SLOTMASK) == 0) return 0;
-  koff = loadoff(js, next + sizeof(jsoff_t));
-  if (koff == (jsoff_t)slot) return next;
-  next = header & ~(3U | FLAGMASK);
-  goto check;
+  while (next != 0 && next < js->brk) {
+    jsoff_t header = loadoff(js, next);
+    if ((header & SLOTMASK) == 0) return 0;
+    jsoff_t koff = loadoff(js, next + sizeof(jsoff_t));
+    if (koff == (jsoff_t)slot) return next;
+    next = header & ~(3U | FLAGMASK);
+  }
+  return 0;
 }
 
-static void set_slot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t val) {
+static void set_slot(ant_t *js, jsval_t obj, internal_slot_t slot, jsval_t val) {
   jsoff_t existing = search_slot(js, obj, slot);
   if (existing > 0) {
     saveval(js, existing + sizeof(jsoff_t) * 2, val);
   } else mkslot(js, obj, slot, val);
 }
 
-static jsval_t get_slot(struct js *js, jsval_t obj, internal_slot_t slot) {
+static jsval_t get_slot(ant_t *js, jsval_t obj, internal_slot_t slot) {
   jsoff_t off = search_slot(js, obj, slot);
   if (off == 0) return js_mkundef();
   return loadval(js, off + sizeof(jsoff_t) * 2);
 }
 
-static void set_func_code_ptr(struct js *js, jsval_t func_obj, const char *code, size_t len) {
+static void set_func_code_ptr(ant_t *js, jsval_t func_obj, const char *code, size_t len) {
   set_slot(js, func_obj, SLOT_CODE, mkval(T_CFUNC, (size_t)code));
   set_slot(js, func_obj, SLOT_CODE_LEN, tov((double)len));
 }
 
-static void set_func_code(struct js *js, jsval_t func_obj, const char *code, size_t len) {
+static void set_func_code(ant_t *js, jsval_t func_obj, const char *code, size_t len) {
   const char *arena_code = code_arena_alloc(code, len);
   if (!arena_code) return;
   set_func_code_ptr(js, func_obj, arena_code, len);
   
-  if (!code_has_function_decl(code, len)) set_slot(js, func_obj, SLOT_NO_FUNC_DECLS, js_true);
   if (!memmem(code, len, "var", 3)) return;
   
   size_t vars_buf_len;
@@ -3402,7 +2928,7 @@ static void set_func_code(struct js *js, jsval_t func_obj, const char *code, siz
   }
 }
 
-static const char *get_func_code(struct js *js, jsval_t func_obj, jsoff_t *len) {
+static const char *get_func_code(ant_t *js, jsval_t func_obj, jsoff_t *len) {
   jsval_t code_val = get_slot(js, func_obj, SLOT_CODE);
   jsval_t len_val = get_slot(js, func_obj, SLOT_CODE_LEN);
   
@@ -3423,7 +2949,7 @@ static inline jsoff_t next_prop(jsoff_t header) {
   return header & ~(3U | FLAGMASK);
 }
 
-static double js_to_number(struct js *js, jsval_t arg) {
+double js_to_number(ant_t *js, jsval_t arg) {
   if (vtype(arg) == T_NUM) return tod(arg);
   if (vtype(arg) == T_BOOL) return vdata(arg) ? 1.0 : 0.0;
   if (vtype(arg) == T_NULL) return 0.0;
@@ -3454,7 +2980,7 @@ static double js_to_number(struct js *js, jsval_t arg) {
   return JS_NAN;
 }
 
-static jsval_t setup_func_prototype(struct js *js, jsval_t func) {
+static jsval_t setup_func_prototype(ant_t *js, jsval_t func) {
   jsval_t proto_obj = mkobj(js, 0);
   if (is_err(proto_obj)) return proto_obj;
   
@@ -3480,7 +3006,7 @@ static jsval_t setup_func_prototype(struct js *js, jsval_t func) {
   return js_mkundef();
 }
 
-static inline bool proto_walk_next(struct js *js, jsval_t *cur, uint8_t *t, uint8_t flags) {
+static inline bool proto_walk_next(ant_t *js, jsval_t *cur, uint8_t *t, uint8_t flags) {
   uint8_t ct = *t;
 
   if (flags & PROTO_WALK_F_OBJECT_ONLY) {
@@ -3493,7 +3019,7 @@ static inline bool proto_walk_next(struct js *js, jsval_t *cur, uint8_t *t, uint
   }
 
   if (ct == T_OBJ || ct == T_ARR || ct == T_FUNC || ct == T_PROMISE) {
-    jsval_t as_obj = mkval(T_OBJ, vdata(*cur));
+    jsval_t as_obj = js_as_obj(*cur);
     jsval_t proto = get_slot(js, as_obj, SLOT_PROTO);
     
     uint8_t pt = vtype(proto);
@@ -3503,7 +3029,7 @@ static inline bool proto_walk_next(struct js *js, jsval_t *cur, uint8_t *t, uint
       return true;
     }
     
-    if (TYPE_FLAG(ct) & T_NEEDS_PROTO_FALLBACK) {
+    if (JS_TYPE_FLAG(ct) & T_NEEDS_PROTO_FALLBACK) {
       jsval_t fallback = get_prototype_for_type(js, ct);
       uint8_t ft = vtype(fallback);
       if (ft == T_NULL || ft == T_UNDEF) return false;
@@ -3515,7 +3041,7 @@ static inline bool proto_walk_next(struct js *js, jsval_t *cur, uint8_t *t, uint
     return false;
   }
 
-  if (ct == T_STR || ct == T_NUM || ct == T_BOOL || ct == T_BIGINT) {
+  if (ct == T_STR || ct == T_NUM || ct == T_BOOL || ct == T_BIGINT || ct == T_SYMBOL) {
     jsval_t proto = get_prototype_for_type(js, ct);
     uint8_t pt = vtype(proto);
     if (pt == T_NULL || pt == T_UNDEF) return false;
@@ -3526,11 +3052,11 @@ static inline bool proto_walk_next(struct js *js, jsval_t *cur, uint8_t *t, uint
   return false;
 }
 
-jsval_t js_instance_proto_from_new_target(struct js *js, jsval_t fallback_proto) {
+jsval_t js_instance_proto_from_new_target(ant_t *js, jsval_t fallback_proto) {
   jsval_t instance_proto = js_mkundef();
   
   if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    jsval_t nt_obj = mkval(T_OBJ, vdata(js->new_target));
+    jsval_t nt_obj = js_as_obj(js->new_target);
     jsoff_t nt_proto_off = lkp_interned(js, nt_obj, INTERN_PROTOTYPE, 9);
     if (nt_proto_off != 0) {
       jsval_t nt_proto = resolveprop(js, mkval(T_PROP, nt_proto_off));
@@ -3543,7 +3069,7 @@ jsval_t js_instance_proto_from_new_target(struct js *js, jsval_t fallback_proto)
   } return instance_proto;
 }
 
-static inline bool proto_chain_contains(struct js *js, jsval_t obj, jsval_t proto_target) {
+bool proto_chain_contains(ant_t *js, jsval_t obj, jsval_t proto_target) {
   if (!is_object_type(obj) || !is_object_type(proto_target)) return false;
   jsval_t cur = obj; uint8_t t = vtype(cur);
   for (int depth = 0; depth < MAX_PROTO_CHAIN_DEPTH; depth++) {
@@ -3553,21 +3079,19 @@ static inline bool proto_chain_contains(struct js *js, jsval_t obj, jsval_t prot
   return false;
 }
 
-static inline bool is_wrapper_ctor_target(struct js *js, jsval_t this_val, jsval_t expected_proto) {
+static inline bool is_wrapper_ctor_target(ant_t *js, jsval_t this_val, jsval_t expected_proto) {
   if (vtype(js->new_target) == T_UNDEF) return false;
   if (vtype(this_val) != T_OBJ) return false;
   if (vtype(get_slot(js, this_val, SLOT_PRIMITIVE)) != T_UNDEF) return false;
   return proto_chain_contains(js, this_val, expected_proto);
 }
 
-static jsval_t get_ctor_species_value(struct js *js, jsval_t ctor) {
-  const char *species_key = get_species_sym_key();
-  if (!species_key || !species_key[0]) return js_mkundef();
+jsval_t get_ctor_species_value(ant_t *js, jsval_t ctor) {
   if (!is_object_type(ctor) && vtype(ctor) != T_CFUNC) return js_mkundef();
-  return js_get(js, ctor, species_key);
+  return js_get_sym(js, ctor, get_species_sym());
 }
 
-static inline bool same_ctor_identity(struct js *js, jsval_t a, jsval_t b) {
+bool same_ctor_identity(ant_t *js, jsval_t a, jsval_t b) {
   if (vtype(a) == vtype(b) && vdata(a) == vdata(b)) return true;
   
   if (vtype(a) == T_FUNC && vtype(b) == T_CFUNC) {
@@ -3589,7 +3113,7 @@ static inline bool same_ctor_identity(struct js *js, jsval_t a, jsval_t b) {
   return false;
 }
 
-static jsval_t array_constructor_from_receiver(struct js *js, jsval_t receiver) {
+static jsval_t array_constructor_from_receiver(ant_t *js, jsval_t receiver) {
   if (!is_object_type(receiver)) return js_mkundef();
   
   jsval_t species_source = receiver;
@@ -3619,7 +3143,7 @@ static jsval_t array_constructor_from_receiver(struct js *js, jsval_t receiver)
   return ctor;
 }
 
-static jsval_t array_alloc_from_ctor_with_length(struct js *js, jsval_t ctor, jsoff_t length_hint) {
+static jsval_t array_alloc_from_ctor_with_length(ant_t *js, jsval_t ctor, jsoff_t length_hint) {
   if (vtype(ctor) != T_FUNC && vtype(ctor) != T_CFUNC) {
     return mkarr(js);
   }
@@ -3634,34 +3158,26 @@ static jsval_t array_alloc_from_ctor_with_length(struct js *js, jsval_t ctor, js
   jsval_t ctor_args[1] = { tov((double)length_hint) };
   jsval_t saved_new_target = js->new_target;
   js->new_target = ctor;
-  jsval_t constructed = js_call_with_this(js, ctor, seed, ctor_args, 1);
+  jsval_t constructed = sv_vm_call(js->vm, js, ctor, seed, ctor_args, 1, NULL, true);
   js->new_target = saved_new_target;
   if (is_err(constructed)) return constructed;
 
   jsval_t result = is_object_type(constructed) ? constructed : seed;
-  set_slot(js, mkval(T_OBJ, vdata(result)), SLOT_CTOR, ctor);
+  set_slot(js, js_as_obj(result), SLOT_CTOR, ctor);
   return result;
 }
 
-static inline jsval_t array_alloc_from_ctor(struct js *js, jsval_t ctor) {
+static inline jsval_t array_alloc_from_ctor(ant_t *js, jsval_t ctor) {
   return array_alloc_from_ctor_with_length(js, ctor, 0);
 }
 
-static inline jsval_t array_alloc_like(struct js *js, jsval_t receiver) {
+static inline jsval_t array_alloc_like(ant_t *js, jsval_t receiver) {
   jsval_t ctor = array_constructor_from_receiver(js, receiver);
   if (is_err(ctor)) return ctor;
   return array_alloc_from_ctor(js, ctor);
 }
 
-static void infer_func_name(struct js *js, jsval_t func, const char *name, size_t len) {
-  jsval_t func_obj = mkval(T_OBJ, vdata(func));
-  if (vtype(get_slot(js, func_obj, SLOT_NAME)) != T_UNDEF) return;
-  jsval_t name_val = js_mkstr(js, name, len);
-  set_slot(js, func_obj, SLOT_NAME, name_val);
-  js_setprop(js, func_obj, js_mkstr(js, "name", 4), name_val);
-}
-
-static jsval_t validate_array_length(struct js *js, jsval_t v) {
+static jsval_t validate_array_length(ant_t *js, jsval_t v) {
   if (vtype(v) != T_NUM) {
     return js_mkerr_typed(js, JS_ERR_RANGE, "Invalid array length");
   }
@@ -3672,7 +3188,8 @@ static jsval_t validate_array_length(struct js *js, jsval_t v) {
   return js_mkundef();
 }
 
-static inline jsval_t check_object_extensibility(struct js *js, jsval_t obj) {
+static inline jsval_t check_object_extensibility(ant_t *js, jsval_t obj) {
+  obj = js_as_obj(obj);
   jsoff_t obj_off_fp = (jsoff_t)vdata(obj);
   jsoff_t next = loadoff(js, obj_off_fp) & ~(3U | FLAGMASK);
   
@@ -3684,19 +3201,19 @@ static inline jsval_t check_object_extensibility(struct js *js, jsval_t obj) {
     jsval_t sv = loadval(js, next + sizeof(jsoff_t) * 2);
     
     if (sk == (jsoff_t)SLOT_FROZEN && js_truthy(js, sv)) {
-      return (js->flags & F_STRICT) 
+      return sv_vm_is_strict(js->vm)
         ? js_mkerr(js, "cannot add property to frozen object")
         : js_mkundef();
     }
     
     if (sk == (jsoff_t)SLOT_SEALED && js_truthy(js, sv)) {
-      return (js->flags & F_STRICT)
+      return sv_vm_is_strict(js->vm)
         ? js_mkerr(js, "cannot add property to sealed object")
         : js_mkundef();
     }
     
     if (sk == (jsoff_t)SLOT_EXTENSIBLE && !js_truthy(js, sv)) {
-      return (js->flags & F_STRICT)
+      return sv_vm_is_strict(js->vm)
         ? js_mkerr(js, "cannot add property to non-extensible object")
         : js_mkundef();
     }
@@ -3707,7 +3224,7 @@ static inline jsval_t check_object_extensibility(struct js *js, jsval_t obj) {
   return js_mkundef();
 }
 
-static inline void update_array_length(struct js *js, jsval_t obj, jsoff_t new_len) {
+static inline void update_array_length(ant_t *js, jsval_t obj, jsoff_t new_len) {
   jsoff_t len_off = lkp_interned(js, obj, INTERN_LENGTH, 6);
   jsval_t new_len_val = tov((double)new_len);
   
@@ -3716,7 +3233,7 @@ static inline void update_array_length(struct js *js, jsval_t obj, jsoff_t new_l
   }
 }
 
-static jsval_t js_setprop_array_fast(struct js *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t klen, const char *key) {
+static jsval_t js_setprop_array_fast(ant_t *js, jsval_t obj, jsval_t k, jsval_t v, jsoff_t klen, const char *key) {
   unsigned long idx;
   if (!parse_array_index(key, klen, (jsoff_t)-1, &idx)) return js_mkundef();
   
@@ -3748,7 +3265,72 @@ static jsval_t js_setprop_array_fast(struct js *js, jsval_t obj, jsval_t k, jsva
   return result;
 }
 
-jsval_t js_setprop(struct js *js, jsval_t obj, jsval_t k, jsval_t v) {
+jsval_t js_setprop(ant_t *js, jsval_t obj, jsval_t k, jsval_t v) {
+  uint8_t ot = vtype(obj);
+
+  if (ot == T_STR || ot == T_NUM || ot == T_BOOL) {
+    jsoff_t klen; jsoff_t koff = vstr(js, k, &klen);
+    const char *key = (char *)&js->mem[koff];
+    jsval_t proto = get_prototype_for_type(js, ot);
+    if (is_object_type(proto)) {
+      jsval_t setter = js_mkundef();
+      bool has_setter = false;
+      lkp_with_setter(js, proto, key, klen, &setter, &has_setter);
+      if (has_setter && (vtype(setter) == T_FUNC || vtype(setter) == T_CFUNC)) {
+        call_proto_accessor(js, obj, setter, true, &v, 1, true);
+        return v;
+      }
+    }
+    if (sv_vm_is_strict(js->vm))
+      return js_mkerr_typed(js, JS_ERR_TYPE,
+        "Cannot create property '%.*s' on %s",
+        (int)klen, key, typestr(ot));
+    return v;
+  }
+
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
+  if (vtype(k) == T_SYMBOL) {
+    jsoff_t sym_off = (jsoff_t)vdata(k);
+    jsval_t cur = obj;
+    
+    for (int i = 0; i < MAX_PROTO_CHAIN_DEPTH; i++) {
+      jsoff_t cur_off = (jsoff_t)vdata(js_as_obj(cur));
+      descriptor_entry_t *sd = lookup_sym_descriptor(cur_off, sym_off);
+      if (sd && sd->has_setter) {
+        jsval_t setter = sd->setter;
+        if (vtype(setter) == T_FUNC || vtype(setter) == T_CFUNC) {
+          jsval_t result = sv_vm_call(js->vm, js, setter, obj, &v, 1, NULL, false);
+          if (is_err(result)) return result;
+          return v;
+        }
+      }
+      
+      if (sd && sd->has_getter && !sd->has_setter) {
+        if (sv_vm_is_strict(js->vm)) return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot set property which has only a getter");
+        return v;
+      }
+      
+      jsval_t proto = get_proto(js, js_as_obj(cur));
+      if (!is_object_type(proto)) break;
+      cur = proto;
+    }
+
+    jsoff_t existing = lkp_sym(js, obj, sym_off);
+    
+    if (existing > 0) {
+      if (is_const_prop(js, existing)) return js_mkerr(js, "assignment to constant");
+      saveval(js, existing + sizeof(jsoff_t) * 2, v);
+      return mkval(T_PROP, existing);
+    }
+    
+    if (js_truthy(js, get_slot(js, obj, SLOT_FROZEN))) {
+      if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to frozen object");
+      return js_mkundef();
+    }
+    
+    return mkprop(js, obj, k, v, 0);
+  }
+
   jsoff_t klen; jsoff_t koff = vstr(js, k, &klen);
   const char *key = (char *) &js->mem[koff];
   
@@ -3782,53 +3364,48 @@ jsval_t js_setprop(struct js *js, jsval_t obj, jsval_t k, jsval_t v) {
     return v;
   }
   
-  if (try_dynamic_setter(js, obj, key, klen, v)) return v;  
+  if (try_dynamic_setter(js, obj, key, klen, v)) return v;
   jsoff_t existing = lkp(js, obj, key, klen);
   
   {
-    jsoff_t obj_off = (jsoff_t)vdata(obj);
+    jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
     descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, klen);
-    
+
+    if (!desc) {
+      jsval_t cur = obj;
+      for (int i = 0; i < MAX_PROTO_CHAIN_DEPTH && !desc; i++) {
+        cur = get_proto(js, cur);
+        if (vtype(cur) != T_OBJ && vtype(cur) != T_FUNC) break;
+        desc = lookup_descriptor(js, (jsoff_t)vdata(js_as_obj(cur)), key, klen);
+      }
+      if (desc && !desc->has_setter && !desc->has_getter && desc->writable) desc = NULL;
+    }
+
     if (!desc) goto no_descriptor;
     
     if (desc->has_setter) {
       jsval_t setter = desc->setter;
       uint8_t setter_type = vtype(setter);
       if (setter_type == T_FUNC || setter_type == T_CFUNC) {
-        js_parse_state_t saved;
-        JS_SAVE_STATE(js, saved);
-        uint8_t saved_flags = js->flags;
-        jsoff_t saved_toff = js->toff;
-        jsoff_t saved_tlen = js->tlen;
-        
-        jsval_t saved_this = js->this_val;
-        js->this_val = obj;
-        push_this(obj);
-        jsval_t result = call_js_with_args(js, setter, &v, 1);
-        pop_this();
-        js->this_val = saved_this;
-        
-        JS_RESTORE_STATE(js, saved);
-        js->flags = saved_flags;
-        js->toff = saved_toff;
-        js->tlen = saved_tlen;
-        
+        js_error_site_t saved_errsite = js->errsite;
+        jsval_t result = sv_vm_call(js->vm, js, setter, obj, &v, 1, NULL, false);
+        js->errsite = saved_errsite;
         if (is_err(result)) return result;
         return v;
       }
     }
     
     if (desc->has_getter && !desc->has_setter) {
-      if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot set property which has only a getter");
+      if (sv_vm_is_strict(js->vm)) return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot set property which has only a getter");
       return v;
     }
     
-    if (existing <= 0) goto no_descriptor;
-    
     if (!desc->writable) {
-      if (js->flags & F_STRICT) return js_mkerr(js, "assignment to read-only property");
-      return mkval(T_PROP, existing);
+      if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "assignment to read-only property");
+      return existing > 0 ? mkval(T_PROP, existing) : v;
     }
+    
+    if (existing <= 0) goto no_descriptor;
   }
   
 no_descriptor:
@@ -3861,18 +3438,18 @@ done_update:
 
 create_new:
   if (js_truthy(js, get_slot(js, obj, SLOT_FROZEN))) {
-    if (js->flags & F_STRICT) return js_mkerr(js, "cannot add property to frozen object");
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to frozen object");
     return js_mkundef();
   }
   
   if (js_truthy(js, get_slot(js, obj, SLOT_SEALED))) {
-    if (js->flags & F_STRICT) return js_mkerr(js, "cannot add property to sealed object");
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to sealed object");
     return js_mkundef();
   }
   
   jsval_t ext_slot = get_slot(js, obj, SLOT_EXTENSIBLE);
   if (vtype(ext_slot) != T_UNDEF && !js_truthy(js, ext_slot)) {
-    if (js->flags & F_STRICT) return js_mkerr(js, "cannot add property to non-extensible object");
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to non-extensible object");
     return js_mkundef();
   }
   
@@ -3905,25 +3482,76 @@ create_new:
   return result;
 }
 
-static inline void esm_export_binding(struct js *js, const char *exported, size_t exported_len, jsval_t value) {
-  jsval_t export_key = js_mkstr(js, exported, exported_len);
-  js_setprop(js, js->module_ns, export_key, value);
-  if (exported_len == 7 && strncmp(exported, "default", 7) == 0) js_set_slot(js, js->module_ns, SLOT_DEFAULT, value);
+jsval_t setprop_cstr(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
+  obj = js_as_obj(obj);
+  jsval_t k = js_mkstr(js, key, len);
+  if (is_err(k)) return k;
+  return mkprop(js, obj, k, v, 0);
 }
 
-jsval_t setprop_cstr(struct js *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
-  jsval_t k = js_mkstr(js, key, len);
+jsval_t js_define_own_prop(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t v) {
+  obj = js_as_obj(obj);
+  if (is_proxy(js, obj)) {
+    jsval_t result = proxy_set(js, obj, key, klen, v);
+    if (is_err(result)) return result;
+    return v;
+  }
+
+  if (try_dynamic_setter(js, obj, key, klen, v)) return v;
+  jsoff_t existing = lkp(js, obj, key, klen);
+
+  {
+    jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
+    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, klen);
+    if (desc) {
+      if (!desc->writable && !desc->has_setter) {
+        if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "assignment to read-only property");
+        return v;
+      }
+      if (desc->has_setter) {
+        jsval_t setter = desc->setter;
+        uint8_t setter_type = vtype(setter);
+        if (setter_type == T_FUNC || setter_type == T_CFUNC) {
+          jsval_t result = sv_vm_call(js->vm, js, setter, obj, &v, 1, NULL, false);
+          if (is_err(result)) return result;
+          return v;
+        }
+      }
+    }
+  }
+
+  if (existing > 0) {
+    if (is_const_prop(js, existing)) return js_mkerr(js, "assignment to constant");
+    saveval(js, existing + sizeof(jsoff_t) * 2, v);
+    return mkval(T_PROP, existing);
+  }
+
+  if (js_truthy(js, get_slot(js, obj, SLOT_FROZEN))) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to frozen object");
+    return js_mkundef();
+  }
+  if (js_truthy(js, get_slot(js, obj, SLOT_SEALED))) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to sealed object");
+    return js_mkundef();
+  }
+  jsval_t ext_slot = get_slot(js, obj, SLOT_EXTENSIBLE);
+  if (vtype(ext_slot) != T_UNDEF && !js_truthy(js, ext_slot)) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot add property to non-extensible object");
+    return js_mkundef();
+  }
+
+  jsval_t k = js_mkstr(js, key, klen);
   if (is_err(k)) return k;
   return mkprop(js, obj, k, v, 0);
 }
 
-jsval_t setprop_interned(struct js *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
+jsval_t setprop_interned(ant_t *js, jsval_t obj, const char *key, size_t len, jsval_t v) {
   jsval_t k = js_mkstr(js, key, len);
   if (is_err(k)) return k;
   return js_setprop(js, obj, k, v);
 }
 
-jsval_t js_setprop_nonconfigurable(struct js *js, jsval_t obj, const char *key, size_t keylen, jsval_t v) {
+jsval_t js_setprop_nonconfigurable(ant_t *js, jsval_t obj, const char *key, size_t keylen, jsval_t v) {
   jsval_t k = js_mkstr(js, key, keylen);
   if (is_err(k)) return k;
   jsval_t result = js_setprop(js, obj, k, v);
@@ -3933,12674 +3561,1713 @@ jsval_t js_setprop_nonconfigurable(struct js *js, jsval_t obj, const char *key,
   return result;
 }
 
-jsval_t js_mksym(struct js *js, const char *desc) {
-  uint64_t id = ++js->sym_counter;
-  jsoff_t desc_off = 0;
-  if (desc && *desc) {
-    jsval_t desc_str = js_mkstr(js, desc, strlen(desc));
-    desc_off = (jsoff_t)vdata(desc_str);
+#define SYM_HEAP_FIXED   (sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uintptr_t))
+#define SYM_FLAG_GLOBAL  1u
+#define SYM_REGISTRY_MAX 256
+
+static struct { 
+  const char *key;
+  uint32_t sym_id;
+} g_sym_registry[SYM_REGISTRY_MAX];
+
+static size_t  g_sym_registry_count = 0;
+static size_t  g_sym_all_count      = 0;
+static size_t  g_sym_all_cap        = 0;
+static jsval_t *g_sym_all = NULL;
+
+static void sym_table_add(jsval_t sym) {
+  if (g_sym_all_count >= g_sym_all_cap) {
+    size_t new_cap = g_sym_all_cap ? g_sym_all_cap * 2 : 64;
+    jsval_t *new_buf = realloc(g_sym_all, new_cap * sizeof(jsval_t));
+    if (!new_buf) return;
+    g_sym_all = new_buf;
+    g_sym_all_cap = new_cap;
   }
-  uint64_t payload = ((id & PROPREF_PAYLOAD) << PROPREF_KEY_SHIFT) | (desc_off & PROPREF_PAYLOAD);
-  return mkval(T_SYMBOL, payload);
+  g_sym_all[g_sym_all_count++] = sym;
 }
 
-static inline uint64_t sym_get_id(jsval_t v) {
-  return (vdata(v) >> PROPREF_KEY_SHIFT) & PROPREF_PAYLOAD;
-}
+jsval_t js_mksym(ant_t *js, const char *desc) {
+  uint32_t id = (uint32_t)(++js->sym_counter);
+  size_t desc_len = (desc && *desc) ? strlen(desc) : 0;
+  size_t payload = SYM_HEAP_FIXED + (desc_len ? desc_len + 1 : 0);
 
-static inline jsoff_t sym_get_desc_off(jsval_t v) {
-  return vdata(v) & PROPREF_PAYLOAD;
-}
+  jsoff_t ofs = js_alloc(js, payload + sizeof(jsoff_t));
+  if (ofs == (jsoff_t)~0) return js_mkerr(js, "oom");
 
-static const char *sym_get_desc(struct js *js, jsval_t v) {
-  jsoff_t off = sym_get_desc_off(v);
-  if (off == 0) return NULL;
-  return (const char *)&js->mem[off + sizeof(jsoff_t)];
-}
+  jsoff_t header = (jsoff_t)(payload << 4);
+  memcpy(&js->mem[ofs], &header, sizeof(header));
 
-uint64_t inline js_sym_id(jsval_t sym) {
-  return sym_get_id(sym);
-}
+  jsoff_t p = ofs + sizeof(jsoff_t);
+  memcpy(&js->mem[p], &id, sizeof(id));
+  p += sizeof(uint32_t);
+  uint32_t flags = 0;
+  memcpy(&js->mem[p], &flags, sizeof(flags));
+  p += sizeof(uint32_t);
+  uintptr_t key_ptr = 0;
+  memcpy(&js->mem[p], &key_ptr, sizeof(key_ptr));
+  p += sizeof(uintptr_t);
 
-jsval_t js_mksym_for(struct js *js, const char *key) {
-  (void)js;
-  const char *interned = intern_string(key, strlen(key));
-  uint64_t id = (uint64_t)(uintptr_t)interned;
-  return mkval(T_SYMBOL, id | (1ULL << 47));
+  if (desc_len) {
+    memcpy(&js->mem[p], desc, desc_len);
+    js->mem[p + desc_len] = '\0';
+  }
+
+  jsval_t sym = mkval(T_SYMBOL, ofs);
+  sym_table_add(sym);
+  return sym;
 }
 
-const char *js_sym_key(jsval_t sym) {
-  if (vtype(sym) != T_SYMBOL) return NULL;
-  uint64_t data = vdata(sym);
-  if (!(data & (1ULL << 47))) return NULL;
-  return (const char *)(uintptr_t)(data & ~(1ULL << 47));
+static inline uint32_t sym_get_id(ant_t *js, jsval_t v) {
+  jsoff_t ofs = (jsoff_t)vdata(v);
+  uint32_t id;
+  memcpy(&id, &js->mem[ofs + sizeof(jsoff_t)], sizeof(id));
+  return id;
 }
 
-const inline char *js_sym_desc(struct js *js, jsval_t sym) {
-  return sym_get_desc(js, sym);
+static inline uint32_t sym_get_flags(ant_t *js, jsval_t v) {
+  jsoff_t ofs = (jsoff_t)vdata(v);
+  uint32_t flags;
+  memcpy(&flags, &js->mem[ofs + sizeof(jsoff_t) + sizeof(uint32_t)], sizeof(flags));
+  return flags;
 }
 
-jsoff_t esize(jsoff_t w) {
-  jsoff_t cleaned = w & ~FLAGMASK;
-  switch (cleaned & 3U) {
-    case T_OBJ:  return (jsoff_t) (sizeof(jsoff_t) + sizeof(jsoff_t) + sizeof(jsoff_t));
-    case T_PROP: return (jsoff_t) (sizeof(jsoff_t) + sizeof(jsoff_t) + sizeof(jsval_t));
-    case T_STR:  return (jsoff_t) (sizeof(jsoff_t) + align64(cleaned >> 3U));
-    default:     return (jsoff_t) ~0U;
-  }
+static inline uintptr_t sym_get_key_ptr(ant_t *js, jsval_t v) {
+  jsoff_t ofs = (jsoff_t)vdata(v);
+  uintptr_t kp;
+  memcpy(&kp, &js->mem[ofs + sizeof(jsoff_t) + sizeof(uint32_t) * 2], sizeof(kp));
+  return kp;
 }
 
-static int is_unicode_space(const unsigned char *p, jsoff_t remaining, bool *is_line_term) {
-  if (is_line_term) *is_line_term = false;
-  if (p[0] < 0x80) return 0;
-  if (remaining >= 2 && p[0] == 0xC2 && p[1] == 0xA0) return 2;
-  if (remaining >= 3 && p[0] == 0xE2 && p[1] == 0x80) {
-    if (p[2] >= 0x80 && p[2] <= 0x8A) return 3;
-    if (p[2] == 0xAF) return 3;
-    if (p[2] == 0xA8) { if (is_line_term) *is_line_term = true; return 3; }
-    if (p[2] == 0xA9) { if (is_line_term) *is_line_term = true; return 3; }
-  }
-  if (remaining >= 3 && p[0] == 0xE1 && p[1] == 0x9A && p[2] == 0x80) return 3;
-  if (remaining >= 3 && p[0] == 0xE2 && p[1] == 0x81 && p[2] == 0x9F) return 3;
-  if (remaining >= 3 && p[0] == 0xE3 && p[1] == 0x80 && p[2] == 0x80) return 3;
-  if (remaining >= 3 && p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF) return 3;
-  return 0;
+static const char *sym_get_desc(ant_t *js, jsval_t v) {
+  jsoff_t ofs = (jsoff_t)vdata(v);
+  jsoff_t header;
+  memcpy(&header, &js->mem[ofs], sizeof(header));
+  size_t payload = (size_t)(header >> 4);
+  if (payload <= SYM_HEAP_FIXED) return NULL;
+  return (const char *)&js->mem[ofs + sizeof(jsoff_t) + SYM_HEAP_FIXED];
 }
 
-enum { C_0 = 0, C_SPC, C_NL, C_SL, C_HI };
+uint64_t inline js_sym_id(jsval_t sym) {
+  // TODO: fix to not use the global runtime
+  ant_t *js = rt->js;
+  return sym_get_id(js, sym);
+}
 
-static const uint8_t cc[128] = {
-  0,0,0,0,0,0,0,0,0,C_SPC,C_NL,C_SPC,C_SPC,C_SPC,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  C_SPC,0,0,0,0,0,0,0,0,0,0,0,0,0,0,C_SL,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-};
+jsval_t js_mksym_for(ant_t *js, const char *key) {
+  const char *interned = intern_string(key, strlen(key));
 
-static jsoff_t skiptonext(const char *code, jsoff_t len, jsoff_t n, bool *nl) {
-  static const void *D[] = { &&L0, &&LS, &&LN, &&LSL, &&LH };
-  bool saw_nl = false;
-  unsigned char c;
-
-  const char *p = code + n;
-  const char *end = code + len;
-
-  if (__builtin_expect(p == code && end - p >= 2 && p[0] == '#' && p[1] == '!', 0)) {
-    for (p += 2; p < end && *p != '\n'; p++);
-    if (p < end) { saw_nl = true; p++; }
-  }
-
-  if (__builtin_expect(p >= end, 0)) goto L0;
-  c = (unsigned char)*p;
-  goto *D[c & 0x80 ? C_HI : cc[c]];
-
-LS:
-  p++;
-  if (__builtin_expect(p >= end, 0)) goto L0;
-  c = (unsigned char)*p;
-  goto *D[c & 0x80 ? C_HI : cc[c]];
-
-LN:
-  saw_nl = true;
-  p++;
-  if (__builtin_expect(p >= end, 0)) goto L0;
-  c = (unsigned char)*p;
-  goto *D[c & 0x80 ? C_HI : cc[c]];
-
-LSL:
-  if (p + 1 >= end) goto L0;
-  if (p[1] == '/') {
-    for (p += 2; p < end && *p != '\n'; p++);
-    if (p < end) { saw_nl = true; p++; }
-    if (__builtin_expect(p >= end, 0)) goto L0;
-    c = (unsigned char)*p;
-    goto *D[c & 0x80 ? C_HI : cc[c]];
-  }
-  if (p[1] == '*') {
-    for (p += 2; p + 1 < end; p++) {
-      if (*p == '*' && p[1] == '/') { p += 2; break; }
-      if (*p == '\n') saw_nl = true;
+  for (size_t i = 0; i < g_sym_registry_count; i++) {
+    if (g_sym_registry[i].key == interned) {
+      uint32_t id = g_sym_registry[i].sym_id;
+      if (id - 1 < g_sym_all_count) return g_sym_all[id - 1];
     }
-    if (__builtin_expect(p >= end, 0)) goto L0;
-    c = (unsigned char)*p;
-    goto *D[c & 0x80 ? C_HI : cc[c]];
   }
-  goto L0;
 
-LH: {
-  bool lt;
-  int u = is_unicode_space((const unsigned char *)p, (jsoff_t)(end - p), &lt);
-  if (u > 0) {
-    if (lt) saw_nl = true;
-    p += u;
-    if (__builtin_expect(p >= end, 0)) goto L0;
-    c = (unsigned char)*p;
-    goto *D[c & 0x80 ? C_HI : cc[c]];
+  jsval_t sym = js_mksym(js, key);
+  if (is_err(sym)) return sym;
+
+  jsoff_t ofs = (jsoff_t)vdata(sym);
+  uint32_t flags = SYM_FLAG_GLOBAL;
+  memcpy(&js->mem[ofs + sizeof(jsoff_t) + sizeof(uint32_t)], &flags, sizeof(flags));
+  uintptr_t kp = (uintptr_t)interned;
+  memcpy(&js->mem[ofs + sizeof(jsoff_t) + sizeof(uint32_t) * 2], &kp, sizeof(kp));
+
+  if (g_sym_registry_count < SYM_REGISTRY_MAX) {
+    uint32_t id = sym_get_id(js, sym);
+    g_sym_registry[g_sym_registry_count].key = interned;
+    g_sym_registry[g_sym_registry_count].sym_id = id;
+    g_sym_registry_count++;
   }
+
+  return sym;
 }
 
-L0:
-  if (nl) *nl = saw_nl;
-  return (jsoff_t)(p - code);
+const char *js_sym_key(jsval_t sym) {
+  if (vtype(sym) != T_SYMBOL) return NULL;
+  ant_t *js = rt->js;
+  if (!(sym_get_flags(js, sym) & SYM_FLAG_GLOBAL)) return NULL;
+  return (const char *)sym_get_key_ptr(js, sym);
 }
 
-#define K(s, t) if (len == sizeof(s)-1 && !memcmp(buf, s, sizeof(s)-1)) return t
-#define M(s)   (len == sizeof(s)-1 && !memcmp(buf, s, sizeof(s)-1))
+const inline char *js_sym_desc(ant_t *js, jsval_t sym) {
+  return sym_get_desc(js, sym);
+}
 
-static uint8_t parsekeyword(const char *buf, size_t len) {
-  switch (buf[0]) {
-    case 'a':
-      K("as", TOK_AS);
-      K("async", TOK_ASYNC);
-      K("await", TOK_AWAIT);
-      break;
-    case 'b':
-      K("break", TOK_BREAK);
-      break;
-    case 'c':
-      K("case", TOK_CASE);
-      K("catch", TOK_CATCH);
-      K("class", TOK_CLASS);
-      K("const", TOK_CONST);
-      K("continue", TOK_CONTINUE);
-      break;
-    case 'd':
-      K("do", TOK_DO);
-      K("default", TOK_DEFAULT);
-      K("delete", TOK_DELETE);
-      K("debugger", TOK_DEBUGGER);
-      break;
-    case 'e':
-      K("else", TOK_ELSE);
-      K("export", TOK_EXPORT);
-      break;
-    case 'f':
-      K("for", TOK_FOR);
-      K("from", TOK_FROM);
-      K("false", TOK_FALSE);
-      K("finally", TOK_FINALLY);
-      K("function", TOK_FUNC);
-      break;
-    case 'g':
-      K("globalThis", TOK_GLOBAL_THIS);
-      break;
-    case 'i':
-      K("if", TOK_IF);
-      K("in", TOK_IN);
-      K("import", TOK_IMPORT);
-      K("instanceof", TOK_INSTANCEOF);
-      break;
-    case 'l':
-      K("let", TOK_LET);
-      break;
-    case 'n':
-      K("new", TOK_NEW);
-      K("null", TOK_NULL);
-      break;
-    case 'o':
-      K("of", TOK_OF);
-      break;
-    case 'r':
-      K("return", TOK_RETURN);
-      break;
-    case 's':
-      K("super", TOK_SUPER);
-      K("static", TOK_STATIC);
-      K("switch", TOK_SWITCH);
-      break;
-    case 't':
-      K("try", TOK_TRY);
-      K("this", TOK_THIS);
-      K("true", TOK_TRUE);
-      K("throw", TOK_THROW);
-      K("typeof", TOK_TYPEOF);
-      break;
-    case 'u':
-      K("undefined", TOK_UNDEF);
-      break;
-    case 'v':
-      K("var", TOK_VAR);
-      K("void", TOK_VOID);
-      break;
-    case 'w':
-      K("while", TOK_WHILE);
-      K("with", TOK_WITH);
-      K("window", TOK_WINDOW);
-      break;
-    case 'y':
-      K("yield", TOK_YIELD);
-      break;
-  }
-  return TOK_IDENTIFIER;
+jsval_t sym_lookup_by_id(uint32_t id) {
+  if (id == 0 || id - 1 >= g_sym_all_count) return (jsval_t)0;
+  return g_sym_all[id - 1];
 }
 
-static bool is_strict_reserved(const char *buf, size_t len) {
-  switch (buf[0]) {
-    case 'i':
-      if M("interface") return true;
-      if M("implements") return true;
-      break;
-    case 'l':
-      if M("let") return true;
-      break;
-    case 'p':
-      if M("private") return true;
-      if M("package") return true;
-      if M("public") return true;
-      if M("protected") return true;
-      break;
-    case 's':
-      if M("static") return true;
-      break;
-    case 'y':
-      if M("yield") return true;
-      break;
+void sym_gc_update_all(void (*op_val)(void *, jsval_t *), void *ctx) {
+  for (size_t i = 0; i < g_sym_all_count; i++) {
+    op_val(ctx, &g_sym_all[i]);
   }
-  return false;
 }
 
-#undef K
-#undef M
+jsoff_t esize(jsoff_t w) {
+  jsoff_t cleaned = w & ~FLAGMASK;
+  switch (cleaned & 3U) {
+    case T_OBJ:  return (jsoff_t) (sizeof(jsoff_t) + sizeof(jsoff_t) + sizeof(jsoff_t));
+    case T_PROP: return (jsoff_t) (sizeof(jsoff_t) + sizeof(jsoff_t) + sizeof(jsval_t));
+    case T_STR:  return (jsoff_t) (sizeof(jsoff_t) + align64(cleaned >> 3U));
+    default:     return (jsoff_t) ~0U;
+  }
+}
 
 static inline bool streq(const char *buf, size_t len, const char *s, size_t n) {
   return len == n && !memcmp(buf, s, n);
 }
 
-static inline bool is_strict_restricted(const char *buf, size_t len) {
-  if (len == 4) return streq(buf, len, "eval", 4);
-  if (len == 9) return streq(buf, len, "arguments", 9);
-  return false;
-}
-
-#define CHAR_DIGIT  0x01
-#define CHAR_XDIGIT 0x02
-#define CHAR_ALPHA  0x04
-#define CHAR_IDENT  0x08
-#define CHAR_IDENT1 0x10
-#define CHAR_WS     0x20
-#define CHAR_OCTAL  0x40
-
-static const uint8_t char_type[256] = {
-  ['\t'] = CHAR_WS, ['\n'] = CHAR_WS, ['\r'] = CHAR_WS, [' '] = CHAR_WS,
-  ['0'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['1'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['2'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['3'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['4'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['5'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['6'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['7'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
-  ['8'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT,
-  ['9'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT,
-  ['A'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['B'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['C'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['D'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['E'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['F'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['a'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['b'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['c'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['d'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['e'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['f'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['G'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['H'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['I'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['J'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['K'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['L'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['M'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['N'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['O'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['P'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['Q'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['R'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['S'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['T'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['U'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['V'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['W'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['X'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['Y'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['Z'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['g'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['h'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['i'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['j'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['k'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['l'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['m'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['n'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['o'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['p'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['q'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['r'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['s'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['t'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['u'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['v'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['w'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['x'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['y'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['z'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
-  ['_'] = CHAR_IDENT | CHAR_IDENT1,
-  ['$'] = CHAR_IDENT | CHAR_IDENT1,
-};
-
-#define IS_DIGIT(c)  (char_type[(uint8_t)(c)] & CHAR_DIGIT)
-#define IS_XDIGIT(c) (char_type[(uint8_t)(c)] & CHAR_XDIGIT)
-#define IS_IDENT(c)  (char_type[(uint8_t)(c)] & CHAR_IDENT)
-#define IS_IDENT1(c) (char_type[(uint8_t)(c)] & CHAR_IDENT1)
-#define IS_OCTAL(c)  (char_type[(uint8_t)(c)] & CHAR_OCTAL)
-
-#define likely(x)   __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-
-static inline bool is_function_keyword(const char *code, jsoff_t pos, jsoff_t end) {
-  if (pos + 8 > end) return false;
-  uint64_t word;
-  memcpy(&word, code + pos, 8);
-  
-  if (word != 0x6e6f6974636e7566ULL) return false;
-  return (pos + 8 >= end) || !IS_IDENT(code[pos + 8]);
-}
-
-static inline bool is_async_function(const char *code, jsoff_t pos, jsoff_t end) {
-  if (pos + 5 > end) return false;
-  
-  uint32_t word4;
-  memcpy(&word4, code + pos, 4);
-  
-  if (word4 != 0x6e797361U || code[pos + 4] != 'c') return false;
-  if (pos + 5 < end && IS_IDENT(code[pos + 5])) return false;
-  
-  jsoff_t scan = pos + 5;
-  while (scan < end && (
-    code[scan] == ' '  || 
-    code[scan] == '\t' || 
-    code[scan] == '\n' || 
-    code[scan] == '\r'
-  )) scan++;
+static inline jsoff_t lkp_interned(ant_t *js, jsval_t obj, const char *search_intern, size_t len) {
+  obj = js_as_obj(obj);
+  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  jsoff_t tail = loadoff(js, obj_off + sizeof(jsoff_t) * 2);
   
-  return is_function_keyword(code, scan, end);
-}
-
-static bool code_has_function_decl(const char *code, size_t len) {
-  if (!memmem(code, len, "function", 8)) return false;
+  uint32_t slot = (((uintptr_t)search_intern >> 3) ^ obj_off) & (ANT_LIMIT_SIZE_CACHE - 1);
+  intern_prop_cache_entry_t *ce = &intern_prop_cache[slot];
   
-  size_t pos = 0;
+  if (ce->generation == intern_prop_cache_gen 
+    && ce->obj_off == obj_off 
+    && ce->intern_ptr == search_intern
+    && ce->tail == tail
+  ) return ce->prop_off;
   
-  int target_depth = 0;
-  if (len > 0 && code[0] == '(') target_depth = 1;
-  int depth = 0;
+  jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
+  jsoff_t off = first_prop; jsoff_t result = 0;
   
-  while (pos < len) {
-    uint8_t c = (uint8_t)code[pos];
-    
-    if (c == '"' || c == '\'' || c == '`') {
-      uint8_t quote = c;
-      pos++;
-      while (pos < len && (uint8_t)code[pos] != quote) {
-        if (code[pos] == '\\' && pos + 1 < len) pos++;
-        pos++;
-      }
-      if (pos < len) pos++;
-      continue;
-    }
-    
-    if (c == '/' && pos + 1 < len) {
-      if (code[pos + 1] == '/') {
-        pos += 2;
-        while (pos < len && code[pos] != '\n') pos++;
-        continue;
-      }
-      if (code[pos + 1] == '*') {
-        pos += 2;
-        while (pos + 1 < len && !(code[pos] == '*' && code[pos + 1] == '/')) pos++;
-        if (pos + 1 < len) pos += 2;
-        continue;
-      }
-    }
+  while (off < js->brk && off != 0) {
+    jsoff_t header = loadoff(js, off);
+    if (is_slot_prop(header)) { off = next_prop(header); continue; }
     
-    if (c == '{') { depth++; pos++; continue; }
-    if (c == '}') {
-      if (depth <= target_depth) break;
-      depth--; pos++; continue;
-    }
+    jsoff_t koff = loadoff(js, off + sizeof(jsoff_t));
+    jsoff_t klen = (loadoff(js, koff) >> 3) - 1;
     
-    if (depth == target_depth) {
-      if (c == 'f' && is_function_keyword(code, (jsoff_t)pos, (jsoff_t)len)) return true;
-      if (c == 'a' && is_async_function(code, (jsoff_t)pos, (jsoff_t)len)) return true;
+    if (klen == len) {
+      const char *p = (char *)&js->mem[koff + sizeof(jsoff_t)];
+      if (intern_string(p, klen) == search_intern) { result = off; break; }
     }
-    
-    pos++;
+    off = next_prop(header);
   }
   
-  return false;
+  ce->generation = intern_prop_cache_gen;
+  ce->obj_off = obj_off;
+  ce->intern_ptr = search_intern;
+  ce->prop_off = result;
+  ce->tail = tail;
+  
+  return result;
 }
 
-static const uint8_t single_char_tok[128] = {
-  ['('] = TOK_LPAREN,
-  [')'] = TOK_RPAREN,
-  ['{'] = TOK_LBRACE,
-  ['}'] = TOK_RBRACE,
-  ['['] = TOK_LBRACKET,
-  [']'] = TOK_RBRACKET,
-  [';'] = TOK_SEMICOLON,
-  [','] = TOK_COMMA,
-  [':'] = TOK_COLON,
-  ['~'] = TOK_TILDA,
-  ['#'] = TOK_HASH,
-};
-
-static bool is_space(int c) { 
-  if (c < 0 || c >= 256) return false;
-  return (char_type[(uint8_t)c] & CHAR_WS) != 0;
-}
-
-static bool is_digit(int c) { 
-  if (c < 0 || c >= 256) return false;
-  return (char_type[(uint8_t)c] & CHAR_DIGIT) != 0;
-}
-
-static bool is_alpha(int c) { 
-  if (c < 0 || c >= 256) return false;
-  return (char_type[(uint8_t)c] & CHAR_ALPHA) != 0;
-}
-
-static bool is_ident_begin(int c) { 
-  if (c < 0) return false;
-  if (c < 128) return (char_type[(uint8_t)c] & CHAR_IDENT1) != 0;
-  return (c & 0x80) != 0;
-}
-
-static bool is_ident_continue(int c) { 
-  if (c < 0) return false;
-  if (c < 128) return (char_type[(uint8_t)c] & (CHAR_IDENT | CHAR_IDENT1)) != 0;
-  return (c & 0x80) != 0;
+inline jsoff_t lkp(ant_t *js, jsval_t obj, const char *buf, size_t len) {
+  const char *search_intern = intern_string(buf, len);
+  if (!search_intern) return 0;
+  return lkp_interned(js, obj, search_intern, len);
 }
 
-static int parse_unicode_escape(const char *buf, jsoff_t len, jsoff_t pos, uint32_t *codepoint) {
-  if (pos + 5 >= len) return 0;
-  if (buf[pos] != '\\' || buf[pos + 1] != 'u') return 0;
+jsoff_t lkp_sym(ant_t *js, jsval_t obj, jsoff_t sym_off) {
+  obj = js_as_obj(obj);
+  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
+  jsoff_t off = first_prop;
   
-  uint32_t cp = 0;
-  for (int i = 0; i < 4; i++) {
-    int c = (unsigned char)buf[pos + 2 + i];
-    if (!is_xdigit(c)) return 0;
-    cp <<= 4;
-    cp |= (c <= '9') ? (c - '0') : ((c | 0x20) - 'a' + 10);
-  }
-  *codepoint = cp;
-  return 6;
-}
-
-static bool is_unicode_ident_begin(uint32_t cp) {
-  if (cp < 128) return (char_type[(uint8_t)cp] & CHAR_IDENT1) != 0;
-  return true;
-}
-
-static bool is_unicode_ident_continue(uint32_t cp) {
-  if (cp < 128) return (char_type[(uint8_t)cp] & (CHAR_IDENT | CHAR_IDENT1)) != 0;
-  return true;
-}
-
-static size_t decode_ident_escapes(const char *src, size_t srclen, char *dst, size_t dstlen) {
-  size_t si = 0, di = 0;
-  while (si < srclen && di + 4 < dstlen) {
-    uint32_t cp;
-    int el = parse_unicode_escape(src, (jsoff_t)srclen, (jsoff_t)si, &cp);
-    if (el > 0) {
-      di += utf8_encode(cp, dst + di);
-      si += el;
-    } else dst[di++] = src[si++];
-  }
-  dst[di] = '\0';
-  return di;
-}
-
-static bool has_unicode_escape(const char *src, size_t len) {
-  if (len < 6) return false;
-  const char *end = src + len - 5;
-  const char *p = src;
-  while ((p = memchr(p, '\\', end - p)) != NULL) {
-    if (p[1] == 'u') return true;
-    p++;
+  while (off < js->brk && off != 0) {
+    jsoff_t header = loadoff(js, off);
+    if (is_slot_prop(header)) { off = next_prop(header); continue; }
+    jsoff_t koff = loadoff(js, off + sizeof(jsoff_t));
+    if (koff == sym_off) return off;
+    off = next_prop(header);
   }
-  return false;
+  return 0;
 }
 
-static jsval_t js_mkstr_ident(struct js *js, const char *src, size_t srclen) {
-  if (!has_unicode_escape(src, srclen)) {
-    return js_mkstr(js, src, srclen);
+jsoff_t lkp_sym_proto(ant_t *js, jsval_t obj, jsoff_t sym_off) {
+  for (int i = 0; i < MAX_PROTO_CHAIN_DEPTH; i++) {
+    jsoff_t off = lkp_sym(js, obj, sym_off);
+    if (off != 0) return off;
+    jsval_t proto = get_proto(js, js_as_obj(obj));
+    if (!is_object_type(proto)) break;
+    obj = proto;
   }
-  char decoded[256];
-  size_t decoded_len = decode_ident_escapes(src, srclen, decoded, sizeof(decoded));
-  return js_mkstr(js, decoded, decoded_len);
+  return 0;
 }
 
-
-static uint8_t parseident(const char *buf, jsoff_t len, jsoff_t *tlen) {
-  if (len == 0) return TOK_ERR;
+static jsval_t *resolve_bound_args(ant_t *js, jsval_t func_obj, jsval_t *args, int nargs, int *out_nargs) {
+  *out_nargs = nargs;
   
-  unsigned char c = (unsigned char)buf[0];
-  jsoff_t i = 0;
+  jsval_t bound_arr = get_slot(js, func_obj, SLOT_BOUND_ARGS);
+  int bound_argc = 0;
   
-  if (c < 128 && c != '\\' && is_ident_begin(c)) {
-    i = 1;
-    while (i < len) {
-      c = (unsigned char)buf[i];
-      if (c >= 128 || c == '\\') goto slow_path_continue;
-      if (!is_ident_continue(c)) break;
-      i++;
-    }
-    *tlen = i;
-    return parsekeyword(buf, i);
-  }
+  if (vtype(bound_arr) == T_ARR) {
+    bound_argc = (int)get_array_length(js, bound_arr);
+  } if (bound_argc <= 0) return NULL;
   
-  if (c == '\\') {
-    uint32_t first_cp;
-    int esc_len = parse_unicode_escape(buf, len, 0, &first_cp);
-    if (esc_len <= 0 || !is_unicode_ident_begin(first_cp)) return TOK_ERR;
-    *tlen = esc_len;
-    goto slow_path_loop;
-  }
+  *out_nargs = bound_argc + nargs;
+  jsval_t *combined = (jsval_t *)ant_calloc(sizeof(jsval_t) * (*out_nargs));
+  if (!combined) return NULL;
   
-  if (c >= 128) {
-    if ((c & 0xC0) == 0x80) return TOK_ERR;
-    int ws_len = is_unicode_space((const unsigned char *)buf, len, NULL);
-    if (ws_len > 0) return TOK_ERR;
-    i = 1;
-    while (i < len && ((unsigned char)buf[i] & 0xC0) == 0x80) i++;
-    *tlen = i;
-    goto slow_path_loop;
-  }
+  for (int i = 0; i < bound_argc; i++) combined[i] = arr_get(js, bound_arr, (jsoff_t)i);
+  for (int i = 0; i < nargs; i++) combined[bound_argc + i] = args[i];
   
-  return TOK_ERR;
+  return combined;
+}
 
-slow_path_continue:
-  *tlen = i;
-  
-slow_path_loop:;
-  int has_escapes = (buf[0] == '\\');
+static jsoff_t lkp_with_getter(ant_t *js, jsval_t obj, const char *buf, size_t len, jsval_t *getter_out, bool *has_getter_out) {
+  *has_getter_out = false;
+  *getter_out = js_mkundef();
   
-  while (*tlen < len) {
-    c = (unsigned char)buf[*tlen];
+  for (jsval_t current = obj; is_object_type(current); ) {
+    current = js_as_obj(current);
+    jsoff_t current_off = (jsoff_t)vdata(current);
+    descriptor_entry_t *desc = lookup_descriptor(js, current_off, buf, len);
     
-    if (c == '\\') {
-      uint32_t cp;
-      int el = parse_unicode_escape(buf, len, *tlen, &cp);
-      if (el <= 0 || !is_unicode_ident_continue(cp)) break;
-      *tlen += el;
-      has_escapes = 1;
-    } else if (c < 128) {
-      if (!is_ident_continue(c)) break;
-      (*tlen)++;
-    } else {
-      if ((c & 0xC0) == 0x80) break;
-      int ws_len = is_unicode_space((const unsigned char *)&buf[*tlen], len - *tlen, NULL);
-      if (ws_len > 0) break;
-      (*tlen)++;
-      while (*tlen < len && ((unsigned char)buf[*tlen] & 0xC0) == 0x80) (*tlen)++;
+    if (desc && desc->has_getter) {
+      *getter_out = desc->getter;
+      *has_getter_out = true;
+      return current_off;
     }
+    
+    jsoff_t prop_off = lkp_interned(js, current, intern_string(buf, len), len);
+    if (prop_off != 0) return prop_off;
+    
+    jsval_t proto = get_proto(js, current);
+    if (!is_object_type(proto)) break;
+    current = proto;
   }
   
-  if (has_escapes) {
-    char decoded[256];
-    size_t decoded_len = decode_ident_escapes(buf, *tlen, decoded, sizeof(decoded));
-    return parsekeyword(decoded, decoded_len);
+  return 0;
+}
+
+static jsoff_t lkp_with_setter(ant_t *js, jsval_t obj, const char *buf, size_t len, jsval_t *setter_out, bool *has_setter_out) {
+  *has_setter_out = false;
+  *setter_out = js_mkundef();
+  
+  jsval_t current = obj;
+  while (vtype(current) == T_OBJ || vtype(current) == T_FUNC) {
+    current = js_as_obj(current);
+    jsoff_t current_off = (jsoff_t)vdata(current);
+    descriptor_entry_t *desc = lookup_descriptor(js, current_off, buf, len);
+    
+    if (desc && desc->has_setter) {
+      *setter_out = desc->setter;
+      *has_setter_out = true;
+      return current_off;
+    }
+    
+    jsoff_t prop_off = lkp_interned(js, current, intern_string(buf, len), len);
+    if (prop_off != 0) return prop_off;
+    
+    jsval_t proto = get_proto(js, current);
+    if (vtype(proto) != T_OBJ && vtype(proto) != T_FUNC) break;
+    current = proto;
   }
   
-  return parsekeyword(buf, *tlen);
+  return 0;
 }
 
-static inline jsoff_t parse_decimal(const char *buf, jsoff_t maxlen, double *out) {
-  uint64_t int_part = 0, frac_part = 0;
-  int frac_digits = 0;
-  jsoff_t i = 0;
-
-  while (i < maxlen && (IS_DIGIT(buf[i]) || buf[i] == '_')) {
-    if (buf[i] != '_') int_part = int_part * 10 + (buf[i] - '0');
-    i++;
+static jsval_t call_proto_accessor(ant_t *js, jsval_t prim, jsval_t accessor, bool has_accessor, jsval_t *arg, int arg_count, bool is_setter) {
+  if (!has_accessor || (vtype(accessor) != T_FUNC && vtype(accessor) != T_CFUNC)) return js_mkundef();
+  
+  js_error_site_t saved_errsite = js->errsite;
+  jsval_t result = sv_vm_call(js->vm, js, accessor, prim, arg, arg_count, NULL, false);
+  
+  bool had_throw = js->thrown_exists;
+  jsval_t thrown = js->thrown_value;
+  js->errsite = saved_errsite;
+  
+  if (had_throw) {
+    js->thrown_exists = true;
+    js->thrown_value = thrown;
   }
+  
+  if (is_setter) return is_err(result) ? result : (arg ? *arg : js_mkundef());
+  return result;
+}
 
-  if (i < maxlen && buf[i] == '.') {
-    i++;
-    while (i < maxlen && (IS_DIGIT(buf[i]) || buf[i] == '_')) {
-      if (buf[i] != '_') { frac_part = frac_part * 10 + (buf[i] - '0'); frac_digits++; }
-      i++;
-    }
-  }
+jsval_t js_get_proto(ant_t *js, jsval_t obj) {
+  uint8_t t = vtype(obj);
 
-  static const double neg_pow10[] = {
-    1e0,1e-1,1e-2,1e-3,1e-4,1e-5,1e-6,1e-7,1e-8,1e-9,1e-10,
-    1e-11,1e-12,1e-13,1e-14,1e-15,1e-16,1e-17,1e-18,1e-19,1e-20
-  };
+  if (!is_object_type(obj)) return js_mknull();
+  jsval_t as_obj = js_as_obj(obj);
   
-  static const double pos_pow10[] = {
-    1e0,1e1,1e2,1e3,1e4,1e5,1e6,1e7,1e8,1e9,1e10,
-    1e11,1e12,1e13,1e14,1e15,1e16,1e17,1e18,1e19,1e20
-  };
+  jsval_t proto = get_slot(js, as_obj, SLOT_PROTO);
+  if (is_object_type(proto)) return proto;
+  
+  if (t != T_OBJ) return get_prototype_for_type(js, t);
+  return js_mknull();
+}
 
-  double val = (double)int_part;
-  if (frac_digits > 0) {
-    val += (frac_digits <= 20) 
-      ? (double)frac_part * neg_pow10[frac_digits] 
-      : (double)frac_part * pow(10.0, -frac_digits);
-  }
+static jsval_t get_proto(ant_t *js, jsval_t obj) {
+  return js_get_proto(js, obj);
+}
 
-  if (i < maxlen && (buf[i] == 'e' || buf[i] == 'E')) {
-    i++;
-    int exp_sign = 1, exp_val = 0;
-    if (i < maxlen && (buf[i] == '+' || buf[i] == '-')) {
-      exp_sign = (buf[i] == '-') ? -1 : 1;
-      i++;
-    }
-    while (i < maxlen && (IS_DIGIT(buf[i]) || buf[i] == '_')) {
-      if (buf[i] != '_') exp_val = exp_val * 10 + (buf[i] - '0');
-      i++;
-    }
-    if (exp_val <= 20) {
-      val = (exp_sign > 0) ? val * pos_pow10[exp_val] : val * neg_pow10[exp_val];
-    } else val *= pow(10.0, exp_sign * exp_val);
-  }
+void js_set_proto(ant_t *js, jsval_t obj, jsval_t proto) {
+  if (!is_object_type(obj)) return;
+  
+  jsval_t as_obj = js_as_obj(obj);
+  set_slot(js, as_obj, SLOT_PROTO, proto);
+}
 
-  *out = val;
-  return i;
+static void set_proto(ant_t *js, jsval_t obj, jsval_t proto) {
+  js_set_proto(js, obj, proto);
 }
 
-static inline jsoff_t parse_binary(const char *buf, jsoff_t maxlen, double *out) {
-  double val = 0;
-  jsoff_t i = 2;
-  while (i < maxlen && (buf[i] == '0' || buf[i] == '1' || buf[i] == '_')) {
-    if (buf[i] != '_') val = val * 2 + (buf[i] - '0');
-    i++;
-  }
-  *out = val;
-  return i;
+jsval_t js_get_ctor_proto(ant_t *js, const char *name, size_t len) {
+  jsoff_t ctor_off = lkp_interned(js, js->global, intern_string(name, len), len);
+  if (ctor_off == 0) return js_mknull();
+  jsval_t ctor = resolveprop(js, mkval(T_PROP, ctor_off));
+  if (vtype(ctor) != T_FUNC) return js_mknull();
+  jsval_t ctor_obj = js_as_obj(ctor);
+  jsoff_t proto_off = lkp_interned(js, ctor_obj, INTERN_PROTOTYPE, 9);
+  if (proto_off == 0) return js_mknull();
+  return resolveprop(js, mkval(T_PROP, proto_off));
 }
 
-static inline jsoff_t parse_octal(const char *buf, jsoff_t maxlen, double *out) {
-  double val = 0;
-  jsoff_t i = 2;
-  while (i < maxlen && (IS_OCTAL(buf[i]) || buf[i] == '_')) {
-    if (buf[i] != '_') val = val * 8 + (buf[i] - '0');
-    i++;
-  }
-  *out = val;
-  return i;
+static inline jsval_t get_ctor_proto(ant_t *js, const char *name, size_t len) {
+  return js_get_ctor_proto(js, name, len);
 }
 
-static inline jsoff_t parse_legacy_octal(const char *buf, jsoff_t maxlen, double *out) {
-  double val = 0;
-  jsoff_t i = 1;
-  while (i < maxlen && IS_OCTAL(buf[i])) {
-      val = val * 8 + (buf[i] - '0');
-      i++;
+static jsval_t get_prototype_for_type(ant_t *js, uint8_t type) {
+switch (type) {
+  case T_STR:     return get_ctor_proto(js, "String", 6);
+  case T_NUM:     return get_ctor_proto(js, "Number", 6);
+  case T_BOOL:    return get_ctor_proto(js, "Boolean", 7);
+  case T_ARR:     return get_ctor_proto(js, "Array", 5);
+  case T_FUNC:    return get_ctor_proto(js, "Function", 8);
+  case T_PROMISE: return get_ctor_proto(js, "Promise", 7);
+  case T_OBJ:     return get_ctor_proto(js, "Object", 6);
+  case T_BIGINT:  return get_ctor_proto(js, "BigInt", 6);
+  case T_SYMBOL:  return get_ctor_proto(js, "Symbol", 6);
+  default:        return js_mknull();
+}}
+
+jsoff_t lkp_proto(ant_t *js, jsval_t obj, const char *key, size_t len) {
+  uint8_t t = vtype(obj);
+  const char *key_intern = intern_string(key, len);
+  if (!key_intern) return 0;
+
+  jsval_t cur = obj;
+  int depth = 0;
+  
+  while (depth < MAX_PROTO_CHAIN_DEPTH) {
+    if (t == T_OBJ || t == T_ARR || t == T_FUNC || t == T_PROMISE) {
+      jsval_t as_obj = js_as_obj(cur);
+      jsoff_t off = lkp_interned(js, as_obj, key_intern, len);
+      if (off != 0) return off;
+    } else if (t == T_CFUNC) {
+      jsval_t func_proto = get_ctor_proto(js, "Function", 8);
+      uint8_t ft = vtype(func_proto);
+      if (ft == T_OBJ || ft == T_ARR || ft == T_FUNC) {
+        jsoff_t off = lkp(js, js_as_obj(func_proto), key, len);
+        if (off != 0) return off;
+      }
+      break;
+    } else if (t != T_STR && t != T_NUM && t != T_BOOL && t != T_BIGINT && t != T_SYMBOL) break;
+    if (!proto_walk_next(js, &cur, &t, PROTO_WALK_F_LOOKUP)) { break; } depth++;
   }
-  *out = val;
-  return i;
+  
+  return 0;
 }
 
-static inline jsoff_t parse_hex(const char *buf, jsoff_t maxlen, double *out) {
-  double val = 0;
-  jsoff_t i = 2;
-  while (i < maxlen && (IS_XDIGIT(buf[i]) || buf[i] == '_')) {
-    if (buf[i] != '_') {
-      int d = 
-        (buf[i] >= 'a') ? (buf[i] - 'a' + 10) :
-        (buf[i] >= 'A') ? (buf[i] - 'A' + 10) : (buf[i] - '0');
-      val = val * 16 + d;
-    } i++;
+static jsval_t getprop_any(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
+  uint8_t t = vtype(obj);
+  
+  if (t == T_STR && key_len == 6 && memcmp(key, "length", 6) == 0) {
+    jsoff_t byte_len;
+    jsoff_t str_off = vstr(js, obj, &byte_len);
+    return tov(D(utf16_strlen((const char *)&js->mem[str_off], byte_len)));
   }
-  *out = val;
-  return i;
-}
-
-static inline uint8_t parse_number(struct js *js, const char *buf, jsoff_t remaining) {
-  double value = 0;
-  jsoff_t numlen = 0;
-  
-  if (buf[0] == '0' && remaining > 1) {
-    char c1 = buf[1] | 0x20; 
-    if (c1 == 'b') {
-      numlen = parse_binary(buf, remaining, &value);
-    } else if (c1 == 'o') {
-      numlen = parse_octal(buf, remaining, &value);
-    } else if (c1 == 'x') {
-      numlen = parse_hex(buf, remaining, &value);
-    } else if (IS_OCTAL(buf[1])) {
-        if (js->flags & F_STRICT) {
-          js->tok = TOK_ERR;
-          js->tlen = 1;
-          return TOK_ERR;
-        }
-        numlen = parse_legacy_octal(buf, remaining, &value);
-    } else if (is_digit(buf[1]) && (js->flags & F_STRICT)) {
-        js->tok = TOK_ERR;
-        js->tlen = 1;
-        return TOK_ERR;
-    } else numlen = parse_decimal(buf, remaining, &value);
-  } else numlen = parse_decimal(buf, remaining, &value);
-  
-  js->tval = tov(value);
-  if (numlen < remaining && buf[numlen] == 'n') {
-    js->tok = TOK_BIGINT;
-    js->tlen = numlen + 1;
-  } else {
-    js->tok = TOK_NUMBER;
-    js->tlen = numlen;
+  
+  if (t == T_STR || t == T_NUM || t == T_BOOL || t == T_BIGINT) {
+    jsoff_t off = lkp_proto(js, obj, key, key_len);
+    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
+    return js_mkundef();
+  }
+  
+  if (t == T_OBJ || t == T_ARR || t == T_FUNC) {
+    jsval_t as_obj = js_as_obj(obj);
+    jsoff_t off = lkp(js, as_obj, key, key_len);
+    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
+    off = lkp_proto(js, obj, key, key_len);
+    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
   }
   
-  return js->tok;
+  return js_mkundef();
 }
 
-static inline uint8_t scan_string(struct js *js, const char *buf, jsoff_t rem, char quote) {
-  jsoff_t i = 1;
-
-  while (i < rem) {
-    const char *p = buf + i;
-    jsoff_t search_len = rem - i;
-
-    const char *q = memchr(p, quote, search_len);
-    const char *b = memchr(p, '\\', search_len);
-
-    if (q == NULL) {
-      js->tok = TOK_ERR;
-      js->tlen = rem;
-      return TOK_ERR;
-    }
-
-    if (b == NULL || q < b) {
-      i = (jsoff_t)((q - buf) + 1);
-      js->tok = TOK_STRING;
-      js->tlen = i;
-      return TOK_STRING;
-    }
-
-    jsoff_t esc_pos = (jsoff_t)(b - buf);
-    if (esc_pos + 1 >= rem) {
-      js->tok = TOK_ERR;
-      js->tlen = rem;
-      return TOK_ERR;
-    }
+static jsval_t try_dynamic_getter(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
+  dynamic_accessors_t *entry = NULL;
+  HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
+  if (!entry || !entry->getter) return js_mkundef();
+  return entry->getter(js, obj, key, key_len);
+}
 
-    char esc_char = buf[esc_pos + 1];
-    jsoff_t skip = 2;
+static bool try_dynamic_setter(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t value) {
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
+  dynamic_accessors_t *entry = NULL;
+  HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
+  if (!entry || !entry->setter) return false;
+  return entry->setter(js, obj, key, key_len, value);
+}
 
-    if (esc_char == 'x') { skip = 4; } else if (esc_char == 'u') {
-      skip = (esc_pos + 2 < rem && buf[esc_pos + 2] == '{') ? 0 : 6;
-      if (skip == 0) {
-        jsoff_t j = esc_pos + 3;
-        while (j < rem && buf[j] != '}') j++;
-        skip = (j < rem) ? (j - esc_pos + 1) : (rem - esc_pos);
-      }
-    }
+static bool try_dynamic_deleter(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
+  dynamic_accessors_t *entry = NULL;
+  HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
+  if (!entry || !entry->deleter) return false;
+  return entry->deleter(js, obj, key, key_len);
+}
 
-    if (esc_pos + skip > rem) {
-      js->tok = TOK_ERR;
-      js->tlen = rem;
-      return TOK_ERR;
-    }
+static bool try_accessor_getter(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t *out) {
+  jsval_t getter = js_mkundef();
+  bool has_getter = false;
+  lkp_with_getter(js, obj, key, key_len, &getter, &has_getter);
 
-    i = esc_pos + skip;
+  jsval_t result = call_proto_accessor(js, obj, getter, has_getter, NULL, 0, false);
+  if (vtype(result) != T_UNDEF) {
+    *out = result;
+    return true;
   }
-
-  js->tok = TOK_ERR;
-  js->tlen = rem;
-  return TOK_ERR;
+  return false;
 }
 
-static inline jsoff_t skip_string_literal(const char *buf, jsoff_t rem, jsoff_t start, char quote) {
-  jsoff_t i = start + 1;
-  while (i < rem) {
-    if (buf[i] == '\\') { i += 2; continue; }
-    if (buf[i] == quote) { return i + 1; } i++;
-  }
-  return rem;
-}
+static bool try_accessor_setter(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t val, jsval_t *out) {
+  jsval_t setter = js_mkundef();
+  bool has_setter = false;
+  
+  lkp_with_setter(js, obj, key, key_len, &setter, &has_setter);
+  if (!has_setter) return false;
 
-static inline jsoff_t skip_line_comment(const char *buf, jsoff_t rem, jsoff_t start) {
-  jsoff_t i = start + 2;
-  while (i < rem && buf[i] != '\n') i++;
-  return i;
+  jsval_t result = call_proto_accessor(js, obj, setter, has_setter, &val, 1, true);
+  if (is_err(result)) {
+    *out = result;
+    return true;
+  }
+  
+  *out = val;
+  return true;
 }
 
-static inline jsoff_t skip_block_comment(const char *buf, jsoff_t rem, jsoff_t start) {
-  jsoff_t i = start + 2;
-  while (i + 1 < rem && !(buf[i] == '*' && buf[i + 1] == '/')) i++;
-  return (i + 1 < rem) ? (i + 2) : rem;
+jsval_t resolveprop(ant_t *js, jsval_t v) {
+  if (vtype(v) != T_PROP) return v;
+  return resolveprop(js, loadval(js, (jsoff_t) (vdata(v) + sizeof(jsoff_t) * 2)));
 }
 
-static jsoff_t skip_template_literal(const char *buf, jsoff_t rem, jsoff_t start) {
-  jsoff_t i = start + 1;
-  int expr_depth = 0;
+typedef struct {
+  char *buffer;
+  size_t capacity;
+  size_t size;
+  bool is_dynamic;
+} string_builder_t;
 
-  while (i < rem) {
-    char c = buf[i];
+static void string_builder_init(string_builder_t *sb, char *static_buf, size_t static_cap) {
+  sb->buffer = static_buf;
+  sb->capacity = static_cap;
+  sb->size = 0;
+  sb->is_dynamic = false;
+}
 
-    if (c == '\\') {
-      i += 2;
-      continue;
-    }
-
-    if (expr_depth == 0) {
-      if (c == '`') return i + 1;
-      if (c == '$' && i + 1 < rem && buf[i + 1] == '{') {
-        expr_depth = 1;
-        i += 2;
-        continue;
-      } i++; continue;
-    }
-
-    if (c == '\'' || c == '"') {
-      i = skip_string_literal(buf, rem, i, c);
-      continue;
-    }
-
-    if (c == '`') {
-      jsoff_t next = skip_template_literal(buf, rem, i);
-      if (next <= i) return rem;
-      i = next; continue;
-    }
-
-    if (c == '/' && i + 1 < rem) {
-      if (buf[i + 1] == '/') { i = skip_line_comment(buf, rem, i); continue; }
-      if (buf[i + 1] == '*') { i = skip_block_comment(buf, rem, i); continue; }
-    }
-
-    if (c == '{') { expr_depth++; i++; continue; }
-    if (c == '}') { expr_depth--; i++; continue; }
-
-    i++;
-  }
-
-  return rem;
-}
-
-static inline uint8_t scan_template(struct js *js, const char *buf, jsoff_t rem) {
-  jsoff_t end = skip_template_literal(buf, rem, 0);
-  if (end <= 1 || end > rem) {
-    js->tok = TOK_ERR;
-    js->tlen = rem;
-    return TOK_ERR;
-  }
-
-  js->tok = TOK_TEMPLATE;
-  js->tlen = end;
-  return TOK_TEMPLATE;
-}
-
-static inline uint8_t parse_operator(struct js *js, const char *buf, jsoff_t rem) {
-  #define MATCH2(c1,c2)       (rem >= 2 && buf[1] == (c2))
-  #define MATCH3(c1,c2,c3)    (rem >= 3 && buf[1] == (c2) && buf[2] == (c3))
-  #define MATCH4(c1,c2,c3,c4) (rem >= 4 && buf[1]==(c2) && buf[2]==(c3) && buf[3]==(c4))
-
-  switch (buf[0]) {
-  case '?':
-    if (MATCH3('?','?','=')) { js->tok = TOK_NULLISH_ASSIGN; js->tlen = 3; }
-    else if (MATCH2('?','?')) { js->tok = TOK_NULLISH; js->tlen = 2; }
-    else if (MATCH2('?','.')) { js->tok = TOK_OPTIONAL_CHAIN; js->tlen = 2; }
-    else { js->tok = TOK_Q; js->tlen = 1; }
-    break;
-
-  case '!':
-    if (MATCH3('!','=','=')) { js->tok = TOK_SNE; js->tlen = 3; }
-    else if (MATCH2('!','=')) { js->tok = TOK_NE; js->tlen = 2; }
-    else { js->tok = TOK_NOT; js->tlen = 1; }
-    break;
-
-  case '=':
-    if (MATCH3('=','=','=')) { js->tok = TOK_SEQ; js->tlen = 3; }
-    else if (MATCH2('=','=')) { js->tok = TOK_EQ; js->tlen = 2; }
-    else if (MATCH2('=','>')) { js->tok = TOK_ARROW; js->tlen = 2; }
-    else { js->tok = TOK_ASSIGN; js->tlen = 1; }
-    break;
-
-  case '<':
-    if (MATCH3('<','<','=')) { js->tok = TOK_SHL_ASSIGN; js->tlen = 3; }
-    else if (MATCH2('<','<')) { js->tok = TOK_SHL; js->tlen = 2; }
-    else if (MATCH2('<','=')) { js->tok = TOK_LE; js->tlen = 2; }
-    else { js->tok = TOK_LT; js->tlen = 1; }
-    break;
-
-  case '>':
-    if (MATCH4('>','>','>','=')) { js->tok = TOK_ZSHR_ASSIGN; js->tlen = 4; }
-    else if (MATCH3('>','>','>')) { js->tok = TOK_ZSHR; js->tlen = 3; }
-    else if (MATCH3('>','>','=')) { js->tok = TOK_SHR_ASSIGN; js->tlen = 3; }
-    else if (MATCH2('>','>')) { js->tok = TOK_SHR; js->tlen = 2; }
-    else if (MATCH2('>','=')) { js->tok = TOK_GE; js->tlen = 2; }
-    else { js->tok = TOK_GT; js->tlen = 1; }
-    break;
-
-  case '&':
-    if (MATCH3('&','&','=')) { js->tok = TOK_LAND_ASSIGN; js->tlen = 3; }
-    else if (MATCH2('&','&')) { js->tok = TOK_LAND; js->tlen = 2; }
-    else if (MATCH2('&','=')) { js->tok = TOK_AND_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_AND; js->tlen = 1; }
-    break;
-
-  case '|':
-    if (MATCH3('|','|','=')) { js->tok = TOK_LOR_ASSIGN; js->tlen = 3; }
-    else if (MATCH2('|','|')) { js->tok = TOK_LOR; js->tlen = 2; }
-    else if (MATCH2('|','=')) { js->tok = TOK_OR_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_OR; js->tlen = 1; }
-    break;
-
-  case '+':
-    if (MATCH2('+','+')) { js->tok = TOK_POSTINC; js->tlen = 2; }
-    else if (MATCH2('+','=')) { js->tok = TOK_PLUS_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_PLUS; js->tlen = 1; }
-    break;
-
-  case '-':
-    if (MATCH2('-','-')) { js->tok = TOK_POSTDEC; js->tlen = 2; }
-    else if (MATCH2('-','=')) { js->tok = TOK_MINUS_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_MINUS; js->tlen = 1; }
-    break;
-
-  case '*':
-    if (MATCH2('*','*')) { js->tok = TOK_EXP; js->tlen = 2; }
-    else if (MATCH2('*','=')) { js->tok = TOK_MUL_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_MUL; js->tlen = 1; }
-    break;
-
-  case '/':
-    if (MATCH2('/','=')) { js->tok = TOK_DIV_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_DIV; js->tlen = 1; }
-    break;
-
-  case '%':
-    if (MATCH2('%','=')) { js->tok = TOK_REM_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_REM; js->tlen = 1; }
-    break;
-
-  case '^':
-    if (MATCH2('^','=')) { js->tok = TOK_XOR_ASSIGN; js->tlen = 2; }
-    else { js->tok = TOK_XOR; js->tlen = 1; }
-    break;
-
-  case '.':
-    if (MATCH3('.','.', '.')) { js->tok = TOK_REST; js->tlen = 3; }
-    else if (rem > 1 && IS_DIGIT(buf[1])) {
-      double val;
-      js->tlen = parse_decimal(buf, rem, &val);
-      js->tval = tov(val);
-      js->tok = TOK_NUMBER;
-    }
-    else { js->tok = TOK_DOT; js->tlen = 1; }
-    break;
-
-  default:
-    return 0;
-  }
-
-  #undef MATCH2
-  #undef MATCH3
-  #undef MATCH4
-
-  return js->tok;
-}
-
-static token_stream_t *token_stream_create(void) {
-  token_stream_t *ts = (token_stream_t *)malloc(sizeof(token_stream_t));
-  if (!ts) return NULL;
-  ts->capacity = 64;
-  ts->tokens = (cached_token_t *)malloc(ts->capacity * sizeof(cached_token_t));
-  if (!ts->tokens) { free(ts); return NULL; }
-  ts->count = 0;
-  return ts;
-}
-
-static bool token_stream_push(token_stream_t *ts, struct js *js) {
-  if (ts->count >= ts->capacity) {
-    int new_cap = ts->capacity * 2;
-    cached_token_t *new_tokens = (cached_token_t *)realloc(ts->tokens, new_cap * sizeof(cached_token_t));
-    if (!new_tokens) return false;
-    ts->tokens = new_tokens;
-    ts->capacity = new_cap;
+static bool string_builder_append(string_builder_t *sb, const char *data, size_t len) {
+  if (sb->size + len > sb->capacity) {
+    size_t new_capacity = sb->capacity ? sb->capacity * 2 : 256;
+    while (new_capacity < sb->size + len) new_capacity *= 2;
+    
+    char *new_buffer = (char *)ant_calloc(new_capacity);
+    if (!new_buffer) return false;
+    
+    if (sb->size > 0) memcpy(new_buffer, sb->buffer, sb->size);
+    if (sb->is_dynamic) free(sb->buffer);
+    
+    sb->buffer = new_buffer;
+    sb->capacity = new_capacity;
+    sb->is_dynamic = true;
   }
-  cached_token_t *ct = &ts->tokens[ts->count++];
-  ct->tok = js->tok;
-  ct->had_newline = js->had_newline ? 1 : 0;
-  ct->toff = js->toff;
-  ct->tlen = js->tlen;
-  ct->pos = js->pos;
-  ct->tval = js->tval;
-  return true;
-}
-
-static inline bool token_stream_next(struct js *js) {
-  token_stream_t *ts = (token_stream_t *)js->token_stream;
-  if (js->token_stream_pos >= ts->count) {
-    js->tok = TOK_EOF;
-    return false;
+  
+  if (len > 0) {
+    memcpy(sb->buffer + sb->size, data, len);
+    sb->size += len;
   }
-  cached_token_t *ct = &ts->tokens[js->token_stream_pos++];
-  js->tok = ct->tok;
-  js->had_newline = ct->had_newline;
-  js->toff = ct->toff;
-  js->tlen = ct->tlen;
-  js->pos = ct->pos;
-  js->tval = ct->tval;
+  
   return true;
 }
 
-static inline void token_stream_sync_pos(struct js *js) {
-  if (!js->token_stream || js->code != js->token_stream_code) return;
-  token_stream_t *ts = (token_stream_t *)js->token_stream;
-  jsoff_t target = js->pos;
-  
-  int lo = 0, hi = ts->count;
-  while (lo < hi) {
-    int mid = lo + (hi - lo) / 2;
-    if (ts->tokens[mid].toff < target) lo = mid + 1;
-    else hi = mid;
-  }
-  js->token_stream_pos = lo;
+static jsval_t string_builder_finalize(ant_t *js, string_builder_t *sb) {
+  jsval_t result = js_mkstr(js, sb->buffer, sb->size);
+  if (sb->is_dynamic && sb->buffer) free(sb->buffer);
+  return result;
 }
 
-static token_stream_t *tokenize_body(struct js *js, const char *code, jsoff_t len) {
-  token_stream_t *ts = token_stream_create();
-  if (!ts) return NULL;
-  
-  const char *saved_code = js->code;
-  jsoff_t saved_clen = js->clen;
-  jsoff_t saved_pos = js->pos;
-  uint8_t saved_tok = js->tok;
-  uint8_t saved_consumed = js->consumed;
-  
-  js->code = code;
-  js->clen = len;
-  js->pos = 0;
-  js->consumed = 1;
-  
-  while (next_raw(js) != TOK_EOF) {
-    if (!token_stream_push(ts, js)) {
-      free(ts->tokens);
-      free(ts);
-      ts = NULL;
-      break;
-    }
-    js->consumed = 1;
-  }
-  
-  if (ts) {
-    cached_token_t eof_tok = {
-      .tok = TOK_EOF,
-      .had_newline = 0,
-      .toff = len,
-      .tlen = 0,
-      .pos = len,
-      .tval = 0
-    };
-    if (ts->count < ts->capacity || 
-        (ts->count >= ts->capacity && 
-         (ts->tokens = realloc(ts->tokens, (ts->capacity + 1) * sizeof(cached_token_t))) != NULL)) {
-      ts->tokens[ts->count++] = eof_tok;
-    }
-  }
-  
-  js->code = saved_code;
-  js->clen = saved_clen;
-  js->pos = saved_pos;
-  js->tok = saved_tok;
-  js->consumed = saved_consumed;
-  
-  return ts;
+jsoff_t str_len_fast(ant_t *js, jsval_t str) {
+  if (vtype(str) != T_STR) return 0;
+  if (is_rope(js, str)) return rope_len(js, str);
+  return assert_flat_string_len(js, str, NULL);
 }
 
-static uint8_t next_raw(struct js *js) {
-  if (likely(js->consumed == 0)) return js->tok;
-
-  js->consumed = 0;
-  js->tok = TOK_ERR;
-  js->toff = js->pos = skiptonext(js->code, js->clen, js->pos, &js->had_newline);
-  js->tlen = 0;
-
-  if (unlikely(js->toff >= js->clen)) {
-    js->tok = TOK_EOF;
-    return TOK_EOF;
-  }
-
-  const char *buf = js->code + js->toff;
-  jsoff_t rem = js->clen - js->toff;
-  uint8_t c = (uint8_t)buf[0];
-
-  if (likely(c < 128)) {
-    uint8_t simple_tok = single_char_tok[c];
-    if (simple_tok != 0) {
-      js->tok = simple_tok;
-      js->tlen = 1;
-      js->pos = js->toff + 1;
-      return simple_tok;
+jsval_t do_string_op(ant_t *js, uint8_t op, jsval_t l, jsval_t r) {
+  if (op == TOK_PLUS) {
+    jsoff_t n1 = str_len_fast(js, l);
+    jsoff_t n2 = str_len_fast(js, r);
+    jsoff_t total_len = n1 + n2;
+    
+    if (n2 == 0) return l;
+    if (n1 == 0) return r;
+    
+    uint8_t left_depth = (vtype(l) == T_STR && is_rope(js, l)) ? rope_depth(js, l) : 0;
+    uint8_t right_depth = (vtype(r) == T_STR && is_rope(js, r)) ? rope_depth(js, r) : 0;
+    uint8_t new_depth = (left_depth > right_depth ? left_depth : right_depth) + 1;
+    
+    if (new_depth >= ROPE_MAX_DEPTH || total_len >= ROPE_FLATTEN_THRESHOLD) {
+      jsval_t flat_l = l, flat_r = r;
+      if (is_rope(js, l)) flat_l = rope_flatten(js, l);
+      if (is_err(flat_l)) return flat_l;
+      if (is_rope(js, r)) flat_r = rope_flatten(js, r);
+      if (is_err(flat_r)) return flat_r;
+      
+      jsoff_t off1, off2, len1, len2;
+      off1 = vstr(js, flat_l, &len1);
+      off2 = vstr(js, flat_r, &len2);
+      
+      string_builder_t sb;
+      char static_buffer[512];
+      string_builder_init(&sb, static_buffer, sizeof(static_buffer));
+      
+      if (
+        !string_builder_append(&sb, (char *)&js->mem[off1], len1) ||
+        !string_builder_append(&sb, (char *)&js->mem[off2], len2)
+      ) return js_mkerr(js, "string concatenation failed");
+      
+      return string_builder_finalize(js, &sb);
     }
+    
+    return js_mkrope(js, l, r, total_len, new_depth);
   }
-
-  if (likely(IS_IDENT1(c))) {
-    js->tok = parseident(buf, rem, &js->tlen);
-    js->pos = js->toff + js->tlen;
-    return js->tok;
-  }
-
-  if (IS_DIGIT(c)) {
-    parse_number(js, buf, rem);
-    if (js->tlen == 0) js->tlen = 1;
-    js->pos = js->toff + js->tlen;
-    return js->tok;
-  }
-
-  if (c == '"' || c == '\'') {
-    scan_string(js, buf, rem, c);
-    if (js->tlen == 0) js->tlen = 1;
-    js->pos = js->toff + js->tlen;
-    return js->tok;
-  }
-
-  if (c == '`') {
-    scan_template(js, buf, rem);
-    if (js->tlen == 0) js->tlen = 1;
-    js->pos = js->toff + js->tlen;
-    return js->tok;
-  }
-
-  if (parse_operator(js, buf, rem)) {
-    if (js->tlen == 0) js->tlen = 1;
-    js->pos = js->toff + js->tlen;
-    return js->tok;
-  }
-
-  js->tok = parseident(buf, rem, &js->tlen);
-  if (js->tlen == 0) js->tlen = 1;
-  js->pos = js->toff + js->tlen;
   
-  return js->tok;
-}
-
-static uint8_t next(struct js *js) {
-  if (likely(js->consumed == 0)) return js->tok;
+  jsoff_t n1, off1 = vstr(js, l, &n1);
+  jsoff_t n2, off2 = vstr(js, r, &n2);
   
-  if (js->token_stream && js->code == js->token_stream_code) {
-    token_stream_t *ts = (token_stream_t *)js->token_stream;
-    int idx = js->token_stream_pos;
-    if (unlikely(idx > 0 && idx <= ts->count && js->pos != ts->tokens[idx - 1].pos)) {
-      token_stream_sync_pos(js);
+  if (op == TOK_EQ) {
+    bool eq = n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
+    return mkval(T_BOOL, eq ? 1 : 0);
+  } else if (op == TOK_NE) {
+    bool eq = n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
+    return mkval(T_BOOL, eq ? 0 : 1);
+  } else if (op == TOK_LT || op == TOK_LE || op == TOK_GT || op == TOK_GE) {
+    jsoff_t min_len = n1 < n2 ? n1 : n2;
+    int cmp = memcmp(&js->mem[off1], &js->mem[off2], min_len);
+    
+    if (cmp == 0) {
+      if (n1 == n2) {
+        return mkval(T_BOOL, (op == TOK_LE || op == TOK_GE) ? 1 : 0);
+      } else cmp = (n1 < n2) ? -1 : 1;
     }
-    js->consumed = 0;
-    token_stream_next(js);
-    return js->tok;
-  }
     
-  return next_raw(js);
+    switch (op) {
+      case TOK_LT: return mkval(T_BOOL, cmp < 0 ? 1 : 0);
+      case TOK_LE: return mkval(T_BOOL, cmp <= 0 ? 1 : 0);
+      case TOK_GT: return mkval(T_BOOL, cmp > 0 ? 1 : 0);
+      case TOK_GE: return mkval(T_BOOL, cmp >= 0 ? 1 : 0);
+      default:     return js_mkerr(js, "bad str op");
+    }
+  } else return js_mkerr(js, "bad str op");
 }
 
-static jsval_t validate_dynamic_function_source(struct js *js, const char *params_body, size_t params_body_len, bool is_async) {
-  #define DYN_FN_PREFIX_SYNC  "(function"
-  #define DYN_FN_PREFIX_ASYNC "(async function"
-  
-  const char *prefix = is_async 
-    ? DYN_FN_PREFIX_ASYNC 
-    : DYN_FN_PREFIX_SYNC;
-    
-  size_t prefix_len = strlen(prefix);
-  size_t wrapped_len = prefix_len + params_body_len + 2;
-  
-  char *wrapped = (char *) malloc(wrapped_len + 1);
-  if (!wrapped) return js_mkerr(js, "oom");
-
-  memcpy(wrapped, prefix, prefix_len);
-  memcpy(wrapped + prefix_len, params_body, params_body_len);
-  wrapped[prefix_len + params_body_len] = ')';
-  
-  wrapped[prefix_len + params_body_len + 1] = ';';
-  wrapped[wrapped_len] = '\0';
-
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  bool saved_had_newline = js->had_newline;
-  uint8_t saved_flags = js->flags;
 
-  js->flags = saved_flags | F_NOEXEC;
-  jsval_t parsed = js_eval(js, wrapped, wrapped_len);
-
-  JS_RESTORE_STATE(js, saved);
-  js->had_newline = saved_had_newline;
-  js->flags = saved_flags;
+typedef enum { ITER_CONTINUE, ITER_BREAK, ITER_ERROR } iter_action_t;
+typedef iter_action_t (*iter_callback_t)(ant_t *js, jsval_t value, void *ctx, jsval_t *out);
+static jsval_t iter_foreach(ant_t *js, jsval_t iterable, iter_callback_t cb, void *ctx);
 
-  free(wrapped);
-  return parsed;
-}
 
-static inline uint8_t lookahead(struct js *js) {
-  uint8_t old = js->tok, tok = 0;
-  uint8_t old_consumed = js->consumed;
-  
-  jsoff_t pos = js->pos;
-  jsoff_t toff = js->toff;
-  jsoff_t tlen = js->tlen;
-  
-  bool had_newline = js->had_newline;
-  int stream_pos = js->token_stream_pos;
+static bool js_try_call_method(ant_t *js, jsval_t obj, const char *method, size_t method_len, jsval_t *args, int nargs, jsval_t *out_result) {
+  jsval_t getter = js_mkundef(); bool has_getter = false;
+  jsoff_t off = lkp_with_getter(js, obj, method, method_len, &getter, &has_getter);
   
-  js->consumed = 1;
-  tok = next(js);
+  jsval_t fn;
+  if (has_getter) {
+    fn = call_proto_accessor(js, obj, getter, true, NULL, 0, false);
+    if (is_err(fn)) { *out_result = fn; return true; }
+  } else if (off != 0) {
+    fn = resolveprop(js, mkval(T_PROP, off));
+  } else return false;
   
-  js->pos = pos;
-  js->tok = old;
-  js->toff = toff;
-  js->tlen = tlen;
+  uint8_t ft = vtype(fn);
+  if (ft != T_FUNC && ft != T_CFUNC) return false;
   
-  js->had_newline = had_newline;
-  js->consumed = old_consumed;
-  js->token_stream_pos = stream_pos;
+  jsval_t saved_this = js->this_val;
+  js->this_val = obj;
   
-  return tok;
-}
-
-static bool is_typeof_bare_ident(struct js *js) {
-  jsoff_t pos = js->pos, toff = js->toff, tlen = js->tlen;
-  uint8_t tok = js->tok, consumed = js->consumed;
-  bool had_newline = js->had_newline;
-  int stream_pos = js->token_stream_pos;
+  jsval_t result;
+  if (ft == T_CFUNC) result = ((jsval_t (*)(ant_t *, jsval_t *, int))vdata(fn))(js, args, nargs);
+  else result = sv_vm_call(js->vm, js, fn, obj, args, nargs, NULL, false);
   
-  int depth = 0;
-  uint8_t t = next(js);
-  while (t == TOK_LPAREN) { js->consumed = 1; t = next(js); depth++; }
+  bool had_throw = js->thrown_exists;
+  jsval_t thrown = js->thrown_value;
   
-  bool bare = (t == TOK_IDENTIFIER);
-  if (bare) {
-    js->consumed = 1;
-    t = next(js);
-    while (depth > 0 && t == TOK_RPAREN) { js->consumed = 1; t = next(js); depth--; }
-    if (depth != 0 || t == TOK_DOT || t == TOK_LBRACKET || t == TOK_LPAREN || t == TOK_OPTIONAL_CHAIN) bare = false;
+  js->this_val = saved_this;
+  if (had_throw) {
+    js->thrown_exists = true;
+    js->thrown_value = thrown;
   }
   
-  js->pos = pos; js->toff = toff; js->tlen = tlen;
-  js->tok = tok; js->consumed = consumed; js->had_newline = had_newline;
-  js->token_stream_pos = stream_pos;
-  
-  return bare;
-}
-
-jsval_t js_mkscope(struct js *js) {
-  assert((js->flags & F_NOEXEC) == 0);
-  if (global_scope_stack == NULL) utarray_new(global_scope_stack, &jsoff_icd);
-  jsoff_t prev = (jsoff_t) vdata(js->scope);
-  utarray_push_back(global_scope_stack, &prev);
-  js->scope = mkobj(js, prev);
-  return js->scope;
+  *out_result = result;
+  return true;
 }
 
-void js_delscope(struct js *js) {
-  if (global_scope_stack && utarray_len(global_scope_stack) > 0) {
-    jsoff_t *prev = (jsoff_t *)utarray_back(global_scope_stack);
-    js->scope = mkval(T_OBJ, *prev);
-    utarray_pop_back(global_scope_stack);
-  } else js->scope = upper(js, js->scope);
+static jsval_t js_call_method(ant_t *js, jsval_t obj, const char *method, size_t method_len, jsval_t *args, int nargs) {
+  jsval_t result;
+  if (!js_try_call_method(js, obj, method, method_len, args, nargs, &result)) return js_mkundef();
+  return result;
 }
 
-static void mkscope(struct js *js) { (void)js_mkscope(js); }
-static void delscope(struct js *js) { (void)js_delscope(js); }
-
-static void for_let_push(struct js *js, const char *var_name, jsoff_t var_len, jsoff_t prop_off, jsval_t body_scope) {
-  if (js->for_let_stack_len >= js->for_let_stack_cap) {
-    int new_cap = js->for_let_stack_cap ? js->for_let_stack_cap * 2 : 4;
-    js->for_let_stack = realloc(js->for_let_stack, new_cap * sizeof(struct for_let_ctx));
-    js->for_let_stack_cap = new_cap;
+static jsval_t js_call_toString(ant_t *js, jsval_t value) {
+  jsval_t result = js_call_method(js, value, "toString", 8, NULL, 0);
+  
+  if (is_err(result)) return result;
+  if (vtype(result) == T_STR) return result;
+  
+  uint8_t rtype = vtype(result);
+  if (rtype == T_UNDEF) {
+    goto fallback;
   }
-  js->for_let_stack[js->for_let_stack_len++] = (struct for_let_ctx){var_name, var_len, prop_off, body_scope};
-}
-
-static inline void for_let_set_body_scope(struct js *js, jsval_t body_scope) {
-  if (js->for_let_stack_len > 0) js->for_let_stack[js->for_let_stack_len - 1].body_scope = body_scope;
+  
+  if (rtype != T_OBJ && rtype != T_ARR && rtype != T_FUNC) {
+    char buf[256];
+    size_t len = tostr(js, result, buf, sizeof(buf));
+    return js_mkstr(js, buf, len);
+  }
+  
+fallback:;
+  char buf[4096];
+  size_t len = tostr(js, value, buf, sizeof(buf));
+  return js_mkstr(js, buf, len);
 }
 
-static inline void for_let_pop(struct js *js) {
-  if (js->for_let_stack_len > 0) js->for_let_stack_len--;
+static jsval_t js_call_valueOf(ant_t *js, jsval_t value) {
+  jsval_t result = js_call_method(js, value, "valueOf", 7, NULL, 0);
+  if (vtype(result) == T_UNDEF) return value;
+  return result;
 }
 
-static inline struct for_let_ctx *for_let_current(struct js *js) {
-  return js->for_let_stack_len > 0 ? &js->for_let_stack[js->for_let_stack_len - 1] : NULL;
+static inline bool is_primitive(jsval_t v) {
+  uint8_t t = vtype(v);
+  return t == T_STR || t == T_NUM || t == T_BOOL || t == T_NULL || t == T_UNDEF || t == T_SYMBOL || t == T_BIGINT;
 }
 
-static void copy_body_scope_props(struct js *js, jsval_t body_scope, jsval_t closure_scope, const char *skip_var, jsoff_t skip_len) {
-  if (vtype(body_scope) != T_OBJ) return;
-  jsoff_t prop_off = loadoff(js, (jsoff_t)vdata(body_scope)) & ~(3U | FLAGMASK);
+static jsval_t try_exotic_to_primitive(ant_t *js, jsval_t value, int hint) {
+  jsval_t tp_sym = get_toPrimitive_sym();
+  if (vtype(tp_sym) != T_SYMBOL) return mkval(T_UNDEF, 0);
+  jsoff_t tp_off = lkp_sym_proto(js, value, (jsoff_t)vdata(tp_sym));
+  if (tp_off == 0) return mkval(T_UNDEF, 0);
   
-  while (prop_off < js->brk && prop_off != 0) {
-    jsoff_t header = loadoff(js, prop_off);
-    if (is_slot_prop(header)) { prop_off = next_prop(header); continue; }
-    
-    jsoff_t koff = loadoff(js, prop_off + (jsoff_t)sizeof(prop_off));
-    jsoff_t klen = offtolen(loadoff(js, koff));
-    const char *key = (char *)&js->mem[koff + sizeof(koff)];
-    jsval_t val = loadval(js, prop_off + (jsoff_t)(sizeof(prop_off) + sizeof(koff)));
-    
-    prop_off = next_prop(header);
-    if (is_internal_prop(key, klen)) continue;
-    if (skip_var && klen == skip_len && memcmp(key, skip_var, klen) == 0) continue;
-    
-    jsval_t key_str = js_mkstr(js, key, klen);
-    mkprop(js, closure_scope, key_str, val, 0);
+  jsval_t tp_fn = resolveprop(js, mkval(T_PROP, tp_off));
+  uint8_t ft = vtype(tp_fn);
+  
+  if (ft == T_UNDEF) return mkval(T_UNDEF, 0);
+  if (ft != T_FUNC && ft != T_CFUNC) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol.toPrimitive is not a function");
   }
+  
+  const char *hint_str = hint == 1 ? "string" : (hint == 2 ? "number" : "default");
+  jsval_t hint_arg = js_mkstr(js, hint_str, strlen(hint_str));
+  jsval_t result = sv_vm_call(js->vm, js, tp_fn, value, &hint_arg, 1, NULL, false);
+  
+  if (is_err(result) || is_primitive(result)) return result;
+  return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
 }
 
-static jsval_t for_let_capture_scope(struct js *js) {
-  struct for_let_ctx *flc = for_let_current(js);
-  if (!flc || flc->prop_off == 0) return js->scope;
-  
-  jsval_t loop_var_val = resolveprop(js, mkval(T_PROP, flc->prop_off));
-  jsval_t closure_scope = js_mkscope(js);
-  if (is_err(closure_scope)) return closure_scope;
+static jsval_t try_ordinary_to_primitive(ant_t *js, jsval_t value, int hint) {
+  static const char *names[] = {"valueOf", "toString"};
+  static const size_t lens[] = {7, 8};
   
-  jsval_t var_key = js_mkstr(js, flc->var_name, flc->var_len);
-  mkprop(js, closure_scope, var_key, loop_var_val, 0);
+  int first = (hint == 1); 
+  jsval_t result;
   
-  if (vtype(flc->body_scope) == T_OBJ) {
-    copy_body_scope_props(js, flc->body_scope, closure_scope, flc->var_name, flc->var_len);
+  for (int i = 0; i < 2; i++) {
+    int idx = first ^ i;
+    if (js_try_call_method(js, value, names[idx], lens[idx], NULL, 0, &result))
+      if (is_err(result) || is_primitive(result)) return result;
   }
-  delscope(js);
-  return closure_scope;
-}
-
-static void scope_clear_props(struct js *js, jsval_t scope) {
-  jsoff_t off = (jsoff_t)vdata(scope);
-  jsoff_t header = loadoff(js, off);
-  jsoff_t parent = loadoff(js, off + sizeof(jsoff_t));
   
-  saveoff(js, off, (header & FLAGMASK) | T_OBJ);
-  saveoff(js, off + sizeof(jsoff_t), parent);
-  saveoff(js, off + sizeof(jsoff_t) + sizeof(jsoff_t), 0);
+  return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
 }
 
-static bool block_needs_scope(struct js *js) {
-  jsoff_t pos = js->pos, toff = js->toff, tlen = js->tlen;
-  uint8_t tok = js->tok, consumed = js->consumed;
-  bool had_newline = js->had_newline;
-  int stream_pos = js->token_stream_pos;
-  
-  bool needs = false;
-  int depth = 1;
-  js->consumed = 1;
-  
-  while (depth > 0) {
-    uint8_t t = next(js);
-    if (t == TOK_EOF) break;
-    if (t == TOK_LBRACE) { depth++; js->consumed = 1; continue; }
-    if (t == TOK_RBRACE) { depth--; js->consumed = 1; continue; }
-    
-    if (depth == 1 && (
-      t == TOK_LET ||
-      t == TOK_CONST ||
-      t == TOK_CLASS ||
-      t == TOK_FUNC
-    )) { needs = true; break; }
-    
-    js->consumed = 1;
-  }
+jsval_t js_to_primitive(ant_t *js, jsval_t value, int hint) {
+  if (is_primitive(value)) return value;
+  if (!is_object_type(value)) return value;
   
-  js->pos = pos; js->toff = toff; js->tlen = tlen;
-  js->tok = tok; js->consumed = consumed; js->had_newline = had_newline;
-  js->token_stream_pos = stream_pos;
+  jsval_t result = try_exotic_to_primitive(js, value, hint);
+  if (vtype(result) != T_UNDEF) return result;
   
-  return needs;
+  return try_ordinary_to_primitive(js, value, hint);
 }
 
-static inline bool push_this(jsval_t this_value) {
-  if (global_this_stack.depth >= global_this_stack.capacity) {
-    int new_capacity = global_this_stack.capacity == 0 ? 16 : global_this_stack.capacity * 2;
-    jsval_t *new_stack = (jsval_t *) realloc(global_this_stack.stack, new_capacity * sizeof(jsval_t));
-    if (!new_stack) return false;
-    global_this_stack.stack = new_stack;
-    global_this_stack.capacity = new_capacity;
-  }
-  global_this_stack.stack[global_this_stack.depth++] = this_value;
-  return true;
-}
-
-static inline jsval_t pop_this() {
-  if (global_this_stack.depth > 0) {
-    return global_this_stack.stack[--global_this_stack.depth];
+bool strict_eq_values(ant_t *js, jsval_t l, jsval_t r) {
+  uint8_t t = vtype(l);
+  if (t != vtype(r)) return false;
+  if (t == T_STR) {
+    jsoff_t n1, n2, off1 = vstr(js, l, &n1), off2 = vstr(js, r, &n2);
+    return n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
   }
-  return js_mkundef();
+  if (t == T_NUM) return tod(l) == tod(r);
+  if (t == T_BIGINT) return bigint_compare(js, l, r) == 0;
+  return vdata(l) == vdata(r);
 }
 
-static inline jsval_t peek_this() {
-  if (global_this_stack.depth > 0) {
-    return global_this_stack.stack[global_this_stack.depth - 1];
+jsval_t coerce_to_str(ant_t *js, jsval_t v) {
+  if (vtype(v) == T_STR) return v;
+  
+  if (is_object_type(v)) {
+    jsval_t prim = js_to_primitive(js, v, 1);
+    if (is_err(prim)) return prim;
+    if (vtype(prim) == T_STR) return prim;
+    return js_tostring_val(js, prim);
   }
-  return js_mkundef();
+  
+  return js_tostring_val(js, v);
 }
 
-static jsval_t js_func_decl(struct js *js);
-static jsval_t js_func_decl_async(struct js *js);
-
-static void hoist_function_declarations(struct js *js) {
-  if (js->flags & F_NOEXEC) return;
-  if (js->is_hoisting) return;
+jsval_t coerce_to_str_concat(ant_t *js, jsval_t v) {
+  if (vtype(v) == T_STR) return v;
   
-  if (js->skip_func_hoist) return;
-  if (!code_has_function_decl(js->code + js->pos, js->clen - js->pos)) return;
+  if (is_object_type(v)) {
+    jsval_t prim = js_to_primitive(js, v, 0);
+    if (is_err(prim)) return prim;
+    if (vtype(prim) == T_STR) return prim;
+    return js_tostring_val(js, prim);
+  }
   
-  js->is_hoisting = true;
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  jsval_t saved_scope = js->scope;
+  return js_tostring_val(js, v);
+}
+
+static void unlink_prop(ant_t *js, jsoff_t obj_off, jsoff_t prop_off, jsoff_t prev_off) {
+  jsoff_t deleted_next = loadoff(js, prop_off) & ~FLAGMASK;
+  jsoff_t target = prev_off ? prev_off : obj_off;
+  jsoff_t current = loadoff(js, target);
   
-  int depth = 0;
-  uint8_t tok, prev_tok = TOK_EOF;
+  saveoff(js, target, (deleted_next & ~3ULL) | (current & (FLAGMASK | 3ULL)));
+  jsoff_t tail = loadoff(js, obj_off + sizeof(jsoff_t) + sizeof(jsoff_t));
   
-  while ((tok = next(js)) != TOK_EOF && !(tok == TOK_RBRACE && depth == 0)) {
-    if (tok == TOK_LBRACE) { depth++; prev_tok = tok; js->consumed = 1; continue; }
-    if (tok == TOK_RBRACE) { depth--; prev_tok = tok; js->consumed = 1; continue; }
-    if (depth > 0) { prev_tok = tok; js->consumed = 1; continue; }
-    
-    if (tok == TOK_EXPORT) {
-      js->consumed = 1;
-      uint8_t next_tok = next(js);
-      if (next_tok != TOK_FUNC && next_tok != TOK_ASYNC && next_tok != TOK_DEFAULT)
-        goto skip_export;
-      
-      int brace_depth = 0;
-      while (next(js) != TOK_EOF) {
-        if (js->tok == TOK_LBRACE) brace_depth++;
-        else if (js->tok == TOK_RBRACE && --brace_depth <= 0) break;
-        js->consumed = 1;
-      }
-      
-      skip_export: {
-        prev_tok = tok;
-        continue;
-      }
-    }
-    
-    if (depth == 0 && tok == TOK_FUNC) {
-      if (expr_context_tok[prev_tok]) {
-        prev_tok = tok;
-        js->consumed = 1;
-        continue;
-      }
-      
-      jsoff_t after_func = js->pos;
-      js->consumed = 1;
-      
-      if (next(js) == TOK_IDENTIFIER) {
-        js->pos = after_func;
-        js->tok = TOK_FUNC;
-        js->consumed = 1;
-        js_func_decl(js);
-      }
-      
-      prev_tok = tok;
-      continue;
-    }
-    
-    if (depth == 0 && tok == TOK_ASYNC) {
-      if (expr_context_tok[prev_tok]) {
-        prev_tok = tok;
-        js->consumed = 1;
-        continue;
-      }
-      
-      js->consumed = 1;
-      if (next(js) != TOK_FUNC) goto skip_async;
-      jsoff_t func_pos = js->pos;
-      js->consumed = 1;
-      if (next(js) != TOK_IDENTIFIER) goto skip_async;
-      js->pos = func_pos;
-      js->tok = TOK_FUNC;
-      js->consumed = 0;
-      js_func_decl_async(js);
-      
-      skip_async: {
-        prev_tok = tok;
-        continue;
-      }
-    }
-    
-    prev_tok = tok;
-    js->consumed = 1;
+  if (tail == prop_off) {
+    saveoff(js, obj_off + sizeof(jsoff_t) + sizeof(jsoff_t), prev_off);
   }
   
-  js->is_hoisting = false;
-  JS_RESTORE_STATE(js, saved);
-  js->scope = saved_scope;
+  invalidate_prop_cache(js, obj_off, prop_off);
+  js->needs_gc = true;
 }
 
-static void declare_hoisted_vars(struct js *js, jsval_t var_scope, const char *var_names) {
-  const char *ptr = var_names;
-  while (*ptr) {
-    size_t len = strlen(ptr);
-    jsoff_t existing = lkp(js, var_scope, ptr, len);
-    if (existing == 0) mkprop(js, var_scope, js_mkstr(js, ptr, len), js_mkundef(), 0);
-    ptr += len + 1;
+static jsval_t check_frozen_sealed(ant_t *js, jsval_t obj, const char *action) {
+  if (js_truthy(js, get_slot(js, obj, SLOT_FROZEN))) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot %s property of frozen object", action);
+    return js_false;
   }
+  if (js_truthy(js, get_slot(js, obj, SLOT_SEALED))) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr(js, "cannot %s property of sealed object", action);
+    return js_false;
+  }
+  return js_mkundef();
 }
 
-static void hoist_var_declarations_from_slot(struct js *js, jsval_t var_scope, jsval_t func_obj) {
-  jsval_t vars_val = get_slot(js, func_obj, SLOT_HOISTED_VARS);
-  if (vtype(vars_val) != T_CFUNC) return;
-  const char *var_names = (const char *)vdata(vars_val);
-  if (!var_names) return;
-  declare_hoisted_vars(js, var_scope, var_names);
-}
+jsval_t js_delete_prop(ant_t *js, jsval_t obj, const char *key, size_t len) {
+  obj = js_as_obj(obj);
+  if (is_proxy(js, obj)) {
+    jsval_t result = proxy_delete(js, obj, key, len);
+    return is_err(result) ? result : js_bool(js_truthy(js, result));
+  }
 
-static void hoist_var_declarations(struct js *js, jsval_t var_scope) {
-  if (js->flags & F_NOEXEC) return;
-  if (js->clen == 0) return;
-  if (!memmem(js->code, js->clen, "var", 3)) return;
-  
-  size_t buf_len;
-  char *var_names = OXC_get_hoisted_vars(js->code, (size_t)js->clen, &buf_len);
-  if (!var_names) return;
-  
-  declare_hoisted_vars(js, var_scope, var_names);
-  OXC_free_hoisted_vars(var_names, buf_len);
-}
+  jsval_t err = check_frozen_sealed(js, obj, "delete");
+  if (vtype(err) != T_UNDEF) return err;
 
-static jsval_t js_block(struct js *js, bool create_scope) {
-  jsval_t res = js_mkundef();
-  bool scope_created = false;
-  
-  if (create_scope && lookahead(js) != TOK_RBRACE && block_needs_scope(js)) {
-    mkscope(js);
-    scope_created = true;
-  }
-  
-  js->consumed = 1;
-  hoist_function_declarations(js);
-  
-  uint8_t peek;
-  while ((peek = next(js)) != TOK_EOF && peek != TOK_RBRACE && !is_err(res)) {
-    uint8_t t = js->tok;
-    res = js_stmt(js);
-    if (!is_err(res) && !is_block_tok(t) && !(js->had_newline || is_asi_ok_tok(js->tok))) {
-      res = js_mkerr_typed(js, JS_ERR_SYNTAX, "; expected"); break;
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(obj));
+
+  if (is_arr_off(js, obj_off)) {
+    jsoff_t doff = get_dense_buf_off(js, obj_off);
+    unsigned long del_idx;
+    if (doff && parse_array_index(key, len, dense_length(js, doff), &del_idx)) {
+      arr_del(js, mkval(T_ARR, (uint64_t)obj_off), (jsoff_t)del_idx);
+      return js_true;
     }
-    if (js->flags & (F_RETURN | F_THROW)) break;
   }
-  
-  if (js->tok == TOK_RBRACE) js->consumed = 1;
-  if (scope_created) delscope(js);
-  
-  return res;
-}
 
-static inline jsoff_t lkp_interned(struct js *js, jsval_t obj, const char *search_intern, size_t len) {
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
-  jsoff_t tail = loadoff(js, obj_off + sizeof(jsoff_t) * 2);
-  
-  uint32_t slot = (((uintptr_t)search_intern >> 3) ^ obj_off) & (ANT_LIMIT_SIZE_CACHE - 1);
-  intern_prop_cache_entry_t *ce = &intern_prop_cache[slot];
-  
-  if (ce->generation == intern_prop_cache_gen 
-    && ce->obj_off == obj_off 
-    && ce->intern_ptr == search_intern
-    && ce->tail == tail
-  ) return ce->prop_off;
-  
+  jsoff_t prop_off = lkp(js, obj, key, len);
+  if (prop_off == 0) {
+    try_dynamic_deleter(js, obj, key, len);
+    return js_true;
+  }
+
+  if (is_nonconfig_prop(js, prop_off)) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
+    return js_false;
+  }
+
+  descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key, len);
+  if (desc && !desc->configurable) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
+    return js_false;
+  }
+
   jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
-  jsoff_t off = first_prop; jsoff_t result = 0;
-  
-  while (off < js->brk && off != 0) {
-    jsoff_t header = loadoff(js, off);
-    if (is_slot_prop(header)) { off = next_prop(header); continue; }
-    
-    jsoff_t koff = loadoff(js, off + sizeof(jsoff_t));
-    jsoff_t klen = (loadoff(js, koff) >> 3) - 1;
-    
-    if (klen == len) {
-      const char *p = (char *)&js->mem[koff + sizeof(jsoff_t)];
-      if (intern_string(p, klen) == search_intern) { result = off; break; }
+  if (first_prop == prop_off) {
+    unlink_prop(js, obj_off, prop_off, 0);
+    return js_true;
+  }
+  for (jsoff_t prev = first_prop; prev != 0; ) {
+    jsoff_t next_prop = loadoff(js, prev) & ~(3U | FLAGMASK);
+    if (next_prop == prop_off) {
+      unlink_prop(js, obj_off, prop_off, prev);
+      return js_true;
     }
-    off = next_prop(header);
+    prev = next_prop;
   }
-  
-  ce->generation = intern_prop_cache_gen;
-  ce->obj_off = obj_off;
-  ce->intern_ptr = search_intern;
-  ce->prop_off = result;
-  ce->tail = tail;
-  
-  return result;
-}
-
-inline jsoff_t lkp(struct js *js, jsval_t obj, const char *buf, size_t len) {
-  const char *search_intern = intern_string(buf, len);
-  if (!search_intern) return 0;
-  return lkp_interned(js, obj, search_intern, len);
+  return js_true;
 }
 
-static jsval_t *resolve_bound_args(struct js *js, jsval_t func_obj, jsval_t *args, int nargs, int *out_nargs) {
-  *out_nargs = nargs;
-  
-  jsval_t bound_arr = get_slot(js, func_obj, SLOT_BOUND_ARGS);
-  int bound_argc = 0;
-  
-  if (vtype(bound_arr) == T_ARR) {
-    bound_argc = (int)get_array_length(js, bound_arr);
-  } if (bound_argc <= 0) return NULL;
-  
-  *out_nargs = bound_argc + nargs;
-  jsval_t *combined = (jsval_t *)ant_calloc(sizeof(jsval_t) * (*out_nargs));
-  if (!combined) return NULL;
-  
-  for (int i = 0; i < bound_argc; i++) combined[i] = arr_get(js, bound_arr, (jsoff_t)i);
-  for (int i = 0; i < nargs; i++) combined[bound_argc + i] = args[i];
-  
-  return combined;
-}
+jsval_t js_delete_sym_prop(ant_t *js, jsval_t obj, jsval_t sym) {
+  obj = js_as_obj(obj);
+  if (is_proxy(js, obj)) {
+    jsval_t result = proxy_delete_val(js, obj, sym);
+    return is_err(result) ? result : js_bool(js_truthy(js, result));
+  }
 
-static jsoff_t lkp_scope(struct js *js, jsval_t scope, const char *buf, size_t len) {
-  const char *search_intern = intern_string(buf, len);
-  if (!search_intern) return 0;
+  jsval_t err = check_frozen_sealed(js, obj, "delete");
+  if (vtype(err) != T_UNDEF) return err;
 
-  jsoff_t scope_off = (jsoff_t)vdata(scope);
-  jsoff_t off = loadoff(js, scope_off) & ~(3U | FLAGMASK);
+  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  jsoff_t sym_off = (jsoff_t)vdata(sym);
+  jsoff_t prop_off = lkp_sym(js, obj, sym_off);
+  if (prop_off == 0) return js_true;
 
-  while (off < js->brk && off != 0) {
-    jsoff_t header = loadoff(js, off);
-    if (is_slot_prop(header)) { off = next_prop(header); continue; }
+  if (is_nonconfig_prop(js, prop_off)) {
+    if (sv_vm_is_strict(js->vm)) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
+    return js_false;
+  }
 
-    jsoff_t koff = loadoff(js, (jsoff_t)(off + sizeof(off)));
-    jsoff_t klen = (loadoff(js, koff) >> 3) - 1;
-    if (klen == len) {
-      const char *p = (char *)&js->mem[koff + sizeof(koff)];
-      if (intern_string(p, klen) == search_intern) return off;
+  jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
+  if (first_prop == prop_off) {
+    unlink_prop(js, obj_off, prop_off, 0);
+    return js_true;
+  }
+  for (jsoff_t prev = first_prop; prev != 0; ) {
+    jsoff_t np = loadoff(js, prev) & ~(3U | FLAGMASK);
+    if (np == prop_off) {
+      unlink_prop(js, obj_off, prop_off, prev);
+      return js_true;
     }
-    off = next_prop(header);
+    prev = np;
   }
-  return 0;
+  return js_true;
 }
 
-static jsoff_t lkp_with_getter(struct js *js, jsval_t obj, const char *buf, size_t len, jsval_t *getter_out, bool *has_getter_out) {
-  *has_getter_out = false;
-  *getter_out = js_mkundef();
+static jsval_t iter_call_noargs_with_this(ant_t *js, jsval_t this_val, jsval_t method) {
+  jsval_t result = sv_vm_call(js->vm, js, method, this_val, NULL, 0, NULL, false);
+  return result;
+}
+
+static jsval_t iter_close_iterator(ant_t *js, jsval_t iterator) {
+  jsoff_t return_off = lkp_proto(js, iterator, "return", 6);
+  if (return_off == 0) return js_mkundef();
+  jsval_t return_method = loadval(js, return_off + sizeof(jsoff_t) * 2);
+  if (vtype(return_method) != T_FUNC && vtype(return_method) != T_CFUNC) {
+    return js_mkerr(js, "iterator.return is not a function");
+  }
+  return iter_call_noargs_with_this(js, iterator, return_method);
+}
+
+static jsval_t iter_foreach(ant_t *js, jsval_t iterable, iter_callback_t cb, void *ctx) {
+  jsval_t iter_sym = get_iterator_sym();
+  jsoff_t iter_prop = (vtype(iter_sym) == T_SYMBOL) ? lkp_sym_proto(js, iterable, (jsoff_t)vdata(iter_sym)) : 0;
+  if (iter_prop == 0) return js_mkerr(js, "not iterable");
+
+  jsval_t iter_method = loadval(js, iter_prop + sizeof(jsoff_t) * 2);
+  jsval_t iterator = iter_call_noargs_with_this(js, iterable, iter_method);
+  if (is_err(iterator)) return iterator;
   
-  for (jsval_t current = obj; is_object_type(current); ) {
-    jsoff_t current_off = (jsoff_t)vdata(current);
-    descriptor_entry_t *desc = lookup_descriptor(js, current_off, buf, len);
+  jshdl_t h_iterator = js_root(js, iterator);
+  jsval_t out = js_mkundef();
+  
+  while (true) {
+    jsval_t cur_iter = js_deref(js, h_iterator);
+    jsoff_t next_off = lkp_proto(js, cur_iter, "next", 4);
+    if (next_off == 0) { js_unroot(js, h_iterator); return js_mkerr(js, "iterator.next is not a function"); }
     
-    if (desc && desc->has_getter) {
-      *getter_out = desc->getter;
-      *has_getter_out = true;
-      return current_off;
+    jsval_t next_method = loadval(js, next_off + sizeof(jsoff_t) * 2);
+    if (vtype(next_method) != T_FUNC && vtype(next_method) != T_CFUNC) {
+      js_unroot(js, h_iterator);
+      return js_mkerr(js, "iterator.next is not a function");
     }
     
-    jsoff_t prop_off = lkp_interned(js, current, intern_string(buf, len), len);
-    if (prop_off != 0) return prop_off;
+    cur_iter = js_deref(js, h_iterator);
+    jsval_t result = iter_call_noargs_with_this(js, cur_iter, next_method);
+    if (is_err(result)) { js_unroot(js, h_iterator); return result; }
     
-    jsval_t proto = get_proto(js, current);
-    if (!is_object_type(proto)) break;
-    current = proto;
+    jsoff_t done_off = lkp(js, result, "done", 4);
+    jsval_t done_val = done_off ? loadval(js, done_off + sizeof(jsoff_t) * 2) : js_mkundef();
+    if (js_truthy(js, done_val)) break;
+    
+    jsoff_t value_off = lkp(js, result, "value", 5);
+    jsval_t value = value_off ? loadval(js, value_off + sizeof(jsoff_t) * 2) : js_mkundef();
+    
+    iter_action_t action = cb(js, value, ctx, &out);
+    if (action == ITER_BREAK) {
+      jsval_t close_result = iter_close_iterator(js, cur_iter);
+      if (is_err(close_result)) { js_unroot(js, h_iterator); return close_result; }
+      break;
+    }
+    if (action == ITER_ERROR) {
+      jsval_t close_result = iter_close_iterator(js, cur_iter);
+      js_unroot(js, h_iterator);
+      if (is_err(close_result)) return close_result;
+      return out;
+    }
   }
   
-  return 0;
+  js_unroot(js, h_iterator);
+  return out;
 }
 
-static jsoff_t lkp_with_setter(struct js *js, jsval_t obj, const char *buf, size_t len, jsval_t *setter_out, bool *has_setter_out) {
-  *has_setter_out = false;
-  *setter_out = js_mkundef();
+jsval_t js_symbol_to_string(ant_t *js, jsval_t sym) {
+  const char *desc = js_sym_desc(js, sym);
+  if (!desc) return js_mkstr(js, "Symbol()", 8);
   
-  jsval_t current = obj;
-  while (vtype(current) == T_OBJ || vtype(current) == T_FUNC) {
-    jsoff_t current_off = (jsoff_t)vdata(current);
-    descriptor_entry_t *desc = lookup_descriptor(js, current_off, buf, len);
-    
-    if (desc && desc->has_setter) {
-      *setter_out = desc->setter;
-      *has_setter_out = true;
-      return current_off;
-    }
-    
-    jsoff_t prop_off = lkp_interned(js, current, intern_string(buf, len), len);
-    if (prop_off != 0) return prop_off;
-    
-    jsval_t proto = get_proto(js, current);
-    if (vtype(proto) != T_OBJ && vtype(proto) != T_FUNC) break;
-    current = proto;
-  }
-  
-  return 0;
-}
-
-static jsval_t call_proto_accessor(struct js *js, jsval_t prim, jsval_t accessor, bool has_accessor, jsval_t *arg, int arg_count, bool is_setter) {
-  if (!has_accessor || (vtype(accessor) != T_FUNC && vtype(accessor) != T_CFUNC)) return js_mkundef();
-  
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  uint8_t saved_flags = js->flags;
-  jsoff_t saved_toff = js->toff;
-  jsoff_t saved_tlen = js->tlen;
+  size_t desc_len = strlen(desc);
+  size_t total = 7 + desc_len + 1;
   
-  jsval_t saved_this = js->this_val;
-  js->this_val = prim; push_this(prim);
-  jsval_t result = call_js_with_args(js, accessor, arg, arg_count);
-  pop_this(); js->this_val = saved_this;
+  char stack_buf[128];
+  char *buf = (total + 1 <= sizeof(stack_buf)) ? stack_buf : malloc(total + 1);
+  if (!buf) return js_mkerr(js, "out of memory");
   
-  bool had_throw = (js->flags & F_THROW) != 0;
-  jsval_t thrown = js->thrown_value;
+  memcpy(buf, "Symbol(", 7);
+  memcpy(buf + 7, desc, desc_len);
+  buf[7 + desc_len] = ')';
+  buf[total] = '\0';
   
-  JS_RESTORE_STATE(js, saved);
-  js->flags = saved_flags;
-  js->toff = saved_toff;
-  js->tlen = saved_tlen;
+  jsval_t result = js_mkstr(js, buf, total);
+  if (buf != stack_buf) free(buf);
+  return result;
+}
+
+static jsval_t builtin_String(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t sval;
   
-  if (had_throw) {
-    js->flags |= F_THROW;
-    js->thrown_value = thrown;
+  if (nargs == 0) {
+    sval = js_mkstr(js, "", 0);
+  } else if (vtype(args[0]) == T_STR) {
+    sval = args[0];
+  } else if (vtype(args[0]) == T_SYMBOL) {
+    sval = js_symbol_to_string(js, args[0]);
+    if (is_err(sval)) return sval;
+  } else {
+    sval = coerce_to_str(js, args[0]);
+    if (is_err(sval)) return sval;
   }
   
-  if (is_setter) return is_err(result) ? result : (arg ? *arg : js_mkundef());
-  return result;
+  jsval_t string_proto = js_get_ctor_proto(js, "String", 6);
+  if (is_wrapper_ctor_target(js, js->this_val, string_proto)) {
+    set_slot(js, js->this_val, SLOT_PRIMITIVE, sval);
+    jsoff_t slen;
+    vstr(js, sval, &slen);
+    js_setprop(js, js->this_val, js->length_str, tov((double)slen));
+    js_set_descriptor(js, js->this_val, "length", 6, 0);
+  }
+  return sval;
 }
 
-jsval_t js_get_proto(struct js *js, jsval_t obj) {
-  uint8_t t = vtype(obj);
+static jsval_t builtin_Number_isNaN(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkval(T_BOOL, 0);
+  jsval_t arg = args[0];
+  
+  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
+  
+  double val = tod(arg);
+  return mkval(T_BOOL, isnan(val) ? 1 : 0);
+}
 
-  if (!is_object_type(obj)) return js_mknull();
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+static jsval_t builtin_Number_isFinite(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkval(T_BOOL, 0);
+  jsval_t arg = args[0];
   
-  jsval_t proto = get_slot(js, as_obj, SLOT_PROTO);
-  if (is_object_type(proto)) return proto;
+  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
   
-  if (t != T_OBJ) return get_prototype_for_type(js, t);
-  return js_mknull();
+  double val = tod(arg);
+  return mkval(T_BOOL, isfinite(val) ? 1 : 0);
 }
 
-static jsval_t get_proto(struct js *js, jsval_t obj) {
-  return js_get_proto(js, obj);
+static jsval_t builtin_global_isNaN(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkval(T_BOOL, 1);
+  double val = js_to_number(js, args[0]);
+  return mkval(T_BOOL, isnan(val) ? 1 : 0);
 }
 
-void js_set_proto(struct js *js, jsval_t obj, jsval_t proto) {
-  uint8_t t = vtype(obj);
-  if (!is_object_type(obj)) return;
-  
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
-  set_slot(js, as_obj, SLOT_PROTO, proto);
+static jsval_t builtin_global_isFinite(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkval(T_BOOL, 0);
+  double val = js_to_number(js, args[0]);
+  return mkval(T_BOOL, isfinite(val) ? 1 : 0);
 }
 
-static void set_proto(struct js *js, jsval_t obj, jsval_t proto) {
-  js_set_proto(js, obj, proto);
+static jsval_t builtin_eval(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return js_mkundef();
+  jsval_t code = args[0];
+  if (vtype(code) != T_STR) return code;
+  jsoff_t code_len = 0;
+  jsoff_t code_off = vstr(js, code, &code_len);
+  const char *code_str = (const char *)&js->mem[code_off];
+  return js_eval_bytecode_eval_with_strict(js, code_str, (size_t)code_len, false);
 }
 
-jsval_t js_get_ctor_proto(struct js *js, const char *name, size_t len) {
-  jsoff_t ctor_off = lkp_scope(js, js->scope, name, len);
+static jsval_t builtin_Number_isInteger(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkval(T_BOOL, 0);
+  jsval_t arg = args[0];
   
-  if (ctor_off == 0 && global_scope_stack) {
-    unsigned int stack_len = utarray_len(global_scope_stack);
-    for (int i = (int)stack_len - 1; i >= 0 && ctor_off == 0; i--) {
-      jsoff_t *scope_off = (jsoff_t *)utarray_eltptr(global_scope_stack, (unsigned int)i);
-      jsval_t scope = mkval(T_OBJ, *scope_off);
-      ctor_off = lkp_scope(js, scope, name, len);
-    }
-  } else if (ctor_off == 0) {
-    for (jsval_t scope = upper(js, js->scope); vdata(scope) != 0 && ctor_off == 0; scope = upper(js, scope)) {
-      ctor_off = lkp_scope(js, scope, name, len);
-    }
-  }
+  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
   
-  if (ctor_off == 0) return js_mknull();
-  jsval_t ctor = resolveprop(js, mkval(T_PROP, ctor_off));
-  if (vtype(ctor) != T_FUNC) return js_mknull();
-  jsval_t ctor_obj = mkval(T_OBJ, vdata(ctor));
-  jsoff_t proto_off = lkp_interned(js, ctor_obj, INTERN_PROTOTYPE, 9);
+  double val = tod(arg);
+  if (!isfinite(val)) return mkval(T_BOOL, 0);
+  return mkval(T_BOOL, (val == floor(val)) ? 1 : 0);
+}
+
+static jsval_t builtin_Number_isSafeInteger(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkval(T_BOOL, 0);
+  jsval_t arg = args[0];
   
-  if (proto_off == 0) return js_mknull();
-  return resolveprop(js, mkval(T_PROP, proto_off));
+  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
+  
+  double val = tod(arg);
+  if (!isfinite(val)) return mkval(T_BOOL, 0);
+  if (val != floor(val)) return mkval(T_BOOL, 0);
+  
+  return mkval(T_BOOL, (val >= -9007199254740991.0 && val <= 9007199254740991.0) ? 1 : 0);
 }
 
-static inline jsval_t get_ctor_proto(struct js *js, const char *name, size_t len) {
-  return js_get_ctor_proto(js, name, len);
+static jsval_t builtin_Number(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t nval = tov(nargs > 0 ? js_to_number(js, args[0]) : 0.0);
+  jsval_t number_proto = js_get_ctor_proto(js, "Number", 6);
+  if (is_wrapper_ctor_target(js, js->this_val, number_proto)) {
+    set_slot(js, js->this_val, SLOT_PRIMITIVE, nval);
+  }
+  return nval;
 }
 
-static jsval_t get_prototype_for_type(struct js *js, uint8_t type) {
-  switch (type) {
-    case T_STR:     return get_ctor_proto(js, "String", 6);
-    case T_NUM:     return get_ctor_proto(js, "Number", 6);
-    case T_BOOL:    return get_ctor_proto(js, "Boolean", 7);
-    case T_ARR:     return get_ctor_proto(js, "Array", 5);
-    case T_FUNC:    return get_ctor_proto(js, "Function", 8);
-    case T_PROMISE: return get_ctor_proto(js, "Promise", 7);
-    case T_OBJ:     return get_ctor_proto(js, "Object", 6);
-    case T_BIGINT:  return get_ctor_proto(js, "BigInt", 6);
-    default:        return js_mknull();
+static jsval_t builtin_Boolean(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t bval = mkval(T_BOOL, nargs > 0 && js_truthy(js, args[0]) ? 1 : 0);
+  jsval_t boolean_proto = js_get_ctor_proto(js, "Boolean", 7);
+  if (is_wrapper_ctor_target(js, js->this_val, boolean_proto)) {
+    set_slot(js, js->this_val, SLOT_PRIMITIVE, bval);
   }
+  return bval;
 }
 
-jsoff_t lkp_proto(struct js *js, jsval_t obj, const char *key, size_t len) {
-  uint8_t t = vtype(obj);
-  const char *key_intern = intern_string(key, len);
-  
-  if (!key_intern) return 0;
-  if (len == STR_PROTO_LEN && memcmp(key, STR_PROTO, STR_PROTO_LEN) == 0) return 0;
+static jsval_t builtin_Object(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0 || vtype(args[0]) == T_NULL || vtype(args[0]) == T_UNDEF) {
+    jsval_t obj_proto = js_get_ctor_proto(js, "Object", 6);
+    if (is_unboxed_obj(js, js->this_val, obj_proto)) return js->this_val;
+    return js_mkobj(js);
+  }
   
-  jsval_t cur = obj;
-  int depth = 0;
+  jsval_t arg = args[0];
+  uint8_t t = vtype(arg);
   
-  while (depth < MAX_PROTO_CHAIN_DEPTH) {
-    if (t == T_OBJ || t == T_ARR || t == T_FUNC || t == T_PROMISE) {
-      jsval_t as_obj = mkval(T_OBJ, vdata(cur));
-      jsoff_t off = lkp_interned(js, as_obj, key_intern, len);
-      if (off != 0) return off;
-    } else if (t == T_CFUNC) {
-      jsval_t func_proto = get_ctor_proto(js, "Function", 8);
-      uint8_t ft = vtype(func_proto);
-      if (ft == T_OBJ || ft == T_ARR || ft == T_FUNC) {
-        jsoff_t off = lkp(js, mkval(T_OBJ, vdata(func_proto)), key, len);
-        if (off != 0) return off;
-      }
-      break;
-    } else if (t != T_STR && t != T_NUM && t != T_BOOL && t != T_BIGINT) break;
-    if (!proto_walk_next(js, &cur, &t, PROTO_WALK_F_LOOKUP)) { break; } depth++;
+  if (t == T_OBJ || t == T_ARR || t == T_FUNC) return arg;
+  if (t == T_STR || t == T_NUM || t == T_BOOL || t == T_BIGINT) {
+    jsval_t wrapper = js_mkobj(js);
+    if (is_err(wrapper)) return wrapper;
+    set_slot(js, wrapper, SLOT_PRIMITIVE, arg);
+    jsval_t proto = get_prototype_for_type(js, t);
+    if (vtype(proto) == T_OBJ) set_proto(js, wrapper, proto);
+    return wrapper;
   }
   
-  return 0;
+  return arg;
 }
 
-static jsval_t getprop_any(struct js *js, jsval_t obj, const char *key, size_t key_len) {
-  uint8_t t = vtype(obj);
+static jsval_t builtin_function_empty(ant_t *, jsval_t *, int);
+
+static jsval_t build_dynamic_function(ant_t *js, jsval_t *args, int nargs, bool is_async) {
+  if (nargs == 0) {
+    jsval_t func_obj = mkobj(js, 0);
+    if (is_err(func_obj)) return func_obj;
+    
+    set_func_code_ptr(js, func_obj, "(){}", 4);
+    if (is_async) {
+      set_slot(js, func_obj, SLOT_ASYNC, js_true);
+      jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
+      if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
+    } else {
+      jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
+      jsval_t instance_proto = js_instance_proto_from_new_target(js, func_proto);
+      if (is_object_type(instance_proto)) set_proto(js, func_obj, instance_proto);
+    }
+    set_slot(js, func_obj, SLOT_CFUNC, js_mkfun(builtin_function_empty));
+    
+    jsval_t func = js_obj_to_func(func_obj);
+    jsval_t proto_setup = setup_func_prototype(js, func);
+    if (is_err(proto_setup)) return proto_setup;
+    return func;
+  }
   
-  if (t == T_STR && key_len == 6 && memcmp(key, "length", 6) == 0) {
-    jsoff_t byte_len;
-    jsoff_t str_off = vstr(js, obj, &byte_len);
-    return tov(D(utf16_strlen((const char *)&js->mem[str_off], byte_len)));
+  size_t total_len = 1;
+  
+  for (int i = 0; i < nargs - 1; i++) {
+    args[i] = coerce_to_str(js, args[i]);
+    if (is_err(args[i])) return args[i];
+    total_len += vstrlen(js, args[i]);
+    if (i < nargs - 2) total_len += 1;
   }
   
-  if (t == T_STR || t == T_NUM || t == T_BOOL || t == T_BIGINT) {
-    jsoff_t off = lkp_proto(js, obj, key, key_len);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
-    return js_mkundef();
+  total_len += 2;
+  
+  jsval_t body = coerce_to_str(js, args[nargs - 1]);
+  if (is_err(body)) return body;
+  total_len += vstrlen(js, body);
+  total_len += 1;
+  
+  char *code_buf = (char *)malloc(total_len + 1);
+  if (!code_buf) return js_mkerr(js, "oom");
+  size_t pos = 0;
+
+  code_buf[pos++] = '(';
+  for (int i = 0; i < nargs - 1; i++) {
+    jsoff_t param_len, param_off = vstr(js, args[i], &param_len);
+    memcpy(code_buf + pos, &js->mem[param_off], param_len);
+    pos += param_len;
+    if (i < nargs - 2) code_buf[pos++] = ',';
+  }
+  code_buf[pos++] = ')';
+  code_buf[pos++] = '{';
+  jsoff_t body_len, body_off = vstr(js, body, &body_len);
+  memcpy(code_buf + pos, &js->mem[body_off], body_len);
+  pos += body_len;
+  code_buf[pos++] = '}';
+  code_buf[pos] = '\0';
+
+  jsval_t func_obj = mkobj(js, 0);
+  if (is_err(func_obj)) { free(code_buf); return func_obj; }
+
+  sv_func_t *compiled = sv_compile_function(js, code_buf, pos, is_async);
+  if (!compiled) {
+    free(code_buf);
+    return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid function body");
   }
+
+  sv_closure_t *closure = calloc(1, sizeof(sv_closure_t));
+  closure->func = compiled;
+  closure->bound_this = js_mkundef();
+  closure->call_flags = 0;
+  closure->func_obj = func_obj;
+
+  size_t params_len = (size_t)(pos - 2) - (size_t)body_len - 2;
+  const char *async_prefix = is_async ? "async " : "";
+  size_t async_len = is_async ? 6 : 0;
+  size_t display_len = async_len + 19 + params_len + 5 + (size_t)body_len + 2;
+  char *display = (char *)malloc(display_len + 1);
+  if (!display) { free(code_buf); return js_mkerr(js, "oom"); }
+  size_t n = 0;
   
-  if (t == T_OBJ || t == T_ARR || t == T_FUNC) {
-    jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
-    jsoff_t off = lkp(js, as_obj, key, key_len);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
-    off = lkp_proto(js, obj, key, key_len);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
+  memcpy(display + n, async_prefix, async_len);         n += async_len;
+  memcpy(display + n, "function anonymous(", 19);       n += 19;
+  memcpy(display + n, code_buf + 1, params_len);        n += params_len;
+  memcpy(display + n, "\n) {\n", 5);                    n += 5;
+  memcpy(display + n, code_buf + 1 + params_len + 2, (size_t)body_len); n += (size_t)body_len;
+  memcpy(display + n, "\n}", 2);                        n += 2;
+  display[n] = '\0';
+  set_func_code(js, func_obj, display, display_len);
+  free(display);
+  free(code_buf);
+  
+  if (is_async) {
+    set_slot(js, func_obj, SLOT_ASYNC, js_true);
+    jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
+    if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
+  } else {
+    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
+    jsval_t instance_proto = js_instance_proto_from_new_target(js, func_proto);
+    if (is_object_type(instance_proto)) set_proto(js, func_obj, instance_proto);
   }
   
-  return js_mkundef();
+  jsval_t func = mkval(T_FUNC, (uintptr_t)closure);
+  jsval_t proto_setup = setup_func_prototype(js, func);
+  if (is_err(proto_setup)) return proto_setup;
+  return func;
 }
 
-static jsval_t try_dynamic_getter(struct js *js, jsval_t obj, const char *key, size_t key_len) {
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
-  dynamic_accessors_t *entry = NULL;
-  HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
-  if (!entry || !entry->getter) return js_mkundef();
-  return entry->getter(js, obj, key, key_len);
+static jsval_t builtin_Function(ant_t *js, jsval_t *args, int nargs) {
+  return build_dynamic_function(js, args, nargs, false);
 }
 
-static bool try_dynamic_setter(struct js *js, jsval_t obj, const char *key, size_t key_len, jsval_t value) {
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
-  dynamic_accessors_t *entry = NULL;
-  HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
-  if (!entry || !entry->setter) return false;
-  return entry->setter(js, obj, key, key_len, value);
+static jsval_t builtin_AsyncFunction(ant_t *js, jsval_t *args, int nargs) {
+  return build_dynamic_function(js, args, nargs, true);
 }
 
-static bool try_dynamic_deleter(struct js *js, jsval_t obj, const char *key, size_t key_len) {
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
-  dynamic_accessors_t *entry = NULL;
-  HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
-  if (!entry || !entry->deleter) return false;
-  return entry->deleter(js, obj, key, key_len);
+static jsval_t builtin_function_empty(ant_t *js, jsval_t *args, int nargs) {
+  (void)js; (void)args; (void)nargs;
+  return js_mkundef();
 }
 
-static jsval_t with_scope_name_blocked(struct js *js, jsval_t with_obj, const char *key, size_t key_len) {
-  const char *unscopables_key = get_unscopables_sym_key();
-  if (!unscopables_key || !unscopables_key[0]) return js_false;
-
-  jsval_t unscopables = js_get(js, with_obj, unscopables_key);
-  if (is_err(unscopables)) return unscopables;
-  if (!is_object_type(unscopables)) return js_false;
-
-  jsoff_t prop_off = lkp_interned(js, unscopables, intern_string(key, key_len), key_len);
-  if (prop_off == 0) prop_off = lkp_proto(js, unscopables, key, key_len);
-  if (prop_off == 0) return js_false;
-
-  jsval_t blocked = resolveprop(js, mkval(T_PROP, prop_off));
-  if (is_err(blocked)) return blocked;
-  return js_bool(js_truthy(js, blocked));
+static jsval_t builtin_function_call(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t func = js->this_val;
+  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC) {
+    return js_mkerr(js, "call requires a function");
+  }
+  
+  jsval_t this_arg = (nargs > 0) ? args[0] : js_mkundef();
+  
+  jsval_t *call_args = NULL;
+  int call_nargs = (nargs > 1) ? nargs - 1 : 0;
+  if (call_nargs > 0) {
+    call_args = &args[1];
+  }
+  
+  return sv_vm_call(js->vm, js, func, this_arg, call_args, call_nargs, NULL, false);
 }
 
-static jsval_t lookup(struct js *js, const char *buf, size_t len) {
-  if (js->flags & F_NOEXEC) return 0;
+static int extract_array_args(ant_t *js, jsval_t arr, jsval_t **out_args) {
+  int len = (int) get_array_length(js, arr);
+  if (len <= 0) return 0;
   
-  char decoded[256];
-  const char *key_str = buf;
-  size_t key_len = len;
+  jsval_t *args_out = (jsval_t *)ant_calloc(sizeof(jsval_t) * len);
+  if (!args_out) return 0;
   
-  if (has_unicode_escape(buf, len)) {
-    key_len = decode_ident_escapes(buf, len, decoded, sizeof(decoded));
-    key_str = decoded;
+  for (int i = 0; i < len; i++) {
+    args_out[i] = arr_get(js, arr, (jsoff_t)i);
   }
   
-  if (key_len == STR_PROTO_LEN && memcmp(key_str, STR_PROTO, STR_PROTO_LEN) == 0) {
-    jsval_t proto = get_slot(js, js->scope, SLOT_PROTO);
-    if (vtype(proto) != T_UNDEF) return proto;
-    return get_prototype_for_type(js, vtype(js->scope));
+  *out_args = args_out;
+  return len;
+}
+
+static jsval_t builtin_function_toString(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t func = js->this_val;
+  uint8_t t = vtype(func);
+  
+  if (t != T_FUNC && t != T_CFUNC) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Function.prototype.toString requires that 'this' be a Function");
   }
   
-  const char *key_intern = intern_string(key_str, key_len);
-  jsval_t parent_scope = upper(js, js->scope);
+  if (t == T_CFUNC) return ANT_STRING("function() { [native code] }");
   
-  jsoff_t off = lkp_interned(js, js->scope, key_intern, key_len);
-  if (off != 0) return mkval(T_PROP, off);
+  jsval_t func_obj = js_func_obj(func);
+  jsval_t cfunc_slot = get_slot(js, func_obj, SLOT_CFUNC);
   
-  jsval_t with_slot = get_slot(js, js->scope, SLOT_WITH);
-  if (vtype(with_slot) != T_UNDEF) {
-    jsval_t with_obj = (
-      vtype(with_slot) == T_OBJ ||
-      vtype(with_slot) == T_ARR || 
-      vtype(with_slot) == T_FUNC) ? 
-      with_slot : mkval(T_OBJ, vdata(with_slot)
-    );
-    
-    jsoff_t prop_off = lkp_interned(js, with_obj, key_intern, key_len);
-    if (prop_off != 0) {
-      jsval_t blocked = with_scope_name_blocked(js, with_obj, key_str, key_len);
-      if (is_err(blocked)) return blocked;
-      if (js_truthy(js, blocked)) goto check_parent_scopes;
-      jsval_t key = js_mkstr(js, key_str, key_len);
-      if (is_err(key)) return key;
-      return mkpropref((jsoff_t)vdata(with_obj), (jsoff_t)vdata(key));
+  if (vtype(cfunc_slot) == T_CFUNC) {
+    jsoff_t name_len = 0;
+    const char *name = get_func_name(js, func, &name_len);
+    if (name && name_len > 0) {
+      size_t total = 9 + name_len + 21 + 1;
+      char *buf = ant_calloc(total);
+      size_t n = 0;
+      n += cpy(buf + n, total - n, "function ", 9);
+      n += cpy(buf + n, total - n, name, name_len);
+      n += cpy(buf + n, total - n, "() { [native code] }", 20);
+      jsval_t result = js_mkstr(js, buf, n);
+      free(buf);
+      return result;
     }
+    return ANT_STRING("function() { [native code] }");
   }
-
-check_parent_scopes:
-  uint8_t depth = 1;
-  for (jsval_t scope = parent_scope; depth < 255; depth++) {
-    off = lkp_interned(js, scope, key_intern, key_len);
-    if (off != 0) {
-      return mkval(T_PROP, off);
-    }
+  
+  jsval_t code_val = get_slot(js, func_obj, SLOT_CODE);
+  jsval_t len_val = get_slot(js, func_obj, SLOT_CODE_LEN);
+  
+  if (vtype(code_val) == T_CFUNC && vtype(len_val) == T_NUM) {
+    const char *code = (const char *)(uintptr_t)vdata(code_val);
+    size_t code_len = (size_t)tod(len_val);
     
-    jsval_t scope_with_slot = get_slot(js, scope, SLOT_WITH);
-    if (vtype(scope_with_slot) != T_UNDEF) {
-      jsval_t with_obj = (
-        vtype(scope_with_slot) == T_OBJ ||
-        vtype(scope_with_slot) == T_ARR || 
-        vtype(scope_with_slot) == T_FUNC) ? 
-        scope_with_slot : mkval(T_OBJ, vdata(scope_with_slot)
-      );
+    if (code && code_len > 0) {
+      jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
+      jsval_t arrow_slot = get_slot(js, func_obj, SLOT_ARROW);
+      
+      bool is_async = (async_slot == js_true);
+      bool is_arrow = (arrow_slot == js_true);
       
-      jsoff_t prop_off = lkp_interned(js, with_obj, key_intern, key_len);
-      if (prop_off != 0) {
-        jsval_t blocked = with_scope_name_blocked(js, with_obj, key_str, key_len);
-        if (is_err(blocked)) return blocked;
-        if (js_truthy(js, blocked)) goto continue_scope_walk;
-        jsval_t key = js_mkstr(js, key_str, key_len);
-        if (is_err(key)) return key;
-        return mkpropref((jsoff_t)vdata(with_obj), (jsoff_t)vdata(key));
+      if (is_arrow) {
+        const char *paren_end = memchr(code, ')', code_len);
+        if (!paren_end) goto fallback_arrow;
+        
+        size_t params_len = paren_end - code + 1;
+        const char *body = paren_end + 1;
+        size_t body_len = code_len - params_len;
+        
+        size_t len = (is_async ? 6 : 0) + params_len + 4 + body_len + 1;
+        char *buf = ant_calloc(len);
+        size_t n = 0;
+        
+        if (is_async) n += cpy(buf + n, REMAIN(n, len), "async ", 6);
+        n += cpy(buf + n, REMAIN(n, len), code, params_len);
+        n += cpy(buf + n, REMAIN(n, len), " => ", 4);
+        n += cpy(buf + n, REMAIN(n, len), body, body_len);
+        
+        jsval_t result = js_mkstr(js, buf, n);
+        free(buf);
+        return result;
+        fallback_arrow:;
       }
+      
+      return js_mkstr(js, code, code_len);
     }
-continue_scope_walk:
-    if (vdata(scope) == 0) break;
-    scope = upper(js, scope);
   }
   
-  if (global_scope_stack && utarray_len(global_scope_stack) > 0) {
-    jsoff_t *root_off = (jsoff_t *)utarray_eltptr(global_scope_stack, 0);
-    if (root_off && *root_off != 0) {
-      jsval_t root_scope = mkval(T_OBJ, *root_off);
-      jsoff_t root_lkp_off = lkp(js, root_scope, key_str, key_len);
-      if (root_lkp_off != 0) return mkval(T_PROP, root_lkp_off);
+  sv_closure_t *cl = js_func_closure(func);
+  if (cl->func != NULL) {
+    sv_func_t *fn = cl->func;
+    if (fn && fn->source && fn->source_end > fn->source_start) {
+      int start = fn->source_start;
+      int end   = fn->source_end;
+      if (start >= 0 && end <= fn->source_len && end > start)
+        return js_mkstr(js, fn->source + start, (size_t)(end - start));
     }
   }
-  
-  return js_mkerr_typed(js, JS_ERR_REFERENCE, "'%.*s' is not defined", (int) key_len, key_str);
-}
-
-static bool try_accessor_getter(struct js *js, jsval_t obj, const char *key, size_t key_len, jsval_t *out) {
-  jsval_t getter = js_mkundef();
-  bool has_getter = false;
-  lkp_with_getter(js, obj, key, key_len, &getter, &has_getter);
-
-  jsval_t result = call_proto_accessor(js, obj, getter, has_getter, NULL, 0, false);
-  if (vtype(result) != T_UNDEF) {
-    *out = result;
-    return true;
-  }
-  return false;
-}
 
-static inline jsval_t resolve_array_length(struct js *js, jsoff_t obj_off) {
-  return tov(D(get_array_length(js, mkval(T_ARR, obj_off))));
+  char buf[256];
+  size_t len = strfunc(js, func, buf, sizeof(buf));
+  return js_mkstr(js, buf, len);
 }
 
-static inline jsval_t resolve_array_index_prop(struct js *js, jsoff_t obj_off, const char *key_str, jsoff_t len) {
-  jsval_t arr = mkval(T_ARR, obj_off);
-  jsoff_t doff = get_dense_buf(js, arr);
-  if (doff) {
-    unsigned long idx = 0;
-    for (jsoff_t i = 0; i < len; i++) idx = idx * 10 + (key_str[i] - '0');
-    jsoff_t dlen = dense_length(js, doff);
-    if (idx < dlen) {
-      jsval_t v = dense_get(js, doff, (jsoff_t)idx);
-      if (!is_empty_slot(v)) return v;
-    }
+static jsval_t builtin_function_apply(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t func = js->this_val;
+  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Function.prototype.apply requires that 'this' be a Function");
   }
-  jsoff_t prop_off = lkp(js, arr, key_str, len);
-  if (prop_off != 0) return resolveprop(js, mkval(T_PROP, prop_off));
-  return js_mkundef();
-}
-
-static inline jsval_t resolve_prim_propref(struct js *js, jsval_t v) {
-  prim_propref_data_t *prim_data = prim_propref_get(v);
-  if (!prim_data) return js_mkundef();
   
-  jsval_t prim = prim_data->prim_val;
-  jsval_t key = mkval(T_STR, prim_data->key_off);
-  jsoff_t key_len; const char *key_str = (const char *)&js->mem[vstr(js, key, &key_len)];
+  jsval_t this_arg = (nargs > 0) ? args[0] : js_mkundef();
+  jsval_t *call_args = NULL;
+  int call_nargs = 0;
   
-  jsval_t proto = get_prototype_for_type(js, vtype(prim));
-  if (vtype(proto) == T_OBJ) {
-    jsval_t getter = js_mkundef();
-    bool has_getter = false;
-    lkp_with_getter(js, proto, key_str, key_len, &getter, &has_getter);
-    jsval_t result = call_proto_accessor(js, prim, getter, has_getter, NULL, 0, false);
-    if (vtype(result) != T_UNDEF) return result;
-    
-    jsoff_t off = lkp_proto(js, prim, key_str, key_len);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
+  if (nargs > 1) {
+    jsval_t arg_array = args[1];
+    uint8_t t = vtype(arg_array);
+    if (t == T_ARR || t == T_OBJ) {
+      call_nargs = extract_array_args(js, arg_array, &call_args);
+    } else if (t != T_UNDEF && t != T_NULL) {}
   }
   
-  return js_mkundef();
+  jsval_t result = sv_vm_call(js->vm, js, func, this_arg, call_args, call_nargs, NULL, false);
+  if (call_args) free(call_args);
+  return result;
 }
 
-static inline jsval_t resolve_array_named_prop(struct js *js, jsoff_t obj_off, const char *key_str, jsoff_t len) {
-  jsval_t obj = mkval(T_ARR, obj_off);
-  
-  if (len == STR_PROTO_LEN && memcmp(key_str, STR_PROTO, STR_PROTO_LEN) == 0) {
-    jsval_t proto = get_slot(js, obj, SLOT_PROTO);
-    if (vtype(proto) != T_UNDEF) return proto;
-    return get_prototype_for_type(js, T_ARR);
-  }
+static jsval_t builtin_function_bind(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t func = js->this_val;
   
-  jsval_t proto = get_slot(js, obj, SLOT_PROTO);
-  if (vtype(proto) == T_UNDEF || vtype(proto) == T_NULL) {
-    proto = get_prototype_for_type(js, T_ARR);
+  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "bind requires a function");
   }
+
+  jsval_t this_arg = (nargs > 0) ? args[0] : js_mkundef();
   
-  jsoff_t prop_off = lkp(js, obj, key_str, len);
-  if (prop_off != 0) return resolveprop(js, mkval(T_PROP, prop_off));
+  int bound_argc = (nargs > 1) ? nargs - 1 : 0;
+  jsval_t *bound_args = (bound_argc > 0) ? &args[1] : NULL;
   
-  if (is_object_type(proto)) {
-    const char *key_intern = intern_string(key_str, len);
-    if (key_intern) {
-      jsoff_t off = lkp_interned(js, proto, key_intern, len);
-      if (off != 0) return resolveprop(js, mkval(T_PROP, off));
+  int orig_length = 0;
+  jsval_t target_func_obj;
+  if (vtype(func) == T_CFUNC) {
+    orig_length = 0;
+  } else {
+    target_func_obj = js_func_obj(func);
+    jsoff_t len_off = lkp_interned(js, target_func_obj, INTERN_LENGTH, 6);
+    if (len_off != 0) {
+      jsval_t len_val = resolveprop(js, mkval(T_PROP, len_off));
+      if (vtype(len_val) == T_NUM) {
+        orig_length = (int) tod(len_val);
+      }
     }
-    
-    jsoff_t proto_off = lkp_proto(js, proto, key_str, len);
-    if (proto_off != 0) return resolveprop(js, mkval(T_PROP, proto_off));
   }
   
-  jsval_t dyn_result = try_dynamic_getter(js, obj, key_str, len);
-  if (vtype(dyn_result) != T_UNDEF) return dyn_result;
-  
-  return js_mkundef();
-}
-
-static inline jsval_t current_lexical_new_target(struct js *js) {
-  if (vtype(js->current_func) != T_FUNC) return js->new_target;
-
-  jsval_t func_obj = mkval(T_OBJ, vdata(js->current_func));
-  if (get_slot(js, func_obj, SLOT_ARROW) != js_true) return js->new_target;
+  int bound_length = orig_length - bound_argc;
+  if (bound_length < 0) bound_length = 0;
 
-  jsval_t captured = get_slot(js, func_obj, SLOT_NEW_TARGET);
-  if (captured == T_EMPTY) return js_mkundef();
-  if (vtype(captured) == T_UNDEF) return js_mkundef();
-  
-  return captured;
-}
+  if (vtype(func) == T_CFUNC) {
+    jsval_t bound_func = mkobj(js, 0);
+    if (is_err(bound_func)) return bound_func;
+    
+    set_slot(js, bound_func, SLOT_CFUNC, func);
+    set_slot(js, bound_func, SLOT_BOUND_THIS, this_arg);
+    
+    if (bound_argc > 0) {
+      jsval_t bound_arr = mkarr(js);
+      for (int i = 0; i < bound_argc; i++) arr_set(js, bound_arr, (jsoff_t)i, bound_args[i]);
+      set_slot(js, bound_func, SLOT_BOUND_ARGS, bound_arr);
+    }
+    
+    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
+    if (vtype(func_proto) == T_FUNC) set_proto(js, bound_func, func_proto);
+    
+    jsval_t bound = js_obj_to_func(bound_func);
+    js_setprop(js, bound_func, js->length_str, tov((double) bound_length));
+    
+    jsval_t proto_setup = setup_func_prototype(js, bound);
+    if (is_err(proto_setup)) return proto_setup;
+    
+    return bound;
+  }
 
-static inline void capture_arrow_new_target(struct js *js, jsval_t func_obj) {
-  jsval_t captured = current_lexical_new_target(js);
-  if (vtype(captured) == T_UNDEF) captured = T_EMPTY;
-  set_slot(js, func_obj, SLOT_NEW_TARGET, captured);
-}
+  jsval_t func_obj = js_func_obj(func);
+  jsval_t bound_func = mkobj(js, 0);
+  if (is_err(bound_func)) return bound_func;
 
-static inline jsval_t resolve_object_prop(struct js *js, jsval_t obj, const char *key_str, jsoff_t len) {
-  if (is_proxy(js, obj)) return proxy_get(js, obj, key_str, len);
-  
-  if (len == STR_PROTO_LEN && memcmp(key_str, STR_PROTO, STR_PROTO_LEN) == 0) {
-    jsval_t proto = get_slot(js, obj, SLOT_PROTO);
-    if (vtype(proto) != T_UNDEF) return proto;
-    return get_prototype_for_type(js, vtype(obj));
-  }
-  
-  jsoff_t prop_off = lkp(js, obj, key_str, len);
-  if (prop_off != 0) return resolveprop(js, mkval(T_PROP, prop_off));
-  
-  jsoff_t proto_off = lkp_proto(js, obj, key_str, len);
-  if (proto_off != 0) return resolveprop(js, mkval(T_PROP, proto_off));
-  
-  jsval_t accessor_result;
-  if (try_accessor_getter(js, obj, key_str, len, &accessor_result)) {
-    return accessor_result;
+  jsval_t code_val = get_slot(js, func_obj, SLOT_CODE);
+  if (vtype(code_val) == T_STR || vtype(code_val) == T_CFUNC) {
+    set_slot(js, bound_func, SLOT_CODE, code_val);
+    set_slot(js, bound_func, SLOT_CODE_LEN, get_slot(js, func_obj, SLOT_CODE_LEN));
   }
-  
-  jsval_t dyn_result = try_dynamic_getter(js, obj, key_str, len);
-  if (vtype(dyn_result) != T_UNDEF) return dyn_result;
-  
-  return js_mkundef();
-}
 
-jsval_t resolveprop(struct js *js, jsval_t v) {
-  assert(v != (jsval_t)T_TAILCALL && "T_TAILCALL leaked into resolveprop");
-  if (is_new_target_ref(v)) return current_lexical_new_target(js);
-
-  if (vtype(v) == T_PROPREF) {
-    if (is_prim_propref(v)) return resolve_prim_propref(js, v);
-    
-    jsoff_t obj_off = propref_obj(v);
-    jsoff_t key_off = propref_key(v);
-    jsval_t key = mkval(T_STR, key_off);
-    
-    jsoff_t len; const char *key_str = (const char *)&js->mem[vstr(js, key, &len)];
-    if (is_arr_off(js, obj_off) && streq(key_str, len, "length", 6)) return resolve_array_length(js, obj_off);
+  sv_closure_t *orig = js_func_closure(func);
+  sv_closure_t *bound_closure = calloc(1, sizeof(sv_closure_t));
+  bound_closure->func = orig->func;
+  bound_closure->upvalues = orig->upvalues;
+  bound_closure->bound_this = this_arg;
+  bound_closure->func_obj = bound_func;
+  bound_closure->call_flags = orig->call_flags;
+  if (bound_argc > 0)
+    bound_closure->call_flags |= SV_CALL_HAS_BOUND_ARGS;
 
-    if (is_arr_off(js, obj_off) && len > 0 && key_str[0] >= '0' && key_str[0] <= '9') {
-      if (is_array_index(key_str, len)) return resolve_array_index_prop(js, obj_off, key_str, len);
-    }
+  jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
+  if (vtype(async_slot) == T_BOOL && vdata(async_slot) == 1) {
+    set_slot(js, bound_func, SLOT_ASYNC, js_true);
+  }
 
-    if (is_arr_off(js, obj_off) && len > 0 && (key_str[0] < '0' || key_str[0] > '9')) {
-      return resolve_array_named_prop(js, obj_off, key_str, len);
-    }
+  jsval_t target_proto = get_proto(js, func);
+  if (is_object_type(target_proto)) {
+    set_proto(js, bound_func, target_proto);
+  } else if (vtype(async_slot) == T_BOOL && vdata(async_slot) == 1) {
+    jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
+    if (vtype(async_proto) == T_FUNC) set_proto(js, bound_func, async_proto);
+  } else {
+    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
+    if (vtype(func_proto) == T_FUNC) set_proto(js, bound_func, func_proto);
+  }
 
-    uint8_t obj_type = is_arr_off(js, obj_off) 
-      ? T_ARR : (is_func_off(js, obj_off) ? T_FUNC : T_OBJ);
-    
-    jsval_t obj = mkval(obj_type, obj_off);
-    return resolve_object_prop(js, obj, key_str, len);
+  jsval_t data_slot = get_slot(js, func_obj, SLOT_DATA);
+  if (vtype(data_slot) != T_UNDEF) {
+    set_slot(js, bound_func, SLOT_DATA, data_slot);
   }
-  
-  if (vtype(v) != T_PROP) return v;
-  return resolveprop(js, loadval(js, (jsoff_t) (vdata(v) + sizeof(jsoff_t) * 2)));
-}
 
-static bool try_accessor_setter(struct js *js, jsval_t obj, const char *key, size_t key_len, jsval_t val, jsval_t *out) {
-  jsval_t setter = js_mkundef();
-  bool has_setter = false;
+  set_slot(js, bound_func, SLOT_TARGET_FUNC, func);
+  set_slot(js, bound_func, SLOT_BOUND_THIS, this_arg);
   
-  lkp_with_setter(js, obj, key, key_len, &setter, &has_setter);
-  if (!has_setter) return false;
-
-  jsval_t result = call_proto_accessor(js, obj, setter, has_setter, &val, 1, true);
-  if (is_err(result)) {
-    *out = result;
-    return true;
+  if (bound_argc > 0) {
+    jsval_t bound_arr = mkarr(js);
+    for (int i = 0; i < bound_argc; i++) arr_set(js, bound_arr, (jsoff_t)i, bound_args[i]);
+    set_slot(js, bound_func, SLOT_BOUND_ARGS, bound_arr);
   }
-  
-  *out = val;
-  return true;
-}
 
-static jsval_t assign_array_index_fast(
-  struct js *js, jsval_t obj,
-  jsoff_t obj_off, jsval_t key,
-  const char *key_str,
-  jsoff_t key_len, jsval_t val
-) {
-  int is_numeric = 1;
-  unsigned long idx = 0;
-  for (jsoff_t ci = 0; ci < key_len; ci++) {
-    if (key_str[ci] < '0' || key_str[ci] > '9') { is_numeric = 0; break; }
-    idx = idx * 10 + (key_str[ci] - '0');
+  jsval_t cfunc_slot = get_slot(js, func_obj, SLOT_CFUNC);
+  if (vtype(cfunc_slot) == T_CFUNC) {
+    set_slot(js, bound_func, SLOT_CFUNC, cfunc_slot);
   }
   
-  if (!is_numeric || (key_len > 1 && key_str[0] == '0')) return js_mkundef();
-  jsoff_t doff = get_dense_buf(js, obj);
+  js_setprop(js, bound_func, js->length_str, tov((double) bound_length));
   
-  if (doff) {
-    jsoff_t cur_len = dense_length(js, doff);
-    jsoff_t density_limit = cur_len > 0 ? cur_len * 4 : 64;
-    if (idx < density_limit) { arr_set(js, obj, (jsoff_t)idx, val); return val; }
-  }
-  int known_new = 0; jsoff_t tail = loadoff(js, obj_off + sizeof(jsoff_t) * 2);
-  
-  if (tail != 0 && tail < js->brk) {
-    jsoff_t tail_koff = loadoff(js, tail + sizeof(jsoff_t));
-    jsoff_t tail_klen = offtolen(loadoff(js, tail_koff));
-    const char *tail_key = (char *)&js->mem[tail_koff + sizeof(jsoff_t)];
-    if (tail_klen > 0 && tail_key[0] >= '0' && tail_key[0] <= '9') {
-      unsigned long tail_idx = 0;
-      int tail_valid = 1;
-      for (jsoff_t ci = 0; ci < tail_klen; ci++) {
-        if (tail_key[ci] < '0' || tail_key[ci] > '9') { tail_valid = 0; break; }
-        tail_idx = tail_idx * 10 + (tail_key[ci] - '0');
-      }
-      if (tail_valid && idx > tail_idx) known_new = 1;
-    }
-  }
-
-  jsoff_t existing = 0;
-  if (!known_new) {
-    const char *interned = intern_string(key_str, key_len);
-    existing = interned ? lkp_interned(js, obj, interned, key_len) : 0;
-  }
-  
-  if (existing != 0) {
-    saveval(js, existing + sizeof(jsoff_t) * 2, val);
-  } else {
-    mkprop_fast(js, obj, key, val, 0);
-    jsoff_t len_off = lkp_interned(js, obj, INTERN_LENGTH, 6);
-    jsoff_t cur_len = 0;
-    if (len_off != 0) {
-      jsval_t lv = resolveprop(js, mkval(T_PROP, len_off));
-      if (vtype(lv) == T_NUM) cur_len = (jsoff_t) tod(lv);
-    }
-    if (idx >= cur_len) {
-      jsval_t new_len = tov((double)(idx + 1));
-      if (len_off != 0) saveval(js, len_off + sizeof(jsoff_t) * 2, new_len);
-      else js_mkprop_fast(js, obj, "length", 6, new_len);
-    }
-  }
-  
-  return val;
-}
-
-static jsval_t assign(struct js *js, jsval_t lhs, jsval_t val) {
-  if (js->flags & F_NOEXEC) return val;
-  if (vtype(lhs) == T_PROPREF) {
-    if (is_prim_propref(lhs)) {
-      prim_propref_data_t *prim_data = prim_propref_get(lhs);
-      if (!prim_data) {
-        if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot create property on primitive value");
-        return val;
-      }
-      
-      jsval_t prim = prim_data->prim_val;
-      jsval_t key = mkval(T_STR, prim_data->key_off);
-      jsoff_t key_len;
-      const char *key_str = (const char *)&js->mem[vstr(js, key, &key_len)];
-      
-       jsval_t proto = get_prototype_for_type(js, vtype(prim));
-       if (vtype(proto) == T_OBJ) {
-         jsval_t setter = js_mkundef();
-         bool has_setter = false;
-         lkp_with_setter(js, proto, key_str, key_len, &setter, &has_setter);
-         jsval_t result = call_proto_accessor(js, prim, setter, has_setter, &val, 1, true);
-         if (vtype(result) != T_UNDEF) return result;
-       }
-      
-      if (js->flags & F_STRICT) {
-        return js_mkerr_typed(
-          js, JS_ERR_TYPE, "Cannot create property '%.*s' on %s", 
-          (int)key_len, key_str, typestr(vtype(prim))
-        );
-      }
-      return val;
-    }
-    
-    jsoff_t obj_off = propref_obj(lhs);
-    jsoff_t key_off = propref_key(lhs);
-    jsval_t obj = mkval(is_arr_off(js, obj_off) ? T_ARR : T_OBJ, obj_off);
-    jsval_t key = mkval(T_STR, key_off);
-
-    jsoff_t key_len;
-    const char *key_str = (const char *)&js->mem[vstr(js, key, &key_len)];
-    
-    if (vtype(obj) == T_ARR && !is_proxy(js, obj) && key_len > 0 && key_str[0] >= '0' && key_str[0] <= '9') {
-      jsval_t result = assign_array_index_fast(js, obj, obj_off, key, key_str, key_len, val);
-      if (vtype(result) != T_UNDEF) return result;
-    }
-
-    jsval_t setter_result;
-    if (try_accessor_setter(js, obj, key_str, key_len, val, &setter_result)) {
-      return setter_result;
-    } return js_setprop(js, obj, key, val);
-  }
-  
-  if (vtype(lhs) != T_PROP) {
-    if (js->flags & F_STRICT) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "Invalid left-hand side in assignment");
-    } return val;
-  }
-  
-  jsoff_t propoff = (jsoff_t) vdata(lhs);
-  jsoff_t koff = loadoff(js, propoff + sizeof(jsoff_t));
-  jsoff_t klen = offtolen(loadoff(js, koff));
-  
-  const char *key = (char *)&js->mem[koff + sizeof(jsoff_t)];
-  if (is_const_prop(js, propoff)) return js_mkerr(js, "assignment to constant");
-  
-  if ((klen == 9 && memcmp(key, "undefined", 9) == 0) ||
-      (klen == 3 && memcmp(key, "NaN", 3) == 0) ||
-      (klen == 8 && memcmp(key, "Infinity", 8) == 0)) {
-    if (js->flags & F_STRICT) return js_mkerr(js, "Cannot assign to read only property");
-    return lhs;
-  }
-  
-  saveval(js, (jsoff_t) ((vdata(lhs) & ~3ULL) + sizeof(jsoff_t) * 2), val);
-  return lhs;
-}
-
-static jsval_t do_assign_op(struct js *js, uint8_t op, jsval_t l, jsval_t r) {
-  uint8_t m[] = {
-    TOK_PLUS, TOK_MINUS, TOK_MUL, TOK_DIV, TOK_REM, TOK_SHL,
-    TOK_SHR,  TOK_ZSHR,  TOK_AND, TOK_XOR, TOK_OR
-  };
-  
-  jsval_t res = do_op(js, m[op - TOK_PLUS_ASSIGN], resolveprop(js, l), r);
-  return assign(js, l, res);
-}
-
-typedef struct {
-  char *buffer;
-  size_t capacity;
-  size_t size;
-  bool is_dynamic;
-} string_builder_t;
-
-static void string_builder_init(string_builder_t *sb, char *static_buf, size_t static_cap) {
-  sb->buffer = static_buf;
-  sb->capacity = static_cap;
-  sb->size = 0;
-  sb->is_dynamic = false;
-}
-
-static bool string_builder_append(string_builder_t *sb, const char *data, size_t len) {
-  if (sb->size + len > sb->capacity) {
-    size_t new_capacity = sb->capacity ? sb->capacity * 2 : 256;
-    while (new_capacity < sb->size + len) new_capacity *= 2;
-    
-    char *new_buffer = (char *)ant_calloc(new_capacity);
-    if (!new_buffer) return false;
-    
-    if (sb->size > 0) memcpy(new_buffer, sb->buffer, sb->size);
-    if (sb->is_dynamic) free(sb->buffer);
-    
-    sb->buffer = new_buffer;
-    sb->capacity = new_capacity;
-    sb->is_dynamic = true;
-  }
-  
-  if (len > 0) {
-    memcpy(sb->buffer + sb->size, data, len);
-    sb->size += len;
-  }
-  
-  return true;
-}
-
-static jsval_t string_builder_finalize(struct js *js, string_builder_t *sb) {
-  jsval_t result = js_mkstr(js, sb->buffer, sb->size);
-  if (sb->is_dynamic && sb->buffer) free(sb->buffer);
-  return result;
-}
-
-static inline jsoff_t str_len_fast(struct js *js, jsval_t str) {
-  if (vtype(str) != T_STR) return 0;
-  jsoff_t off = (jsoff_t) vdata(str);
-  jsoff_t header = loadoff(js, off);
-  if (header & ROPE_FLAG) {
-    return offtolen(header & ~(ROPE_FLAG | (ROPE_DEPTH_MASK << ROPE_DEPTH_SHIFT)));
-  }
-  return offtolen(header);
-}
-
-static jsval_t do_string_op(struct js *js, uint8_t op, jsval_t l, jsval_t r) {
-  if (op == TOK_PLUS) {
-    jsoff_t n1 = str_len_fast(js, l);
-    jsoff_t n2 = str_len_fast(js, r);
-    jsoff_t total_len = n1 + n2;
-    
-    if (n2 == 0) return l;
-    if (n1 == 0) return r;
-    
-    uint8_t left_depth = (vtype(l) == T_STR && is_rope(js, l)) ? rope_depth(js, l) : 0;
-    uint8_t right_depth = (vtype(r) == T_STR && is_rope(js, r)) ? rope_depth(js, r) : 0;
-    uint8_t new_depth = (left_depth > right_depth ? left_depth : right_depth) + 1;
-    
-    if (new_depth >= ROPE_MAX_DEPTH || total_len >= ROPE_FLATTEN_THRESHOLD) {
-      jsval_t flat_l = l, flat_r = r;
-      if (is_rope(js, l)) flat_l = rope_flatten(js, l);
-      if (is_err(flat_l)) return flat_l;
-      if (is_rope(js, r)) flat_r = rope_flatten(js, r);
-      if (is_err(flat_r)) return flat_r;
-      
-      jsoff_t off1, off2, len1, len2;
-      off1 = vstr(js, flat_l, &len1);
-      off2 = vstr(js, flat_r, &len2);
-      
-      string_builder_t sb;
-      char static_buffer[512];
-      string_builder_init(&sb, static_buffer, sizeof(static_buffer));
-      
-      if (
-        !string_builder_append(&sb, (char *)&js->mem[off1], len1) ||
-        !string_builder_append(&sb, (char *)&js->mem[off2], len2)
-      ) return js_mkerr(js, "string concatenation failed");
-      
-      return string_builder_finalize(js, &sb);
-    }
-    
-    return js_mkrope(js, l, r, total_len, new_depth);
-  }
-  
-  jsoff_t n1, off1 = vstr(js, l, &n1);
-  jsoff_t n2, off2 = vstr(js, r, &n2);
-  
-  if (op == TOK_EQ) {
-    bool eq = n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
-    return mkval(T_BOOL, eq ? 1 : 0);
-  } else if (op == TOK_NE) {
-    bool eq = n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
-    return mkval(T_BOOL, eq ? 0 : 1);
-  } else if (op == TOK_LT || op == TOK_LE || op == TOK_GT || op == TOK_GE) {
-    jsoff_t min_len = n1 < n2 ? n1 : n2;
-    int cmp = memcmp(&js->mem[off1], &js->mem[off2], min_len);
-    
-    if (cmp == 0) {
-      if (n1 == n2) {
-        return mkval(T_BOOL, (op == TOK_LE || op == TOK_GE) ? 1 : 0);
-      } else cmp = (n1 < n2) ? -1 : 1;
-    }
-    
-    switch (op) {
-      case TOK_LT: return mkval(T_BOOL, cmp < 0 ? 1 : 0);
-      case TOK_LE: return mkval(T_BOOL, cmp <= 0 ? 1 : 0);
-      case TOK_GT: return mkval(T_BOOL, cmp > 0 ? 1 : 0);
-      case TOK_GE: return mkval(T_BOOL, cmp >= 0 ? 1 : 0);
-      default:     return js_mkerr(js, "bad str op");
-    }
-  } else return js_mkerr(js, "bad str op");
-}
-
-static inline bool parse_string_index_key(jsval_t key_val, const char *kstr, size_t klen, size_t *out_idx) {
-  if (vtype(key_val) == T_NUM) {
-    double d = tod(key_val);
-    if (!isfinite(d) || d < 0.0) return false;
-    
-    double di = floor(d);
-    if (di != d || di > (double)SIZE_MAX) return false;
-    
-    size_t idx = (size_t)di;
-    if ((double)idx != di) return false;
-    
-    *out_idx = idx;
-    return true;
-  }
-
-  if (!is_array_index(kstr, (jsoff_t)klen)) return false;
-  unsigned long idx = 0;
-  
-  if (!parse_array_index(kstr, klen, (jsoff_t)-1, &idx)) return false;
-  *out_idx = (size_t)idx;
-  
-  return true;
-}
-
-static inline jsval_t try_string_index_access(struct js *js, jsval_t str, jsval_t key_val, const char *keystr, size_t keylen) {
-  size_t idx = 0;
-  if (!parse_string_index_key(key_val, keystr, keylen, &idx)) return js_mkundef();
-
-  jsoff_t byte_len;
-  jsoff_t str_off = vstr(js, str, &byte_len);
-  
-  const char *str_data = (const char *)&js->mem[str_off];
-  size_t char_bytes;
-  
-  int byte_offset = utf16_index_to_byte_offset(str_data, byte_len, idx, &char_bytes);
-  if (byte_offset < 0) return js_mkundef();
-
-  return js_mkstr(js, str_data + byte_offset, char_bytes);
-}
-
-static jsval_t do_bracket_op(struct js *js, jsval_t l, jsval_t r) {
-  jsval_t obj = resolveprop(js, l);
-  jsval_t key_val = resolveprop(js, r);
-  char keybuf[64];
-  const char *keystr;
-  size_t keylen;
-  if (vtype(key_val) == T_NUM) {
-    double dv = tod(key_val);
-    if (dv >= 0 && dv <= 0xFFFFFFFF && dv == (double)(uint32_t)dv) {
-      keylen = uint_to_str(keybuf, sizeof(keybuf), (uint32_t)dv);
-    } else keylen = strnum(key_val, keybuf, sizeof(keybuf));
-    keystr = keybuf;
-  } else if (vtype(key_val) == T_STR) {
-    jsoff_t slen;
-    jsoff_t off = vstr(js, key_val, &slen);
-    keystr = (char *) &js->mem[off];
-    keylen = slen;
-  } else if (vtype(key_val) == T_SYMBOL) {
-    sym_to_prop_key(key_val, keybuf, sizeof(keybuf));
-    keystr = keybuf;
-    keylen = strlen(keybuf);
-  } else {
-    jsval_t str_val = js_tostring_val(js, key_val);
-    if (is_err(str_val)) return str_val;
-    jsoff_t slen;
-    jsoff_t off = vstr(js, str_val, &slen);
-    keystr = (char *) &js->mem[off];
-    keylen = slen;
-  }
-  if (vtype(obj) == T_PROMISE) obj = mkval(T_OBJ, vdata(obj));
-  if (streq(keystr, keylen, "length", 6)) {
-    if (vtype(obj) == T_STR) {
-      jsoff_t byte_len;
-      jsoff_t str_off = vstr(js, obj, &byte_len);
-      const char *str_data = (const char *)&js->mem[str_off];
-      return tov(D(utf16_strlen(str_data, byte_len)));
-    }
-    if (vtype(obj) == T_ARR) return mkpropref((jsoff_t)vdata(obj), (jsoff_t)vdata(js->length_str));
-  }
-  if (vtype(obj) == T_STR) {
-    jsval_t ch = try_string_index_access(js, obj, key_val, keystr, keylen);
-    if (!is_undefined(ch)) return ch;
-    jsoff_t off = lkp_proto(js, obj, keystr, keylen);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
-    return js_mkundef();
-  }
-  if (vtype(obj) == T_OBJ) {
-    jsval_t prim = get_slot(js, obj, SLOT_PRIMITIVE);
-    if (vtype(prim) == T_STR) {
-      jsval_t ch = try_string_index_access(js, prim, key_val, keystr, keylen);
-      if (!is_undefined(ch)) return ch;
-    }
-  }
-  if (vtype(obj) == T_FUNC) {
-    if ((js->flags & F_STRICT) && (streq(keystr, keylen, "caller", 6) || streq(keystr, keylen, "arguments", 9))) {
-      return js_mkerr_typed(js, JS_ERR_TYPE, "'%.*s' not allowed on functions in strict mode", (int)keylen, keystr);
-    }
-    jsoff_t obj_off = (jsoff_t)vdata(obj);
-    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, keystr, keylen);
-    if (desc && (desc->has_getter || desc->has_setter)) {
-      jsval_t key = js_mkstr(js, keystr, keylen);
-      return mkpropref(obj_off, (jsoff_t)vdata(key));
-    }
-    jsval_t func_obj = mkval(T_OBJ, vdata(obj));
-    jsoff_t off = lkp_proto(js, obj, keystr, keylen);
-    if (off != 0) {
-      jsval_t key = js_mkstr(js, keystr, keylen);
-      return mkpropref(obj_off, (jsoff_t)vdata(key));
-    }
-    if (streq(keystr, keylen, "name", 4)) return js_mkstr(js, "", 0);
-    jsval_t key = js_mkstr(js, keystr, keylen);
-    jsval_t prop = js_setprop(js, func_obj, key, js_mkundef());
-    return prop;
-  }
-  if (vtype(obj) == T_CFUNC) {
-    if ((js->flags & F_STRICT) && (streq(keystr, keylen, "caller", 6) || streq(keystr, keylen, "arguments", 9))) {
-      return js_mkerr_typed(js, JS_ERR_TYPE, "'%.*s' not allowed on functions in strict mode", (int)keylen, keystr);
-    }
-    jsoff_t off = lkp_proto(js, obj, keystr, keylen);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
-    if (streq(keystr, keylen, "name", 4)) return js_mkstr(js, "", 0);
-    return js_mkundef();
-  }
-  if (vtype(obj) == T_NUM || vtype(obj) == T_BOOL || vtype(obj) == T_BIGINT) {
-    jsval_t key = js_mkstr(js, keystr, keylen);
-    return mkprim_propref(obj, (jsoff_t)vdata(key));
-  }
-  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR) {
-    return js_mkundef();
-  }
-  if (vtype(obj) == T_ARR && !is_proxy(js, obj) && keylen > 0 && keystr[0] >= '0' && keystr[0] <= '9') {
-    int valid = 1;
-    for (size_t ci = 0; ci < keylen; ci++) {
-      if (keystr[ci] < '0' || keystr[ci] > '9') { valid = 0; break; }
-    }
-    if (valid && (keylen == 1 || keystr[0] != '0')) {
-      jsval_t key = js_mkstr(js, keystr, keylen);
-      return mkpropref((jsoff_t)vdata(obj), (jsoff_t)vdata(key));
-    }
-  }
-
-  if ((streq(keystr, keylen, "callee", 6) || streq(keystr, keylen, "caller", 6)) &&
-      vtype(get_slot(js, obj, SLOT_STRICT_ARGS)) != T_UNDEF) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "'%.*s' not allowed on strict arguments", (int)keylen, keystr);
-  }
-  
-  jsval_t getter = js_mkundef();
-  bool has_getter = false;
-  jsoff_t prop_off = lkp_with_getter(js, obj, keystr, keylen, &getter, &has_getter);
-  
-  jsval_t setter = js_mkundef();
-  bool has_setter = false;
-  if (!has_getter) {
-    lkp_with_setter(js, obj, keystr, keylen, &setter, &has_setter);
-  }
-  
-  if (has_getter || has_setter) {
-    jsval_t key = js_mkstr(js, keystr, keylen);
-    return mkpropref((jsoff_t)vdata(obj), (jsoff_t)vdata(key));
-  }
-  
-  if (prop_off != 0) {
-    jsval_t key = js_mkstr(js, keystr, keylen);
-    return mkpropref((jsoff_t)vdata(obj), (jsoff_t)vdata(key));
-  }
-  
-  jsval_t dyn_result = try_dynamic_getter(js, obj, keystr, keylen);
-  if (vtype(dyn_result) != T_UNDEF) {
-    jsval_t key = js_mkstr(js, keystr, keylen);
-    return mkpropref((jsoff_t)vdata(obj), (jsoff_t)vdata(key));
-  }
-  
-  jsval_t key = js_mkstr(js, keystr, keylen);
-  return mkpropref((jsoff_t)vdata(obj), (jsoff_t)vdata(key));
-}
-
-static jsval_t do_dot_op(struct js *js, jsval_t l, jsval_t r) {
-  if (vtype(r) == T_CODEREF && is_special_object(l) && !is_proxy(js, l)) {
-    dot_ic_entry_t *ic = &dot_ic_table[dot_ic_slot(js->code, coderefoff(r))];
-    
-    if (
-      ic->generation == intern_prop_cache_gen
-      && ic->code_ptr == js->code
-      && ic->code_off == coderefoff(r)
-    ) return mkpropref((jsoff_t)vdata(l), ic->cached_key_off);
-  }
-
-  const char *raw_ptr = (char *) &js->code[coderefoff(r)];
-  size_t raw_len = codereflen(r);
-  
-  char decoded_buf[256];
-  size_t plen = decode_ident_escapes(raw_ptr, raw_len, decoded_buf, sizeof(decoded_buf));
-  const char *ptr = decoded_buf;
-  
-  if (vtype(r) != T_CODEREF) return js_mkerr_typed(js, JS_ERR_SYNTAX, "ident expected");
-  uint8_t t = vtype(l);
-  
-  if (t == T_PROMISE) {
-    l = mkval(T_OBJ, vdata(l));
-    t = T_OBJ;
-  }
-  
-  if (t == T_STR && streq(ptr, plen, "length", 6)) {
-    jsoff_t byte_len;
-    jsoff_t str_off = vstr(js, l, &byte_len);
-    const char *str_data = (const char *)&js->mem[str_off];
-    return tov(D(utf16_strlen(str_data, byte_len)));
-  }
-  
-  if (t == T_ARR && streq(ptr, plen, "length", 6)) {
-    return mkpropref((jsoff_t)vdata(l), (jsoff_t)vdata(js->length_str));
-  }
-
-  if (t == T_STR || t == T_NUM || t == T_BOOL || t == T_BIGINT) {
-    jsval_t key = js_mkstr(js, ptr, plen);
-    return mkprim_propref(l, (jsoff_t)vdata(key));
-  }
-  
-  if (t == T_FUNC) {
-    if ((js->flags & F_STRICT) && (streq(ptr, plen, "caller", 6) || streq(ptr, plen, "arguments", 9))) {
-      return js_mkerr_typed(js, JS_ERR_TYPE, "'%.*s' not allowed on functions in strict mode", (int)plen, ptr);
-    }
-    if (plen == STR_PROTO_LEN && memcmp(ptr, STR_PROTO, STR_PROTO_LEN) == 0) {
-      jsval_t proto = get_slot(js, mkval(T_OBJ, vdata(l)), SLOT_PROTO);
-      if (vtype(proto) != T_UNDEF) return proto;
-      return get_prototype_for_type(js, T_FUNC);
-    }
-    jsoff_t obj_off = (jsoff_t)vdata(l);
-    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, ptr, plen);
-    if (desc && (desc->has_getter || desc->has_setter)) {
-      jsval_t key = js_mkstr(js, ptr, plen);
-      return mkpropref(obj_off, (jsoff_t)vdata(key));
-    }
-    jsval_t func_obj = mkval(T_OBJ, vdata(l));
-    jsoff_t off = lkp_proto(js, l, ptr, plen);
-    if (off != 0) {
-      jsval_t key = js_mkstr(js, ptr, plen);
-      return mkpropref(obj_off, (jsoff_t)vdata(key));
-    }
-    if (streq(ptr, plen, "name", 4)) return js_mkstr(js, "", 0);
-    jsval_t key = js_mkstr(js, ptr, plen);
-    jsval_t prop = js_setprop(js, func_obj, key, js_mkundef());
-    return prop;
-  }
-  
-  if (t == T_CFUNC) {
-    if ((js->flags & F_STRICT) && (streq(ptr, plen, "caller", 6) || streq(ptr, plen, "arguments", 9))) {
-      return js_mkerr_typed(js, JS_ERR_TYPE, "'%.*s' not allowed on functions in strict mode", (int)plen, ptr);
-    }
-    jsoff_t off = lkp_proto(js, l, ptr, plen);
-    if (off != 0) return resolveprop(js, mkval(T_PROP, off));
-    if (streq(ptr, plen, "name", 4)) return js_mkstr(js, "", 0);
-    return js_mkundef();
-  }
-  
-  if (t == T_SYMBOL) {
-    if (streq(ptr, plen, "description", 11)) {
-      const char *desc = sym_get_desc(js, l);
-      if (desc) return js_mkstr(js, desc, strlen(desc));
-      return js_mkundef();
-    }
-    
-    jsval_t sym_proto = get_ctor_proto(js, "Symbol", 6);
-    if (vtype(sym_proto) == T_OBJ) {
-      jsoff_t off = lkp(js, sym_proto, ptr, plen);
-      if (off != 0) return resolveprop(js, mkval(T_PROP, off));
-    }
-    
-    return js_mkundef();
-  }
-  
-  if (t != T_OBJ && t != T_ARR) {
-    jsoff_t saved_toff = js->toff;
-    jsoff_t saved_tlen = js->tlen;
-    
-    js->toff = coderefoff(r);
-    js->tlen = codereflen(r);
-    
-    jsval_t err = js_mkerr(
-      js, "Cannot read properties of %s (reading '%.*s')",
-      t == T_UNDEF ? "undefined" : t == T_NULL ? "null" : typestr(t),
-      (int)plen, ptr
-    );
-    
-    js->toff = saved_toff;
-    js->tlen = saved_tlen;
-    
-    return err;
-  }
-  
-  bool ic_eligible = !is_proxy(js, l);
-  jsoff_t ic_obj_off = (jsoff_t)vdata(l);
-  jsoff_t ic_key_off = 0;
-  
-  if ((streq(ptr, plen, "callee", 6) || streq(ptr, plen, "caller", 6)) &&
-      vtype(get_slot(js, l, SLOT_STRICT_ARGS)) != T_UNDEF) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "'%.*s' not allowed on strict arguments", (int)plen, ptr);
-  }
-  
-  if (plen == STR_PROTO_LEN && memcmp(ptr, STR_PROTO, STR_PROTO_LEN) == 0) {
-    jsval_t key = js_mkstr(js, ptr, plen);
-    return mkpropref((jsoff_t)vdata(l), (jsoff_t)vdata(key));
-  }
-  
-  if (t == T_ARR && !is_proxy(js, l) && plen > 0 && (ptr[0] < '0' || ptr[0] > '9')) {
-    jsoff_t obj_off = (jsoff_t)vdata(l);
-    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, ptr, plen);
-    if (desc) {
-      if (desc->has_getter || desc->has_setter) ic_eligible = false;
-      jsval_t key = js_mkstr(js, ptr, plen);
-      ic_key_off = (jsoff_t)vdata(key);
-      if (ic_eligible) goto ic_populate;
-      return mkpropref(obj_off, ic_key_off);
-    }
-    jsval_t result = try_dynamic_getter(js, l, ptr, plen);
-    if (vtype(result) != T_UNDEF) {
-      jsoff_t own_off = lkp(js, l, ptr, plen);
-      if (own_off != 0) return mkval(T_PROP, own_off);
-    }
-    jsval_t key = js_mkstr(js, ptr, plen);
-    ic_key_off = (jsoff_t)vdata(key);
-    if (ic_eligible) goto ic_populate;
-    return mkpropref((jsoff_t)vdata(l), ic_key_off);
-  }
-  
-  {
-    jsoff_t own_off = lkp(js, l, ptr, plen);
-    if (own_off != 0) {
-      if (ic_eligible) {
-        descriptor_entry_t *desc = lookup_descriptor(js, ic_obj_off, ptr, plen);
-        if (desc && (desc->has_getter || desc->has_setter)) ic_eligible = false;
-      }
-      jsval_t key = js_mkstr(js, ptr, plen);
-      ic_key_off = (jsoff_t)vdata(key);
-      if (ic_eligible) goto ic_populate;
-      return mkpropref((jsoff_t)vdata(l), ic_key_off);
-    }
-    
-    jsval_t result = try_dynamic_getter(js, l, ptr, plen);
-    if (vtype(result) != T_UNDEF) {
-      own_off = lkp(js, l, ptr, plen);
-      if (own_off != 0) {
-        jsval_t key = js_mkstr(js, ptr, plen);
-        ic_key_off = (jsoff_t)vdata(key);
-        if (ic_eligible) goto ic_populate;
-        return mkpropref((jsoff_t)vdata(l), ic_key_off);
-      }
-    }
-
-    jsval_t key = js_mkstr(js, ptr, plen);
-    ic_key_off = (jsoff_t)vdata(key);
-    if (ic_eligible) goto ic_populate;
-    return mkpropref((jsoff_t)vdata(l), ic_key_off);
-  }
-
-ic_populate: {
-    dot_ic_entry_t *ic = &dot_ic_table[dot_ic_slot(js->code, coderefoff(r))];
-    ic->code_ptr = js->code;
-    ic->code_off = coderefoff(r);
-    ic->generation = intern_prop_cache_gen;
-    ic->cached_key_off = ic_key_off;
-    return mkpropref(ic_obj_off, ic_key_off);
-  }
-}
-
-static jsval_t do_optional_chain_op(struct js *js, jsval_t l, jsval_t r) {
-  if (vtype(l) == T_NULL || vtype(l) == T_UNDEF) return js_mkundef();
-  return do_dot_op(js, l, r);
-}
-
-static jsval_t js_call_params(struct js *js) {
-  jsoff_t pos = js->pos;
-  uint8_t flags = js->flags;
-  js->flags |= F_NOEXEC;
-  js->consumed = 1;
-  
-  while (next(js) != TOK_EOF) {
-    if (next(js) == TOK_RPAREN) break;
-    if (next(js) == TOK_REST) js->consumed = 1;
-    js_expr(js);
-    if (next(js) == TOK_RPAREN) break;
-    EXPECT(TOK_COMMA, js->flags = flags);
-  }
-  
-  EXPECT(TOK_RPAREN, js->flags = flags);
-  js->flags = flags;
-  return mkcoderef(pos, js->pos - pos - js->tlen);
-}
-
-static void reverse(jsval_t *args, int nargs) {
-  for (int i = 0; i < nargs / 2; i++) {
-    jsval_t tmp = args[i];
-    args[i] = args[nargs - i - 1], args[nargs - i - 1] = tmp;
-  }
-}
-
-typedef enum { ITER_CONTINUE, ITER_BREAK, ITER_ERROR } iter_action_t;
-typedef iter_action_t (*iter_callback_t)(struct js *js, jsval_t value, void *ctx, jsval_t *out);
-static jsval_t iter_foreach(struct js *js, jsval_t iterable, iter_callback_t cb, void *ctx);
-
-#define SPREAD_STR_CB      0
-#define SPREAD_STR_UTARRAY 1
-#define SPREAD_STR_DYNARGS 2
-
-typedef struct {
-  jsval_t **args;
-  int *argc; int *args_cap;
-  bool *args_on_heap;
-} spread_dynargs_ctx_t;
-
-static void spread_dynargs_push(spread_dynargs_ctx_t *ctx, jsval_t value) {
-  if (*ctx->argc >= *ctx->args_cap) {
-    int new_cap = *ctx->args_cap * 2;
-    jsval_t *new_args = try_oom((size_t)new_cap * sizeof(jsval_t));
-    memcpy(new_args, *ctx->args, (size_t)*ctx->argc * sizeof(jsval_t));
-    if (*ctx->args_on_heap) free(*ctx->args);
-    *ctx->args = new_args;
-    *ctx->args_cap = new_cap;
-    *ctx->args_on_heap = true;
-  }
-  (*ctx->args)[(*ctx->argc)++] = value;
-}
-
-static jsval_t str_spread_chars(struct js *js, jsval_t str, int flags, void *ctx, iter_callback_t cb) {
-  if (is_rope(js, str)) str = rope_flatten(js, str);
-  if (is_err(str)) return str;
-  jsoff_t len = str_len_fast(js, str);
-  for (jsoff_t i = 0; i < len; ) {
-    jsoff_t off = vstr(js, str, NULL);
-    unsigned char c = (unsigned char)js->mem[off + i];
-    jsoff_t cb_len = 1;
-    if (c >= 0x80) {
-      int seq = utf8_sequence_length(c);
-      cb_len = seq > 0 ? (jsoff_t)seq : 1;
-      if (i + cb_len > len) cb_len = len - i;
-    }
-    jsval_t ch = js_mkstr(js, (char *)&js->mem[off + i], cb_len);
-    if (flags == SPREAD_STR_CB) {
-      jsval_t out;
-      iter_action_t act = cb(js, ch, ctx, &out);
-      if (act == ITER_ERROR) return out;
-      if (act == ITER_BREAK) break;
-    } else if (flags == SPREAD_STR_UTARRAY) {
-      utarray_push_back((UT_array *)ctx, &ch);
-    } else if (flags == SPREAD_STR_DYNARGS) {
-      spread_dynargs_push((spread_dynargs_ctx_t *)ctx, ch);
-    } i += cb_len;
-  }
-  return js_mkundef();
-}
-
-static iter_action_t spread_utarray_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
-  utarray_push_back((UT_array *)ctx, &value);
-  return ITER_CONTINUE;
-}
-
-static iter_action_t spread_dynargs_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
-  spread_dynargs_ctx_t *sctx = (spread_dynargs_ctx_t *)ctx;
-  spread_dynargs_push(sctx, value);
-  return ITER_CONTINUE;
-}
-
-static jsval_t append_spread_to_utarray(struct js *js, UT_array *args, jsval_t spread_value) {
-  if (vtype(spread_value) == T_ARR) {
-    jsoff_t len = js_arr_len(js, spread_value);
-    for (jsoff_t i = 0; i < len; i++) {
-      jsval_t elem = arr_get(js, spread_value, i);
-      utarray_push_back(args, &elem);
-    } return js_mkundef();
-  }
-  if (vtype(spread_value) == T_STR) return str_spread_chars(js, spread_value, SPREAD_STR_UTARRAY, args, NULL);
-  return iter_foreach(js, spread_value, spread_utarray_iter_cb, args);
-}
-
-static jsval_t append_spread_to_dynargs(struct js *js, spread_dynargs_ctx_t *ctx, jsval_t spread_value) {
-  if (vtype(spread_value) == T_ARR) {
-    jsoff_t len = js_arr_len(js, spread_value);
-    for (jsoff_t i = 0; i < len; i++) spread_dynargs_push(ctx, arr_get(js, spread_value, i));
-    return js_mkundef();
-  }
-  if (vtype(spread_value) == T_STR) return str_spread_chars(js, spread_value, SPREAD_STR_DYNARGS, ctx, NULL);
-  return iter_foreach(js, spread_value, spread_dynargs_iter_cb, ctx);
-}
-
-static int parse_call_args(struct js *js, UT_array *args, jsval_t *err_out) {
-  while (js->pos < js->clen) {
-    if (next(js) == TOK_RPAREN) break;
-    bool is_spread = (next(js) == TOK_REST);
-    if (is_spread) js->consumed = 1;
-    jsval_t arg = resolveprop(js, js_expr(js));
-    if (is_err(arg)) { *err_out = arg; return -1; }
-    if (is_spread) {
-      jsval_t spread_result = append_spread_to_utarray(js, args, arg);
-      if (is_err(spread_result)) { *err_out = spread_result; return -1; }
-    } else utarray_push_back(args, &arg);
-    if (next(js) == TOK_COMMA) js->consumed = 1;
-  }
-  
-  return (int)utarray_len(args);
-}
-
-static jsval_t call_c(struct js *js, jsval_t (*fn)(struct js *, jsval_t *, int)) {
-  UT_array *args;
-  utarray_new(args, &jsval_icd);
-  jsval_t err, res;
-  
-  int argc = parse_call_args(js, args, &err);
-  if (argc < 0) { utarray_free(args); return err; }
-  
-  jsval_t *argv = (jsval_t *)utarray_front(args);
-  jsval_t saved_this = js->this_val;
-  js->this_val = peek_this();
-  res = fn(js, argv, argc);
-  js->this_val = saved_this;
-  
-  utarray_free(args);
-  return res;
-}
-
-static jsoff_t extract_default_param_value(const char *fn, jsoff_t fnlen, jsoff_t start_pos, jsoff_t *out_start, jsoff_t *out_len) {
-  jsoff_t after_ident = skiptonext(fn, fnlen, start_pos, NULL);
-  if (after_ident >= fnlen || fn[after_ident] != '=') {
-    *out_start = 0;
-    *out_len = 0;
-    return after_ident;
-  }
-  
-  jsoff_t default_start = skiptonext(fn, fnlen, after_ident + 1, NULL);
-  jsoff_t default_len = 0;
-  jsoff_t depth = 0;
-  bool in_string = false;
-  char string_char = 0;
-  
-  for (jsoff_t i = default_start; i < fnlen; i++) {
-    if (in_string) {
-      if (fn[i] == '\\' && i + 1 < fnlen) {
-        default_len += 2;
-        i++;
-        continue;
-      }
-      if (fn[i] == string_char) {
-        in_string = false;
-      }
-      default_len++;
-    } else {
-      if (fn[i] == '"' || fn[i] == '\'' || fn[i] == '`') {
-        in_string = true;
-        string_char = fn[i];
-        default_len++;
-      } else if (fn[i] == '(' || fn[i] == '[' || fn[i] == '{') {
-        depth++;
-        default_len++;
-      } else if (fn[i] == ')' || fn[i] == ']' || fn[i] == '}') {
-        if (depth == 0 && fn[i] == ')') break;
-        depth--;
-        default_len++;
-      } else if (depth == 0 && fn[i] == ',') {
-        break;
-      } else {
-        default_len++;
-      }
-    }
-  }
-  
-  *out_start = default_start;
-  *out_len = default_len;
-  return skiptonext(fn, fnlen, default_start + default_len, NULL);
-}
-
-static jsoff_t skip_default_expr(const char *p, jsoff_t len, jsoff_t pos) {
-  int depth = 0;
-  while (pos < len) {
-    char c = p[pos];
-    if (c == '(' || c == '[' || c == '{') depth++;
-    else if (c == ')' || c == ']' || c == '}') { if (depth == 0) break; depth--; }
-    else if (c == ',' && depth == 0) break;
-    pos++;
-  }
-  return pos;
-}
-
-static jsoff_t destruct_source_len(struct js *js, jsval_t val) {
-  if (vtype(val) == T_STR) {
-    size_t slen = 0;
-    (void)js_getstr(js, val, &slen);
-    return (jsoff_t)slen;
-  }
-  return js_arr_len(js, val);
-}
-
-static jsval_t destruct_source_get(struct js *js, jsval_t val, jsoff_t idx) {
-  if (vtype(val) == T_STR) {
-    size_t slen = 0;
-    char *s = js_getstr(js, val, &slen);
-    if ((size_t)idx >= slen) return js_mkundef();
-    return js_mkstr(js, &s[idx], 1);
-  }
-  return js_arr_get(js, val, idx);
-}
-
-static jsval_t destruct_get_by_key(struct js *js, jsval_t obj, jsval_t key) {
-  if (!is_object_type(obj)) return js_mkerr(js, "invalid assignment target");
-  if (vtype(key) == T_SYMBOL) {
-    char sym_buf[32];
-    int klen = sym_to_prop_key(key, sym_buf, sizeof(sym_buf));
-    if (klen < 0) return js_mkerr(js, "invalid symbol key");
-    return getprop_any(js, obj, sym_buf, (size_t)klen);
-  }
-  jsval_t key_str = coerce_to_str(js, key);
-  if (is_err(key_str)) return key_str;
-  jsoff_t klen = 0, koff = vstr(js, key_str, &klen);
-  return getprop_any(js, obj, (const char *)&js->mem[koff], (size_t)klen);
-}
-
-static jsval_t destruct_set_by_key(struct js *js, jsval_t obj, jsval_t key, jsval_t value) {
-  if (!is_object_type(obj)) return js_mkerr(js, "invalid assignment target");
-  if (vtype(key) == T_SYMBOL) {
-    char sym_buf[32];
-    int klen = sym_to_prop_key(key, sym_buf, sizeof(sym_buf));
-    if (klen < 0) return js_mkerr(js, "invalid symbol key");
-    return js_setprop(js, obj, js_mkstr(js, sym_buf, (size_t)klen), value);
-  }
-  jsval_t key_str = coerce_to_str(js, key);
-  if (is_err(key_str)) return key_str;
-  return js_setprop(js, obj, key_str, value);
-}
-
-static bool scan_balanced_with_strings(const char *p, jsoff_t len, jsoff_t *pos, char open, char close) {
-  if (*pos >= len || p[*pos] != open) return false;
-
-  int depth = 1;
-  bool in_string = false;
-  char string_char = '\0';
-  (*pos)++;
-
-  while (*pos < len && depth > 0) {
-    char ch = p[*pos];
-    if (in_string) {
-      if (ch == '\\' && *pos + 1 < len) {
-        *pos += 2;
-        continue;
-      }
-      if (ch == string_char) {
-        in_string = false;
-        string_char = '\0';
-      }
-      (*pos)++;
-      continue;
-    }
-    if (ch == '"' || ch == '\'' || ch == '`') {
-      in_string = true;
-      string_char = ch;
-      (*pos)++;
-      continue;
-    }
-    if (ch == open) depth++;
-    else if (ch == close) depth--;
-    (*pos)++;
-  }
-  return depth == 0;
-}
-
-static jsval_t parse_nested_pattern_span(
-  struct js *js, const char *p, jsoff_t len, jsoff_t *pos,
-  jsoff_t *out_start, jsoff_t *out_len
-) {
-  char open = p[*pos];
-  char close = (open == '[') ? ']' : '}';
-
-  *out_start = *pos;
-  if (!scan_balanced_with_strings(p, len, pos, open, close)) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "unclosed nested destructuring pattern");
-  }
-  *out_len = *pos - *out_start;
-  return js_mkundef();
-}
-
-static jsval_t eval_computed_key_expr(
-  struct js *js, const char *p, jsoff_t len, jsoff_t *pos, const char *unclosed_msg
-) {
-  jsoff_t expr_start = *pos + 1;
-  if (!scan_balanced_with_strings(p, len, pos, '[', ']')) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "%s", unclosed_msg);
-  }
-
-  jsoff_t expr_end = *pos - 1;
-  jsval_t key = js_eval_str(js, &p[expr_start], expr_end - expr_start);
-  if (is_err(key)) return key;
-  return resolveprop(js, key);
-}
-
-static jsval_t extend_destruct_target_span(
-  struct js *js, const char *p, jsoff_t len, jsoff_t target_pos,
-  jsoff_t *target_len, jsoff_t *out_pos
-) {
-  jsoff_t pos = skiptonext(p, len, target_pos + *target_len, NULL);
-
-  while (pos < len && (p[pos] == '.' || p[pos] == '[')) {
-    if (p[pos] == '.') {
-      pos = skiptonext(p, len, pos + 1, NULL);
-      jsoff_t ident_len = 0;
-      if (parseident(&p[pos], len - pos, &ident_len) != TOK_IDENTIFIER) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected after '.'");
-      }
-      pos += ident_len;
-      pos = skiptonext(p, len, pos, NULL);
-      *target_len = pos - target_pos;
-      continue;
-    }
-
-    if (!scan_balanced_with_strings(p, len, &pos, '[', ']')) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "']' expected");
-    }
-    pos = skiptonext(p, len, pos, NULL);
-    *target_len = pos - target_pos;
-  }
-
-  *out_pos = pos;
-  return js_mkundef();
-}
-
-static jsval_t make_destruct_rest_array(struct js *js, jsval_t val, jsoff_t start_idx) {
-  jsval_t rest = js_mkarr(js);
-  if (is_err(rest)) return rest;
-
-  jsoff_t alen = destruct_source_len(js, val);
-  for (jsoff_t i = start_idx; i < alen; i++) {
-    js_arr_push(js, rest, destruct_source_get(js, val, i));
-  }
-  return rest;
-}
-
-static jsval_t assign_destruct_target(struct js *js, const char *p, jsoff_t len, jsval_t value, jsval_t scope) {
-  jsoff_t pos = skiptonext(p, len, 0, NULL);
-  jsoff_t base_len = 0;
-  if (parseident(&p[pos], len - pos, &base_len) != TOK_IDENTIFIER) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid assignment target in destructuring");
-  }
-
-  jsoff_t base_pos = pos;
-  pos += base_len;
-  pos = skiptonext(p, len, pos, NULL);
-  if (pos >= len) {
-    jsval_t vname = js_mkstr(js, &p[base_pos], base_len);
-    return js_setprop(js, scope, vname, value);
-  }
-
-  jsval_t cur = getprop_any(js, scope, &p[base_pos], (size_t)base_len);
-  if (is_err(cur)) return cur;
-
-  while (pos < len) {
-    if (p[pos] == '.') {
-      pos = skiptonext(p, len, pos + 1, NULL);
-      jsoff_t nlen = 0;
-      if (parseident(&p[pos], len - pos, &nlen) != TOK_IDENTIFIER) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected after '.'");
-      }
-      jsval_t key = js_mkstr(js, &p[pos], nlen);
-      pos += nlen;
-      pos = skiptonext(p, len, pos, NULL);
-      if (pos >= len) return destruct_set_by_key(js, cur, key, value);
-      cur = destruct_get_by_key(js, cur, key);
-      if (is_err(cur)) return cur;
-      continue;
-    }
-
-    if (p[pos] == '[') {
-      jsval_t key = eval_computed_key_expr(js, p, len, &pos, "']' expected");
-      if (is_err(key)) return key;
-      pos = skiptonext(p, len, pos, NULL);
-      if (pos >= len) return destruct_set_by_key(js, cur, key, value);
-      cur = destruct_get_by_key(js, cur, key);
-      if (is_err(cur)) return cur;
-      continue;
-    }
-
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid assignment target in destructuring");
-  }
-  return js_mkundef();
-}
-
-static jsval_t bind_destruct_pattern(struct js *js, const char *p, jsoff_t len, jsval_t val, jsval_t scope) {
-  jsoff_t pos = skiptonext(p, len, 0, NULL);
-  if (pos >= len) return js_mkundef();
-  
-  bool is_arr = (p[pos] == '[');
-  if (!is_arr && p[pos] != '{') return js_mkerr(js, "invalid destructuring pattern");
-  
-  pos++;
-  int idx = 0;
-  
-  while (pos < len) {
-    pos = skiptonext(p, len, pos, NULL);
-    if (pos >= len) break;
-    if ((is_arr && p[pos] == ']') || (!is_arr && p[pos] == '}')) break;
-    if (p[pos] == ',') { pos++; idx++; continue; }
-
-    if (is_arr && (p[pos] == '[' || p[pos] == '{')) {
-      jsoff_t nested_start = 0, nested_len = 0;
-      jsval_t nested_res = parse_nested_pattern_span(js, p, len, &pos, &nested_start, &nested_len);
-      if (is_err(nested_res)) return nested_res;
-
-      jsval_t elem_val = destruct_source_get(js, val, idx);
-      jsval_t r = bind_destruct_pattern(js, &p[nested_start], nested_len, elem_val, scope);
-      if (is_err(r)) return r;
-      idx++;
-      pos = skiptonext(p, len, pos, NULL);
-      if (pos < len && p[pos] == ',') pos++;
-      continue;
-    }
-    
-    bool is_rest = (pos + 2 < len && p[pos] == '.' && p[pos+1] == '.' && p[pos+2] == '.');
-    if (is_rest) { pos += 3; pos = skiptonext(p, len, pos, NULL); }
-
-    if (is_arr && is_rest && pos < len && (p[pos] == '[' || p[pos] == '{')) {
-      jsoff_t nested_start = 0, nested_len = 0;
-      jsval_t nested_res = parse_nested_pattern_span(js, p, len, &pos, &nested_start, &nested_len);
-      if (is_err(nested_res)) return nested_res;
-
-      jsval_t rest = make_destruct_rest_array(js, val, idx);
-      if (is_err(rest)) return rest;
-
-      jsval_t r = bind_destruct_pattern(js, &p[nested_start], nested_len, rest, scope);
-      if (is_err(r)) return r;
-
-      idx = (int)destruct_source_len(js, val);
-      pos = skiptonext(p, len, pos, NULL);
-      if (pos < len && p[pos] == ',') pos++;
-      continue;
-    }
-    
-    bool has_computed_key = false;
-    jsval_t computed_key = js_mkundef();
-    jsoff_t name_len = 0;
-    jsoff_t var_pos = 0, var_len = 0;
-    jsoff_t src_pos = 0, src_len = 0;
-    jsoff_t target_pos = 0, target_len = 0;
-
-    if (!is_arr && p[pos] == '[') {
-      has_computed_key = true;
-      computed_key = eval_computed_key_expr(js, p, len, &pos, "unclosed computed property name");
-      if (is_err(computed_key)) return computed_key;
-    } else {
-      if (parseident(&p[pos], len - pos, &name_len) != TOK_IDENTIFIER) break;
-      var_pos = pos;
-      var_len = name_len;
-      src_pos = pos;
-      src_len = name_len;
-      target_pos = pos;
-      target_len = name_len;
-      pos += name_len;
-    }
-    pos = skiptonext(p, len, pos, NULL);
-    
-    bool is_nested = false;
-    jsoff_t nested_start = 0, nested_len = 0;
-    
-    if (!is_arr && !is_rest && pos < len && p[pos] == ':') {
-      pos = skiptonext(p, len, pos + 1, NULL);
-      
-      if (pos < len && (p[pos] == '{' || p[pos] == '[')) {
-        is_nested = true;
-        jsval_t nested_res = parse_nested_pattern_span(js, p, len, &pos, &nested_start, &nested_len);
-        if (is_err(nested_res)) return nested_res;
-        pos = skiptonext(p, len, pos, NULL);
-      } else {
-        jsoff_t rlen = 0;
-        if (parseident(&p[pos], len - pos, &rlen) == TOK_IDENTIFIER) {
-          var_pos = pos; var_len = rlen;
-          target_pos = pos; target_len = rlen;
-          pos += rlen;
-          pos = skiptonext(p, len, pos, NULL);
-        }
-      }
-    } else if (!is_arr && has_computed_key) {
-      return js_mkerr(js, "':' expected after computed property name");
-    }
-
-    if (target_len > 0) {
-      jsval_t span_res = extend_destruct_target_span(js, p, len, target_pos, &target_len, &pos);
-      if (is_err(span_res)) return span_res;
-    }
-    
-    jsval_t prop_val;
-    if (is_rest && is_arr) {
-      prop_val = make_destruct_rest_array(js, val, idx);
-      if (is_err(prop_val)) return prop_val;
-    } else if (is_rest) prop_val = mkobj(js, 0);
-    else if (is_arr) prop_val = destruct_source_get(js, val, idx);
-    else if (has_computed_key) prop_val = destruct_get_by_key(js, val, computed_key);
-    else prop_val = getprop_any(js, val, &p[src_pos], src_len);
-    if (is_err(prop_val)) return prop_val;
-    
-    if (is_nested) {
-      jsval_t r = bind_destruct_pattern(js, &p[nested_start], nested_len, prop_val, scope);
-      if (is_err(r)) return r;
-      idx++; pos = skiptonext(p, len, pos, NULL);
-      if (pos < len && p[pos] == ',') pos++;
-      continue;
-    }
-    
-    if (is_rest) goto bind;
-    if (pos >= len || p[pos] != '=') goto bind;
-    
-    pos++;
-    jsoff_t def_start = pos;
-    pos = skip_default_expr(p, len, pos);
-    if (vtype(prop_val) != T_UNDEF) goto bind;
-    
-    prop_val = js_eval_str(js, &p[def_start], pos - def_start);
-    if (is_err(prop_val)) return prop_val;
-    prop_val = resolveprop(js, prop_val);
-    
-bind:;
-    jsval_t r;
-    if (target_len > 0) r = assign_destruct_target(js, &p[target_pos], target_len, prop_val, scope);
-    else {
-      jsval_t vname = js_mkstr(js, &p[var_pos], var_len);
-      if (is_err(vname)) return vname;
-      r = js_setprop(js, scope, vname, prop_val);
-    }
-    if (is_err(r)) return r;
-    
-    idx++;
-    pos = skiptonext(p, len, pos, NULL);
-    if (pos < len && p[pos] == ',') pos++;
-  }
-  
-  return js_mkundef();
-}
-
-static bool is_strict_function_body(const char *body, size_t len) {
-  size_t i = 0;
-  while (i < len && (body[i] == ' ' || body[i] == '\t' || body[i] == '\n' || body[i] == '\r')) i++;
-  if (i + 12 <= len && (body[i] == '\'' || body[i] == '"')) {
-    char q = body[i];
-    if (memcmp(&body[i+1], "use strict", 10) == 0 && body[i+11] == q) return true;
-  }
-  return false;
-}
-
-static bool code_uses_arguments(const char *code, jsoff_t len) {
-  if (len < 9) return false;
-  for (jsoff_t i = 0; i + 8 < len; i++) {
-    if (code[i] == 'a' && memcmp(&code[i], INTERN_ARGUMENTS, 9) == 0) {
-      if (i > 0 && (is_alpha(code[i-1]) || code[i-1] == '_' || (code[i-1] >= '0' && code[i-1] <= '9'))) continue;
-      if (i + 9 < len && (is_alpha(code[i+9]) || code[i+9] == '_' || (code[i+9] >= '0' && code[i+9] <= '9'))) continue;
-      return true;
-    }
-  } return false;
-}
-
-static inline int find_statement_end(const token_stream_t *restrict ts, int start) {
-  const cached_token_t *restrict toks = ts->tokens;
-  const int count = ts->count;
-  if (start >= count) return count;
-
-  static const void *dispatch[] = {
-    [TOK_LPAREN]    = &&open,
-    [TOK_LBRACKET]  = &&open,
-    [TOK_LBRACE]    = &&open,
-    [TOK_RPAREN]    = &&close,
-    [TOK_RBRACKET]  = &&close,
-    [TOK_RBRACE]    = &&close,
-    [TOK_SEMICOLON] = &&semi,
-    [TOK_EOF]       = &&semi,
-  };
-  
-  int depth = 0;
-  int j = start;
-  
-  for (;;) {
-    uint8_t t = toks[j].tok;
-    if (t < sizeof(dispatch) / sizeof(*dispatch) && dispatch[t]) goto *dispatch[t];
-    
-  next:
-    if (++j >= count) return count;
-    continue;
-    
-  open:
-    depth++;
-    goto next;
-    
-  close:
-    if (depth == 0) return j;
-    depth--;
-    goto next;
-    
-  semi:
-    if (depth == 0) return j;
-    goto next;
-  }
-}
-
-
-static inline void find_top_level_tokens(
-  const token_stream_t *restrict ts, int start, int end,
-  uint8_t tok1, int *restrict first_tok1,
-  uint8_t tok2, int *restrict first_tok2_after_tok1
-) {
-  const cached_token_t *restrict toks = ts->tokens;
-  int depth = 0;
-  int j = start;
-
-  for (; j < end; j++) {
-    uint8_t t = toks[j].tok;
-    if (t == TOK_LPAREN || t == TOK_LBRACKET) depth++;
-    else if (t == TOK_RPAREN || t == TOK_RBRACKET) depth--;
-    else if (depth == 0 && t == tok1) {
-      *first_tok1 = j;
-      if (!tok2 || !first_tok2_after_tok1) return;
-      j++; goto phase2;
-    }
-  }
-  
-  *first_tok1 = -1;
-  if (first_tok2_after_tok1) *first_tok2_after_tok1 = -1;
-  return;
-
-phase2:
-  for (; j < end; j++) {
-    uint8_t t = toks[j].tok;
-    if (t == TOK_LPAREN || t == TOK_LBRACKET) depth++;
-    else if (t == TOK_RPAREN || t == TOK_RBRACKET) depth--;
-    else if (depth == 0 && t == tok2) { *first_tok2_after_tok1 = j; return; }
-  }
-  *first_tok2_after_tok1 = -1;
-}
-
-static inline int find_last_top_level_token(const token_stream_t *restrict ts, int start, int end, uint8_t tok) {
-  const cached_token_t *restrict toks = ts->tokens;
-  int depth = 0;
-  for (int j = end - 1; j >= start; j--) {
-    uint8_t t = toks[j].tok;
-    if (t == TOK_RPAREN || t == TOK_RBRACKET) depth++;
-    else if (t == TOK_LPAREN || t == TOK_LBRACKET) depth--;
-    else if (depth == 0 && t == tok) return j;
-  }
-  return -1;
-}
-
-static inline int find_matching_open(const token_stream_t *restrict ts, int rparen_idx) {
-  const cached_token_t *restrict toks = ts->tokens;
-  int depth = 0;
-  for (int j = rparen_idx; j >= 0; j--) {
-    uint8_t t = toks[j].tok;
-    if (t == TOK_RPAREN) depth++;
-    else if (t == TOK_LPAREN) if (--depth == 0) return j;
-  }
-  return -1;
-}
-
-static inline bool expr_ends_with_bare_call(const token_stream_t *restrict ts, int start, int end) {
-  if (start >= end) return false;
-
-  const cached_token_t *restrict toks = ts->tokens;
-  if (toks[end - 1].tok != TOK_RPAREN) return false;
-
-  int depth = 0;
-  for (int j = start; j < end - 1; j++) {
-    uint8_t t = toks[j].tok;
-    if (t == TOK_LPAREN || t == TOK_LBRACKET) depth++;
-    else if (t == TOK_RPAREN || t == TOK_RBRACKET) depth--;
-  }
-
-  if (depth != 1) return false;
-  int match = find_matching_open(ts, end - 1);
-  if (match < 0 || match <= start) return false;
-
-  uint8_t before = toks[match - 1].tok;
-  return before == TOK_IDENTIFIER || before == TOK_RPAREN || before == TOK_RBRACKET;
-}
-
-static inline bool return_expr_is_tail_call(
-  const token_stream_t *restrict ts, int start,
-  const char *body, jsoff_t body_len
-) {
-  int end = find_statement_end(ts, start);
-  int last = end - 1;
-  
-  if (last < start) return false;
-  const int count = ts->count;
-
-  int ternary, colon;
-  find_top_level_tokens(ts, start, end, TOK_Q, &ternary, TOK_COLON, &colon);
-
-  if (ternary >= 0) {
-    if (colon < 0) return false;
-    jsoff_t then_start = ts->tokens[ternary + 1].toff;
-    jsoff_t then_end   = ts->tokens[colon].toff;
-    jsoff_t else_start = (colon + 1 < count) ? ts->tokens[colon + 1].toff : body_len;
-    jsoff_t else_end   = (end < count) ? ts->tokens[end].toff : body_len;
-
-    int then_r = scan_tail_span(body, body_len, then_start, then_end);
-    if (then_r == TAIL_UNSAFE) return false;
-    int else_r = scan_tail_span(body, body_len, else_start, else_end);
-
-    return else_r != TAIL_UNSAFE && (then_r == TAIL_OK || else_r == TAIL_OK);
-  }
-
-  int last_comma = find_last_top_level_token(ts, start, end, TOK_COMMA);
-  if (last_comma >= 0) return return_expr_is_tail_call(ts, last_comma + 1, body, body_len);
-
-  return expr_ends_with_bare_call(ts, start, end);
-}
-
-static inline bool tokens_have_tail_calls(
-  const token_stream_t *restrict ts,
-  const char *body, jsoff_t body_len, bool is_expr
-) {
-  if (!ts || ts->count == 0) return false;
-  if (is_expr) return return_expr_is_tail_call(ts, 0, body, body_len);
-
-  const cached_token_t *restrict toks = ts->tokens;
-  const int count = ts->count;
-
-  for (int i = 0; i < count; i++) {
-    if (toks[i].tok != TOK_RETURN) continue;
-
-    int j = i + 1;
-    if (j >= count) continue;
-    uint8_t first = toks[j].tok;
-
-    if (first == TOK_SEMICOLON || first == TOK_RBRACE || first == TOK_EOF) continue;
-    if (return_expr_is_tail_call(ts, j, body, body_len)) return true;
-  }
-
-  return false;
-}
-
-static parsed_func_t *get_or_parse_func(struct js *js, const char *fn, jsoff_t fnlen) {
-  uint64_t h = hash_key(fn, fnlen);
-  parsed_func_t *cached = NULL;
-  HASH_FIND(hh, func_parse_cache, &h, sizeof(h), cached);
-  if (cached) return cached;
-  
-  parsed_func_t *pf = (parsed_func_t *)malloc(sizeof(parsed_func_t));
-  if (!pf) return NULL;
-  memset(pf, 0, sizeof(*pf));
-  pf->code_hash = h;
-  utarray_new(pf->params, &parsed_param_icd);
-  
-  jsoff_t fnpos = 1;
-  
-  while (fnpos < fnlen) {
-    fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-    if (fnpos < fnlen && fn[fnpos] == ')') break;
-    
-    bool is_rest = false;
-    if (fnpos + 3 < fnlen && fn[fnpos] == '.' && fn[fnpos + 1] == '.' && fn[fnpos + 2] == '.') {
-      is_rest = true;
-      pf->has_rest = true;
-      fnpos += 3;
-      fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-    }
-    
-    jsoff_t identlen = 0;
-    
-    uint8_t tok = parseident(&fn[fnpos], fnlen - fnpos, &identlen);
-    bool is_valid_ident = (tok == TOK_IDENTIFIER || is_contextual_keyword(tok));
-    
-    if (!is_valid_ident && (fn[fnpos] == '{' || fn[fnpos] == '[')) {
-      char bracket_open = fn[fnpos];
-      char bracket_close = (bracket_open == '{') ? '}' : ']';
-      
-      jsoff_t pattern_start = fnpos;
-      int depth = 1; fnpos++;
-      
-      while (fnpos < fnlen && depth > 0) {
-        if (fn[fnpos] == bracket_open) depth++;
-        else if (fn[fnpos] == bracket_close) depth--;
-        fnpos++;
-      }
-      jsoff_t pattern_len = fnpos - pattern_start;
-      
-      {
-        parsed_param_t pp = {0};
-        pp.is_destruct = true;
-        pp.pattern_off = pattern_start;
-        pp.pattern_len = pattern_len;
-        
-        fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-        if (fnpos < fnlen && fn[fnpos] == '=') {
-          fnpos = extract_default_param_value(fn, fnlen, fnpos, &pp.default_start, &pp.default_len);
-        }
-        utarray_push_back(pf->params, &pp);
-        pf->param_count++;
-      }
-      
-      if (fnpos < fnlen && fn[fnpos] == ',') fnpos++;
-      continue;
-    }
-    
-    if (!is_valid_ident) break;
-    
-    if (is_rest) {
-      pf->rest_param_start = fnpos;
-      pf->rest_param_len = identlen;
-      fnpos = skiptonext(fn, fnlen, fnpos + identlen, NULL);
-      break;
-    }
-    
-    {
-      parsed_param_t pp = {0};
-      pp.name_off = fnpos;
-      pp.name_len = identlen;
-      pp.is_destruct = false;
-      fnpos = extract_default_param_value(fn, fnlen, fnpos + identlen, &pp.default_start, &pp.default_len);
-      utarray_push_back(pf->params, &pp);
-      pf->param_count++;
-    }
-    
-    if (fnpos < fnlen && fn[fnpos] == ',') fnpos++;
-  }
-  
-  if (fnpos < fnlen && fn[fnpos] == ')') fnpos++;
-  fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-  bool is_block = (fnpos < fnlen && fn[fnpos] == '{');
-  if (is_block) fnpos++;
-  
-  pf->body_start = fnpos;
-  pf->body_len = (fnlen > fnpos) ? (fnlen - fnpos - (is_block ? 1 : 0)) : 0;
-  pf->is_expr = !is_block;
-  pf->is_strict = is_strict_function_body(&fn[fnpos], pf->body_len);
-  pf->uses_arguments = code_uses_arguments(&fn[pf->body_start], pf->body_len);
-  pf->tokens = (pf->body_len > 0) ? tokenize_body(js, &fn[pf->body_start], pf->body_len) : NULL;
-  pf->has_tail_calls = tokens_have_tail_calls(pf->tokens, &fn[pf->body_start], pf->body_len, pf->is_expr);
-  
-  HASH_ADD(hh, func_parse_cache, code_hash, sizeof(pf->code_hash), pf);
-  return pf;
-}
-
-static bool is_eval_or_arguments(struct js *js, jsoff_t toff, jsoff_t tlen) {
-  if (tlen == 4 && memcmp(&js->code[toff], "eval", 4) == 0) return true;
-  if (tlen == 9 && memcmp(&js->code[toff], "arguments", 9) == 0) return true;
-  return false;
-}
-
-static void setup_arguments(struct js *js, jsval_t scope, jsval_t *args, int nargs, bool strict) {
-  if (vtype(js->current_func) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(js->current_func));
-    if (vtype(get_slot(js, func_obj, SLOT_THIS)) != T_UNDEF) return;
-  }
-  
-  jsval_t arguments_obj = mkobj(js, 0);
-  for (int i = 0; i < nargs; i++) {
-    if (i < 10) js_setprop(js, arguments_obj, js_mkstr(js, INTERN_IDX[i], 1), args[i]); else {
-      char idxstr[16];
-      size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)i);
-      js_setprop(js, arguments_obj, js_mkstr(js, idxstr, idxlen), args[i]);
-    }
-  }
-  setprop_interned(js, arguments_obj, INTERN_LENGTH, 6, tov((double) nargs));
-  if (strict) {
-    set_slot(js, arguments_obj, SLOT_STRICT_ARGS, tov(1));
-  } else if (vtype(js->current_func) == T_FUNC) {
-    setprop_interned(js, arguments_obj, INTERN_CALLEE, 6, js->current_func);
-  }
-  
-  const char *toStringTag_key = get_toStringTag_sym_key();
-  if (toStringTag_key && toStringTag_key[0] != '\0') {
-    js_setprop(js, arguments_obj, js_mkstr(js, toStringTag_key, strlen(toStringTag_key)), js_mkstr(js, "Arguments", 9));
-  }
-  
-  const char *iter_key = get_iterator_sym_key();
-  if (iter_key && iter_key[0] != '\0') {
-    jsval_t array_proto = get_prototype_for_type(js, T_ARR);
-    jsval_t iter_fn = is_object_type(array_proto) ? js_get(js, array_proto, iter_key) : js_mkundef();
-    if (vtype(iter_fn) == T_FUNC || vtype(iter_fn) == T_CFUNC) js_setprop(
-      js, arguments_obj, js_mkstr(js, iter_key, strlen(iter_key)), iter_fn
-    );
-  }
-  
-  arguments_obj = mkval(T_ARR, vdata(arguments_obj));
-  setprop_interned(js, scope, INTERN_ARGUMENTS, 9, arguments_obj);
-  
-  if (!strict && vtype(js->current_func) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(js->current_func));
-    setprop_interned(js, func_obj, INTERN_ARGUMENTS, 9, arguments_obj);
-  }
-}
-
-static inline void restore_saved_scope(struct js *js) {
-  if (saved_scope_stack && utarray_len(saved_scope_stack) >= 2) {
-    jsval_t *saved_this_ptr = (jsval_t *)utarray_back(saved_scope_stack);
-    js->this_val = *saved_this_ptr;
-    utarray_pop_back(saved_scope_stack);
-    
-    jsval_t *saved_scope_ptr = (jsval_t *)utarray_back(saved_scope_stack);
-    js->scope = *saved_scope_ptr;
-    utarray_pop_back(saved_scope_stack);
-  }
-}
-
-jsval_t call_js_internal(
-  struct js *js, const char *fn, jsoff_t fnlen,
-  jsval_t closure_scope, jsval_t *bound_args, int bound_argc, jsval_t func_val
-) {
-  if (saved_scope_stack == NULL) utarray_new(saved_scope_stack, &jsval_icd);
-  utarray_push_back(saved_scope_stack, &js->scope);
-  utarray_push_back(saved_scope_stack, &js->this_val);
-
-  jsval_t res; jsval_t *tc_args = NULL;
-  int tc_argc = 0; bool tc_iter = false;
-  bool tc_pushed_this = false;
-
-  for (;;) {
-  jsval_t target_this = peek_this();
-  jsoff_t parent_scope_offset;
-  
-  if (vtype(closure_scope) == T_OBJ) parent_scope_offset = (jsoff_t) vdata(closure_scope);
-  else parent_scope_offset = (jsoff_t) vdata(js->scope);
-  
-  if (global_scope_stack == NULL) utarray_new(global_scope_stack, &jsoff_icd);
-  jsval_t function_scope = mkobj(js, parent_scope_offset);
-  jsoff_t function_scope_offset = (jsoff_t)vdata(function_scope);
-  utarray_push_back(global_scope_stack, &function_scope_offset);
-  
-  jsval_t args_buf[8];
-  jsval_t *args;
-  
-  int argc;
-  bool args_on_heap;
-
-  if (tc_iter) {
-    args = tc_args ? tc_args : args_buf;
-    argc = tc_argc;
-    args_on_heap = (tc_args != NULL && tc_argc > 0);
-    tc_args = NULL; tc_argc = 0; tc_iter = false;
-  } else {
-    const char *caller_code = js->code;
-    jsoff_t caller_clen = js->clen;
-    jsoff_t caller_pos = js->pos;
-
-    args = args_buf;
-    argc = 0;
-    args_on_heap = false;
-    int args_cap = 8;
-    spread_dynargs_ctx_t spread_ctx = {
-      .args = &args,
-      .argc = &argc,
-      .args_cap = &args_cap,
-      .args_on_heap = &args_on_heap
-    };
-
-    for (int i = 0; i < bound_argc; i++) spread_dynargs_push(&spread_ctx, bound_args[i]);
-    caller_pos = skiptonext(caller_code, caller_clen, caller_pos, NULL);
-
-    while (caller_pos < caller_clen && caller_code[caller_pos] != ')') {
-      bool is_spread = (
-        caller_code[caller_pos] == '.' && caller_pos + 2 < caller_clen &&
-        caller_code[caller_pos + 1] == '.' && caller_code[caller_pos + 2] == '.'
-      );
-      if (is_spread) caller_pos += 3;
-      js->pos = caller_pos;
-      js->consumed = 1;
-      jsval_t arg = resolveprop(js, js_expr(js));
-      caller_pos = js->pos;
-      if (is_err(arg)) {
-        if (args_on_heap) free(args);
-        restore_saved_scope(js);
-        if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-        return arg;
-      }
-      if (is_spread) {
-        jsval_t spread_result = append_spread_to_dynargs(js, &spread_ctx, arg);
-        if (is_err(spread_result)) {
-          if (args_on_heap) free(args);
-          restore_saved_scope(js);
-          if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-          return spread_result;
-        }
-      } else spread_dynargs_push(&spread_ctx, arg);
-      caller_pos = skiptonext(caller_code, caller_clen, caller_pos, NULL);
-      if (caller_pos < caller_clen && caller_code[caller_pos] == ',') caller_pos++;
-      caller_pos = skiptonext(caller_code, caller_clen, caller_pos, NULL);
-    }
-
-    js->pos = caller_pos;
-  }
-
-  js->scope = function_scope;
-  parsed_func_t *pf = get_or_parse_func(js, fn, fnlen);
-  
-  if (!pf) {
-    if (args_on_heap) free(args);
-    restore_saved_scope(js);
-    if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-    return js_mkerr(js, "failed to parse function");
-  }
-  
-  bool func_strict = pf->is_strict;
-  if (!func_strict && vtype(func_val) == T_FUNC) {
-    jsval_t strict_slot = get_slot(js, mkval(T_OBJ, vdata(func_val)), SLOT_STRICT);
-    func_strict = (vtype(strict_slot) == T_BOOL && vdata(strict_slot) == 1);
-  }
-  
-  if (func_strict && (vtype(target_this) == T_UNDEF || vtype(target_this) == T_NULL ||
-      (vtype(target_this) == T_OBJ && vdata(target_this) == 0))) {
-    js->this_val = js_mkundef();
-  } else js->this_val = target_this;
-  
-  int argi = 0;
-  for (int i = 0; i < pf->param_count; i++) {
-    parsed_param_t *pp = (parsed_param_t *)utarray_eltptr(pf->params, (unsigned int)i);
-    
-    if (pp->is_destruct) {
-      jsval_t arg_val = (argi < argc) ? args[argi++] : js_mkundef();
-      if (vtype(arg_val) == T_UNDEF && pp->default_len > 0) {
-        arg_val = js_eval_str(js, &fn[pp->default_start], pp->default_len);
-      }
-      jsval_t r = bind_destruct_pattern(js, &fn[pp->pattern_off], pp->pattern_len, arg_val, function_scope);
-      if (is_err(r)) {
-        if (args_on_heap) free(args);
-        restore_saved_scope(js);
-        if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-        return r;
-      }
-    } else {
-      jsval_t v;
-      if (argi < argc) v = args[argi++];
-      else if (pp->default_len > 0) v = js_eval_str(js, &fn[pp->default_start], pp->default_len);
-      else v = js_mkundef();
-      jsval_t k = js_mkstr(js, &fn[pp->name_off], pp->name_len);
-      if (!is_err(k)) mkprop_fast(js, function_scope, k, v, 0);
-    }
-  }
-  
-  if (pf->has_rest && pf->rest_param_len > 0) {
-    jsval_t rest_array = mkarr(js);
-    if (!is_err(rest_array)) {
-      jsoff_t idx = 0;
-      while (argi < argc) { arr_set(js, rest_array, idx, args[argi++]); idx++; }
-      rest_array = mkval(T_ARR, vdata(rest_array));
-      js_setprop(js, function_scope, js_mkstr(js, &fn[pf->rest_param_start], pf->rest_param_len), rest_array);
-    }
-  }
-  
-  bool needs_arguments = pf->uses_arguments;
-  if (needs_arguments) setup_arguments(js, function_scope, args, argc, func_strict);
-  
-   jsval_t slot_name = get_slot(js, func_val, SLOT_NAME);
-   if (vtype(slot_name) == T_STR && vtype(func_val) == T_FUNC) {
-     jsoff_t len;
-     (void)vstr(js, slot_name, &len);
-     if (len > 0) mkprop_fast(js, function_scope, slot_name, func_val, CONSTMASK);
-   }
-  
-  if (vtype(func_val) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(func_val));
-    hoist_var_declarations_from_slot(js, function_scope, func_obj);
-    jsval_t no_func_decls = get_slot(js, func_obj, SLOT_NO_FUNC_DECLS);
-    js->skip_func_hoist = (vtype(no_func_decls) == T_BOOL && vdata(no_func_decls) == 1);
-  } else js->skip_func_hoist = false;
-  
-  js->flags = F_CALL | (func_strict ? F_STRICT : 0);
-  void *saved_token_stream = js->token_stream;
-  
-  int saved_token_stream_pos = js->token_stream_pos;
-  const char *saved_token_stream_code = js->token_stream_code;
-  
-  if (pf->tokens) {
-    js->token_stream = pf->tokens;
-    js->token_stream_pos = 0;
-    js->token_stream_code = &fn[pf->body_start];
-  } else {
-    js->token_stream = NULL;
-    js->token_stream_code = NULL;
-  }
-  
-  bool saved_has_tail = js->has_tail_calls;
-  js->has_tail_calls = pf->has_tail_calls;
-
-  if (pf->is_expr) {
-    js->tail_ctx = pf->has_tail_calls;
-    res = js_eval_str(js, &fn[pf->body_start], pf->body_len);
-    js->tail_ctx = false;
-    if (res != (jsval_t)T_TAILCALL) res = resolveprop(js, res);
-  } else {
-    js->tail_ctx = false;
-    res = js_eval(js, &fn[pf->body_start], pf->body_len);
-    if (!is_err(res) && !(js->flags & F_RETURN)) res = js_mkundef();
-  }
-
-  js->has_tail_calls = saved_has_tail;
-  js->token_stream = saved_token_stream;
-  js->token_stream_pos = saved_token_stream_pos;
-  js->token_stream_code = saved_token_stream_code;
-  
-  js->skip_func_hoist = false;
-  
-  if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-  if (args_on_heap) free(args);
-
-  if (res == (jsval_t)T_TAILCALL && js->tc.pending) {
-    js->tc.pending = false;
-    fn = js->tc.code_str;
-    fnlen = js->tc.fnlen;
-    closure_scope = js->tc.closure_scope;
-    func_val = js->tc.func;
-    if (tc_pushed_this) pop_this();
-    push_this(js->tc.this_val);
-    tc_pushed_this = true;
-    bound_args = NULL;
-    bound_argc = 0;
-    tc_args = js->tc.args;
-    js->tc.args = NULL;
-    tc_argc = js->tc.argc;
-    tc_iter = true;
-    continue;
-  }
-
-  break;
-  } // end trampoline
-  if (tc_pushed_this) pop_this();
-
-  free(tc_args);
-  tc_args = NULL;
-  free(js->tc.args);
-  js->tc.args = NULL;
-
-  restore_saved_scope(js);
-  assert(res != (jsval_t)T_TAILCALL && "T_TAILCALL escaped call_js_internal");
-  return res;
-}
-
-jsval_t call_js(struct js *js, const char *fn, jsoff_t fnlen, jsval_t closure_scope) {
-  return call_js_internal(js, fn, fnlen, closure_scope, NULL, 0, js_mkundef());
-}
-
-jsval_t call_js_with_args(struct js *js, jsval_t func, jsval_t *args, int nargs) {
-  if (vtype(func) == T_CFUNC) {
-    jsval_t (*fn)(struct js *, jsval_t *, int) = (jsval_t(*)(struct js *, jsval_t *, int)) vdata(func);
-    return fn(js, args, nargs);
-  }
-  
-  if (vtype(func) != T_FUNC) return js_mkerr(js, "not a function");
-  jsval_t func_obj = mkval(T_OBJ, vdata(func));
-  
-  jsval_t *combined_args = NULL;
-  int combined_nargs = nargs;
-  int bound_argc = 0;
-  
-  jsval_t bound_arr = get_slot(js, func_obj, SLOT_BOUND_ARGS);
-  if (vtype(bound_arr) == T_ARR) {
-    bound_argc = (int) get_array_length(js, bound_arr);
-    
-    if (bound_argc > 0) {
-      combined_nargs = bound_argc + nargs;
-      combined_args = (jsval_t *)ant_calloc(sizeof(jsval_t) * combined_nargs);
-      if (combined_args) {
-        for (int i = 0; i < bound_argc; i++) combined_args[i] = arr_get(js, bound_arr, (jsoff_t)i);
-        for (int i = 0; i < nargs; i++) combined_args[bound_argc + i] = args[i];
-        args = combined_args; nargs = combined_nargs;
-      }
-    }
-  }
-
-  jsval_t cfunc_slot = get_slot(js, func_obj, SLOT_CFUNC);
-  if (vtype(cfunc_slot) == T_CFUNC) {
-    jsval_t bound_this = get_slot(js, func_obj, SLOT_BOUND_THIS);
-    
-    jsval_t saved_this = js->this_val;
-    if (vtype(bound_this) != T_UNDEF) {
-      push_this(bound_this);
-      js->this_val = bound_this;
-    }
-    
-    jsval_t saved_func = js->current_func;
-    js->current_func = func;
-    
-    jsval_t (*fn)(struct js *, jsval_t *, int) = (jsval_t(*)(struct js *, jsval_t *, int)) vdata(cfunc_slot);
-    jsval_t result = fn(js, args, nargs);
-    
-    js->current_func = saved_func;
-    if (vtype(bound_this) != T_UNDEF) {
-      pop_this();
-      js->this_val = saved_this;
-    }
-    
-    if (combined_args) free(combined_args);
-    return result;
-  }
-  
-  jsoff_t fnlen;
-  const char *fn = get_func_code(js, func_obj, &fnlen);
-  if (!fn) {
-    if (combined_args) free(combined_args);
-    return js_mkerr(js, "function has no code");
-  }
-  
-  jsval_t closure_scope = get_slot(js, func_obj, SLOT_SCOPE);
-  jsval_t saved_super = js->super_val;
-  
-  jsval_t func_super = get_slot(js, func_obj, SLOT_SUPER);
-  if (vtype(func_super) != T_UNDEF) js->super_val = func_super;
-  
-  jsval_t captured_this = get_slot(js, func_obj, SLOT_THIS);
-  if (vtype(captured_this) != T_UNDEF) {
-    pop_this();
-    push_this(captured_this);
-  }
-  
-  jsval_t bound_this = get_slot(js, func_obj, SLOT_BOUND_THIS);
-  if (vtype(bound_this) != T_UNDEF) {
-    pop_this();
-    push_this(bound_this);
-  }
-  
-  jsval_t result = call_js_code_with_args(js, fn, fnlen, closure_scope, args, nargs, func);
-  js->super_val = saved_super;
-  if (combined_args) free(combined_args);
-  
-  return result;
-}
-
-jsval_t call_js_code_with_args(struct js *js, const char *fn, jsoff_t fnlen, jsval_t closure_scope, jsval_t *args, int nargs, jsval_t func_val) {
-  jsoff_t parent_scope_offset;
-  if (vtype(closure_scope) == T_OBJ) {
-    parent_scope_offset = (jsoff_t) vdata(closure_scope);
-  } else parent_scope_offset = (jsoff_t) vdata(js->scope);
-  
-  jsval_t saved_scope = js->scope;
-  if (global_scope_stack == NULL) utarray_new(global_scope_stack, &jsoff_icd);
-   jsval_t function_scope = mkobj(js, parent_scope_offset);
-   jsoff_t function_scope_offset = (jsoff_t) vdata(function_scope);
-   utarray_push_back(global_scope_stack, &function_scope_offset);
-   js->scope = function_scope;
-   
-   jsval_t slot_name = get_slot(js, func_val, SLOT_NAME);
-   if (vtype(slot_name) == T_STR && vtype(func_val) == T_FUNC) {
-     jsoff_t len; vstr(js, slot_name, &len);
-     if (len > 0) mkprop(js, function_scope, slot_name, func_val, CONSTMASK);
-   }
-   
-  jsval_t func_obj = mkval(T_OBJ, vdata(func_val));
-  hoist_var_declarations_from_slot(js, function_scope, func_obj);
-  
-  jsoff_t fnpos = 1;
-  int arg_idx = 0;
-  bool has_rest = false;
-  jsoff_t rest_param_start = 0, rest_param_len = 0;
-  
-  while (fnpos < fnlen) {
-    fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-    if (fnpos < fnlen && fn[fnpos] == ')') break;
-    
-    bool is_rest = false;
-    if (fnpos + 3 < fnlen && fn[fnpos] == '.' && fn[fnpos + 1] == '.' && fn[fnpos + 2] == '.') {
-      is_rest = true;
-      has_rest = true;
-      fnpos += 3;
-      fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-    }
-    
-    jsoff_t identlen = 0;
-    uint8_t tok = parseident(&fn[fnpos], fnlen - fnpos, &identlen);
-    
-    fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-    if (tok != TOK_IDENTIFIER && fnpos < fnlen && (fn[fnpos] == '{' || fn[fnpos] == '[')) {
-      char bracket_open = fn[fnpos];
-      char bracket_close = (bracket_open == '{') ? '}' : ']';
-      jsoff_t pattern_start = fnpos;
-      int depth = 1;
-      fnpos++;
-      while (fnpos < fnlen && depth > 0) {
-        if (fn[fnpos] == bracket_open) depth++;
-        else if (fn[fnpos] == bracket_close) depth--;
-        fnpos++;
-      }
-      jsoff_t pattern_len = fnpos - pattern_start;
-      
-      jsval_t arg_val = (arg_idx < nargs) ? args[arg_idx] : js_mkundef();
-      jsval_t r = bind_destruct_pattern(js, &fn[pattern_start], pattern_len, arg_val, function_scope);
-      if (is_err(r)) return r;
-      
-      arg_idx++;
-      fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-      if (fnpos < fnlen && fn[fnpos] == ',') fnpos++;
-      continue;
-    }
-    
-    if (tok != TOK_IDENTIFIER) break;
-    
-    if (is_rest) {
-      rest_param_start = fnpos;
-      rest_param_len = identlen;
-      fnpos = skiptonext(fn, fnlen, fnpos + identlen, NULL);
-      break;
-    }
-    
-    jsoff_t param_name_pos = fnpos;
-    jsoff_t default_start = 0, default_len = 0;
-    fnpos = extract_default_param_value(fn, fnlen, fnpos + identlen, &default_start, &default_len);
-    
-    jsval_t v;
-    if (arg_idx < nargs) {
-      v = args[arg_idx];
-    } else if (default_len > 0) {
-      v = js_eval_str(js, &fn[default_start], default_len);
-    } else {
-      v = js_mkundef();
-    }
-    js_setprop(js, function_scope, js_mkstr(js, &fn[param_name_pos], identlen), v);
-    arg_idx++;
-    if (fnpos < fnlen && fn[fnpos] == ',') fnpos++;
-  }
-  
-  if (has_rest && rest_param_len > 0) {
-    jsval_t rest_array = mkarr(js);
-    if (!is_err(rest_array)) {
-      jsoff_t idx = 0;
-      while (arg_idx < nargs) {
-        arr_set(js, rest_array, idx, args[arg_idx]);
-        idx++; arg_idx++;
-      }
-      rest_array = mkval(T_ARR, vdata(rest_array));
-      js_setprop(js, function_scope, js_mkstr(js, &fn[rest_param_start], rest_param_len), rest_array);
-    }
-  }
-  
-  if (fnpos < fnlen && fn[fnpos] == ')') fnpos++;
-  fnpos = skiptonext(fn, fnlen, fnpos, NULL);
-  
-  if (fnpos >= fnlen) return js_mkerr(js, "unexpected end of function");
-  bool is_block = (fn[fnpos] == '{');
-  
-  if (is_block) fnpos++;
-  jsoff_t body_len = fnlen - fnpos - (is_block ? 1 : 0);
-  
-  bool func_strict = is_strict_function_body(&fn[fnpos], body_len);
-  if (code_uses_arguments(&fn[fnpos], body_len)) {
-    setup_arguments(js, function_scope, args, nargs, func_strict);
-  }
-  
-  jsval_t saved_this = js->this_val;
-  jsval_t target_this = peek_this();
-  
-  if (func_strict && (vtype(target_this) == T_UNDEF || vtype(target_this) == T_NULL ||
-      (vtype(target_this) == T_OBJ && vdata(target_this) == 0))) {
-    js->this_val = js_mkundef();
-  } else {
-    js->this_val = target_this;
-  }
-  js->flags = F_CALL | (func_strict ? F_STRICT : 0);
-  
-  jsval_t res;
-  if (!is_block) {
-    res = js_eval_str(js, &fn[fnpos], body_len);
-    res = resolveprop(js, res);
-  } else {
-    res = js_eval(js, &fn[fnpos], body_len);
-    if (!is_err(res) && !(js->flags & F_RETURN)) res = js_mkundef();
-  }
-  
-  js->this_val = saved_this;
-  if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-  
-  js->scope = saved_scope;  
-  return res;
-}
-
-static jsval_t call_ffi(struct js *js, unsigned int func_index) {
-  UT_array *args;
-  utarray_new(args, &jsval_icd);
-  jsval_t err, res;
-  
-  int argc = parse_call_args(js, args, &err);
-  if (argc < 0) { utarray_free(args); return err; }
-  
-  jsval_t *argv = (jsval_t *)utarray_front(args);
-  res = ffi_call_by_index(js, func_index, argv, argc);
-  
-  utarray_free(args);
-  return res;
-}
-
-__attribute__((noinline))
-static jsval_t do_call_bound_cfunc(struct js *js, jsval_t func, jsval_t func_obj, jsval_t cfunc_slot, jsval_t target_this) {
-  jsval_t bound_this_slot = get_slot(js, func_obj, SLOT_BOUND_THIS);
-  bool has_bound_this = vtype(bound_this_slot) != T_UNDEF;
-
-  if (has_bound_this) {
-    pop_this();
-    push_this(bound_this_slot);
-  }
-
-  jsval_t saved_func = js->current_func;
-  js->current_func = func;
-
-  int bound_argc;
-  jsval_t *bound_args = resolve_bound_args(js, func_obj, NULL, 0, &bound_argc);
-
-  jsval_t res;
-  if (!bound_args) {
-    res = call_c(js, (jsval_t(*)(struct js *, jsval_t *, int)) vdata(cfunc_slot));
-  } else {
-    UT_array *args_arr;
-    utarray_new(args_arr, &jsval_icd);
-    for (int i = 0; i < bound_argc; i++) utarray_push_back(args_arr, &bound_args[i]);
-    free(bound_args);
-
-    jsval_t err;
-    int call_argc = parse_call_args(js, args_arr, &err);
-    if (call_argc < 0) {
-      utarray_free(args_arr);
-      js->current_func = saved_func;
-      if (has_bound_this) pop_this();
-      return err;
-    }
-
-    jsval_t *argv = (jsval_t *)utarray_front(args_arr);
-    int total_argc = (int)utarray_len(args_arr);
-    jsval_t saved_this = js->this_val;
-    js->this_val = peek_this();
-    res = ((jsval_t(*)(struct js *, jsval_t *, int)) vdata(cfunc_slot))(js, argv, total_argc);
-    js->this_val = saved_this;
-    utarray_free(args_arr);
-  }
-
-  js->current_func = saved_func;
-
-  if (has_bound_this) {
-    pop_this();
-    push_this(target_this);
-  }
-
-  return res;
-}
-
-__attribute__((noinline))
-static jsval_t do_call_init_fields(struct js *js, jsval_t func_obj, jsval_t target_this) {
-  jsval_t count_val = get_slot(js, func_obj, SLOT_FIELD_COUNT);
-  if (vtype(count_val) != T_NUM || vtype(target_this) != T_OBJ) return js_mkundef();
-
-  int field_count = (int)tod(count_val);
-  jsval_t src_val = get_slot(js, func_obj, SLOT_SOURCE);
-  jsval_t fields_meta = get_slot(js, func_obj, SLOT_FIELDS);
-  if (vtype(src_val) == T_UNDEF || vtype(fields_meta) == T_UNDEF) return js_mkundef();
-
-  if (vtype(src_val) != T_CFUNC) return js_mkundef();
-  const char *source = (const char *)vdata(src_val);
-
-  jsoff_t meta_len, meta_ptr_off = vstr(js, fields_meta, &meta_len);
-  const jsoff_t *metadata = (const jsoff_t *)(&js->mem[meta_ptr_off]);
-
-  for (int i = 0; i < field_count; i++) {
-    jsoff_t name_off = metadata[i * 5 + 0];
-    jsoff_t name_len = metadata[i * 5 + 1];
-    jsoff_t init_start = metadata[i * 5 + 2];
-    jsoff_t init_end = metadata[i * 5 + 3];
-    bool computed = metadata[i * 5 + 4] != 0;
-
-    jsval_t fname;
-    if (computed) fname = (jsval_t) name_off;
-    else fname = js_mkstr(js, &source[name_off], name_len);
-
-    if (is_err(fname)) return fname;
-
-    jsval_t field_val = js_mkundef();
-    if (init_start > 0 && init_end > init_start) {
-      field_val = js_eval_str(js, &source[init_start], init_end - init_start);
-      field_val = resolveprop(js, field_val);
-    }
-
-    jsval_t set_res = js_setprop(js, target_this, fname, field_val);
-    if (is_err(set_res)) return set_res;
-  }
-
-  return js_mkundef();
-}
-
-__attribute__((noinline))
-static jsval_t do_call_async(struct js *js, const char *code_str, jsoff_t fnlen, jsval_t closure_scope, jsval_t *bound_args, int bound_argc) {
-  UT_array *call_args;
-  utarray_new(call_args, &jsval_icd);
-  for (int i = 0; i < bound_argc; i++) utarray_push_back(call_args, &bound_args[i]);
-  jsval_t err;
-  int call_argc = parse_call_args(js, call_args, &err);
-  if (call_argc < 0) {
-    utarray_free(call_args);
-    return err;
-  }
-  jsval_t *argv = (jsval_t *)utarray_front(call_args);
-  int argc = (int)utarray_len(call_args);
-  jsval_t res = start_async_in_coroutine(js, code_str, fnlen, closure_scope, argv, argc);
-  utarray_free(call_args);
-  return res;
-}
-
-static jsval_t do_call_op(struct js *js, jsval_t func, jsval_t args) {
-  if (js_stack_overflow(js)) {
-    return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum call stack size exceeded");
-  }
-  
-  if (vtype(args) != T_CODEREF) return js_mkerr(js, "bad call");
-  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC && vtype(func) != T_FFI) return js_mkerr(js, "calling non-function");
-
-  bool is_tail = js->tail_ctx;
-  js->tail_ctx = false;
-  
-  if (vtype(func) == T_FFI) {
-    const char *code = js->code;
-    jsoff_t clen = js->clen, pos = js->pos;
-    uint8_t tok = js->tok, flags = js->flags;
-    
-    js->code = &js->code[coderefoff(args)];
-    js->clen = codereflen(args);
-    js->pos = skiptonext(js->code, js->clen, 0, NULL);
-    
-    jsval_t res = call_ffi(js, (unsigned int)vdata(func));
-    
-    js->code = code; js->clen = clen; js->pos = pos;
-    js->flags = (flags & ~F_THROW) | (js->flags & F_THROW);
-    js->tok = tok;
-    js->consumed = 1;
-    return res;
-  }
-  
-  jsval_t target_this = peek_this();
-  jsval_t target_proto = (vtype(target_this) == T_OBJ) ? get_slot(js, target_this, SLOT_PROTO) : js_mkundef();
-  
-  if (vtype(func) == T_FUNC && vtype(target_this) == T_OBJ) {
-    if (vtype(target_proto) == T_UNDEF) {
-      jsval_t func_obj = mkval(T_OBJ, vdata(func));
-      
-      jsval_t target_func = get_slot(js, func_obj, SLOT_TARGET_FUNC);
-      jsval_t proto_source = func_obj;
-      if (vtype(target_func) == T_FUNC) {
-        proto_source = mkval(T_OBJ, vdata(target_func));
-      }
-      
-      jsoff_t proto_off = lkp_interned(js, proto_source, INTERN_PROTOTYPE, 9);
-      if (proto_off != 0) {
-        jsval_t proto = resolveprop(js, mkval(T_PROP, proto_off));
-        if (vtype(proto) == T_OBJ) set_proto(js, target_this, proto);
-      }
-    }
-  }
-  
-  const char *code = js->code;
-  jsoff_t clen = js->clen, pos = js->pos;
-  
-  js->code = &js->code[coderefoff(args)];
-  js->clen = codereflen(args);
-  js->pos = skiptonext(js->code, js->clen, 0, NULL);
-  
-  uint8_t tok = js->tok, flags = js->flags;
-  jsval_t res = js_mkundef();
-
-  jsval_t saved_new_target = js->new_target;
-  js->new_target = js->pending_ntg;
-  js->pending_ntg = js_mkundef();
-
-  if (vtype(func) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(func));
-    jsval_t cfunc_slot = get_slot(js, func_obj, SLOT_CFUNC);
-    if (vtype(cfunc_slot) == T_CFUNC) {
-      res = do_call_bound_cfunc(js, func, func_obj, cfunc_slot, target_this);
-    } else {
-      jsval_t builtin_slot = get_slot(js, func_obj, SLOT_BUILTIN);
-      if (vtype(builtin_slot) == T_NUM && (int)tod(builtin_slot) == BUILTIN_OBJECT) res = call_c(js, builtin_Object); else {
-      jsoff_t fnlen;
-      
-      const char *code_str = get_func_code(js, func_obj, &fnlen);
-      if (!code_str) return js_mkerr(js, "function has no code");
-      
-      jsval_t closure_scope = get_slot(js, func_obj, SLOT_SCOPE);
-      jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
-      bool is_async = (async_slot == js_true);
-      
-      jsval_t captured_this = js_mkundef();
-      bool is_arrow = false;
-      bool is_bound = false;
-      
-      jsval_t this_slot = get_slot(js, func_obj, SLOT_THIS);
-      if (vtype(this_slot) != T_UNDEF) {
-        captured_this = this_slot; is_arrow = true;
-      }
-      
-      jsval_t bound_this_slot = get_slot(js, func_obj, SLOT_BOUND_THIS);
-      if (vtype(bound_this_slot) != T_UNDEF && vtype(js->new_target) == T_UNDEF) {
-        captured_this = bound_this_slot; is_bound = true;
-      }
-      
-      int bound_argc;
-      jsval_t *bound_args = resolve_bound_args(js, func_obj, NULL, 0, &bound_argc);
-      
-      jsval_t nfe_name_val = js_mkundef();
-      jsval_t slot_name = get_slot(js, func_obj, SLOT_NAME);
-      
-      if (vtype(slot_name) == T_STR) nfe_name_val = slot_name; else {
-        jsoff_t nfe_name_off = lkp(js, func_obj, "name", 4);
-        if (nfe_name_off != 0) nfe_name_val = resolveprop(js, mkval(T_PROP, nfe_name_off));
-      }
-      
-      const char *func_name = NULL;
-      
-      if (vtype(nfe_name_val) == T_STR) {
-        jsoff_t name_len, name_offset = vstr(js, nfe_name_val, &name_len);
-        func_name = (const char *)&js->mem[name_offset];
-      }
-      
-      const char *final_name = func_name ? func_name : "<anonymous>";
-      push_call_frame(js->filename, final_name,  code, (uint32_t) pos);
-      
-      jsval_t saved_func = js->current_func;
-      js->current_func = func;
-      
-      jsval_t saved_super = js->super_val;
-      jsval_t func_super = get_slot(js, func_obj, SLOT_SUPER);
-      if (vtype(func_super) != T_UNDEF) js->super_val = func_super;
-      
-      if (is_arrow || is_bound) {
-        pop_this();
-        push_this(captured_this);
-      }
-      
-      if (get_slot(js, func_obj, SLOT_DEFAULT_CTOR) == js_true) {
-        jsval_t super_ctor = js->super_val;
-        uint8_t st = vtype(super_ctor);
-        if (st == T_FUNC || st == T_CFUNC) {
-          js->code = code; js->clen = clen; js->pos = pos;
-          js->pending_ntg = js->new_target;
-          res = do_call_op(js, super_ctor, args);
-          js->super_val = saved_super;
-          js->current_func = saved_func;
-          pop_call_frame(); goto restore_state;
-        }
-      }
-      {
-        jsval_t field_err = do_call_init_fields(js, func_obj, target_this);
-        if (is_err(field_err)) {
-          js->current_func = saved_func;
-          pop_call_frame();
-          return field_err;
-        }
-      }
-        if (is_async) {
-          res = do_call_async(js, code_str, fnlen, closure_scope, bound_args, bound_argc);
-          if (is_err(res)) {
-            pop_call_frame();
-            if (bound_args) free(bound_args);
-            js->super_val = saved_super;
-            js->current_func = saved_func;
-            return res;
-          }
-        } else if (is_tail && vtype(js->new_target) == T_UNDEF) {
-          UT_array *tc_args_arr;
-          utarray_new(tc_args_arr, &jsval_icd);
-          if (bound_args) {
-            for (int i = 0; i < bound_argc; i++) utarray_push_back(tc_args_arr, &bound_args[i]);
-            free(bound_args); bound_args = NULL;
-          }
-          jsval_t tc_err;
-          int tc_argc = parse_call_args(js, tc_args_arr, &tc_err);
-          if (tc_argc < 0) {
-            utarray_free(tc_args_arr);
-            pop_call_frame();
-            js->super_val = saved_super;
-            js->current_func = saved_func;
-            js->code = code; js->clen = clen; js->pos = pos;
-            js->flags = (flags & ~F_THROW) | (js->flags & F_THROW);
-            js->tok = tok; js->consumed = 1;
-            return tc_err;
-          }
-          jsval_t *tc_argv = NULL;
-          if (tc_argc > 0) {
-            tc_argv = malloc(tc_argc * sizeof(jsval_t));
-            memcpy(tc_argv, utarray_front(tc_args_arr), tc_argc * sizeof(jsval_t));
-          }
-          utarray_free(tc_args_arr);
-          js->tc.pending = true;
-          js->tc.func = func;
-          js->tc.closure_scope = closure_scope;
-          js->tc.this_val = peek_this();
-          js->tc.code_str = code_str;
-          js->tc.fnlen = fnlen;
-          js->tc.args = tc_argv;
-          js->tc.argc = tc_argc;
-          pop_call_frame();
-          js->super_val = saved_super;
-          js->current_func = saved_func;
-          js->code = code; js->clen = clen; js->pos = pos;
-          js->flags = (flags & ~F_THROW) | (js->flags & F_THROW);
-          js->tok = tok;
-          js->consumed = 1;
-          return (jsval_t)T_TAILCALL;
-        } else res = call_js_internal(js, code_str, fnlen, closure_scope, bound_args, bound_argc, func);
-        pop_call_frame();
-        if (bound_args) free(bound_args);
-        js->super_val = saved_super;
-        js->current_func = saved_func;
-      }
-    }
-  } else {
-    res = call_c(js, (jsval_t(*)(struct js *, jsval_t *, int)) vdata(func));
-  }
-  
-restore_state:
-  js->new_target = saved_new_target;
-  js->code = code, js->clen = clen, js->pos = pos;
-  js->flags = (flags & ~F_THROW) | (js->flags & F_THROW);
-  js->tok = tok;
-  js->consumed = 1;
-  
-  return res;
-}
-
-static bool js_try_call_method(struct js *js, jsval_t obj, const char *method, size_t method_len, jsval_t *args, int nargs, jsval_t *out_result) {
-  jsval_t getter = js_mkundef(); bool has_getter = false;
-  jsoff_t off = lkp_with_getter(js, obj, method, method_len, &getter, &has_getter);
-  
-  jsval_t fn;
-  if (has_getter) {
-    fn = call_proto_accessor(js, obj, getter, true, NULL, 0, false);
-    if (is_err(fn)) { *out_result = fn; return true; }
-  } else if (off != 0) {
-    fn = resolveprop(js, mkval(T_PROP, off));
-  } else return false;
-  
-  uint8_t ft = vtype(fn);
-  if (ft != T_FUNC && ft != T_CFUNC) return false;
-  
-  js_parse_state_t saved_state;
-  JS_SAVE_STATE(js, saved_state);
-  uint8_t saved_flags = js->flags;
-  
-  jsval_t saved_this = js->this_val;
-  js->this_val = obj;
-  push_this(obj);
-  
-  jsval_t result;
-  if (ft == T_CFUNC) result = ((jsval_t (*)(struct js *, jsval_t *, int))vdata(fn))(js, args, nargs);
-  else result = call_js_with_args(js, fn, args, nargs);
-  
-  bool had_throw = (js->flags & F_THROW) != 0;
-  jsval_t thrown = js->thrown_value;
-  
-  pop_this();
-  js->this_val = saved_this;
-  
-  JS_RESTORE_STATE(js, saved_state);
-  js->flags = saved_flags;
-  
-  if (had_throw) {
-    js->flags |= F_THROW;
-    js->thrown_value = thrown;
-  }
-  
-  *out_result = result;
-  return true;
-}
-
-static jsval_t js_call_method(struct js *js, jsval_t obj, const char *method, size_t method_len, jsval_t *args, int nargs) {
-  jsval_t result;
-  if (!js_try_call_method(js, obj, method, method_len, args, nargs, &result)) return js_mkundef();
-  return result;
-}
-
-static jsval_t js_call_toString(struct js *js, jsval_t value) {
-  jsval_t result = js_call_method(js, value, "toString", 8, NULL, 0);
-  
-  if (is_err(result)) return result;
-  if (vtype(result) == T_STR) return result;
-  
-  uint8_t rtype = vtype(result);
-  if (rtype == T_UNDEF) {
-    goto fallback;
-  }
-  
-  if (rtype != T_OBJ && rtype != T_ARR && rtype != T_FUNC) {
-    char buf[256];
-    size_t len = tostr(js, result, buf, sizeof(buf));
-    return js_mkstr(js, buf, len);
-  }
-  
-fallback:;
-  char buf[4096];
-  size_t len = tostr(js, value, buf, sizeof(buf));
-  return js_mkstr(js, buf, len);
-}
-
-static jsval_t js_call_valueOf(struct js *js, jsval_t value) {
-  jsval_t result = js_call_method(js, value, "valueOf", 7, NULL, 0);
-  if (vtype(result) == T_UNDEF) return value;
-  return result;
-}
-
-static inline bool is_primitive(jsval_t v) {
-  uint8_t t = vtype(v);
-  return t == T_STR || t == T_NUM || t == T_BOOL || t == T_NULL || t == T_UNDEF || t == T_SYMBOL || t == T_BIGINT;
-}
-
-static jsval_t try_exotic_to_primitive(struct js *js, jsval_t value, int hint) {
-  const char *tp_key = get_toPrimitive_sym_key();
-  if (!tp_key || !tp_key[0]) return mkval(T_UNDEF, 0);
-  size_t tp_key_len = strlen(tp_key);
-  
-  jsoff_t tp_off = lkp(js, value, tp_key, tp_key_len);
-  if (tp_off == 0) tp_off = lkp_proto(js, value, tp_key, tp_key_len);
-  if (tp_off == 0) return mkval(T_UNDEF, 0);
-  
-  jsval_t tp_fn = resolveprop(js, mkval(T_PROP, tp_off));
-  uint8_t ft = vtype(tp_fn);
-  
-  if (ft == T_UNDEF) return mkval(T_UNDEF, 0);
-  if (ft != T_FUNC && ft != T_CFUNC) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol.toPrimitive is not a function");
-  }
-  
-  const char *hint_str = hint == 1 ? "string" : (hint == 2 ? "number" : "default");
-  jsval_t hint_arg = js_mkstr(js, hint_str, strlen(hint_str));
-  jsval_t result = js_call_method(js, value, tp_key, tp_key_len, &hint_arg, 1);
-  
-  if (is_err(result) || is_primitive(result)) return result;
-  return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
-}
-
-static jsval_t try_ordinary_to_primitive(struct js *js, jsval_t value, int hint) {
-  static const char *names[] = {"valueOf", "toString"};
-  static const size_t lens[] = {7, 8};
-  
-  int first = (hint == 1); 
-  jsval_t result;
-  
-  for (int i = 0; i < 2; i++) {
-    int idx = first ^ i;
-    if (js_try_call_method(js, value, names[idx], lens[idx], NULL, 0, &result))
-      if (is_err(result) || is_primitive(result)) return result;
-  }
-  
-  return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
-}
-
-static jsval_t js_to_primitive(struct js *js, jsval_t value, int hint) {
-  if (is_primitive(value)) return value;
-  if (!is_object_type(value)) return value;
-  
-  jsval_t result = try_exotic_to_primitive(js, value, hint);
-  if (vtype(result) != T_UNDEF) return result;
-  
-  return try_ordinary_to_primitive(js, value, hint);
-}
-
-static inline bool strict_eq_values(struct js *js, jsval_t l, jsval_t r) {
-  uint8_t t = vtype(l);
-  if (t != vtype(r)) return false;
-  if (t == T_STR) {
-    jsoff_t n1, n2, off1 = vstr(js, l, &n1), off2 = vstr(js, r, &n2);
-    return n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
-  }
-  if (t == T_NUM) return tod(l) == tod(r);
-  if (t == T_BIGINT) return bigint_compare(js, l, r) == 0;
-  return vdata(l) == vdata(r);
-}
-
-jsval_t coerce_to_str(struct js *js, jsval_t v) {
-  if (vtype(v) == T_STR) return v;
-  
-  if (is_object_type(v)) {
-    jsval_t prim = js_to_primitive(js, v, 1);
-    if (is_err(prim)) return prim;
-    if (vtype(prim) == T_STR) return prim;
-    return js_tostring_val(js, prim);
-  }
-  
-  return js_tostring_val(js, v);
-}
-
-jsval_t coerce_to_str_concat(struct js *js, jsval_t v) {
-  if (vtype(v) == T_STR) return v;
-  
-  if (is_object_type(v)) {
-    jsval_t prim = js_to_primitive(js, v, 0);
-    if (is_err(prim)) return prim;
-    if (vtype(prim) == T_STR) return prim;
-    return js_tostring_val(js, prim);
-  }
-  
-  return js_tostring_val(js, v);
-}
-
-static jsval_t do_op(struct js *js, uint8_t op, jsval_t lhs, jsval_t rhs) {
-  if (js->flags & F_NOEXEC) return 0;
-  
-  jsval_t l = is_assign(op) ? lhs : resolveprop(js, lhs);
-  jsval_t r = resolveprop(js, rhs);
-  
-  if (is_err(l)) return l;
-  if (is_err(r)) return r;
-  
-  if (is_assign(op) && vtype(lhs) != T_PROP && vtype(lhs) != T_PROPREF) {
-    if (!(js->flags & F_STRICT) && vtype(lhs) == T_UNDEF) return r;
-    if (!(js->flags & F_STRICT) && vtype(lhs) == T_CODEREF && op == TOK_ASSIGN) {
-      jsoff_t id_off = coderefoff(lhs), id_len = codereflen(lhs);
-      jsval_t global_scope = js->scope;
-      while (vdata(upper(js, global_scope)) != 0) global_scope = upper(js, global_scope);
-      jsval_t key = js_mkstr(js, &js->code[id_off], id_len);
-      if (is_err(key)) return key;
-      jsval_t prop = js_setprop(js, global_scope, key, r);
-      return is_err(prop) ? prop : r;
-    }
-    return js_mkerr_typed(js, (js->flags & F_STRICT) && vtype(lhs) == T_UNDEF ? JS_ERR_TYPE : JS_ERR_SYNTAX,
-      (js->flags & F_STRICT) && vtype(lhs) == T_UNDEF ? "Cannot create property on primitive value" : "Invalid left-hand side in assignment");
-  }
-
-#define L(tok) [tok] = &&L_##tok
-  static const void *dispatch[TOK_MAX] = {
-    L(TOK_TYPEOF), L(TOK_VOID), L(TOK_INSTANCEOF), L(TOK_IN),
-    L(TOK_CALL), L(TOK_BRACKET), L(TOK_ASSIGN), L(TOK_DOT),
-    L(TOK_OPTIONAL_CHAIN), L(TOK_POSTINC), L(TOK_POSTDEC),
-    L(TOK_NOT), L(TOK_UMINUS), L(TOK_UPLUS), L(TOK_SEQ),
-    L(TOK_SNE), L(TOK_EQ), L(TOK_NE), L(TOK_PLUS),
-    L(TOK_MINUS), L(TOK_MUL), L(TOK_DIV), L(TOK_REM),
-    L(TOK_EXP), L(TOK_LT), L(TOK_LE), L(TOK_GT), L(TOK_GE),
-    L(TOK_XOR), L(TOK_AND), L(TOK_OR), L(TOK_TILDA),
-    L(TOK_SHL), L(TOK_SHR), L(TOK_ZSHR),
-  };
-#undef L
-
-  if (op < TOK_MAX && dispatch[op]) goto *dispatch[op];
-  goto L_default;
-
-  L_TOK_TYPEOF: {
-    const char *ts = typestr(vtype(r));
-    return js_mkstr(js, ts, strlen(ts));
-  }
-  L_TOK_VOID:           return js_mkundef();
-  L_TOK_INSTANCEOF:     return do_instanceof(js, l, r);
-  L_TOK_IN:             return do_in(js, l, r);
-  L_TOK_CALL:           return do_call_op(js, l, r);
-  L_TOK_BRACKET:        return do_bracket_op(js, l, rhs);
-  L_TOK_ASSIGN:         return assign(js, lhs, r);
-  L_TOK_DOT:            return do_dot_op(js, l, r);
-  L_TOK_OPTIONAL_CHAIN: return do_optional_chain_op(js, l, r);
-
-  L_TOK_POSTINC:
-  L_TOK_POSTDEC: {
-    uint8_t lhs_type = vtype(lhs);
-    if (lhs_type != T_PROP && lhs_type != T_PROPREF)
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "Invalid left-hand side expression in postfix operation");
-    jsval_t assign_res = do_assign_op(js, op == TOK_POSTINC ? TOK_PLUS_ASSIGN : TOK_MINUS_ASSIGN, lhs, tov(1));
-    if (is_err(assign_res)) return assign_res;
-    return l;
-  }
-
-  L_TOK_NOT: return mkval(T_BOOL, !js_truthy(js, r));
-  
-  L_TOK_UMINUS:
-    if (vtype(r) == T_BIGINT) return bigint_neg(js, r);
-    if (is_object_type(r)) {
-      jsval_t prim = js_to_primitive(js, r, 2);
-      if (is_err(prim)) return prim;
-      return tov(-js_to_number(js, prim));
-    }
-    return tov(-js_to_number(js, r));
-  
-  L_TOK_UPLUS:
-    if (vtype(r) == T_BIGINT) return js_mkerr(js, "Cannot convert a BigInt value to a number");
-    if (is_object_type(r)) {
-      jsval_t prim = js_to_primitive(js, r, 2);
-      if (is_err(prim)) return prim;
-      return tov(js_to_number(js, prim));
-    }
-    return tov(js_to_number(js, r));
-
-  L_TOK_TILDA: return tov((double)(~js_to_int32(js_to_number(js, r))));
-
-  L_TOK_SEQ:
-  L_TOK_SNE: {
-    bool eq = strict_eq_values(js, l, r);
-    return mkval(T_BOOL, op == TOK_SEQ ? eq : !eq);
-  }
-
-  L_TOK_EQ:
-  L_TOK_NE: {
-    bool eq = false;
-    uint8_t lt = vtype(l), rtype = vtype(r);
-
-    if ((lt == T_NULL && rtype == T_NULL) || (lt == T_UNDEF && rtype == T_UNDEF) ||
-        (lt == T_UNDEF && rtype == T_NULL) || (lt == T_NULL && rtype == T_UNDEF)) {
-      eq = true;
-    } else if (lt == T_NULL || rtype == T_NULL || lt == T_UNDEF || rtype == T_UNDEF) {
-      eq = false;
-    } else if (lt == rtype) {
-      eq = strict_eq_values(js, l, r);
-    } else if ((lt == T_BIGINT && rtype == T_NUM) || (lt == T_NUM && rtype == T_BIGINT)) {
-      double num_val = lt == T_NUM ? tod(l) : tod(r);
-      jsval_t bigint_val = lt == T_BIGINT ? l : r;
-      if (isfinite(num_val) && num_val == trunc(num_val)) {
-        bool neg = num_val < 0;
-        if (neg) num_val = -num_val;
-        char buf[64];
-        snprintf(buf, sizeof(buf), "%.0f", num_val);
-        eq = bigint_compare(js, bigint_val, js_mkbigint(js, buf, strlen(buf), neg)) == 0;
-      }
-    } else if (lt == T_BOOL) {
-      return do_op(js, op, tov(vdata(l) ? 1.0 : 0.0), r);
-    } else if (rtype == T_BOOL) {
-      return do_op(js, op, l, tov(vdata(r) ? 1.0 : 0.0));
-    } else if ((lt == T_NUM && rtype == T_STR) || (lt == T_STR && rtype == T_NUM)) {
-      eq = js_to_number(js, l) == js_to_number(js, r);
-    } else if (is_object_type(l)) {
-      jsval_t l_prim = js_to_primitive(js, l, 0);
-      if (!is_err(l_prim)) return do_op(js, op, l_prim, r);
-    } else if (is_object_type(r)) {
-      jsval_t r_prim = js_to_primitive(js, r, 0);
-      if (!is_err(r_prim)) return do_op(js, op, l, r_prim);
-    }
-    return mkval(T_BOOL, op == TOK_EQ ? eq : !eq);
-  }
-
-  L_TOK_PLUS: {
-    if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) + tod(r));
-    jsval_t lu = unwrap_primitive(js, l);
-    jsval_t ru = unwrap_primitive(js, r);
-    if (vtype(lu) == T_BIGINT && vtype(ru) == T_BIGINT) return bigint_add(js, lu, ru);
-    if (vtype(lu) == T_BIGINT || vtype(ru) == T_BIGINT) return js_mkerr(js, "Cannot mix BigInt value and other types");
-    if (is_non_numeric(lu) || is_non_numeric(ru) || (vtype(lu) == T_STR && vtype(ru) == T_STR)) {
-      jsval_t l_str = coerce_to_str_concat(js, l);
-      if (is_err(l_str)) return l_str;
-      jshdl_t lh = js_root(js, l_str);
-      jsval_t r_str = coerce_to_str_concat(js, r);
-      l_str = js_deref(js, lh); js_unroot(js, lh);
-      if (is_err(r_str)) return r_str;
-      return do_string_op(js, op, l_str, r_str);
-    }
-    return tov(js_to_number(js, l) + js_to_number(js, r));
-  }
-
-  L_TOK_MINUS:
-  L_TOK_MUL:
-  L_TOK_DIV:
-  L_TOK_REM:
-  L_TOK_EXP: {
-    uint8_t lt = vtype(l), rtype = vtype(r);
-    if (lt == T_NUM && rtype == T_NUM) {
-      double a = tod(l), b = tod(r);
-      switch (op) {
-        case TOK_MINUS: return tov(a - b);
-        case TOK_MUL:   return tov(a * b);
-        case TOK_DIV:   return tov(a / b);
-        case TOK_REM:   return tov(a - b * ((double)(long)(a / b)));
-        case TOK_EXP:   return tov(pow(a, b));
-      }
-    }
-    if (lt == T_BIGINT && rtype == T_BIGINT) {
-      switch (op) {
-        case TOK_MINUS: return bigint_sub(js, l, r);
-        case TOK_MUL:   return bigint_mul(js, l, r);
-        case TOK_DIV:   return bigint_div(js, l, r);
-        case TOK_REM:   return bigint_mod(js, l, r);
-        case TOK_EXP:   return bigint_exp(js, l, r);
-      }
-    }
-    if (lt == T_BIGINT || rtype == T_BIGINT)
-      return js_mkerr(js, "Cannot mix BigInt value and other types");
-    double a = js_to_number(js, l), b = js_to_number(js, r);
-    switch (op) {
-      case TOK_MINUS: return tov(a - b);
-      case TOK_MUL:   return tov(a * b);
-      case TOK_DIV:   return tov(a / b);
-      case TOK_REM:   return tov(a - b * ((double)(long)(a / b)));
-      case TOK_EXP:   return tov(pow(a, b));
-    }
-  }
-
-  L_TOK_LT:
-  L_TOK_LE:
-  L_TOK_GT:
-  L_TOK_GE: {
-    if (is_object_type(l) || is_object_type(r)) {
-      jsval_t lp = l, rp = r;
-      if (is_object_type(lp)) {
-        lp = js_to_primitive(js, lp, 2);
-        if (is_err(lp)) return lp;
-      }
-      if (is_object_type(rp)) {
-        rp = js_to_primitive(js, rp, 2);
-        if (is_err(rp)) return rp;
-      }
-      if (vtype(lp) != vtype(l) || vdata(lp) != vdata(l) || vtype(rp) != vtype(r) || vdata(rp) != vdata(r)) {
-        return do_op(js, op, lp, rp);
-      }
-    }
-    
-    uint8_t lt = vtype(l), rtype = vtype(r);
-    if (lt == T_NUM && rtype == T_NUM) {
-      double a = tod(l), b = tod(r);
-      switch (op) {
-        case TOK_LT: return mkval(T_BOOL, a < b);
-        case TOK_LE: return mkval(T_BOOL, a <= b);
-        case TOK_GT: return mkval(T_BOOL, a > b);
-        case TOK_GE: return mkval(T_BOOL, a >= b);
-      }
-    }
-    if (lt == T_BIGINT && rtype == T_BIGINT) {
-      int cmp = bigint_compare(js, l, r);
-      switch (op) {
-        case TOK_LT: return mkval(T_BOOL, cmp < 0);
-        case TOK_LE: return mkval(T_BOOL, cmp <= 0);
-        case TOK_GT: return mkval(T_BOOL, cmp > 0);
-        case TOK_GE: return mkval(T_BOOL, cmp >= 0);
-      }
-    }
-    if (lt == T_BIGINT || rtype == T_BIGINT)
-      return js_mkerr(js, "Cannot mix BigInt value and other types");
-    if (lt == T_STR && rtype == T_STR)
-      return do_string_op(js, op, l, r);
-    double a = js_to_number(js, l), b = js_to_number(js, r);
-    switch (op) {
-      case TOK_LT: return mkval(T_BOOL, a < b);
-      case TOK_LE: return mkval(T_BOOL, a <= b);
-      case TOK_GT: return mkval(T_BOOL, a > b);
-      case TOK_GE: return mkval(T_BOOL, a >= b);
-    }
-  }
-
-  L_TOK_XOR:
-  L_TOK_AND:
-  L_TOK_OR:
-  L_TOK_SHL:
-  L_TOK_SHR:
-  L_TOK_ZSHR: {
-    uint8_t lt = vtype(l), rtype = vtype(r);
-    if (lt == T_BIGINT || rtype == T_BIGINT) {
-      if (lt != T_BIGINT || rtype != T_BIGINT)
-        return js_mkerr(js, "Cannot mix BigInt value and other types");
-      if (op == TOK_AND || op == TOK_OR || op == TOK_XOR)
-        return js_mkerr_typed(js, JS_ERR_TYPE, "BigInt does not support bitwise ops");
-      uint64_t shift = 0;
-      jsval_t shift_err = bigint_asint_bits(js, r, &shift);
-      if (is_err(shift_err)) return shift_err;
-      switch (op) {
-        case TOK_SHL:  return bigint_shift_left(js, l, shift);
-        case TOK_SHR:  return bigint_shift_right(js, l, shift);
-        case TOK_ZSHR: return bigint_shift_right_logical(js, l, shift);
-      }
-    }
-    int32_t ai = (lt == T_NUM) ? js_to_int32(tod(l)) : js_to_int32(js_to_number(js, l));
-    uint32_t bi = (rtype == T_NUM) ? js_to_uint32(tod(r)) : js_to_uint32(js_to_number(js, r));
-    switch (op) {
-      case TOK_XOR:  return tov((double)(ai ^ (int32_t)bi));
-      case TOK_AND:  return tov((double)(ai & (int32_t)bi));
-      case TOK_OR:   return tov((double)(ai | (int32_t)bi));
-      case TOK_SHL:  return tov((double)(ai << (bi & 0x1f)));
-      case TOK_SHR:  return tov((double)(ai >> (bi & 0x1f)));
-      case TOK_ZSHR: return tov((double)((uint32_t)ai >> (bi & 0x1f)));
-    }
-  }
-
-  L_default:
-    if (is_assign(op)) return do_assign_op(js, op, lhs, r);
-    return js_mkerr(js, "unknown op %d", (int)op);
-}
-
-static jsval_t js_template_literal(struct js *js) {
-  uint8_t *in = (uint8_t *) &js->code[js->toff];
-  size_t template_len = js->tlen;
-  
-  size_t n = 1; 
-  jsval_t parts[64]; 
-  int part_count = 0;
-  
-  while (n < template_len - 1 && part_count < 64) {
-    size_t part_start = n;
-    while (n < template_len - 1) {
-      if (in[n] == '\\' && n + 1 < template_len - 1) {
-        n += 2;
-        continue;
-      }
-      if (in[n] == '$' && n + 1 < template_len - 1 && in[n + 1] == '{') {
-        break;
-      }
-      n++;
-    }
-    if (n > part_start || (n == part_start && (n >= template_len - 1 || in[n] != '$'))) {
-      size_t part_len = n - part_start;
-      size_t needed = sizeof(jsoff_t) + part_len;
-      if (js->brk + needed > js->size) {
-        if (!js_try_grow_memory(js, needed)) return js_mkerr(js, "oom");
-      }
-      uint8_t *out = &js->mem[js->brk + sizeof(jsoff_t)];
-      size_t out_len = 0;
-      
-      for (size_t i = part_start; i < n; i++) {
-        if (in[i] == '\\' && i + 1 < n) {
-          if (is_octal_escape(in, i)) return js_mkerr_typed(
-            js, JS_ERR_SYNTAX, "Octal escape sequences are not allowed in template strings."
-          );
-          i += 1 + decode_escape(in, i, n, out, &out_len, '`');
-        } else out[out_len++] = in[i];
-      }
-      
-      parts[part_count++] = js_mkstr(js, NULL, out_len);
-    }
-    
-    if (n < template_len - 1 && in[n] == '$' && in[n + 1] == '{') {
-      n += 2;
-      size_t expr_start = n;
-      int brace_count = 1;
-      
-      while (n < template_len - 1 && brace_count > 0) {
-        if (in[n] == '{') brace_count++;
-        else if (in[n] == '}') brace_count--;
-        if (brace_count > 0) n++;
-      }
-      
-      if (brace_count != 0) return js_mkerr_typed(js, JS_ERR_SYNTAX, "unclosed ${");
-      
-      jsval_t expr_result = js_eval_str(js, (const char *)&in[expr_start], (jsoff_t)(n - expr_start));
-      if (is_err(expr_result)) return expr_result;
-      expr_result = resolveprop(js, expr_result);
-
-      if (vtype(expr_result) == T_SYMBOL) {
-        return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert a Symbol value to a string");
-      }
-      
-      if (vtype(expr_result) != T_STR) {
-        expr_result = coerce_to_str(js, expr_result);
-        if (is_err(expr_result)) return expr_result;
-      }
-      
-      parts[part_count++] = expr_result;
-      n++;
-    }
-  }
-  
-  if (part_count == 0) return js_mkstr(js, "", 0);
-  if (part_count == 1) return parts[0];
-  
-  size_t total_len = 0;
-  for (int i = 0; i < part_count; i++) {
-    if (vtype(parts[i]) == T_STR) {
-      total_len += vstrlen(js, parts[i]);
-    }
-  }
-  
-  jsval_t result = js_mkstr(js, NULL, total_len);
-  if (is_err(result)) return result;
-  
-  jsoff_t result_len, result_off = vstr(js, result, &result_len);
-  size_t pos = 0;
-  
-  for (int i = 0; i < part_count; i++) {
-    if (vtype(parts[i]) == T_STR) {
-      jsoff_t part_len, part_off = vstr(js, parts[i], &part_len);
-      memmove(&js->mem[result_off + pos], &js->mem[part_off], part_len);
-      pos += part_len;
-    }
-  }
-  
-  return result;
-}
-
-static jsval_t js_tagged_template(struct js *js, jsval_t tag_func) {
-  if (js->flags & F_NOEXEC) return js_mkundef();
-  
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  
-  uint8_t *in = (uint8_t *) &js->code[js->toff];
-  size_t template_len = js->tlen;
-  jsval_t strings[64], values[64];
-  int string_count = 0, value_count = 0;
-  size_t n = 1;
-  
-  while (n < template_len - 1) {
-    size_t part_start = n;
-    
-    while (n < template_len - 1 && !(in[n] == '$' && n + 1 < template_len - 1 && in[n + 1] == '{')) {
-      if (in[n] == '\\' && n + 1 < template_len - 1) n += 2;
-      else n++;
-    }
-    
-    size_t out_len = 0;
-    size_t needed = sizeof(jsoff_t) + (n - part_start);
-    if (js->brk + needed > js->size) {
-      if (!js_try_grow_memory(js, needed)) return js_mkerr(js, "oom");
-    } uint8_t *out = &js->mem[js->brk + sizeof(jsoff_t)];
-    
-    for (size_t i = part_start; i < n; i++) {
-      if (in[i] == '\\' && i + 1 < n) {
-        if (is_octal_escape(in, i)) return js_mkerr_typed(
-          js, JS_ERR_SYNTAX, "Octal escape sequences are not allowed in template strings."
-        );
-        i += 1 + decode_escape(in, i, n, out, &out_len, '`');
-      } else out[out_len++] = in[i];
-    }
-    
-    strings[string_count++] = js_mkstr(js, NULL, out_len);
-    if (n >= template_len - 1 || in[n] != '$') break;
-    
-    n += 2;
-    int brace_count = 1;
-    size_t expr_start = n;
-    while (n < template_len - 1 && brace_count > 0) {
-      if (in[n] == '{') brace_count++;
-      else if (in[n] == '}') brace_count--;
-      if (brace_count > 0) n++;
-    }
-    if (brace_count != 0) return js_mkerr_typed(js, JS_ERR_SYNTAX, "unclosed ${");
-    
-    jsval_t expr_result = js_eval_str(js, (const char *)&in[expr_start], (jsoff_t)(n - expr_start));
-    if (is_err(expr_result)) return expr_result;
-    expr_result = resolveprop(js, expr_result);
-    values[value_count++] = expr_result;
-    n++;
-  }
-  
-  jsval_t strings_arr = mkarr(js);
-  for (int i = 0; i < string_count; i++) {
-    arr_set(js, strings_arr, (jsoff_t)i, strings[i]);
-  }
-  
-  jsval_t args[65];
-  args[0] = strings_arr;
-  for (int i = 0; i < value_count; i++) {
-    args[i + 1] = values[i];
-  }
-  
-  uint8_t saved_flags = js->flags;
-  jsval_t result = call_js_with_args(js, tag_func, args, 1 + value_count);
-  
-  JS_RESTORE_STATE(js, saved);
-  js->flags = saved_flags;
-  js->consumed = 1;
-  
-  return result;
-}
-
-static jsval_t js_str_literal(struct js *js) {
-  uint8_t *in = (uint8_t *) &js->code[js->toff];
-  size_t n1 = 0, n2 = 0;
-  size_t needed = sizeof(jsoff_t) + js->tlen;
-  if (js->brk + needed > js->size) {
-    if (!js_try_grow_memory(js, needed)) return js_mkerr(js, "oom");
-  }
-  uint8_t *out = &js->mem[js->brk + sizeof(jsoff_t)];
-  while (n2++ + 2 < js->tlen) {
-    if (in[n2] == '\\') {
-      if ((js->flags & F_STRICT) && is_octal_escape(in, n2)) return js_mkerr_typed(
-        js, JS_ERR_SYNTAX, "Octal escape sequences are not allowed in strict mode."
-      );
-      size_t extra = decode_escape(in, n2, js->tlen, out, &n1, in[0]);
-      n2 += extra + 1;
-    } else out[n1++] = ((uint8_t *) js->code)[js->toff + n2];
-  }
-  return js_mkstr(js, NULL, n1);
-}
-
-static jsval_t js_bigint_literal(struct js *js) {
-  const char *start = &js->code[js->toff];
-  size_t len = js->tlen - 1;
-  while (len > 1 && start[0] == '0') { start++; len--; }
-  bool neg = false;
-  if (len > 0 && start[0] == '-') { neg = true; start++; len--; }
-  return js_mkbigint(js, start, len, neg);
-}
-
-static jsval_t js_destruct_assign_pattern(
-  struct js *js, uint8_t open_tok, uint8_t close_tok,
-  const char *missing_assign_msg, bool object_required
-) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  jsoff_t pattern_start = js->toff;
-  js->consumed = 1;
-  
-  int depth = 1;
-  while (depth > 0 && next(js) != TOK_EOF) {
-    if (js->tok == open_tok) depth++;
-    else if (js->tok == close_tok) depth--;
-    if (depth > 0) js->consumed = 1;
-  }
-  js->consumed = 1;
-  jsoff_t pattern_len = js->pos - pattern_start;
-  
-  if (next(js) != TOK_ASSIGN) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "%s", missing_assign_msg);
-  }
-  js->consumed = 1;
-  
-  jsval_t rhs = js_expr(js);
-  if (is_err(rhs)) return rhs;
-  
-  if (exe) {
-    jsval_t val = resolveprop(js, rhs);
-    uint8_t vt = vtype(val);
-    
-    if (object_required) {
-      if (vt == T_NULL || vt == T_UNDEF) {
-        return js_mkerr(js, "cannot destructure null or undefined");
-      }
-    } else if (vt != T_ARR && vt != T_STR) {
-      return js_mkerr(js, "cannot array destructure non-iterable");
-    }
-    
-    jsval_t bind = bind_destruct_pattern(js, &js->code[pattern_start], pattern_len, val, js->scope);
-    if (is_err(bind)) return bind;
-  }
-  
-  return rhs;
-}
-
-static jsval_t js_arr_destruct_assign(struct js *js) {
-  return js_destruct_assign_pattern(
-    js, TOK_LBRACKET, TOK_RBRACKET,
-    "array destructuring requires assignment", false
-  );
-}
-
-static jsval_t js_obj_destruct_assign(struct js *js) {
-  return js_destruct_assign_pattern(
-    js, TOK_LBRACE, TOK_RBRACE,
-    "destructuring requires assignment", true
-  );
-}
-
-static jsval_t js_arr_literal(struct js *js);
-static jsval_t js_obj_literal(struct js *js);
-
-static jsval_t js_arr_or_destruct(struct js *js) {
-  jsoff_t saved_pos = js->pos;
-  uint8_t saved_tok = js->tok;
-  uint8_t saved_consumed = js->consumed;
-  uint8_t saved_flags = js->flags;
-  
-  jsoff_t saved_toff = js->toff;
-  jsoff_t saved_tlen = js->tlen;
-  int saved_stream_pos = js->token_stream_pos;
-  
-  js->flags |= F_NOEXEC;
-  js->consumed = 1;
-  int depth = 1;
-  while (depth > 0 && next(js) != TOK_EOF) {
-    if (js->tok == TOK_LBRACKET) depth++;
-    else if (js->tok == TOK_RBRACKET) depth--;
-    if (depth > 0) js->consumed = 1;
-  }
-  js->consumed = 1;
-  bool is_destruct = (next(js) == TOK_ASSIGN);
-  
-  js->pos = saved_pos;
-  js->tok = saved_tok;
-  js->consumed = saved_consumed;
-  js->flags = saved_flags;
-  js->toff = saved_toff;
-  js->tlen = saved_tlen;
-  js->token_stream_pos = saved_stream_pos;
-  
-  if (is_destruct) return js_arr_destruct_assign(js);  
-  return js_arr_literal(js);
-}
-
-static jsval_t js_obj_or_destruct(struct js *js) {
-  jsoff_t saved_pos = js->pos;
-  uint8_t saved_tok = js->tok;
-  uint8_t saved_consumed = js->consumed;
-  uint8_t saved_flags = js->flags;
-  
-  jsoff_t saved_toff = js->toff;
-  jsoff_t saved_tlen = js->tlen;
-  int saved_stream_pos = js->token_stream_pos;
-  
-  js->flags |= F_NOEXEC;
-  js->consumed = 1;
-  int depth = 1;
-  while (depth > 0 && next(js) != TOK_EOF) {
-    if (js->tok == TOK_LBRACE) depth++;
-    else if (js->tok == TOK_RBRACE) depth--;
-    if (depth > 0) js->consumed = 1;
-  }
-  js->consumed = 1;
-  bool is_destruct = (next(js) == TOK_ASSIGN);
-  
-  js->pos = saved_pos;
-  js->tok = saved_tok;
-  js->consumed = saved_consumed;
-  js->flags = saved_flags;
-  js->toff = saved_toff;
-  js->tlen = saved_tlen;
-  js->token_stream_pos = saved_stream_pos;
-  
-  if (is_destruct) return js_obj_destruct_assign(js);
-  return js_obj_literal(js);
-}
-
-typedef struct {
-  jsval_t arr;
-  jsoff_t *idx;
-} spread_arr_literal_ctx_t;
-
-static iter_action_t spread_arr_literal_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
-  spread_arr_literal_ctx_t *sctx = (spread_arr_literal_ctx_t *)ctx;
-  arr_set(js, sctx->arr, *sctx->idx, value);
-  (*sctx->idx)++;
-  return ITER_CONTINUE;
-}
-
-static jsval_t append_spread_to_array_literal(struct js *js, jsval_t arr, jsoff_t *idx, jsval_t spread_value) {
-  uint8_t t = vtype(spread_value);
-  if (t == T_ARR) {
-    jsoff_t len = js_arr_len(js, spread_value);
-    for (jsoff_t i = 0; i < len; i++) {
-      arr_set(js, arr, *idx, arr_get(js, spread_value, i)); (*idx)++;
-    }
-    return js_mkundef();
-  }
-  if (t == T_STR) {
-    spread_arr_literal_ctx_t ctx = { .arr = arr, .idx = idx };
-    return str_spread_chars(js, spread_value, SPREAD_STR_CB, &ctx, spread_arr_literal_iter_cb);
-  }
-  spread_arr_literal_ctx_t ctx = { .arr = arr, .idx = idx };
-  return iter_foreach(js, spread_value, spread_arr_literal_iter_cb, &ctx);
-}
-
-static jsval_t js_arr_literal(struct js *js) {
-  bool saved_tail = js->tail_ctx;
-  js->tail_ctx = false;
-  
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  jsval_t arr = exe ? mkarr(js) : js_mkundef();
-  if (is_err(arr)) return arr;
-
-  js->consumed = 1;
-  jsoff_t idx = 0;
-  
-  while (next(js) != TOK_RBRACKET) {
-    if (next(js) == TOK_COMMA) {
-      if (exe) {
-        jsoff_t doff = get_dense_buf(js, arr);
-        if (doff && idx >= dense_capacity(js, doff)) doff = dense_grow(js, arr, idx + 1);
-        if (doff) {
-          dense_set(js, doff, idx, T_EMPTY);
-          if (idx >= dense_length(js, doff))  dense_set_length(js, doff, idx + 1);
-        }
-      }
-      idx++; js->consumed = 1;
-      continue;
-    }
-    
-    bool is_spread = (next(js) == TOK_REST);
-    if (is_spread) js->consumed = 1;
-
-    jsval_t val = js_expr(js);
-    if (!exe) goto next_elem;
-    if (is_err(val)) return val;
-
-    jsval_t resolved = resolveprop(js, val);
-    if (!is_spread) {
-      arr_set(js, arr, idx, resolved);
-      idx++; goto next_elem;
-    }
-    jsval_t spread_result = append_spread_to_array_literal(js, arr, &idx, resolved);
-    if (is_err(spread_result)) return spread_result;
-
-  next_elem:
-    if (next(js) == TOK_RBRACKET) break;
-    EXPECT(TOK_COMMA);
-  }
-
-  EXPECT(TOK_RBRACKET);
-  if (exe) {
-    jsoff_t doff = get_dense_buf(js, arr);
-    if (doff) dense_set_length(js, doff, idx); else {
-      jsval_t res = js_mkprop_fast(js, arr, "length", 6, tov((double)idx));
-      if (is_err(res)) return res;
-    }
-    arr = mkval(T_ARR, vdata(arr));
-  }
-  js->tail_ctx = saved_tail;
-  return arr;
-}
-
-static void regexp_init_flags(struct js *js, jsval_t obj, const char *fstr, jsoff_t flen) {
-  bool g = false, i = false, m = false, s = false, y = false;
-  for (jsoff_t k = 0; k < flen; k++) {
-    if (fstr[k] == 'g') g = true;
-    if (fstr[k] == 'i') i = true;
-    if (fstr[k] == 'm') m = true;
-    if (fstr[k] == 's') s = true;
-    if (fstr[k] == 'y') y = true;
-  }
-
-  char sorted[8]; int si = 0;
-  if (g) sorted[si++] = 'g';
-  if (i) sorted[si++] = 'i';
-  if (m) sorted[si++] = 'm';
-  if (s) sorted[si++] = 's';
-  if (y) sorted[si++] = 'y';
-  
-  js_setprop(js, obj, js_mkstr(js, "flags", 5), js_mkstr(js, sorted, si));
-  js_setprop(js, obj, js_mkstr(js, "global", 6), mkval(T_BOOL, g ? 1 : 0));
-  js_setprop(js, obj, js_mkstr(js, "ignoreCase", 10), mkval(T_BOOL, i ? 1 : 0));
-  js_setprop(js, obj, js_mkstr(js, "multiline", 9), mkval(T_BOOL, m ? 1 : 0));
-  js_setprop(js, obj, js_mkstr(js, "dotAll", 6), mkval(T_BOOL, s ? 1 : 0));
-  js_setprop(js, obj, js_mkstr(js, "sticky", 6), mkval(T_BOOL, y ? 1 : 0));
-  js_setprop(js, obj, js_mkstr(js, "lastIndex", 9), tov(0));
-}
-
-static jsval_t js_regex_literal(struct js *js) {
-  jsoff_t start = js->pos;
-  jsoff_t pattern_start = start;
-  bool in_class = false;
-  
-  while (js->pos < js->clen) {
-    char c = js->code[js->pos];
-    if (c == '\\' && js->pos + 1 < js->clen) {
-      js->pos += 2;
-      continue;
-    }
-    if (c == '[') in_class = true;
-    else if (c == ']') in_class = false;
-    else if (c == '/' && !in_class) break;
-    js->pos++;
-  }
-  
-  if (js->pos >= js->clen || js->code[js->pos] != '/') {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "unterminated regex");
-  }
-  
-  jsoff_t pattern_end = js->pos;
-  js->pos++;
-  
-  jsoff_t flags_start = js->pos;
-  while (js->pos < js->clen) {
-    char c = js->code[js->pos];
-    if (c == 'g' || c == 'i' || c == 'm' || c == 's' || c == 'u' || c == 'y') {
-      js->pos++;
-    } else break;
-  }
-  
-  jsoff_t flags_end = js->pos;
-  if (js->flags & F_NOEXEC) return js_mkundef();
-  
-  jsval_t pattern = js_mkstr(js, &js->code[pattern_start], pattern_end - pattern_start);
-  jsval_t regexp_obj = mkobj(js, 0);
-  
-  jsval_t regexp_proto = get_ctor_proto(js, "RegExp", 6);
-  if (vtype(regexp_proto) == T_OBJ) set_proto(js, regexp_obj, regexp_proto);
-
-  js_setprop(js, regexp_obj, js_mkstr(js, "source", 6), pattern);
-  regexp_init_flags(js, regexp_obj, &js->code[flags_start], flags_end - flags_start);
-
-  return regexp_obj;
-}
-
-static jsval_t set_obj_property(struct js *js, jsval_t obj, jsval_t key, jsval_t val, bool is_computed, bool *proto_set) {
-  bool is_proto = false;
-  if (!is_computed && vtype(key) == T_STR) {
-    jsoff_t klen;
-    const char *kstr = (char *)&js->mem[vstr(js, key, &klen)];
-    is_proto = (klen == STR_PROTO_LEN && memcmp(kstr, STR_PROTO, STR_PROTO_LEN) == 0);
-  }
-
-  if (is_proto) {
-    if (*proto_set) return js_mkerr_typed(js, JS_ERR_SYNTAX, "Duplicate __proto__ fields are not allowed in object literals");
-    *proto_set = true;
-    uint8_t pt = vtype(val);
-    if (pt == T_OBJ || pt == T_ARR || pt == T_FUNC || pt == T_NULL) {
-      set_proto(js, obj, pt == T_NULL ? js_mknull() : val);
-    }
-    return js_mkundef();
-  }
-
-  if (vtype(val) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(val));
-    if (lkp(js, func_obj, "name", 4) == 0) {
-      jsval_t name_key = js_mkstr(js, "name", 4);
-      if (!is_err(name_key)) js_setprop(js, func_obj, name_key, key);
-    }
-  }
-  
-  return js_setprop(js, obj, key, val);
-}
-
-static jsval_t js_obj_literal(struct js *js) {
-  bool saved_tail = js->tail_ctx;
-  js->tail_ctx = false;
-  
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  jsval_t obj = exe ? mkobj(js, 0) : js_mkundef();
-  if (is_err(obj)) return obj;
-  if (exe) {
-    jsval_t object_proto = get_ctor_proto(js, "Object", 6);
-    if (vtype(object_proto) == T_OBJ) set_proto(js, obj, object_proto);
-  }
-  js->consumed = 1;
-  bool proto_set_in_literal = false;
-  
-  while (next(js) != TOK_RBRACE) {
-    jsval_t key = 0;
-    jsoff_t id_off = 0, id_len = 0;
-    bool is_computed = false;
-    
-    if (js->tok == TOK_REST) {
-      js->consumed = 1;
-      jsval_t spread_expr = js_expr(js);
-      if (is_err(spread_expr)) return spread_expr;
-      if (!exe) goto spread_next;
-      
-      jsval_t spread_obj = resolveprop(js, spread_expr);
-      uint8_t st = vtype(spread_obj);
-      if (st != T_OBJ && st != T_ARR && st != T_FUNC) goto spread_next;
-      
-      jsval_t src_obj = (st == T_OBJ) ? spread_obj : mkval(T_OBJ, vdata(spread_obj));
-      jsoff_t next_prop_off = loadoff(js, (jsoff_t) vdata(src_obj)) & ~(3U | FLAGMASK);
-      
-      while (next_prop_off < js->brk && next_prop_off != 0) {
-        jsoff_t header = loadoff(js, next_prop_off);
-        if (is_slot_prop(header)) { next_prop_off = next_prop(header); continue; }
-        
-        jsoff_t koff = loadoff(js, next_prop_off + (jsoff_t) sizeof(next_prop_off));
-        jsoff_t klen = offtolen(loadoff(js, koff));
-        const char *prop_key = (char *) &js->mem[koff + sizeof(koff)];
-        jsval_t prop_val = loadval(js, next_prop_off + (jsoff_t) (sizeof(next_prop_off) + sizeof(koff)));
-        
-        next_prop_off = next_prop(header);
-        if (is_internal_prop(prop_key, klen)) continue;
-        
-        jsval_t key_str = js_mkstr(js, prop_key, klen);
-        js_setprop(js, obj, key_str, prop_val);
-      }
-      
-    spread_next:
-      if (next(js) == TOK_RBRACE) break;
-      EXPECT(TOK_COMMA);
-      continue;
-    }
-    
-    bool is_getter = false, is_setter = false;
-    if (js->tok == TOK_IDENTIFIER) {
-      bool is_get = (js->tlen == 3 && memcmp(js->code + js->toff, "get", 3) == 0);
-      bool is_set = (js->tlen == 3 && memcmp(js->code + js->toff, "set", 3) == 0);
-      
-      if (is_get || is_set) {
-        jsoff_t saved_pos = js->pos;
-        uint8_t saved_tok = js->tok;
-        uint8_t saved_consumed = js->consumed;
-        jsoff_t saved_toff = js->toff;
-        jsoff_t saved_tlen = js->tlen;
-        int saved_stream_pos = js->token_stream_pos;
-        
-        js->consumed = 1;
-        uint8_t peek = next(js);
-        
-        if (peek == TOK_IDENTIFIER || peek == TOK_STRING || peek == TOK_NUMBER || peek == TOK_LBRACKET) {
-          is_getter = is_get;
-          is_setter = is_set;
-          
-          if (peek == TOK_IDENTIFIER) {
-            id_off = js->toff;
-            id_len = js->tlen;
-            if (exe) key = js_mkstr_ident(js, js->code + js->toff, js->tlen);
-          } else if (peek == TOK_STRING) {
-            id_off = js->toff;
-            id_len = js->tlen;
-            if (exe) key = js_str_literal(js);
-          } else if (peek == TOK_NUMBER) {
-            id_off = js->toff;
-            id_len = js->tlen;
-            if (exe) {
-              double num = strtod(js->code + js->toff, NULL);
-              char buf[64];
-              size_t n = strnum(tov(num), buf, sizeof(buf));
-              key = js_mkstr(js, buf, n);
-            }
-          } else if (peek == TOK_LBRACKET) {
-            is_computed = true;
-            js->consumed = 1;
-            jsval_t key_expr = js_expr(js);
-            if (is_err(key_expr)) return key_expr;
-            
-            if (exe) {
-              jsval_t resolved_key = resolveprop(js, key_expr);
-              if (vtype(resolved_key) == T_STR) {
-                key = resolved_key;
-              } else {
-                char buf[64];
-                size_t n = tostr(js, resolved_key, buf, sizeof(buf));
-                key = js_mkstr(js, buf, n);
-              }
-              if (is_err(key)) return key;
-            }
-            
-            if (next(js) != TOK_RBRACKET) {
-              return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected after computed property name");
-            }
-          }
-        } else {
-          js->pos = saved_pos;
-          js->tok = saved_tok;
-          js->consumed = saved_consumed;
-          js->toff = saved_toff;
-          js->tlen = saved_tlen;
-          js->token_stream_pos = saved_stream_pos;
-          
-          id_off = saved_toff;
-          id_len = saved_tlen;
-          if (exe) key = js_mkstr_ident(js, js->code + saved_toff, saved_tlen);
-        }
-      } else {
-        id_off = js->toff;
-        id_len = js->tlen;
-        if (exe) key = js_mkstr_ident(js, js->code + js->toff, js->tlen);
-      }
-    } else if (js->tok == TOK_STRING) {
-      if (exe) key = js_str_literal(js);
-    } else if (js->tok == TOK_NUMBER) {
-      if (exe) {
-        double num = strtod(js->code + js->toff, NULL);
-        char buf[64];
-        size_t n = strnum(tov(num), buf, sizeof(buf));
-        key = js_mkstr(js, buf, n);
-      }
-    } else if (js->tok == TOK_LBRACKET) {
-      is_computed = true;
-      js->consumed = 1;
-      jsval_t key_expr = js_expr(js);
-      if (is_err(key_expr)) return key_expr;
-      
-      if (exe) {
-        jsval_t resolved_key = resolveprop(js, key_expr);
-        if (vtype(resolved_key) == T_STR) {
-          key = resolved_key;
-        } else if (vtype(resolved_key) == T_SYMBOL) {
-          char buf[64];
-          sym_to_prop_key(resolved_key, buf, sizeof(buf));
-          key = js_mkstr(js, buf, strlen(buf));
-        } else {
-          char buf[64];
-          size_t n = tostr(js, resolved_key, buf, sizeof(buf));
-          key = js_mkstr(js, buf, n);
-        }
-        if (is_err(key)) return key;
-      }
-      
-      if (next(js) != TOK_RBRACKET) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected after computed property name");
-      }
-    } else if (is_keyword_propname(js->tok)) {
-      id_off = js->toff;
-      id_len = js->tlen;
-      if (exe) key = js_mkstr(js, js->code + js->toff, js->tlen);
-    } else {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "parse error");
-    }
-    js->consumed = 1;
-    
-    if (!is_computed && id_len > 0 && (next(js) == TOK_COMMA || next(js) == TOK_RBRACE)) {
-      jsval_t val = lookup(js, js->code + id_off, id_len);
-      if (exe) {
-        if (is_err(val)) return val;
-        if (is_err(key)) return key;
-        jsval_t res = js_setprop(js, obj, key, resolveprop(js, val));
-        if (is_err(res)) return res;
-      }
-    } else if (
-        (is_getter || is_setter) ||
-        (!is_computed && id_len > 0 && next(js) == TOK_LPAREN) ||
-        (is_computed && next(js) == TOK_LPAREN)
-      ) {
-      uint8_t flags = js->flags;
-      jsoff_t pos = js->pos - 1;
-      js->consumed = 1;
-      if (!parse_func_params(js, &flags, NULL)) {
-        js->flags = flags;
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid parameters");
-      }
-      EXPECT(TOK_RPAREN, js->flags = flags);
-      EXPECT(TOK_LBRACE, js->flags = flags);
-      js->consumed = 0;
-      js->flags |= F_NOEXEC;
-      jsval_t block_res = js_block(js, false);
-      if (is_err(block_res)) {
-        js->flags = flags;
-        return block_res;
-      }
-      js->flags = flags;
-      js->consumed = 1;
-      
-      if (exe) {
-        jsval_t func_obj = mkobj(js, 0);
-        if (is_err(func_obj)) return func_obj;
-        set_func_code(js, func_obj, &js->code[pos], js->pos - pos);
-        jsval_t name_key = js_mkstr(js, "name", 4);
-        js_setprop(js, func_obj, name_key, key);
-        
-        jsval_t closure_scope = for_let_capture_scope(js);
-        if (is_err(closure_scope)) return closure_scope;
-        set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-        
-        jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-        if (vtype(func_proto) == T_FUNC) set_proto(js, func_obj, func_proto);
-        jsval_t val = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-        
-        if (is_getter || is_setter) {
-          jsoff_t key_len;
-          const char *key_str = NULL;
-          if (vtype(key) == T_STR) {
-            jsoff_t key_off = vstr(js, key, &key_len);
-            key_str = (char *)&js->mem[key_off];
-          }
-          
-          if (key_str) {
-            if (is_getter) {
-              js_set_getter_desc(js, obj, key_str, key_len, val, JS_DESC_E | JS_DESC_C);
-            } else js_set_setter_desc(js, obj, key_str, key_len, val, JS_DESC_E | JS_DESC_C);
-          }
-        } else {
-          jsval_t res = js_setprop(js, obj, key, val);
-          if (is_err(res)) return res;
-        }
-      }
-    } else {
-      EXPECT(TOK_COLON);
-      jsval_t val = js_expr(js);
-      if (exe) {
-        if (is_err(val)) return val;
-        if (is_err(key)) return key;
-        jsval_t res = set_obj_property(
-          js, obj, key, resolveprop(js, val), 
-          is_computed, &proto_set_in_literal
-        );
-        if (is_err(res)) return res;
-      }
-    }
-    
-    if (next(js) == TOK_RBRACE) break;
-    EXPECT(TOK_COMMA);
-  }
-  
-  EXPECT(TOK_RBRACE);
-  js->tail_ctx = saved_tail;
-  
-  return obj;
-}
-
-static void skip_default_value(struct js *js) {
-  int depth = 0;
-  while (next(js) != TOK_EOF) {
-    uint8_t tok = next(js);
-    if (depth == 0 && (tok == TOK_RPAREN || tok == TOK_COMMA)) break;
-    js->consumed = 1;
-    if (tok == TOK_LPAREN || tok == TOK_LBRACKET || tok == TOK_LBRACE) depth++;
-    else if (tok == TOK_RPAREN || tok == TOK_RBRACKET || tok == TOK_RBRACE) depth--;
-  }
-}
-
-static void skip_destructuring_pattern(struct js *js) {
-  uint8_t open_tok = js->tok;
-  uint8_t close_tok = (open_tok == TOK_LBRACE) ? TOK_RBRACE : TOK_RBRACKET;
-  int depth = 1;
-  js->consumed = 1;
-  while (depth > 0 && next(js) != TOK_EOF) {
-    if (js->tok == open_tok) depth++;
-    else if (js->tok == close_tok) depth--;
-    if (depth > 0) js->consumed = 1;
-  }
-  js->consumed = 1;
-}
-
-typedef struct { const char *name; size_t len; } param_entry_t;
-static const UT_icd param_entry_icd = { sizeof(param_entry_t), NULL, NULL, NULL };
-
-static bool parse_func_params(struct js *js, uint8_t *flags, int *out_count) {
-  UT_array *params;
-  utarray_new(params, &param_entry_icd);
-  
-  #define FAIL(msg, ...) do { \
-    if (flags) js->flags = *flags; \
-    js_mkerr_typed(js, JS_ERR_SYNTAX, msg, ##__VA_ARGS__); \
-    utarray_free(params); \
-    return false; \
-  } while(0)
-  
-  while (next(js) != TOK_EOF && next(js) != TOK_RPAREN) {
-    bool is_rest = (next(js) == TOK_REST);
-    if (is_rest) { js->consumed = 1; next(js); }
-    
-    if (next(js) == TOK_LBRACE || next(js) == TOK_LBRACKET) {
-      skip_destructuring_pattern(js);
-      param_entry_t entry = {NULL, 0};
-      utarray_push_back(params, &entry);
-      if (next(js) == TOK_ASSIGN) { js->consumed = 1; skip_default_value(js); }
-    } else if (is_valid_param_name(next(js))) {
-      const char *name = &js->code[js->toff];
-      size_t len = js->tlen;
-      
-      if ((js->flags & F_STRICT) && is_strict_restricted(name, len))
-      FAIL("cannot use '%.*s' as parameter name in strict mode", (int)len, name);
-      
-      if (js->flags & F_STRICT) {
-        param_entry_t *p = NULL;
-        while ((p = (param_entry_t *)utarray_next(params, p))) {
-          if (p->len == len && p->name && memcmp(p->name, name, len) == 0)
-          FAIL("duplicate parameter name '%.*s' in strict mode", (int)len, name);
-        }
-      }
-      
-      param_entry_t entry = {name, len};
-      utarray_push_back(params, &entry);
-      js->consumed = 1;
-      if (next(js) == TOK_ASSIGN) { js->consumed = 1; skip_default_value(js); }
-    } else {
-      FAIL("identifier expected");
-    }
-    
-    if (is_rest && next(js) != TOK_RPAREN) FAIL("rest parameter must be last");
-    if (next(js) == TOK_RPAREN) break;
-    if (next(js) != TOK_COMMA) FAIL("parse error");
-    js->consumed = 1;
-  }
-  
-  #undef FAIL
-  
-  if (out_count) *out_count = (int)utarray_len(params);
-  utarray_free(params);
-  return true;
-}
-
-static jsval_t js_func_literal(struct js *js, bool is_async) {
-  uint8_t flags = js->flags;
-  js->consumed = 1;
-  jsoff_t name_off = 0, name_len = 0;
-  if (next(js) == TOK_IDENTIFIER) {
-    name_off = js->toff;
-    name_len = js->tlen;
-    js->consumed = 1;
-  }
-  
-  EXPECT(TOK_LPAREN, js->flags = flags);
-  jsoff_t pos = js->pos - 1;
-  int param_count = 0;
-  if (!parse_func_params(js, &flags, &param_count)) {
-    js->flags = flags;
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid parameters");
-  }
-  
-  EXPECT(TOK_RPAREN, js->flags = flags);
-  EXPECT(TOK_LBRACE, js->flags = flags);
-  js->consumed = 0;
-  js->flags |= F_NOEXEC;
-  
-  jsval_t res = js_block(js, false);
-  if (is_err(res)) {
-    js->flags = flags;
-    return res;
-  }
-  js->flags = flags;
-  js->consumed = 1;
-  jsval_t func_obj = mkobj(js, 0);
-  if (is_err(func_obj)) return func_obj;
-  set_func_code(js, func_obj, &js->code[pos], js->pos - pos);
-  
-  jsval_t res_len = js_setprop(js, func_obj, js->length_str, tov(param_count));
-  if (is_err(res_len)) return res_len;
-  js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
-  
-  if (is_async) {
-    set_slot(js, func_obj, SLOT_ASYNC, js_true);
-    jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-    if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
-  } else {
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    if (vtype(func_proto) == T_FUNC) set_proto(js, func_obj, func_proto);
-  }
-  
-  if (name_len > 0) {
-    jsval_t name_val = js_mkstr(js, &js->code[name_off], name_len);
-    if (is_err(name_val)) return name_val;
-    set_slot(js, func_obj, SLOT_NAME, name_val);
-    jsval_t name_key = js_mkstr(js, "name", 4);
-    if (is_err(name_key)) return name_key;
-    jsval_t res3 = js_setprop(js, func_obj, name_key, name_val);
-    if (is_err(res3)) return res3;
-  }
-  
-  if (!(flags & F_NOEXEC)) {
-    jsval_t closure_scope = for_let_capture_scope(js);
-    if (is_err(closure_scope)) return closure_scope;
-    set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-    if (flags & F_STRICT) set_slot(js, func_obj, SLOT_STRICT, js_true);
-  }
-  
-  jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-  
-  jsval_t proto_setup = setup_func_prototype(js, func);
-  if (is_err(proto_setup)) return proto_setup;
-  
-  return func;
-}
-
-#define RTL_BINOP(_f1, _f2, _cond)  \
-  jsval_t res = _f1(js);            \
-  while (!is_err(res) && (_cond)) { \
-    uint8_t op = js->tok;           \
-    js->consumed = 1;               \
-    jsval_t rhs = _f2(js);          \
-    if (is_err(rhs)) return rhs;    \
-    res = do_op(js, op, res, rhs);  \
-  }                                 \
-  return res;
-
-#define LTR_BINOP(_f, _cond)        \
-  jsval_t res = _f(js);             \
-  while (!is_err(res) && (_cond)) { \
-    uint8_t op = js->tok;           \
-    js->consumed = 1;               \
-    jsval_t rhs = _f(js);           \
-    if (is_err(rhs)) return rhs;    \
-    res = do_op(js, op, res, rhs);  \
-  }                                 \
-  return res;
-
-static jsval_t js_class_expr(struct js *js, bool is_expression);
-
-static jsval_t js_literal(struct js *js) {
-  next(js);
-  js->consumed = 1;
-  
-  switch (js->tok) {
-    case TOK_ERR:
-      if ((js->flags & F_STRICT) && js->toff < js->clen && js->code[js->toff] == '0' && 
-          js->toff + 1 < js->clen && is_digit(js->code[js->toff + 1])) {
-        uint8_t d = js->code[js->toff + 1];
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, d >= '0' && d <= '7'
-          ? "Octal literals are not allowed in strict mode."
-          : "Decimals with leading zeros are not allowed in strict mode.");
-      }
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "parse error");
-    case TOK_NUMBER:      return js->tval;
-    case TOK_BIGINT:      return js_bigint_literal(js);
-    case TOK_STRING:      return js_str_literal(js);
-    case TOK_TEMPLATE:    return js_template_literal(js);
-    case TOK_LBRACE:      return js_obj_or_destruct(js);
-    case TOK_LBRACKET:    return js_arr_or_destruct(js);
-    case TOK_DIV:         return js_regex_literal(js);
-    case TOK_CLASS:       return js_class_expr(js, true);
-    case TOK_FUNC: {
-      uint8_t la = lookahead(js);
-      if (la != TOK_LPAREN && la != TOK_IDENTIFIER) {
-        return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
-      }
-      return js_func_literal(js, false);
-    }
-    case TOK_ASYNC: {
-      jsoff_t async_off = js->toff, async_len = js->tlen;
-      js->consumed = 1;
-      uint8_t next_tok = next(js);
-      if (next_tok == TOK_FUNC) {
-        return js_func_literal(js, true);
-      } else if (next_tok == TOK_LPAREN) {
-        return js_async_arrow_paren(js);
-      } else if (next_tok == TOK_IDENTIFIER) {
-        jsoff_t id_start = js->toff;
-        jsoff_t id_len = js->tlen;
-        js->consumed = 1;
-        if (next(js) == TOK_ARROW) {
-          js->consumed = 1;
-          char param_buf[256];
-          if (id_len + 3 > sizeof(param_buf)) return js_mkerr(js, "param too long");
-          param_buf[0] = '(';
-          memcpy(param_buf + 1, &js->code[id_start], id_len);
-          param_buf[id_len + 1] = ')';
-          param_buf[id_len + 2] = '\0';
-          uint8_t flags = js->flags;
-          bool is_expr = next(js) != TOK_LBRACE;
-          jsoff_t body_start = is_expr ? js->toff : js->pos;
-          jsoff_t body_end = 0;
-          jsval_t body_result;
-          if (is_expr) {
-            js->flags |= F_NOEXEC;
-            body_result = js_assignment(js);
-            if (is_err(body_result)) { js->flags = flags; return body_result; }
-            uint8_t tok = next(js);
-            body_end = is_body_end_tok(tok) ? js->toff : js->pos;
-          } else {
-            body_start = js->toff;
-            js->flags |= F_NOEXEC;
-            js->consumed = 1;
-            body_result = js_block(js, false);
-            if (is_err(body_result)) { js->flags = flags; return body_result; }
-            if (js->tok == TOK_RBRACE && js->consumed) {
-              body_end = js->pos;
-            } else if (next(js) == TOK_RBRACE) {
-              body_end = js->pos;
-              js->consumed = 1;
-            } else body_end = js->pos;
-          }
-          js->flags = flags;
-          size_t body_len = body_end - body_start;
-          size_t param_len = id_len + 2;
-          size_t fn_len = param_len + body_len;
-          char *fn_str = (char *) malloc(fn_len + 1);
-          if (!fn_str) return js_mkerr(js, "oom");
-          memcpy(fn_str, param_buf, param_len);
-          memcpy(fn_str + param_len, &js->code[body_start], body_len);
-          jsval_t func_obj = mkobj(js, 0);
-          if (is_err(func_obj)) { free(fn_str); return func_obj; }
-          set_func_code(js, func_obj, fn_str, fn_len);
-          free(fn_str);
-          set_slot(js, func_obj, SLOT_ASYNC, js_true);
-          set_slot(js, func_obj, SLOT_ARROW, js_true);
-          jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-          if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
-          if (!(flags & F_NOEXEC)) {
-            jsval_t closure_scope = for_let_capture_scope(js);
-            if (is_err(closure_scope)) return closure_scope;
-            set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-            set_slot(js, func_obj, SLOT_THIS, js->this_val);
-            capture_arrow_new_target(js, func_obj);
-          }
-          return mkval(T_FUNC, (unsigned long) vdata(func_obj));
-        }
-        return mkcoderef((jsoff_t) id_start, (jsoff_t) id_len);
-      }
-      return mkcoderef(async_off, async_len);
-    }
-    
-    case TOK_SUPER: {
-      jsval_t super_ctor = js->super_val;
-      uint8_t la = lookahead(js);
-      if ((la == TOK_DOT || la == TOK_LBRACKET) && vtype(super_ctor) == T_FUNC) {
-        jsval_t ctor_obj = mkval(T_OBJ, vdata(super_ctor));
-        jsoff_t proto_off = lkp_interned(js, ctor_obj, INTERN_PROTOTYPE, 9);
-        if (proto_off == 0) return js_mkundef();
-        jsval_t proto = resolveprop(js, mkval(T_PROP, proto_off));
-        
-        next(js); js->consumed = 1;
-        const char *prop; jsoff_t prop_len;
-        if (la == TOK_DOT) {
-          if (next(js) != TOK_IDENTIFIER && !is_keyword_propname(js->tok))
-            return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected");
-          prop = &js->code[js->toff]; prop_len = js->tlen;
-          js->consumed = 1;
-        } else {
-          jsval_t idx = js_expr(js);
-          if (is_err(idx)) return idx;
-          if (next(js) != TOK_RBRACKET) return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected");
-          js->consumed = 1;
-          idx = resolveprop(js, idx);
-          if (vtype(idx) == T_STR) {
-            prop_len = 0; prop = (const char *)&js->mem[vstr(js, idx, &prop_len)];
-          } else {
-            char buf[32]; prop_len = (jsoff_t)tostr(js, idx, buf, sizeof(buf));
-            prop = buf;
-          }
-        }
-        
-        jsoff_t off = lkp(js, proto, prop, prop_len);
-        if (off == 0) off = lkp_proto(js, proto, prop, prop_len);
-        if (off == 0) return js_mkundef();
-        
-        jsval_t method = resolveprop(js, mkval(T_PROP, off));
-        if (vtype(method) != T_FUNC) return method;
-        
-        jsval_t bound = mkobj(js, 0);
-        jsval_t method_obj = mkval(T_OBJ, vdata(method));
-        
-        set_slot(js, bound, SLOT_CODE, get_slot(js, method_obj, SLOT_CODE));
-        set_slot(js, bound, SLOT_CODE_LEN, get_slot(js, method_obj, SLOT_CODE_LEN));
-        set_slot(js, bound, SLOT_SCOPE, get_slot(js, method_obj, SLOT_SCOPE));
-        set_slot(js, bound, SLOT_BOUND_THIS, js->this_val);
-        
-        jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-        if (vtype(func_proto) == T_FUNC) set_proto(js, bound, func_proto);
-        
-        return mkval(T_FUNC, vdata(bound));
-      }
-      js->pending_ntg = js->new_target;
-      return super_ctor;
-    }
-    
-    case TOK_TRUE:        return js_true;
-    case TOK_FALSE:       return js_false;
-    
-    case TOK_NULL:        return js_mknull();
-    case TOK_UNDEF:       return js_mkundef();
-    case TOK_THIS:        return js->this_val;
-    
-    default:
-      if (is_identifier_like(js->tok)) return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
-      size_t tok_len = js->tlen > 20 ? 20 : js->tlen;
-      if (tok_len == 0) return js_mkerr_typed(js, JS_ERR_SYNTAX, "Unexpected token 'EOF'");
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "Unexpected token '%.*s'", (int)tok_len, &js->code[js->toff]);
-  }
-}
-
-static jsval_t js_arrow_func(struct js *js, jsoff_t params_start, jsoff_t params_end, bool is_async) {
-  uint8_t flags = js->flags;
-  bool is_expr = next(js) != TOK_LBRACE;
-  jsoff_t body_start, body_end_actual;
-  jsval_t body_result;
-  
-  if (is_expr) {
-    body_start = js->toff;
-    js->flags |= F_NOEXEC;
-    body_result = js_assignment(js);
-    if (is_err(body_result)) {
-      js->flags = flags;
-      return body_result;
-    }
-    uint8_t tok = next(js);
-    body_end_actual = is_body_end_tok(tok) ? js->toff : js->pos;
-  } else {
-    body_start = js->toff;
-    js->flags |= F_NOEXEC;
-    js->consumed = 1;
-    body_result = js_block(js, false);
-    if (is_err(body_result)) {
-      js->flags = flags;
-      return body_result;
-    }
-    if (js->tok == TOK_RBRACE && js->consumed) {
-      body_end_actual = js->pos;
-    } else if (next(js) == TOK_RBRACE) {
-      body_end_actual = js->pos;
-      js->consumed = 1;
-    } else {
-      body_end_actual = js->pos;
-    }
-  }
-  
-  js->flags = flags;
-  
-  size_t param_len = params_end - params_start;
-  size_t body_len = body_end_actual - body_start;
-  size_t fn_len = param_len + body_len;
-  
-  char *fn_str = (char *) malloc(fn_len + 1);
-  if (!fn_str) return js_mkerr(js, "oom");
-  
-  memcpy(fn_str, &js->code[params_start], param_len);
-  memcpy(fn_str + param_len, &js->code[body_start], body_len);
-
-  jsval_t func_obj = mkobj(js, 0);
-  if (is_err(func_obj)) { free(fn_str); return func_obj; }
-  
-  set_func_code(js, func_obj, fn_str, fn_len);
-  free(fn_str);
-  
-  if (is_async) {
-    set_slot(js, func_obj, SLOT_ASYNC, js_true);
-    jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-    if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
-  } else {
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    if (vtype(func_proto) == T_FUNC) set_proto(js, func_obj, func_proto);
-  }
-  
-  if (!(flags & F_NOEXEC)) {
-    jsval_t closure_scope = for_let_capture_scope(js);
-    if (is_err(closure_scope)) return closure_scope;
-    set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-    set_slot(js, func_obj, SLOT_THIS, js->this_val);
-    capture_arrow_new_target(js, func_obj);
-  }
-  
-  set_slot(js, func_obj, SLOT_ARROW, js_true);
-  return mkval(T_FUNC, (unsigned long) vdata(func_obj));
-}
-
-static jsval_t js_async_arrow_paren(struct js *js) {
-  jsoff_t paren_start = js->pos - 1;
-  js->consumed = 1;
-  jsoff_t saved_pos = js->pos;
-  uint8_t saved_tok = js->tok;
-  uint8_t saved_consumed = js->consumed;
-  uint8_t saved_flags = js->flags;
-  int saved_stream_pos = js->token_stream_pos;
-  int paren_depth = 1;
-  js->flags |= F_NOEXEC;
-  while (paren_depth > 0 && next(js) != TOK_EOF) {
-    if (js->tok == TOK_LPAREN) paren_depth++;
-    else if (js->tok == TOK_RPAREN) paren_depth--;
-    js->consumed = 1;
-  }
-  jsoff_t paren_end = js->pos;
-  bool is_arrow = lookahead(js) == TOK_ARROW;
-  js->pos = saved_pos;
-  js->tok = saved_tok;
-  js->consumed = saved_consumed;
-  js->flags = saved_flags;
-  js->token_stream_pos = saved_stream_pos;
-  if (is_arrow) {
-    js->flags |= F_NOEXEC;
-    while (next(js) != TOK_RPAREN && next(js) != TOK_EOF) {
-      js->consumed = 1;
-    }
-    if (next(js) != TOK_RPAREN) return js_mkerr_typed(js, JS_ERR_SYNTAX, ") expected");
-    js->consumed = 1;
-    js->flags = saved_flags;
-    if (next(js) != TOK_ARROW) return js_mkerr_typed(js, JS_ERR_SYNTAX, "=> expected");
-    js->consumed = 1;
-    return js_arrow_func(js, paren_start, paren_end, true);
-  }
-  return js_mkerr_typed(js, JS_ERR_SYNTAX, "async ( must be arrow function");
-}
-
-static jsval_t js_group(struct js *js) {
-  if (next(js) == TOK_LPAREN) {
-    if (++js->parse_depth > JS_MAX_PARSE_DEPTH) {
-      js->parse_depth--;
-      return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum call stack size exceeded");
-    }
-    jsoff_t paren_start = js->pos - 1;
-    js->consumed = 1;
-    
-    jsoff_t saved_pos = js->pos;
-    uint8_t saved_tok = js->tok;
-    uint8_t saved_consumed = js->consumed;
-    uint8_t saved_flags = js->flags;
-    int saved_stream_pos = js->token_stream_pos;
-    
-    int paren_depth = 1;
-    bool could_be_arrow = true;
-    js->flags |= F_NOEXEC;
-    
-    while (paren_depth > 0 && next(js) != TOK_EOF) {
-      if (js->tok == TOK_LPAREN) paren_depth++;
-      else if (js->tok == TOK_RPAREN) paren_depth--;
-      if (paren_depth > 0 && !is_valid_arrow_param_tok(js->tok)) could_be_arrow = false;
-      js->consumed = 1;
-    }
-    
-    jsoff_t paren_end = js->pos;
-    bool is_arrow = could_be_arrow && lookahead(js) == TOK_ARROW;
-    
-    js->pos = saved_pos;
-    js->tok = saved_tok;
-    js->consumed = saved_consumed;
-    js->flags = saved_flags;
-    js->token_stream_pos = saved_stream_pos;
-    
-    if (is_arrow) {
-      js->flags |= F_NOEXEC;
-      int skip_paren_depth = 1;
-      while (skip_paren_depth > 0 && next(js) != TOK_EOF) {
-        if (js->tok == TOK_LPAREN) skip_paren_depth++;
-        else if (js->tok == TOK_RPAREN) skip_paren_depth--;
-        if (skip_paren_depth > 0) js->consumed = 1;
-      }
-      
-      if (next(js) != TOK_RPAREN) { 
-        js->parse_depth--; 
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, ") expected"); 
-      }
-      
-      js->consumed = 1;
-      js->flags = saved_flags;
-      
-      if (next(js) != TOK_ARROW) { 
-        js->parse_depth--; 
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "=> expected"); 
-      }
-      
-      js->consumed = 1;
-      js->parse_depth--;
-      
-      return js_arrow_func(js, paren_start, paren_end, false);
-    } else {
-      if (next(js) == TOK_RPAREN) {
-        js->parse_depth--;
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "Parenthesized expression cannot be empty");
-      }
-      
-      jsval_t v = js_expr(js);
-      if (is_err(v)) { js->parse_depth--; return v; }
-      
-      while (next(js) == TOK_COMMA) {
-        js->consumed = 1;
-        v = js_expr(js);
-        if (is_err(v)) { js->parse_depth--; return v; }
-      }
-      
-      if (next(js) != TOK_RPAREN) { 
-        js->parse_depth--;
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, ") expected"); 
-      }
-      
-      js->consumed = 1;
-      js->parse_depth--;
-      
-      return v;
-    }
-  } else return js_literal(js);
-}
-
-static jsval_t js_call_dot(struct js *js) {
-  jsval_t res = js_group(js);
-  jsval_t obj = js_mkundef();
-  if (is_err(res)) return res;
-  if (vtype(res) == T_CODEREF) {
-    if (lookahead(js) == TOK_ARROW) return res;
-    if (lookahead(js) == TOK_TEMPLATE) {
-      jsval_t tag_func = lookup(js, &js->code[coderefoff(res)], codereflen(res));
-      if (is_err(tag_func)) return tag_func;
-      if (!(js->flags & F_NOEXEC) && !is_err(tag_func)) tag_func = resolveprop(js, tag_func);
-      js->consumed = 1;
-      next(js);
-      js->consumed = 1;
-      res = js_tagged_template(js, tag_func);
-      if (is_err(res)) return res;
-      goto js_call_dot_loop;
-    }
-    if ((js->flags & F_STRICT) && is_eval_or_arguments(js, coderefoff(res), codereflen(res))) {
-      uint8_t la = lookahead(js);
-      if (la == TOK_ASSIGN || la == TOK_PLUS_ASSIGN || la == TOK_MINUS_ASSIGN ||
-          la == TOK_MUL_ASSIGN || la == TOK_DIV_ASSIGN || la == TOK_REM_ASSIGN ||
-          la == TOK_SHL_ASSIGN || la == TOK_SHR_ASSIGN || la == TOK_ZSHR_ASSIGN ||
-          la == TOK_AND_ASSIGN || la == TOK_XOR_ASSIGN || la == TOK_OR_ASSIGN ||
-          la == TOK_POSTINC || la == TOK_POSTDEC) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot modify eval or arguments in strict mode");
-      }
-    }
-    jsoff_t id_off = coderefoff(res);
-    jsoff_t id_len = codereflen(res);
-    jsoff_t saved_pos = js->pos;
-    uint8_t saved_tok = js->tok;
-    uint8_t saved_consumed = js->consumed;
-    int saved_stream_pos = js->token_stream_pos;
-    res = lookup(js, &js->code[id_off], id_len);
-    if (is_err(res)) {
-      if (!(js->flags & F_STRICT) && !(js->flags & F_NOEXEC)) {
-        js->pos = saved_pos;
-        js->tok = saved_tok;
-        js->consumed = saved_consumed;
-        js->token_stream_pos = saved_stream_pos;
-        uint8_t next_tok = next(js);
-        if (next_tok == TOK_ASSIGN) {
-          js->flags &= (uint8_t)~F_THROW;
-          js->thrown_value = js_mkundef();
-          if (js->errmsg) js->errmsg[0] = '\0';
-          return mkcoderef(id_off, id_len);
-        }
-      }
-      if (is_err(res)) return res;
-    }
-  }
-  js_call_dot_loop:
-  bool opt_chain_skip = false;
-  bool saved_tail_for_chain = js->tail_ctx;
-  uint8_t cd_tok;
-  while (
-    cd_tok = next(js), 
-    cd_tok == TOK_LPAREN 
-    || cd_tok == TOK_DOT 
-    || cd_tok == TOK_OPTIONAL_CHAIN 
-    || cd_tok == TOK_LBRACKET 
-    || cd_tok == TOK_TEMPLATE
-  ) {
-    if (opt_chain_skip) {
-      if (js->tok == TOK_OPTIONAL_CHAIN || js->tok == TOK_DOT) {
-        js->consumed = 1;
-        uint8_t nxt = next(js);
-        if (nxt == TOK_HASH) { js->consumed = 1; next(js); }
-        if (next(js) == TOK_IDENTIFIER || is_keyword_propname(next(js))) js->consumed = 1;
-        else if (next(js) == TOK_LBRACKET) {
-          js->consumed = 1; js_expr(js);
-          if (next(js) == TOK_RBRACKET) js->consumed = 1;
-        }
-        if (js->tok == TOK_OPTIONAL_CHAIN) opt_chain_skip = false;
-        continue;
-      } else if (js->tok == TOK_LBRACKET) {
-        js->consumed = 1; js_expr(js);
-        if (next(js) == TOK_RBRACKET) js->consumed = 1;
-        continue;
-      } else if (js->tok == TOK_LPAREN) {
-        js->consumed = 1; js_call_params(js);
-        continue;
-      } else opt_chain_skip = false;
-    }
-    if (js->tok == TOK_TEMPLATE) {
-      if (vtype(res) == T_PROP) res = resolveprop(js, res);
-      if (is_err(res)) return res;
-      js->consumed = 1;
-      res = js_tagged_template(js, res);
-      if (is_err(res)) return res;
-    } else if (js->tok == TOK_DOT || js->tok == TOK_OPTIONAL_CHAIN) {
-      uint8_t op = js->tok;
-      js->consumed = 1;
-      if (vtype(res) != T_PROP && vtype(res) != T_PROPREF) {
-        obj = res;
-      } else obj = resolveprop(js, res);
-      jsval_t prop_name;
-      uint8_t nxt = next(js);
-      if (nxt == TOK_HASH) {
-        js->consumed = 1;
-        if (next(js) != TOK_IDENTIFIER) {
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "private field name expected");
-        }
-        js->consumed = 1;
-        prop_name = mkcoderef((jsoff_t) (js->toff - 1), (jsoff_t) (js->tlen + 1));
-      } else if (nxt == TOK_IDENTIFIER || is_keyword_propname(nxt)) {
-        js->consumed = 1;
-        prop_name = mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
-      } else if (nxt == TOK_LBRACKET) {
-        js->consumed = 1;
-        jsval_t idx = js_expr(js);
-        if (is_err(idx)) return idx;
-        if (next(js) != TOK_RBRACKET) return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected");
-        js->consumed = 1;
-        if (op == TOK_OPTIONAL_CHAIN && (vtype(obj) == T_NULL || vtype(obj) == T_UNDEF)) {
-          res = js_mkundef();
-          opt_chain_skip = true;
-        } else res = do_op(js, TOK_BRACKET, res, idx);
-        continue;
-      } else prop_name = js_group(js);
-      if (op == TOK_OPTIONAL_CHAIN && (vtype(obj) == T_NULL || vtype(obj) == T_UNDEF)) {
-        res = js_mkundef();
-        opt_chain_skip = true;
-      } else res = do_op(js, op, res, prop_name);
-    } else if (js->tok == TOK_LBRACKET) {
-      js->consumed = 1;
-      if (vtype(res) != T_PROP && vtype(res) != T_PROPREF) {
-        obj = res;
-      } else obj = resolveprop(js, res);
-      jsval_t idx = js_expr(js);
-      if (is_err(idx)) return idx;
-      if (next(js) != TOK_RBRACKET) return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected");
-      js->consumed = 1;
-      res = do_op(js, TOK_BRACKET, res, idx);
-    } else {
-      jsval_t func_this = obj;
-      bool is_super_call = (vtype(js->super_val) != T_UNDEF && res == js->super_val);
-      if (vtype(obj) == T_UNDEF) {
-        if (vtype(res) == T_PROPREF) {
-          jsoff_t obj_off = propref_obj(res);
-          func_this = mkval(T_OBJ, obj_off);
-        } else func_this = js->this_val;
-      }
-      push_this(func_this);
-      js->tail_ctx = false;
-      jsval_t params = js_call_params(js);
-      if (is_err(params)) {
-        pop_this();
-        return params;
-      }
-      uint8_t la = lookahead(js);
-      if (la != TOK_LPAREN && la != TOK_DOT && la != TOK_LBRACKET
-          && la != TOK_OPTIONAL_CHAIN && la != TOK_TEMPLATE) {
-        js->tail_ctx = saved_tail_for_chain;
-      }
-      res = do_op(js, TOK_CALL, res, params);
-      pop_this();
-      if (res == (jsval_t)T_TAILCALL) return res;
-      if (is_super_call && !is_err(res) && is_object_type(res)) {
-        jsoff_t proto_off = lkp_interned(js, mkval(T_OBJ, vdata(js->current_func)), INTERN_PROTOTYPE, 9);
-        if (proto_off) set_proto(js, res, resolveprop(js, mkval(T_PROP, proto_off)));
-        js->this_val = res;
-        if (global_this_stack.depth > 0) global_this_stack.stack[global_this_stack.depth - 1] = res;
-      }
-      obj = js_mkundef();
-    }
-  }
-  return res;
-}
-
-static jsval_t js_postfix(struct js *js) {
-  jsval_t res = js_call_dot(js);
-  if (is_err(res)) return res;
-  next(js);
-  if ((js->tok == TOK_POSTINC || js->tok == TOK_POSTDEC) && !js->had_newline) {
-    js->consumed = 1;
-    res = do_op(js, js->tok, res, 0);
-  }
-  return res;
-}
-
-static inline jsval_t resolve_coderef(struct js *js, jsval_t v) {
-  if (vtype(v) == T_CODEREF) return lookup(js, &js->code[coderefoff(v)], codereflen(v));
-  return v;
-}
-
-static void unlink_prop(struct js *js, jsoff_t obj_off, jsoff_t prop_off, jsoff_t prev_off) {
-  jsoff_t deleted_next = loadoff(js, prop_off) & ~FLAGMASK;
-  jsoff_t target = prev_off ? prev_off : obj_off;
-  jsoff_t current = loadoff(js, target);
-  
-  saveoff(js, target, (deleted_next & ~3ULL) | (current & (FLAGMASK | 3ULL)));
-  jsoff_t tail = loadoff(js, obj_off + sizeof(jsoff_t) + sizeof(jsoff_t));
-  
-  if (tail == prop_off) {
-    saveoff(js, obj_off + sizeof(jsoff_t) + sizeof(jsoff_t), prev_off);
-  }
-  
-  invalidate_prop_cache(js, obj_off, prop_off);
-  js->needs_gc = true;
-}
-
-static jsval_t check_frozen_sealed(struct js *js, jsval_t obj, const char *action) {
-  if (js_truthy(js, get_slot(js, obj, SLOT_FROZEN))) {
-    if (js->flags & F_STRICT) return js_mkerr(js, "cannot %s property of frozen object", action);
-    return js_false;
-  }
-  if (js_truthy(js, get_slot(js, obj, SLOT_SEALED))) {
-    if (js->flags & F_STRICT) return js_mkerr(js, "cannot %s property of sealed object", action);
-    return js_false;
-  }
-  return js_mkundef();
-}
-
-__attribute__((noinline))
-static jsval_t js_unary_new(struct js *js) {
-  js->consumed = 1;
-  if (next(js) == TOK_DOT) {
-    js->consumed = 1;
-    if (next(js) != TOK_IDENTIFIER || !streq(&js->code[js->toff], js->tlen, "target", 6)) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected");
-    }
-    js->consumed = 1;
-    return mkntarg(NTARG_NEW_TARGET);
-  }
-
-  jsval_t obj = mkobj(js, 0);
-  jsval_t saved_this = js->this_val;
-  jsval_t saved_new_target = js->new_target;
-
-  jsval_t ctor = js_group(js);
-  if (is_err(ctor)) { return ctor; }
-
-  while (next(js) == TOK_DOT || next(js) == TOK_LBRACKET) {
-    ctor = resolve_coderef(js, ctor);
-    if (is_err(ctor)) { return ctor; }
-
-    if (js->tok == TOK_DOT) {
-      js->consumed = 1;
-      if (next(js) != TOK_IDENTIFIER && !is_keyword_propname(js->tok)) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected");
-      }
-      js->consumed = 1;
-      ctor = do_op(js, TOK_DOT, ctor, mkcoderef((jsoff_t)js->toff, (jsoff_t)js->tlen));
-    } else {
-      js->consumed = 1;
-      jsval_t idx = js_expr(js);
-      if (is_err(idx)) { return idx; }
-      if (next(js) != TOK_RBRACKET) { return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected"); }
-      js->consumed = 1;
-      ctor = do_op(js, TOK_BRACKET, ctor, idx);
-    }
-  }
-
-  ctor = resolve_coderef(js, ctor);
-  if (is_err(ctor)) { return ctor; }
-  if (vtype(ctor) == T_PROP || vtype(ctor) == T_PROPREF) ctor = resolveprop(js, ctor);
-  if (vtype(obj) == T_OBJ && (vtype(ctor) == T_FUNC || vtype(ctor) == T_CFUNC)) set_slot(js, obj, SLOT_CTOR, ctor);
-  js->pending_ntg = ctor;
-
-  jsval_t result;
-  push_this(obj);
-  if (next(js) == TOK_LPAREN) {
-    jsval_t params = js_call_params(js);
-    if (is_err(params)) { 
-      pop_this(); 
-      js->pending_ntg = js_mkundef();
-      js->new_target = saved_new_target; return params; 
-    }
-    result = do_op(js, TOK_CALL, ctor, params);
-  } else {
-    result = do_op(js, TOK_CALL, ctor, mkcoderef(0, 0));
-    js->consumed = 0;
-  }
-  
-  jsval_t constructed_obj = peek_this();
-  pop_this();
-  
-  js->this_val = saved_this;
-  js->new_target = saved_new_target;
-  
-  if (is_err(result)) return result;
-  
-  uint8_t rtype = vtype(result);
-  jsval_t new_result = (
-    rtype == T_OBJ || rtype == T_ARR ||
-    rtype == T_PROMISE || rtype == T_FUNC
-   ) ? result : constructed_obj;
-  
-  if (vtype(new_result) == T_OBJ && (vtype(ctor) == T_FUNC || vtype(ctor) == T_CFUNC)) {
-    set_slot(js, new_result, SLOT_CTOR, ctor);
-  }
-
-  jsval_t call_obj = js_mkundef();
-  while (next(js) == TOK_DOT || next(js) == TOK_LBRACKET || next(js) == TOK_OPTIONAL_CHAIN || next(js) == TOK_LPAREN) {
-    uint8_t op = js->tok;
-    if (op == TOK_DOT || op == TOK_OPTIONAL_CHAIN) {
-      js->consumed = 1;
-      call_obj = new_result;
-      if (op == TOK_OPTIONAL_CHAIN && (vtype(call_obj) == T_NULL || vtype(call_obj) == T_UNDEF)) {
-        new_result = call_obj = js_mkundef();
-      } else {
-        if (next(js) != TOK_IDENTIFIER && !is_keyword_propname(js->tok)) {
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected");
-        }
-        js->consumed = 1;
-        new_result = do_op(js, op, new_result, mkcoderef((jsoff_t)js->toff, (jsoff_t)js->tlen));
-      }
-    } else if (op == TOK_LBRACKET) {
-      js->consumed = 1;
-      call_obj = new_result;
-      jsval_t idx = js_expr(js);
-      if (is_err(idx)) return idx;
-      if (next(js) != TOK_RBRACKET) return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected");
-      js->consumed = 1;
-      new_result = do_op(js, TOK_BRACKET, new_result, idx);
-    } else {
-      jsval_t func_this = vtype(call_obj) == T_UNDEF ? js->this_val : call_obj;
-      push_this(func_this);
-      jsval_t params = js_call_params(js);
-      if (is_err(params)) { pop_this(); return params; }
-      new_result = do_op(js, TOK_CALL, new_result, params);
-      pop_this();
-      call_obj = js_mkundef();
-    }
-  }
-  return new_result;
-}
-
-__attribute__((noinline))
-static jsval_t js_unary_delete(struct js *js) {
-  js->consumed = 1;
-
-  if ((js->flags & F_STRICT) && next(js) == TOK_IDENTIFIER) {
-    jsoff_t id_pos = js->pos;
-    uint8_t id_tok = js->tok;
-    jsoff_t id_toff = js->toff, id_tlen = js->tlen;
-    int id_stream_pos = js->token_stream_pos;
-    js->consumed = 1;
-    uint8_t after = next(js);
-    if (after != TOK_DOT && after != TOK_LBRACKET && after != TOK_OPTIONAL_CHAIN) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot delete unqualified identifier in strict mode");
-    }
-    js->pos = id_pos; js->tok = id_tok; js->toff = id_toff; js->tlen = id_tlen; js->consumed = 0;
-    js->token_stream_pos = id_stream_pos;
-  }
-
-  js_parse_state_t saved_state;
-  JS_SAVE_STATE(js, saved_state);
-  uint8_t saved_flags = js->flags;
-  jsval_t operand = js_postfix(js);
-
-  if (is_err(operand)) {
-    JS_RESTORE_STATE(js, saved_state);
-    js->flags = (saved_flags & ~F_THROW) | F_NOEXEC;
-    js_postfix(js);
-    js->flags = saved_flags;
-    return js_true;
-  }
-  if (js->flags & F_NOEXEC) return js_true;
-
-  if (vtype(operand) == T_PROPREF) {
-    jsoff_t obj_off = propref_obj(operand);
-    jsoff_t key_off = propref_key(operand);
-    jsval_t obj = mkval(T_OBJ, obj_off);
-    jsval_t key = mkval(T_STR, key_off);
-    jsoff_t len;
-    const char *key_str = (const char *)&js->mem[vstr(js, key, &len)];
-
-    if (is_proxy(js, obj)) {
-      jsval_t result = proxy_delete(js, obj, key_str, len);
-      return is_err(result) ? result : js_bool(js_truthy(js, result));
-    }
-
-    jsval_t err = check_frozen_sealed(js, obj, "delete");
-    if (vtype(err) != T_UNDEF) return err;
-
-    if (is_arr_off(js, obj_off)) {
-      jsoff_t doff = get_dense_buf_off(js, obj_off);
-      unsigned long del_idx;
-      if (doff && parse_array_index(key_str, len, dense_length(js, doff), &del_idx)) {
-        arr_del(js, mkval(T_ARR, (uint64_t)obj_off), (jsoff_t)del_idx);
-        return js_true;
-      }
-    }
-
-    jsoff_t prop_off = lkp(js, obj, key_str, len);
-    if (prop_off == 0) {
-      try_dynamic_deleter(js, obj, key_str, len);
-      return js_true;
-    }
-
-    if (is_nonconfig_prop(js, prop_off)) {
-      if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
-      return js_false;
-    }
-
-    descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key_str, len);
-    if (desc && !desc->configurable) {
-      if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
-      return js_false;
-    }
-
-    jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
-    if (first_prop == prop_off) {
-      unlink_prop(js, obj_off, prop_off, 0);
-      return js_true;
-    }
-    for (jsoff_t prev = first_prop; prev != 0; ) {
-      jsoff_t next_prop = loadoff(js, prev) & ~(3U | FLAGMASK);
-      if (next_prop == prop_off) { 
-        unlink_prop(js, obj_off, prop_off, prev); 
-        return js_true; 
-      }
-      prev = next_prop;
-    }
-    return js_true;
-  }
-
-  if (vtype(operand) == T_PROP) {
-    jsoff_t prop_off = (jsoff_t)vdata(operand);
-    if (is_nonconfig_prop(js, prop_off)) {
-      if (js->flags & F_STRICT) return js_mkerr(js, "cannot delete non-configurable property");
-      return js_false;
-    }
-
-    for (jsval_t scope = js->scope; ; scope = upper(js, scope)) {
-      jsoff_t scope_off = (jsoff_t)vdata(scope);
-      jsoff_t first = loadoff(js, scope_off) & ~(3U | FLAGMASK);
-      if (first == prop_off) {
-        unlink_prop(js, scope_off, prop_off, 0);
-        return js_true;
-      }
-      for (jsoff_t cur = first; cur != 0 && cur < js->brk; ) {
-        jsoff_t nx = loadoff(js, cur) & ~(3U | FLAGMASK);
-        if (nx == prop_off) {
-          unlink_prop(js, scope_off, prop_off, cur);
-          return js_true;
-        } cur = nx;
-      } if (vdata(scope) == 0) break;
-    } return js_true;
-  } return js_true;
-}
-
-static jsval_t js_unary(struct js *js) {
-  uint8_t tok = next(js);
-
-  static const void *dispatch[] = {
-    [TOK_NEW]     = &&do_new,
-    [TOK_DELETE]  = &&do_delete,
-    [TOK_AWAIT]   = &&do_await,
-    [TOK_POSTINC] = &&do_prefix_inc,
-    [TOK_POSTDEC] = &&do_prefix_inc,
-    [TOK_NOT]     = &&do_unary_op,
-    [TOK_TILDA]   = &&do_unary_op,
-    [TOK_TYPEOF]  = &&do_typeof,
-    [TOK_VOID]    = &&do_unary_op,
-    [TOK_MINUS]   = &&do_unary_op,
-    [TOK_PLUS]    = &&do_unary_op,
-  };
-
-  if (tok < sizeof(dispatch)/sizeof(dispatch[0]) && dispatch[tok]) {
-    goto *dispatch[tok];
-  }
-  return js_postfix(js);
-
-  do_new: return js_unary_new(js);
-  do_delete: return js_unary_delete(js);
-
-  do_await: {
-    js->consumed = 1;
-    jsval_t expr = js_unary(js);
-    if (is_err(expr)) return expr;
-    if (js->flags & F_NOEXEC) return expr;
-
-    jsval_t resolved = resolveprop(js, expr);
-    if (vtype(resolved) != T_PROMISE) return resolved;
-
-    uint32_t pid = get_promise_id(js, resolved);
-    promise_data_entry_t *pd = get_promise_data(pid, false);
-    if (!pd) return js_mkerr(js, "invalid promise state");
-
-    if (pd->state == 1) return pd->value;
-    if (pd->state == 2) return js_throw(js, pd->value);
-
-    mco_coro *current_mco = mco_running();
-    if (!current_mco) return js_mkerr(js, "await can only be used inside async functions");
-
-    async_exec_context_t *ctx = (async_exec_context_t *)mco_get_user_data(current_mco);
-    if (!ctx || !ctx->coro) return js_mkerr(js, "invalid async context");
-
-    coroutine_t *coro = ctx->coro;
-    coro->awaited_promise = resolved;
-    coro->is_settled = coro->is_ready = false;
-
-    jsval_t resume_obj = mkobj(js, 0);
-    set_slot(js, resume_obj, SLOT_CFUNC, js_mkfun(resume_coroutine_wrapper));
-    set_slot(js, resume_obj, SLOT_CORO, tov((double)(uintptr_t)coro));
-
-    jsval_t reject_obj = mkobj(js, 0);
-    set_slot(js, reject_obj, SLOT_CFUNC, js_mkfun(reject_coroutine_wrapper));
-    set_slot(js, reject_obj, SLOT_CORO, tov((double)(uintptr_t)coro));
-
-    jsval_t then_args[] = { mkval(T_FUNC, vdata(resume_obj)), mkval(T_FUNC, vdata(reject_obj)) };
-    jsval_t saved_this = js->this_val;
-    js->this_val = resolved;
-    
-    builtin_promise_then(js, then_args, 2);
-    js->this_val = saved_this;
-
-    js_parse_state_t saved;
-    JS_SAVE_STATE(js, saved);
-    uint8_t saved_flags = js->flags;
-    jsval_t saved_current_func = js->current_func;
-    mco_result mco_res = mco_yield(current_mco);
-    
-    JS_RESTORE_STATE(js, saved);
-    js->flags = saved_flags;
-    js->current_func = saved_current_func;
-
-    if (mco_res != MCO_SUCCESS) return js_mkerr(js, "failed to yield coroutine");
-
-    jsval_t result = coro->result;
-    bool is_error = coro->is_error;
-    coro->is_settled = false;
-    coro->awaited_promise = js_mkundef();
-
-    return is_error ? js_throw(js, result) : result;
-  }
-
-  do_prefix_inc: {
-    uint8_t op = js->tok;
-    js->consumed = 1;
-    if ((js->flags & F_STRICT) && next(js) == TOK_IDENTIFIER && is_eval_or_arguments(js, js->toff, js->tlen)) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot modify eval or arguments in strict mode");
-    }
-    jsval_t operand = js_unary(js);
-    if (is_err(operand)) return operand;
-    if (js->flags & F_NOEXEC) return operand;
-    jsval_t resolved = resolveprop(js, operand);
-    if (vtype(operand) == T_PROP || vtype(operand) == T_PROPREF) {
-      jsval_t assign_res = do_assign_op(js, op == TOK_POSTINC ? TOK_PLUS_ASSIGN : TOK_MINUS_ASSIGN, operand, tov(1));
-      if (is_err(assign_res)) return assign_res;
-    } else return js_mkerr_typed(js, JS_ERR_SYNTAX, "Invalid left-hand side in assignment");
-    return do_op(js, op == TOK_POSTINC ? TOK_PLUS : TOK_MINUS, resolved, tov(1));
-  }
-  
-  do_typeof: {
-    js->consumed = 1;
-    jsoff_t saved_pos = js->pos;
-    uint8_t saved_tok = js->tok, saved_consumed = js->consumed, saved_flags = js->flags;
-    int saved_stream_pos = js->token_stream_pos;
-    bool bare = is_typeof_bare_ident(js);
-    jsval_t operand = js_unary(js);
-    if (is_err(operand)) {
-      if (!bare || get_error_type(js) != JS_ERR_REFERENCE) return operand;
-      js->pos = saved_pos; js->tok = saved_tok; js->consumed = saved_consumed;
-      js->token_stream_pos = saved_stream_pos;
-      js->flags = (saved_flags & ~F_THROW) | F_NOEXEC;
-      js_unary(js);
-      js->flags = saved_flags & ~F_THROW;
-      operand = js_mkundef();
-    }
-    return do_op(js, TOK_TYPEOF, js_mkundef(), operand);
-  }
-
-  do_unary_op: {
-    uint8_t t = js->tok;
-    if (t == TOK_MINUS) t = TOK_UMINUS;
-    if (t == TOK_PLUS) t = TOK_UPLUS;
-    js->consumed = 1;
-    jsval_t operand = js_unary(js);
-    if (is_err(operand)) return operand;
-    if (next(js) == TOK_EXP) {
-      return js_mkerr_typed(
-        js, JS_ERR_SYNTAX, 
-        "Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence"
-      );
-    }
-    return do_op(js, t, js_mkundef(), operand);
-  }
-}
-
-static jsval_t js_expr_bp(struct js *js, uint8_t min_bp) {
-  jsval_t lhs = js_unary(js);
-  if (is_err(lhs)) return lhs;
-
-  loop: {
-    uint8_t tok = next(js);
-    if (tok >= TOK_MAX) return lhs;
-    uint8_t bp = prec_table[tok];
-    if (bp == 0 || bp < min_bp) return lhs;
-
-    js->consumed = 1;
-
-    static const void *dispatch[] = {
-      [TOK_LOR]        = &&do_lor,
-      [TOK_LAND]       = &&do_land,
-      [TOK_NULLISH]    = &&do_nullish,
-      [TOK_EXP]        = &&do_exp,
-      [TOK_OR]         = &&do_binop,
-      [TOK_XOR]        = &&do_binop,
-      [TOK_AND]        = &&do_binop,
-      [TOK_EQ]         = &&do_binop,
-      [TOK_NE]         = &&do_binop,
-      [TOK_SEQ]        = &&do_binop,
-      [TOK_SNE]        = &&do_binop,
-      [TOK_LT]         = &&do_binop,
-      [TOK_LE]         = &&do_binop,
-      [TOK_GT]         = &&do_binop,
-      [TOK_GE]         = &&do_binop,
-      [TOK_INSTANCEOF] = &&do_binop,
-      [TOK_IN]         = &&do_binop,
-      [TOK_SHL]        = &&do_binop,
-      [TOK_SHR]        = &&do_binop,
-      [TOK_ZSHR]       = &&do_binop,
-      [TOK_PLUS]       = &&do_binop,
-      [TOK_MINUS]      = &&do_binop,
-      [TOK_MUL]        = &&do_binop,
-      [TOK_DIV]        = &&do_binop,
-      [TOK_REM]        = &&do_binop,
-    };
-
-    goto *dispatch[tok];
-
-    do_binop: {
-      jshdl_t lh = js_root(js, lhs);
-      jsval_t rhs = js_expr_bp(js, bp + 1);
-      lhs = js_deref(js, lh); js_unroot(js, lh);
-      if (is_err(rhs)) return rhs;
-      lhs = do_op(js, tok, lhs, rhs);
-      goto loop;
-    }
-
-    do_exp: {
-      jshdl_t lh = js_root(js, lhs);
-      jsval_t rhs = js_expr_bp(js, bp);
-      lhs = js_deref(js, lh); js_unroot(js, lh);
-      if (is_err(rhs)) return rhs;
-      lhs = do_op(js, TOK_EXP, lhs, rhs);
-      goto loop;
-    }
-
-    do_lor: {
-      uint8_t flags = js->flags;
-      lhs = resolveprop(js, lhs);
-      if (js_truthy(js, lhs)) js->flags |= F_NOEXEC;
-      jshdl_t lh = js_root(js, lhs);
-      jsval_t rhs = js_expr_bp(js, bp);
-      lhs = js_deref(js, lh); js_unroot(js, lh);
-      if (!(flags & F_NOEXEC) && !js_truthy(js, lhs)) lhs = rhs;
-      js->flags = flags;
-      if (is_err(rhs)) return rhs;
-      goto loop;
-    }
-
-    do_land: {
-      uint8_t flags = js->flags;
-      lhs = resolveprop(js, lhs);
-      if (!js_truthy(js, lhs)) js->flags |= F_NOEXEC;
-      jshdl_t lh = js_root(js, lhs);
-      jsval_t rhs = js_expr_bp(js, bp);
-      lhs = js_deref(js, lh); js_unroot(js, lh);
-      if (!(flags & F_NOEXEC) && js_truthy(js, lhs)) lhs = rhs;
-      js->flags = flags;
-      if (is_err(rhs)) return rhs;
-      goto loop;
-    }
-
-    do_nullish: {
-      uint8_t flags = js->flags;
-      lhs = resolveprop(js, lhs);
-      uint8_t lhs_type = vtype(lhs);
-      if (lhs_type != T_NULL && lhs_type != T_UNDEF) js->flags |= F_NOEXEC;
-      jshdl_t lh = js_root(js, lhs);
-      jsval_t rhs = js_expr_bp(js, bp);
-      lhs = js_deref(js, lh); js_unroot(js, lh);
-      if (!(flags & F_NOEXEC) && (lhs_type == T_NULL || lhs_type == T_UNDEF)) lhs = rhs;
-      js->flags = flags;
-      if (is_err(rhs)) return rhs;
-      goto loop;
-    }
-  }
-}
-
-static jsval_t js_ternary(struct js *js) {
-  jsval_t res = js_expr_bp(js, 1);
-  if (next(js) == TOK_Q) {
-    uint8_t flags = js->flags;
-    js->consumed = 1;
-    if (js_truthy(js, resolveprop(js, res))) {
-      res = js_assignment(js);
-      js->flags |= F_NOEXEC;
-      EXPECT(TOK_COLON, js->flags = flags);
-      js_assignment(js);
-      js->flags = flags;
-    } else {
-      js->flags |= F_NOEXEC;
-      js_assignment(js);
-      EXPECT(TOK_COLON, js->flags = flags);
-      js->flags = flags;
-      res = js_assignment(js);
-    }
-  }
-  return res;
-}
-
-static jsval_t js_assignment(struct js *js) {
-  jsval_t res = js_ternary(js);
-  bool lhs_is_new_target = is_new_target_ref(res);
-  
-  if (!is_err(res) && vtype(res) == T_CODEREF && next(js) == TOK_ARROW) {
-    jsoff_t param_start = coderefoff(res);
-    jsoff_t param_len = codereflen(res);
-    js->consumed = 1;
-    
-    char *param_buf = (char *)malloc(param_len + 3);
-    if (!param_buf) return js_mkerr(js, "oom");
-    param_buf[0] = '(';
-    memcpy(param_buf + 1, &js->code[param_start], param_len);
-    param_buf[param_len + 1] = ')';
-    param_buf[param_len + 2] = '\0';
-    
-    uint8_t flags = js->flags;
-    bool is_expr = next(js) != TOK_LBRACE;
-    jsoff_t body_start = js->pos;
-    if (is_expr && js->tok != TOK_EOF) {
-      body_start = js->toff;
-    }
-    jsval_t body_result;
-    
-    if (is_expr) {
-      js->flags |= F_NOEXEC;
-      body_result = js_assignment(js);
-      if (is_err(body_result)) {
-        js->flags = flags;
-        free(param_buf);
-        return body_result;
-      }
-    } else {
-      body_start = js->toff;
-      js->flags |= F_NOEXEC;
-      js->consumed = 1;
-      body_result = js_block(js, false);
-      if (is_err(body_result)) {
-        js->flags = flags;
-        free(param_buf);
-        return body_result;
-      }
-      if (js->tok == TOK_RBRACE && js->consumed) {
-      } else if (next(js) == TOK_RBRACE) {
-        js->consumed = 1;
-      }
-    }
-
-    js->flags = flags;
-    jsoff_t body_end;
-    if (is_expr) {
-      uint8_t tok = next(js);
-      body_end = is_body_end_tok(tok) ? js->toff : js->pos;
-    } else body_end = js->pos;
-
-    size_t params_len = param_len + 2;
-    size_t body_len = body_end - body_start;
-    size_t fn_len = params_len + body_len;
-    
-    char *fn_str = (char *) malloc(fn_len + 1);
-    if (!fn_str) { free(param_buf); return js_mkerr(js, "oom"); }
-    
-    memcpy(fn_str, param_buf, params_len);
-    memcpy(fn_str + params_len, &js->code[body_start], body_len);
-    free(param_buf);
-    
-    jsval_t func_obj = mkobj(js, 0);
-    if (is_err(func_obj)) { free(fn_str); return func_obj; }
-    
-    set_func_code(js, func_obj, fn_str, fn_len);
-    free(fn_str);
-    
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    if (vtype(func_proto) == T_FUNC) set_proto(js, func_obj, func_proto);
-    
-    if (!(flags & F_NOEXEC)) {
-      jsval_t closure_scope = for_let_capture_scope(js);
-      if (is_err(closure_scope)) return closure_scope;
-      set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-      set_slot(js, func_obj, SLOT_THIS, js->this_val);
-      capture_arrow_new_target(js, func_obj);
-    }
-    
-    set_slot(js, func_obj, SLOT_ARROW, js_true);
-    return mkval(T_FUNC, (unsigned long) vdata(func_obj));
-  }
-  
-  while (
-    !is_err(res) && (next(js) == TOK_ASSIGN || js->tok == TOK_PLUS_ASSIGN ||
-    js->tok == TOK_MINUS_ASSIGN || js->tok == TOK_MUL_ASSIGN ||
-    js->tok == TOK_DIV_ASSIGN || js->tok == TOK_REM_ASSIGN ||
-    js->tok == TOK_SHL_ASSIGN || js->tok == TOK_SHR_ASSIGN ||
-    js->tok == TOK_ZSHR_ASSIGN || js->tok == TOK_AND_ASSIGN ||
-    js->tok == TOK_XOR_ASSIGN || js->tok == TOK_OR_ASSIGN ||
-    js->tok == TOK_LOR_ASSIGN || js->tok == TOK_LAND_ASSIGN ||
-    js->tok == TOK_NULLISH_ASSIGN)
-  ) {
-    if (lhs_is_new_target) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "Invalid left-hand side in assignment");
-    }
-    uint8_t op = js->tok;
-    js->consumed = 1;
-    
-    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN || op == TOK_NULLISH_ASSIGN) {
-      jsval_t lhs_val = js_mkundef();
-      bool should_assign = true;
-      
-      if (!(js->flags & F_NOEXEC)) {
-        lhs_val = resolveprop(js, res);
-        if (is_err(lhs_val)) return lhs_val;
-        
-        if (op == TOK_LOR_ASSIGN) {
-          should_assign = !js_truthy(js, lhs_val);
-        } else if (op == TOK_LAND_ASSIGN) {
-          should_assign = js_truthy(js, lhs_val);
-        } else should_assign = is_null(lhs_val) || is_undefined(lhs_val);
-      }
-      
-      if (should_assign || (js->flags & F_NOEXEC)) {
-        jsval_t rhs = js_assignment(js);
-        if (is_err(rhs)) return rhs;
-        
-        if (!(js->flags & F_NOEXEC) && should_assign) {
-          jsval_t rhs_resolved = resolveprop(js, rhs);
-          if (is_err(rhs_resolved)) return rhs_resolved;
-          res = assign(js, res, rhs_resolved);
-        }
-      } else {
-        uint8_t saved_flags = js->flags;
-        js->flags |= F_NOEXEC;
-        jsval_t rhs = js_assignment(js);
-        js->flags = saved_flags;
-        if (is_err(rhs)) return rhs;
-        res = lhs_val;
-      }
-      continue;
-    }
-    
-    jsval_t lhs_val = js_mkundef();
-    if (op != TOK_ASSIGN && !(js->flags & F_NOEXEC)) {
-      lhs_val = resolveprop(js, res);
-      if (is_err(lhs_val)) return lhs_val;
-    }
-    
-    jsval_t rhs = js_assignment(js);
-    if (is_err(rhs)) return rhs;
-    
-    if (op == TOK_ASSIGN) {
-      res = do_op(js, op, res, rhs);
-    } else {
-      jsval_t rhs_resolved = resolveprop(js, rhs);
-      if (is_err(rhs_resolved)) return rhs_resolved;
-      
-      uint8_t m[] = {
-        TOK_PLUS, TOK_MINUS, TOK_MUL, TOK_DIV, TOK_REM, TOK_SHL,
-        TOK_SHR,  TOK_ZSHR,  TOK_AND, TOK_XOR, TOK_OR
-      };
-      uint8_t binary_op = m[op - TOK_PLUS_ASSIGN];
-      
-      jsval_t op_result = do_op(js, binary_op, lhs_val, rhs_resolved);
-      if (is_err(op_result)) return op_result;
-      res = assign(js, res, op_result);
-    }
-  }
-  
-  return res;
-}
-
-static jsval_t js_decl(struct js *js, bool is_const) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  js->consumed = 1;
-  for (;;) {
-    if (next(js) == TOK_LBRACE) {
-      js->consumed = 1;
-      
-      js_parse_state_t pattern_state;
-      JS_SAVE_STATE(js, pattern_state);
-      
-      int depth = 1;
-      while (depth > 0 && next(js) != TOK_EOF) {
-        if (js->tok == TOK_LBRACE) depth++;
-        else if (js->tok == TOK_RBRACE) depth--;
-        if (depth > 0) js->consumed = 1;
-      }
-      js->consumed = 1;
-      
-      if (next(js) != TOK_ASSIGN) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "destructuring requires assignment");
-      }
-      js->consumed = 1;
-      
-      jsval_t v = js_expr(js);
-      if (is_err(v)) return v;
-      
-      jsval_t obj = js_mkundef();
-      if (exe) {
-        obj = resolveprop(js, v);
-        uint8_t ot = vtype(obj);
-        if (ot == T_NULL || ot == T_UNDEF) return js_mkerr(js, "cannot destructure null or undefined");
-      }
-      
-      js_parse_state_t end_state;
-      JS_SAVE_STATE(js, end_state);
-      JS_RESTORE_STATE(js, pattern_state);
-      
-      jsval_t picked_keys = exe ? js_mkarr(js) : js_mkundef();
-      if (exe && is_err(picked_keys)) return picked_keys;
-      
-      while (next(js) != TOK_RBRACE && next(js) != TOK_EOF) {
-        bool is_rest = false;
-        if (next(js) == TOK_REST) {
-          is_rest = true;
-          js->consumed = 1;
-        }
-        
-        if (next(js) != TOK_IDENTIFIER) {
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected in object destructuring");
-        }
-        jsoff_t src_off = js->toff, src_len = js->tlen;
-        jsoff_t var_off = src_off, var_len = src_len;
-        js->consumed = 1;
-        
-        bool is_nested_obj = false;
-        bool is_nested_arr = false;
-        jsoff_t nested_pattern_start = 0;
-        
-        if (!is_rest && next(js) == TOK_COLON) {
-          js->consumed = 1;
-          if (next(js) == TOK_LBRACE) {
-            is_nested_obj = true;
-            nested_pattern_start = js->toff;
-            int inner_depth = 1;
-            js->consumed = 1;
-            while (inner_depth > 0 && next(js) != TOK_EOF) {
-              if (js->tok == TOK_LBRACE) inner_depth++;
-              else if (js->tok == TOK_RBRACE) inner_depth--;
-              if (inner_depth > 0) js->consumed = 1;
-            }
-            js->consumed = 1;
-          } else if (next(js) == TOK_LBRACKET) {
-            is_nested_arr = true;
-            nested_pattern_start = js->toff;
-            int inner_depth = 1;
-            js->consumed = 1;
-            while (inner_depth > 0 && next(js) != TOK_EOF) {
-              if (js->tok == TOK_LBRACKET) inner_depth++;
-              else if (js->tok == TOK_RBRACKET) inner_depth--;
-              if (inner_depth > 0) js->consumed = 1;
-            }
-            js->consumed = 1;
-          } else {
-            EXPECT_IDENT();
-            var_off = js->toff;
-            var_len = js->tlen;
-            js->consumed = 1;
-          }
-        }
-        
-        jsoff_t default_off = 0, default_len = 0;
-        if (!is_rest && !is_nested_obj && !is_nested_arr && next(js) == TOK_ASSIGN) {
-          js->consumed = 1;
-          default_off = js->pos;
-          uint8_t sf = js->flags;
-          js->flags |= F_NOEXEC;
-          jsval_t r = js_expr(js);
-          js->flags = sf;
-          if (is_err(r)) return r;
-          default_len = js->pos - default_off;
-        }
-        
-        if (!exe) goto obj_destruct_next;
-        
-        if (is_rest) goto obj_destruct_rest;
-        if (is_nested_obj || is_nested_arr) goto obj_destruct_nested;
-        goto obj_destruct_simple;
-        
-obj_destruct_rest:;
-        jsval_t rest_obj = mkobj(js, 0);
-        if (is_err(rest_obj)) return rest_obj;
-        uint8_t obj_type = vtype(obj);
-        if (obj_type == T_OBJ || obj_type == T_ARR) {
-          jsoff_t scan = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
-          while (scan < js->brk && scan != 0) {
-            jsoff_t header = loadoff(js, scan);
-            if (is_slot_prop(header)) { scan = next_prop(header); continue; }
-            
-            const char *key; jsoff_t klen;
-            get_prop_key(js, scan, &key, &klen);
-            bool is_picked = false;
-            jsoff_t picked_len = js_arr_len(js, picked_keys);
-            for (jsoff_t i = 0; i < picked_len; i++) {
-              jsval_t pk = js_arr_get(js, picked_keys, i);
-              if (vtype(pk) != T_STR) continue;
-              jsoff_t pklen, pkoff = vstr(js, pk, &pklen);
-              if (klen == pklen && memcmp(key, &js->mem[pkoff], klen) == 0) { is_picked = true; break; }
-            }
-            if (!is_picked && !(klen == STR_PROTO_LEN && memcmp(key, STR_PROTO, STR_PROTO_LEN) == 0)) {
-              jsval_t val = get_prop_val(js, scan);
-              jsval_t key_str = js_mkstr(js, key, klen);
-              if (is_err(key_str)) return key_str;
-              jsval_t res = js_setprop(js, rest_obj, key_str, val);
-              if (is_err(res)) return res;
-            }
-            scan = next_prop(header);
-          }
-        }
-        {
-          const char *vn = &js->code[var_off];
-          if (lkp_scope(js, js->scope, vn, var_len) > 0) return js_mkerr(js, "'%.*s' already declared", (int)var_len, vn);
-          jsval_t x = mkprop(js, js->scope, js_mkstr(js, vn, var_len), rest_obj, is_const ? CONSTMASK : 0);
-          if (is_err(x)) return x;
-        }
-        goto obj_destruct_next;
-        
-obj_destruct_nested:;
-        {
-          jsval_t sk = js_mkstr(js, &js->code[src_off], src_len);
-          if (is_err(sk)) return sk;
-          js_arr_push(js, picked_keys, sk);
-          
-          jsval_t nobj = getprop_any(js, obj, &js->code[src_off], src_len);
-          jsoff_t pattern_end = js->pos;
-          
-          js->pos = nested_pattern_start;
-          js->consumed = 1;
-          
-          jsval_t saved_obj = obj;
-          obj = nobj;
-          
-          if (!is_nested_obj) goto nested_done;
-          if (next(js) != TOK_LBRACE) return js_mkerr_typed(js, JS_ERR_SYNTAX, "expected '{' in nested destructuring");
-          js->consumed = 1;
-          
-          while (next(js) != TOK_RBRACE && next(js) != TOK_EOF) {
-            if (next(js) != TOK_IDENTIFIER) return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected in nested destructuring");
-            jsoff_t isoff = js->toff, islen = js->tlen;
-            jsoff_t ivoff = isoff, ivlen = islen;
-            js->consumed = 1;
-            
-            if (next(js) == TOK_COLON) {
-              js->consumed = 1;
-              EXPECT_IDENT();
-              ivoff = js->toff; ivlen = js->tlen;
-              js->consumed = 1;
-            }
-            
-            const char *ivn = &js->code[ivoff];
-            if (lkp_scope(js, js->scope, ivn, ivlen) > 0) return js_mkerr(js, "'%.*s' already declared", (int)ivlen, ivn);
-            
-            jsval_t ival = getprop_any(js, nobj, &js->code[isoff], islen);
-            jsval_t ix = mkprop(js, js->scope, js_mkstr(js, ivn, ivlen), ival, is_const ? CONSTMASK : 0);
-            if (is_err(ix)) return ix;
-            
-            if (next(js) == TOK_RBRACE) break;
-            EXPECT(TOK_COMMA);
-          }
-          js->consumed = 1;
-          
-nested_done:
-          obj = saved_obj;
-          js->pos = pattern_end;
-          js->consumed = 1;
-        }
-        goto obj_destruct_next;
-        
-obj_destruct_simple:;
-        {
-          const char *vn = &js->code[var_off];
-          if (lkp_scope(js, js->scope, vn, var_len) > 0) return js_mkerr(js, "'%.*s' already declared", (int)var_len, vn);
-          
-          jsval_t sk = js_mkstr(js, &js->code[src_off], src_len);
-          if (is_err(sk)) return sk;
-          js_arr_push(js, picked_keys, sk);
-          jsval_t pval = getprop_any(js, obj, &js->code[src_off], src_len);
-          
-          if (vtype(pval) == T_UNDEF && default_len > 0) {
-            pval = js_eval_slice(js, default_off, default_len);
-            if (is_err(pval)) return pval;
-            pval = resolveprop(js, pval);
-          }
-          
-          jsval_t x = mkprop(js, js->scope, js_mkstr(js, vn, var_len), pval, is_const ? CONSTMASK : 0);
-          if (is_err(x)) return x;
-        }
-        
-obj_destruct_next:
-        
-        if (next(js) == TOK_RBRACE) break;
-        EXPECT(TOK_COMMA);
-      }
-      
-      JS_RESTORE_STATE(js, end_state);
-    } else if (next(js) == TOK_LBRACKET) {
-      js->consumed = 1;
-      
-      js_parse_state_t pattern_state;
-      JS_SAVE_STATE(js, pattern_state);
-      
-      int depth = 1;
-      while (depth > 0 && next(js) != TOK_EOF) {
-        if (js->tok == TOK_LBRACKET) depth++;
-        else if (js->tok == TOK_RBRACKET) depth--;
-        if (depth > 0) js->consumed = 1;
-      }
-      js->consumed = 1;
-      
-      if (next(js) != TOK_ASSIGN) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "array destructuring requires assignment");
-      }
-      js->consumed = 1;
-      
-      jsval_t v = js_expr(js);
-      if (is_err(v)) return v;
-      
-      jsval_t arr = js_mkundef();
-      if (exe) {
-        arr = resolveprop(js, v);
-        if (vtype(arr) != T_ARR && vtype(arr) != T_STR) {
-          return js_mkerr(js, "cannot array destructure non-iterable");
-        }
-      }
-      
-      js_parse_state_t end_state;
-      JS_SAVE_STATE(js, end_state);
-      JS_RESTORE_STATE(js, pattern_state);
-      
-      int index = 0;
-      while (next(js) != TOK_RBRACKET && next(js) != TOK_EOF) {
-        if (next(js) == TOK_COMMA) {
-          js->consumed = 1;
-          index++;
-          continue;
-        }
-        
-        bool is_rest = false;
-        if (next(js) == TOK_REST) {
-          is_rest = true;
-          js->consumed = 1;
-        }
-        
-        if (next(js) != TOK_IDENTIFIER) {
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "identifier expected in array destructuring");
-        }
-        jsoff_t var_off = js->toff, var_len = js->tlen;
-        js->consumed = 1;
-        
-        jsoff_t default_off = 0, default_len = 0;
-        if (!is_rest && next(js) == TOK_ASSIGN) {
-          js->consumed = 1;
-          default_off = js->pos;
-          uint8_t sf = js->flags;
-          js->flags |= F_NOEXEC;
-          jsval_t r = js_expr(js);
-          js->flags = sf;
-          if (is_err(r)) return r;
-          default_len = js->pos - default_off;
-        }
-        
-        if (exe) {
-          const char *var_name = &js->code[var_off];
-          if (lkp_scope(js, js->scope, var_name, var_len) > 0) {
-            return js_mkerr(js, "'%.*s' already declared", (int)var_len, var_name);
-          }
-          
-          jsval_t prop_val;
-          if (is_rest) {
-            jsval_t rest_arr = js_mkarr(js);
-            if (is_err(rest_arr)) return rest_arr;
-            jsoff_t total_len = vtype(arr) == T_STR ? 0 : js_arr_len(js, arr);
-            if (vtype(arr) == T_STR) {
-              jsoff_t slen;
-              vstr(js, arr, &slen);
-              total_len = slen;
-            }
-            for (jsoff_t i = index; i < total_len; i++) {
-              jsval_t elem;
-              if (vtype(arr) == T_STR) {
-                jsoff_t slen, soff = vstr(js, arr, &slen);
-                elem = js_mkstr(js, (char *)&js->mem[soff + i], 1);
-              } else {
-                elem = js_arr_get(js, arr, i);
-              }
-              js_arr_push(js, rest_arr, elem);
-            }
-            prop_val = rest_arr;
-          } else {
-            if (vtype(arr) == T_STR) {
-              jsoff_t slen, soff = vstr(js, arr, &slen);
-              if ((jsoff_t)index < slen) {
-                prop_val = js_mkstr(js, (char *)&js->mem[soff + index], 1);
-              } else {
-                prop_val = js_mkundef();
-              }
-            } else {
-              prop_val = js_arr_get(js, arr, index);
-            }
-            
-            if (vtype(prop_val) == T_UNDEF && default_len > 0) {
-              prop_val = js_eval_slice(js, default_off, default_len);
-              if (is_err(prop_val)) return prop_val;
-              prop_val = resolveprop(js, prop_val);
-            }
-          }
-          
-          jsval_t x = mkprop(js, js->scope, js_mkstr(js, var_name, var_len), prop_val, is_const ? CONSTMASK : 0);
-          if (is_err(x)) return x;
-        }
-        
-        index++;
-        if (next(js) == TOK_RBRACKET) break;
-        EXPECT(TOK_COMMA);
-      }
-      
-      JS_RESTORE_STATE(js, end_state);
-    } else {
-      EXPECT_IDENT();
-      js->consumed = 0;
-      jsoff_t noff = js->toff, nlen = js->tlen;
-      char *name = (char *) &js->code[noff];
-      
-      if ((js->flags & F_STRICT) && is_strict_restricted(name, nlen)) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot use '%.*s' as variable name in strict mode", (int) nlen, name);
-      }
-      
-      if ((js->flags & F_STRICT) && is_strict_reserved(name, nlen)) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "'%.*s' is reserved in strict mode", (int) nlen, name);
-      }
-      
-      jsval_t v = js_mkundef();
-      js->consumed = 1;
-      if (next(js) == TOK_ASSIGN) {
-        js->consumed = 1;
-        v = js_expr(js);
-        if (is_err(v)) return v;
-      } else if (is_const) return js_mkerr_typed(js, JS_ERR_SYNTAX, "Missing initializer in const declaration");
-      if (exe) {
-        char decoded_name[256];
-        size_t decoded_len = decode_ident_escapes(name, nlen, decoded_name, sizeof(decoded_name));
-        
-        jsval_t resolved = resolveprop(js, v);
-        if (vtype(resolved) == T_FUNC) infer_func_name(js, resolved, decoded_name, decoded_len);
-        
-        if (lkp_scope(js, js->scope, decoded_name, decoded_len) > 0) return js_mkerr(js, "'%.*s' already declared", (int) decoded_len, decoded_name);
-        jsval_t x = mkprop(js, js->scope, js_mkstr(js, decoded_name, decoded_len), resolved, is_const ? CONSTMASK : 0);
-        
-        if (is_err(x)) return x;
-      }
-    }
-    
-    uint8_t decl_next = next(js);
-    bool asi = js->had_newline || decl_next == TOK_EOF || decl_next == TOK_RBRACE;
-    if (decl_next == TOK_SEMICOLON || asi) break;
-    EXPECT(TOK_COMMA);
-  }
-  return js_mkundef();
-}
-
-static jsval_t js_expr(struct js *js) {
-  return js_assignment(js);
-}
-
-static jsval_t js_expr_comma(struct js *js) {
-  jsval_t res = js_assignment(js);
-  if (is_err(res)) return res;
-  while (next(js) == TOK_COMMA) {
-    js->consumed = 1;
-    res = js_assignment(js);
-    if (is_err(res)) return res;
-  }
-  return res;
-}
-
-static jsval_t js_eval_slice(struct js *js, jsoff_t off, jsoff_t len) {
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  
-  js->code = saved.code + off;
-  js->clen = len;
-  js->pos = 0;
-  js->consumed = 1;
-  
-  jsval_t result = js_expr(js);
-  
-  JS_RESTORE_STATE(js, saved);
-  return result;
-}
-
-static jsval_t js_eval_str(struct js *js, const char *code, jsoff_t len) {
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  
-  js->code = code;
-  js->clen = len;
-  js->pos = 0;
-  js->consumed = 1;
-  
-  jsval_t result = js_expr(js);
-  
-  JS_RESTORE_STATE(js, saved);
-  return result;
-}
-
-static jsval_t js_let(struct js *js) {
-  return js_decl(js, false);
-}
-
-static jsval_t js_const(struct js *js) {
-  return js_decl(js, true);
-}
-
-static jsval_t js_func_decl(struct js *js) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  uint8_t saved_flags = js->flags;
-  js->consumed = 1;
-  EXPECT_IDENT();
-  js->consumed = 0;
-  jsoff_t noff = js->toff, nlen = js->tlen;
-  char *name = (char *) &js->code[noff];
-  js->consumed = 1;
-  EXPECT(TOK_LPAREN);
-  jsoff_t pos = js->pos - 1;
-  int param_count = 0;
-  if (!parse_func_params(js, &saved_flags, &param_count)) {
-    js->flags = saved_flags;
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid parameters");
-  }
-  EXPECT(TOK_RPAREN);
-  EXPECT(TOK_LBRACE);
-  js->consumed = 0;
-  uint8_t flags = js->flags;
-  js->flags |= F_NOEXEC;
-  jsval_t res = js_block(js, false);
-  if (is_err(res)) {
-    js->flags = flags;
-    return res;
-  }
-  js->flags = flags;
-   jsval_t func_obj = mkobj(js, 0);
-   if (is_err(func_obj)) return func_obj;
-   set_func_code(js, func_obj, &js->code[pos], js->pos - pos);
-   
-   jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-   if (vtype(func_proto) == T_FUNC) set_proto(js, func_obj, func_proto);
-   
-   jsval_t res_len = js_setprop(js, func_obj, js->length_str, tov(param_count));
-   if (is_err(res_len)) return res_len;
-   js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
-   jsval_t name_key = js_mkstr(js, "name", 4);
-   if (is_err(name_key)) return name_key;
-   jsval_t name_val = js_mkstr(js, name, nlen);
-   if (is_err(name_val)) return name_val;
-   set_slot(js, func_obj, SLOT_NAME, name_val);
-   jsval_t res3 = js_setprop(js, func_obj, name_key, name_val);
-   if (is_err(res3)) return res3;
-   if (exe) {
-     jsval_t closure_scope = for_let_capture_scope(js);
-     if (is_err(closure_scope)) return closure_scope;
-     set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-     if (flags & F_STRICT) {
-       set_slot(js, func_obj, SLOT_STRICT, js_true);
-     }
-   }
-   
-   jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-   jsval_t proto_setup = setup_func_prototype(js, func);
-   if (is_err(proto_setup)) return proto_setup;
-  
-   if (exe) {
-     jsoff_t existing = lkp_scope(js, js->scope, name, nlen);
-     if (existing > 0) {
-       saveval(js, existing + sizeof(jsoff_t) * 2, func);
-     } else {
-       jsval_t x = mkprop(js, js->scope, js_mkstr(js, name, nlen), func, 0);
-       if (is_err(x)) return x;
-     }
-   }
-  
-  return js_mkundef();
-}
-
-static jsval_t js_func_decl_async(struct js *js) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  js->consumed = 1;
-  EXPECT_IDENT();
-  js->consumed = 0;
-  jsoff_t noff = js->toff, nlen = js->tlen;
-  char *name = (char *) &js->code[noff];
-  js->consumed = 1;
-  EXPECT(TOK_LPAREN);
-  jsoff_t pos = js->pos - 1;
-  if (!parse_func_params(js, NULL, NULL)) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid parameters");
-  }
-  EXPECT(TOK_RPAREN);
-  EXPECT(TOK_LBRACE);
-  js->consumed = 0;
-  uint8_t flags = js->flags;
-  js->flags |= F_NOEXEC;
-  jsval_t res = js_block(js, false);
-  if (is_err(res)) {
-    js->flags = flags;
-    return res;
-  }
-  js->flags = flags;
-  jsval_t func_obj = mkobj(js, 0);
-  if (is_err(func_obj)) return func_obj;
-   set_func_code(js, func_obj, &js->code[pos], js->pos - pos);
-   set_slot(js, func_obj, SLOT_ASYNC, js_true);
-   jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-   if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
-   jsval_t res_len = js_setprop(js, func_obj, js->length_str, tov(0));
-   if (is_err(res_len)) return res_len;
-   js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
-   jsval_t name_key = js_mkstr(js, "name", 4);
-   if (is_err(name_key)) return name_key;
-   jsval_t name_val = js_mkstr(js, name, nlen);
-   if (is_err(name_val)) return name_val;
-   set_slot(js, func_obj, SLOT_NAME, name_val);
-   jsval_t res3 = js_setprop(js, func_obj, name_key, name_val);
-   if (is_err(res3)) return res3;
-  if (exe) {
-    jsval_t closure_scope = for_let_capture_scope(js);
-    if (is_err(closure_scope)) return closure_scope;
-    set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
-    if (flags & F_STRICT) set_slot(js, func_obj, SLOT_STRICT, js_true);
-  }
-  jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-  
-  jsval_t proto_setup = setup_func_prototype(js, func);
-  if (is_err(proto_setup)) return proto_setup;
-  
-  if (exe) {
-    jsoff_t existing = lkp_scope(js, js->scope, name, nlen);
-    if (existing > 0) {
-      saveval(js, existing + sizeof(jsoff_t) * 2, func);
-    } else {
-      jsval_t x = mkprop(js, js->scope, js_mkstr(js, name, nlen), func, 0);
-      if (is_err(x)) return x;
-    }
-  }
-  
-  return js_mkundef();
-}
-
-static jsval_t js_block_or_stmt_pos(struct js *js, jsoff_t *end_pos) {
-  if (next(js) == TOK_LBRACE) {
-    jsval_t res = js_block(js, !(js->flags & F_NOEXEC));
-    if (end_pos) *end_pos = js->pos;
-    return res;
-  }
-  uint8_t stmt_tok = js->tok;
-  jsval_t res = js_stmt(js);
-  if (res != (jsval_t)T_TAILCALL) res = resolveprop(js, res);
-  bool is_block_stmt = (
-    stmt_tok == TOK_FUNC || stmt_tok == TOK_CLASS || 
-    stmt_tok == TOK_IF || stmt_tok == TOK_WHILE || 
-    stmt_tok == TOK_DO || stmt_tok == TOK_FOR || 
-    stmt_tok == TOK_SWITCH || stmt_tok == TOK_TRY ||
-    stmt_tok == TOK_LBRACE || stmt_tok == TOK_ASYNC
-  );
-  if (end_pos) {
-    *end_pos = (!is_block_stmt && !js->consumed) ? js->toff : js->pos;
-  }
-  if (!is_block_stmt) js->consumed = 0;
-  return res;
-}
-
-static inline jsval_t js_block_or_stmt(struct js *js) {
-  return js_block_or_stmt_pos(js, NULL);
-}
-
-typedef struct {
-  bool is_block;
-  bool needs_scope;
-  bool has_func_decl;
-  bool has_func_decl_checked;
-  jshdl_t loop_scope_handle;
-} loop_block_ctx_t;
-
-static void loop_block_init(struct js *js, loop_block_ctx_t *ctx) {
-  ctx->is_block = (lookahead(js) == TOK_LBRACE);
-  ctx->needs_scope = false;
-  ctx->has_func_decl = false;
-  ctx->has_func_decl_checked = false;
-  ctx->loop_scope_handle = -1;
-  
-  if (ctx->is_block && !(js->flags & F_NOEXEC)) {
-    jsoff_t saved_pos = js->pos;
-    uint8_t saved_tok = js->tok;
-    uint8_t saved_consumed = js->consumed;
-    int saved_stream_pos = js->token_stream_pos;
-    
-    js->consumed = 1;
-    next(js);
-    ctx->needs_scope = block_needs_scope(js);
-    
-    js->pos = saved_pos;
-    js->tok = saved_tok;
-    js->consumed = saved_consumed;
-    js->token_stream_pos = saved_stream_pos;
-    
-    if (ctx->needs_scope) ctx->loop_scope_handle = js_root(js, js_mkscope(js));
-  }
-}
-
-static inline jsval_t loop_block_exec(struct js *js, loop_block_ctx_t *ctx) {
-  if (ctx->is_block) {
-    next(js);
-    
-    if (!ctx->has_func_decl_checked) {
-      ctx->has_func_decl = code_has_function_decl(
-        js->code + js->pos, 
-        js->clen - js->pos
-      );
-      ctx->has_func_decl_checked = true;
-    }
-    
-    bool saved_skip = js->skip_func_hoist;
-    if (!ctx->has_func_decl) js->skip_func_hoist = true;
-    
-    jsval_t result = js_block(js, false);
-    js->skip_func_hoist = saved_skip;
-    
-    return result;
-  }
-  
-  return js_block_or_stmt(js);
-}
-
-static inline void loop_block_sync_scope(struct js *js, loop_block_ctx_t *ctx) {
-  struct for_let_ctx *flc = for_let_current(js);
-  if (flc && vtype(flc->body_scope) == T_OBJ) js_root_update(js, ctx->loop_scope_handle, flc->body_scope);
-}
-
-#define loop_block_clear(js, ctx) \
-  if ((ctx)->needs_scope) scope_clear_props(js, js_deref(js, (ctx)->loop_scope_handle))
-  
-#define loop_block_cleanup(js, ctx) \
-  do { if ((ctx)->needs_scope) { js_unroot(js, (ctx)->loop_scope_handle); delscope(js); } } while(0)
-
-static jsval_t js_if(struct js *js) {
-  js->consumed = 1;
-  EXPECT(TOK_LPAREN);
-  
-  jsval_t res = js_mkundef(), cond_expr = js_expr(js);
-  if (is_err(cond_expr)) return cond_expr;
-  jsval_t cond = resolveprop(js, cond_expr);
-  if (is_err(cond)) return cond;
-  
-  EXPECT(TOK_RPAREN);
-  
-  bool cond_true = js_truthy(js, cond), exe = !(js->flags & F_NOEXEC);
-  if (!cond_true) js->flags |= F_NOEXEC;
-  jsval_t blk = js_block_or_stmt(js);
-  if (cond_true) res = blk;
-  if (exe && !cond_true) js->flags &= (uint8_t) ~F_NOEXEC;
-  
-  if ((!js->consumed && js->tok == TOK_ELSE) || lookahead(js) == TOK_ELSE) {
-    if (js->tok != TOK_ELSE) { js->consumed = 1; next(js); }
-    js->consumed = 1;
-    if (cond_true) js->flags |= F_NOEXEC;
-    blk = js_block_or_stmt(js);
-    if (!cond_true) res = blk;
-    if (cond_true && exe) js->flags &= (uint8_t) ~F_NOEXEC;
-  }
-  
-  return res;
-}
-
-static inline bool expect(struct js *js, uint8_t tok, jsval_t *res) {
-  if (next(js) != tok) {
-    *res = js_mkerr_typed(js, JS_ERR_SYNTAX, "parse error");
-    return false;
-  } else { js->consumed = 1; return true; }
-}
-
-static inline bool is_err2(jsval_t *v, jsval_t *res) {
-  bool r = is_err(*v);
-  if (r) { *res = *v; } return r;
-}
-
-typedef struct {
-  jsoff_t body_start;
-  jsoff_t body_end;
-  jsoff_t var_name_off;
-  jsoff_t var_name_len;
-  bool is_const_var;
-  uint8_t flags;
-  bool has_destructure;
-  jsoff_t destructure_off;
-  jsoff_t destructure_len;
-  int marker_index;
-  loop_block_ctx_t loop_ctx;
-} for_iter_ctx_t;
-
-static jsval_t for_iter_bind_var(struct js *js, for_iter_ctx_t *ctx, jsval_t value) {
-  loop_block_clear(js, &ctx->loop_ctx);
-  if (ctx->has_destructure) {
-    return bind_destruct_pattern(js, &js->code[ctx->destructure_off], ctx->destructure_len, value, js->scope);
-  }
-  const char *var_name = &js->code[ctx->var_name_off];
-  jsoff_t existing = lkp_scope(js, js->scope, var_name, ctx->var_name_len);
-  if (existing > 0) {
-    saveval(js, existing + sizeof(jsoff_t) * 2, value);
-    return js_mkundef();
-  }
-  return mkprop(js, js->scope, js_mkstr(js, var_name, ctx->var_name_len), value, ctx->is_const_var ? CONSTMASK : 0);
-}
-
-static jsval_t for_iter_exec_body(struct js *js, for_iter_ctx_t *ctx) {
-  js->pos = ctx->body_start;
-  js->consumed = 1;
-  js->flags = (ctx->flags & ~F_NOEXEC) | F_LOOP;
-  return loop_block_exec(js, &ctx->loop_ctx);
-}
-
-static inline bool for_iter_handle_continue(struct js *js, for_iter_ctx_t *ctx) {
-  if (!(label_flags & F_CONTINUE_LABEL)) return false;
-  if (is_this_loop_continue_target(ctx->marker_index)) {
-    clear_continue_label();
-    js->flags &= ~(F_BREAK | F_NOEXEC);
-    return false;
-  }
-  js->flags |= F_BREAK;
-  return true;
-}
-
-static int for_iter_step(struct js *js, for_iter_ctx_t *ctx, jsval_t key_str, jsval_t *out) {
-  jsval_t err = for_iter_bind_var(js, ctx, key_str);
-  if (is_err(err)) { *out = err; return 2; }
-  
-  jsval_t v = for_iter_exec_body(js, ctx);
-  if (is_err(v)) { *out = v; return 2; }
-  if (for_iter_handle_continue(js, ctx)) return 1;
-  if (js->flags & F_BREAK) return 1;
-  if (js->flags & F_RETURN) { *out = v; return 2; }
-  
-  return 0;
-}
-
-static jsval_t for_iter_string_indices(struct js *js, for_iter_ctx_t *ctx, jsval_t str) {
-  jsoff_t slen = vstrlen(js, str);
-  for (jsoff_t i = 0; i < slen; i++) {
-    char idx[16];
-    snprintf(idx, sizeof(idx), "%u", (unsigned)i);
-    jsval_t key_str = js_mkstr(js, idx, strlen(idx));
-    
-    jsval_t out;
-    int rc = for_iter_step(js, ctx, key_str, &out);
-    if (rc) return (rc == 2) ? out : js_mkundef();
-  }
-  return js_mkundef();
-}
-
-static jsval_t for_in_iter_object(struct js *js, for_iter_ctx_t *ctx, jsval_t obj) {
-  uint8_t obj_type = vtype(obj);
-  if (obj_type == T_NULL || obj_type == T_UNDEF) return js_mkundef();
-  if (obj_type == T_STR) return for_iter_string_indices(js, ctx, obj);
-  
-  if (obj_type != T_OBJ && obj_type != T_ARR && obj_type != T_FUNC)
-    return js_mkerr(js, "for-in requires object");
-  
-  jsval_t iter_obj = (obj_type == T_FUNC) ? mkval(T_OBJ, vdata(obj)) : obj;
-  jsval_t prim = get_slot(js, iter_obj, SLOT_PRIMITIVE);
-  if (vtype(prim) == T_STR) return for_iter_string_indices(js, ctx, prim);
-  
-  jshdl_t h_obj = js_root(js, iter_obj);
-  const char *tag_sym_key = get_toStringTag_sym_key();
-  
-  size_t tag_sym_len = tag_sym_key ? strlen(tag_sym_key) : 0;
-  char key_buf[256];
-  
-  if (obj_type == T_ARR) {
-    jsval_t cur_obj = js_deref(js, h_obj);
-    jsoff_t doff = get_dense_buf(js, cur_obj);
-    if (doff) {
-      jsoff_t dense_len = dense_length(js, doff);
-      for (jsoff_t i = 0; i < dense_len; i++) {
-        jsval_t v = dense_get(js, doff, i);
-        if (is_empty_slot(v)) continue;
-        size_t klen = uint_to_str(key_buf, sizeof(key_buf), (unsigned)i);
-        jsval_t out;
-        int rc = for_iter_step(js, ctx, js_mkstr(js, key_buf, (jsoff_t)klen), &out);
-        if (rc) { js_unroot(js, h_obj); return (rc == 2) ? out : js_mkundef(); }
-      }
-    }
-  }
-  
-  jsoff_t prop_idx = 0;
-  
-  for (;;) {
-    jsval_t cur_obj = js_deref(js, h_obj);
-    jsoff_t cur_obj_off = (jsoff_t)vdata(cur_obj);
-    jsoff_t prop_off = loadoff(js, cur_obj_off) & ~(3U | FLAGMASK);
-    
-    jsoff_t cur_idx = 0;
-    while (prop_off < js->brk && prop_off != 0 && cur_idx < prop_idx) {
-      jsoff_t header = loadoff(js, prop_off);
-      prop_off = next_prop(header); cur_idx++;
-    }
-    
-    if (prop_off >= js->brk || prop_off == 0) break;
-    jsoff_t header = loadoff(js, prop_off);
-    if (is_slot_prop(header)) { prop_idx++; continue; }
-    
-    jsoff_t koff = loadoff(js, prop_off + (jsoff_t)sizeof(prop_off));
-    jsoff_t klen = offtolen(loadoff(js, koff));
-    const char *key = (char *)&js->mem[koff + sizeof(koff)];
-    
-    bool skip = streq(key, klen, STR_PROTO, STR_PROTO_LEN);
-    if (!skip && tag_sym_key) skip = streq(key, klen, tag_sym_key, tag_sym_len);
-    if (!skip && obj_type == T_ARR && is_array_index(key, klen)) {
-      jsval_t cur = js_deref(js, h_obj);
-      jsoff_t d = get_dense_buf(js, cur);
-      if (d) {
-        unsigned long pidx = 0;
-        for (jsoff_t ci = 0; ci < klen; ci++) pidx = pidx * 10 + (key[ci] - '0');
-        if (pidx < dense_length(js, d)) skip = true;
-      }
-    }
-    
-    if (!skip) {
-      descriptor_entry_t *desc = lookup_descriptor(js, cur_obj_off, key, klen);
-      if (desc && !desc->enumerable) skip = true;
-    }
-    
-    if (!skip) {
-      size_t copy_len = klen < sizeof(key_buf) - 1 ? klen : sizeof(key_buf) - 1;
-      memcpy(key_buf, key, copy_len);
-      key_buf[copy_len] = '\0';
-      
-      jsval_t out;
-      int rc = for_iter_step(js, ctx, js_mkstr(js, key_buf, (jsoff_t)copy_len), &out);
-      if (rc) { js_unroot(js, h_obj); return (rc == 2) ? out : js_mkundef(); }
-    }
-    
-    prop_idx++;
-  }
-  
-  js_unroot(js, h_obj);
-  return js_mkundef();
-}
-
-static jsval_t for_of_iter_array(struct js *js, for_iter_ctx_t *ctx, jsval_t iterable) {
-  jshdl_t h_iterable = js_root(js, iterable);
-  
-  jsoff_t length = 0; {
-    jsval_t arr = js_deref(js, h_iterable);
-    length = get_array_length(js, arr);
-  }
-  
-  for (jsoff_t i = 0; i < length; i++) {
-    jsval_t arr = js_deref(js, h_iterable);
-    jsval_t val = arr_get(js, arr, i);
-    
-    jsval_t err = for_iter_bind_var(js, ctx, val);
-    if (is_err(err)) { js_unroot(js, h_iterable); return err; }
-    
-    jsval_t v = for_iter_exec_body(js, ctx);
-    if (is_err(v)) { js_unroot(js, h_iterable); return v; }
-    if (for_iter_handle_continue(js, ctx)) break;
-    if (js->flags & F_BREAK) break;
-    if (js->flags & F_RETURN) { js_unroot(js, h_iterable); return v; }
-  }
-  
-  js_unroot(js, h_iterable);
-  return js_mkundef();
-}
-
-static void init_ascii_cache(struct js *js) {
-  if (js->ascii_cache_init) return;
-  for (int i = 0; i < 128; i++) {
-    char c = (char)i;
-    js->ascii_char_cache[i] = js_mkstr(js, &c, 1);
-  }
-  js->ascii_cache_init = true;
-}
-
-static jsval_t for_of_iter_string(struct js *js, for_iter_ctx_t *ctx, jsval_t iterable) {
-  jshdl_t h_iterable = js_root(js, iterable);
-  size_t byte_pos = 0;
-  
-  if (!js->ascii_cache_init) init_ascii_cache(js);
-  
-  for (;;) {
-    jsval_t cur = js_deref(js, h_iterable);
-    jsoff_t cur_byte_len;
-    jsoff_t cur_soff = vstr(js, cur, &cur_byte_len);
-    
-    if (byte_pos >= cur_byte_len) break;
-    
-    const char *cur_str = (char *) &js->mem[cur_soff];
-    unsigned char c = (unsigned char)cur_str[byte_pos];
-    size_t char_bytes;
-    jsval_t char_str;
-    
-    if (c < 0x80) {
-      char_bytes = 1;
-      char_str = js->ascii_char_cache[c];
-    } else {
-      int seq_len = utf8_sequence_length(c);
-      char_bytes = (size_t)(seq_len > 0 ? seq_len : 1);
-      if (byte_pos + char_bytes > cur_byte_len) char_bytes = cur_byte_len - byte_pos;
-      char_str = js_mkstr(js, cur_str + byte_pos, char_bytes);
-    }
-    byte_pos += char_bytes;
-    
-    jsval_t err = for_iter_bind_var(js, ctx, char_str);
-    if (is_err(err)) { js_unroot(js, h_iterable); return err; }
-    
-    jsval_t v = for_iter_exec_body(js, ctx);
-    if (is_err(v)) { js_unroot(js, h_iterable); return v; }
-    if (for_iter_handle_continue(js, ctx)) break;
-    if (js->flags & F_BREAK) break;
-    if (js->flags & F_RETURN) { js_unroot(js, h_iterable); return v; }
-  }
-  
-  js_unroot(js, h_iterable);
-  return js_mkundef();
-}
-
-static jsval_t iter_call_noargs_with_this(struct js *js, jsval_t this_val, jsval_t method) {
-  js_parse_state_t saved_state;
-  JS_SAVE_STATE(js, saved_state);
-  uint8_t saved_flags = js->flags;
-  jsval_t saved_this = js->this_val;
-  push_this(this_val); js->this_val = this_val;
-  jsval_t result = call_js_with_args(js, method, NULL, 0);
-  pop_this();  js->this_val = saved_this;
-  JS_RESTORE_STATE(js, saved_state);
-  js->flags = saved_flags;
-  return result;
-}
-
-static jsval_t iter_close_iterator(struct js *js, jsval_t iterator) {
-  jsoff_t return_off = lkp_proto(js, iterator, "return", 6);
-  if (return_off == 0) return js_mkundef();
-  jsval_t return_method = loadval(js, return_off + sizeof(jsoff_t) * 2);
-  if (vtype(return_method) != T_FUNC && vtype(return_method) != T_CFUNC) {
-    return js_mkerr(js, "iterator.return is not a function");
-  }
-  return iter_call_noargs_with_this(js, iterator, return_method);
-}
-
-static jsval_t iter_foreach(struct js *js, jsval_t iterable, iter_callback_t cb, void *ctx) {
-  const char *iter_key = get_iterator_sym_key();
-  jsoff_t iter_prop = iter_key ? lkp_proto(js, iterable, iter_key, strlen(iter_key)) : 0;
-  if (iter_prop == 0) return js_mkerr(js, "not iterable");
-
-  jsval_t iter_method = loadval(js, iter_prop + sizeof(jsoff_t) * 2);
-  jsval_t iterator = iter_call_noargs_with_this(js, iterable, iter_method);
-  if (is_err(iterator)) return iterator;
-  
-  jshdl_t h_iterator = js_root(js, iterator);
-  jsval_t out = js_mkundef();
-  
-  while (true) {
-    jsval_t cur_iter = js_deref(js, h_iterator);
-    jsoff_t next_off = lkp_proto(js, cur_iter, "next", 4);
-    if (next_off == 0) { js_unroot(js, h_iterator); return js_mkerr(js, "iterator.next is not a function"); }
-    
-    jsval_t next_method = loadval(js, next_off + sizeof(jsoff_t) * 2);
-    if (vtype(next_method) != T_FUNC && vtype(next_method) != T_CFUNC) {
-      js_unroot(js, h_iterator);
-      return js_mkerr(js, "iterator.next is not a function");
-    }
-    
-    cur_iter = js_deref(js, h_iterator);
-    jsval_t result = iter_call_noargs_with_this(js, cur_iter, next_method);
-    if (is_err(result)) { js_unroot(js, h_iterator); return result; }
-    
-    jsoff_t done_off = lkp(js, result, "done", 4);
-    jsval_t done_val = done_off ? loadval(js, done_off + sizeof(jsoff_t) * 2) : js_mkundef();
-    if (js_truthy(js, done_val)) break;
-    
-    jsoff_t value_off = lkp(js, result, "value", 5);
-    jsval_t value = value_off ? loadval(js, value_off + sizeof(jsoff_t) * 2) : js_mkundef();
-    
-    iter_action_t action = cb(js, value, ctx, &out);
-    if (action == ITER_BREAK) {
-      jsval_t close_result = iter_close_iterator(js, cur_iter);
-      if (is_err(close_result)) { js_unroot(js, h_iterator); return close_result; }
-      break;
-    }
-    if (action == ITER_ERROR) {
-      jsval_t close_result = iter_close_iterator(js, cur_iter);
-      js_unroot(js, h_iterator);
-      if (is_err(close_result)) return close_result;
-      return out;
-    }
-  }
-  
-  js_unroot(js, h_iterator);
-  return out;
-}
-
-static iter_action_t for_of_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
-  for_iter_ctx_t *fctx = (for_iter_ctx_t *)ctx;
-  
-  jsval_t err = for_iter_bind_var(js, fctx, value);
-  if (is_err(err)) { *out = err; return ITER_ERROR; }
-  
-  jsval_t v = for_iter_exec_body(js, fctx);
-  if (is_err(v)) { *out = v; return ITER_ERROR; }
-  if (for_iter_handle_continue(js, fctx)) return ITER_BREAK;
-  if (js->flags & F_BREAK) return ITER_BREAK;
-  if (js->flags & F_RETURN) { *out = v; return ITER_BREAK; }
-  
-  return ITER_CONTINUE;
-}
-
-static jsval_t for_of_iter_object(struct js *js, for_iter_ctx_t *ctx, jsval_t iterable) {
-  jsval_t result = iter_foreach(js, iterable, for_of_iter_cb, ctx);
-  if (is_err(result) && strcmp(js->errmsg, "not iterable") == 0) {
-    return js_mkerr(js, "for-of requires iterable");
-  }
-  return result;
-}
-
-static jsval_t js_for(struct js *js) {
-  uint8_t flags = js->flags, exe = !(flags & F_NOEXEC);
-  jsval_t v, res = js_mkundef();
-  jsoff_t pos1 = 0, pos2 = 0, pos3 = 0, pos4 = 0;
-  
-  bool use_label_stack = label_stack && utarray_len(label_stack) > 0;
-  int marker_index = 0;
-  if (use_label_stack) {
-    label_entry_t marker = { .name = NULL, .name_len = 0, .is_loop = true, .is_block = false };
-    utarray_push_back(label_stack, &marker);
-    marker_index = utarray_len(label_stack) - 1;
-  }
-  
-  if (exe) mkscope(js);
-  if (!expect(js, TOK_FOR, &res)) goto done;
-  if (!expect(js, TOK_LPAREN, &res)) goto done;
-  
-  bool is_for_in = false;
-  bool is_for_of = false;
-  
-  bool is_var_decl = false;
-  bool is_const_var = false;
-  bool is_let_loop = false;
-  
-  jsoff_t var_name_off = 0;
-  jsoff_t var_name_len = 0;
-  jsoff_t let_var_off = 0;
-  jsoff_t let_var_len = 0;
-  
-  bool has_destructure = false;
-  jsoff_t destructure_off = 0;
-  jsoff_t destructure_len = 0;
-  
-  if (next(js) == TOK_LET || next(js) == TOK_CONST || next(js) == TOK_VAR) {
-    if (js->tok == TOK_VAR) {
-      is_var_decl = true;
-      if ((js->flags & F_STRICT) && !js->var_warning_shown) {
-        fprintf(stderr, "Warning: 'var' is deprecated, use 'let' or 'const' instead\n");
-        js->var_warning_shown = true;
-      }
-    } else if (js->tok == TOK_LET) {
-      is_let_loop = true;
-    }
-    is_const_var = (js->tok == TOK_CONST);
-    js->consumed = 1;
-    
-    if (next(js) == TOK_LBRACKET || next(js) == TOK_LBRACE) {
-      has_destructure = true;
-      destructure_off = js->toff;
-      uint8_t open_tok = js->tok;
-      uint8_t close_tok = (open_tok == TOK_LBRACKET) ? TOK_RBRACKET : TOK_RBRACE;
-      int depth = 1;
-      js->consumed = 1;
-      while (depth > 0 && next(js) != TOK_EOF) {
-        if (js->tok == open_tok) depth++;
-        else if (js->tok == close_tok) depth--;
-        js->consumed = 1;
-      }
-      destructure_len = js->pos - destructure_off;
-      if (next(js) == TOK_IN) {
-        is_for_in = true;
-        js->consumed = 1;
-      } else if (next(js) == TOK_OF) {
-        is_for_of = true;
-        js->consumed = 1;
-      } else if (next(js) == TOK_ASSIGN) {
-        js->pos = destructure_off;
-        js->consumed = 1;
-        if (is_const_var) v = js_const(js);
-        else if (is_var_decl) v = js_var_decl(js);
-        else v = js_let(js);
-        if (is_err2(&v, &res)) goto done;
-        has_destructure = false;
-      } else {
-        res = js_mkerr_typed(js, JS_ERR_SYNTAX, "expected 'in', 'of', or '=' after destructuring pattern");
-        goto done;
-      }
-    } else if (next(js) == TOK_IDENTIFIER) {
-      var_name_off = js->toff;
-      var_name_len = js->tlen;
-      if (is_let_loop) {
-        let_var_off = var_name_off;
-        let_var_len = var_name_len;
-      }
-      js->consumed = 1;
-      if (next(js) == TOK_IN) {
-        is_for_in = true;
-        js->consumed = 1;
-      } else if (next(js) == TOK_OF) {
-        is_for_of = true;
-        js->consumed = 1;
-      } else {
-        js->pos = var_name_off;
-        js->consumed = 1;
-        if (is_const_var) v = js_const(js);
-        else if (is_var_decl) v = js_var_decl(js);
-        else v = js_let(js);
-        if (is_err2(&v, &res)) goto done;
-      }
-    }
-  } else if (next(js) == TOK_IDENTIFIER) {
-    var_name_off = js->toff;
-    var_name_len = js->tlen;
-    js->consumed = 1;
-    if (next(js) == TOK_IN) {
-      is_for_in = true;
-      js->consumed = 1;
-    } else if (next(js) == TOK_OF) {
-      is_for_of = true;
-      js->consumed = 1;
-    } else {
-      js->pos = var_name_off;
-      js->consumed = 1;
-      v = js_expr_comma(js);
-      if (is_err2(&v, &res)) goto done;
-    }
-  } else if (next(js) == TOK_SEMICOLON) {
-  } else {
-    v = js_expr_comma(js);
-    if (is_err2(&v, &res)) goto done;
-  }
-  
-  if (is_for_in) {
-    jsval_t obj_expr = js_expr(js);
-    if (is_err2(&obj_expr, &res)) goto done;
-    if (!expect(js, TOK_RPAREN, &res)) goto done;
-    
-    jsoff_t body_start = js->pos;
-    jsoff_t body_end_pos = 0;
-    uint8_t body_end_token = TOK_ERR;
-    uint8_t body_end_consumed = 1;
-    jsoff_t body_end_toff = 0, body_end_tlen = 0;
-    
-    int body_end_stream_pos = 0;
-    loop_block_ctx_t forin_loop_ctx = {0};
-    
-    if (exe) loop_block_init(js, &forin_loop_ctx);
-    js->flags |= F_NOEXEC;
-    v = js_block_or_stmt(js);
-    if (is_err2(&v, &res)) goto done;
-    
-    body_end_pos = js->pos;
-    body_end_token = js->tok;
-    body_end_consumed = js->consumed;
-    body_end_toff = js->toff;
-    body_end_tlen = js->tlen;
-    body_end_stream_pos = js->token_stream_pos;
-    
-    if (exe) {
-      jsval_t obj = resolveprop(js, obj_expr);
-      for_iter_ctx_t ctx = { 
-        body_start, body_end_pos,
-        var_name_off, var_name_len,
-        is_const_var, flags,
-        has_destructure, destructure_off,
-        destructure_len, marker_index,
-        forin_loop_ctx
-      };
-      res = for_in_iter_object(js, &ctx, obj);
-      loop_block_cleanup(js, &forin_loop_ctx);
-      if (is_err(res)) goto done;
-      if (js->flags & F_RETURN) goto done;
-    }
-    
-    js->pos = body_end_pos;
-    js->tok = body_end_token;
-    js->consumed = body_end_consumed;
-    js->toff = body_end_toff;
-    js->tlen = body_end_tlen;
-    js->token_stream_pos = body_end_stream_pos;
-    
-    goto done;
-  }
-  
-  if (is_for_of) {
-    jsval_t iter_expr = js_expr(js);
-    if (is_err2(&iter_expr, &res)) goto done;
-    if (!expect(js, TOK_RPAREN, &res)) goto done;
-    
-    jsoff_t body_start = js->pos;
-    jsoff_t body_end_pos = 0;
-    uint8_t body_end_token = TOK_ERR;
-    uint8_t body_end_consumed = 1;
-    jsoff_t body_end_toff = 0, body_end_tlen = 0;
-    
-    int body_end_stream_pos = 0;
-    loop_block_ctx_t forof_loop_ctx = {0};
-    
-    if (exe) loop_block_init(js, &forof_loop_ctx);
-    js->flags |= F_NOEXEC;
-    v = js_block_or_stmt(js);
-    if (is_err2(&v, &res)) goto done;
-    
-    body_end_pos = js->pos;
-    body_end_token = js->tok;
-    body_end_consumed = js->consumed;
-    body_end_toff = js->toff;
-    body_end_tlen = js->tlen;
-    body_end_stream_pos = js->token_stream_pos;
-    
-    if (exe) {
-      jsval_t iterable = resolveprop(js, iter_expr);
-      uint8_t itype = vtype(iterable);
-      for_iter_ctx_t ctx = { 
-        body_start, body_end_pos,
-        var_name_off, var_name_len,
-        is_const_var, flags,
-        has_destructure, destructure_off,
-        destructure_len, marker_index,
-        forof_loop_ctx
-      };
-      
-      if (itype == T_ARR) res = for_of_iter_array(js, &ctx, iterable);
-      else if (itype == T_STR) res = for_of_iter_string(js, &ctx, iterable);
-      else if (itype == T_OBJ) res = for_of_iter_object(js, &ctx, iterable);
-      else res = js_mkerr(js, "for-of requires iterable");
-      
-      loop_block_cleanup(js, &forof_loop_ctx);
-      if (is_err(res)) goto done;
-      if (js->flags & F_RETURN) goto done;
-    }
-    
-    js->pos = body_end_pos;
-    js->tok = body_end_token;
-    js->consumed = body_end_consumed;
-    js->toff = body_end_toff;
-    js->tlen = body_end_tlen;
-    js->token_stream_pos = body_end_stream_pos;
-    
-    goto done;
-  }
-  
-  if (!expect(js, TOK_SEMICOLON, &res)) goto done;
-  js->flags |= F_NOEXEC;
-  pos1 = js->pos;
-  if (next(js) != TOK_SEMICOLON) {
-    v = js_expr(js);
-    if (is_err2(&v, &res)) goto done;
-  }
-  if (!expect(js, TOK_SEMICOLON, &res)) goto done;
-  pos2 = js->pos;
-  if (next(js) != TOK_RPAREN) {
-    v = js_expr_comma(js);
-    if (is_err2(&v, &res)) goto done;
-  }
-  if (!expect(js, TOK_RPAREN, &res)) goto done;
-  pos3 = js->pos;
-  
-  jsoff_t iter_var_prop_off = 0;
-  if (is_let_loop && let_var_len > 0 && exe) {
-    js->flags = flags;
-    mkscope(js);
-    jsval_t let_var_key = js_mkstr(js, &js->code[let_var_off], let_var_len);
-    jsoff_t outer_off = lkp_scope(js, upper(js, js->scope), &js->code[let_var_off], let_var_len);
-    jsval_t init_val = outer_off ? resolveprop(js, mkval(T_PROP, outer_off)) : js_mkundef();
-    mkprop(js, js->scope, let_var_key, init_val, 0);
-    iter_var_prop_off = lkp(js, js->scope, &js->code[let_var_off], let_var_len);
-    const char *var_interned = intern_string(&js->code[let_var_off], let_var_len);
-    for_let_push(js, var_interned, let_var_len, iter_var_prop_off, js_mkundef());
-  }
-  
-  loop_block_ctx_t loop_ctx = {0};
-  if (exe) {
-    loop_block_init(js, &loop_ctx);
-    if (is_let_loop && let_var_len > 0 && loop_ctx.needs_scope) for_let_set_body_scope(js, js_deref(js, loop_ctx.loop_scope_handle));
-  }
-  
-  js->flags |= F_NOEXEC;
-  v = js_block_or_stmt_pos(js, &pos4);
-  if (exe) js->flags = flags;
-  if (is_err2(&v, &res)) goto done;
-  
-  while (!(flags & F_NOEXEC)) {
-    js_gc_safepoint(js);
-    js->flags = flags, js->pos = pos1, js->consumed = 1;
-    if (next(js) != TOK_SEMICOLON) {
-      v = resolveprop(js, js_expr(js));
-      if (is_err2(&v, &res)) goto done;
-      if (!js_truthy(js, v)) break;
-    }
-    
-    js->flags |= F_LOOP;
-    js->pos = pos3;
-    js->consumed = 1;
-    
-    if (is_let_loop && let_var_len > 0 && loop_ctx.needs_scope) {
-      loop_block_sync_scope(js, &loop_ctx);
-    }
-    
-    loop_block_clear(js, &loop_ctx);
-    v = loop_block_exec(js, &loop_ctx);
-    if (is_err2(&v, &res)) {
-      loop_block_cleanup(js, &loop_ctx);
-      if (is_let_loop && let_var_len > 0) {
-        for_let_pop(js); delscope(js);
-      }
-      goto done;
-    }
-    
-    if (label_flags & F_CONTINUE_LABEL) {
-      if (is_this_loop_continue_target(marker_index)) {
-        clear_continue_label();
-        js->flags &= ~(F_BREAK | F_NOEXEC);
-        js->flags = flags;
-        js->pos = pos2, js->consumed = 1;
-        if (next(js) != TOK_RPAREN) {
-          v = js_expr_comma(js);
-          if (is_err2(&v, &res)) goto done;
-        } continue;
-      }
-    }
-    
-    if (js->flags & F_BREAK) break;
-    if (js->flags & F_RETURN) { res = v; break; }
-    
-    js->flags = flags, js->pos = pos2, js->consumed = 1;
-    if (next(js) != TOK_RPAREN) {
-      v = js_expr_comma(js);
-      if (is_err2(&v, &res)) goto done;
-    }
-  }
-  if (exe) loop_block_cleanup(js, &loop_ctx);
-  if (is_let_loop && let_var_len > 0 && exe) {
-    for_let_pop(js); delscope(js);
-  }
-  js->pos = pos4, js->tok = TOK_SEMICOLON, js->consumed = 0;
-done:
-  if (use_label_stack && label_stack && utarray_len(label_stack) > 0) {
-    utarray_pop_back(label_stack);
-  }
-  
-  if (exe) delscope(js);
-  uint8_t preserve = 0;
-  if (js->flags & F_RETURN) {
-    preserve = js->flags & (F_RETURN | F_NOEXEC);
-  }
-  if ((js->flags & F_BREAK) && (label_flags & F_BREAK_LABEL)) {
-    preserve |= (js->flags & (F_BREAK | F_NOEXEC));
-  }
-  if (label_flags & F_CONTINUE_LABEL) {
-    preserve |= F_BREAK | F_NOEXEC;
-  }
-  js->flags = flags | preserve;
-  return res;
-}
-
-static jsval_t js_while(struct js *js) {
-  uint8_t flags = js->flags, exe = !(flags & F_NOEXEC);
-  jsval_t res = js_mkundef(), v;
-  loop_block_ctx_t loop_ctx = {0};
-  
-  bool use_label_stack = label_stack && utarray_len(label_stack) > 0;
-  int marker_index = 0;
-  if (use_label_stack) {
-    label_entry_t marker = { .name = NULL, .name_len = 0, .is_loop = true, .is_block = false };
-    utarray_push_back(label_stack, &marker);
-    marker_index = utarray_len(label_stack) - 1;
-  }
-  
-  js->consumed = 1;
-  if (!expect(js, TOK_LPAREN, &res)) goto done;
-  
-  jsoff_t cond_start = js->pos;
-  js->flags |= F_NOEXEC;
-  v = js_expr(js);
-  if (is_err(v)) { res = v; goto done; }
-  
-  if (!expect(js, TOK_RPAREN, &res)) goto done;
-  
-  jsoff_t body_start = js->pos;
-  if (exe) {
-    js->flags = flags;
-    loop_block_init(js, &loop_ctx);
-    js->flags |= F_NOEXEC;
-  }
-  
-  jsoff_t body_end;
-  v = js_block_or_stmt_pos(js, &body_end);
-  if (is_err(v)) { res = v; goto done; }
-  
-  if (exe) {
-    while (true) {
-      js_gc_safepoint(js);
-      js->flags = flags;
-      js->pos = cond_start;
-      js->consumed = 1;
-      
-      v = resolveprop(js, js_expr(js));
-      if (is_err(v)) { res = v; break; }
-      
-      if (!js_truthy(js, v)) break;
-      
-      js->pos = body_start;
-      js->consumed = 1;
-      js->flags = (flags & ~F_NOEXEC) | F_LOOP;
-      
-      loop_block_clear(js, &loop_ctx);
-      v = loop_block_exec(js, &loop_ctx);
-      if (is_err(v)) { res = v; break; }
-      
-      if (label_flags & F_CONTINUE_LABEL) {
-        if (is_this_loop_continue_target(marker_index)) {
-          clear_continue_label();
-          js->flags &= ~(F_BREAK | F_NOEXEC);
-          continue;
-        }
-      }
-      
-      if (js->flags & F_BREAK) break;
-      if (js->flags & F_RETURN) { res = v; break; }
-    }
-    loop_block_cleanup(js, &loop_ctx);
-  }
-  
-  js->pos = body_end;
-  js->tok = TOK_SEMICOLON;
-  js->consumed = 0;
-  
-done:
-  if (use_label_stack && label_stack && utarray_len(label_stack) > 0) {
-    utarray_pop_back(label_stack);
-  }
-  
-  uint8_t preserve = 0;
-  if (js->flags & F_RETURN) {
-    preserve = js->flags & (F_RETURN | F_NOEXEC);
-  }
-  if ((js->flags & F_BREAK) && (label_flags & F_BREAK_LABEL)) {
-    preserve |= (js->flags & (F_BREAK | F_NOEXEC));
-  }
-  if (label_flags & F_CONTINUE_LABEL) {
-    preserve |= F_BREAK | F_NOEXEC;
-  }
-  js->flags = flags | preserve;
-  
-  return res;
-}
-
-static jsval_t js_do_while(struct js *js) {
-  uint8_t flags = js->flags, exe = !(flags & F_NOEXEC);
-  jsval_t res = js_mkundef(), v;
-  loop_block_ctx_t loop_ctx = {0};
-  
-  bool use_label_stack = label_stack && utarray_len(label_stack) > 0;
-  int marker_index = 0;
-  if (use_label_stack) {
-    label_entry_t marker = { .name = NULL, .name_len = 0, .is_loop = true, .is_block = false };
-    utarray_push_back(label_stack, &marker);
-    marker_index = utarray_len(label_stack) - 1;
-  }
-  
-  js->consumed = 1;
-  
-  jsoff_t body_start = js->pos;
-  bool is_block = (next(js) == TOK_LBRACE);
-  if (exe) loop_block_init(js, &loop_ctx);
-  
-  js->flags |= F_NOEXEC;
-  v = js_block_or_stmt(js);
-  if (is_err(v)) { res = v; goto done; }
-  
-  if (is_block && next(js) == TOK_RBRACE) {
-    js->consumed = 1;
-  }
-  (void) js->pos;
-  
-  if (!expect(js, TOK_WHILE, &res)) goto done;
-  if (!expect(js, TOK_LPAREN, &res)) goto done;
-  
-  jsoff_t cond_start = js->pos;
-  v = js_expr(js);
-  if (is_err(v)) { res = v; goto done; }
-  
-  if (!expect(js, TOK_RPAREN, &res)) goto done;
-  jsoff_t cond_end = js->pos;
-  
-  if (exe) {
-    do {
-      js_gc_safepoint(js);
-      js->pos = body_start;
-      js->consumed = 1;
-      js->flags = (flags & ~F_NOEXEC) | F_LOOP;
-      
-      loop_block_clear(js, &loop_ctx);
-      v = loop_block_exec(js, &loop_ctx);
-      if (is_err(v)) {
-        res = v; break;
-      }
-      
-      if (label_flags & F_CONTINUE_LABEL) {
-        if (is_this_loop_continue_target(marker_index)) {
-          clear_continue_label();
-          js->flags &= ~(F_BREAK | F_NOEXEC);
-        } else { break; }
-      }
-      
-      if (js->flags & F_BREAK) {
-        break;
-      }
-      
-      if (js->flags & F_RETURN) {
-        res = v;
-        break;
-      }
-      
-      js->flags = flags;
-      js->pos = cond_start;
-      js->consumed = 1;
-      
-      v = resolveprop(js, js_expr(js));
-      if (is_err(v)) {
-        res = v;
-        break;
-      }
-    } while (js_truthy(js, v));
-    loop_block_cleanup(js, &loop_ctx);
-  }
-  
-  js->pos = cond_end;
-  js->consumed = 1;
-  
-done:
-  if (use_label_stack && label_stack && utarray_len(label_stack) > 0) {
-    utarray_pop_back(label_stack);
-  }
-  
-  uint8_t preserve = 0;
-  if (js->flags & F_RETURN) {
-    preserve = js->flags & (F_RETURN | F_NOEXEC);
-  }
-  if ((js->flags & F_BREAK) && (label_flags & F_BREAK_LABEL)) {
-    preserve |= (js->flags & (F_BREAK | F_NOEXEC));
-  }
-  if (label_flags & F_CONTINUE_LABEL) {
-    preserve |= F_BREAK | F_NOEXEC;
-  }
-  js->flags = flags | preserve;
-  
-  return res;
-}
-
-static jsval_t js_try(struct js *js) {
-  uint8_t flags = js->flags, exe = !(flags & F_NOEXEC);
-  jsval_t res = js_mkundef();
-  jsval_t try_result = js_mkundef();
-  jsval_t catch_result = js_mkundef();
-  jsval_t finally_result = js_mkundef();
-  
-  bool had_exception = false;
-  char saved_errmsg[256] = {0};
-  jsval_t exception_value = js_mkundef();
-  
-  js->consumed = 1;
-  
-  if (next(js) != TOK_LBRACE) {
-    return js_mkerr(js, "{ expected after try");
-  }
-  
-  jsoff_t try_start = js->pos;
-  js->flags |= F_NOEXEC;
-  js->consumed = 1;
-  
-  while (next(js) != TOK_EOF && next(js) != TOK_RBRACE) {
-    jsval_t v = js_stmt(js);
-    if (is_err(v)) break;
-  }
-  if (next(js) == TOK_RBRACE) js->consumed = 1;
-  jsoff_t try_end = js->pos;
-  
-  bool has_catch = false;
-  bool has_finally = false;
-  jsoff_t catch_start = 0, catch_end = 0;
-  jsoff_t finally_start = 0, finally_end = 0;
-  jsoff_t catch_param_off = 0, catch_param_len = 0;
-  
-  if (lookahead(js) == TOK_CATCH) {
-    has_catch = true;
-    js->consumed = 1;
-    next(js);
-    js->consumed = 1;
-    
-    if (next(js) == TOK_LPAREN) {
-      js->consumed = 1;
-      if (next(js) == TOK_IDENTIFIER) {
-        catch_param_off = js->toff;
-        catch_param_len = js->tlen;
-        if ((js->flags & F_STRICT) && is_strict_restricted(&js->code[catch_param_off], catch_param_len)) {
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot use '%.*s' as catch parameter in strict mode", (int) catch_param_len, &js->code[catch_param_off]);
-        }
-        js->consumed = 1;
-      }
-      if (next(js) != TOK_RPAREN) return js_mkerr(js, ") expected in catch");
-      js->consumed = 1;
-    }
-    
-    if (next(js) != TOK_LBRACE) {
-      return js_mkerr(js, "{ expected after catch");
-    }
-    
-    catch_start = js->pos;
-    js->consumed = 1;
-    
-    while (next(js) != TOK_EOF && next(js) != TOK_RBRACE) {
-      jsval_t v = js_stmt(js);
-      if (is_err(v)) break;
-    }
-    if (next(js) == TOK_RBRACE) js->consumed = 1;
-    catch_end = js->pos;
-  }
-  
-  if (lookahead(js) == TOK_FINALLY) {
-    has_finally = true;
-    js->consumed = 1;
-    next(js);
-    js->consumed = 1;
-    
-    if (next(js) != TOK_LBRACE) {
-      return js_mkerr(js, "{ expected after finally");
-    }
-    
-    finally_start = js->pos;
-    js->consumed = 1;
-    
-    while (next(js) != TOK_EOF && next(js) != TOK_RBRACE) {
-      jsval_t v = js_stmt(js);
-      if (is_err(v)) break;
-    }
-    if (next(js) == TOK_RBRACE) js->consumed = 1;
-    finally_end = js->pos;
-  }
-  
-  if (!has_catch && !has_finally) {
-    return js_mkerr(js, "try requires catch or finally");
-  }
-  
-  jsoff_t end_pos = has_finally ? finally_end : (has_catch ? catch_end : try_end);
-  
-  if (exe) {
-    bool try_returned = false;
-    jsval_t try_return_value = js_mkundef();
-    
-    js->flags = flags & (uint8_t)~F_NOEXEC;
-    js->pos = try_start;
-    js->consumed = 1;
-    
-    mkscope(js);
-    while (next(js) != TOK_EOF && next(js) != TOK_RBRACE && !(js->flags & (F_RETURN | F_THROW | F_BREAK))) {
-      try_result = js_stmt(js);
-      if (is_err(try_result)) { had_exception = true; break; }
-    } delscope(js);
-    
-    if (js->flags & F_RETURN) {
-      try_returned = true;
-      try_return_value = try_result;
-      js->flags &= (uint8_t)~(F_RETURN | F_NOEXEC);
-    }
-    
-    if (js->flags & F_THROW) {
-      had_exception = true;
-      js->flags &= (uint8_t)~F_THROW;
-      strncpy(saved_errmsg, js->errmsg, sizeof(saved_errmsg) - 1);
-      saved_errmsg[sizeof(saved_errmsg) - 1] = '\0';
-      
-      exception_value = js->thrown_value;
-      js->thrown_value = js_mkundef();
-      js->errmsg[0] = '\0';
-    }
-    
-    if (next(js) == TOK_RBRACE) js->consumed = 1;
-    
-    bool exception_handled = false;
-    bool catch_returned = false;
-    jsval_t catch_return_value = js_mkundef();
-    
-    if (had_exception && has_catch) {
-      exception_handled = true;
-      mkscope(js);
-      
-      if (catch_param_len > 0) {
-        jsval_t key = js_mkstr(js, &js->code[catch_param_off], catch_param_len);
-        mkprop(js, js->scope, key, exception_value, 0);
-      }
-      
-      js->flags = flags & (uint8_t)~F_NOEXEC;
-      js->pos = catch_start;
-      js->consumed = 1;
-      
-      while (next(js) != TOK_EOF && next(js) != TOK_RBRACE && !(js->flags & (F_RETURN | F_THROW | F_BREAK))) {
-        catch_result = js_stmt(js);
-        if (is_err(catch_result)) break;
-      }
-      
-      if (js->flags & F_RETURN) {
-        catch_returned = true;
-        catch_return_value = catch_result;
-        js->flags &= (uint8_t)~(F_RETURN | F_NOEXEC);
-      }
-      
-      if (next(js) == TOK_RBRACE) js->consumed = 1;
-      delscope(js);
-      
-      if (js->flags & F_THROW) {
-        exception_handled = false;
-        strncpy(saved_errmsg, js->errmsg, sizeof(saved_errmsg) - 1);
-        saved_errmsg[sizeof(saved_errmsg) - 1] = '\0';
-        exception_value = js->thrown_value;
-        js->thrown_value = js_mkundef();
-        js->flags &= (uint8_t)~F_THROW;
-        js->errmsg[0] = '\0';
-      } else {
-        res = catch_result;
-      }
-    }
-    
-    if (has_finally) {
-      uint8_t pre_finally_flags = js->flags;
-      bool had_pre_finally_exception = (js->flags & F_THROW) != 0;
-      char pre_finally_errmsg[256] = {0};
-      if (had_pre_finally_exception) {
-        strncpy(pre_finally_errmsg, js->errmsg, sizeof(pre_finally_errmsg) - 1);
-        js->flags &= (uint8_t)~F_THROW;
-        js->errmsg[0] = '\0';
-      }
-      
-      js->flags = flags & (uint8_t)~F_NOEXEC;
-      js->pos = finally_start;
-      js->consumed = 1;
-      
-      while (next(js) != TOK_EOF && next(js) != TOK_RBRACE && !(js->flags & (F_RETURN | F_THROW | F_BREAK))) {
-        finally_result = js_stmt(js);
-        if (is_err(finally_result)) break;
-      }
-      
-      if (next(js) == TOK_RBRACE) js->consumed = 1;
-      
-      if (!(js->flags & (F_RETURN | F_THROW))) {
-        if (had_pre_finally_exception) {
-          js->flags = pre_finally_flags;
-          strncpy(js->errmsg, pre_finally_errmsg, sizeof(js->errmsg) - 1);
-        } else if (had_exception && !exception_handled) {
-          js->flags |= F_THROW;
-          strncpy(js->errmsg, saved_errmsg, sizeof(js->errmsg) - 1);
-          js->thrown_value = exception_value;
-        } else if (catch_returned) {
-          js->flags |= F_RETURN;
-          res = catch_return_value;
-        } else if (try_returned) {
-          js->flags |= F_RETURN;
-          res = try_return_value;
-        }
-      }
-    } else if (had_exception && !exception_handled) {
-      js->flags |= F_THROW;
-      strncpy(js->errmsg, saved_errmsg, sizeof(js->errmsg) - 1);
-      js->thrown_value = exception_value;
-      res = mkval(T_ERR, 0);
-    } else if (catch_returned) {
-      js->flags |= F_RETURN;
-      res = catch_return_value;
-    } else if (try_returned) {
-      js->flags |= F_RETURN;
-      res = try_return_value;
-    }
-    
-    if (!had_exception && !try_returned && !(js->flags & (F_RETURN | F_THROW))) {
-      res = try_result;
-    }
-  }
-  
-  js->pos = end_pos;
-  js->tok = TOK_SEMICOLON;
-  js->consumed = 0;
-  
-  return res;
-}
-
-static bool label_exists(const char *name, jsoff_t len, bool check_loop) {
-  if (!label_stack) return false;
-  unsigned int depth = utarray_len(label_stack);
-  for (int i = (int)depth - 1; i >= 0; i--) {
-    label_entry_t *entry = (label_entry_t *)utarray_eltptr(label_stack, (unsigned int)i);
-    if (entry && entry->name_len == len && 
-        memcmp(entry->name, name, len) == 0) {
-      if (check_loop && !entry->is_loop) {
-        return false;
-      }
-      return true;
-    }
-  }
-  return false;
-}
-
-static bool is_this_loop_continue_target(int marker_index) {
-  if (!(label_flags & F_CONTINUE_LABEL)) return false;
-  if (!label_stack || !continue_target_label) return false;
-  if (marker_index <= 0) return false;
-  
-  label_entry_t *entry = (label_entry_t *)utarray_eltptr(label_stack, (unsigned int)(marker_index - 1));
-  if (!entry) return false;
-  if (entry->name == NULL) return false;
-  if (!entry->is_loop) return false;
-  
-  if (entry->name_len == continue_target_label_len &&
-      memcmp(entry->name, continue_target_label, continue_target_label_len) == 0) {
-    return true;
-  }
-  return false;
-}
-
-static jsval_t js_break(struct js *js) {
-  js->consumed = 1;
-  
-  uint8_t nxt = next(js);
-  if (nxt == TOK_IDENTIFIER && !js->had_newline) {
-    const char *label = &js->code[js->toff];
-    jsoff_t label_len = js->tlen;
-    js->consumed = 1;
-    
-    if (js->flags & F_NOEXEC) {
-      return js_mkundef();
-    }
-    
-    if (!label_exists(label, label_len, false)) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "undefined label '%.*s'", (int)label_len, label);
-    }
-    
-    break_target_label = label;
-    break_target_label_len = label_len;
-    label_flags |= F_BREAK_LABEL;
-    js->flags |= F_BREAK | F_NOEXEC;
-    return js_mkundef();
-  }
-  
-  if (js->flags & F_NOEXEC) {
-    return js_mkundef();
-  }
-  
-  if (!(js->flags & (F_LOOP | F_SWITCH))) {
-    bool in_labeled_block = false;
-    if (label_stack) {
-      unsigned int depth = utarray_len(label_stack);
-      for (int i = (int)depth - 1; i >= 0; i--) {
-        label_entry_t *entry = (label_entry_t *)utarray_eltptr(label_stack, (unsigned int)i);
-        if (entry && entry->is_block) {
-          in_labeled_block = true;
-          break;
-        }
-      }
-    }
-    if (!in_labeled_block) {
-      return js_mkerr(js, "not in loop or switch");
-    }
-  }
-  
-  js->flags |= F_BREAK | F_NOEXEC;
-  return js_mkundef();
-}
-
-static jsval_t js_continue(struct js *js) {
-  js->consumed = 1;
-  
-  uint8_t nxt = next(js);
-  if (nxt == TOK_IDENTIFIER && !js->had_newline) {
-    const char *label = &js->code[js->toff];
-    jsoff_t label_len = js->tlen;
-    js->consumed = 1;
-    
-    if (js->flags & F_NOEXEC) {
-      return js_mkundef();
-    }
-    
-    if (!label_exists(label, label_len, true)) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "undefined label '%.*s' or not a loop", (int)label_len, label);
-    }
-    
-    continue_target_label = label;
-    continue_target_label_len = label_len;
-    label_flags |= F_CONTINUE_LABEL;
-    js->flags |= F_BREAK | F_NOEXEC;
-    return js_mkundef();
-  }
-  
-  if (js->flags & F_NOEXEC) {
-    return js_mkundef();
-  }
-  
-  if (!(js->flags & F_LOOP)) {
-    return js_mkerr(js, "not in loop");
-  }
-  
-  js->flags |= F_NOEXEC;
-  return js_mkundef();
-}
-
-static inline jsoff_t skip_comment_or_string(const char *code, jsoff_t clen, jsoff_t p) {
-  char c = code[p];
-  if (c == '/' && p + 1 < clen) {
-    if (code[p + 1] == '/') return skip_line_comment(code, clen, p);
-    if (code[p + 1] == '*') return skip_block_comment(code, clen, p);
-  }
-  if (c == '\'' || c == '"') return skip_string_literal(code, clen, p, c);
-  if (c == '`') return skip_template_literal(code, clen, p);
-  return 0;
-}
-
-static inline bool is_stmt_end(char c) {
-  return c == ';' || c == '}' || c == '\n';
-}
-
-static const uint8_t binop_table[128] = {
-  ['+']=1, ['*']=1, ['%']=1, ['^']=1, [',']=1, ['=']=1,
-  ['/']=2, ['-']=2, ['&']=2, ['|']=2, ['<']=2, ['>']=2, ['!']=2,
-};
-
-static bool is_binop_char(const char *code, jsoff_t clen, jsoff_t p) {
-  unsigned char c = (unsigned char)code[p];
-  if (c > 127) return false;
-  uint8_t kind = binop_table[c];
-  if (kind == 1) return true;
-  if (kind == 0) return false;
-  if (p + 1 >= clen) return c == '/';
-  char n = code[p + 1];
-  switch (c) {
-    case '/': return n != '/' && n != '*';
-    case '-': return n != '-';
-    case '&': return n != '&';
-    case '|': return n != '|';
-    case '<': return true;
-    case '>': return true;
-    case '!': return n == '=';
-  }
-  return false;
-}
-
-static jsoff_t find_ternary_colon(const char *code, jsoff_t clen, jsoff_t p) {
-  int depth = 0, nesting = 0;
-  for (; p < clen; p++) {
-    jsoff_t skip = skip_comment_or_string(code, clen, p);
-    if (skip) { p = skip - 1; continue; }
-    switch (code[p]) {
-      case '(': case '[': case '{': depth++; break;
-      case ')': case ']': case '}': depth--; break;
-      case '?': if (!depth) nesting++; break;
-      case ':': if (!depth && nesting-- == 0) return p; break;
-    }
-  }
-  return clen;
-}
-
-static enum tail_scan scan_tail_span(const char *code, jsoff_t clen, jsoff_t start, jsoff_t end) {
-  jsoff_t p = skiptonext(code, end, start, NULL);
-  int depth = 0, bdepth = 0, cdepth = 0;
-  
-  jsoff_t last_paren_close = 0;
-  bool seen_binop = false;
-
-  while (p < end) {
-    jsoff_t skip = skip_comment_or_string(code, end, p);
-    if (skip) { p = skip; continue; }
-    char c = code[p];
-    if (c == '{') { cdepth++; p++; continue; }
-    if (c == '}') {
-      cdepth--; p++;
-      if (cdepth < 0) return TAIL_UNSAFE;
-      continue;
-    }
-    if (c == '[') { bdepth++; p++; continue; }
-    if (c == ']') {
-      bdepth--; p++;
-      if (bdepth < 0) return TAIL_UNSAFE;
-      continue;
-    }
-    if (c == '(') { depth++; p++; continue; }
-    if (c == ')') {
-      depth--; p++;
-      if (depth < 0) return TAIL_UNSAFE;
-      if (depth == 0 && bdepth == 0 && cdepth == 0) last_paren_close = p;
-      continue;
-    }
-    if (depth == 0 && bdepth == 0 && cdepth == 0) {
-      if (c == '?') {
-        p++;
-        jsoff_t colon = find_ternary_colon(code, end, p);
-        if (colon >= end) return TAIL_UNSAFE;
-        enum tail_scan t = scan_tail_span(code, colon, p, colon);
-        enum tail_scan f = scan_tail_span(code, end, colon + 1, end);
-        if (t == TAIL_UNSAFE || f == TAIL_UNSAFE) return TAIL_UNSAFE;
-        if (t == TAIL_OK || f == TAIL_OK) return TAIL_OK;
-        return TAIL_NONE;
-      }
-      if (is_binop_char(code, end, p)) seen_binop = true;
-    } p++;
-  }
-
-  if (last_paren_close == 0) return TAIL_NONE;
-  if (seen_binop) return TAIL_UNSAFE;
-  jsoff_t after = skiptonext(code, end, last_paren_close, NULL);
-  if ((after >= end) || is_stmt_end(code[after])) return TAIL_OK;
-  return TAIL_UNSAFE;
-}
-
-static bool is_tail_call_expr(struct js *js) {
-  const char *code = js->code;
-  jsoff_t clen = js->clen;
-  jsoff_t start = skiptonext(code, clen, js->toff, NULL);
-  return scan_tail_span(code, clen, start, clen) == TAIL_OK;
-}
-
-static jsval_t js_return(struct js *js) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  uint8_t in_func = js->flags & F_CALL;
-  js->consumed = 1;
-  jsval_t res = js_mkundef();
-  
-  uint8_t nxt = next(js);
-  if (nxt != TOK_SEMICOLON && nxt != TOK_RBRACE && nxt != TOK_EOF && !js->had_newline) {
-    bool prev_tail = js->tail_ctx;
-    if (exe && in_func && js->has_tail_calls && is_tail_call_expr(js)) js->tail_ctx = true;
-    res = js_expr_comma(js);
-    js->tail_ctx = prev_tail;
-    if (res != (jsval_t)T_TAILCALL) res = resolveprop(js, res);
-  }
-  
-  if (exe && !in_func) return js_mkundef();
-  
-  if (exe) {
-    js->pos = js->clen;
-    js->flags |= F_RETURN | F_NOEXEC;
-  }
-  
-  return res;
-}
-
-static jsval_t js_switch(struct js *js) {
-  uint8_t flags = js->flags, exe = !(flags & F_NOEXEC);
-  jsval_t res = js_mkundef();
-  
-  js->consumed = 1;
-  if (!expect(js, TOK_LPAREN, &res)) return res;
-  
-  jsoff_t switch_expr_start = js->pos;
-  uint8_t saved_flags = js->flags;
-  js->flags |= F_NOEXEC;
-  jsval_t switch_expr = js_expr(js);
-  js->flags = saved_flags;
-  
-  if (is_err(switch_expr)) return switch_expr;
-  
-  if (!expect(js, TOK_RPAREN, &res)) return res;
-  if (!expect(js, TOK_LBRACE, &res)) return res;
-  
-  typedef struct {
-    jsoff_t case_expr_start;
-    jsoff_t case_expr_end;
-    jsoff_t body_start;
-    bool is_default;
-  } CaseInfo;
-  
-  CaseInfo cases[64];
-  int case_count = 0;
-  
-  js->flags |= F_NOEXEC;
-  
-  while (next(js) != TOK_RBRACE && next(js) != TOK_EOF && case_count < 64) {
-    if (next(js) == TOK_CASE) {
-      js->consumed = 1;
-      
-      cases[case_count].is_default = false;
-      cases[case_count].case_expr_start = js->pos;
-      
-      jsval_t case_val = js_expr(js);
-      if (is_err(case_val)) {
-        js->flags = flags;
-        return case_val;
-      }
-      
-      cases[case_count].case_expr_end = js->pos;
-      
-      if (!expect(js, TOK_COLON, &res)) {
-        js->flags = flags;
-        return res;
-      }
-      
-      cases[case_count].body_start = js->pos;
-      case_count++;
-      
-      while (next(js) != TOK_EOF && next(js) != TOK_CASE && next(js) != TOK_DEFAULT && next(js) != TOK_RBRACE) {
-        jsval_t stmt = js_stmt(js);
-        if (is_err(stmt)) {
-          js->flags = flags;
-          return stmt;
-        }
-      }
-      
-    } else if (next(js) == TOK_DEFAULT) {
-      js->consumed = 1;
-      
-      cases[case_count].is_default = true;
-      cases[case_count].case_expr_start = 0;
-      cases[case_count].case_expr_end = 0;
-      
-      if (!expect(js, TOK_COLON, &res)) {
-        js->flags = flags;
-        return res;
-      }
-      
-      cases[case_count].body_start = js->pos;
-      case_count++;
-      
-      while (next(js) != TOK_EOF && next(js) != TOK_CASE && next(js) != TOK_DEFAULT && next(js) != TOK_RBRACE) {
-        jsval_t stmt = js_stmt(js);
-        if (is_err(stmt)) {
-          js->flags = flags;
-          return stmt;
-        }
-      }
-      
-    } else break;
-  }
-  
-  if (!expect(js, TOK_RBRACE, &res)) {
-    js->flags = flags;
-    return res;
-  }
-  
-  jsoff_t end_pos = js->pos;
-  
-  if (exe) {
-    js->pos = switch_expr_start;
-    js->consumed = 1;
-    js->flags = flags;
-    jsval_t switch_val = resolveprop(js, js_expr(js));
-    
-    if (is_err(switch_val)) {
-      js->pos = end_pos;
-      js->flags = flags;
-      return switch_val;
-    }
-    
-    int matching_case = -1;
-    int default_case = -1;
-    
-    for (int i = 0; i < case_count; i++) {
-      if (cases[i].is_default) {
-        default_case = i;
-        continue;
-      }
-      
-      js->pos = cases[i].case_expr_start;
-      js->consumed = 1;
-      js->flags = flags;
-      jsval_t case_val = resolveprop(js, js_expr(js));
-      
-      if (is_err(case_val)) {
-        js->pos = end_pos;
-        js->flags = flags;
-        return case_val;
-      }
-      
-      bool matches = false;
-      if (vtype(switch_val) == vtype(case_val)) {
-        if (vtype(switch_val) == T_NUM) {
-          matches = tod(switch_val) == tod(case_val);
-        } else if (vtype(switch_val) == T_STR) {
-          jsoff_t n1, off1 = vstr(js, switch_val, &n1);
-          jsoff_t n2, off2 = vstr(js, case_val, &n2);
-          matches = n1 == n2 && memcmp(&js->mem[off1], &js->mem[off2], n1) == 0;
-        } else if (vtype(switch_val) == T_BOOL) {
-          matches = vdata(switch_val) == vdata(case_val);
-        } else {
-          matches = vdata(switch_val) == vdata(case_val);
-        }
-      }
-      
-      if (matches) {
-        matching_case = i;
-        break;
-      }
-    }
-    
-    if (matching_case < 0 && default_case >= 0) matching_case = default_case;
-    
-    if (matching_case >= 0) {
-      js->flags = (flags & ~F_NOEXEC) | F_SWITCH;
-      
-      for (int i = matching_case; i < case_count; i++) {
-        js->pos = cases[i].body_start;
-        js->consumed = 1;
-        
-        while (next(js) != TOK_EOF && next(js) != TOK_CASE && 
-               next(js) != TOK_DEFAULT && next(js) != TOK_RBRACE &&
-               !(js->flags & (F_BREAK | F_RETURN | F_THROW))) {
-          res = js_stmt(js);
-          if (is_err(res)) {
-            js->pos = end_pos;
-            uint8_t preserve = 0;
-            if (js->flags & F_RETURN) {
-              preserve = js->flags & (F_RETURN | F_NOEXEC);
-            }
-            if (js->flags & F_THROW) {
-              preserve = js->flags & (F_THROW | F_NOEXEC);
-            }
-            js->flags = flags | preserve;
-            return res;
-          }
-        }
-        
-        if (js->flags & F_BREAK) { js->flags &= ~F_BREAK; break; }
-        if (js->flags & (F_RETURN | F_THROW)) break;
-      }
-    }
-  }
-  
-  js->pos = end_pos;
-  js->tok = TOK_SEMICOLON;
-  js->consumed = 0;
-  
-  uint8_t preserve = 0;
-  if (js->flags & F_RETURN) preserve = js->flags & (F_RETURN | F_NOEXEC);
-  if (js->flags & F_THROW) preserve = js->flags & (F_THROW | F_NOEXEC);
-  js->flags = flags | preserve;
-  
-  return res;
-}
-
-static jsval_t js_with(struct js *js) {
-  uint8_t flags = js->flags, exe = !(flags & F_NOEXEC);
-  jsval_t res = js_mkundef();
-  
-  if (flags & F_STRICT) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "with statement not allowed in strict mode");
-  }
-  
-  js->consumed = 1;
-  if (!expect(js, TOK_LPAREN, &res)) return res;
-  
-  jsval_t obj_expr = js_expr(js);
-  if (is_err(obj_expr)) return obj_expr;
-  
-  if (!expect(js, TOK_RPAREN, &res)) return res;
-  
-  if (exe) {
-    jsval_t obj = resolveprop(js, obj_expr);
-    if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) {
-      return js_mkerr(js, "with requires object");
-    }
-    
-    jsval_t with_obj = obj;
-    if (vtype(obj) == T_FUNC) {
-      with_obj = mkval(T_OBJ, vdata(obj));
-    }
-    
-    jsoff_t parent_scope_offset = (jsoff_t) vdata(js->scope);
-    if (global_scope_stack == NULL) utarray_new(global_scope_stack, &jsoff_icd);
-    utarray_push_back(global_scope_stack, &parent_scope_offset);
-    
-    jsval_t with_scope = mkobj(js, parent_scope_offset);
-    set_slot(js, with_scope, SLOT_WITH, with_obj);
-    
-    jsval_t saved_scope = js->scope;
-    js->scope = with_scope;
-    
-    res = js_block_or_stmt(js);
-    if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-    js->scope = saved_scope;
-  } else res = js_block_or_stmt(js);
-  
-  const uint8_t flow_mask = F_RETURN | F_THROW | F_BREAK | F_BREAK_LABEL | F_CONTINUE_LABEL;
-  js->flags = (flags & (uint8_t)~flow_mask) | (js->flags & flow_mask);
-  
-  return res;
-}
-
-static jsval_t js_class_expr(struct js *js, bool is_expression);
-static jsval_t js_class_decl(struct js *js) { return js_class_expr(js, false); }
-
-static jsval_t js_class_expr(struct js *js, bool is_expression) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  js->consumed = 1;
-  
-  jsoff_t class_name_off = 0, class_name_len = 0;
-  char *class_name = NULL;
-  
-  if (next(js) == TOK_IDENTIFIER) {
-    if (!(js->tlen == 7 && streq(&js->code[js->toff], js->tlen, "extends", 7))) {
-      class_name_off = js->toff;
-      class_name_len = js->tlen;
-      class_name = (char *) &js->code[class_name_off];
-      js->consumed = 1;
-    }
-  } else if (!is_expression) {
-    return js_mkerr_typed(js, JS_ERR_SYNTAX, "class name expected");
-  }
-  
-  jsoff_t super_expr_off = 0, super_expr_len = 0;
-  if (
-    next(js) == TOK_IDENTIFIER 
-    && js->tlen == 7 
-    && streq(&js->code[js->toff], js->tlen, "extends", 7)
-  ) {
-    js->consumed = 1;
-    if (next(js) == TOK_LBRACE || next(js) == TOK_EOF) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "super class expression expected");
-    }
-    super_expr_off = js->toff;
-    uint8_t saved_flags = js->flags;
-    js->flags |= F_NOEXEC;
-    jsval_t super_expr = js_expr(js);
-    js->flags = saved_flags;
-    if (is_err(super_expr)) return super_expr;
-    super_expr_len = js->pos - super_expr_off;
-  }
-  
-  EXPECT(TOK_LBRACE);
-  jsoff_t constructor_params_start = 0;
-  jsoff_t constructor_body_start = 0, constructor_body_end = 0;
-  uint8_t save_flags = js->flags;
-  js->flags |= F_NOEXEC;
-  
-  typedef struct { 
-    jsoff_t name_off, name_len, fn_start, fn_end; 
-    bool is_async;
-    bool is_static;
-    bool is_field;
-    bool is_private;
-    bool is_getter;
-    bool is_setter;
-    bool is_static_block;
-    bool is_computed;
-    jsval_t computed_key;
-    jsoff_t field_start, field_end; 
-    jsoff_t param_start;
-  } MethodInfo;
-  
-  static const UT_icd method_info_icd = {
-    .sz = sizeof(MethodInfo),
-    .init = NULL,
-    .copy = NULL,
-    .dtor = NULL,
-  };
-  
-  UT_array *methods = NULL;
-  utarray_new(methods, &method_info_icd);
-  
-  uint8_t class_tok;
-  while ((class_tok = next(js)) != TOK_RBRACE && class_tok != TOK_EOF) {
-    if (class_tok == TOK_SEMICOLON) { js->consumed = 1; continue; }
-    
-    bool is_async_method = false;
-    bool is_static_member = false;
-    bool is_getter_method = false;
-    bool is_setter_method = false;
-    
-    if (next(js) == TOK_STATIC) {
-      is_static_member = true;
-      js->consumed = 1;
-    }
-    if (next(js) == TOK_ASYNC) {
-      is_async_method = true;
-      js->consumed = 1;
-    }
-    
-    bool is_private_member = false;
-    if (next(js) == TOK_HASH) {
-      js->consumed = 1;
-      if (next(js) == TOK_IDENTIFIER) { is_private_member = true; } else {
-        js->flags = save_flags;
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "private field name expected");
-      }
-    }
-    
-    if (next(js) == TOK_IDENTIFIER) {
-      bool is_get = (js->tlen == 3 && memcmp(&js->code[js->toff], "get", 3) == 0);
-      bool is_set = (js->tlen == 3 && memcmp(&js->code[js->toff], "set", 3) == 0);
-      if (is_get || is_set) {
-        jsoff_t saved_pos = js->pos;
-        jsoff_t saved_toff = js->toff;
-        jsoff_t saved_tlen = js->tlen;
-        uint8_t saved_tok = js->tok;
-        int saved_stream_pos = js->token_stream_pos;
-        js->consumed = 1;
-        uint8_t peek = next(js);
-        bool next_is_name = (
-          peek == TOK_IDENTIFIER || is_keyword_propname(peek) ||
-          peek == TOK_STRING || peek == TOK_NUMBER ||
-          peek == TOK_LBRACKET
-        );
-        if (!next_is_name && peek == TOK_HASH) {
-          js->consumed = 1;
-          if (next(js) == TOK_IDENTIFIER) { 
-            next_is_name = true;
-            is_private_member = true; 
-          }
-        }
-        if (next_is_name) {
-          is_getter_method = is_get;
-          is_setter_method = is_set;
-        } else {
-          js->pos = saved_pos;
-          js->toff = saved_toff;
-          js->tlen = saved_tlen;
-          js->tok = saved_tok;
-          js->token_stream_pos = saved_stream_pos;
-          js->consumed = 0;
-        }
-      }
-    }
-    
-    if (is_static_member && !is_getter_method && !is_setter_method && next(js) == TOK_LBRACE) {
-      jsoff_t block_start = js->pos - 1; js->consumed = 0;
-      jsval_t blk = js_block(js, false);
-      if (is_err(blk)) { js->flags = save_flags; utarray_free(methods); return blk; }
-      jsoff_t block_end = js->pos;
-      MethodInfo static_block = {0};
-      static_block.is_static = true;
-      static_block.is_static_block = true;
-      static_block.field_start = block_start;
-      static_block.field_end = block_end;
-      utarray_push_back(methods, &static_block);
-      js->consumed = 1;
-      continue;
-    }
-    
-    if (next(js) == TOK_LBRACKET) {
-      jsoff_t key_start = js->pos;
-      js->consumed = 1;
-      jsval_t computed_key = js_expr(js);
-      if (is_err(computed_key)) { js->flags = save_flags; utarray_free(methods); return computed_key; }
-      if (next(js) != TOK_RBRACKET) { js->flags = save_flags; return js_mkerr_typed(js, JS_ERR_SYNTAX, "] expected"); }
-      jsoff_t key_end = js->pos - 1;
-      js->consumed = 1;
-      
-      MethodInfo computed = {0};
-      computed.is_static = is_static_member;
-      computed.is_computed = true;
-      computed.name_off = key_start;
-      computed.name_len = key_end - key_start;
-      
-      if (next(js) == TOK_LPAREN) {
-        computed.is_field = false;
-        computed.is_async = is_async_method;
-        computed.is_getter = is_getter_method;
-        computed.is_setter = is_setter_method;
-        EXPECT(TOK_LPAREN, js->flags = save_flags);
-        jsoff_t method_params_start = js->pos - 1;
-        if (!parse_func_params(js, &save_flags, NULL)) {
-          js->flags = save_flags;
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid method parameters");
-        }
-        EXPECT(TOK_RPAREN, js->flags = save_flags);
-        EXPECT(TOK_LBRACE, js->flags = save_flags);
-        js->consumed = 0;
-        jsval_t blk = js_block(js, false);
-        if (is_err(blk)) { js->flags = save_flags; return blk; }
-        jsoff_t method_body_end = js->pos;
-        computed.fn_start = method_params_start;
-        computed.fn_end = method_body_end;
-        computed.param_start = method_params_start;
-        js->consumed = 1;
-      } else if (next(js) == TOK_ASSIGN) {
-        computed.is_field = true;
-        js->consumed = 1;
-        jsoff_t field_start = js->pos;
-        jsval_t field_expr = js_expr(js);
-        if (is_err(field_expr)) { js->flags = save_flags; utarray_free(methods); return field_expr; }
-        jsoff_t field_end = js->pos;
-        computed.field_start = field_start;
-        computed.field_end = field_end;
-        if (next(js) == TOK_SEMICOLON) js->consumed = 1;
-      } else {
-        computed.is_field = true;
-        if (next(js) == TOK_SEMICOLON) js->consumed = 1;
-      }
-      utarray_push_back(methods, &computed);
-      continue;
-    }
-    
-    uint8_t name_tok = next(js);
-    bool name_is_ident = (name_tok == TOK_IDENTIFIER || is_keyword_propname(name_tok));
-    bool name_is_literal = (name_tok == TOK_STRING || name_tok == TOK_NUMBER);
-    
-    if (!name_is_ident && !name_is_literal) {
-      js->flags = save_flags;
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "method name expected");
-    }
-    
-    jsoff_t method_name_off = is_private_member ? js->toff - 1 : js->toff;
-    jsoff_t method_name_len = is_private_member ? js->tlen + 1 : js->tlen;
-    bool name_needs_eval = name_is_literal; js->consumed = 1;
-    
-    if (next(js) == TOK_ASSIGN) {
-      js->consumed = 1;
-      jsoff_t field_start = js->pos;
-      jsval_t field_expr = js_expr(js);
-      if (is_err(field_expr)) {
-        js->flags = save_flags;
-        utarray_free(methods);
-        return field_expr;
-      }
-      jsoff_t field_end = js->pos;
-      if (next(js) == TOK_SEMICOLON) js->consumed = 1;
-      
-      MethodInfo field_method = {
-        .name_off = method_name_off,
-        .name_len = method_name_len,
-        .is_static = is_static_member,
-        .is_async = false,
-        .is_field = true,
-        .is_private = is_private_member,
-        .is_computed = name_needs_eval,
-        .field_start = field_start,
-        .field_end = field_end,
-        .fn_start = 0,
-        .fn_end = 0,
-      };
-      utarray_push_back(methods, &field_method);
-      continue;
-    }
-    
-    if (next(js) == TOK_SEMICOLON || (next(js) != TOK_LPAREN && next(js) == TOK_IDENTIFIER)) {
-      if (next(js) == TOK_SEMICOLON) js->consumed = 1;
-      MethodInfo bare_method = {
-        .name_off = method_name_off,
-        .name_len = method_name_len,
-        .is_static = is_static_member,
-        .is_async = false,
-        .is_field = true,
-        .is_private = is_private_member,
-        .is_computed = name_needs_eval,
-        .field_start = 0,
-        .field_end = 0,
-        .fn_start = 0,
-        .fn_end = 0,
-      };
-      utarray_push_back(methods, &bare_method);
-      continue;
-    }
-    
-    EXPECT(TOK_LPAREN, js->flags = save_flags);
-    jsoff_t method_params_start = js->pos - 1;
-    if (!parse_func_params(js, &save_flags, NULL)) {
-      js->flags = save_flags;
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "invalid method parameters");
-    }
-    EXPECT(TOK_RPAREN, js->flags = save_flags);
-    EXPECT(TOK_LBRACE, js->flags = save_flags);
-    jsoff_t method_body_start = js->pos - 1;
-    js->consumed = 0;
-    jsval_t blk = js_block(js, false);
-    if (is_err(blk)) {
-      js->flags = save_flags;
-      return blk;
-    }
-    jsoff_t method_body_end = js->pos;
-    if (
-      !is_private_member 
-      && !name_needs_eval 
-      && streq(&js->code[method_name_off], method_name_len, "constructor", 11)
-    ) {
-      constructor_params_start = method_params_start;
-      constructor_body_start = method_body_start + 1;
-      constructor_body_end = method_body_end;
-    } else {
-      MethodInfo func_method = {
-        .name_off = method_name_off,
-        .name_len = method_name_len,
-        .fn_start = method_params_start,
-        .fn_end = method_body_end,
-        .param_start = method_params_start,
-        .is_async = is_async_method,
-        .is_static = is_static_member,
-        .is_field = false,
-        .is_private = is_private_member,
-        .is_getter = is_getter_method,
-        .is_setter = is_setter_method,
-        .is_computed = name_needs_eval,
-        .field_start = 0,
-        .field_end = 0,
-      };
-      utarray_push_back(methods, &func_method);
-     } js->consumed = 1;
-  }
-  
-  EXPECT(TOK_RBRACE, js->flags = save_flags);
-  js->flags = save_flags;
-  
-  if (exe) {
-    jsval_t super_constructor = js_mkundef();
-    jsval_t super_proto = js_mknull();
-    bool has_super_ctor = false;
-    if (super_expr_len > 0) {
-      jsval_t super_val = js_eval_slice(js, super_expr_off, super_expr_len);
-      if (is_err(super_val)) return super_val;
-      super_constructor = resolveprop(js, super_val);
-      uint8_t super_type = vtype(super_constructor);
-      if (super_type == T_NULL) {
-        super_proto = js_mknull();
-      } else if (super_type == T_FUNC) {
-        has_super_ctor = true;
-        jsval_t super_obj = mkval(T_OBJ, vdata(super_constructor));
-        jsoff_t super_proto_off = lkp_interned(js, super_obj, INTERN_PROTOTYPE, 9);
-        if (super_proto_off != 0) {
-          super_proto = resolveprop(js, mkval(T_PROP, super_proto_off));
-        }
-        if (!is_object_type(super_proto) && vtype(super_proto) != T_NULL) {
-          return js_mkerr(js, "super class prototype must be an object or null");
-        }
-      } else return js_mkerr(js, "super class must be a constructor");
-    }
-    
-    jsval_t proto = js_mkobj(js);
-    if (is_err(proto)) return proto;
-    
-    if (super_expr_len > 0) {
-      if (is_object_type(super_proto) || vtype(super_proto) == T_NULL) {
-        set_proto(js, proto, super_proto);
-      } else {
-        jsval_t object_proto = get_ctor_proto(js, "Object", 6);
-        if (vtype(object_proto) == T_OBJ) set_proto(js, proto, object_proto);
-      }
-    } else {
-      jsval_t object_proto = get_ctor_proto(js, "Object", 6);
-      if (vtype(object_proto) == T_OBJ) set_proto(js, proto, object_proto);
-    }
-    
-    jsval_t func_scope = mkobj(js, (jsoff_t) vdata(js->scope));
-    
-    for (unsigned int i = 0; i < utarray_len(methods); i++) {
-      MethodInfo *m = (MethodInfo *)utarray_eltptr(methods, i);
-      if (!m->is_computed) continue;
-      jsval_t key_val = js_eval_slice(js, m->name_off, m->name_len);
-      key_val = resolveprop(js, key_val);
-      if (vtype(key_val) == T_SYMBOL) {
-        char sym_buf[48];
-        sym_to_prop_key(key_val, sym_buf, sizeof(sym_buf));
-        m->computed_key = js_mkstr(js, sym_buf, strlen(sym_buf));
-      } else m->computed_key = coerce_to_str(js, key_val);
-      if (is_err(m->computed_key)) { utarray_free(methods); return m->computed_key; }
-    }
-    
-    for (unsigned int i = 0; i < utarray_len(methods); i++) {
-      MethodInfo *m = (MethodInfo *)utarray_eltptr(methods, i);
-      if (m->is_static) continue;
-      if (m->is_field) continue;
-      
-      jsval_t method_name;
-      if (m->is_computed) method_name = m->computed_key;
-      else method_name = js_mkstr(js, &js->code[m->name_off], m->name_len);
-      if (is_err(method_name)) return method_name;
-      
-      jsoff_t mlen = m->fn_end - m->fn_start;
-      jsval_t method_obj = mkobj(js, 0);
-      if (is_err(method_obj)) return method_obj;
-      
-      set_func_code(js, method_obj, &js->code[m->fn_start], mlen);
-      set_slot(js, method_obj, SLOT_SCOPE, func_scope);
-      
-      if (m->is_async) {
-        set_slot(js, method_obj, SLOT_ASYNC, js_true);
-        jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-        if (vtype(async_proto) == T_FUNC) set_proto(js, method_obj, async_proto);
-      } else {
-        jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-        if (vtype(func_proto) == T_FUNC) set_proto(js, method_obj, func_proto);
-      }
-      
-      if (has_super_ctor) set_slot(js, method_obj, SLOT_SUPER, super_constructor);
-      jsval_t method_func = mkval(T_FUNC, (unsigned long) vdata(method_obj));
-      
-      if (m->is_getter || m->is_setter) {
-        jsoff_t name_len;
-        const char *name_str = (const char *)&js->mem[vstr(js, method_name, &name_len)];
-        
-        if (m->is_getter) {
-          js_set_getter_desc(js, proto, name_str, name_len, method_func, JS_DESC_C);
-        } else {
-          js_set_setter_desc(js, proto, name_str, name_len, method_func, JS_DESC_C);
-        }
-      } else {
-        jsval_t set_res = js_setprop(js, proto, method_name, method_func);
-        if (is_err(set_res)) return set_res;
-      }
-    }
-    
-    jsval_t func_obj = mkobj(js, 0);
-    if (is_err(func_obj)) return func_obj;
-    
-    if (constructor_params_start > 0 && constructor_body_start > 0) {
-      jsoff_t code_len = constructor_body_end - constructor_params_start;
-      set_func_code(js, func_obj, &js->code[constructor_params_start], code_len);
-    } else {
-      set_func_code_ptr(js, func_obj, "(){}", 4);
-      if (has_super_ctor) set_slot(js, func_obj, SLOT_DEFAULT_CTOR, js_true);
-    }
-    
-    int instance_field_count = 0;
-    for (unsigned int i = 0; i < utarray_len(methods); i++) {
-      MethodInfo *m = (MethodInfo *)utarray_eltptr(methods, i);
-      if (m->is_static) continue;
-      if (!m->is_field) continue;
-      instance_field_count++;
-    }
-    
-    if (instance_field_count > 0) {
-      size_t metadata_size = instance_field_count * sizeof(jsoff_t) * 5;
-      jsoff_t meta_len = (jsoff_t) (metadata_size + 1);
-      jsoff_t meta_header = (jsoff_t) ((meta_len << 3) | T_STR);
-      jsoff_t meta_off = js_alloc(js, meta_len + sizeof(meta_header));
-      if (meta_off == (jsoff_t) ~0) return js_mkerr(js, "oom");
-      
-      memcpy(&js->mem[meta_off], &meta_header, sizeof(meta_header));
-      jsoff_t *metadata = (jsoff_t *)(&js->mem[meta_off + sizeof(meta_header)]);
-      
-      int meta_idx = 0;
-      for (unsigned int i = 0; i < utarray_len(methods); i++) {
-        MethodInfo *m = (MethodInfo *)utarray_eltptr(methods, i);
-        if (m->is_static) continue;
-        if (!m->is_field) continue;
-        
-        if (m->is_computed) {
-          metadata[meta_idx * 5 + 0] = (jsoff_t) m->computed_key;
-          metadata[meta_idx * 5 + 1] = 0;
-        } else {
-          metadata[meta_idx * 5 + 0] = m->name_off;
-          metadata[meta_idx * 5 + 1] = m->name_len;
-        }
-        
-        metadata[meta_idx * 5 + 2] = m->field_start;
-        metadata[meta_idx * 5 + 3] = m->field_end;
-        metadata[meta_idx * 5 + 4] = m->is_computed ? 1 : 0;
-        meta_idx++;
-      }
-      
-      js->mem[meta_off + sizeof(meta_header) + metadata_size] = 0;
-      jsval_t fields_meta = mkval(T_STR, meta_off);
-      
-      set_slot(js, func_obj, SLOT_FIELD_COUNT, tov((double)instance_field_count));
-      set_slot(js, func_obj, SLOT_FIELDS, fields_meta);
-      
-      const char *arena_src = code_arena_alloc(js->code, js->clen);
-      if (arena_src) set_slot(js, func_obj, SLOT_SOURCE, mkval(T_CFUNC, (size_t)arena_src));
-    }
-    
-    set_slot(js, func_obj, SLOT_SCOPE, func_scope);
-    if (has_super_ctor) set_slot(js, func_obj, SLOT_SUPER, super_constructor);
-    
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    if (vtype(func_proto) == T_FUNC) set_proto(js, func_obj, func_proto);
-    if (has_super_ctor) set_proto(js, func_obj, super_constructor);
-    
-    jsval_t name_key = js_mkstr(js, "name", 4);
-    if (is_err(name_key)) return name_key;
-    jsval_t name_val = class_name_len > 0 ? js_mkstr(js, class_name, class_name_len) : js_mkstr(js, "", 0);
-    if (is_err(name_val)) return name_val;
-    jsval_t res_name = js_setprop(js, func_obj, name_key, name_val);
-    if (is_err(res_name)) return res_name;
-    
-    jsval_t proto_key = js_mkstr(js, "prototype", 9);
-    if (is_err(proto_key)) return proto_key;
-    jsval_t proto_res = js_setprop(js, func_obj, proto_key, proto);
-    if (is_err(proto_res)) return proto_res;
-    
-    jsval_t constructor = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-    
-    jsval_t ctor_key = js_mkstr(js, "constructor", 11);
-    if (is_err(ctor_key)) return ctor_key;
-    jsval_t ctor_res = js_setprop(js, proto, ctor_key, constructor);
-    if (is_err(ctor_res)) return ctor_res;
-    js_set_descriptor(js, proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
-    
-    if (class_name_len > 0) {
-      if (lkp_scope(js, js->scope, class_name, class_name_len) > 0) {
-        return js_mkerr(js, "'%.*s' already declared", (int) class_name_len, class_name);
-      }
-      jsval_t x = mkprop(js, js->scope, js_mkstr(js, class_name, class_name_len), constructor, 0);
-      if (is_err(x)) return x;
-    }
-    
-    for (unsigned int i = 0; i < utarray_len(methods); i++) {
-      MethodInfo *m = (MethodInfo *)utarray_eltptr(methods, i);
-      if (!m->is_static) continue;
-      
-      if (m->is_static_block) {
-        if (m->field_start > 0 && m->field_end > m->field_start) {
-          const char *saved_code = js->code;
-          jsoff_t saved_clen = js->clen, saved_pos = js->pos;
-          uint8_t saved_tok = js->tok, saved_consumed = js->consumed;
-          jsval_t blk_res = js_eval(js, &saved_code[m->field_start], m->field_end - m->field_start);
-          js->code = saved_code; js->clen = saved_clen; js->pos = saved_pos;
-          js->tok = saved_tok; js->consumed = saved_consumed;
-          if (is_err(blk_res)) { utarray_free(methods); return blk_res; }
-        }
-        continue;
-      }
-      
-      jsval_t member_name;
-      if (m->is_computed) member_name = m->computed_key;
-      else member_name = js_mkstr(js, &js->code[m->name_off], m->name_len);
-      
-      if (is_err(member_name)) return member_name;
-      
-      if (m->is_field) {
-        jsval_t field_val = js_mkundef();
-        if (m->field_start > 0 && m->field_end > m->field_start) {
-          field_val = js_eval_slice(js, m->field_start, m->field_end - m->field_start);
-          field_val = resolveprop(js, field_val);
-        }
-        jsval_t set_res = js_setprop(js, func_obj, member_name, field_val);
-        if (is_err(set_res)) return set_res;
-      } else {
-        jsoff_t mlen = m->fn_end - m->fn_start;
-        
-        jsval_t method_obj = mkobj(js, 0);
-        if (is_err(method_obj)) return method_obj;
-        
-        set_func_code(js, method_obj, &js->code[m->fn_start], mlen);
-        set_slot(js, method_obj, SLOT_SCOPE, func_scope);
-        if (has_super_ctor) set_slot(js, method_obj, SLOT_SUPER, super_constructor);
-        
-        jsval_t method_func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-        if (vtype(method_func_proto) == T_FUNC) set_proto(js, method_obj, method_func_proto);
-        
-        jsval_t method_func = mkval(T_FUNC, (unsigned long) vdata(method_obj));
-        
-        if (m->is_getter || m->is_setter) {
-          jsoff_t nm_len;
-          const char *nm_str = (const char *)&js->mem[vstr(js, member_name, &nm_len)];
-          if (m->is_getter) {
-            js_set_getter_desc(js, func_obj, nm_str, nm_len, method_func, JS_DESC_C);
-          } else {
-            js_set_setter_desc(js, func_obj, nm_str, nm_len, method_func, JS_DESC_C);
-          }
-        } else {
-          jsval_t set_res = js_setprop(js, func_obj, member_name, method_func);
-          if (is_err(set_res)) return set_res;
-        }
-      }
-    }
-    
-    utarray_free(methods);
-    return constructor;
-  }
-  
-  utarray_free(methods);
-  return js_mkundef();
-}
-
-static void js_throw_handle(struct js *js, jsval_t *res) {
-  js->consumed = 1;
-  jsval_t throw_val = js_expr(js);
-  if (js->flags & F_NOEXEC) *res = js_mkundef(); else {
-    throw_val = resolveprop(js, throw_val);
-    if (is_err(throw_val)) *res = throw_val;
-    else *res = js_throw(js, throw_val);
-  }
-}
-
-static jsval_t find_var_scope(struct js *js) {
-  jsval_t scope = js->scope;
-  
-  jsval_t eval_marker = get_slot(js, scope, SLOT_STRICT_EVAL_SCOPE);
-  if (vtype(eval_marker) != T_UNDEF) return scope;
-  
-  jsval_t module_marker = get_slot(js, scope, SLOT_MODULE_SCOPE);
-  if (vtype(module_marker) != T_UNDEF) return scope;
-  
-  if ((js->flags & F_CALL) && global_scope_stack && utarray_len(global_scope_stack) > 0) {
-    jsoff_t *scope_off = (jsoff_t *)utarray_back(global_scope_stack);
-    if (scope_off && *scope_off != 0) return mkval(T_OBJ, *scope_off);
-  }
-  
-  while (vdata(upper(js, scope)) != 0) {
-    jsval_t parent = upper(js, scope);
-    
-    jsval_t parent_eval_marker = get_slot(js, parent, SLOT_STRICT_EVAL_SCOPE);
-    if (vtype(parent_eval_marker) != T_UNDEF) return scope;
-    
-    jsval_t parent_module_marker = get_slot(js, parent, SLOT_MODULE_SCOPE);
-    if (vtype(parent_module_marker) != T_UNDEF) return scope;
-    
-    scope = parent;
-  }
-  
-  return scope;
-}
-
-static jsval_t js_var_decl(struct js *js) {
-  uint8_t exe = !(js->flags & F_NOEXEC);
-  jsval_t var_scope = find_var_scope(js);
-  
-  js->consumed = 1;
-  for (;;) {
-    uint8_t tok = next(js);
-    
-    if (tok == TOK_LBRACKET || tok == TOK_LBRACE) {
-      jsoff_t pattern_start = js->toff;
-      uint8_t close_tok = (tok == TOK_LBRACKET) ? TOK_RBRACKET : TOK_RBRACE;
-      
-      js->consumed = 1;
-      int depth = 1;
-      while (depth > 0 && next(js) != TOK_EOF) {
-        if (js->tok == tok) depth++;
-        else if (js->tok == close_tok) depth--;
-        if (depth > 0) js->consumed = 1;
-      }
-      js->consumed = 1;
-      jsoff_t pattern_end = js->pos;
-      jsoff_t pattern_len = pattern_end - pattern_start;
-      
-      if (next(js) != TOK_ASSIGN) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "destructuring requires assignment");
-      } js->consumed = 1;
-      
-      jsval_t v = js_expr(js);
-      if (is_err(v)) return v;
-      
-      if (exe) {
-        jsval_t val = resolveprop(js, v);
-        jsval_t r = bind_destruct_pattern(js, &js->code[pattern_start], pattern_len, val, var_scope);
-        if (is_err(r)) return r;
-      }
-    } else {
-      EXPECT_IDENT();
-      js->consumed = 0;
-      jsoff_t noff = js->toff, nlen = js->tlen;
-      char *name = (char *) &js->code[noff];
-      
-      if (exe && (js->flags & F_STRICT) && is_strict_restricted(name, nlen)) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot use '%.*s' as variable name in strict mode", (int) nlen, name);
-      }
-      
-      if (exe && (js->flags & F_STRICT) && is_strict_reserved(name, nlen)) {
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "'%.*s' is reserved in strict mode", (int) nlen, name);
-      }
-      
-      jsval_t v = js_mkundef();
-      bool has_initializer = false;
-      js->consumed = 1;
-      if (next(js) == TOK_ASSIGN) {
-        js->consumed = 1;
-        v = js_expr(js);
-        if (is_err(v)) return v;
-        has_initializer = true;
-      }
-      
-      if (exe) {
-        char decoded_name[256];
-        size_t decoded_len = decode_ident_escapes(name, nlen, decoded_name, sizeof(decoded_name));
-        
-        jsoff_t existing_off = lkp(js, var_scope, decoded_name, decoded_len);
-        if (existing_off > 0) {
-          if (has_initializer && !is_err(v)) {
-            jsval_t key_val = js_mkstr(js, decoded_name, decoded_len);
-            js_setprop(js, var_scope, key_val, resolveprop(js, v));
-          }
-        } else {
-          jsval_t x = mkprop(js, var_scope, js_mkstr(js, decoded_name, decoded_len), resolveprop(js, v), 0);
-          if (is_err(x)) return x;
-        }
-      }
-    }
-    
-    uint8_t var_next = next(js);
-    if (var_next == TOK_SEMICOLON || var_next == TOK_EOF || var_next == TOK_RBRACE || js->had_newline) break;
-    EXPECT(TOK_COMMA);
-  }
-  return js_mkundef();
-}
-
-static void js_var(struct js *js, jsval_t *res) {
-  if ((js->flags & F_STRICT) && !js->var_warning_shown) {
-    fprintf(stderr, "Warning: 'var' is deprecated, use 'let' or 'const' instead\n");
-    js->var_warning_shown = true;
-  }
-  
-  *res = js_var_decl(js);
-}
-
-static void js_async(struct js *js, jsval_t *res) {
-  js->consumed = 1;
-  uint8_t next_tok = next(js);
-  if (next_tok == TOK_FUNC) {
-    *res = js_func_decl_async(js);
-    return;
-  }
-  if (next_tok == TOK_LPAREN) {
-    *res = js_async_arrow_paren(js);
-    return;
-  }
-  *res = js_mkerr_typed(js, JS_ERR_SYNTAX, "async must be followed by function");
-}
-
-static jsval_t js_stmt(struct js *js);
-
-static bool is_break_target(const char *name, jsoff_t len) {
-  if (!(label_flags & F_BREAK_LABEL)) return false;
-  if (break_target_label_len != len) return false;
-  return memcmp(break_target_label, name, len) == 0;
-}
-
-static bool is_continue_target(const char *name, jsoff_t len) {
-  if (!(label_flags & F_CONTINUE_LABEL)) return false;
-  if (continue_target_label_len != len) return false;
-  return memcmp(continue_target_label, name, len) == 0;
-}
-
-static jsval_t js_labeled_stmt(struct js *js, const char *label, jsoff_t label_len) {
-  uint8_t flags = js->flags;
-  jsval_t res = js_mkundef();
-  
-  if (!label_stack) {
-    utarray_new(label_stack, &label_entry_icd);
-  }
-  
-  uint8_t next_tok = next(js);
-  bool is_loop = (next_tok == TOK_WHILE || next_tok == TOK_DO || next_tok == TOK_FOR);
-  bool is_block = (next_tok == TOK_LBRACE);
-  
-  label_entry_t entry = {
-    .name = label,
-    .name_len = label_len,
-    .is_loop = is_loop,
-    .is_block = is_block || !is_loop
-  };
-  utarray_push_back(label_stack, &entry);
-  
-  if (is_loop && !(flags & F_NOEXEC)) {
-    res = js_stmt_impl(js);
-    
-    if ((js->flags & F_BREAK) && is_break_target(label, label_len)) {
-      js->flags &= ~(F_BREAK | F_NOEXEC);
-      clear_break_label();
-      res = js_mkundef();
-    }
-    
-    if ((label_flags & F_CONTINUE_LABEL) && is_continue_target(label, label_len)) {
-      clear_continue_label();
-    }
-  } else if (is_loop && (flags & F_NOEXEC)) {
-    res = js_stmt_impl(js);
-  } else {
-    res = js_stmt_impl(js);
-    
-    if ((js->flags & F_BREAK) && is_break_target(label, label_len)) {
-      js->flags &= ~(F_BREAK | F_NOEXEC);
-      js->flags |= (flags & F_NOEXEC);
-      clear_break_label();
-      res = js_mkundef();
-    }
-  }
-  
-  if (label_stack && utarray_len(label_stack) > 0) {
-    utarray_pop_back(label_stack);
-  }
-  
-  return res;
-}
-
-static jsval_t js_stmt_impl(struct js *js) {
-  jsval_t res;
-  uint8_t stmt_tok = next(js);
-  
-  switch (stmt_tok) {
-    case TOK_SEMICOLON:
-      res = js_mkundef();
-      break;
-    case TOK_CASE: case TOK_CATCH:
-    case TOK_DEFAULT: case TOK_FINALLY:
-      res = js_mkerr(js, "SyntaxError '%.*s'", (int) js->tlen, js->code + js->toff);
-      break;
-    case TOK_YIELD:
-      res = js_mkerr(js, " '%.*s' not implemented", (int) js->tlen, js->code + js->toff);
-      break;
-    case TOK_IMPORT:    res = js_import_stmt(js); break;
-    case TOK_EXPORT:    res = js_export_stmt(js); break;
-    case TOK_THROW:     js_throw_handle(js, &res); break;
-    case TOK_VAR:       js_var(js, &res); break;
-    case TOK_ASYNC:     js_async(js, &res); break;
-    case TOK_WITH:      res = js_with(js); break;
-    case TOK_SWITCH:    res = js_switch(js); break;
-    case TOK_WHILE:     res = js_while(js); break;
-    case TOK_DO:        res = js_do_while(js); break;
-    case TOK_DEBUGGER:  js->consumed = 1; res = js_mkundef(); break;
-    case TOK_CONTINUE:  res = js_continue(js); break;
-    case TOK_BREAK:     res = js_break(js); break;
-    case TOK_LET:       res = js_let(js); break;
-    case TOK_CONST:     res = js_const(js); break;
-    case TOK_FUNC:      res = js_func_decl(js); break;
-    case TOK_CLASS:     res = js_class_decl(js); break;
-    case TOK_IF:        res = js_if(js); break;
-    case TOK_LBRACE:    res = js_block(js, !(js->flags & F_NOEXEC)); break;
-    case TOK_FOR:       res = js_for(js); break;
-    case TOK_RETURN:    res = js_return(js); break;
-    case TOK_TRY:       res = js_try(js); break;
-    default:
-      res = resolveprop(js, js_expr(js));
-      while (next(js) == TOK_COMMA) {
-        js->consumed = 1;
-        res = resolveprop(js, js_expr(js));
-      }
-      break;
-  }
-  
-  bool is_block_statement = (
-    stmt_tok == TOK_FUNC || stmt_tok == TOK_CLASS || 
-    stmt_tok == TOK_EXPORT || stmt_tok == TOK_IMPORT ||
-    stmt_tok == TOK_IF || stmt_tok == TOK_WHILE || 
-    stmt_tok == TOK_DO || stmt_tok == TOK_FOR || 
-    stmt_tok == TOK_SWITCH || stmt_tok == TOK_TRY || 
-    stmt_tok == TOK_LBRACE || stmt_tok == TOK_ASYNC
-  );
-  
-  if (is_err(res)) return res;
-  
-  if (!is_block_statement) {
-    int next_tok = next(js);
-    bool asi_applies = js->had_newline || next_tok == TOK_EOF || next_tok == TOK_RBRACE;
-    bool missing_semicolon = next_tok != TOK_SEMICOLON && !asi_applies;
-    if (missing_semicolon) return js_mkerr_typed(js, JS_ERR_SYNTAX, "; expected");
-    if (next_tok == TOK_SEMICOLON) js->consumed = 1;
-  }
-  
-  return res;
-}
-
-static jsval_t js_stmt(struct js *js) {
-  uint8_t tok = next(js);
-  
-  if (tok == TOK_IDENTIFIER) {
-    js_parse_state_t saved_state;
-    JS_SAVE_STATE(js, saved_state);
-    jsoff_t saved_toff = js->toff;
-    jsoff_t saved_tlen = js->tlen;
-    
-    const char *potential_label = &js->code[js->toff];
-    jsoff_t potential_label_len = js->tlen;
-    
-    js->consumed = 1;
-    
-    if (next(js) == TOK_COLON) {
-      js->consumed = 1;
-      return js_labeled_stmt(js, potential_label, potential_label_len);
-    }
-    
-    JS_RESTORE_STATE(js, saved_state);
-    js->toff = saved_toff;
-    js->tlen = saved_tlen;
-  }
-  
-  return js_stmt_impl(js);
-}
-
-jsval_t js_symbol_to_string(struct js *js, jsval_t sym) {
-  const char *desc = js_sym_desc(js, sym);
-  if (!desc) return js_mkstr(js, "Symbol()", 8);
-  
-  size_t desc_len = strlen(desc);
-  size_t total = 7 + desc_len + 1;
-  
-  char stack_buf[128];
-  char *buf = (total + 1 <= sizeof(stack_buf)) ? stack_buf : malloc(total + 1);
-  if (!buf) return js_mkerr(js, "out of memory");
-  
-  memcpy(buf, "Symbol(", 7);
-  memcpy(buf + 7, desc, desc_len);
-  buf[7 + desc_len] = ')';
-  buf[total] = '\0';
-  
-  jsval_t result = js_mkstr(js, buf, total);
-  if (buf != stack_buf) free(buf);
-  return result;
-}
-
-static jsval_t builtin_String(struct js *js, jsval_t *args, int nargs) {
-  jsval_t sval;
-  
-  if (nargs == 0) {
-    sval = js_mkstr(js, "", 0);
-  } else if (vtype(args[0]) == T_STR) {
-    sval = args[0];
-  } else if (vtype(args[0]) == T_SYMBOL) {
-    sval = js_symbol_to_string(js, args[0]);
-    if (is_err(sval)) return sval;
-  } else {
-    sval = coerce_to_str(js, args[0]);
-    if (is_err(sval)) return sval;
-  }
-  
-  jsval_t string_proto = js_get_ctor_proto(js, "String", 6);
-  if (is_wrapper_ctor_target(js, js->this_val, string_proto)) {
-    set_slot(js, js->this_val, SLOT_PRIMITIVE, sval);
-    jsoff_t slen;
-    vstr(js, sval, &slen);
-    js_setprop(js, js->this_val, js->length_str, tov((double)slen));
-    js_set_descriptor(js, js->this_val, "length", 6, 0);
-  }
-  return sval;
-}
-
-static jsval_t builtin_Number_isNaN(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkval(T_BOOL, 0);
-  jsval_t arg = args[0];
-  
-  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
-  
-  double val = tod(arg);
-  return mkval(T_BOOL, isnan(val) ? 1 : 0);
-}
-
-static jsval_t builtin_Number_isFinite(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkval(T_BOOL, 0);
-  jsval_t arg = args[0];
-  
-  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
-  
-  double val = tod(arg);
-  return mkval(T_BOOL, isfinite(val) ? 1 : 0);
-}
-
-static jsval_t builtin_global_isNaN(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkval(T_BOOL, 1);
-  double val = js_to_number(js, args[0]);
-  return mkval(T_BOOL, isnan(val) ? 1 : 0);
-}
-
-static jsval_t builtin_global_isFinite(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkval(T_BOOL, 0);
-  double val = js_to_number(js, args[0]);
-  return mkval(T_BOOL, isfinite(val) ? 1 : 0);
-}
-
-static jsval_t builtin_Number_isInteger(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkval(T_BOOL, 0);
-  jsval_t arg = args[0];
-  
-  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
-  
-  double val = tod(arg);
-  if (!isfinite(val)) return mkval(T_BOOL, 0);
-  return mkval(T_BOOL, (val == floor(val)) ? 1 : 0);
-}
-
-static jsval_t builtin_Number_isSafeInteger(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkval(T_BOOL, 0);
-  jsval_t arg = args[0];
-  
-  if (vtype(arg) != T_NUM) return mkval(T_BOOL, 0);
-  
-  double val = tod(arg);
-  if (!isfinite(val)) return mkval(T_BOOL, 0);
-  if (val != floor(val)) return mkval(T_BOOL, 0);
-  
-  return mkval(T_BOOL, (val >= -9007199254740991.0 && val <= 9007199254740991.0) ? 1 : 0);
-}
-
-static jsval_t builtin_Number(struct js *js, jsval_t *args, int nargs) {
-  jsval_t nval = tov(nargs > 0 ? js_to_number(js, args[0]) : 0.0);
-  jsval_t number_proto = js_get_ctor_proto(js, "Number", 6);
-  if (is_wrapper_ctor_target(js, js->this_val, number_proto)) {
-    set_slot(js, js->this_val, SLOT_PRIMITIVE, nval);
-  }
-  return nval;
-}
-
-static jsval_t builtin_Boolean(struct js *js, jsval_t *args, int nargs) {
-  jsval_t bval = mkval(T_BOOL, nargs > 0 && js_truthy(js, args[0]) ? 1 : 0);
-  jsval_t boolean_proto = js_get_ctor_proto(js, "Boolean", 7);
-  if (is_wrapper_ctor_target(js, js->this_val, boolean_proto)) {
-    set_slot(js, js->this_val, SLOT_PRIMITIVE, bval);
-  }
-  return bval;
-}
-
-static jsval_t builtin_Object(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0 || vtype(args[0]) == T_NULL || vtype(args[0]) == T_UNDEF) {
-    jsval_t obj_proto = js_get_ctor_proto(js, "Object", 6);
-    if (is_unboxed_obj(js, js->this_val, obj_proto)) return js->this_val;
-    return js_mkobj(js);
-  }
-  
-  jsval_t arg = args[0];
-  uint8_t t = vtype(arg);
-  
-  if (t == T_OBJ || t == T_ARR || t == T_FUNC) return arg;
-  if (t == T_STR || t == T_NUM || t == T_BOOL || t == T_BIGINT) {
-    jsval_t wrapper = js_mkobj(js);
-    if (is_err(wrapper)) return wrapper;
-    set_slot(js, wrapper, SLOT_PRIMITIVE, arg);
-    jsval_t proto = get_prototype_for_type(js, t);
-    if (vtype(proto) == T_OBJ) set_proto(js, wrapper, proto);
-    return wrapper;
-  }
-  
-  return arg;
-}
-
-static jsval_t js_eval_inherit_strict(struct js *js, const char *buf, size_t len, bool inherit_strict);
-
-static jsval_t builtin_eval(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return js_mkundef();
-  
-  jsval_t code_arg = args[0];
-  if (vtype(code_arg) != T_STR) return code_arg;
-  
-  jsoff_t code_len, code_off = vstr(js, code_arg, &code_len);
-  const char *code_str = (const char *)&js->mem[code_off];
-  
-  js_parse_state_t saved;
-  JS_SAVE_STATE(js, saved);
-  uint8_t saved_flags = js->flags;
-  bool caller_strict = (js->flags & F_STRICT) != 0;
-  
-  jsval_t result = js_eval_inherit_strict(js, code_str, code_len, caller_strict);
-  bool had_throw = (js->flags & F_THROW) != 0;
-  
-  JS_RESTORE_STATE(js, saved);
-  js->flags = saved_flags;
-  
-  if (is_err(result) || had_throw) {
-    js->flags |= F_THROW;
-  }
-  
-  return result;
-}
-
-static jsval_t builtin_Function(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) {
-    jsval_t func_obj = mkobj(js, 0);
-    if (is_err(func_obj)) return func_obj;
-    
-    set_func_code_ptr(js, func_obj, "(){}", 4);
-    set_slot(js, func_obj, SLOT_SCOPE, js_glob(js));
-    
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    jsval_t instance_proto = js_instance_proto_from_new_target(js, func_proto);
-    if (is_object_type(instance_proto)) set_proto(js, func_obj, instance_proto);
-    
-    jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-    jsval_t proto_setup = setup_func_prototype(js, func);
-    
-    if (is_err(proto_setup)) return proto_setup;
-    return func;
-  }
-  
-  size_t total_len = 1;
-  
-  for (int i = 0; i < nargs - 1; i++) {
-    if (vtype(args[i]) != T_STR) {
-      const char *str = js_str(js, args[i]);
-      args[i] = js_mkstr(js, str, strlen(str));
-      if (is_err(args[i])) return args[i];
-    }
-    total_len += vstrlen(js, args[i]);
-    if (i < nargs - 2) total_len += 1;
-  }
-  
-  total_len += 2;
-  
-  jsval_t body = args[nargs - 1];
-  if (vtype(body) != T_STR) {
-    const char *str = js_str(js, body);
-    body = js_mkstr(js, str, strlen(str));
-    if (is_err(body)) return body;
-  }
-  total_len += vstrlen(js, body);
-  total_len += 1;
-  
-  char *code_buf = (char *)malloc(total_len + 1);
-  if (!code_buf) return js_mkerr(js, "oom");
-  size_t pos = 0;
-  
-  code_buf[pos++] = '(';
-  
-  for (int i = 0; i < nargs - 1; i++) {
-    jsoff_t param_len, param_off = vstr(js, args[i], &param_len);
-    memcpy(code_buf + pos, &js->mem[param_off], param_len);
-    pos += param_len;
-    if (i < nargs - 2) {
-      code_buf[pos++] = ',';
-    }
-  }
-  
-  code_buf[pos++] = ')';
-  code_buf[pos++] = '{';
-  
-  jsoff_t body_len, body_off = vstr(js, body, &body_len);
-  memcpy(code_buf + pos, &js->mem[body_off], body_len);
-  pos += body_len;
-  
-  code_buf[pos++] = '}';
-  code_buf[pos] = '\0';
-  
-  bool is_strict_body = is_strict_function_body((const char *)&js->mem[body_off], body_len);
-  if (is_strict_body && nargs > 1) {
-    int i = 0, j;
-    jsoff_t param_len_i, param_off_i;
-    const char *param_i;
-    
-check_param:
-    if (i >= nargs - 1) goto params_done;
-    
-    param_off_i = vstr(js, args[i], &param_len_i);
-    param_i = (const char *)&js->mem[param_off_i];
-    
-    if (is_strict_restricted(param_i, param_len_i)) {
-      free(code_buf);
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "cannot use '%.*s' as parameter name in strict mode", (int)param_len_i, param_i);
-    }
-    
-    j = i + 1;
-    
-check_dup:
-    if (j >= nargs - 1) { i++; goto check_param; }
-    
-    jsoff_t param_len_j, param_off_j = vstr(js, args[j], &param_len_j);
-    const char *param_j = (const char *)&js->mem[param_off_j];
-    
-    if (param_len_i == param_len_j && memcmp(param_i, param_j, param_len_i) == 0) {
-      free(code_buf);
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "duplicate parameter name '%.*s' in strict mode", (int)param_len_i, param_i);
-    }
-    
-    j++;
-    goto check_dup;
-    
-params_done:;
-  }
-
-  jsval_t validate_res = validate_dynamic_function_source(js, code_buf, pos, false);
-  if (is_err(validate_res)) {
-    free(code_buf);
-    return validate_res;
-  }
-
-  jsval_t func_obj = mkobj(js, 0);
-  if (is_err(func_obj)) { free(code_buf); return func_obj; }
-  
-  set_func_code(js, func_obj, code_buf, pos); free(code_buf);
-  set_slot(js, func_obj, SLOT_SCOPE, js_glob(js));
-  
-  jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-  jsval_t instance_proto = js_instance_proto_from_new_target(js, func_proto);
-  if (is_object_type(instance_proto)) set_proto(js, func_obj, instance_proto);
-  
-  jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-  jsval_t proto_setup = setup_func_prototype(js, func);
-  
-  if (is_err(proto_setup)) return proto_setup;
-  return func;
-}
-
-static jsval_t builtin_AsyncFunction(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) {
-    jsval_t func_obj = mkobj(js, 0);
-    if (is_err(func_obj)) return func_obj;
-    
-    set_func_code_ptr(js, func_obj, "(){}", 4);
-    set_slot(js, func_obj, SLOT_SCOPE, js_glob(js));
-    set_slot(js, func_obj, SLOT_ASYNC, js_true);
-    
-    jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-    if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
-    
-    jsval_t func = mkval(T_FUNC, (unsigned long)vdata(func_obj));
-    jsval_t proto_setup = setup_func_prototype(js, func);
-    
-    if (is_err(proto_setup)) return proto_setup;
-    return func;
-  }
-  
-  size_t total_len = 1;
-  
-  for (int i = 0; i < nargs - 1; i++) {
-    if (vtype(args[i]) != T_STR) {
-      const char *str = js_str(js, args[i]);
-      args[i] = js_mkstr(js, str, strlen(str));
-      if (is_err(args[i])) return args[i];
-    }
-    total_len += vstrlen(js, args[i]);
-    if (i < nargs - 2) total_len += 1;
-  }
-  
-  total_len += 2;
-  
-  jsval_t body = args[nargs - 1];
-  if (vtype(body) != T_STR) {
-    const char *str = js_str(js, body);
-    body = js_mkstr(js, str, strlen(str));
-    if (is_err(body)) return body;
-  }
-  total_len += vstrlen(js, body);
-  total_len += 1;
-  
-  char *code_buf = (char *)malloc(total_len + 1);
-  if (!code_buf) return js_mkerr(js, "oom");
-  size_t pos = 0;
-  
-  code_buf[pos++] = '(';
-  
-  for (int i = 0; i < nargs - 1; i++) {
-    jsoff_t param_len, param_off = vstr(js, args[i], &param_len);
-    memcpy(code_buf + pos, &js->mem[param_off], param_len);
-    pos += param_len;
-    if (i < nargs - 2) code_buf[pos++] = ',';
-  }
-  
-  code_buf[pos++] = ')';
-  code_buf[pos++] = '{';
-  
-  jsoff_t body_len, body_off = vstr(js, body, &body_len);
-  memcpy(code_buf + pos, &js->mem[body_off], body_len);
-  pos += body_len;
-  code_buf[pos++] = '}';
-  code_buf[pos] = '\0';
-
-  jsval_t validate_res = validate_dynamic_function_source(js, code_buf, pos, true);
-  if (is_err(validate_res)) {
-    free(code_buf);
-    return validate_res;
-  }
-
-  jsval_t func_obj = mkobj(js, 0);
-  if (is_err(func_obj)) { free(code_buf); return func_obj; }
-  
-  set_func_code(js, func_obj, code_buf, pos);
-  free(code_buf);
-  set_slot(js, func_obj, SLOT_SCOPE, js_glob(js));
-  set_slot(js, func_obj, SLOT_ASYNC, js_true);
-  
-  jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-  if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
-  
-  jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
-  jsval_t proto_setup = setup_func_prototype(js, func);
-  
-  if (is_err(proto_setup)) return proto_setup;
-  return func;
-}
-
-static jsval_t builtin_function_empty(struct js *js, jsval_t *args, int nargs) {
-  (void)js; (void)args; (void)nargs;
-  return js_mkundef();
-}
-
-static jsval_t builtin_function_call(struct js *js, jsval_t *args, int nargs) {
-  jsval_t func = js->this_val;
-  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC) {
-    return js_mkerr(js, "call requires a function");
-  }
-  
-  jsval_t this_arg = (nargs > 0) ? args[0] : js_mkundef();
-  
-  jsval_t *call_args = NULL;
-  int call_nargs = (nargs > 1) ? nargs - 1 : 0;
-  if (call_nargs > 0) {
-    call_args = &args[1];
-  }
-  
-  jsval_t saved_this = js->this_val;
-  push_this(this_arg);
-  js->this_val = this_arg;
-  
-  jsval_t result = call_js_with_args(js, func, call_args, call_nargs);
-  
-  pop_this();
-  js->this_val = saved_this;
-  
-  return result;
-}
-
-static int extract_array_args(struct js *js, jsval_t arr, jsval_t **out_args) {
-  int len = (int) get_array_length(js, arr);
-  if (len <= 0) return 0;
-  
-  jsval_t *args_out = (jsval_t *)ant_calloc(sizeof(jsval_t) * len);
-  if (!args_out) return 0;
-  
-  for (int i = 0; i < len; i++) {
-    args_out[i] = arr_get(js, arr, (jsoff_t)i);
-  }
-  
-  *out_args = args_out;
-  return len;
-}
-
-static jsval_t builtin_function_toString(struct js *js, jsval_t *args, int nargs) {
-  jsval_t func = js->this_val;
-  uint8_t t = vtype(func);
-  
-  if (t != T_FUNC && t != T_CFUNC) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "Function.prototype.toString requires that 'this' be a Function");
-  }
-  
-  if (t == T_CFUNC) return ANT_STRING("function() { [native code] }");
-  
-  jsval_t func_obj = mkval(T_OBJ, vdata(func));
-  jsval_t code_val = get_slot(js, func_obj, SLOT_CODE);
-  jsval_t len_val = get_slot(js, func_obj, SLOT_CODE_LEN);
-  
-  if (vtype(code_val) == T_CFUNC && vtype(len_val) == T_NUM) {
-    const char *code = (const char *)(uintptr_t)vdata(code_val);
-    size_t code_len = (size_t)tod(len_val);
-    
-    if (code && code_len > 0) {
-      jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
-      jsval_t arrow_slot = get_slot(js, func_obj, SLOT_ARROW);
-      
-      bool is_async = (async_slot == js_true);
-      bool is_arrow = (arrow_slot == js_true);
-      
-      if (is_arrow) {
-        const char *paren_end = memchr(code, ')', code_len);
-        if (!paren_end) goto fallback_arrow;
-        
-        size_t params_len = paren_end - code + 1;
-        const char *body = paren_end + 1;
-        size_t body_len = code_len - params_len;
-        
-        size_t len = (is_async ? 6 : 0) + params_len + 4 + body_len + 1;
-        char *buf = ant_calloc(len);
-        size_t n = 0;
-        
-        if (is_async) n += cpy(buf + n, REMAIN(n, len), "async ", 6);
-        n += cpy(buf + n, REMAIN(n, len), code, params_len);
-        n += cpy(buf + n, REMAIN(n, len), " => ", 4);
-        n += cpy(buf + n, REMAIN(n, len), body, body_len);
-        
-        jsval_t result = js_mkstr(js, buf, n);
-        free(buf);
-        return result;
-        fallback_arrow:;
-      }
-      
-      jsoff_t name_len = 0;
-      const char *name = get_func_name(js, func, &name_len);
-      size_t total = (is_async ? 6 : 0) + 9 + name_len + code_len + 1;
-      char *buf = ant_calloc(total + 1);
-      size_t n = 0;
-      
-      if (is_async) n += cpy(buf + n, total - n, "async ", 6);
-      n += cpy(buf + n, total - n, "function ", 9);
-      if (name && name_len > 0) n += cpy(buf + n, total - n, name, name_len);
-      n += cpy(buf + n, total - n, code, code_len);
-      n += cpy(buf + n, total - n, "}", 1);
-      
-      jsval_t result = js_mkstr(js, buf, n);
-      free(buf);
-      
-      return result;
-    }
-  }
-  
-  char buf[256];
-  size_t len = strfunc(js, func, buf, sizeof(buf));
-  return js_mkstr(js, buf, len);
-}
-
-static jsval_t builtin_function_apply(struct js *js, jsval_t *args, int nargs) {
-  jsval_t func = js->this_val;
-  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "Function.prototype.apply requires that 'this' be a Function");
-  }
-  
-  jsval_t this_arg = (nargs > 0) ? args[0] : js_mkundef();
-  jsval_t *call_args = NULL;
-  int call_nargs = 0;
-  
-  if (nargs > 1) {
-    jsval_t arg_array = args[1];
-    uint8_t t = vtype(arg_array);
-    if (t == T_ARR || t == T_OBJ) {
-      call_nargs = extract_array_args(js, arg_array, &call_args);
-    } else if (t != T_UNDEF && t != T_NULL) {}
-  }
-  
-  jsval_t saved_this = js->this_val;
-  push_this(this_arg);
-  
-  js->this_val = this_arg;
-  jsval_t result = call_js_with_args(js, func, call_args, call_nargs);
-
-  pop_this();
-  js->this_val = saved_this;
-
-  if (call_args) free(call_args);
-
-  return result;
-}
-
-static jsval_t builtin_function_bind(struct js *js, jsval_t *args, int nargs) {
-  jsval_t func = js->this_val;
-  
-  if (vtype(func) != T_FUNC && vtype(func) != T_CFUNC) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "bind requires a function");
-  }
-
-  jsval_t this_arg = (nargs > 0) ? args[0] : js_mkundef();
-  
-  int bound_argc = (nargs > 1) ? nargs - 1 : 0;
-  jsval_t *bound_args = (bound_argc > 0) ? &args[1] : NULL;
-  
-  int orig_length = 0;
-  jsval_t target_func_obj;
-  if (vtype(func) == T_CFUNC) {
-    orig_length = 0;
-  } else {
-    target_func_obj = mkval(T_OBJ, vdata(func));
-    jsoff_t len_off = lkp_interned(js, target_func_obj, INTERN_LENGTH, 6);
-    if (len_off != 0) {
-      jsval_t len_val = resolveprop(js, mkval(T_PROP, len_off));
-      if (vtype(len_val) == T_NUM) {
-        orig_length = (int) tod(len_val);
-      }
-    }
-  }
-  
-  int bound_length = orig_length - bound_argc;
-  if (bound_length < 0) bound_length = 0;
-
-  if (vtype(func) == T_CFUNC) {
-    jsval_t bound_func = mkobj(js, 0);
-    if (is_err(bound_func)) return bound_func;
-    
-    set_slot(js, bound_func, SLOT_CFUNC, func);
-    set_slot(js, bound_func, SLOT_BOUND_THIS, this_arg);
-    
-    if (bound_argc > 0) {
-      jsval_t bound_arr = mkarr(js);
-      for (int i = 0; i < bound_argc; i++) arr_set(js, bound_arr, (jsoff_t)i, bound_args[i]);
-      set_slot(js, bound_func, SLOT_BOUND_ARGS, bound_arr);
-    }
-    
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    if (vtype(func_proto) == T_FUNC) set_proto(js, bound_func, func_proto);
-    
-    jsval_t bound = mkval(T_FUNC, (unsigned long) vdata(bound_func));
-    js_setprop(js, bound_func, js->length_str, tov((double) bound_length));
-    
-    jsval_t proto_setup = setup_func_prototype(js, bound);
-    if (is_err(proto_setup)) return proto_setup;
-    
-    return bound;
-  }
-
-  jsval_t func_obj = mkval(T_OBJ, vdata(func));
-  jsval_t bound_func = mkobj(js, 0);
-  if (is_err(bound_func)) return bound_func;
-
-  jsval_t code_val = get_slot(js, func_obj, SLOT_CODE);
-  if (vtype(code_val) == T_STR || vtype(code_val) == T_CFUNC) {
-    set_slot(js, bound_func, SLOT_CODE, code_val);
-    set_slot(js, bound_func, SLOT_CODE_LEN, get_slot(js, func_obj, SLOT_CODE_LEN));
-  }
-
-  jsval_t cfunc_slot = get_slot(js, func_obj, SLOT_CFUNC);
-  if (vtype(cfunc_slot) == T_CFUNC) {
-    set_slot(js, bound_func, SLOT_CFUNC, cfunc_slot);
-  }
-
-  jsval_t scope_slot = get_slot(js, func_obj, SLOT_SCOPE);
-  if (vtype(scope_slot) != T_UNDEF) {
-    set_slot(js, bound_func, SLOT_SCOPE, scope_slot);
-  }
-
-  jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
-  if (vtype(async_slot) == T_BOOL && vdata(async_slot) == 1) {
-    set_slot(js, bound_func, SLOT_ASYNC, js_true);
-  }
-
-  jsval_t target_proto = get_proto(js, func);
-  if (is_object_type(target_proto)) {
-    set_proto(js, bound_func, target_proto);
-  } else if (vtype(async_slot) == T_BOOL && vdata(async_slot) == 1) {
-    jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
-    if (vtype(async_proto) == T_FUNC) set_proto(js, bound_func, async_proto);
-  } else {
-    jsval_t func_proto = get_slot(js, js_glob(js), SLOT_FUNC_PROTO);
-    if (vtype(func_proto) == T_FUNC) set_proto(js, bound_func, func_proto);
-  }
-
-  jsval_t data_slot = get_slot(js, func_obj, SLOT_DATA);
-  if (vtype(data_slot) != T_UNDEF) {
-    set_slot(js, bound_func, SLOT_DATA, data_slot);
-  }
-
-  set_slot(js, bound_func, SLOT_TARGET_FUNC, func);
-  set_slot(js, bound_func, SLOT_BOUND_THIS, this_arg);
-  
-  if (bound_argc > 0) {
-    jsval_t bound_arr = mkarr(js);
-    for (int i = 0; i < bound_argc; i++) arr_set(js, bound_arr, (jsoff_t)i, bound_args[i]);
-    set_slot(js, bound_func, SLOT_BOUND_ARGS, bound_arr);
-  }
-  
-  js_setprop(js, bound_func, js->length_str, tov((double) bound_length));
-  
-  jsval_t bound = mkval(T_FUNC, (unsigned long) vdata(bound_func));  
-  jsval_t proto_setup = setup_func_prototype(js, bound);
-  if (is_err(proto_setup)) return proto_setup;
-  
-  return bound;
-}
-
-static jsval_t builtin_Array(struct js *js, jsval_t *args, int nargs) {
-  jsval_t arr = mkarr(js);
-  if (is_err(arr)) return arr;
-  
-  if (nargs == 1 && vtype(args[0]) == T_NUM) {
-    jsval_t err = validate_array_length(js, args[0]);
-    if (is_err(err)) return err;
-    jsoff_t new_len = (jsoff_t)tod(args[0]);
-    jsoff_t doff = get_dense_buf(js, arr);
-    if (doff && new_len <= 1024) {
-      if (new_len > dense_capacity(js, doff)) doff = dense_grow(js, arr, new_len);
-      if (doff) dense_set_length(js, doff, new_len);
-    }
-    update_array_length(js, arr, new_len);
-  } else if (nargs > 0) {
-    for (int i = 0; i < nargs; i++) arr_set(js, arr, (jsoff_t)i, args[i]);
-  }
-
-  jsval_t array_proto = get_ctor_proto(js, "Array", 5);
-  jsval_t instance_proto = js_instance_proto_from_new_target(js, array_proto);
-  
-  if (is_object_type(instance_proto)) set_proto(js, arr, instance_proto);
-  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    set_slot(js, arr, SLOT_CTOR, js->new_target);
-  }
-  
-  return arr;
-}
-
-static jsval_t builtin_Error(struct js *js, jsval_t *args, int nargs) {
-  bool is_new = (vtype(js->new_target) != T_UNDEF);
-  jsval_t this_val = js->this_val;
-  
-  jsval_t target = is_new ? js->new_target : js->current_func;
-  jsval_t name = ANT_STRING("Error");
-  
-  if (vtype(target) == T_FUNC) {
-    jsoff_t off = lkp(js, mkval(T_OBJ, vdata(target)), "name", 4);
-    if (off) name = resolveprop(js, mkval(T_PROP, off));
-  }
-
-  if (!is_new) {
-    this_val = js_mkobj(js);
-    jsoff_t proto_off = lkp_interned(js, mkval(T_OBJ, vdata(js->current_func)), INTERN_PROTOTYPE, 9);
-    if (proto_off) set_proto(js, this_val, resolveprop(js, mkval(T_PROP, proto_off)));
-    else set_proto(js, this_val, get_ctor_proto(js, "Error", 5));
-  }
-  
-  if (nargs > 0) {
-    jsval_t msg = args[0];
-    if (vtype(msg) != T_STR) {
-      const char *str = js_str(js, msg);
-      msg = js_mkstr(js, str, strlen(str));
-    }
-    js_mkprop_fast(js, this_val, "message", 7, msg);
-  }
-  
-  js_mkprop_fast(js, this_val, "name", 4, name);
-  set_slot(js, this_val, SLOT_ERROR_BRAND, js_true);
-  
-  return this_val;
-}
-
-static jsval_t builtin_Error_toString(struct js *js, jsval_t *args, int nargs) {
-  jsval_t this_val = js_getthis(js);
-  
-  jsval_t name = js_get(js, this_val, "name");
-  if (vtype(name) == T_UNDEF) name = js_mkstr(js, "Error", 5);
-  else if (vtype(name) != T_STR) {
-    const char *s = js_str(js, name);
-    name = js_mkstr(js, s, strlen(s));
-  }
-  
-  jsval_t msg = js_get(js, this_val, "message");
-  if (vtype(msg) == T_UNDEF) msg = js_mkstr(js, "", 0);
-  else if (vtype(msg) != T_STR) {
-    const char *s = js_str(js, msg);
-    msg = js_mkstr(js, s, strlen(s));
-  }
-  
-  jsoff_t name_len, msg_len;
-  jsoff_t name_off = vstr(js, name, &name_len);
-  jsoff_t msg_off = vstr(js, msg, &msg_len);
-  
-  const char *name_str = (const char *)&js->mem[name_off];
-  const char *msg_str = (const char *)&js->mem[msg_off];
-  
-  if (name_len == 0) return msg;
-  if (msg_len == 0) return name;
-  
-  size_t total = name_len + 2 + msg_len;
-  char *buf = malloc(total + 1);
-  if (!buf) return js_mkerr(js, "out of memory");
-  
-  memcpy(buf, name_str, name_len);
-  buf[name_len] = ':'; buf[name_len + 1] = ' ';
-  memcpy(buf + name_len + 2, msg_str, msg_len);
-  buf[total] = '\0';
-  
-  jsval_t result = js_mkstr(js, buf, total);
-  free(buf); return result;
-}
-
-static jsval_t builtin_AggregateError(struct js *js, jsval_t *args, int nargs) {
-  bool is_new = (vtype(js->new_target) != T_UNDEF);
-  jsval_t this_val = js->this_val;
-  
-  if (!is_new) {
-    this_val = js_mkobj(js);
-    jsoff_t proto_off = lkp_interned(js, mkval(T_OBJ, vdata(js->current_func)), INTERN_PROTOTYPE, 9);
-    if (proto_off) set_proto(js, this_val, resolveprop(js, mkval(T_PROP, proto_off)));
-    else set_proto(js, this_val, get_ctor_proto(js, "AggregateError", 14));
-  }
-  
-  jsval_t errors = nargs > 0 ? args[0] : mkarr(js);
-  if (vtype(errors) != T_ARR) errors = mkarr(js);
-  js_mkprop_fast(js, this_val, "errors", 6, errors);
-  
-  if (nargs > 1 && vtype(args[1]) != T_UNDEF) {
-    jsval_t msg = args[1];
-    if (vtype(msg) != T_STR) {
-      const char *str = js_str(js, msg);
-      msg = js_mkstr(js, str, strlen(str));
-    }
-    js_mkprop_fast(js, this_val, "message", 7, msg);
-  }
-  
-  js_mkprop_fast(js, this_val, "name", 4, ANT_STRING("AggregateError"));
-  set_slot(js, this_val, SLOT_ERROR_BRAND, js_true);
-  
-  return this_val;
-}
-
-static jsval_t builtin_RegExp(struct js *js, jsval_t *args, int nargs) {
-  bool pattern_is_regexp = false;
-  if (nargs > 0) {
-    jsval_t is_re = is_regexp_like(js, args[0]);
-    if (is_err(is_re)) return is_re;
-    pattern_is_regexp = js_truthy(js, is_re);
-  }
-
-  if (vtype(js->new_target) == T_UNDEF && nargs > 0 && pattern_is_regexp) {
-    if (nargs < 2 || vtype(args[1]) == T_UNDEF) {
-      jsval_t ctor = js_getprop_fallback(js, args[0], "constructor");
-      if (is_err(ctor)) return ctor;
-      jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
-      if (is_err(regexp_ctor)) return regexp_ctor;
-      if (same_ctor_identity(js, ctor, regexp_ctor)) return args[0];
-    }
-  }
-
-  jsval_t regexp_obj = js->this_val;
-  bool use_this = (vtype(js->new_target) != T_UNDEF && vtype(regexp_obj) == T_OBJ);
-  
-  if (!use_this) {
-    regexp_obj = mkobj(js, 0);
-    if (is_err(regexp_obj)) return regexp_obj;
-  }
-  
-  jsval_t regexp_proto = get_ctor_proto(js, "RegExp", 6);
-  jsval_t instance_proto = js_instance_proto_from_new_target(js, regexp_proto);
-  
-  if (is_object_type(instance_proto)) set_proto(js, regexp_obj, instance_proto);
-  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    set_slot(js, regexp_obj, SLOT_CTOR, js->new_target);
-  }
-
-  jsval_t pattern = js_mkstr(js, "", 0);
-  jsval_t flags = js_mkstr(js, "", 0);
-  if (nargs > 0) {
-    if (pattern_is_regexp) {
-      jsval_t src = js_getprop_fallback(js, args[0], "source");
-      if (is_err(src)) return src;
-      pattern = js_tostring_val(js, src);
-      if (is_err(pattern)) return pattern;
-      if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
-        flags = js_tostring_val(js, args[1]);
-      } else {
-        jsval_t fl = js_getprop_fallback(js, args[0], "flags");
-        if (is_err(fl)) return fl;
-        flags = js_tostring_val(js, fl);
-      }
-      if (is_err(flags)) return flags;
-    } else if (vtype(args[0]) == T_STR) {
-      pattern = args[0];
-      if (nargs > 1 && vtype(args[1]) == T_STR) flags = args[1];
-    } else if (vtype(args[0]) != T_UNDEF) {
-      jsval_t s = js_tostring_val(js, args[0]);
-      if (is_err(s)) return s;
-      pattern = s;
-      if (nargs > 1 && vtype(args[1]) == T_STR) flags = args[1];
-    }
-  }
-  
-  js_setprop(js, regexp_obj, js_mkstr(js, "source", 6), pattern);
-  jsoff_t flags_len, flags_off = vstr(js, flags, &flags_len);
-  regexp_init_flags(js, regexp_obj, (const char *)&js->mem[flags_off], flags_len);
-
-  return regexp_obj;
-}
-
-static jsval_t builtin_regexp_exec(struct js *js, jsval_t *args, int nargs) {
-  jsval_t regexp = js->this_val;
-  if (vtype(regexp) != T_OBJ) return js_mkerr(js, "exec called on non-regexp");
-  if (nargs < 1) return js_mknull();
-
-  jsval_t str_arg = args[0];
-  if (vtype(str_arg) != T_STR) return js_mknull();
-
-  jsoff_t source_off = lkp(js, regexp, "source", 6);
-  if (source_off == 0) return js_mknull();
-  jsval_t source_val = resolveprop(js, mkval(T_PROP, source_off));
-  if (vtype(source_val) != T_STR) return js_mknull();
-
-  jsoff_t plen, poff = vstr(js, source_val, &plen);
-  const char *pattern_ptr = (char *) &js->mem[poff];
-
-  bool ignore_case = false, multiline = false, global_flag = false;
-  jsoff_t flags_off = lkp(js, regexp, "flags", 5);
-  if (flags_off != 0) {
-    jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
-    if (vtype(flags_val) == T_STR) {
-      jsoff_t flen, foff = vstr(js, flags_val, &flen);
-      const char *flags_str = (char *) &js->mem[foff];
-      for (jsoff_t i = 0; i < flen; i++) {
-        if (flags_str[i] == 'i') ignore_case = true;
-        if (flags_str[i] == 'm') multiline = true;
-        if (flags_str[i] == 'g') global_flag = true;
-      }
-    }
-  }
-
-  jsoff_t str_len, str_off = vstr(js, str_arg, &str_len);
-  const char *str_ptr = (char *) &js->mem[str_off];
-
-  PCRE2_SIZE start_offset = 0;
-  if (global_flag) {
-    jsoff_t lastindex_off = lkp(js, regexp, "lastIndex", 9);
-    if (lastindex_off != 0) {
-      jsval_t li_val = resolveprop(js, mkval(T_PROP, lastindex_off));
-      if (vtype(li_val) == T_NUM) {
-        double li = tod(li_val);
-        if (li >= 0 && li <= D(str_len)) start_offset = (PCRE2_SIZE)li;
-      }
-    }
-  }
-
-  char pcre2_pattern[512];
-  size_t pcre2_len = js_to_pcre2_pattern(pattern_ptr, plen, pcre2_pattern, sizeof(pcre2_pattern));
-
-  uint32_t options = PCRE2_UTF | PCRE2_UCP | PCRE2_MATCH_UNSET_BACKREF;
-  if (ignore_case) options |= PCRE2_CASELESS;
-  if (multiline) options |= PCRE2_MULTILINE;
-
-  int errcode;
-  PCRE2_SIZE erroffset;
-  pcre2_code *re = pcre2_compile((PCRE2_SPTR)pcre2_pattern, pcre2_len, options, &errcode, &erroffset, NULL);
-  if (re == NULL) return js_mknull();
-
-  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
-  int rc = pcre2_match(re, (PCRE2_SPTR)str_ptr, str_len, start_offset, 0, match_data, NULL);
-
-  if (rc < 0) {
-    pcre2_match_data_free(match_data);
-    pcre2_code_free(re);
-    if (global_flag) {
-      js_setprop(js, regexp, js_mkstr(js, "lastIndex", 9), tov(0));
-    }
-    return js_mknull();
-  }
-
-  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
-  uint32_t ovcount = pcre2_get_ovector_count(match_data);
-
-  jsval_t result_arr = js_mkarr(js);
-  for (uint32_t i = 0; i < ovcount && i < 32; i++) {
-    PCRE2_SIZE start = ovector[2*i];
-    PCRE2_SIZE end = ovector[2*i+1];
-    if (start == PCRE2_UNSET) {
-      js_arr_push(js, result_arr, js_mkundef());
-    } else {
-      jsval_t match_str = js_mkstr(js, str_ptr + start, end - start);
-      js_arr_push(js, result_arr, match_str);
-    }
-  }
-
-  js_setprop(js, result_arr, js_mkstr(js, "index", 5), tov((double)ovector[0]));
-  js_setprop(js, result_arr, js_mkstr(js, "input", 5), str_arg);
-
-  if (global_flag) {
-    PCRE2_SIZE new_lastindex = ovector[1];
-    if (ovector[0] == ovector[1]) new_lastindex++;
-    js_setprop(js, regexp, js_mkstr(js, "lastIndex", 9), tov((double)new_lastindex));
-  }
-
-  pcre2_match_data_free(match_data);
-  pcre2_code_free(re);
-  return result_arr;
-}
-
-static jsval_t builtin_regexp_toString(struct js *js, jsval_t *args, int nargs) {
-  jsval_t regexp = js->this_val;
-  if (!is_object_type(regexp))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "toString called on non-object");
-
-  jsval_t source_val = js_getprop_fallback(js, regexp, "source");
-  if (is_err(source_val)) return source_val;
-  jsval_t source_str = js_tostring_val(js, source_val);
-  if (is_err(source_str)) return source_str;
-
-  jsval_t flags_val = js_getprop_fallback(js, regexp, "flags");
-  if (is_err(flags_val)) return flags_val;
-  jsval_t flags_str = js_tostring_val(js, flags_val);
-  if (is_err(flags_str)) return flags_str;
-
-  jsoff_t src_len, src_off = vstr(js, source_str, &src_len);
-  jsoff_t fl_len, fl_off = vstr(js, flags_str, &fl_len);
-
-  char static_buf[128];
-  string_builder_t sb;
-  string_builder_init(&sb, static_buf, sizeof(static_buf));
-  string_builder_append(&sb, "/", 1);
-  string_builder_append(&sb, (const char *)&js->mem[src_off], src_len);
-  string_builder_append(&sb, "/", 1);
-  string_builder_append(&sb, (const char *)&js->mem[fl_off], fl_len);
-  
-  return string_builder_finalize(js, &sb);
-}
-
-static jsval_t maybe_call_symbol_method(
-  struct js *js, jsval_t target,
-  const char *symbol_key,
-  jsval_t this_arg, jsval_t *args,
-  int nargs, bool *called
-) {
-  *called = false;
-  if (!symbol_key || !symbol_key[0] || !is_object_type(target)) return js_mkundef();
-
-  jsval_t method = js_get(js, target, symbol_key);
-  if (is_err(method)) return method;
-
-  uint8_t mt = vtype(method);
-  if (mt == T_UNDEF || mt == T_NULL) return js_mkundef();
-  if (mt != T_FUNC && mt != T_CFUNC) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol method is not callable");
-  }
-
-  *called = true;
-  return js_call_with_this(js, method, this_arg, args, nargs);
-}
-
-static jsval_t is_regexp_like(struct js *js, jsval_t value) {
-  if (!is_object_type(value)) return js_false;
-
-  const char *match_key = get_match_sym_key();
-  if (match_key && match_key[0]) {
-    jsval_t match_val = js_get(js, value, match_key);
-    if (is_err(match_val)) return match_val;
-    if (vtype(match_val) != T_UNDEF) return js_bool(js_truthy(js, match_val));
-  }
-
-  jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
-  if (is_err(regexp_ctor)) return regexp_ctor;
-  
-  jsval_t regexp_proto = js_get(js, regexp_ctor, "prototype");
-  if (is_err(regexp_proto)) return regexp_proto;
-  if (!is_object_type(regexp_proto)) return js_false;
-  
-  return js_bool(proto_chain_contains(js, value, regexp_proto));
-}
-
-static jsval_t should_regexp_passthrough(struct js *js, jsval_t *args, int nargs) {
-  if (vtype(js->new_target) != T_UNDEF) return js_false;
-  if (nargs <= 0) return js_false;
-  
-  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) return js_false;
-  if (!is_object_type(args[0])) return js_false;
-
-  jsval_t is_re = is_regexp_like(js, args[0]);
-  if (is_err(is_re)) return is_re;
-  if (!js_truthy(js, is_re)) return js_false;
-
-  jsval_t ctor = js_getprop_fallback(js, args[0], "constructor");
-  if (is_err(ctor)) return ctor;
-  
-  jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
-  if (is_err(regexp_ctor)) return regexp_ctor;
-
-  return js_bool(same_ctor_identity(js, ctor, regexp_ctor));
-}
-
-static jsval_t reject_regexp_arg(struct js *js, jsval_t value, const char *method_name) {
-  jsval_t is_re = is_regexp_like(js, value);
-  if (is_err(is_re)) return is_re;
-  if (js_truthy(js, is_re)) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "First argument to %s must not be a RegExp", method_name);
-  }
-  return js_mkundef();
-}
-
-static jsval_t regexp_species_construct(struct js *js, jsval_t rx, jsval_t ctor, jsval_t *ctor_args, int nargs) {
-  jsval_t seed = js_mkobj(js);
-  if (is_err(seed)) return seed;
-
-  jsval_t proto = js_get(js, ctor, "prototype");
-  if (is_err(proto)) return proto;
-  if (is_object_type(proto)) set_proto(js, seed, proto);
-
-  jsval_t saved = js->new_target;
-  js->new_target = ctor;
-  jsval_t result = js_call_with_this(js, ctor, seed, ctor_args, nargs);
-  js->new_target = saved;
-  
-  if (is_err(result)) return result;
-  if (!is_object_type(result)) 
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp species constructor returned non-object");
-  
-  return result;
-}
-
-static jsval_t regexp_exec_abstract(struct js *js, jsval_t rx, jsval_t str) {
-  jsval_t exec_fn = js_get(js, rx, "exec");
-  if (is_err(exec_fn)) return exec_fn;
-
-  if (vtype(exec_fn) == T_FUNC || vtype(exec_fn) == T_CFUNC) {
-    jsval_t call_args[1] = { str };
-    jsval_t result = js_call_with_this(js, exec_fn, rx, call_args, 1);
-    if (is_err(result)) return result;
-    if (!is_object_type(result) && vtype(result) != T_NULL) 
-      return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp exec returned non-object");
-    return result;
-  }
-
-  jsval_t call_args[1] = { str };
-  jsval_t saved = js->this_val;
-  js->this_val = rx;
-  jsval_t result = builtin_regexp_exec(js, call_args, 1);
-  js->this_val = saved;
-  
-  return result;
-}
-
-static jsval_t builtin_regexp_test(struct js *js, jsval_t *args, int nargs) {
-  jsval_t regexp = js->this_val;
-  if (!is_object_type(regexp))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "test called on non-object");
-  jsval_t str_arg = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
-  if (is_err(str_arg)) return str_arg;
-  jsval_t result = regexp_exec_abstract(js, regexp, str_arg);
-  if (is_err(result)) return result;
-  return mkval(T_BOOL, vtype(result) != T_NULL ? 1 : 0);
-}
-
-jsval_t builtin_regexp_flags_getter(struct js *js, jsval_t *args, int nargs) {
-  jsval_t rx = js->this_val;
-  if (!is_object_type(rx))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype.flags called on non-object");
-
-  char static_buf[16]; string_builder_t sb;
-  string_builder_init(&sb, static_buf, sizeof(static_buf));
-
-  static const struct { const char *name; size_t len; char flag; } flag_props[] = {
-    {"hasIndices", 10, 'd'}, {"global", 6, 'g'}, {"ignoreCase", 10, 'i'},
-    {"multiline", 9, 'm'}, {"dotAll", 6, 's'}, {"unicode", 7, 'u'},
-    {"unicodeSets", 11, 'v'}, {"sticky", 6, 'y'},
-  };
-
-  for (int i = 0; i < 8; i++) {
-    jsval_t v = js_getprop_fallback(js, rx, flag_props[i].name);
-    if (is_err(v)) { if (sb.is_dynamic) free(sb.buffer); return v; }
-    if (js_truthy(js, v)) string_builder_append(&sb, &flag_props[i].flag, 1);
-  }
-
-  return string_builder_finalize(js, &sb);
-}
-
-jsval_t builtin_regexp_symbol_match(struct js *js, jsval_t *args, int nargs) {
-  jsval_t rx = js->this_val;
-  if (!is_object_type(rx))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@match] called on non-object");
-
-  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
-  if (is_err(str)) return str;
-
-  jsval_t global_val = js_getprop_fallback(js, rx, "global");
-  if (is_err(global_val)) return global_val;
-
-  if (!js_truthy(js, global_val))
-    return regexp_exec_abstract(js, rx, str);
-
-  jsval_t unicode_val = js_getprop_fallback(js, rx, "unicode");
-  if (is_err(unicode_val)) return unicode_val;
-  
-  bool full_unicode = js_truthy(js, unicode_val);
-  js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(0));
-
-  jsval_t A = mkarr(js);
-  if (is_err(A)) return A;
-  jsoff_t n = 0;
-
-  for (;;) {
-    jsval_t result = regexp_exec_abstract(js, rx, str);
-    if (is_err(result)) return result;
-    if (vtype(result) == T_NULL) return n == 0 ? js_mknull() : mkval(T_ARR, vdata(A));
-
-    jsval_t match_str = js_tostring_val(js, arr_get(js, result, 0));
-    if (is_err(match_str)) return match_str;
-    arr_set(js, A, n++, match_str);
-
-    jsoff_t mlen;
-    vstr(js, match_str, &mlen);
-    if (mlen == 0) {
-      jsval_t li_val = js_getprop_fallback(js, rx, "lastIndex");
-      if (is_err(li_val)) return li_val;
-      double li = vtype(li_val) == T_NUM ? tod(li_val) : 0;
-      jsoff_t str_len, str_off = vstr(js, str, &str_len);
-      double advance = 1;
-      if (full_unicode && li < (double)str_len) {
-        advance = (double)utf8_char_len_at((const char *)&js->mem[str_off], str_len, (jsoff_t)li);
-      } js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(li + advance));
-    }
-  }
-}
-
-jsval_t builtin_regexp_symbol_replace(struct js *js, jsval_t *args, int nargs) {
-  jsval_t rx = js->this_val;
-  if (!is_object_type(rx))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@replace] called on non-object");
-
-  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
-  if (is_err(str)) return str;
-  jsval_t replace_value = nargs > 1 ? args[1] : js_mkundef();
-  bool func_replace = (vtype(replace_value) == T_FUNC || vtype(replace_value) == T_CFUNC);
-  jsval_t replace_str = js_mkundef();
-  if (!func_replace) {
-    replace_str = js_tostring_val(js, replace_value);
-    if (is_err(replace_str)) return replace_str;
-  }
-
-  jsval_t global_val = js_getprop_fallback(js, rx, "global");
-  if (is_err(global_val)) return global_val;
-  bool global = js_truthy(js, global_val);
-
-  bool full_unicode = false;
-  if (global) {
-    jsval_t unicode_val = js_getprop_fallback(js, rx, "unicode");
-    if (is_err(unicode_val)) return unicode_val;
-    full_unicode = js_truthy(js, unicode_val);
-    js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(0));
-  }
-
-  jsval_t results = mkarr(js);
-  if (is_err(results)) return results;
-  jsoff_t nresults = 0;
-
-  for (;;) {
-    jsval_t result = regexp_exec_abstract(js, rx, str);
-    if (is_err(result)) return result;
-    if (vtype(result) == T_NULL) break;
-    arr_set(js, results, nresults++, result);
-    if (!global) break;
-
-    jsval_t match_str = js_tostring_val(js, arr_get(js, result, 0));
-    if (is_err(match_str)) return match_str;
-    jsoff_t mlen; vstr(js, match_str, &mlen);
-    if (mlen == 0) {
-      jsval_t li_val = js_getprop_fallback(js, rx, "lastIndex");
-      if (is_err(li_val)) return li_val;
-      double li = vtype(li_val) == T_NUM ? tod(li_val) : 0;
-      jsoff_t sl, so = vstr(js, str, &sl);
-      double advance = 1;
-      if (full_unicode && li < (double)sl) {
-        advance = (double)utf8_char_len_at((const char *)&js->mem[so], sl, (jsoff_t)li);
-      }
-      js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(li + advance));
-    }
-  }
-
-  jsoff_t str_len, str_off = vstr(js, str, &str_len);
-  char static_buf[256];
-  string_builder_t sb;
-  string_builder_init(&sb, static_buf, sizeof(static_buf));
-  jsoff_t next_src_pos = 0;
-
-  for (jsoff_t i = 0; i < nresults; i++) {
-    jsval_t result = arr_get(js, results, i);
-    jsval_t matched = js_tostring_val(js, arr_get(js, result, 0));
-    if (is_err(matched)) { if (sb.is_dynamic) free(sb.buffer); return matched; }
-    jsoff_t matched_len; vstr(js, matched, &matched_len);
-
-    jsval_t pos_val = js_getprop_fallback(js, result, "index");
-    jsoff_t position = 0;
-    if (!is_err(pos_val) && vtype(pos_val) == T_NUM) {
-      double d = tod(pos_val);
-      position = d < 0 ? 0 : (jsoff_t)d;
-    }
-    if (position > str_len) position = str_len;
-
-    jsval_t replacement;
-    if (func_replace) {
-      jsoff_t ncaptures = get_array_length(js, result);
-      jsval_t call_args[32];
-      int ca = 0;
-      for (jsoff_t c = 0; c < ncaptures && ca < 30; c++)
-        call_args[ca++] = arr_get(js, result, c);
-      call_args[ca++] = tov((double)position);
-      call_args[ca++] = str;
-      replacement = js_call_with_this(js, replace_value, js_mkundef(), call_args, ca);
-    } else {
-      replacement = replace_str;
-    }
-    if (is_err(replacement)) { if (sb.is_dynamic) free(sb.buffer); return replacement; }
-    jsval_t rep_str = js_tostring_val(js, replacement);
-    if (is_err(rep_str)) { if (sb.is_dynamic) free(sb.buffer); return rep_str; }
-
-    if (position >= next_src_pos) {
-      str_off = vstr(js, str, &str_len);
-      if (position > next_src_pos)
-        string_builder_append(&sb, (const char *)&js->mem[str_off + next_src_pos], position - next_src_pos);
-      jsoff_t rep_len, rep_off = vstr(js, rep_str, &rep_len);
-      string_builder_append(&sb, (const char *)&js->mem[rep_off], rep_len);
-      next_src_pos = position + matched_len;
-    }
-  }
-
-  str_off = vstr(js, str, &str_len);
-  if (next_src_pos < str_len)
-    string_builder_append(&sb, (const char *)&js->mem[str_off + next_src_pos], str_len - next_src_pos);
-
-  return string_builder_finalize(js, &sb);
-}
-
-jsval_t builtin_regexp_symbol_search(struct js *js, jsval_t *args, int nargs) {
-  jsval_t rx = js->this_val;
-  if (!is_object_type(rx))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@search] called on non-object");
-
-  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
-  if (is_err(str)) return str;
-
-  jsval_t prev_li = js_getprop_fallback(js, rx, "lastIndex");
-  if (is_err(prev_li)) return prev_li;
-  js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(0));
-
-  jsval_t result = regexp_exec_abstract(js, rx, str);
-  if (is_err(result)) return result;
-
-  jsval_t cur_li = js_getprop_fallback(js, rx, "lastIndex");
-  if (is_err(cur_li)) return cur_li;
-  js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), prev_li);
-
-  if (vtype(result) == T_NULL) return tov(-1);
-
-  jsval_t idx = js_getprop_fallback(js, result, "index");
-  if (is_err(idx)) return idx;
-  return vtype(idx) == T_NUM ? idx : tov(-1);
-}
-
-jsval_t builtin_regexp_symbol_split(struct js *js, jsval_t *args, int nargs) {
-  jsval_t rx = js_getthis(js);
-  if (!is_object_type(rx))
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@split] called on non-object");
-
-  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "", 0);
-  if (is_err(str)) return str;
-
-  jsval_t ctor = js_get(js, rx, "constructor");
-  if (is_err(ctor)) return ctor;
-
-  jsval_t C;
-  if (vtype(ctor) == T_UNDEF) {
-    C = js_get(js, js_glob(js), "RegExp");
-  } else if (!is_object_type(ctor)) {
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@split]: constructor is not an object");
-  } else {
-    jsval_t species = get_ctor_species_value(js, ctor);
-    if (is_err(species)) return species;
-    if (vtype(species) == T_UNDEF || vtype(species) == T_NULL)
-      C = js_get(js, js_glob(js), "RegExp");
-    else C = species;
-  }
-  
-  if (is_err(C)) return C;
-  if (vtype(C) != T_FUNC && vtype(C) != T_CFUNC)
-    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp species is not a constructor");
-
-  jsval_t flags_val = js_get(js, rx, "flags");
-  if (is_err(flags_val)) return flags_val;
-  jsval_t flags_str = js_tostring_val(js, flags_val);
-  if (is_err(flags_str)) return flags_str;
-
-  jsoff_t flen, foff = vstr(js, flags_str, &flen);
-  const char *fptr = (const char *)&js->mem[foff];
-  bool unicode_matching = false, has_sticky = false;
-  for (jsoff_t i = 0; i < flen; i++) {
-    if (fptr[i] == 'u' || fptr[i] == 'v') unicode_matching = true;
-    if (fptr[i] == 'y') has_sticky = true;
-  }
-
-  jsval_t new_flags;
-  if (has_sticky) new_flags = flags_str; else {
-    char fbuf[16];
-    if (flen > 14) flen = 14;
-    foff = vstr(js, flags_str, &flen);
-    fptr = (const char *)&js->mem[foff];
-    memcpy(fbuf, fptr, flen);
-    fbuf[flen] = 'y';
-    new_flags = js_mkstr(js, fbuf, flen + 1);
-  }
-
-  jsval_t ctor_args[2] = { rx, new_flags };
-  jsval_t splitter = regexp_species_construct(js, rx, C, ctor_args, 2);
-  if (is_err(splitter)) return splitter;
-
-  jsval_t A = mkarr(js);
-  if (is_err(A)) return A;
-  jsoff_t lengthA = 0;
-
-  uint32_t lim = UINT32_MAX;
-  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
-    double d = tod(args[1]);
-    if (d >= 0 && d <= UINT32_MAX) lim = (uint32_t)d;
-  } if (lim == 0) return mkval(T_ARR, vdata(A));
-
-  jsoff_t str_len, str_off = vstr(js, str, &str_len);
-  jsoff_t size = str_len;
-
-  if (size == 0) {
-    jsval_t z = regexp_exec_abstract(js, splitter, str);
-    if (is_err(z)) return z;
-    if (vtype(z) == T_NULL) arr_set(js, A, 0, str);
-    return mkval(T_ARR, vdata(A));
-  }
-
-  jsoff_t p = 0, q = p;
-  jsval_t lastIndex_key = js_mkstr(js, "lastIndex", 9);
-
-  while (q < size) {
-    js_setprop(js, splitter, lastIndex_key, tov((double)q));
-
-    jsval_t z = regexp_exec_abstract(js, splitter, str);
-    if (is_err(z)) return z;
-
-    if (vtype(z) == T_NULL) {
-      if (unicode_matching) {
-        str_off = vstr(js, str, &str_len);
-        q += utf8_char_len_at((const char *)&js->mem[str_off], str_len, q);
-      } else q++;
-      continue;
-    }
-
-    jsval_t li_val = js_get(js, splitter, "lastIndex");
-    if (is_err(li_val)) return li_val;
-    double e_raw = vtype(li_val) == T_NUM ? tod(li_val) : 0;
-    jsoff_t e = (jsoff_t)(e_raw < 0 ? 0 : (e_raw > (double)size ? (double)size : e_raw));
-
-    if (e == p) {
-      if (unicode_matching) {
-        str_off = vstr(js, str, &str_len);
-        q += utf8_char_len_at((const char *)&js->mem[str_off], str_len, q);
-      } else q++;
-      continue;
-    }
-
-    str_off = vstr(js, str, NULL);
-    jsval_t T_val = js_mkstr(js, (char *)&js->mem[str_off + p], q - p);
-    arr_set(js, A, lengthA++, T_val);
-    if (lengthA == lim) return mkval(T_ARR, vdata(A));
-
-    jsoff_t num_caps = get_array_length(js, z);
-    for (jsoff_t i = 1; i < num_caps; i++) {
-      jsval_t cap = arr_get(js, z, i);
-      arr_set(js, A, lengthA++, cap);
-      if (lengthA == lim) return mkval(T_ARR, vdata(A));
-    }
-
-    p = e;
-    q = p;
-  }
-
-  str_off = vstr(js, str, &str_len);
-  jsval_t trailing = js_mkstr(js, (char *)&js->mem[str_off + p], str_len - p);
-  arr_set(js, A, lengthA, trailing);
-  return mkval(T_ARR, vdata(A));
-}
-
-static jsval_t builtin_string_search(struct js *js, jsval_t *args, int nargs) {
-  jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
-  jsval_t str = js_tostring_val(js, this_unwrapped);
-  if (is_err(str)) return str;
-  if (nargs < 1) return tov(-1);
-  
-  if (is_object_type(args[0])) {
-    bool called = false;
-    jsval_t call_args[1] = { str };
-    jsval_t dispatched = maybe_call_symbol_method(
-      js, args[0], get_search_sym_key(), args[0], call_args, 1, &called
-    );
-    if (is_err(dispatched)) return dispatched;
-    if (called) return dispatched;
-  }
-
-  jsval_t pattern = args[0];
-  const char *pattern_ptr = NULL;
-  jsoff_t pattern_len = 0;
-  bool ignore_case = false, multiline = false;
-
-  if (vtype(pattern) == T_OBJ) {
-    jsoff_t source_off = lkp(js, pattern, "source", 6);
-    if (source_off == 0) return tov(-1);
-    jsval_t source_val = resolveprop(js, mkval(T_PROP, source_off));
-    if (vtype(source_val) != T_STR) return tov(-1);
-
-    jsoff_t poff;
-    poff = vstr(js, source_val, &pattern_len);
-    pattern_ptr = (char *) &js->mem[poff];
-
-    jsoff_t flags_off = lkp(js, pattern, "flags", 5);
-    if (flags_off != 0) {
-      jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
-      if (vtype(flags_val) == T_STR) {
-        jsoff_t flen, foff = vstr(js, flags_val, &flen);
-        const char *flags_str = (char *) &js->mem[foff];
-        for (jsoff_t i = 0; i < flen; i++) {
-          if (flags_str[i] == 'i') ignore_case = true;
-          if (flags_str[i] == 'm') multiline = true;
-        }
-      }
-    }
-  } else if (vtype(pattern) == T_STR) {
-    jsoff_t poff;
-    poff = vstr(js, pattern, &pattern_len);
-    pattern_ptr = (char *) &js->mem[poff];
-  } else {
-    return tov(-1);
-  }
-
-  jsoff_t str_len, str_off = vstr(js, str, &str_len);
-  const char *str_ptr = (char *) &js->mem[str_off];
-
-  char pcre2_pattern[512];
-  size_t pcre2_len = js_to_pcre2_pattern(pattern_ptr, pattern_len, pcre2_pattern, sizeof(pcre2_pattern));
-
-  uint32_t options = PCRE2_UTF | PCRE2_UCP | PCRE2_MATCH_UNSET_BACKREF;
-  if (ignore_case) options |= PCRE2_CASELESS;
-  if (multiline) options |= PCRE2_MULTILINE;
-
-  int errcode;
-  PCRE2_SIZE erroffset;
-  pcre2_code *re = pcre2_compile((PCRE2_SPTR)pcre2_pattern, pcre2_len, options, &errcode, &erroffset, NULL);
-  if (re == NULL) return tov(-1);
-
-  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
-  int rc = pcre2_match(re, (PCRE2_SPTR)str_ptr, str_len, 0, 0, match_data, NULL);
-
-  if (rc < 0) {
-    pcre2_match_data_free(match_data);
-    pcre2_code_free(re);
-    return tov(-1);
-  }
-
-  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
-  double result = (double)ovector[0];
-
-  pcre2_match_data_free(match_data);
-  pcre2_code_free(re);
-
-  return tov(result);
-}
-
-static jsval_t builtin_Date(struct js *js, jsval_t *args, int nargs) {
-  jsval_t date_obj = js->this_val;
-  
-  if (vtype(js->new_target) == T_UNDEF) {
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    
-    time_t t = tv.tv_sec;
-    struct tm *tm = localtime(&t);
-    
-    static const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-    static const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-    char buf[64];
-    
-    snprintf(
-      buf, sizeof(buf), "%s %s %02d %04d %02d:%02d:%02d GMT%+03ld%02ld",
-      days[tm->tm_wday], months[tm->tm_mon], tm->tm_mday, tm->tm_year + 1900,
-      tm->tm_hour, tm->tm_min, tm->tm_sec, -timezone/3600, (labs(timezone)/60)%60
-    );
-    
-    return js_mkstr(js, buf, strlen(buf));
-  }
-  
-  double timestamp_ms;
-  
-  if (nargs == 0) {
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    // NOLINTNEXTLINE(bugprone-integer-division)
-    timestamp_ms = (double)tv.tv_sec * 1000.0 + (double)(tv.tv_usec / 1000);
-  } else if (nargs == 1) {
-    if (vtype(args[0]) == T_NUM) {
-      timestamp_ms = tod(args[0]);
-    } else if (vtype(args[0]) == T_STR) {
-      timestamp_ms = 0;
-    } else timestamp_ms = 0;
-  } else {
-    int year = (int)tod(args[0]);
-    int month = nargs >= 2 ? (int)tod(args[1]) : 0;
-    int day = nargs >= 3 ? (int)tod(args[2]) : 1;
-    int hour = nargs >= 4 ? (int)tod(args[3]) : 0;
-    int minute = nargs >= 5 ? (int)tod(args[4]) : 0;
-    int sec = nargs >= 6 ? (int)tod(args[5]) : 0;
-    int ms = nargs >= 7 ? (int)tod(args[6]) : 0;
-    if (year >= 0 && year <= 99) year += 1900;
-    struct tm tm_val = {0};
-    tm_val.tm_year = year - 1900;
-    tm_val.tm_mon = month;
-    tm_val.tm_mday = day;
-    tm_val.tm_hour = hour;
-    tm_val.tm_min = minute;
-    tm_val.tm_sec = sec;
-    tm_val.tm_isdst = -1;
-    time_t t = mktime(&tm_val);
-    timestamp_ms = (double)t * 1000.0 + ms;
-  }
-  
-  js_set_slot(js, date_obj, SLOT_DATA, tov(timestamp_ms));
-  
-  return date_obj;
-}
-
-static jsval_t builtin_Date_now(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  
-  struct timeval tv;
-  gettimeofday(&tv, NULL);
-  // NOLINTNEXTLINE(bugprone-integer-division)
-  double timestamp_ms = (double)tv.tv_sec * 1000.0 + (double)(tv.tv_usec / 1000);
-  
-  return tov(timestamp_ms);
-}
-
-static jsval_t builtin_Date_UTC(struct js *js, jsval_t *args, int nargs) {
-  (void) js;
-  if (nargs < 1) return tov(JS_NAN);
-  
-  int year = (int)tod(args[0]);
-  int month = nargs >= 2 ? (int)tod(args[1]) : 0;
-  int day = nargs >= 3 ? (int)tod(args[2]) : 1;
-  int hour = nargs >= 4 ? (int)tod(args[3]) : 0;
-  int min = nargs >= 5 ? (int)tod(args[4]) : 0;
-  int sec = nargs >= 6 ? (int)tod(args[5]) : 0;
-  int ms = nargs >= 7 ? (int)tod(args[6]) : 0;
-  
-  if (year >= 0 && year <= 99) year += 1900;
-  
-  struct tm tm = {0};
-  tm.tm_year = year - 1900;
-  tm.tm_mon = month;
-  tm.tm_mday = day;
-  tm.tm_hour = hour;
-  tm.tm_min = min;
-  tm.tm_sec = sec;
+  jsval_t bound = mkval(T_FUNC, (uintptr_t)bound_closure);  
+  jsval_t proto_setup = setup_func_prototype(js, bound);
+  if (is_err(proto_setup)) return proto_setup;
   
-  time_t t = timegm(&tm);
-  return tov((double)t * 1000.0 + ms);
-}
-
-static double date_get_time(struct js *js, jsval_t this_val) {
-  jsval_t time_val = js_get_slot(js, this_val, SLOT_DATA);
-  if (vtype(time_val) != T_NUM) return JS_NAN;
-  return tod(time_val);
-}
-
-static jsval_t builtin_Date_getTime(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  return tov(date_get_time(js, js->this_val));
-}
-
-static jsval_t builtin_Date_getFullYear(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)(tm->tm_year + 1900));
-}
-
-static jsval_t builtin_Date_getMonth(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)tm->tm_mon);
-}
-
-static jsval_t builtin_Date_getDate(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)tm->tm_mday);
-}
-
-static jsval_t builtin_Date_getHours(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)tm->tm_hour);
-}
-
-static jsval_t builtin_Date_getMinutes(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)tm->tm_min);
-}
-
-static jsval_t builtin_Date_getSeconds(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)tm->tm_sec);
-}
-
-static jsval_t builtin_Date_getMilliseconds(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  return tov(fmod(ms, 1000.0));
-}
-
-static jsval_t builtin_Date_getDay(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)tm->tm_wday);
-}
-
-static jsval_t builtin_Date_toISOString(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkerr_typed(js, JS_ERR_RANGE, "Invalid time value");
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  int millis = (int)fmod(ms, 1000.0);
-  if (millis < 0) millis += 1000;
-  char buf[32];
-  snprintf(buf, sizeof(buf), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",
-           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
-           tm->tm_hour, tm->tm_min, tm->tm_sec, millis);
-  return js_mkstr(js, buf, strlen(buf));
+  return bound;
 }
 
-static jsval_t builtin_Date_toString(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkstr(js, "Invalid Date", 12);
-  
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm_local = localtime(&t);
-  if (!tm_local) return js_mkstr(js, "Invalid Date", 12);
-  
-  struct tm local_copy = *tm_local;
-  struct tm *gm = gmtime(&t);
-  long offset_sec = (long)difftime(mktime(&local_copy), mktime(gm));
-  int offset_hours = (int)(offset_sec / 3600);
-  int offset_mins = (int)(labs(offset_sec) % 3600) / 60;
+static jsval_t builtin_Array(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t arr = mkarr(js);
+  if (is_err(arr)) return arr;
   
-  char tz[32], buf[80];
-  strftime(tz, sizeof(tz), "%Z", &local_copy);
-  strftime(buf, sizeof(buf), "%a %b %d %Y %H:%M:%S", &local_copy);
-  size_t n = strlen(buf);
-  n += snprintf(buf + n, sizeof(buf) - n, " GMT%+03d%02d (%s)", offset_hours, offset_mins, tz);
-  return js_mkstr(js, buf, n);
-}
-
-static jsval_t builtin_Date_valueOf(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  return tov(date_get_time(js, js->this_val));
-}
-
-static jsval_t builtin_Date_getTimezoneOffset(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *local = localtime(&t);
-  struct tm *utc = gmtime(&t);
-  int diff = (local->tm_hour - utc->tm_hour) * 60 + (local->tm_min - utc->tm_min);
-  if (local->tm_mday != utc->tm_mday) {
-    diff += (local->tm_mday > utc->tm_mday || (local->tm_mday == 1 && utc->tm_mday > 1)) ? 1440 : -1440;
-  }
-  return tov((double)(-diff));
-}
-
-static jsval_t builtin_Date_getUTCFullYear(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)(tm->tm_year + 1900));
-}
-
-static jsval_t builtin_Date_getUTCMonth(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)tm->tm_mon);
-}
-
-static jsval_t builtin_Date_getUTCDate(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)tm->tm_mday);
-}
-
-static jsval_t builtin_Date_getUTCHours(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)tm->tm_hour);
-}
-
-static jsval_t builtin_Date_getUTCMinutes(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)tm->tm_min);
-}
+  if (nargs == 1 && vtype(args[0]) == T_NUM) {
+    jsval_t err = validate_array_length(js, args[0]);
+    if (is_err(err)) return err;
+    jsoff_t new_len = (jsoff_t)tod(args[0]);
+    jsoff_t doff = get_dense_buf(js, arr);
+    if (doff && new_len <= 1024) {
+      if (new_len > dense_capacity(js, doff)) doff = dense_grow(js, arr, new_len);
+      if (doff) dense_set_length(js, doff, new_len);
+    }
+    update_array_length(js, arr, new_len);
+  } else if (nargs > 0) {
+    for (int i = 0; i < nargs; i++) arr_set(js, arr, (jsoff_t)i, args[i]);
+  }
 
-static jsval_t builtin_Date_getUTCSeconds(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)tm->tm_sec);
+  jsval_t array_proto = get_ctor_proto(js, "Array", 5);
+  jsval_t instance_proto = js_instance_proto_from_new_target(js, array_proto);
+  
+  if (is_object_type(instance_proto)) set_proto(js, arr, instance_proto);
+  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
+    set_slot(js, arr, SLOT_CTOR, js->new_target);
+  }
+  
+  return arr;
 }
 
-static jsval_t builtin_Date_getUTCMilliseconds(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  return tov(fmod(ms, 1000.0));
-}
+static jsval_t builtin_Error(ant_t *js, jsval_t *args, int nargs) {
+  bool is_new = (vtype(js->new_target) != T_UNDEF);
+  jsval_t this_val = js->this_val;
+  
+  jsval_t target = is_new ? js->new_target : js->current_func;
+  jsval_t name = ANT_STRING("Error");
+  
+  if (vtype(target) == T_FUNC) {
+    jsoff_t off = lkp(js, js_func_obj(target), "name", 4);
+    if (off) name = resolveprop(js, mkval(T_PROP, off));
+  }
 
-static jsval_t builtin_Date_getUTCDay(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  return tov((double)tm->tm_wday);
-}
-
-static void date_set_time(struct js *js, jsval_t date, double ms) {
-  if (vtype(date) != T_OBJ) return;
-  js_set_slot(js, date, SLOT_DATA, tov(ms));
-}
-
-static jsval_t builtin_Date_setTime(struct js *js, jsval_t *args, int nargs) {
-  double ms = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setMilliseconds(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double newMs = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(newMs)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  ms = floor(ms / 1000.0) * 1000.0 + newMs;
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setSeconds(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double sec = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(sec)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  tm->tm_sec = (int)sec;
-  if (nargs >= 2) ms = floor(ms / 1000.0) * 1000.0 + tod(args[1]);
-  else ms = floor(ms / 1000.0) * 1000.0 + fmod(ms, 1000.0);
-  time_t newt = mktime(tm);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setMinutes(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double min = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(min)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  tm->tm_min = (int)min;
-  if (nargs >= 2) tm->tm_sec = (int)tod(args[1]);
-  time_t newt = mktime(tm);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setHours(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double hour = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(hour)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  tm->tm_hour = (int)hour;
-  if (nargs >= 2) tm->tm_min = (int)tod(args[1]);
-  if (nargs >= 3) tm->tm_sec = (int)tod(args[2]);
-  time_t newt = mktime(tm);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setDate(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double day = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(day)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  tm->tm_mday = (int)day;
-  time_t newt = mktime(tm);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setMonth(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double mon = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(mon)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  tm->tm_mon = (int)mon;
-  if (nargs >= 2) tm->tm_mday = (int)tod(args[1]);
-  time_t newt = mktime(tm);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setFullYear(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double year = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(year)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  if (isnan(ms)) ms = 0;
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  tm->tm_year = (int)year - 1900;
-  if (nargs >= 2) tm->tm_mon = (int)tod(args[1]);
-  if (nargs >= 3) tm->tm_mday = (int)tod(args[2]);
-  time_t newt = mktime(tm);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCMilliseconds(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double newMs = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(newMs)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  ms = floor(ms / 1000.0) * 1000.0 + newMs;
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCSeconds(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double sec = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(sec)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  struct tm copy = *tm;
-  copy.tm_sec = (int)sec;
-  time_t newt = timegm(&copy);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCMinutes(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double min = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(min)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  struct tm copy = *tm;
-  copy.tm_min = (int)min;
-  if (nargs >= 2) copy.tm_sec = (int)tod(args[1]);
-  time_t newt = timegm(&copy);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCHours(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double hour = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(hour)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  struct tm copy = *tm;
-  copy.tm_hour = (int)hour;
-  if (nargs >= 2) copy.tm_min = (int)tod(args[1]);
-  if (nargs >= 3) copy.tm_sec = (int)tod(args[2]);
-  time_t newt = timegm(&copy);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCDate(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double day = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(day)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  struct tm copy = *tm;
-  copy.tm_mday = (int)day;
-  time_t newt = timegm(&copy);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCMonth(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double mon = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(ms) || isnan(mon)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  struct tm copy = *tm;
-  copy.tm_mon = (int)mon;
-  if (nargs >= 2) copy.tm_mday = (int)tod(args[1]);
-  time_t newt = timegm(&copy);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_setUTCFullYear(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  double year = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
-  if (isnan(year)) { date_set_time(js, js->this_val, JS_NAN); return tov(JS_NAN); }
-  if (isnan(ms)) ms = 0;
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  struct tm copy = *tm;
-  copy.tm_year = (int)year - 1900;
-  if (nargs >= 2) copy.tm_mon = (int)tod(args[1]);
-  if (nargs >= 3) copy.tm_mday = (int)tod(args[2]);
-  time_t newt = timegm(&copy);
-  ms = (double)newt * 1000.0 + fmod(ms, 1000.0);
-  date_set_time(js, js->this_val, ms);
-  return tov(ms);
-}
-
-static jsval_t builtin_Date_toUTCString(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkstr(js, "Invalid Date", 12);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = gmtime(&t);
-  static const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-  static const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%s, %02d %s %04d %02d:%02d:%02d GMT",
-           days[tm->tm_wday], tm->tm_mday, months[tm->tm_mon],
-           tm->tm_year + 1900, tm->tm_hour, tm->tm_min, tm->tm_sec);
-  return js_mkstr(js, buf, strlen(buf));
-}
+  if (!is_new) {
+    this_val = js_mkobj(js);
+    jsoff_t proto_off = lkp_interned(js, js_func_obj(js->current_func), INTERN_PROTOTYPE, 9);
+    if (proto_off) set_proto(js, this_val, resolveprop(js, mkval(T_PROP, proto_off)));
+    else set_proto(js, this_val, get_ctor_proto(js, "Error", 5));
+  }
+  
+  if (nargs > 0) {
+    jsval_t msg = args[0];
+    if (vtype(msg) != T_STR) {
+      const char *str = js_str(js, msg);
+      msg = js_mkstr(js, str, strlen(str));
+    }
+    js_mkprop_fast(js, this_val, "message", 7, msg);
+  }
+  
+  if (nargs > 1 && vtype(args[1]) == T_OBJ) {
+    jsoff_t cause_off = lkp(js, args[1], "cause", 5);
+    if (cause_off) js_mkprop_fast(js, this_val, "cause", 5, resolveprop(js, mkval(T_PROP, cause_off)));
+  }
+  
+  js_mkprop_fast(js, this_val, "name", 4, name);
+  set_slot(js, this_val, SLOT_ERROR_BRAND, js_true);
 
-static jsval_t builtin_Date_toDateString(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkstr(js, "Invalid Date", 12);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  static const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-  static const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-  char buf[32];
-  snprintf(buf, sizeof(buf), "%s %s %02d %04d",
-           days[tm->tm_wday], months[tm->tm_mon], tm->tm_mday, tm->tm_year + 1900);
-  return js_mkstr(js, buf, strlen(buf));
+  return this_val;
 }
 
-static jsval_t builtin_Date_toTimeString(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkstr(js, "Invalid Date", 12);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  char buf[32];
-  int offset = (int)(-timezone / 60);
-  int offset_hours = offset / 60;
-  int offset_mins = abs(offset % 60);
-  snprintf(buf, sizeof(buf), "%02d:%02d:%02d GMT%+03d%02d",
-           tm->tm_hour, tm->tm_min, tm->tm_sec, offset_hours, offset_mins);
-  return js_mkstr(js, buf, strlen(buf));
-}
+static jsval_t builtin_Error_toString(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_val = js_getthis(js);
+  
+  jsval_t name = js_get(js, this_val, "name");
+  if (vtype(name) == T_UNDEF) name = js_mkstr(js, "Error", 5);
+  else if (vtype(name) != T_STR) {
+    const char *s = js_str(js, name);
+    name = js_mkstr(js, s, strlen(s));
+  }
+  
+  jsval_t msg = js_get(js, this_val, "message");
+  if (vtype(msg) == T_UNDEF) msg = js_mkstr(js, "", 0);
+  else if (vtype(msg) != T_STR) {
+    const char *s = js_str(js, msg);
+    msg = js_mkstr(js, s, strlen(s));
+  }
+  
+  jsoff_t name_len, msg_len;
+  jsoff_t name_off = vstr(js, name, &name_len);
+  jsoff_t msg_off = vstr(js, msg, &msg_len);
+  
+  const char *name_str = (const char *)&js->mem[name_off];
+  const char *msg_str = (const char *)&js->mem[msg_off];
+  
+  if (name_len == 0) return msg;
+  if (msg_len == 0) return name;
 
-static jsval_t builtin_Date_toLocaleDateString(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkstr(js, "Invalid Date", 12);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  char buf[32];
-  snprintf(buf, sizeof(buf), "%d/%d/%04d", tm->tm_mon + 1, tm->tm_mday, tm->tm_year + 1900);
-  return js_mkstr(js, buf, strlen(buf));
-}
+  size_t total = (size_t)(name_len + 2 + msg_len);
+  char *buf = malloc(total + 1);
+  if (!buf) return js_mkerr(js, "out of memory");
 
-static jsval_t builtin_Date_toLocaleTimeString(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mkstr(js, "Invalid Date", 12);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  char buf[16];
-  snprintf(buf, sizeof(buf), "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
-  return js_mkstr(js, buf, strlen(buf));
+  memcpy(buf, name_str, (size_t)name_len);
+  buf[name_len] = ':';
+  buf[name_len + 1] = ' ';
+  memcpy(buf + name_len + 2, msg_str, (size_t)msg_len);
+  buf[total] = '\0';
+  
+  jsval_t result = js_mkstr(js, buf, total);
+  free(buf);
+  return result;
 }
 
-static jsval_t builtin_Date_getYear(struct js *js, jsval_t *args, int nargs) {
-  (void) args;
-  (void) nargs;
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return tov(JS_NAN);
-  time_t t = (time_t)(ms / 1000.0);
-  struct tm *tm = localtime(&t);
-  return tov((double)(tm->tm_year));
-}
-
-static jsval_t builtin_Date_setYear(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1) {
-    date_set_time(js, js->this_val, JS_NAN);
-    return tov(JS_NAN);
-  }
-  double year_arg = tod(args[0]);
-  if (isnan(year_arg)) {
-    date_set_time(js, js->this_val, JS_NAN);
-    return tov(JS_NAN);
-  }
-  int year = (int)year_arg;
-  if (year >= 0 && year <= 99) year += 1900;
-  double ms = date_get_time(js, js->this_val);
-  time_t t;
-  struct tm tm_val;
-  if (isnan(ms)) {
-    t = 0;
-    tm_val = *localtime(&t);
-    tm_val.tm_mday = 1;
-    tm_val.tm_mon = 0;
-    tm_val.tm_hour = 0;
-    tm_val.tm_min = 0;
-    tm_val.tm_sec = 0;
-  } else {
-    t = (time_t)(ms / 1000.0);
-    tm_val = *localtime(&t);
+static jsval_t builtin_AggregateError(ant_t *js, jsval_t *args, int nargs) {
+  bool is_new = (vtype(js->new_target) != T_UNDEF);
+  jsval_t this_val = js->this_val;
+  
+  if (!is_new) {
+    this_val = js_mkobj(js);
+    jsoff_t proto_off = lkp_interned(js, js_func_obj(js->current_func), INTERN_PROTOTYPE, 9);
+    if (proto_off) set_proto(js, this_val, resolveprop(js, mkval(T_PROP, proto_off)));
+    else set_proto(js, this_val, get_ctor_proto(js, "AggregateError", 14));
   }
-  tm_val.tm_year = year - 1900;
-  time_t new_t = mktime(&tm_val);
-  double new_ms = (double)new_t * 1000.0;
-  date_set_time(js, js->this_val, new_ms);
-  return tov(new_ms);
-}
+  
+  jsval_t errors = nargs > 0 ? args[0] : mkarr(js);
+  if (vtype(errors) != T_ARR) errors = mkarr(js);
+  js_mkprop_fast(js, this_val, "errors", 6, errors);
+  
+  if (nargs > 1 && vtype(args[1]) != T_UNDEF) {
+    jsval_t msg = args[1];
+    if (vtype(msg) != T_STR) {
+      const char *str = js_str(js, msg);
+      msg = js_mkstr(js, str, strlen(str));
+    }
+    js_mkprop_fast(js, this_val, "message", 7, msg);
+  }
+  
+  if (nargs > 2 && vtype(args[2]) == T_OBJ) {
+    jsoff_t cause_off = lkp(js, args[2], "cause", 5);
+    if (cause_off) js_mkprop_fast(js, this_val, "cause", 5, resolveprop(js, mkval(T_PROP, cause_off)));
+  }
+  
+  js_mkprop_fast(js, this_val, "name", 4, ANT_STRING("AggregateError"));
+  set_slot(js, this_val, SLOT_ERROR_BRAND, js_true);
 
-static jsval_t builtin_Date_toJSON(struct js *js, jsval_t *args, int nargs) {
-  double ms = date_get_time(js, js->this_val);
-  if (isnan(ms)) return js_mknull();
-  return builtin_Date_toISOString(js, args, nargs);
+  return this_val;
 }
 
-static jsval_t builtin_Math_abs(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_abs(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(fabs(x));
 }
 
-static jsval_t builtin_Math_acos(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_acos(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(acos(x));
 }
 
-static jsval_t builtin_Math_acosh(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_acosh(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(acosh(x));
 }
 
-static jsval_t builtin_Math_asin(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_asin(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(asin(x));
 }
 
-static jsval_t builtin_Math_asinh(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_asinh(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(asinh(x));
 }
 
-static jsval_t builtin_Math_atan(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_atan(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(atan(x));
 }
 
-static jsval_t builtin_Math_atanh(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_atanh(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(atanh(x));
 }
 
-static jsval_t builtin_Math_atan2(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_atan2(ant_t *js, jsval_t *args, int nargs) {
   double y = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   double x = (nargs < 2) ? JS_NAN : js_to_number(js, args[1]);
   if (isnan(y) || isnan(x)) return tov(JS_NAN);
   return tov(atan2(y, x));
 }
 
-static jsval_t builtin_Math_cbrt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_cbrt(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(cbrt(x));
 }
 
-static jsval_t builtin_Math_ceil(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_ceil(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(ceil(x));
 }
 
-static jsval_t builtin_Math_clz32(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_clz32(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return tov(32);
   double x = js_to_number(js, args[0]);
   if (isnan(x) || isinf(x)) return tov(32);
@@ -16611,43 +5278,43 @@ static jsval_t builtin_Math_clz32(struct js *js, jsval_t *args, int nargs) {
   return tov((double) count);
 }
 
-static jsval_t builtin_Math_cos(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_cos(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(cos(x));
 }
 
-static jsval_t builtin_Math_cosh(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_cosh(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(cosh(x));
 }
 
-static jsval_t builtin_Math_exp(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_exp(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(exp(x));
 }
 
-static jsval_t builtin_Math_expm1(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_expm1(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(expm1(x));
 }
 
-static jsval_t builtin_Math_floor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_floor(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(floor(x));
 }
 
-static jsval_t builtin_Math_fround(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_fround(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov((double)(float)x);
 }
 
-static jsval_t builtin_Math_hypot(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_hypot(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return tov(0.0);
   double sum = 0.0;
   for (int i = 0; i < nargs; i++) {
@@ -16669,38 +5336,38 @@ static int32_t toInt32(double d) {
   return (int32_t)mod_val;
 }
 
-static jsval_t builtin_Math_imul(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_imul(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return tov(0);
   int32_t a = toInt32(js_to_number(js, args[0]));
   int32_t b = toInt32(js_to_number(js, args[1]));
   return tov((double)((int32_t)((uint32_t)a * (uint32_t)b)));
 }
 
-static jsval_t builtin_Math_log(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_log(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(log(x));
 }
 
-static jsval_t builtin_Math_log1p(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_log1p(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(log1p(x));
 }
 
-static jsval_t builtin_Math_log10(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_log10(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(log10(x));
 }
 
-static jsval_t builtin_Math_log2(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_log2(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(log2(x));
 }
 
-static jsval_t builtin_Math_max(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_max(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return tov(JS_NEG_INF);
   double max_val = JS_NEG_INF;
   for (int i = 0; i < nargs; i++) {
@@ -16711,7 +5378,7 @@ static jsval_t builtin_Math_max(struct js *js, jsval_t *args, int nargs) {
   return tov(max_val);
 }
 
-static jsval_t builtin_Math_min(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_min(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return tov(JS_INF);
   double min_val = JS_INF;
   for (int i = 0; i < nargs; i++) {
@@ -16722,7 +5389,7 @@ static jsval_t builtin_Math_min(struct js *js, jsval_t *args, int nargs) {
   return tov(min_val);
 }
 
-static jsval_t builtin_Math_pow(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_pow(ant_t *js, jsval_t *args, int nargs) {
   double base = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   double exp = (nargs < 2) ? JS_NAN : js_to_number(js, args[1]);
   if (isnan(base) || isnan(exp)) return tov(JS_NAN);
@@ -16731,7 +5398,7 @@ static jsval_t builtin_Math_pow(struct js *js, jsval_t *args, int nargs) {
 
 static bool random_seeded = false;
 
-static jsval_t builtin_Math_random(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_random(ant_t *js, jsval_t *args, int nargs) {
   if (!random_seeded) {
     srand((unsigned int) time(NULL));
     random_seeded = true;
@@ -16739,13 +5406,13 @@ static jsval_t builtin_Math_random(struct js *js, jsval_t *args, int nargs) {
   return tov((double) rand() / ((double) RAND_MAX + 1.0));
 }
 
-static jsval_t builtin_Math_round(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_round(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x) || isinf(x)) return tov(x);
   return tov(floor(x + 0.5));
 }
 
-static jsval_t builtin_Math_sign(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_sign(ant_t *js, jsval_t *args, int nargs) {
   double v = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(v)) return tov(JS_NAN);
   if (v > 0) return tov(1.0);
@@ -16753,49 +5420,49 @@ static jsval_t builtin_Math_sign(struct js *js, jsval_t *args, int nargs) {
   return tov(v);
 }
 
-static jsval_t builtin_Math_sin(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_sin(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(sin(x));
 }
 
-static jsval_t builtin_Math_sinh(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_sinh(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(sinh(x));
 }
 
-static jsval_t builtin_Math_sqrt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_sqrt(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(sqrt(x));
 }
 
-static jsval_t builtin_Math_tan(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_tan(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(tan(x));
 }
 
-static jsval_t builtin_Math_tanh(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_tanh(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(tanh(x));
 }
 
-static jsval_t builtin_Math_trunc(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Math_trunc(ant_t *js, jsval_t *args, int nargs) {
   double x = (nargs < 1) ? JS_NAN : js_to_number(js, args[0]);
   if (isnan(x)) return tov(JS_NAN);
   return tov(trunc(x));
 }
 
 typedef jsval_t (*dynamic_kv_mapper_fn)(
-  struct js *js,
+  ant_t *js,
   jsval_t key,
   jsval_t val
 );
 
-static jsval_t iterate_dynamic_keys(struct js *js, jsval_t obj, dynamic_accessors_t *acc, dynamic_kv_mapper_fn mapper) {
+static jsval_t iterate_dynamic_keys(ant_t *js, jsval_t obj, dynamic_accessors_t *acc, dynamic_kv_mapper_fn mapper) {
   jsval_t keys_arr = acc->keys(js, obj);
   jsval_t arr = mkarr(js);
   jsoff_t len = get_array_length(js, keys_arr);
@@ -16812,7 +5479,7 @@ static jsval_t iterate_dynamic_keys(struct js *js, jsval_t obj, dynamic_accessor
   return mkval(T_ARR, vdata(arr));
 }
 
-static jsval_t builtin_object_is(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_is(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_false;
   
   jsval_t x = args[0];
@@ -16847,16 +5514,16 @@ enum obj_enum_mode {
   OBJ_ENUM_ENTRIES
 };
 
-static jsval_t map_to_entry(struct js *js, jsval_t key, jsval_t val) {
+static jsval_t map_to_entry(ant_t *js, jsval_t key, jsval_t val) {
   jsval_t pair = mkarr(js);
   arr_set(js, pair, 0, key);
   arr_set(js, pair, 1, val);
   return mkval(T_ARR, vdata(pair));
 }
 
-static jsval_t object_enum(struct js *js, jsval_t obj, enum obj_enum_mode mode) {
+static jsval_t object_enum(ant_t *js, jsval_t obj, enum obj_enum_mode mode) {
   bool is_arr = (vtype(obj) == T_ARR);
-  if (vtype(obj) == T_FUNC) obj = mkval(T_OBJ, vdata(obj));
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
   
   jsoff_t obj_off = (jsoff_t)vdata(obj);
   dynamic_accessors_t *acc = NULL;
@@ -16894,6 +5561,7 @@ static jsval_t object_enum(struct js *js, jsval_t obj, enum obj_enum_mode mode)
   while (next < js->brk && next != 0) {
     jsoff_t header = loadoff(js, next);
     if (is_slot_prop(header)) { next = next_prop(header); continue; }
+    if (is_sym_key_prop(js, next)) { next = next_prop(header); continue; }
     
     jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
     jsoff_t klen = offtolen(loadoff(js, koff));
@@ -16924,43 +5592,154 @@ static jsval_t object_enum(struct js *js, jsval_t obj, enum obj_enum_mode mode)
     }
   }
   
-  if (mode == OBJ_ENUM_KEYS) {
-    descriptor_entry_t *desc, *tmp;
-    HASH_ITER(hh, desc_registry, desc, tmp) {
-      if (desc->obj_off != obj_off) continue;
-      if (!desc->enumerable) continue;
-      if (!desc->has_getter && !desc->has_setter) continue;
-      jsval_t key_val = js_mkstr(js, desc->prop_name, desc->prop_len);
-      arr_set(js, arr, idx, key_val);
-      idx++;
-    }
-  }
-  
   return mkval(T_ARR, vdata(arr));
 }
 
-static jsval_t builtin_object_keys(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_keys(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return mkarr(js);
   jsval_t obj = args[0];
   if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) return mkarr(js);
+  
+  if (is_proxy(js, obj)) {
+    proxy_data_t *data = get_proxy_data(obj);
+    if (!data) return mkarr(js);
+    if (data->revoked)
+      return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot perform 'ownKeys' on a proxy that has been revoked");
+    
+    jsoff_t trap_off = lkp(js, data->handler, "ownKeys", 7);
+    if (!trap_off) return object_enum(js, data->target, OBJ_ENUM_KEYS);
+    
+    jsval_t trap = resolveprop(js, mkval(T_PROP, trap_off));
+    uint8_t ft = vtype(trap);
+    if (ft != T_FUNC && ft != T_CFUNC) return object_enum(js, data->target, OBJ_ENUM_KEYS);
+    
+    jsval_t trap_args[1] = { data->target };
+    jsval_t result = sv_vm_call(js->vm, js, trap, data->handler, trap_args, 1, NULL, false);
+    if (is_err(result)) return result;
+    if (vtype(result) != T_ARR)
+      return js_mkerr_typed(js, JS_ERR_TYPE, "ownKeys trap must return an array");
+    
+    jsoff_t len = get_array_length(js, result);
+    for (jsoff_t i = 0; i < len; i++) {
+      jsval_t ki = arr_get(js, result, i);
+      if (vtype(ki) != T_STR && vtype(ki) != T_SYMBOL)
+        return js_mkerr_typed(js, JS_ERR_TYPE, "ownKeys trap result must contain only strings or symbols");
+      jsoff_t ki_len; jsoff_t ki_off = vstr(js, ki, &ki_len);
+      for (jsoff_t j = 0; j < i; j++) {
+        jsval_t kj = arr_get(js, result, j);
+        jsoff_t kj_len; jsoff_t kj_off = vstr(js, kj, &kj_len);
+        if (ki_len == kj_len && memcmp(&js->mem[ki_off], &js->mem[kj_off], ki_len) == 0)
+          return js_mkerr_typed(js, JS_ERR_TYPE, "ownKeys trap result must not contain duplicate entries");
+      }
+    }
+    return result;
+  }
+  
   return object_enum(js, obj, OBJ_ENUM_KEYS);
 }
 
-static jsval_t builtin_object_values(struct js *js, jsval_t *args, int nargs) {
+static jsval_t for_in_keys_add(ant_t *js, jsval_t out, jsval_t seen, jsval_t key) {
+  if (vtype(key) != T_STR) return js_mkundef();
+
+  jsoff_t key_len = 0;
+  jsoff_t key_off = vstr(js, key, &key_len);
+  const char *key_ptr = (const char *)&js->mem[key_off];
+
+  if (is_internal_prop(key_ptr, key_len))
+    return js_mkundef();
+  if (lkp(js, seen, key_ptr, key_len) != 0)
+    return js_mkundef();
+
+  jsval_t mark = setprop_cstr(js, seen, key_ptr, key_len, js_true);
+  if (is_err(mark)) return mark;
+
+  js_arr_push(js, out, key);
+  return js_mkundef();
+}
+
+static jsval_t for_in_keys_add_string_indices(ant_t *js, jsval_t out, jsval_t seen, jsval_t str) {
+  jsoff_t slen = vstrlen(js, str);
+  for (jsoff_t i = 0; i < slen; i++) {
+    char idx[16];
+    size_t idx_len = uint_to_str(idx, sizeof(idx), (uint64_t)i);
+    jsval_t key = js_mkstr(js, idx, idx_len);
+    jsval_t r = for_in_keys_add(js, out, seen, key);
+    if (is_err(r)) return r;
+  }
+  return js_mkundef();
+}
+
+jsval_t js_for_in_keys(ant_t *js, jsval_t obj) {
+  uint8_t t = vtype(obj);
+  jsval_t out = mkarr(js);
+  if (t == T_NULL || t == T_UNDEF) return out;
+
+  jsval_t seen = mkobj(js, 0);
+  jshdl_t h_out = js_root(js, out);
+  jshdl_t h_seen = js_root(js, seen);
+  jsval_t result = js_mkundef();
+
+  if (t == T_STR) {
+    result = for_in_keys_add_string_indices(js, js_deref(js, h_out), js_deref(js, h_seen), obj);
+    goto done;
+  }
+
+  if (t == T_OBJ) {
+    jsval_t prim = get_slot(js, obj, SLOT_PRIMITIVE);
+    if (vtype(prim) == T_STR) {
+      result = for_in_keys_add_string_indices(js, js_deref(js, h_out), js_deref(js, h_seen), prim);
+      if (is_err(result)) goto done;
+    }
+  }
+
+  if (t == T_OBJ || t == T_ARR || t == T_FUNC) {
+    jsval_t own_keys = object_enum(js, obj, OBJ_ENUM_KEYS);
+    if (is_err(own_keys)) {
+      result = own_keys;
+      goto done;
+    }
+    if (vtype(own_keys) == T_ARR) {
+      jshdl_t h_own = js_root(js, own_keys);
+      jsoff_t own_len = js_arr_len(js, js_deref(js, h_own));
+      for (jsoff_t i = 0; i < own_len; i++) {
+        jsval_t key = js_arr_get(js, js_deref(js, h_own), i);
+        result = for_in_keys_add(js, js_deref(js, h_out), js_deref(js, h_seen), key);
+        if (is_err(result)) {
+          js_unroot(js, h_own);
+          goto done;
+        }
+      }
+      js_unroot(js, h_own);
+    }
+  }
+
+done:
+  if (is_err(result)) {
+    js_unroot(js, h_seen);
+    js_unroot(js, h_out);
+    return result;
+  }
+  jsval_t ret = js_deref(js, h_out);
+  js_unroot(js, h_seen);
+  js_unroot(js, h_out);
+  return ret;
+}
+
+static jsval_t builtin_object_values(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return mkarr(js);
   jsval_t obj = args[0];
   if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) return mkarr(js);
   return object_enum(js, obj, OBJ_ENUM_VALUES);
 }
 
-static jsval_t builtin_object_entries(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_entries(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return mkarr(js);
   jsval_t obj = args[0];
   if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) return mkarr(js);
   return object_enum(js, obj, OBJ_ENUM_ENTRIES);
 }
 
-static jsval_t builtin_object_getPrototypeOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_getPrototypeOf(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkerr(js, "Object.getPrototypeOf requires an argument");
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
@@ -16971,7 +5750,7 @@ static jsval_t builtin_object_getPrototypeOf(struct js *js, jsval_t *args, int n
   return js_mknull();
 }
 
-static jsval_t builtin_object_setPrototypeOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_setPrototypeOf(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "Object.setPrototypeOf requires 2 arguments");
   
   jsval_t obj = args[0];
@@ -16988,14 +5767,14 @@ static jsval_t builtin_object_setPrototypeOf(struct js *js, jsval_t *args, int n
   }
   
   for (jsval_t cur = proto; pt != T_NULL && vtype(cur) != T_NULL; cur = get_proto(js, cur)) {
-    if (vdata(cur) == vdata(obj)) return js_mkerr(js, "Cyclic __proto__ value");
+    if (vdata(js_as_obj(cur)) == vdata(js_as_obj(obj))) return js_mkerr(js, "Cyclic __proto__ value");
   }
   
   set_proto(js, obj, proto);
   return obj;
 }
 
-static jsval_t builtin_proto_getter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_proto_getter(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js->this_val;
   uint8_t t = vtype(this_val);
   
@@ -17010,7 +5789,7 @@ static jsval_t builtin_proto_getter(struct js *js, jsval_t *args, int nargs) {
   return get_prototype_for_type(js, t);
 }
 
-static jsval_t builtin_proto_setter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_proto_setter(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js->this_val;
   uint8_t t = vtype(this_val);
   
@@ -17039,7 +5818,7 @@ static jsval_t builtin_proto_setter(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_object_create(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_create(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkerr(js, "Object.create requires a prototype argument");
   
   jsval_t proto = args[0];
@@ -17083,18 +5862,25 @@ static jsval_t builtin_object_create(struct js *js, jsval_t *args, int nargs) {
   return obj;
 }
 
-static jsval_t builtin_object_hasOwn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_hasOwn(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return mkval(T_BOOL, 0);
   
   jsval_t obj = args[0];
-  jsval_t key = args[1];
-  
   uint8_t t = vtype(obj);
   
+  if (t == T_NULL || t == T_UNDEF) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert undefined or null to object");
+  }
+  
+  jsval_t key = args[1];
+  if (vtype(key) != T_STR) {
+    key = js_tostring_val(js, key);
+    if (is_err(key)) return key;
+  }
+  
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return mkval(T_BOOL, 0);
-  if (vtype(key) != T_STR) return mkval(T_BOOL, 0);
   
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   jsoff_t key_len, key_off = vstr(js, key, &key_len);
   const char *key_str = (char *) &js->mem[key_off];
   
@@ -17102,7 +5888,47 @@ static jsval_t builtin_object_hasOwn(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_BOOL, off != 0 ? 1 : 0);
 }
 
-static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_groupBy(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2) return js_mkerr_typed(js, JS_ERR_TYPE, "Object.groupBy requires 2 arguments");
+  
+  jsval_t items = args[0];
+  jsval_t callback = args[1];
+  
+  if (vtype(callback) != T_FUNC && vtype(callback) != T_CFUNC)
+    return js_mkerr_typed(js, JS_ERR_TYPE, "callback is not a function");
+  
+  jsval_t result = js_mkobj(js);
+  set_proto(js, result, js_mknull());
+  
+  jsoff_t len = get_array_length(js, items);
+  for (jsoff_t i = 0; i < len; i++) {
+    jsval_t val = arr_get(js, items, i);
+    jsval_t cb_args[2] = { val, tov((double)i) };
+    jsval_t key = sv_vm_call(js->vm, js, callback, js_mkundef(), cb_args, 2, NULL, false);
+    if (is_err(key)) return key;
+    
+    jsval_t key_str = js_tostring_val(js, key);
+    if (is_err(key_str)) return key_str;
+    
+    jsoff_t klen;
+    jsoff_t koff = vstr(js, key_str, &klen);
+    const char *kptr = (char *)&js->mem[koff];
+    
+    jsoff_t grp_off = lkp(js, result, kptr, klen);
+    jsval_t group;
+    if (grp_off) {
+      group = resolveprop(js, mkval(T_PROP, grp_off));
+    } else {
+      group = mkarr(js);
+      js_setprop(js, result, key_str, group);
+    }
+    js_arr_push(js, group, val);
+  }
+  
+  return result;
+}
+
+static jsval_t builtin_object_defineProperty(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) return js_mkerr(js, "Object.defineProperty requires 3 arguments");
   
   jsval_t obj = args[0];
@@ -17114,11 +5940,8 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
     return js_mkerr(js, "Object.defineProperty called on non-object");
   }
   
-  if (vtype(prop) == T_SYMBOL) {
-    char keybuf[64];
-    sym_to_prop_key(prop, keybuf, sizeof(keybuf));
-    prop = js_mkstr(js, keybuf, strlen(keybuf));
-  } else if (vtype(prop) != T_STR) {
+  bool sym_key = (vtype(prop) == T_SYMBOL);
+  if (!sym_key && vtype(prop) != T_STR) {
     char buf[64];
     size_t len = tostr(js, prop, buf, sizeof(buf));
     prop = js_mkstr(js, buf, len);
@@ -17128,18 +5951,28 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
     return js_mkerr(js, "Property descriptor must be an object");
   }
   
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
-  
-  jsoff_t prop_len, prop_off = vstr(js, prop, &prop_len);
-  const char *prop_str = (char *) &js->mem[prop_off];
+  jsval_t as_obj = js_as_obj(obj);
   
-  if (streq(prop_str, prop_len, STR_PROTO, STR_PROTO_LEN)) {
-    return js_mkerr(js, "Cannot define " STR_PROTO " property");
+  jsoff_t prop_len = 0;
+  const char *prop_str = NULL;
+  jsoff_t sym_off = 0;
+  
+  if (sym_key) {
+    sym_off = (jsoff_t)vdata(prop);
+    const char *desc = js_sym_desc(js, prop);
+    prop_str = desc ? desc : "symbol";
+    prop_len = (jsoff_t)strlen(prop_str);
+  } else {
+    jsoff_t prop_off = vstr(js, prop, &prop_len);
+    prop_str = (char *) &js->mem[prop_off];
+    if (streq(prop_str, prop_len, STR_PROTO, STR_PROTO_LEN)) {
+      return js_mkerr(js, "Cannot define " STR_PROTO " property");
+    }
   }
   
   bool has_value = false, has_get = false, has_set = false, has_writable = false;
   jsval_t value = js_mkundef();
-  bool writable = true, enumerable = false, configurable = false;
+  bool writable = false, enumerable = false, configurable = false;
   
   jsoff_t value_off = lkp(js, descriptor, "value", 5);
   if (value_off != 0) {
@@ -17188,7 +6021,7 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
     configurable = js_truthy(js, c_val);
   }
   
-  jsoff_t existing_off = lkp(js, as_obj, prop_str, prop_len);
+  jsoff_t existing_off = sym_key ? lkp_sym(js, as_obj, sym_off) : lkp(js, as_obj, prop_str, prop_len);
   
   if (existing_off == 0) {
     if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) 
@@ -17204,16 +6037,18 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
       (enumerable ? JS_DESC_E : 0) |
       (configurable ? JS_DESC_C : 0);
     
-    if (has_get && has_set) {
-      jsval_t getter = resolveprop(js, mkval(T_PROP, get_off));
-      jsval_t setter = resolveprop(js, mkval(T_PROP, set_off));
-      js_set_accessor_desc(js, as_obj, prop_str, prop_len, getter, setter, desc_flags);
-    } else if (has_get) {
-      jsval_t getter = resolveprop(js, mkval(T_PROP, get_off));
-      js_set_getter_desc(js, as_obj, prop_str, prop_len, getter, desc_flags);
-    } else {
-      jsval_t setter = resolveprop(js, mkval(T_PROP, set_off));
-      js_set_setter_desc(js, as_obj, prop_str, prop_len, setter, desc_flags);
+    if (!sym_key) {
+      if (has_get && has_set) {
+        jsval_t getter = resolveprop(js, mkval(T_PROP, get_off));
+        jsval_t setter = resolveprop(js, mkval(T_PROP, set_off));
+        js_set_accessor_desc(js, as_obj, prop_str, prop_len, getter, setter, desc_flags);
+      } else if (has_get) {
+        jsval_t getter = resolveprop(js, mkval(T_PROP, get_off));
+        js_set_getter_desc(js, as_obj, prop_str, prop_len, getter, desc_flags);
+      } else {
+        jsval_t setter = resolveprop(js, mkval(T_PROP, set_off));
+        js_set_setter_desc(js, as_obj, prop_str, prop_len, setter, desc_flags);
+      }
     }
   } else {
     int desc_flags = 
@@ -17221,7 +6056,7 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
       (enumerable ? JS_DESC_E : 0) | 
       (configurable ? JS_DESC_C : 0);
       
-    js_set_descriptor(js, as_obj, prop_str, prop_len, desc_flags);
+    if (!sym_key) js_set_descriptor(js, as_obj, prop_str, prop_len, desc_flags);
     
     if (existing_off > 0) {
       bool is_frozen = js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN));
@@ -17261,7 +6096,7 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
       }
     } else {
       if (!has_value) value = js_mkundef();      
-      jsval_t prop_key = js_mkstr(js, prop_str, prop_len);
+      jsval_t prop_key = sym_key ? prop : js_mkstr(js, prop_str, prop_len);
       jsoff_t flags = (writable ? 0 : CONSTMASK) | (configurable ? 0 : NONCONFIGMASK);
       mkprop(js, as_obj, prop_key, value, flags);
     }
@@ -17270,7 +6105,7 @@ static jsval_t builtin_object_defineProperty(struct js *js, jsval_t *args, int n
   return obj;
 }
 
-static jsval_t builtin_object_defineProperties(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_defineProperties(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "Object.defineProperties requires 2 arguments");
   
   jsval_t obj = args[0];
@@ -17309,7 +6144,7 @@ static jsval_t builtin_object_defineProperties(struct js *js, jsval_t *args, int
   return obj;
 }
 
-static jsval_t builtin_object_assign(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_assign(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkerr(js, "Object.assign requires at least 1 argument");
   
   jsval_t target = args[0];
@@ -17323,7 +6158,7 @@ static jsval_t builtin_object_assign(struct js *js, jsval_t *args, int nargs) {
     target = js_mkobj(js);
   }
   
-  jsval_t as_obj = (vtype(target) == T_OBJ) ? target : mkval(T_OBJ, vdata(target));
+  jsval_t as_obj = js_as_obj(target);
   
   for (int i = 1; i < nargs; i++) {
     jsval_t source = args[i];
@@ -17332,7 +6167,7 @@ static jsval_t builtin_object_assign(struct js *js, jsval_t *args, int nargs) {
     if (st == T_NULL || st == T_UNDEF) continue;
     if (st != T_OBJ && st != T_ARR && st != T_FUNC) continue;
     
-    jsval_t src_obj = (st == T_OBJ) ? source : mkval(T_OBJ, vdata(source));
+    jsval_t src_obj = js_as_obj(source);
     jsoff_t next = loadoff(js, (jsoff_t) vdata(src_obj)) & ~(3U | FLAGMASK);
     
     while (next < js->brk && next != 0) {
@@ -17363,14 +6198,14 @@ static jsval_t builtin_object_assign(struct js *js, jsval_t *args, int nargs) {
   return target;
 }
 
-static jsval_t builtin_object_freeze(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_freeze(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkundef();
   
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return obj;
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   
   jsoff_t next = loadoff(js, (jsoff_t) vdata(as_obj)) & ~(3U | FLAGMASK);
   
@@ -17403,26 +6238,26 @@ static jsval_t builtin_object_freeze(struct js *js, jsval_t *args, int nargs) {
   return obj;
 }
 
-static jsval_t builtin_object_isFrozen(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_isFrozen(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_true;
   
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_true;
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   
   return js_bool(js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN)));
 }
 
-static jsval_t builtin_object_seal(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_seal(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkundef();
   
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return obj;
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   
   set_slot(js, as_obj, SLOT_SEALED, js_true);
   jsoff_t next = loadoff(js, (jsoff_t) vdata(as_obj)) & ~(3U | FLAGMASK);
@@ -17455,14 +6290,14 @@ static jsval_t builtin_object_seal(struct js *js, jsval_t *args, int nargs) {
   return obj;
 }
 
-static jsval_t builtin_object_isSealed(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_isSealed(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_true;
   
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_true;
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   
   if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return js_true;
   if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return js_true;
@@ -17470,7 +6305,7 @@ static jsval_t builtin_object_isSealed(struct js *js, jsval_t *args, int nargs)
   return js_false;
 }
 
-static jsval_t builtin_object_fromEntries(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_fromEntries(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkerr(js, "Object.fromEntries requires an iterable argument");
   
   jsval_t iterable = args[0];
@@ -17504,7 +6339,7 @@ static jsval_t builtin_object_fromEntries(struct js *js, jsval_t *args, int narg
   return result;
 }
 
-static jsval_t builtin_object_getOwnPropertyDescriptor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_getOwnPropertyDescriptor(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t obj = args[0];
@@ -17513,14 +6348,14 @@ static jsval_t builtin_object_getOwnPropertyDescriptor(struct js *js, jsval_t *a
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_mkundef();
   
-  char sym_buf[32];
   const char *key_str;
   jsoff_t key_len;
   
-  if (vtype(key) == T_SYMBOL) {
-    sym_to_prop_key(key, sym_buf, sizeof(sym_buf));
-    key_str = sym_buf;
-    key_len = (jsoff_t)strlen(sym_buf);
+  bool is_sym = (vtype(key) == T_SYMBOL);
+  if (is_sym) {
+    const char *d = js_sym_desc(js, key);
+    key_str = d ? d : "symbol";
+    key_len = (jsoff_t)strlen(key_str);
   } else if (vtype(key) == T_STR) {
     jsoff_t key_off = vstr(js, key, &key_len);
     key_str = (char *) &js->mem[key_off];
@@ -17532,12 +6367,14 @@ static jsval_t builtin_object_getOwnPropertyDescriptor(struct js *js, jsval_t *a
     key_str = (char *) &js->mem[key_off];
   }
   
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
-  
+  jsval_t as_obj = js_as_obj(obj);
   jsoff_t obj_off = (jsoff_t)vdata(as_obj);
-  descriptor_entry_t *desc = lookup_descriptor(js, obj_off, key_str, key_len);
   
-  jsoff_t prop_off = lkp(js, as_obj, key_str, key_len);
+  descriptor_entry_t *desc = is_sym 
+    ? lookup_sym_descriptor(obj_off, (jsoff_t)vdata(key)) 
+    : lookup_descriptor(js, obj_off, key_str, key_len);
+  
+  jsoff_t prop_off = is_sym ? lkp_sym(js, as_obj, (jsoff_t)vdata(key)) : lkp(js, as_obj, key_str, key_len);
   if (prop_off == 0 && !desc) {
     return js_mkundef();
   }
@@ -17565,98 +6402,86 @@ static jsval_t builtin_object_getOwnPropertyDescriptor(struct js *js, jsval_t *a
   
   return result;
   
-  return js_mkundef();
-}
-
-static jsval_t builtin_object_getOwnPropertyNames(struct js *js, jsval_t *args, int nargs) {
-  if (nargs == 0) return mkarr(js);
-  jsval_t obj = args[0];
-  
-  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) return mkarr(js);
-  if (vtype(obj) == T_FUNC) obj = mkval(T_OBJ, vdata(obj));
-  
-  jsoff_t count = 0;
-  jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
-  
-  while (next < js->brk && next != 0) {
-    jsoff_t header = loadoff(js, next);
-    if (!is_slot_prop(header)) {
-      jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
-      jsoff_t klen = offtolen(loadoff(js, koff));
-      const char *key = (char *) &js->mem[koff + sizeof(koff)];
-      if (!is_internal_prop(key, klen)) count++;
-    }
-    next = next_prop(header);
-  }
-  
-  if (count == 0) return mkarr(js);
+  return js_mkundef();
+}
+
+static inline bool own_prop_names_is_dense_shadow(
+  ant_t *js, jsoff_t obj_off,
+  const char *key, jsoff_t key_len
+) {
+  jsoff_t doff = get_dense_buf_off(js, obj_off);
+  if (!doff) return false;
+  
+  jsoff_t dense_len = dense_length(js, doff);
+  if (dense_len <= 0 || !is_array_index(key, key_len)) return false;
+  
+  unsigned long dense_idx = 0;
+  return parse_array_index(key, (size_t)key_len, dense_len, &dense_idx);
+}
+
+static jsval_t builtin_object_getOwnPropertyNames(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return mkarr(js);
+  jsval_t obj = args[0];
+  
+  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) return mkarr(js);
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
   
+  jsoff_t obj_off = (jsoff_t)vdata(obj);
   bool is_arr_obj = (vtype(obj) == T_ARR);
+  
   jsval_t arr = mkarr(js);
   jsoff_t idx = 0;
   
   if (is_arr_obj) {
-    jsoff_t doff = get_dense_buf_off(js, (jsoff_t)vdata(obj));
-    if (doff) {
-      jsoff_t dense_len = dense_length(js, doff);
-      for (jsoff_t i = 0; i < dense_len; i++) {
-        jsval_t v = dense_get(js, doff, i);
-        if (is_empty_slot(v)) continue;
-        char idxstr[16]; size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)i);
-        arr_set(js, arr, idx++, js_mkstr(js, idxstr, idxlen));
-      }
-    }
-  }
+  for (jsoff_t i = 0;; i++) {
+    jsoff_t doff = get_dense_buf_off(js, obj_off);
+    if (!doff) break;
+    
+    jsoff_t dense_len = dense_length(js, doff);
+    if (i >= dense_len) break;
+
+    jsval_t v = dense_get(js, doff, i);
+    if (is_empty_slot(v)) continue;
+    
+    char idxstr[16]; size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)i);
+    arr_set(js, arr, idx++, js_mkstr(js, idxstr, idxlen));
+  }}
   
-  next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
+  jsoff_t next = loadoff(js, obj_off) & ~(3U | FLAGMASK);
   while (next < js->brk && next != 0) {
-    jsoff_t header = loadoff(js, next);
-    if (!is_slot_prop(header)) {
-      jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
-      jsoff_t klen = offtolen(loadoff(js, koff));
-      const char *key = (char *) &js->mem[koff + sizeof(koff)];
-      if (!is_internal_prop(key, klen)) {
-        if (is_arr_obj && is_array_index(key, klen)) {
-          jsoff_t doff = get_dense_buf_off(js, (jsoff_t)vdata(obj));
-          if (doff) {
-            unsigned long pidx = 0;
-            for (jsoff_t ci = 0; ci < klen; ci++) pidx = pidx * 10 + (key[ci] - '0');
-            if (pidx < dense_length(js, doff)) continue;
-          }
-        } arr_set(js, arr, idx++, js_mkstr(js, key, klen));
-      }
-    } next = next_prop(header);
+    jsoff_t prop = next;
+    jsoff_t header = loadoff(js, prop);
+    next = next_prop(header);
+    if (is_slot_prop(header) || is_sym_key_prop(js, prop)) continue;
+
+    jsoff_t koff = loadoff(js, prop + (jsoff_t)sizeof(prop));
+    jsoff_t klen = offtolen(loadoff(js, koff));
+    const char *key = (char *)&js->mem[koff + sizeof(koff)];
+
+    if (is_internal_prop(key, klen)) continue;
+    if (is_arr_obj && own_prop_names_is_dense_shadow(js, obj_off, key, klen)) continue;
+    arr_set(js, arr, idx++, js_mkstr(js, key, klen));
   }
   
   if (is_arr_obj) arr_set(js, arr, idx++, js->length_str);
   return mkval(T_ARR, vdata(arr));
 }
 
-// refactor with desc when SLOT_SYMBOL
-static jsval_t builtin_object_getOwnPropertySymbols(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_getOwnPropertySymbols(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return mkarr(js);
   jsval_t obj = args[0];
   
   uint8_t t = vtype(obj);
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return mkarr(js);
-  if (t == T_FUNC) obj = mkval(T_OBJ, vdata(obj));
+  if (t == T_FUNC) obj = js_func_obj(obj);
   
   jsval_t arr = mkarr(js); jsoff_t idx = 0;
   jsoff_t next = loadoff(js, (jsoff_t)vdata(obj)) & ~(3U | FLAGMASK);
   
   while (next < js->brk && next != 0) {
     jsoff_t header = loadoff(js, next);
-    if (!is_slot_prop(header)) {
-      jsoff_t koff = loadoff(js, next + (jsoff_t)sizeof(next));
-      jsoff_t klen = offtolen(loadoff(js, koff));
-      const char *key = (char *)&js->mem[koff + sizeof(koff)];
-      
-      if (is_symbol_key(key, klen)) {
-        uint64_t sym_id = 0;
-        for (const char *p = key + 6; *p >= '0' && *p <= '9' && sym_id <= PROPREF_PAYLOAD / 10; p++)
-          sym_id = sym_id * 10 + (uint64_t)(*p - '0');
-        arr_set(js, arr, idx++, mkval(T_SYMBOL, (sym_id & PROPREF_PAYLOAD) << PROPREF_KEY_SHIFT));
-      }
+    if (!is_slot_prop(header) && is_sym_key_prop(js, next)) {
+      arr_set(js, arr, idx++, mkval(T_SYMBOL, get_prop_koff(js, next)));
     }
     next = next_prop(header);
   }
@@ -17664,14 +6489,14 @@ static jsval_t builtin_object_getOwnPropertySymbols(struct js *js, jsval_t *args
   return mkval(T_ARR, vdata(arr));
 }
 
-static jsval_t builtin_object_isExtensible(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_isExtensible(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_true;
   
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_true;
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   
   if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return js_false;
   if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return js_false;
@@ -17682,20 +6507,20 @@ static jsval_t builtin_object_isExtensible(struct js *js, jsval_t *args, int nar
   return js_true;
 }
 
-static jsval_t builtin_object_preventExtensions(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_preventExtensions(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkundef();
   
   jsval_t obj = args[0];
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return obj;
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
   
   set_slot(js, as_obj, SLOT_EXTENSIBLE, js_false);
   return obj;
 }
 
-static jsval_t builtin_object_hasOwnProperty(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_hasOwnProperty(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return mkval(T_BOOL, 0);
   
   jsval_t obj = js->this_val;
@@ -17705,25 +6530,22 @@ static jsval_t builtin_object_hasOwnProperty(struct js *js, jsval_t *args, int n
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return mkval(T_BOOL, 0);
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
+
+  if (vtype(key) == T_SYMBOL) {
+    jsoff_t off = lkp_sym(js, as_obj, (jsoff_t)vdata(key));
+    return mkval(T_BOOL, off != 0 ? 1 : 0);
+  }
 
-  char sym_buf[64];
   const char *key_str = NULL;
   jsoff_t key_len = 0;
-  if (vtype(key) == T_SYMBOL) {
-    int klen = sym_to_prop_key(key, sym_buf, sizeof(sym_buf));
-    if (klen <= 0) return mkval(T_BOOL, 0);
-    key_str = sym_buf;
-    key_len = (jsoff_t)klen;
-  } else {
-    if (vtype(key) != T_STR) {
-      char buf[64];
-      size_t n = tostr(js, key, buf, sizeof(buf));
-      key = js_mkstr(js, buf, n);
-    }
-    jsoff_t key_off = vstr(js, key, &key_len);
-    key_str = (char *) &js->mem[key_off];
+  if (vtype(key) != T_STR) {
+    char buf[64];
+    size_t n = tostr(js, key, buf, sizeof(buf));
+    key = js_mkstr(js, buf, n);
   }
+  jsoff_t key_off = vstr(js, key, &key_len);
+  key_str = (char *) &js->mem[key_off];
 
   if (t == T_ARR && streq(key_str, key_len, "length", 6)) return mkval(T_BOOL, 1);
   if (t == T_ARR && is_array_index(key_str, key_len)) {
@@ -17734,10 +6556,12 @@ static jsval_t builtin_object_hasOwnProperty(struct js *js, jsval_t *args, int n
   }
 
   jsoff_t off = lkp(js, as_obj, key_str, key_len);
-  return mkval(T_BOOL, off != 0 ? 1 : 0);
+  if (off != 0) return mkval(T_BOOL, 1);
+  descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(as_obj), key_str, key_len);
+  return mkval(T_BOOL, (desc && (desc->has_getter || desc->has_setter)) ? 1 : 0);
 }
 
-static jsval_t builtin_object_isPrototypeOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_isPrototypeOf(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return mkval(T_BOOL, 0);
   
   jsval_t proto_obj = resolveprop(js, js->this_val);
@@ -17748,20 +6572,20 @@ static jsval_t builtin_object_isPrototypeOf(struct js *js, jsval_t *args, int na
   
   uint8_t proto_type = vtype(proto_obj);
   if (proto_type != T_OBJ && proto_type != T_ARR && proto_type != T_FUNC) return mkval(T_BOOL, 0);
-  jsoff_t proto_data = (jsoff_t)vdata(proto_obj);
+  jsoff_t proto_data = (jsoff_t)vdata(js_as_obj(proto_obj));
   
   jsval_t current = get_proto(js, obj);
   while (!is_undefined(current) && !is_null(current)) {
     uint8_t cur_type = vtype(current);
     if (cur_type != T_OBJ && cur_type != T_ARR && cur_type != T_FUNC) break;
-    if (vdata(current) == proto_data) return mkval(T_BOOL, 1);
+    if ((jsoff_t)vdata(js_as_obj(current)) == proto_data) return mkval(T_BOOL, 1);
     current = get_proto(js, current);
   }
   
   return mkval(T_BOOL, 0);
 }
 
-static jsval_t builtin_object_propertyIsEnumerable(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_propertyIsEnumerable(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return mkval(T_BOOL, 0);
   
   jsval_t obj = js->this_val;
@@ -17771,25 +6595,22 @@ static jsval_t builtin_object_propertyIsEnumerable(struct js *js, jsval_t *args,
   uint8_t t = vtype(obj);
   
   if (t != T_OBJ && t != T_ARR && t != T_FUNC) return mkval(T_BOOL, 0);
-  jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
+  jsval_t as_obj = js_as_obj(obj);
+
+  if (vtype(key) == T_SYMBOL) {
+    jsoff_t off = lkp_sym(js, as_obj, (jsoff_t)vdata(key));
+    return mkval(T_BOOL, off != 0 ? 1 : 0);
+  }
 
-  char sym_buf[64];
   const char *key_str = NULL;
   jsoff_t key_len = 0;
-  if (vtype(key) == T_SYMBOL) {
-    int klen = sym_to_prop_key(key, sym_buf, sizeof(sym_buf));
-    if (klen <= 0) return mkval(T_BOOL, 0);
-    key_str = sym_buf;
-    key_len = (jsoff_t)klen;
-  } else {
-    if (vtype(key) != T_STR) {
-      char buf[64];
-      size_t n = tostr(js, key, buf, sizeof(buf));
-      key = js_mkstr(js, buf, n);
-    }
-    jsoff_t key_off = vstr(js, key, &key_len);
-    key_str = (char *) &js->mem[key_off];
+  if (vtype(key) != T_STR) {
+    char buf[64];
+    size_t n = tostr(js, key, buf, sizeof(buf));
+    key = js_mkstr(js, buf, n);
   }
+  jsoff_t key_off = vstr(js, key, &key_len);
+  key_str = (char *) &js->mem[key_off];
 
   if (t == T_ARR && streq(key_str, key_len, "length", 6)) {
     return mkval(T_BOOL, 0);
@@ -17817,7 +6638,7 @@ static jsval_t builtin_object_propertyIsEnumerable(struct js *js, jsval_t *args,
   return mkval(T_BOOL, 1);
 }
 
-static jsval_t builtin_object_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_toString(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t obj = js->this_val;
   
@@ -17827,18 +6648,16 @@ static jsval_t builtin_object_toString(struct js *js, jsval_t *args, int nargs)
   const char *tag = NULL;
   jsoff_t tag_len = 0;
 
-  const char *tostr_tag_key = get_toStringTag_sym_key();
-  if (tostr_tag_key && tostr_tag_key[0]) {
+  jsval_t tag_sym = get_toStringTag_sym();
+  if (vtype(tag_sym) == T_SYMBOL) {
+    jsoff_t sym_off = (jsoff_t)vdata(tag_sym);
     jsoff_t tag_off = 0;
     if (is_object_type(obj)) {
-      jsval_t check_obj = (t != T_OBJ) ? mkval(T_OBJ, vdata(obj)) : obj;
-      tag_off = lkp(js, check_obj, tostr_tag_key, strlen(tostr_tag_key));
-      if (tag_off == 0) tag_off = lkp_proto(js, check_obj, tostr_tag_key, strlen(tostr_tag_key));
+      tag_off = lkp_sym_proto(js, obj, sym_off);
     } else {
       jsval_t proto = get_prototype_for_type(js, t);
       if (is_object_type(proto)) {
-        tag_off = lkp(js, proto, tostr_tag_key, strlen(tostr_tag_key));
-        if (tag_off == 0) tag_off = lkp_proto(js, proto, tostr_tag_key, strlen(tostr_tag_key));
+        tag_off = lkp_sym_proto(js, proto, sym_off);
       }
     }
     if (tag_off != 0) {
@@ -17861,6 +6680,7 @@ static jsval_t builtin_object_toString(struct js *js, jsval_t *args, int nargs)
       case T_STR:     tag = "String";    tag_len = 6; break;
       case T_ARR:     tag = "Array";     tag_len = 5; break;
       case T_FUNC:    tag = "Function";  tag_len = 8; break;
+      case T_CFUNC:   tag = "Function";  tag_len = 8; break;
       case T_ERR:     tag = "Error";     tag_len = 5; break;
       case T_BIGINT:  tag = "BigInt";    tag_len = 6; break;
       case T_PROMISE: tag = "Promise";   tag_len = 7; break;
@@ -17880,11 +6700,11 @@ static jsval_t builtin_object_toString(struct js *js, jsval_t *args, int nargs)
   return string_builder_finalize(js, &sb);
 }
 
-static jsval_t builtin_object_valueOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_valueOf(ant_t *js, jsval_t *args, int nargs) {
   return js->this_val;
 }
 
-static jsval_t builtin_object_toLocaleString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_object_toLocaleString(ant_t *js, jsval_t *args, int nargs) {
   return js_call_toString(js, js->this_val);
 }
 
@@ -17893,13 +6713,13 @@ static inline bool is_callable(jsval_t v) {
   return t == T_FUNC || t == T_CFUNC;
 }
 
-static inline jsval_t require_callback(struct js *js, jsval_t *args, int nargs, const char *name) {
+static inline jsval_t require_callback(ant_t *js, jsval_t *args, int nargs, const char *name) {
   if (nargs == 0 || !is_callable(args[0]))
     return js_mkerr(js, "%s requires a function argument", name);
   return args[0];
 }
 
-static jsval_t array_shallow_copy(struct js *js, jsval_t arr, jsoff_t len) {
+static jsval_t array_shallow_copy(ant_t *js, jsval_t arr, jsoff_t len) {
   jsval_t result = mkarr(js);
   if (is_err(result)) return result;
   
@@ -17927,7 +6747,7 @@ static jsval_t array_shallow_copy(struct js *js, jsval_t arr, jsoff_t len) {
   return result;
 }
 
-static jsval_t builtin_array_push(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_push(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   arr = resolveprop(js, arr);
   
@@ -17987,7 +6807,7 @@ static jsval_t builtin_array_push(struct js *js, jsval_t *args, int nargs) {
   return new_len;
 }
 
-void js_arr_push(struct js *js, jsval_t arr, jsval_t val) {
+void js_arr_push(ant_t *js, jsval_t arr, jsval_t val) {
   arr = resolveprop(js, arr);
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) return;
   
@@ -18019,7 +6839,7 @@ void js_arr_push(struct js *js, jsval_t arr, jsval_t val) {
   else js_mkprop_fast(js, arr, "length", 6, tov((double)(len + 1)));
 }
 
-static jsval_t builtin_array_pop(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_pop(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
 
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
@@ -18065,7 +6885,7 @@ static jsval_t builtin_array_pop(struct js *js, jsval_t *args, int nargs) {
   len--; char idxstr[16];
   size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)len);
 
-  jsoff_t arr_off = (jsoff_t)vdata(arr);
+  jsoff_t arr_off = (jsoff_t)vdata(js_as_obj(arr));
   jsoff_t tail = loadoff(js, arr_off + sizeof(jsoff_t) * 2);
   jsoff_t elem_off = 0;
 
@@ -18091,7 +6911,7 @@ static jsval_t builtin_array_pop(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_array_slice(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_slice(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "slice called on non-array");
@@ -18131,7 +6951,7 @@ static jsval_t builtin_array_slice(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_array_join(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_join(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "join called on non-array");
@@ -18228,7 +7048,7 @@ static jsval_t builtin_array_join(struct js *js, jsval_t *args, int nargs) {
   free(result); return ret;
 }
 
-static jsval_t builtin_array_includes(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_includes(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18250,31 +7070,14 @@ static jsval_t builtin_array_includes(struct js *js, jsval_t *args, int nargs) {
   
   for (jsoff_t i = start; i < len; i++) {
     jsval_t val = arr_get(js, arr, i);
-    
-    if (vtype(val) == vtype(search)) {
-      bool match = false;
-      if (vtype(val) == T_NUM) {
-        if (isnan(tod(val)) && isnan(tod(search))) match = true;
-        else if (tod(val) == tod(search)) match = true;
-      }
-      else if (vtype(val) == T_BOOL && vdata(val) == vdata(search)) match = true;
-      else if (vtype(val) == T_STR) {
-        jsoff_t vl, vo = vstr(js, val, &vl);
-        jsoff_t sl, so = vstr(js, search, &sl);
-        if (vl == sl && memcmp(&js->mem[vo], &js->mem[so], vl) == 0) match = true;
-      }
-      else if ((vtype(val) == T_OBJ || vtype(val) == T_ARR || vtype(val) == T_FUNC) && vdata(val) == vdata(search)) match = true;
-      
-      if (match) return mkval(T_BOOL, 1);
-    }
-    else if (vtype(search) == T_UNDEF && vtype(val) == T_UNDEF) return mkval(T_BOOL, 1);
-    else if (vtype(search) == T_NULL && vtype(val) == T_NULL) return mkval(T_BOOL, 1);
+    if (vtype(val) == T_NUM && vtype(search) == T_NUM && isnan(tod(val)) && isnan(tod(search))) return mkval(T_BOOL, 1);
+    if (strict_eq_values(js, val, search)) return mkval(T_BOOL, 1);
   }
   
   return mkval(T_BOOL, 0);
 }
 
-static jsval_t builtin_array_every(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_every(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18282,6 +7085,7 @@ static jsval_t builtin_array_every(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t callback = require_callback(js, args, nargs, "every");
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   
@@ -18289,7 +7093,7 @@ static jsval_t builtin_array_every(struct js *js, jsval_t *args, int nargs) {
     if (!arr_has(js, arr, i)) continue;
     jsval_t val = arr_get(js, arr, i);
     jsval_t call_args[3] = { val, tov((double)i), arr };
-    jsval_t result = call_js_with_args(js, callback, call_args, 3);
+    jsval_t result = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     if (is_err(result)) return result;
     if (!js_truthy(js, result)) return mkval(T_BOOL, 0);
   }
@@ -18297,7 +7101,7 @@ static jsval_t builtin_array_every(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_BOOL, 1);
 }
 
-static jsval_t builtin_array_forEach(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_forEach(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18305,6 +7109,7 @@ static jsval_t builtin_array_forEach(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t callback = require_callback(js, args, nargs, "forEach");
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   
@@ -18312,14 +7117,14 @@ static jsval_t builtin_array_forEach(struct js *js, jsval_t *args, int nargs) {
     if (!arr_has(js, arr, i)) continue;
     jsval_t val = arr_get(js, arr, i);
     jsval_t call_args[3] = { val, tov((double)i), arr };
-    jsval_t result = call_js_with_args(js, callback, call_args, 3);
+    jsval_t result = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     if (is_err(result)) return result;
   }
   
   return js_mkundef();
 }
 
-static jsval_t builtin_array_reverse(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_reverse(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t arr = js->this_val;
 
@@ -18401,7 +7206,7 @@ static jsval_t builtin_array_reverse(struct js *js, jsval_t *args, int nargs) {
   return arr;
 }
 
-static jsval_t builtin_array_map(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_map(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18409,6 +7214,7 @@ static jsval_t builtin_array_map(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t callback = require_callback(js, args, nargs, "map");
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   jsval_t result = array_alloc_like(js, arr);
@@ -18418,7 +7224,7 @@ static jsval_t builtin_array_map(struct js *js, jsval_t *args, int nargs) {
     if (!arr_has(js, arr, i)) continue;
     jsval_t val = arr_get(js, arr, i);
     jsval_t call_args[3] = { val, tov((double)i), arr };
-    jsval_t mapped = call_js_with_args(js, callback, call_args, 3);
+    jsval_t mapped = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     if (is_err(mapped)) return mapped;
     arr_set(js, result, i, mapped);
   }
@@ -18426,7 +7232,7 @@ static jsval_t builtin_array_map(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_array_filter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_filter(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18434,6 +7240,7 @@ static jsval_t builtin_array_filter(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t callback = require_callback(js, args, nargs, "filter");
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   jsval_t result = array_alloc_like(js, arr);
@@ -18445,7 +7252,7 @@ static jsval_t builtin_array_filter(struct js *js, jsval_t *args, int nargs) {
     if (!arr_has(js, arr, i)) continue;
     jsval_t val = arr_get(js, arr, i);
     jsval_t call_args[3] = { val, tov((double)i), arr };
-    jsval_t test = call_js_with_args(js, callback, call_args, 3);
+    jsval_t test = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     
     if (is_err(test)) return test;
     if (js_truthy(js, test)) { arr_set(js, result, result_idx, val); result_idx++; }
@@ -18454,7 +7261,7 @@ static jsval_t builtin_array_filter(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_array_reduce(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_reduce(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18474,7 +7281,7 @@ static jsval_t builtin_array_reduce(struct js *js, jsval_t *args, int nargs) {
     jsval_t val = arr_get(js, arr, i);
     if (first) { accumulator = val; first = false; continue; }
     jsval_t call_args[4] = { accumulator, val, tov((double)i), arr };
-    accumulator = call_js_with_args(js, callback, call_args, 4);
+    accumulator = sv_vm_call(js->vm, js, callback, js_mkundef(), call_args, 4, NULL, false);
     if (is_err(accumulator)) return accumulator;
   }
   
@@ -18482,7 +7289,7 @@ static jsval_t builtin_array_reduce(struct js *js, jsval_t *args, int nargs) {
   return accumulator;
 }
 
-static void flat_helper(struct js *js, jsval_t arr, jsval_t result, jsoff_t *result_idx, int depth) {
+static void flat_helper(ant_t *js, jsval_t arr, jsval_t result, jsoff_t *result_idx, int depth) {
   jsoff_t len = get_array_length(js, arr);
   if (len == 0) return;
   
@@ -18496,7 +7303,7 @@ static void flat_helper(struct js *js, jsval_t arr, jsval_t result, jsoff_t *res
   }
 }
 
-static jsval_t builtin_array_flat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_flat(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "flat called on non-array");
@@ -18516,7 +7323,7 @@ static jsval_t builtin_array_flat(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_array_concat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_concat(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "concat called on non-array");
@@ -18537,13 +7344,10 @@ static jsval_t builtin_array_concat(struct js *js, jsval_t *args, int nargs) {
         array_default_spreadable = (vtype(target) == T_ARR);
       }
       
-      const char *spread_key = get_isConcatSpreadable_sym_key();
-      if (spread_key && spread_key[0]) {
-        jsval_t spread_val = js_get(js, arg, spread_key);
-        if (is_err(spread_val)) return spread_val;
-        if (vtype(spread_val) == T_UNDEF) spreadable = array_default_spreadable;
-        else spreadable = js_truthy(js, spread_val);
-      } else spreadable = array_default_spreadable;
+      jsval_t spread_val = js_get_sym(js, arg, get_isConcatSpreadable_sym());
+      if (is_err(spread_val)) return spread_val;
+      if (vtype(spread_val) == T_UNDEF) spreadable = array_default_spreadable;
+      else spreadable = js_truthy(js, spread_val);
     }
     
     if (spreadable) {
@@ -18569,7 +7373,7 @@ static jsval_t builtin_array_concat(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_array_at(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_at(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "at called on non-array");
@@ -18586,7 +7390,7 @@ static jsval_t builtin_array_at(struct js *js, jsval_t *args, int nargs) {
   return arr_get(js, arr, (jsoff_t)idx);
 }
 
-static jsval_t builtin_array_fill(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_fill(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "fill called on non-array");
@@ -18619,7 +7423,7 @@ static jsval_t builtin_array_fill(struct js *js, jsval_t *args, int nargs) {
   return arr;
 }
 
-static jsval_t array_find_impl(struct js *js, jsval_t *args, int nargs, bool return_index, const char *name) {
+static jsval_t array_find_impl(ant_t *js, jsval_t *args, int nargs, bool return_index, const char *name) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18627,6 +7431,7 @@ static jsval_t array_find_impl(struct js *js, jsval_t *args, int nargs, bool ret
   
   jsval_t callback = require_callback(js, args, nargs, name);
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   if (len == 0) return return_index ? tov(-1) : js_mkundef();
@@ -18635,7 +7440,7 @@ static jsval_t array_find_impl(struct js *js, jsval_t *args, int nargs, bool ret
     jsval_t val = arr_get(js, arr, i);
     
     jsval_t call_args[3] = { val, tov((double)i), arr };
-    jsval_t result = call_js_with_args(js, callback, call_args, 3);
+    jsval_t result = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     
     if (is_err(result)) return result;
     if (js_truthy(js, result)) return return_index ? tov((double)i) : val;
@@ -18644,15 +7449,15 @@ static jsval_t array_find_impl(struct js *js, jsval_t *args, int nargs, bool ret
   return return_index ? tov(-1) : js_mkundef();
 }
 
-static jsval_t builtin_array_find(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_find(ant_t *js, jsval_t *args, int nargs) {
   return array_find_impl(js, args, nargs, false, "find");
 }
 
-static jsval_t builtin_array_findIndex(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_findIndex(ant_t *js, jsval_t *args, int nargs) {
   return array_find_impl(js, args, nargs, true, "findIndex");
 }
 
-static jsval_t array_find_last_impl(struct js *js, jsval_t *args, int nargs, bool return_index, const char *name) {
+static jsval_t array_find_last_impl(ant_t *js, jsval_t *args, int nargs, bool return_index, const char *name) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18660,6 +7465,7 @@ static jsval_t array_find_last_impl(struct js *js, jsval_t *args, int nargs, boo
   
   jsval_t callback = require_callback(js, args, nargs, name);
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   if (len == 0) return return_index ? tov(-1) : js_mkundef();
@@ -18668,7 +7474,7 @@ static jsval_t array_find_last_impl(struct js *js, jsval_t *args, int nargs, boo
     jsval_t val = arr_get(js, arr, i - 1);
     
     jsval_t call_args[3] = { val, tov((double)(i - 1)), arr };
-    jsval_t result = call_js_with_args(js, callback, call_args, 3);
+    jsval_t result = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     
     if (is_err(result)) return result;
     if (js_truthy(js, result)) return return_index ? tov((double)(i - 1)) : val;
@@ -18677,15 +7483,15 @@ static jsval_t array_find_last_impl(struct js *js, jsval_t *args, int nargs, boo
   return return_index ? tov(-1) : js_mkundef();
 }
 
-static jsval_t builtin_array_findLast(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_findLast(ant_t *js, jsval_t *args, int nargs) {
   return array_find_last_impl(js, args, nargs, false, "findLast");
 }
 
-static jsval_t builtin_array_findLastIndex(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_findLastIndex(ant_t *js, jsval_t *args, int nargs) {
   return array_find_last_impl(js, args, nargs, true, "findLastIndex");
 }
 
-static jsval_t builtin_array_flatMap(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_flatMap(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "flatMap called on non-array");
@@ -18695,6 +7501,7 @@ static jsval_t builtin_array_flatMap(struct js *js, jsval_t *args, int nargs) {
   }
   
   jsval_t callback = args[0];
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   jsoff_t len = get_array_length(js, arr);
   
   jsval_t result = mkarr(js);
@@ -18704,7 +7511,7 @@ static jsval_t builtin_array_flatMap(struct js *js, jsval_t *args, int nargs) {
   for (jsoff_t i = 0; i < len; i++) {
     jsval_t elem = arr_get(js, arr, i);
     jsval_t call_args[3] = { elem, tov((double)i), arr };
-    jsval_t mapped = call_js_with_args(js, callback, call_args, 3);
+    jsval_t mapped = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     if (is_err(mapped)) return mapped;
     
     if (vtype(mapped) == T_ARR || vtype(mapped) == T_OBJ) {
@@ -18723,7 +7530,7 @@ static jsval_t builtin_array_flatMap(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_ARR, vdata(result));
 }
 
-static const char *js_tostring(struct js *js, jsval_t v) {
+static const char *js_tostring(ant_t *js, jsval_t v) {
   if (vtype(v) == T_STR) {
     jsoff_t slen, off = vstr(js, v, &slen);
     return (const char *)&js->mem[off];
@@ -18731,11 +7538,11 @@ static const char *js_tostring(struct js *js, jsval_t v) {
   return js_str(js, v);
 }
 
-static int js_compare_values(struct js *js, jsval_t a, jsval_t b, jsval_t compareFn) {
+static int js_compare_values(ant_t *js, jsval_t a, jsval_t b, jsval_t compareFn) {
   uint8_t t = vtype(compareFn);
   if (t == T_FUNC || t == T_CFUNC) {
     jsval_t call_args[2] = { a, b };
-    jsval_t result = call_js_with_args(js, compareFn, call_args, 2);
+    jsval_t result = sv_vm_call(js->vm, js, compareFn, js_mkundef(), call_args, 2, NULL, false);
     if (vtype(result) == T_NUM) return (int)tod(result);
     return 0;
   }
@@ -18756,7 +7563,7 @@ static int js_compare_values(struct js *js, jsval_t a, jsval_t b, jsval_t compar
   return strcmp(copy, js_tostring(js, b));
 }
 
-static jsval_t builtin_array_indexOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_indexOf(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "indexOf called on non-array");
@@ -18777,21 +7584,12 @@ static jsval_t builtin_array_indexOf(struct js *js, jsval_t *args, int nargs) {
   for (jsoff_t i = start; i < len; i++) {
     jsval_t elem = arr_get(js, arr, i);
     if (vtype(elem) == T_UNDEF && !arr_has(js, arr, i)) continue;
-    if (vtype(elem) == vtype(search)) {
-      if (vtype(elem) == T_NUM && tod(elem) == tod(search)) return tov((double)i);
-      if (vtype(elem) == T_BOOL && vdata(elem) == vdata(search)) return tov((double)i);
-      if (vtype(elem) == T_STR) {
-        jsoff_t el, eo = vstr(js, elem, &el);
-        jsoff_t sl, so = vstr(js, search, &sl);
-        if (el == sl && memcmp(&js->mem[eo], &js->mem[so], el) == 0) return tov((double)i);
-      }
-      if ((vtype(elem) == T_OBJ || vtype(elem) == T_ARR || vtype(elem) == T_FUNC) && vdata(elem) == vdata(search)) return tov((double)i);
-    }
+    if (strict_eq_values(js, elem, search)) return tov((double)i);
   }
   return tov(-1);
 }
 
-static jsval_t builtin_array_lastIndexOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_lastIndexOf(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "lastIndexOf called on non-array");
@@ -18811,21 +7609,12 @@ static jsval_t builtin_array_lastIndexOf(struct js *js, jsval_t *args, int nargs
   for (int i = start; i >= 0; i--) {
     jsval_t elem = arr_get(js, arr, (jsoff_t)i);
     if (vtype(elem) == T_UNDEF && !arr_has(js, arr, (jsoff_t)i)) continue;
-    if (vtype(elem) == vtype(search)) {
-      if (vtype(elem) == T_NUM && tod(elem) == tod(search)) return tov((double)i);
-      if (vtype(elem) == T_BOOL && vdata(elem) == vdata(search)) return tov((double)i);
-      if (vtype(elem) == T_STR) {
-        jsoff_t el, eo = vstr(js, elem, &el);
-        jsoff_t sl, so = vstr(js, search, &sl);
-        if (el == sl && memcmp(&js->mem[eo], &js->mem[so], el) == 0) return tov((double)i);
-      }
-      if ((vtype(elem) == T_OBJ || vtype(elem) == T_ARR || vtype(elem) == T_FUNC) && vdata(elem) == vdata(search)) return tov((double)i);
-    }
+    if (strict_eq_values(js, elem, search)) return tov((double)i);
   }
   return tov(-1);
 }
 
-static jsval_t builtin_array_reduceRight(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_reduceRight(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "reduceRight called on non-array");
@@ -18851,14 +7640,14 @@ static jsval_t builtin_array_reduceRight(struct js *js, jsval_t *args, int nargs
   for (int i = start_idx; i >= 0; i--) {
     jsval_t elem = arr_get(js, arr, (jsoff_t)i);
     jsval_t call_args[4] = { accumulator, elem, tov((double)i), arr };
-    accumulator = call_js_with_args(js, callback, call_args, 4);
+    accumulator = sv_vm_call(js->vm, js, callback, js_mkundef(), call_args, 4, NULL, false);
     if (is_err(accumulator)) return accumulator;
   }
   
   return accumulator;
 }
 
-static jsval_t builtin_array_shift(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_shift(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   jsval_t arr = js->this_val;
@@ -18901,7 +7690,7 @@ static jsval_t builtin_array_shift(struct js *js, jsval_t *args, int nargs) {
   return first;
 }
 
-static jsval_t builtin_array_unshift(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_unshift(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "unshift called on non-array");
@@ -18951,7 +7740,7 @@ static jsval_t builtin_array_unshift(struct js *js, jsval_t *args, int nargs) {
   return tov((double) new_len);
 }
 
-static jsval_t builtin_array_some(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_some(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -18959,6 +7748,7 @@ static jsval_t builtin_array_some(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t callback = require_callback(js, args, nargs, "some");
   if (is_err(callback)) return callback;
+  jsval_t this_arg = (nargs >= 2) ? args[1] : js_mkundef();
   
   jsoff_t len = get_array_length(js, arr);
   if (len == 0) return mkval(T_BOOL, 0);
@@ -18968,7 +7758,7 @@ static jsval_t builtin_array_some(struct js *js, jsval_t *args, int nargs) {
     jsval_t val = arr_get(js, arr, i);
     
     jsval_t call_args[3] = { val, tov((double)i), arr };
-    jsval_t result = call_js_with_args(js, callback, call_args, 3);
+    jsval_t result = sv_vm_call(js->vm, js, callback, this_arg, call_args, 3, NULL, false);
     
     if (is_err(result)) return result;
     if (js_truthy(js, result)) return mkval(T_BOOL, 1);
@@ -18977,7 +7767,7 @@ static jsval_t builtin_array_some(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_BOOL, 0);
 }
 
-static jsval_t builtin_array_sort(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_sort(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   jsval_t compareFn = js_mkundef();
   jsval_t *vals = NULL, *keys = NULL, *temp_vals = NULL, *temp_keys = NULL;
@@ -19120,7 +7910,7 @@ oom:
   return js_mkerr(js, "out of memory");
 }
 
-static jsval_t builtin_array_splice(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_splice(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "splice called on non-array");
@@ -19238,7 +8028,7 @@ static jsval_t builtin_array_splice(struct js *js, jsval_t *args, int nargs) {
   return removed;
 }
 
-static jsval_t builtin_array_copyWithin(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_copyWithin(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "copyWithin called on non-array");
@@ -19304,7 +8094,7 @@ static jsval_t builtin_array_copyWithin(struct js *js, jsval_t *args, int nargs)
   return arr;
 }
 
-static jsval_t builtin_array_toSorted(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_toSorted(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
     return js_mkerr(js, "toSorted called on non-array");
@@ -19321,7 +8111,7 @@ static jsval_t builtin_array_toSorted(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_toReversed(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_toReversed(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
@@ -19339,7 +8129,7 @@ static jsval_t builtin_array_toReversed(struct js *js, jsval_t *args, int nargs)
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_toSpliced(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_toSpliced(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ)
     return js_mkerr(js, "toSpliced called on non-array");
@@ -19355,7 +8145,7 @@ static jsval_t builtin_array_toSpliced(struct js *js, jsval_t *args, int nargs)
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_with(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_with(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   if (vtype(arr) != T_ARR && vtype(arr) != T_OBJ) {
     return js_mkerr(js, "with called on non-array");
@@ -19380,7 +8170,7 @@ static jsval_t builtin_array_with(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_keys(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_keys(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   jsval_t arr = js->this_val;
@@ -19400,7 +8190,7 @@ static jsval_t builtin_array_keys(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_values(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_values(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   jsval_t arr = js->this_val;
@@ -19420,7 +8210,7 @@ static jsval_t builtin_array_values(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_entries(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_entries(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   jsval_t arr = js->this_val;
@@ -19448,7 +8238,7 @@ static jsval_t builtin_array_entries(struct js *js, jsval_t *args, int nargs) {
   return mkval(T_ARR, vdata(result));
 }
 
-static jsval_t builtin_array_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_toString(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js->this_val;
   
   jsval_t join_result;
@@ -19460,7 +8250,7 @@ static jsval_t builtin_array_toString(struct js *js, jsval_t *args, int nargs) {
   return builtin_object_toString(js, args, nargs);
 }
 
-static jsval_t builtin_array_toLocaleString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_array_toLocaleString(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   jsval_t arr = js->this_val;
@@ -19511,7 +8301,7 @@ static jsval_t builtin_array_toLocaleString(struct js *js, jsval_t *args, int na
   return ret;
 }
 
-static jsval_t builtin_Array_isArray(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Array_isArray(ant_t *js, jsval_t *args, int nargs) {
   (void) js;
   if (nargs == 0) return mkval(T_BOOL, 0);
   return mkval(T_BOOL, vtype(args[0]) == T_ARR ? 1 : 0);
@@ -19525,13 +8315,13 @@ typedef struct {
   jsoff_t index;
 } array_from_iter_ctx_t;
 
-static iter_action_t array_from_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
+static iter_action_t array_from_iter_cb(ant_t *js, jsval_t value, void *ctx, jsval_t *out) {
   array_from_iter_ctx_t *fctx = (array_from_iter_ctx_t *)ctx;
   jsval_t elem = value;
 
   if (is_callable(fctx->mapFn)) {
     jsval_t call_args[2] = { elem, tov((double)fctx->index) };
-    elem = js_call_with_this(js, fctx->mapFn, fctx->mapThis, call_args, 2);
+    elem = sv_vm_call(js->vm, js, fctx->mapFn, fctx->mapThis, call_args, 2, NULL, false);
     if (is_err(elem)) { *out = elem; return ITER_ERROR; }
   }
 
@@ -19545,7 +8335,7 @@ static iter_action_t array_from_iter_cb(struct js *js, jsval_t value, void *ctx,
   return ITER_CONTINUE;
 }
 
-static jsval_t builtin_Array_from(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Array_from(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return mkarr(js);
 
   jsval_t src = args[0];
@@ -19559,22 +8349,53 @@ static jsval_t builtin_Array_from(struct js *js, jsval_t *args, int nargs) {
 
   bool result_is_proxy = is_proxy(js, result);
   jsval_t write_target = result_is_proxy ? proxy_read_target(js, result) : result;
+  jsval_t iter_sym = get_iterator_sym();
 
   if (vtype(src) == T_STR) {
+    if (is_rope(js, src)) { src = rope_flatten(js, src); if (is_err(src)) return src; }
+    jsoff_t slen = str_len_fast(js, src);
     array_from_iter_ctx_t ctx = { write_target, result, mapFn, mapThis, 0 };
-    jsval_t r = str_spread_chars(js, src, SPREAD_STR_CB, &ctx, array_from_iter_cb);
-    if (is_err(r)) return r;
-    if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double) ctx.index));
+    for (jsoff_t i = 0; i < slen; ) {
+      jsoff_t off = vstr(js, src, NULL);
+      utf8proc_int32_t cp;
+      jsoff_t cb_len = (jsoff_t)utf8_next((const utf8proc_uint8_t *)&js->mem[off + i], (utf8proc_ssize_t)(slen - i), &cp);
+      jsval_t ch = js_mkstr(js, (char *)&js->mem[off + i], cb_len);
+      
+      jsval_t out;
+      iter_action_t act = array_from_iter_cb(js, ch, &ctx, &out);
+      
+      if (act == ITER_ERROR) return out;
+      i += cb_len;
+    }
+    if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double)ctx.index));
+  } else if (vtype(src) == T_ARR) {
+    jsoff_t iter_off = (vtype(iter_sym) == T_SYMBOL) ? lkp_sym_proto(js, src, (jsoff_t)vdata(iter_sym)) : 0;
+    bool default_iter = iter_off != 0 && vtype(loadval(js, iter_off + sizeof(jsoff_t) * 2)) == T_CFUNC;
+
+    if (default_iter) {
+      array_from_iter_ctx_t ctx = { write_target, result, mapFn, mapThis, 0 };
+      jsoff_t len = get_array_length(js, src);
+      for (jsoff_t i = 0; i < len; i++) {
+        jsval_t unused;
+        iter_action_t act = array_from_iter_cb(js, arr_get(js, src, i), &ctx, &unused);
+        if (act == ITER_ERROR) return unused;
+      }
+      if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double)len));
+    } else {
+      array_from_iter_ctx_t ctx = { write_target, result, mapFn, mapThis, 0 };
+      jsval_t iter_result = iter_foreach(js, src, array_from_iter_cb, &ctx);
+      if (is_err(iter_result)) return iter_result;
+      if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double)ctx.index));
+    }
   } else {
-    const char *iter_key = get_iterator_sym_key();
-    jsoff_t iter_prop = iter_key ? lkp_proto(js, src, iter_key, strlen(iter_key)) : 0;
+    jsoff_t iter_prop = (vtype(iter_sym) == T_SYMBOL) ? lkp_sym_proto(js, src, (jsoff_t)vdata(iter_sym)) : 0;
 
     if (iter_prop != 0) {
       array_from_iter_ctx_t ctx = { write_target, result, mapFn, mapThis, 0 };
       jsval_t iter_result = iter_foreach(js, src, array_from_iter_cb, &ctx);
       if (is_err(iter_result)) return iter_result;
-      if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double) ctx.index));
-    } else if (vtype(src) == T_ARR || vtype(src) == T_OBJ) {
+      if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double)ctx.index));
+    } else if (vtype(src) == T_OBJ) {
       array_from_iter_ctx_t ctx = { write_target, result, mapFn, mapThis, 0 };
       jsoff_t len = get_array_length(js, src);
       for (jsoff_t i = 0; i < len; i++) {
@@ -19582,7 +8403,7 @@ static jsval_t builtin_Array_from(struct js *js, jsval_t *args, int nargs) {
         iter_action_t act = array_from_iter_cb(js, arr_get(js, src, i), &ctx, &unused);
         if (act == ITER_ERROR) return unused;
       }
-      if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double) len));
+      if (vtype(result) != T_ARR) js_setprop(js, result, js->length_str, tov((double)len));
     }
   }
 
@@ -19590,7 +8411,7 @@ static jsval_t builtin_Array_from(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_Array_of(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Array_of(ant_t *js, jsval_t *args, int nargs) {
   jsval_t ctor = js->this_val;
   bool use_ctor = (vtype(ctor) == T_FUNC || vtype(ctor) == T_CFUNC);
   jsval_t arr = use_ctor ? array_alloc_from_ctor_with_length(js, ctor, (jsoff_t)nargs) : mkarr(js);
@@ -19613,7 +8434,7 @@ static jsval_t builtin_Array_of(struct js *js, jsval_t *args, int nargs) {
   return arr;
 }
 
-static jsval_t builtin_string_indexOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_indexOf(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "indexOf called on non-string");
   if (nargs == 0) return tov(-1);
@@ -19645,7 +8466,7 @@ static jsval_t builtin_string_indexOf(struct js *js, jsval_t *args, int nargs) {
   return tov(-1);
 }
 
-static jsval_t builtin_string_substring(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_substring(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "substring called on non-string");
   jsoff_t byte_len, str_off = vstr(js, str, &byte_len);
@@ -19675,7 +8496,7 @@ static jsval_t builtin_string_substring(struct js *js, jsval_t *args, int nargs)
   return js_mkstr(js, str_ptr + byte_start, byte_end - byte_start);
 }
 
-static jsval_t builtin_string_substr(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_substr(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "substr called on non-string");
   jsoff_t byte_len, str_off = vstr(js, str, &byte_len);
@@ -19707,7 +8528,7 @@ static jsval_t builtin_string_substr(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, str_ptr + byte_start, byte_end - byte_start);
 }
 
-static jsval_t string_split_impl(struct js *js, jsval_t str, jsval_t *args, int nargs) {
+static jsval_t string_split_impl(ant_t *js, jsval_t str, jsval_t *args, int nargs) {
   if (vtype(str) != T_STR) return js_mkerr(js, "split called on non-string");
   jsoff_t str_len, str_off = vstr(js, str, &str_len);
   const char *str_ptr = (char *) &js->mem[str_off];
@@ -19887,7 +8708,7 @@ return_whole:
   return mkval(T_ARR, vdata(arr));
 }
 
-static jsval_t builtin_string_split(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_split(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "split called on non-string");
 
@@ -19901,7 +8722,7 @@ static jsval_t builtin_string_split(struct js *js, jsval_t *args, int nargs) {
       call_nargs = 2;
     }
     jsval_t dispatched = maybe_call_symbol_method(
-      js, args[0], get_split_sym_key(), args[0], call_args, call_nargs, &called
+      js, args[0], get_split_sym(), args[0], call_args, call_nargs, &called
     );
     if (is_err(dispatched)) return dispatched;
     if (called) return dispatched;
@@ -19910,7 +8731,7 @@ static jsval_t builtin_string_split(struct js *js, jsval_t *args, int nargs) {
   return string_split_impl(js, str, args, nargs);
 }
 
-static jsval_t builtin_string_slice(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_slice(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
   jsval_t str = js_tostring_val(js, this_unwrapped);
   if (is_err(str)) return str;
@@ -19941,7 +8762,7 @@ static jsval_t builtin_string_slice(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, str_ptr + byte_start, byte_end - byte_start);
 }
 
-static jsval_t builtin_string_includes(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_includes(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "includes called on non-string");
   if (nargs == 0) return mkval(T_BOOL, 0);
@@ -19976,7 +8797,7 @@ static jsval_t builtin_string_includes(struct js *js, jsval_t *args, int nargs)
   return mkval(T_BOOL, 0);
 }
 
-static jsval_t builtin_string_startsWith(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_startsWith(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "startsWith called on non-string");
   if (nargs == 0) return mkval(T_BOOL, 0);
@@ -20000,7 +8821,7 @@ static jsval_t builtin_string_startsWith(struct js *js, jsval_t *args, int nargs
   return mkval(T_BOOL, memcmp(str_ptr, search_ptr, search_len) == 0 ? 1 : 0);
 }
 
-static jsval_t builtin_string_endsWith(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_endsWith(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "endsWith called on non-string");
   if (nargs == 0) return mkval(T_BOOL, 0);
@@ -20025,7 +8846,7 @@ static jsval_t builtin_string_endsWith(struct js *js, jsval_t *args, int nargs)
   return mkval(T_BOOL, memcmp(str_ptr + str_len - search_len, search_ptr, search_len) == 0 ? 1 : 0);
 }
 
-static jsval_t builtin_string_replace(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_replace(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
   jsval_t str = js_tostring_val(js, this_unwrapped);
   if (is_err(str)) return str;
@@ -20036,7 +8857,7 @@ static jsval_t builtin_string_replace(struct js *js, jsval_t *args, int nargs) {
     jsval_t replacement_arg = nargs > 1 ? args[1] : js_mkundef();
     jsval_t call_args[2] = { str, replacement_arg };
     jsval_t dispatched = maybe_call_symbol_method(
-      js, args[0], get_replace_sym_key(), args[0], call_args, 2, &called
+      js, args[0], get_replace_sym(), args[0], call_args, 2, &called
     );
     if (is_err(dispatched)) return dispatched;
     if (called) return dispatched;
@@ -20161,7 +8982,7 @@ static jsval_t builtin_string_replace(struct js *js, jsval_t *args, int nargs) {
         cb_args[1 + capture_count] = tov((double)match_start);
         cb_args[2 + capture_count] = str;
 
-        jsval_t cb_result = js_call(js, replacement, cb_args, nargs_cb);
+        jsval_t cb_result = sv_vm_call(js->vm, js, replacement, js_mkundef(), cb_args, nargs_cb, NULL, false);
         free(cb_args);
 
         if (vtype(cb_result) == T_ERR) {
@@ -20183,64 +9004,15 @@ static jsval_t builtin_string_replace(struct js *js, jsval_t *args, int nargs) {
           result_len += n;
         }
       } else {
-        for (jsoff_t ri = 0; ri < repl_len; ) {
-          if (repl_ptr[ri] == '$' && ri + 1 < repl_len) {
-            char next = repl_ptr[ri + 1];
-            if (next == '$') {
-              ENSURE_RESULT_CAP(1);
-              result[result_len++] = '$';
-              ri += 2;
-            } else if (next == '&') {
-              PCRE2_SIZE mlen = match_end - match_start;
-              ENSURE_RESULT_CAP(mlen);
-              memcpy(result + result_len, str_ptr + match_start, mlen);
-              result_len += mlen;
-              ri += 2;
-            } else if (next == '`') {
-              ENSURE_RESULT_CAP(match_start);
-              memcpy(result + result_len, str_ptr, match_start);
-              result_len += match_start;
-              ri += 2;
-            } else if (next == '\'') {
-              PCRE2_SIZE after_len = str_len - match_end;
-              ENSURE_RESULT_CAP(after_len);
-              memcpy(result + result_len, str_ptr + match_end, after_len);
-              result_len += after_len;
-              ri += 2;
-            } else if (next >= '0' && next <= '9') {
-              int group_num = next - '0';
-              ri += 2;
-              if (ri < repl_len && repl_ptr[ri] >= '0' && repl_ptr[ri] <= '9') {
-                int second_digit = repl_ptr[ri] - '0';
-                int two_digit = group_num * 10 + second_digit;
-                if (two_digit <= (int)capture_count) {
-                  group_num = two_digit;
-                  ri++;
-                }
-              }
-              if (group_num > 0 && group_num <= (int)capture_count) {
-                PCRE2_SIZE cap_start = ovector[2*group_num];
-                PCRE2_SIZE cap_end = ovector[2*group_num+1];
-                if (cap_start != PCRE2_UNSET) {
-                  PCRE2_SIZE cap_len = cap_end - cap_start;
-                  ENSURE_RESULT_CAP(cap_len);
-                  memcpy(result + result_len, str_ptr + cap_start, cap_len);
-                  result_len += cap_len;
-                }
-              } else {
-                ENSURE_RESULT_CAP(2);
-                result[result_len++] = '$';
-                result[result_len++] = next;
-              }
-            } else {
-              ENSURE_RESULT_CAP(1);
-              result[result_len++] = repl_ptr[ri++];
-            }
-          } else {
-            ENSURE_RESULT_CAP(1);
-            result[result_len++] = repl_ptr[ri++];
-          }
+        repl_capture_t caps_buf[16], *caps = (int)capture_count <= 16 ? caps_buf : ant_calloc(sizeof(repl_capture_t) * capture_count);
+        for (uint32_t ci = 0; ci < capture_count; ci++) {
+          PCRE2_SIZE cs = ovector[2*(ci+1)], ce = ovector[2*(ci+1)+1];
+          if (cs != PCRE2_UNSET) caps[ci] = (repl_capture_t){ str_ptr + cs, ce - cs };
+          else caps[ci] = (repl_capture_t){ NULL, 0 };
         }
+        repl_template(repl_ptr, repl_len, str_ptr + match_start, match_end - match_start,
+          str_ptr, str_len, match_start, caps, (int)capture_count, &result, &result_len, &result_cap);
+        if (caps != caps_buf) free(caps);
       }
 
       if (match_start == match_end) {
@@ -20283,7 +9055,7 @@ static jsval_t builtin_string_replace(struct js *js, jsval_t *args, int nargs) {
         if (is_func_replacement) {
           jsval_t match_str = js_mkstr(js, search_ptr, search_len);
           jsval_t cb_args[1] = { match_str };
-          jsval_t cb_result = js_call(js, replacement, cb_args, 1);
+          jsval_t cb_result = sv_vm_call(js->vm, js, replacement, js_mkundef(), cb_args, 1, NULL, false);
           
           if (vtype(cb_result) == T_ERR) { free(result); return cb_result; }
           
@@ -20323,7 +9095,7 @@ static jsval_t builtin_string_replace(struct js *js, jsval_t *args, int nargs) {
 #undef ENSURE_RESULT_CAP
 }
 
-static jsval_t builtin_string_replaceAll(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_replaceAll(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "replaceAll called on non-string");
   if (nargs < 2) return str;
@@ -20397,202 +9169,8 @@ static jsval_t builtin_string_replaceAll(struct js *js, jsval_t *args, int nargs
   return ret;
 }
 
-static size_t js_to_pcre2_pattern(const char *src, size_t src_len, char *dst, size_t dst_size) {
-  size_t di = 0;
-  for (size_t si = 0; si < src_len && di < dst_size - 1; si++) {
-    if (src[si] == '\\' && si + 1 < src_len) {
-      char next = src[si + 1];
-      
-      if (next == 'u' && si + 5 < src_len) {
-        bool valid = true;
-        for (int i = 0; i < 4; i++) {
-          char c = src[si + 2 + i];
-          if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
-            valid = false;
-            break;
-          }
-        }
-        if (valid && di + 8 < dst_size) {
-          dst[di++] = '\\';
-          dst[di++] = 'x';
-          dst[di++] = '{';
-          dst[di++] = src[si + 2];
-          dst[di++] = src[si + 3];
-          dst[di++] = src[si + 4];
-          dst[di++] = src[si + 5];
-          dst[di++] = '}';
-          si += 5;
-          continue;
-        }
-      }
-      
-      if (next == '0' && (si + 2 >= src_len || src[si + 2] < '0' || src[si + 2] > '9')) {
-        if (di + 5 < dst_size) {
-          dst[di++] = '\\';
-          dst[di++] = 'x';
-          dst[di++] = '{';
-          dst[di++] = '0';
-          dst[di++] = '}';
-          si += 1;
-          continue;
-        }
-      }
-    }
-    dst[di++] = src[si];
-  }
-  dst[di] = '\0';
-  return di;
-}
-
-static jsval_t do_regex_match_pcre2(
-  struct js *js, const char *pattern_ptr, jsoff_t pattern_len, 
-  const char *str_ptr, jsoff_t str_len, 
-  bool global_flag, bool ignore_case, bool multiline
-) {
-  char pcre2_pattern[512];
-  size_t pcre2_len = js_to_pcre2_pattern(pattern_ptr, pattern_len, pcre2_pattern, sizeof(pcre2_pattern));
-
-  uint32_t options = PCRE2_UTF | PCRE2_UCP | PCRE2_MATCH_UNSET_BACKREF;
-  if (ignore_case) options |= PCRE2_CASELESS;
-  if (multiline) options |= PCRE2_MULTILINE;
-
-  int errcode;
-  PCRE2_SIZE erroffset;
-  pcre2_code *re = pcre2_compile((PCRE2_SPTR)pcre2_pattern, pcre2_len, options, &errcode, &erroffset, NULL);
-  if (re == NULL) return js_mknull();
-
-  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
-  uint32_t capture_count;
-  pcre2_pattern_info(re, PCRE2_INFO_CAPTURECOUNT, &capture_count);
-
-  jsval_t result_arr = js_mkarr(js);
-  if (is_err(result_arr)) {
-    pcre2_match_data_free(match_data);
-    pcre2_code_free(re);
-    return result_arr;
-  }
-
-  PCRE2_SIZE pos = 0;
-  int match_count = 0;
-
-  while (pos <= str_len) {
-    int rc = pcre2_match(re, (PCRE2_SPTR)str_ptr, str_len, pos, 0, match_data, NULL);
-    if (rc < 0) break;
-
-    PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
-    PCRE2_SIZE match_start = ovector[0];
-    PCRE2_SIZE match_end = ovector[1];
-
-    if (global_flag) {
-      jsval_t match_str = js_mkstr(js, str_ptr + match_start, match_end - match_start);
-      if (is_err(match_str)) {
-        pcre2_match_data_free(match_data);
-        pcre2_code_free(re);
-        return match_str;
-      }
-      js_arr_push(js, result_arr, match_str);
-    } else {
-      for (uint32_t i = 0; i <= capture_count; i++) {
-        PCRE2_SIZE start = ovector[2*i];
-        PCRE2_SIZE end = ovector[2*i+1];
-        if (start == PCRE2_UNSET) {
-          js_arr_push(js, result_arr, js_mkundef());
-        } else {
-          jsval_t match_str = js_mkstr(js, str_ptr + start, end - start);
-          if (is_err(match_str)) {
-            pcre2_match_data_free(match_data);
-            pcre2_code_free(re);
-            return match_str;
-          }
-          js_arr_push(js, result_arr, match_str);
-        }
-      }
-      js_setprop(js, result_arr, js_mkstr(js, "index", 5), tov((double)match_start));
-    }
-    match_count++;
-
-    if (!global_flag) break;
-
-    if (match_start == match_end) {
-      pos = match_end + 1;
-    } else { pos = match_end; }
-  }
-
-  pcre2_match_data_free(match_data);
-  pcre2_code_free(re);
-
-  if (match_count == 0) return js_mknull();
-  return result_arr;
-}
-
-static jsval_t builtin_string_match(struct js *js, jsval_t *args, int nargs) {
-  jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
-  jsval_t str = js_tostring_val(js, this_unwrapped);
-  if (is_err(str)) return str;
-  if (nargs < 1) return js_mknull();
-  
-  if (is_object_type(args[0])) {
-    bool called = false;
-    jsval_t call_args[1] = { str };
-    jsval_t dispatched = maybe_call_symbol_method(
-      js, args[0], get_match_sym_key(), args[0], call_args, 1, &called
-    );
-    if (is_err(dispatched)) return dispatched;
-    if (called) return dispatched;
-  }
-
-  jsval_t pattern = args[0];
-  const char *pattern_ptr = NULL;
-  jsoff_t pattern_len = 0;
-  bool global_flag = false;
-  bool ignore_case = false;
-  bool multiline = false;
-
-  if (vtype(pattern) == T_OBJ) {
-    jsoff_t source_off = lkp(js, pattern, "source", 6);
-    if (source_off == 0) return js_mknull();
-
-    jsval_t source_val = resolveprop(js, mkval(T_PROP, source_off));
-    if (vtype(source_val) != T_STR) return js_mknull();
-
-    jsoff_t poff;
-    poff = vstr(js, source_val, &pattern_len);
-    pattern_ptr = (char *) &js->mem[poff];
-
-    jsoff_t flags_off = lkp(js, pattern, "flags", 5);
-    if (flags_off != 0) {
-      jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
-      if (vtype(flags_val) == T_STR) {
-        jsoff_t flen, foff = vstr(js, flags_val, &flen);
-        const char *flags_str = (char *) &js->mem[foff];
-        for (jsoff_t i = 0; i < flen; i++) {
-          if (flags_str[i] == 'g') global_flag = true;
-          if (flags_str[i] == 'i') ignore_case = true;
-          if (flags_str[i] == 'm') multiline = true;
-        }
-      }
-    }
-  } else if (vtype(pattern) == T_STR) {
-    jsoff_t poff;
-    poff = vstr(js, pattern, &pattern_len);
-    pattern_ptr = (char *) &js->mem[poff];
-  } else {
-    return js_mknull();
-  }
-
-  jsoff_t str_len, str_off = vstr(js, str, &str_len);
-  const char *str_ptr = (char *) &js->mem[str_off];
-
-  jsval_t result = do_regex_match_pcre2(js, pattern_ptr, pattern_len, str_ptr, str_len, global_flag, ignore_case, multiline);
-  
-  if (!global_flag && vtype(result) == T_ARR) {
-    js_setprop(js, result, js_mkstr(js, "input", 5), str);
-  }
-
-  return result;
-}
 
-static jsval_t builtin_string_template(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_template(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "template called on non-string");
   if (nargs < 1 || vtype(args[0]) != T_OBJ) return str;
@@ -20662,7 +9240,7 @@ static jsval_t builtin_string_template(struct js *js, jsval_t *args, int nargs)
 #undef ENSURE_CAP
 }
 
-static jsval_t builtin_string_charCodeAt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_charCodeAt(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "charCodeAt called on non-string");
   
@@ -20682,7 +9260,7 @@ static jsval_t builtin_string_charCodeAt(struct js *js, jsval_t *args, int nargs
   return tov((double) code_unit);
 }
 
-static jsval_t builtin_string_codePointAt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_codePointAt(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "codePointAt called on non-string");
   
@@ -20703,49 +9281,89 @@ static jsval_t builtin_string_codePointAt(struct js *js, jsval_t *args, int narg
   return tov((double) cp);
 }
 
-static jsval_t builtin_string_toLowerCase(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_toLowerCase(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "toLowerCase called on non-string");
   
   jsoff_t str_len, str_off = vstr(js, str, &str_len);
   const char *str_ptr = (char *) &js->mem[str_off];
-  jsval_t result = js_mkstr(js, NULL, str_len);
+  if (str_len == 0) return js_mkstr(js, "", 0);
+
+  const utf8proc_uint8_t *src = (const utf8proc_uint8_t *)str_ptr;
+  utf8proc_ssize_t src_len = (utf8proc_ssize_t)str_len;
+
+  jsoff_t out_len = 0;
+  utf8proc_ssize_t pos = 0;
+  while (pos < src_len) {
+    utf8proc_int32_t cp;
+    utf8proc_ssize_t n = utf8_next(src + pos, src_len - pos, &cp);
+    if (cp < 0) { out_len++; pos++; continue; }
+    utf8proc_uint8_t tmp[4];
+    out_len += (jsoff_t)utf8proc_encode_char(utf8proc_tolower(cp), tmp);
+    pos += n;
+  }
+
+  jsval_t result = js_mkstr(js, NULL, out_len);
   if (is_err(result)) return result;
-  
   jsoff_t result_len, result_off = vstr(js, result, &result_len);
   char *result_ptr = (char *) &js->mem[result_off];
-  
-  for (jsoff_t i = 0; i < str_len; i++) {
-    char ch = str_ptr[i];
-    result_ptr[i] = (ch >= 'A' && ch <= 'Z') ? ch + 32 : ch;
+
+  pos = 0;
+  jsoff_t wpos = 0;
+  while (pos < src_len) {
+    utf8proc_int32_t cp;
+    utf8proc_ssize_t n = utf8_next(src + pos, src_len - pos, &cp);
+    if (cp < 0) { result_ptr[wpos++] = (char)src[pos]; pos++; continue; }
+    wpos += (jsoff_t)utf8proc_encode_char(utf8proc_tolower(cp), (utf8proc_uint8_t *)(result_ptr + wpos));
+    pos += n;
   }
-  
+
   return result;
 }
 
-static jsval_t builtin_string_toUpperCase(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_toUpperCase(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "toUpperCase called on non-string");
   
   jsoff_t str_len, str_off = vstr(js, str, &str_len);
   const char *str_ptr = (char *) &js->mem[str_off];
-  jsval_t result = js_mkstr(js, NULL, str_len);
+  if (str_len == 0) return js_mkstr(js, "", 0);
+
+  const utf8proc_uint8_t *src = (const utf8proc_uint8_t *)str_ptr;
+  utf8proc_ssize_t src_len = (utf8proc_ssize_t)str_len;
+
+  jsoff_t out_len = 0;
+  utf8proc_ssize_t pos = 0;
+  while (pos < src_len) {
+    utf8proc_int32_t cp;
+    utf8proc_ssize_t n = utf8_next(src + pos, src_len - pos, &cp);
+    if (cp < 0) { out_len++; pos++; continue; }
+    utf8proc_uint8_t tmp[4];
+    out_len += (jsoff_t)utf8proc_encode_char(utf8proc_toupper(cp), tmp);
+    pos += n;
+  }
+
+  jsval_t result = js_mkstr(js, NULL, out_len);
   if (is_err(result)) return result;
-  
   jsoff_t result_len, result_off = vstr(js, result, &result_len);
   char *result_ptr = (char *) &js->mem[result_off];
-  
-  for (jsoff_t i = 0; i < str_len; i++) {
-    char ch = str_ptr[i];
-    result_ptr[i] = (ch >= 'a' && ch <= 'z') ? ch - 32 : ch;
+
+  pos = 0;
+  jsoff_t wpos = 0;
+  while (pos < src_len) {
+    utf8proc_int32_t cp;
+    utf8proc_ssize_t n = utf8_next(src + pos, src_len - pos, &cp);
+    if (cp < 0) { result_ptr[wpos++] = (char)src[pos]; pos++; continue; }
+    wpos += (jsoff_t)utf8proc_encode_char(utf8proc_toupper(cp), (utf8proc_uint8_t *)(result_ptr + wpos));
+    pos += n;
   }
-  
+
   return result;
 }
 
-static jsval_t builtin_string_trim(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_trim(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "trim called on non-string");
@@ -20760,7 +9378,7 @@ static jsval_t builtin_string_trim(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, str_ptr + start, end - start);
 }
 
-static jsval_t builtin_string_trimStart(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_trimStart(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "trimStart called on non-string");
@@ -20774,7 +9392,7 @@ static jsval_t builtin_string_trimStart(struct js *js, jsval_t *args, int nargs)
   return js_mkstr(js, str_ptr + start, str_len - start);
 }
 
-static jsval_t builtin_string_trimEnd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_trimEnd(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "trimEnd called on non-string");
@@ -20788,7 +9406,7 @@ static jsval_t builtin_string_trimEnd(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, str_ptr, end);
 }
 
-static jsval_t builtin_string_repeat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_repeat(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "repeat called on non-string");
   if (nargs < 1 || vtype(args[0]) != T_NUM) return js_mkerr(js, "repeat count required");
@@ -20815,82 +9433,119 @@ static jsval_t builtin_string_repeat(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_string_padStart(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_padStart(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "padStart called on non-string");
   if (nargs < 1 || vtype(args[0]) != T_NUM) return str;
   
-  jsoff_t target_len = (jsoff_t) tod(args[0]);
+  jsoff_t target_len = (jsoff_t)tod(args[0]);
+  if (target_len <= 0) return str;
   jsoff_t str_len, str_off = vstr(js, str, &str_len);
   const char *str_ptr = (char *) &js->mem[str_off];
+  size_t str_utf16_len = utf16_strlen(str_ptr, (size_t)str_len);
   
-  if (target_len <= str_len) return str;
+  if ((size_t)target_len <= str_utf16_len) return str;
   
-  const char *pad_str = " ";
-  jsoff_t pad_len = 1;
-  if (nargs >= 2 && vtype(args[1]) == T_STR) {
-    jsoff_t pad_off = vstr(js, args[1], &pad_len);
-    pad_str = (char *) &js->mem[pad_off];
+  jsval_t pad_val = js_mkstr(js, " ", 1);
+  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
+    pad_val = coerce_to_str(js, args[1]);
+    if (is_err(pad_val)) return pad_val;
   }
+  jsoff_t pad_len, pad_off = vstr(js, pad_val, &pad_len);
+  const char *pad_str = (char *)&js->mem[pad_off];
+  size_t pad_utf16_len = utf16_strlen(pad_str, (size_t)pad_len);
   
-  if (pad_len == 0) return str;
+  if (pad_utf16_len == 0) return str;
   
-  jsoff_t fill_len = target_len - str_len;
-  jsval_t result = js_mkstr(js, NULL, target_len);
+  size_t fill_utf16_len = (size_t)target_len - str_utf16_len;
+  size_t full_repeats = fill_utf16_len / pad_utf16_len;
+  size_t rem_utf16 = fill_utf16_len % pad_utf16_len;
+  size_t rem_bytes = 0;
+  if (rem_utf16 > 0) {
+    int off = utf16_index_to_byte_offset(pad_str, (size_t)pad_len, rem_utf16, NULL);
+    if (off < 0) return str;
+    rem_bytes = (size_t)off;
+  }
+  size_t fill_bytes = full_repeats * (size_t)pad_len + rem_bytes;
+  size_t total_bytes = fill_bytes + (size_t)str_len;
+
+  jsval_t result = js_mkstr(js, NULL, (jsoff_t)total_bytes);
   if (is_err(result)) return result;
   
   jsoff_t result_len, result_off = vstr(js, result, &result_len);
   char *result_ptr = (char *) &js->mem[result_off];
   
-  jsoff_t pos = 0;
-  while (pos < fill_len) {
-    jsoff_t copy_len = (fill_len - pos < pad_len) ? fill_len - pos : pad_len;
-    memcpy(result_ptr + pos, pad_str, copy_len);
-    pos += copy_len;
+  size_t pos = 0;
+  for (size_t i = 0; i < full_repeats; i++) {
+    memcpy(result_ptr + pos, pad_str, (size_t)pad_len);
+    pos += (size_t)pad_len;
+  }
+  if (rem_bytes > 0) {
+    memcpy(result_ptr + pos, pad_str, rem_bytes);
+    pos += rem_bytes;
   }
-  memcpy(result_ptr + fill_len, str_ptr, str_len);
+  memcpy(result_ptr + pos, str_ptr, (size_t)str_len);
   
   return result;
 }
 
-static jsval_t builtin_string_padEnd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_padEnd(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "padEnd called on non-string");
   if (nargs < 1 || vtype(args[0]) != T_NUM) return str;
   
-  jsoff_t target_len = (jsoff_t) tod(args[0]);
+  jsoff_t target_len = (jsoff_t)tod(args[0]);
+  if (target_len <= 0) return str;
   jsoff_t str_len, str_off = vstr(js, str, &str_len);
   const char *str_ptr = (char *) &js->mem[str_off];
+  size_t str_utf16_len = utf16_strlen(str_ptr, (size_t)str_len);
   
-  if (target_len <= str_len) return str;
+  if ((size_t)target_len <= str_utf16_len) return str;
   
-  const char *pad_str = " ";
-  jsoff_t pad_len = 1;
-  if (nargs >= 2 && vtype(args[1]) == T_STR) {
-    jsoff_t pad_off = vstr(js, args[1], &pad_len);
-    pad_str = (char *) &js->mem[pad_off];
+  jsval_t pad_val = js_mkstr(js, " ", 1);
+  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
+    pad_val = coerce_to_str(js, args[1]);
+    if (is_err(pad_val)) return pad_val;
   }
+  jsoff_t pad_len, pad_off = vstr(js, pad_val, &pad_len);
+  const char *pad_str = (char *) &js->mem[pad_off];
+  size_t pad_utf16_len = utf16_strlen(pad_str, (size_t)pad_len);
   
-  if (pad_len == 0) return str;
+  if (pad_utf16_len == 0) return str;
   
-  jsval_t result = js_mkstr(js, NULL, target_len);
+  size_t fill_utf16_len = (size_t)target_len - str_utf16_len;
+  size_t full_repeats = fill_utf16_len / pad_utf16_len;
+  size_t rem_utf16 = fill_utf16_len % pad_utf16_len;
+  size_t rem_bytes = 0;
+  if (rem_utf16 > 0) {
+    int off = utf16_index_to_byte_offset(pad_str, (size_t)pad_len, rem_utf16, NULL);
+    if (off < 0) return str;
+    rem_bytes = (size_t)off;
+  }
+  size_t fill_bytes = full_repeats * (size_t)pad_len + rem_bytes;
+  size_t total_bytes = (size_t)str_len + fill_bytes;
+
+  jsval_t result = js_mkstr(js, NULL, (jsoff_t)total_bytes);
   if (is_err(result)) return result;
   
   jsoff_t result_len, result_off = vstr(js, result, &result_len);
   char *result_ptr = (char *) &js->mem[result_off];
   
-  memcpy(result_ptr, str_ptr, str_len);
-  jsoff_t pos = str_len;
-  while (pos < target_len) {
-    jsoff_t copy_len = (target_len - pos < pad_len) ? target_len - pos : pad_len;
-    memcpy(result_ptr + pos, pad_str, copy_len);
-    pos += copy_len;
+  memcpy(result_ptr, str_ptr, (size_t)str_len);
+  size_t pos = (size_t)str_len;
+  for (size_t i = 0; i < full_repeats; i++) {
+    memcpy(result_ptr + pos, pad_str, (size_t)pad_len);
+    pos += (size_t)pad_len;
+  }
+  if (rem_bytes > 0) {
+    memcpy(result_ptr + pos, pad_str, rem_bytes);
+    pos += rem_bytes;
   }
   
   return result;
 }
 
-static jsval_t builtin_string_charAt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_charAt(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "charAt called on non-string");
   
@@ -20912,7 +9567,7 @@ static jsval_t builtin_string_charAt(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, str_data + byte_offset, char_bytes);
 }
 
-static jsval_t builtin_string_at(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_at(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "at called on non-string");
   
@@ -20934,7 +9589,7 @@ static jsval_t builtin_string_at(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, str_data + byte_offset, char_bytes);
 }
 
-static jsval_t builtin_string_localeCompare(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_localeCompare(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "localeCompare called on non-string");
   if (nargs < 1) return tov(0);
@@ -20957,7 +9612,7 @@ static jsval_t builtin_string_localeCompare(struct js *js, jsval_t *args, int na
   return tov(0);
 }
 
-static jsval_t builtin_string_lastIndexOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_lastIndexOf(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "lastIndexOf called on non-string");
   if (nargs == 0) return tov(-1);
@@ -20991,7 +9646,7 @@ static jsval_t builtin_string_lastIndexOf(struct js *js, jsval_t *args, int narg
   return tov(-1);
 }
 
-static jsval_t builtin_string_concat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_concat(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
   jsval_t str = js_tostring_val(js, this_unwrapped);
   if (is_err(str)) return str;
@@ -21039,7 +9694,50 @@ static jsval_t builtin_string_concat(struct js *js, jsval_t *args, int nargs) {
   return ret;
 }
 
-static jsval_t builtin_string_fromCharCode(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_normalize(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t str = to_string_val(js, js->this_val);
+  if (vtype(str) != T_STR) return js_mkerr(js, "normalize called on non-string");
+
+  jsoff_t str_len, str_off = vstr(js, str, &str_len);
+  const char *str_ptr = (const char *)&js->mem[str_off];
+
+  if (str_len == 0) return js_mkstr(js, "", 0);
+  utf8proc_option_t opts = UTF8PROC_COMPOSE | UTF8PROC_STABLE;
+
+  if (nargs >= 1 && vtype(args[0]) != T_UNDEF) {
+    jsval_t form_val = js_tostring_val(js, args[0]);
+    if (is_err(form_val)) return form_val;
+    jsoff_t flen, foff = vstr(js, form_val, &flen);
+    const char *form = (const char *)&js->mem[foff];
+
+    if (flen == 3 && memcmp(form, "NFC", 3) == 0) {
+      opts = UTF8PROC_COMPOSE | UTF8PROC_STABLE;
+    } else if (flen == 3 && memcmp(form, "NFD", 3) == 0) {
+      opts = UTF8PROC_DECOMPOSE | UTF8PROC_STABLE;
+    } else if (flen == 4 && memcmp(form, "NFKC", 4) == 0) {
+      opts = UTF8PROC_COMPOSE | UTF8PROC_STABLE | UTF8PROC_COMPAT;
+    } else if (flen == 4 && memcmp(form, "NFKD", 4) == 0) {
+      opts = UTF8PROC_DECOMPOSE | UTF8PROC_STABLE | UTF8PROC_COMPAT;
+    } else return js_mkerr_typed(js, JS_ERR_RANGE, "The normalization form should be one of NFC, NFD, NFKC, NFKD");
+  }
+
+  utf8proc_uint8_t *result = NULL;
+  utf8proc_ssize_t rlen = utf8proc_map(
+    (const utf8proc_uint8_t *)str_ptr, (utf8proc_ssize_t)str_len, &result, opts
+  );
+
+  if (rlen < 0 || !result) {
+    if (result) free(result);
+    return js_mkstr(js, str_ptr, str_len);
+  }
+
+  jsval_t ret = js_mkstr(js, (const char *)result, (jsoff_t)rlen);
+  free(result);
+  
+  return ret;
+}
+
+static jsval_t builtin_string_fromCharCode(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkstr(js, "", 0);
 
   char *buf = (char *)ant_calloc(nargs + 1);
@@ -21057,7 +9755,7 @@ static jsval_t builtin_string_fromCharCode(struct js *js, jsval_t *args, int nar
   return ret;
 }
 
-static jsval_t builtin_string_fromCodePoint(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_fromCodePoint(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return js_mkstr(js, "", 0);
 
   char *buf = (char *)ant_calloc(nargs * 4 + 1);
@@ -21088,14 +9786,100 @@ static jsval_t builtin_string_fromCodePoint(struct js *js, jsval_t *args, int na
       buf[len++] = (char)(0x80 | (cp & 0x3F));
     }
   }
-  buf[len] = '\0';
+  buf[len] = '\0';
+
+  jsval_t ret = js_mkstr(js, buf, len);
+  free(buf);
+  return ret;
+}
+
+static bool string_builder_append_value(
+  ant_t *js, char **buf,
+  size_t *len, size_t *cap,
+  jsval_t value, jsval_t *err
+) {
+  jsval_t s = js_tostring_val(js, value);
+  if (is_err(s)) {
+    if (err) *err = s;
+    return false;
+  }
+
+  jsoff_t slen = 0;
+  jsoff_t soff = vstr(js, s, &slen);
+  
+  size_t need = *len + (size_t)slen + 1;
+  if (need > *cap) {
+    size_t next = (*cap == 0) ? 64 : *cap;
+    while (next < need) next *= 2;
+    char *grown = (char *)realloc(*buf, next);
+    if (!grown) {
+      if (err) *err = js_mkerr(js, "oom");
+      return false;
+    }
+    *buf = grown;
+    *cap = next;
+  }
+
+  if (slen > 0) memcpy(*buf + *len, &js->mem[soff], (size_t)slen);
+  *len += (size_t)slen;
+  (*buf)[*len] = '\0';
+  return true;
+}
+
+static jsval_t builtin_string_raw(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || is_null(args[0]) || is_undefined(args[0])) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "String.raw requires a template object");
+  }
+
+  jsval_t tmpl = args[0];
+  if (!is_object_type(tmpl)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "String.raw requires a template object");
+  }
+
+  jsval_t raw = js_get(js, tmpl, "raw");
+  if (is_null(raw) || is_undefined(raw) || !is_object_type(raw)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "String.raw requires template.raw");
+  }
+
+  jsval_t raw_len_val = js_get(js, raw, "length");
+  double raw_len_num = js_to_number(js, raw_len_val);
+  if (!isfinite(raw_len_num) || raw_len_num <= 0) return js_mkstr(js, "", 0);
+
+  size_t literal_count = (size_t)raw_len_num;
+  if (literal_count == 0) return js_mkstr(js, "", 0);
+
+  char *buf = NULL;
+  size_t len = 0; size_t cap = 0;
+  jsval_t err = js_mkundef();
+
+  for (size_t i = 0; i < literal_count; i++) {
+    jsval_t chunk = js_mkundef();
+    if (vtype(raw) == T_ARR) chunk = js_arr_get(js, raw, (jsoff_t)i);
+    else {
+      char key[32];
+      snprintf(key, sizeof(key), "%zu", i);
+      chunk = js_get(js, raw, key);
+    }
+
+    if (!string_builder_append_value(js, &buf, &len, &cap, chunk, &err)) {
+      free(buf);
+      return is_err(err) ? err : js_mkerr(js, "oom");
+    }
+
+    if (i + 1 < literal_count && (int)(i + 1) < nargs) {
+      if (!string_builder_append_value(js, &buf, &len, &cap, args[i + 1], &err)) {
+        free(buf); return is_err(err) ? err : js_mkerr(js, "oom");
+      }
+    }
+  }
 
-  jsval_t ret = js_mkstr(js, buf, len);
+  jsval_t out = js_mkstr(js, buf ? buf : "", len);
   free(buf);
-  return ret;
+  
+  return out;
 }
 
-static jsval_t builtin_number_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_number_toString(ant_t *js, jsval_t *args, int nargs) {
   jsval_t num = unwrap_primitive(js, js->this_val);
   if (vtype(num) != T_NUM) return js_mkerr(js, "toString called on non-number");
   
@@ -21165,7 +9949,7 @@ static jsval_t builtin_number_toString(struct js *js, jsval_t *args, int nargs)
   return js_mkstr(js, p, int_len);
 }
 
-static jsval_t builtin_number_toFixed(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_number_toFixed(ant_t *js, jsval_t *args, int nargs) {
   jsval_t num = unwrap_primitive(js, js->this_val);
   if (vtype(num) != T_NUM) return js_mkerr(js, "toFixed called on non-number");
   
@@ -21226,7 +10010,7 @@ static jsval_t builtin_number_toFixed(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, buf, pos);
 }
 
-static jsval_t builtin_number_toPrecision(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_number_toPrecision(ant_t *js, jsval_t *args, int nargs) {
   jsval_t num = unwrap_primitive(js, js->this_val);
   if (vtype(num) != T_NUM) return js_mkerr(js, "toPrecision called on non-number");
   
@@ -21331,7 +10115,7 @@ static jsval_t builtin_number_toPrecision(struct js *js, jsval_t *args, int narg
   }
 }
 
-static jsval_t builtin_number_toExponential(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_number_toExponential(ant_t *js, jsval_t *args, int nargs) {
   jsval_t num = unwrap_primitive(js, js->this_val);
   if (vtype(num) != T_NUM) return js_mkerr(js, "toExponential called on non-number");
   
@@ -21412,48 +10196,66 @@ static jsval_t builtin_number_toExponential(struct js *js, jsval_t *args, int na
   return js_mkstr(js, buf, strlen(buf));
 }
 
-static jsval_t builtin_number_valueOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_number_valueOf(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t num = unwrap_primitive(js, js->this_val);
   if (vtype(num) != T_NUM) return js_mkerr(js, "valueOf called on non-number");
   return num;
 }
 
-static jsval_t builtin_number_toLocaleString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_number_toLocaleString(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t num = unwrap_primitive(js, js->this_val);
   if (vtype(num) != T_NUM) return js_mkerr(js, "toLocaleString called on non-number");
-  char buf[64];
-  strnum(num, buf, sizeof(buf));
-  return js_mkstr(js, buf, strlen(buf));
+  double d = tod(num);
+  char raw[64];
+  strnum(num, raw, sizeof(raw));
+  if (!isfinite(d) || strchr(raw, 'e') || strchr(raw, 'E'))
+    return js_mkstr(js, raw, strlen(raw));
+  char *dot = strchr(raw, '.');
+  size_t int_len = dot ? (size_t)(dot - raw) : strlen(raw);
+  size_t start = (raw[0] == '-') ? 1 : 0;
+  size_t frac_len = dot ? strlen(dot) : 0;
+  char buf[128];
+  size_t pos = 0;
+  if (start) buf[pos++] = '-';
+  for (size_t i = start; i < int_len; i++) {
+    buf[pos++] = raw[i];
+    size_t remaining = int_len - 1 - i;
+    if (remaining > 0 && remaining % 3 == 0) buf[pos++] = ',';
+  }
+  if (frac_len) memcpy(buf + pos, dot, frac_len);
+  pos += frac_len;
+  buf[pos] = '\0';
+  return js_mkstr(js, buf, pos);
 }
 
-static jsval_t builtin_string_valueOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_valueOf(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t str = to_string_val(js, js->this_val);
   if (vtype(str) != T_STR) return js_mkerr(js, "valueOf called on non-string");
   return str;
 }
 
-static jsval_t builtin_string_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_string_toString(ant_t *js, jsval_t *args, int nargs) {
   return builtin_string_valueOf(js, args, nargs);
 }
 
-static jsval_t builtin_boolean_valueOf(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_boolean_valueOf(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t b = unwrap_primitive(js, js->this_val);
   if (vtype(b) != T_BOOL) return js_mkerr(js, "valueOf called on non-boolean");
   return b;
 }
 
-static jsval_t builtin_boolean_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_boolean_toString(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t b = unwrap_primitive(js, js->this_val);
   if (vtype(b) != T_BOOL) return js_mkerr(js, "toString called on non-boolean");
   return vdata(b) ? js_mkstr(js, "true", 4) : js_mkstr(js, "false", 5);
 }
 
-static jsval_t builtin_parseInt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_parseInt(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return tov(JS_NAN);
   
   jsval_t str_val = args[0];
@@ -21518,7 +10320,7 @@ static jsval_t builtin_parseInt(struct js *js, jsval_t *args, int nargs) {
   return tov(sign * result);
 }
 
-static jsval_t builtin_parseFloat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_parseFloat(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return tov(JS_NAN);
   
   jsval_t str_val = args[0];
@@ -21543,7 +10345,7 @@ static jsval_t builtin_parseFloat(struct js *js, jsval_t *args, int nargs) {
   return tov(result);
 }
 
-static jsval_t builtin_btoa(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_btoa(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "btoa requires 1 argument");
   
   jsval_t str_val = args[0];
@@ -21565,7 +10367,7 @@ static jsval_t builtin_btoa(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_atob(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_atob(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "atob requires 1 argument");
   
   jsval_t str_val = args[0];
@@ -21588,12 +10390,12 @@ static jsval_t builtin_atob(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t builtin_resolve_internal(struct js *js, jsval_t *args, int nargs);
-static jsval_t builtin_reject_internal(struct js *js, jsval_t *args, int nargs);
-static void resolve_promise(struct js *js, jsval_t p, jsval_t val);
-static void reject_promise(struct js *js, jsval_t p, jsval_t val);
+static jsval_t builtin_resolve_internal(ant_t *js, jsval_t *args, int nargs);
+static jsval_t builtin_reject_internal(ant_t *js, jsval_t *args, int nargs);
+static void resolve_promise(ant_t *js, jsval_t p, jsval_t val);
+static void reject_promise(ant_t *js, jsval_t p, jsval_t val);
 
-static size_t strpromise(struct js *js, jsval_t value, char *buf, size_t len) {
+static size_t strpromise(ant_t *js, jsval_t value, char *buf, size_t len) {
   uint32_t pid = get_promise_id(js, value);
   promise_data_entry_t *pd = get_promise_data(pid, false);
   
@@ -21637,41 +10439,41 @@ static promise_data_entry_t *get_promise_data(uint32_t promise_id, bool create)
   return entry;
 }
 
-static uint32_t get_promise_id(struct js *js, jsval_t p) {
-  jsval_t p_obj = mkval(T_OBJ, vdata(p));
+static uint32_t get_promise_id(ant_t *js, jsval_t p) {
+  jsval_t p_obj = js_as_obj(p);
   jsval_t pid_val = get_slot(js, p_obj, SLOT_PID);
   if (vtype(pid_val) == T_UNDEF) return 0;
   return (uint32_t)tod(pid_val);
 }
 
-static jsval_t mkpromise(struct js *js) {
+static jsval_t mkpromise(ant_t *js) {
   jsval_t obj = mkobj(js, 0);
   if (is_err(obj)) return obj;
 
-  jsval_t promise_proto = get_ctor_proto(js, "Promise", 7);
-  if (is_object_type(promise_proto)) {
-    set_slot(js, obj, SLOT_PROTO, promise_proto);
-  }
+  uint32_t pid = next_promise_id++;
+  set_slot(js, obj, SLOT_PID, tov((double)pid));
 
   jsval_t promise_ctor = js_get(js, js_glob(js), "Promise");
   if (vtype(promise_ctor) == T_FUNC || vtype(promise_ctor) == T_CFUNC) {
     set_slot(js, obj, SLOT_CTOR, promise_ctor);
   }
-  
-  uint32_t pid = next_promise_id++;
-  set_slot(js, obj, SLOT_PID, tov((double)pid));
+
+  jsval_t promise_proto = get_ctor_proto(js, "Promise", 7);
+  if (is_object_type(promise_proto)) {
+    set_slot(js, obj, SLOT_PROTO, promise_proto);
+  }
   promise_data_entry_t *pd = get_promise_data(pid, true);
-  if (pd) pd->obj_offset = (jsoff_t)vdata(obj);
+  if (pd) pd->obj_offset = (jsoff_t)vdata(js_as_obj(obj));
   
   return mkval(T_PROMISE, vdata(obj));
 }
 
-static inline void trigger_handlers(struct js *js, jsval_t p) {
+static inline void trigger_handlers(ant_t *js, jsval_t p) {
   uint32_t pid = get_promise_id(js, p);
   queue_promise_trigger(pid);
 }
 
-void js_process_promise_handlers(struct js *js, uint32_t pid) {
+void js_process_promise_handlers(ant_t *js, uint32_t pid) {
   promise_data_entry_t *pd = get_promise_data(pid, false);
   if (!pd) return;
   
@@ -21688,19 +10490,19 @@ void js_process_promise_handlers(struct js *js, uint32_t pid) {
     if (vtype(handler) == T_FUNC || vtype(handler) == T_CFUNC) {
       jsval_t res;
       if (vtype(handler) == T_CFUNC) {
-        jsval_t (*fn)(struct js *, jsval_t *, int) = (jsval_t(*)(struct js *, jsval_t *, int)) vdata(handler);
+        jsval_t (*fn)(ant_t *, jsval_t *, int) = (jsval_t(*)(ant_t *, jsval_t *, int)) vdata(handler);
         res = fn(js, &val, 1);
       } else {
         jsval_t call_args[] = { val };
-        res = js_call(js, handler, call_args, 1);
+        res = sv_vm_call(js->vm, js, handler, js_mkundef(), call_args, 1, NULL, false);
       }
        
       if (is_err(res)) {
         jsval_t reject_val = js->thrown_value;
-        if (vtype(reject_val) == T_UNDEF) {
-          reject_val = js_mkstr(js, js->errmsg, strlen(js->errmsg));
-        }
+        if (vtype(reject_val) == T_UNDEF) reject_val = res;
+        js->thrown_exists = false;
         js->thrown_value = js_mkundef();
+        js->thrown_stack = js_mkundef();
         reject_promise(js, h->nextPromise, reject_val);
       } else resolve_promise(js, h->nextPromise, res);
     } else {
@@ -21713,7 +10515,7 @@ void js_process_promise_handlers(struct js *js, uint32_t pid) {
   utarray_clear(pd->handlers);
 }
 
-static void resolve_promise(struct js *js, jsval_t p, jsval_t val) {
+static void resolve_promise(ant_t *js, jsval_t p, jsval_t val) {
   uint32_t pid = get_promise_id(js, p);
   promise_data_entry_t *pd = get_promise_data(pid, false);
   if (!pd || pd->state != 0) return;
@@ -21726,20 +10528,20 @@ static void resolve_promise(struct js *js, jsval_t p, jsval_t val) {
     }
     
     jsval_t res_obj = mkobj(js, 0);
-    set_slot(js, res_obj, SLOT_CFUNC, js_mkfun(builtin_resolve_internal));
     set_slot(js, res_obj, SLOT_DATA, p);
-    jsval_t res_fn = mkval(T_FUNC, vdata(res_obj));
+    set_slot(js, res_obj, SLOT_CFUNC, js_mkfun(builtin_resolve_internal));
+    jsval_t res_fn = js_obj_to_func(res_obj);
     
     jsval_t rej_obj = mkobj(js, 0);
-    set_slot(js, rej_obj, SLOT_CFUNC, js_mkfun(builtin_reject_internal));
     set_slot(js, rej_obj, SLOT_DATA, p);
-    jsval_t rej_fn = mkval(T_FUNC, vdata(rej_obj));
+    set_slot(js, rej_obj, SLOT_CFUNC, js_mkfun(builtin_reject_internal));
+    jsval_t rej_fn = js_obj_to_func(rej_obj);
     
     jsval_t call_args[] = { res_fn, rej_fn };
     jsval_t then_prop = js_get(js, val, "then");
     
     if (vtype(then_prop) == T_FUNC || vtype(then_prop) == T_CFUNC) {
-      (void)js_call_with_this(js, then_prop, val, call_args, 2); return;
+      (void)sv_vm_call(js->vm, js, then_prop, val, call_args, 2, NULL, false); return;
     }
   }
 
@@ -21748,7 +10550,7 @@ static void resolve_promise(struct js *js, jsval_t p, jsval_t val) {
   trigger_handlers(js, p);
 }
 
-static void reject_promise(struct js *js, jsval_t p, jsval_t val) {
+static void reject_promise(ant_t *js, jsval_t p, jsval_t val) {
   uint32_t pid = get_promise_id(js, p);
   promise_data_entry_t *pd = get_promise_data(pid, false);
   if (!pd || pd->state != 0) return;
@@ -21767,7 +10569,7 @@ static void reject_promise(struct js *js, jsval_t p, jsval_t val) {
   trigger_handlers(js, p);
 }
 
-static jsval_t builtin_resolve_internal(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_resolve_internal(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t p = get_slot(js, me, SLOT_DATA);
   if (vtype(p) != T_PROMISE) return js_mkundef();
@@ -21775,7 +10577,7 @@ static jsval_t builtin_resolve_internal(struct js *js, jsval_t *args, int nargs)
   return js_mkundef();
 }
 
-static jsval_t builtin_reject_internal(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_reject_internal(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t p = get_slot(js, me, SLOT_DATA);
   if (vtype(p) != T_PROMISE) return js_mkundef();
@@ -21783,7 +10585,7 @@ static jsval_t builtin_reject_internal(struct js *js, jsval_t *args, int nargs)
   return js_mkundef();
 }
 
-static jsval_t builtin_Promise(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise(ant_t *js, jsval_t *args, int nargs) {
   if (vtype(js->new_target) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Promise constructor cannot be invoked without 'new'");
   }
@@ -21795,32 +10597,32 @@ static jsval_t builtin_Promise(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t p = mkpromise(js);
   jsval_t new_target = js->new_target;
-  jsval_t p_obj = mkval(T_OBJ, vdata(p));
+  jsval_t p_obj = js_as_obj(p);
   
   jsval_t promise_proto = get_ctor_proto(js, "Promise", 7);
   jsval_t instance_proto = js_instance_proto_from_new_target(js, promise_proto);
   
-  if (is_object_type(instance_proto)) set_slot(js, p_obj, SLOT_PROTO, instance_proto);
   if (vtype(new_target) == T_FUNC || vtype(new_target) == T_CFUNC) set_slot(js, p_obj, SLOT_CTOR, new_target);
+  if (is_object_type(instance_proto)) set_slot(js, p_obj, SLOT_PROTO, instance_proto);
   
   jsval_t res_obj = mkobj(js, 0);
-  set_slot(js, res_obj, SLOT_CFUNC, js_mkfun(builtin_resolve_internal));
   set_slot(js, res_obj, SLOT_DATA, p);
+  set_slot(js, res_obj, SLOT_CFUNC, js_mkfun(builtin_resolve_internal));
   
-  jsval_t res_fn = mkval(T_FUNC, vdata(res_obj));
+  jsval_t res_fn = js_obj_to_func(res_obj);
   jsval_t rej_obj = mkobj(js, 0);
   
-  set_slot(js, rej_obj, SLOT_CFUNC, js_mkfun(builtin_reject_internal));
   set_slot(js, rej_obj, SLOT_DATA, p);
+  set_slot(js, rej_obj, SLOT_CFUNC, js_mkfun(builtin_reject_internal));
   
-  jsval_t rej_fn = mkval(T_FUNC, vdata(rej_obj));
+  jsval_t rej_fn = js_obj_to_func(rej_obj);
   jsval_t exec_args[] = { res_fn, rej_fn };
-  js_call(js, args[0], exec_args, 2);
+  sv_vm_call(js->vm, js, args[0], js_mkundef(), exec_args, 2, NULL, false);
   
   return p;
 }
 
-static jsval_t builtin_Promise_resolve(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_resolve(ant_t *js, jsval_t *args, int nargs) {
   jsval_t val = nargs > 0 ? args[0] : js_mkundef();
   if (vtype(val) == T_PROMISE) return val;
   jsval_t p = mkpromise(js);
@@ -21828,24 +10630,24 @@ static jsval_t builtin_Promise_resolve(struct js *js, jsval_t *args, int nargs)
   return p;
 }
 
-static jsval_t builtin_Promise_reject(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_reject(ant_t *js, jsval_t *args, int nargs) {
   jsval_t val = nargs > 0 ? args[0] : js_mkundef();
   jsval_t p = mkpromise(js);
   reject_promise(js, p, val);
   return p;
 }
 
-static jsval_t promise_species_noop_executor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t promise_species_noop_executor(ant_t *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_promise_then(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_promise_then(ant_t *js, jsval_t *args, int nargs) {
   jsval_t p = js->this_val;
   if (vtype(p) != T_PROMISE) return js_mkerr(js, "not a promise");
   
   jsval_t promise_ctor = js_get(js, js_glob(js), "Promise");
   jsval_t species_ctor = promise_ctor;
-  jsval_t p_obj = mkval(T_OBJ, vdata(p));
+  jsval_t p_obj = js_as_obj(p);
   jsval_t ctor = js_get(js, p_obj, "constructor");
   
   if (is_err(ctor)) return ctor;
@@ -21862,36 +10664,21 @@ static jsval_t builtin_promise_then(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Promise species is not a constructor");
   }
   
-  if ((vtype(species_ctor) == T_FUNC || vtype(species_ctor) == T_CFUNC) 
-    && !(vtype(species_ctor) == vtype(promise_ctor) 
-    && vdata(species_ctor) == vdata(promise_ctor))
-  ) {
-    jsval_t seed = js_mkobj(js);
-    if (is_err(seed)) return seed;
-    jsval_t species_proto = js_get(js, species_ctor, "prototype");
-    
-    if (is_err(species_proto)) return species_proto;
-    if (is_object_type(species_proto)) set_proto(js, seed, species_proto);
-    
-    jsval_t exec = js_mkfun(promise_species_noop_executor);
-    jsval_t ctor_args[1] = { exec };
-    jsval_t saved_new_target = js->new_target;
-    
-    js->new_target = species_ctor;
-    jsval_t constructed = js_call_with_this(js, species_ctor, seed, ctor_args, 1);
-    js->new_target = saved_new_target;
-    
-    if (is_err(constructed)) return constructed;
-    return is_object_type(constructed) ? constructed : seed;
-  }
-  
   jsval_t nextP = mkpromise(js);
-  jsval_t p_proto = get_slot(js, mkval(T_OBJ, vdata(p)), SLOT_PROTO);
-  
-  if (vtype(p_proto) == T_OBJ) {
-    set_slot(js, mkval(T_OBJ, vdata(nextP)), SLOT_PROTO, p_proto);
-    jsval_t p_ctor = get_slot(js, mkval(T_OBJ, vdata(p)), SLOT_CTOR);
-    if (vtype(p_ctor) == T_FUNC) set_slot(js, mkval(T_OBJ, vdata(nextP)), SLOT_CTOR, p_ctor);
+  if ((vtype(species_ctor) == T_FUNC || vtype(species_ctor) == T_CFUNC)
+      && !(vtype(species_ctor) == vtype(promise_ctor)
+           && vdata(species_ctor) == vdata(promise_ctor))) {
+    jsval_t species_proto = js_get(js, species_ctor, "prototype");
+    if (is_object_type(species_proto))
+      set_proto(js, js_as_obj(nextP), species_proto);
+    set_slot(js, js_as_obj(nextP), SLOT_CTOR, species_ctor);
+  } else {
+    jsval_t p_proto = get_slot(js, js_as_obj(p), SLOT_PROTO);
+    if (vtype(p_proto) == T_OBJ) {
+      set_slot(js, js_as_obj(nextP), SLOT_PROTO, p_proto);
+      jsval_t p_ctor = get_slot(js, js_as_obj(p), SLOT_CTOR);
+      if (vtype(p_ctor) == T_FUNC) set_slot(js, js_as_obj(nextP), SLOT_CTOR, p_ctor);
+    }
   }
   
   jsval_t onFulfilled = nargs > 0 ? args[0] : js_mkundef();
@@ -21920,17 +10707,17 @@ static jsval_t builtin_promise_then(struct js *js, jsval_t *args, int nargs) {
   return nextP;
 }
 
-static jsval_t builtin_promise_catch(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_promise_catch(ant_t *js, jsval_t *args, int nargs) {
   jsval_t args_then[] = { js_mkundef(), nargs > 0 ? args[0] : js_mkundef() };
   return builtin_promise_then(js, args_then, 2);
 }
 
-static jsval_t finally_value_thunk(struct js *js, jsval_t *args, int nargs) {
+static jsval_t finally_value_thunk(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   return get_slot(js, me, SLOT_DATA);
 }
 
-static jsval_t finally_thrower(struct js *js, jsval_t *args, int nargs) {
+static jsval_t finally_thrower(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t reason = get_slot(js, me, SLOT_DATA);
   jsval_t rejected = js_mkpromise(js);
@@ -21938,63 +10725,63 @@ static jsval_t finally_thrower(struct js *js, jsval_t *args, int nargs) {
   return rejected;
 }
 
-static jsval_t finally_identity_reject(struct js *js, jsval_t *args, int nargs) {
+static jsval_t finally_identity_reject(ant_t *js, jsval_t *args, int nargs) {
   jsval_t reason = nargs > 0 ? args[0] : js_mkundef();
   jsval_t rejected = js_mkpromise(js);
   js_reject_promise(js, rejected, reason);
   return rejected;
 }
 
-static jsval_t finally_fulfilled_wrapper(struct js *js, jsval_t *args, int nargs) {
+static jsval_t finally_fulfilled_wrapper(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t callback = get_slot(js, me, SLOT_DATA);
   jsval_t value = nargs > 0 ? args[0] : js_mkundef();
   
   jsval_t result = js_mkundef();
   if (vtype(callback) == T_FUNC || vtype(callback) == T_CFUNC) {
-    result = js_call(js, callback, NULL, 0);
+    result = sv_vm_call(js->vm, js, callback, js_mkundef(), NULL, 0, NULL, false);
     if (is_err(result)) return result;
   }
   
   if (vtype(result) == T_PROMISE || (vtype(result) == T_OBJ && vtype(js_get(js, result, "then")) == T_FUNC)) {
     jsval_t thunk_obj = mkobj(js, 0);
-    set_slot(js, thunk_obj, SLOT_CFUNC, js_mkfun(finally_value_thunk));
     set_slot(js, thunk_obj, SLOT_DATA, value);
-    jsval_t thunk_fn = mkval(T_FUNC, vdata(thunk_obj));
+    set_slot(js, thunk_obj, SLOT_CFUNC, js_mkfun(finally_value_thunk));
+    jsval_t thunk_fn = js_obj_to_func(thunk_obj);
     
     jsval_t identity_rej_fn = js_mkfun(finally_identity_reject);
     
     jsval_t then_fn = js_get(js, result, "then");
     jsval_t call_args[] = { thunk_fn, identity_rej_fn };
-    return js_call_with_this(js, then_fn, result, call_args, 2);
+    return sv_vm_call(js->vm, js, then_fn, result, call_args, 2, NULL, false);
   }
   
   return value;
 }
 
-static jsval_t finally_rejected_wrapper(struct js *js, jsval_t *args, int nargs) {
+static jsval_t finally_rejected_wrapper(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t callback = get_slot(js, me, SLOT_DATA);
   jsval_t reason = nargs > 0 ? args[0] : js_mkundef();
   
   jsval_t result = js_mkundef();
   if (vtype(callback) == T_FUNC || vtype(callback) == T_CFUNC) {
-    result = js_call(js, callback, NULL, 0);
+    result = sv_vm_call(js->vm, js, callback, js_mkundef(), NULL, 0, NULL, false);
     if (is_err(result)) return result;
   }
   
   if (vtype(result) == T_PROMISE || (vtype(result) == T_OBJ && vtype(js_get(js, result, "then")) == T_FUNC)) {
     jsval_t thrower_obj = mkobj(js, 0);
-    set_slot(js, thrower_obj, SLOT_CFUNC, js_mkfun(finally_thrower));
     set_slot(js, thrower_obj, SLOT_DATA, reason);
+    set_slot(js, thrower_obj, SLOT_CFUNC, js_mkfun(finally_thrower));
     
-    jsval_t thrower_fn = mkval(T_FUNC, vdata(thrower_obj));
+    jsval_t thrower_fn = js_obj_to_func(thrower_obj);
     jsval_t identity_rej_fn = js_mkfun(finally_identity_reject);
     
     jsval_t then_prop = js_get(js, result, "then");
     jsval_t call_args[] = { thrower_fn, identity_rej_fn };
     
-    return js_call_with_this(js, then_prop, result, call_args, 2);
+    return sv_vm_call(js->vm, js, then_prop, result, call_args, 2, NULL, false);
   }
   
   jsval_t rejected = js_mkpromise(js);
@@ -22002,35 +10789,35 @@ static jsval_t finally_rejected_wrapper(struct js *js, jsval_t *args, int nargs)
   return rejected;
 }
 
-static jsval_t builtin_promise_finally(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_promise_finally(ant_t *js, jsval_t *args, int nargs) {
   jsval_t callback = nargs > 0 ? args[0] : js_mkundef();
   
   jsval_t fulfilled_obj = mkobj(js, 0);
-  set_slot(js, fulfilled_obj, SLOT_CFUNC, js_mkfun(finally_fulfilled_wrapper));
   set_slot(js, fulfilled_obj, SLOT_DATA, callback);
-  jsval_t fulfilled_fn = mkval(T_FUNC, vdata(fulfilled_obj));
+  set_slot(js, fulfilled_obj, SLOT_CFUNC, js_mkfun(finally_fulfilled_wrapper));
+  jsval_t fulfilled_fn = js_obj_to_func(fulfilled_obj);
   
   jsval_t rejected_obj = mkobj(js, 0);
-  set_slot(js, rejected_obj, SLOT_CFUNC, js_mkfun(finally_rejected_wrapper));
   set_slot(js, rejected_obj, SLOT_DATA, callback);
-  jsval_t rejected_fn = mkval(T_FUNC, vdata(rejected_obj));
+  set_slot(js, rejected_obj, SLOT_CFUNC, js_mkfun(finally_rejected_wrapper));
+  jsval_t rejected_fn = js_obj_to_func(rejected_obj);
   
   jsval_t args_then[] = { fulfilled_fn, rejected_fn };
   return builtin_promise_then(js, args_then, 2);
 }
 
-static jsval_t builtin_Promise_try(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_try(ant_t *js, jsval_t *args, int nargs) {
   if (nargs == 0) return builtin_Promise_resolve(js, args, 0);
   jsval_t fn = args[0];
   jsval_t *call_args = nargs > 1 ? &args[1] : NULL;
   int call_nargs = nargs > 1 ? nargs - 1 : 0;
-  jsval_t res = js_call_with_this(js, fn, js_mkundef(), call_args, call_nargs);
+  jsval_t res = sv_vm_call(js->vm, js, fn, js_mkundef(), call_args, call_nargs, NULL, false);
   if (is_err(res)) {
     jsval_t reject_val = js->thrown_value;
-    if (vtype(reject_val) == T_UNDEF) {
-      reject_val = js_mkstr(js, js->errmsg, strlen(js->errmsg));
-    }
+    if (vtype(reject_val) == T_UNDEF) reject_val = res;
+    js->thrown_exists = false;
     js->thrown_value = js_mkundef();
+    js->thrown_stack = js_mkundef();
     jsval_t rej_args[] = { reject_val };
     return builtin_Promise_reject(js, rej_args, 1);
   }
@@ -22038,21 +10825,42 @@ static jsval_t builtin_Promise_try(struct js *js, jsval_t *args, int nargs) {
   return builtin_Promise_resolve(js, res_args, 1);
 }
 
-static jsval_t mkpromise_with_ctor(struct js *js, jsval_t ctor) {
+static jsval_t builtin_Promise_withResolvers(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t p = mkpromise(js);
+  
+  jsval_t res_obj = mkobj(js, 0);
+  set_slot(js, res_obj, SLOT_DATA, p);
+  set_slot(js, res_obj, SLOT_CFUNC, js_mkfun(builtin_resolve_internal));
+  jsval_t res_fn = js_obj_to_func(res_obj);
+  
+  jsval_t rej_obj = mkobj(js, 0);
+  set_slot(js, rej_obj, SLOT_DATA, p);
+  set_slot(js, rej_obj, SLOT_CFUNC, js_mkfun(builtin_reject_internal));
+  jsval_t rej_fn = js_obj_to_func(rej_obj);
+  
+  jsval_t result = js_newobj(js);
+  js_setprop(js, result, js_mkstr(js, "promise", 7), p);
+  js_setprop(js, result, js_mkstr(js, "resolve", 7), res_fn);
+  js_setprop(js, result, js_mkstr(js, "reject", 6), rej_fn);
+  
+  return result;
+}
+
+static jsval_t mkpromise_with_ctor(ant_t *js, jsval_t ctor) {
   jsval_t p = mkpromise(js);
   if (vtype(ctor) != T_FUNC && vtype(ctor) != T_CFUNC) return p;
 
   jsval_t proto = js_get(js, ctor, "prototype");
   if (is_err(proto)) return proto;
   if (is_object_type(proto)) {
-    jsval_t p_obj = mkval(T_OBJ, vdata(p));
-    set_slot(js, p_obj, SLOT_PROTO, proto);
+    jsval_t p_obj = js_as_obj(p);
     set_slot(js, p_obj, SLOT_CTOR, ctor);
+    set_slot(js, p_obj, SLOT_PROTO, proto);
   }
   return p;
 }
 
-static jsval_t builtin_Promise_all_resolve_handler(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_all_resolve_handler(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t tracker = js_get(js, me, "tracker");
   jsval_t index_val = js_get(js, me, "index");
@@ -22075,7 +10883,7 @@ static jsval_t builtin_Promise_all_resolve_handler(struct js *js, jsval_t *args,
   return js_mkundef();
 }
 
-static jsval_t builtin_Promise_all_reject_handler(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_all_reject_handler(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t tracker = js_get(js, me, "tracker");
   jsval_t result_promise = get_slot(js, tracker, SLOT_DATA);
@@ -22091,7 +10899,7 @@ typedef struct {
   int index;
 } promise_all_iter_ctx_t;
 
-static iter_action_t promise_all_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
+static iter_action_t promise_all_iter_cb(ant_t *js, jsval_t value, void *ctx, jsval_t *out) {
   promise_all_iter_ctx_t *pctx = (promise_all_iter_ctx_t *)ctx;
   jsval_t item = value;
   
@@ -22104,12 +10912,12 @@ static iter_action_t promise_all_iter_cb(struct js *js, jsval_t value, void *ctx
   set_slot(js, resolve_obj, SLOT_CFUNC, js_mkfun(builtin_Promise_all_resolve_handler));
   js_setprop(js, resolve_obj, js_mkstr(js, "index", 5), tov((double)pctx->index));
   js_setprop(js, resolve_obj, js_mkstr(js, "tracker", 7), pctx->tracker);
-  jsval_t resolve_fn = mkval(T_FUNC, vdata(resolve_obj));
+  jsval_t resolve_fn = js_obj_to_func(resolve_obj);
   
   jsval_t reject_obj = mkobj(js, 0);
   set_slot(js, reject_obj, SLOT_CFUNC, js_mkfun(builtin_Promise_all_reject_handler));
   js_setprop(js, reject_obj, js_mkstr(js, "tracker", 7), pctx->tracker);
-  jsval_t reject_fn = mkval(T_FUNC, vdata(reject_obj));
+  jsval_t reject_fn = js_obj_to_func(reject_obj);
   
   jsval_t then_args[] = { resolve_fn, reject_fn };
   jsval_t saved_this = js->this_val;
@@ -22121,7 +10929,7 @@ static iter_action_t promise_all_iter_cb(struct js *js, jsval_t value, void *ctx
   return ITER_CONTINUE;
 }
 
-static jsval_t builtin_Promise_all(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_all(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Promise.all requires an iterable");
   
   jsval_t iterable = args[0];
@@ -22171,7 +10979,7 @@ typedef struct {
   bool settled;
 } promise_race_iter_ctx_t;
 
-static iter_action_t promise_race_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
+static iter_action_t promise_race_iter_cb(ant_t *js, jsval_t value, void *ctx, jsval_t *out) {
   promise_race_iter_ctx_t *pctx = (promise_race_iter_ctx_t *)ctx;
   jsval_t item = value;
   
@@ -22204,7 +11012,7 @@ static iter_action_t promise_race_iter_cb(struct js *js, jsval_t value, void *ct
   return ITER_CONTINUE;
 }
 
-static jsval_t builtin_Promise_race(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_race(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Promise.race requires an iterable");
   
   jsval_t iterable = args[0];
@@ -22219,12 +11027,12 @@ static jsval_t builtin_Promise_race(struct js *js, jsval_t *args, int nargs) {
   jsval_t resolve_obj = mkobj(js, 0);
   set_slot(js, resolve_obj, SLOT_CFUNC, js_mkfun(builtin_resolve_internal));
   set_slot(js, resolve_obj, SLOT_DATA, result_promise);
-  jsval_t resolve_fn = mkval(T_FUNC, vdata(resolve_obj));
+  jsval_t resolve_fn = js_obj_to_func(resolve_obj);
   
   jsval_t reject_obj = mkobj(js, 0);
   set_slot(js, reject_obj, SLOT_CFUNC, js_mkfun(builtin_reject_internal));
   set_slot(js, reject_obj, SLOT_DATA, result_promise);
-  jsval_t reject_fn = mkval(T_FUNC, vdata(reject_obj));
+  jsval_t reject_fn = js_obj_to_func(reject_obj);
   
   promise_race_iter_ctx_t ctx = {
     .result_promise = result_promise,
@@ -22239,21 +11047,21 @@ static jsval_t builtin_Promise_race(struct js *js, jsval_t *args, int nargs) {
   return result_promise;
 }
 
-static jsval_t mk_aggregate_error(struct js *js, jsval_t errors) {
+static jsval_t mk_aggregate_error(ant_t *js, jsval_t errors) {
   jsval_t args[] = { errors, js_mkstr(js, "All promises were rejected", 26) };
   jsoff_t off = lkp(js, js_glob(js), "AggregateError", 14);
   jsval_t ctor = off ? resolveprop(js, mkval(T_PROP, off)) : js_mkundef();
-  return js_call(js, ctor, args, 2);
+  return sv_vm_call(js->vm, js, ctor, js_mkundef(), args, 2, NULL, false);
 }
 
-static bool promise_any_try_resolve(struct js *js, jsval_t tracker, jsval_t value) {
+static bool promise_any_try_resolve(ant_t *js, jsval_t tracker, jsval_t value) {
   if (js_truthy(js, js_get(js, tracker, "resolved"))) return false;
   js_set(js, tracker, "resolved", js_true);
   resolve_promise(js, get_slot(js, tracker, SLOT_DATA), value);
   return true;
 }
 
-static void promise_any_record_rejection(struct js *js, jsval_t tracker, int index, jsval_t reason) {
+static void promise_any_record_rejection(ant_t *js, jsval_t tracker, int index, jsval_t reason) {
   jsval_t errors = resolveprop(js, js_get(js, tracker, "errors"));
   arr_set(js, errors, (jsoff_t)index, reason);
   
@@ -22263,13 +11071,13 @@ static void promise_any_record_rejection(struct js *js, jsval_t tracker, int ind
   if (remaining == 0) reject_promise(js, get_slot(js, tracker, SLOT_DATA), mk_aggregate_error(js, errors));
 }
 
-static jsval_t builtin_Promise_any_resolve_handler(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_any_resolve_handler(ant_t *js, jsval_t *args, int nargs) {
   jsval_t tracker = js_get(js, js->this_val, "tracker");
   promise_any_try_resolve(js, tracker, nargs > 0 ? args[0] : js_mkundef());
   return js_mkundef();
 }
 
-static jsval_t builtin_Promise_any_reject_handler(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_any_reject_handler(ant_t *js, jsval_t *args, int nargs) {
   jsval_t tracker = js_get(js, js->this_val, "tracker");
   if (js_truthy(js, js_get(js, tracker, "resolved"))) return js_mkundef();
   
@@ -22278,7 +11086,7 @@ static jsval_t builtin_Promise_any_reject_handler(struct js *js, jsval_t *args,
   return js_mkundef();
 }
 
-static jsval_t builtin_Promise_any(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Promise_any(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Promise.any requires an array");
   
   jsval_t arr = args[0];
@@ -22344,7 +11152,7 @@ static jsval_t builtin_Promise_any(struct js *js, jsval_t *args, int nargs) {
     js_setprop(js, reject_obj, js_mkstr(js, "index", 5), tov((double)i));
     js_setprop(js, reject_obj, js_mkstr(js, "tracker", 7), tracker);
     
-    jsval_t then_args[] = { mkval(T_FUNC, vdata(resolve_obj)), mkval(T_FUNC, vdata(reject_obj)) };
+    jsval_t then_args[] = { js_obj_to_func(resolve_obj), js_obj_to_func(reject_obj) };
     jsval_t saved_this = js->this_val;
     js->this_val = item;
     builtin_promise_then(js, then_args, 2);
@@ -22354,7 +11162,7 @@ static jsval_t builtin_Promise_any(struct js *js, jsval_t *args, int nargs) {
   return result_promise;
 }
 
-static jsval_t handle_proxy_instanceof(struct js *js, jsval_t l, jsval_t r, uint8_t ltype) {
+static jsval_t handle_proxy_instanceof(ant_t *js, jsval_t l, jsval_t r, uint8_t ltype) {
   jsval_t target = proxy_read_target(js, r);
   uint8_t ttype = vtype(target);
   
@@ -22362,14 +11170,13 @@ static jsval_t handle_proxy_instanceof(struct js *js, jsval_t l, jsval_t r, uint
     return js_mkerr_typed(js, JS_ERR_TYPE, "Right-hand side of 'instanceof' is not callable");
   }
   
-  const char *hi_key = get_hasInstance_sym_key();
-  if (hi_key && *hi_key) {
-    jsval_t has_instance = proxy_get(js, r, hi_key, strlen(hi_key));
+  {
+    jsval_t has_instance = js_get_sym(js, r, get_hasInstance_sym());
     if (is_err(has_instance)) return has_instance;
     uint8_t hit = vtype(has_instance);
     if (hit == T_FUNC || hit == T_CFUNC) {
       jsval_t args[1] = { l };
-      jsval_t result = js_call_with_this(js, has_instance, r, args, 1);
+      jsval_t result = sv_vm_call(js->vm, js, has_instance, r, args, 1, NULL, false);
       if (is_err(result)) return result;
       return js_bool(js_truthy(js, result));
     }
@@ -22401,7 +11208,7 @@ static jsval_t handle_proxy_instanceof(struct js *js, jsval_t l, jsval_t r, uint
 }
 
 static jsval_t handle_cfunc_instanceof(jsval_t l, jsval_t r, uint8_t ltype) {
-  jsval_t (*fn)(struct js *, jsval_t *, int) = (jsval_t(*)(struct js *, jsval_t *, int)) vdata(r);
+  jsval_t (*fn)(ant_t *, jsval_t *, int) = (jsval_t(*)(ant_t *, jsval_t *, int)) vdata(r);
   
   if (fn == builtin_Object) return mkval(T_BOOL, ltype == T_OBJ ? 1 : 0);
   if (fn == builtin_Function) return mkval(T_BOOL, (ltype == T_FUNC || ltype == T_CFUNC) ? 1 : 0);
@@ -22414,7 +11221,7 @@ static jsval_t handle_cfunc_instanceof(jsval_t l, jsval_t r, uint8_t ltype) {
   return mkval(T_BOOL, 0);
 }
 
-static jsval_t walk_prototype_chain(struct js *js, jsval_t l, jsval_t ctor_proto) {
+static jsval_t walk_prototype_chain(ant_t *js, jsval_t l, jsval_t ctor_proto) {
   jsval_t current = get_proto(js, l);
   const int MAX_DEPTH = 32;
   
@@ -22426,7 +11233,7 @@ static jsval_t walk_prototype_chain(struct js *js, jsval_t l, jsval_t ctor_proto
   return mkval(T_BOOL, 0);
 }
 
-static jsval_t do_instanceof(struct js *js, jsval_t l, jsval_t r) {
+jsval_t do_instanceof(ant_t *js, jsval_t l, jsval_t r) {
   uint8_t ltype = vtype(l);
   uint8_t rtype = vtype(r);
   
@@ -22439,14 +11246,13 @@ static jsval_t do_instanceof(struct js *js, jsval_t l, jsval_t r) {
     return handle_cfunc_instanceof(l, r, ltype);
   }
   
-  const char *hi_key = get_hasInstance_sym_key();
-  if (hi_key && hi_key[0]) {
-    jsval_t has_instance = js_get(js, r, hi_key);
+  {
+    jsval_t has_instance = js_get_sym(js, r, get_hasInstance_sym());
     if (is_err(has_instance)) return has_instance;
     uint8_t hit = vtype(has_instance);
     if (hit == T_FUNC || hit == T_CFUNC) {
       jsval_t args[1] = { l };
-      jsval_t result = js_call_with_this(js, has_instance, r, args, 1);
+      jsval_t result = sv_vm_call(js->vm, js, has_instance, r, args, 1, NULL, false);
       if (is_err(result)) return result;
       return js_bool(js_truthy(js, result));
     }
@@ -22455,7 +11261,7 @@ static jsval_t do_instanceof(struct js *js, jsval_t l, jsval_t r) {
     }
   }
   
-  jsval_t func_obj = mkval(T_OBJ, vdata(r));
+  jsval_t func_obj = js_func_obj(r);
   jsoff_t proto_off = lkp_interned(js, func_obj, INTERN_PROTOTYPE, 9);
   if (proto_off == 0) return mkval(T_BOOL, 0);
   
@@ -22475,20 +11281,20 @@ static jsval_t do_instanceof(struct js *js, jsval_t l, jsval_t r) {
   return walk_prototype_chain(js, l, ctor_proto);
 }
 
-static jsval_t do_in(struct js *js, jsval_t l, jsval_t r) {
+jsval_t do_in(ant_t *js, jsval_t l, jsval_t r) {
   jsoff_t prop_len;
   const char *prop_name;
   char num_buf[32];
-  char sym_buf[64];
   
   jsval_t key = js_to_primitive(js, l, 1);
   if (is_err(key)) return key;
   
-  if (vtype(key) == T_SYMBOL) {
-    int klen = sym_to_prop_key(key, sym_buf, sizeof(sym_buf));
-    if (klen <= 0) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid symbol key");
-    prop_len = (jsoff_t)klen;
-    prop_name = sym_buf;
+  bool is_sym = (vtype(key) == T_SYMBOL);
+  
+  if (is_sym) {
+    const char *d = js_sym_desc(js, key);
+    prop_name = d ? d : "symbol";
+    prop_len = (jsoff_t)strlen(prop_name);
   } else if (vtype(key) == T_NUM) {
     prop_len = (jsoff_t)strnum(key, num_buf, sizeof(num_buf));
     prop_name = num_buf;
@@ -22499,583 +11305,56 @@ static jsval_t do_in(struct js *js, jsval_t l, jsval_t r) {
     prop_name = (char *)&js->mem[prop_off];
   }
   
-  if (vtype(r) != T_OBJ && vtype(r) != T_ARR && vtype(r) != T_FUNC) {
+  if (!is_object_type(r)) {
+    if (vtype(r) == T_CFUNC) return mkval(T_BOOL, 0);
     return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot use 'in' operator to search for '%.*s' in non-object", (int)prop_len, prop_name);
   }
   
   if (is_proxy(js, r)) {
-    jsval_t result = proxy_has(js, r, prop_name, prop_len);
+    jsval_t result = is_sym ? proxy_has_val(js, r, key) : proxy_has(js, r, prop_name, prop_len);
     if (is_err(result)) return result;
     return js_bool(js_truthy(js, result));
   }
   
-  if (vtype(r) == T_ARR) {
+  if (!is_sym && vtype(r) == T_ARR) {
     unsigned long idx;
     jsoff_t arr_len = get_array_length(js, r);
     if (parse_array_index(prop_name, prop_len, arr_len, &idx)) return mkval(T_BOOL, arr_has(js, r, (jsoff_t)idx) ? 1 : 0);
     if (prop_len == 6 && memcmp(prop_name, "length", 6) == 0) return mkval(T_BOOL, 1);
   }
   
-  jsoff_t found = lkp_proto(js, r, prop_name, prop_len);
+  jsoff_t found = is_sym ? lkp_sym_proto(js, r, (jsoff_t)vdata(key)) : lkp_proto(js, r, prop_name, prop_len);
   return mkval(T_BOOL, found != 0 ? 1 : 0);
 }
 
-static char *esm_get_extension(const char *path) {
-  const char *dot = strrchr(path, '.');
-  const char *slash = strrchr(path, '/');
-  
-  if (dot && (!slash || dot > slash)) {
-    return strdup(dot);
-  }
-  return strdup(".js");
-}
-
-static char *esm_try_resolve(const char *dir, const char *spec, const char *suffix) {
-  char path[PATH_MAX];
-  snprintf(path, PATH_MAX, "%s/%s%s", dir, spec, suffix);
-  char *resolved = realpath(path, NULL);
-  if (resolved) {
-    struct stat st;
-    if (stat(resolved, &st) == 0 && S_ISREG(st.st_mode)) return resolved;
-    free(resolved);
-  }
-  return NULL;
-}
-
-static bool esm_has_extension(const char *spec) {
-  const char *dot = strrchr(spec, '.');
-  const char *slash = strrchr(spec, '/');
-  return dot && (!slash || dot > slash);
-}
-
-static char *esm_resolve_absolute(const char *specifier) {
-  char *result;
-  if ((result = esm_try_resolve("", specifier, ""))) return result;
-  if (esm_has_extension(specifier)) return NULL;
-  if ((result = esm_try_resolve("", specifier, ".js"))) return result;
-  if ((result = esm_try_resolve("", specifier, ".ts"))) return result;
-  if ((result = esm_try_resolve("", specifier, ".mts"))) return result;
-  if ((result = esm_try_resolve("", specifier, ".cts"))) return result;
-  if ((result = esm_try_resolve("", specifier, ".json"))) return result;
-  return NULL;
-}
-
-static char *esm_resolve_path(const char *specifier, const char *base_path) {
-  if (specifier[0] == '/' && specifier[1] != '.') {
-    return esm_resolve_absolute(specifier);
-  }
-  
-  if (!((specifier[0] == '.' && specifier[1] == '/') || 
-        (specifier[0] == '.' && specifier[1] == '.' && specifier[2] == '/'))) {
-    return strdup(specifier);
-  }
-  
-  char *base_copy = strdup(base_path);
-  char *dir = dirname(base_copy);
-  char *result = NULL;
-  
-  const char *spec = (specifier[0] == '.' && specifier[1] == '/') ? specifier + 2 : specifier;
-  bool has_ext = esm_has_extension(spec);
-  
-  if ((result = esm_try_resolve(dir, spec, ""))) goto cleanup;
-  if (has_ext) goto cleanup;
-  
-  char *base_ext = esm_get_extension(base_path);
-  
-  if ((result = esm_try_resolve(dir, spec, base_ext))) goto cleanup_ext;
-  if (strcmp(base_ext, ".js") != 0 && (result = esm_try_resolve(dir, spec, ".js"))) goto cleanup_ext;
-  
-  if ((result = esm_try_resolve(dir, spec, ".ts"))) goto cleanup_ext;
-  if ((result = esm_try_resolve(dir, spec, ".mts"))) goto cleanup_ext;
-  if ((result = esm_try_resolve(dir, spec, ".cts"))) goto cleanup_ext;
-  if ((result = esm_try_resolve(dir, spec, ".json"))) goto cleanup_ext;
-  
-  char idx[PATH_MAX];
-  snprintf(idx, PATH_MAX, "%s/index%s", spec, base_ext);
-  if ((result = esm_try_resolve(dir, idx, ""))) goto cleanup_ext;
-  
-  if (strcmp(base_ext, ".js") != 0) {
-    snprintf(idx, PATH_MAX, "%s/index.js", spec);
-    if ((result = esm_try_resolve(dir, idx, ""))) goto cleanup_ext;
-  }
-  
-  snprintf(idx, PATH_MAX, "%s/index.ts", spec);
-  if ((result = esm_try_resolve(dir, idx, ""))) goto cleanup_ext;
-  
-cleanup_ext:
-  free(base_ext);
-cleanup:
-  free(base_copy);
-  return result;
-}
-
-static bool esm_has_suffix(const char *path, const char *ext) {
-  size_t len = strlen(path);
-  size_t elen = strlen(ext);
-  return len > elen && strcmp(path + len - elen, ext) == 0;
-}
-
-static bool esm_is_json(const char *path) {
-  return esm_has_suffix(path, ".json");
-}
-
-static bool esm_is_text(const char *path) {
-  return esm_has_suffix(path, ".txt")  ||
-         esm_has_suffix(path, ".md")   ||
-         esm_has_suffix(path, ".html") ||
-         esm_has_suffix(path, ".css");
-}
-
-static bool esm_is_image(const char *path) {
-  return esm_has_suffix(path, ".png")  ||
-         esm_has_suffix(path, ".jpg")  ||
-         esm_has_suffix(path, ".jpeg") ||
-         esm_has_suffix(path, ".gif")  ||
-         esm_has_suffix(path, ".svg")  ||
-         esm_has_suffix(path, ".webp");
-}
-
-static char *esm_canonicalize_path(const char *path) {
-  if (!path) return NULL;
-  
-  char *canonical = strdup(path);
-  if (!canonical) return NULL;
-  
-  char *src = canonical, *dst = canonical;
-  
-  while (*src) {
-    if (*src == '/') {
-      *dst++ = '/';
-      while (*src == '/') src++;
-      
-      if (strncmp(src, "./", 2) == 0) {
-        src += 2;
-      } else if (strncmp(src, "../", 3) == 0) {
-        src += 3;
-        if (dst > canonical + 1) {
-          dst--;
-          while (dst > canonical && *(dst - 1) != '/') dst--;
-        }
-      }
-    } else {
-      *dst++ = *src++;
-    }
-  }
-  
-  *dst = '\0';
-  
-  if (strlen(canonical) > 1 && canonical[strlen(canonical) - 1] == '/') {
-    canonical[strlen(canonical) - 1] = '\0';
-  }
-  
-  return canonical;
-}
-
-static esm_module_t *esm_find_module(const char *resolved_path) {
-  char *canonical_path = esm_canonicalize_path(resolved_path);
-  if (!canonical_path) return NULL;
-  
-  esm_module_t *mod = NULL;
-  HASH_FIND_STR(global_module_cache.modules, canonical_path, mod);
-  
-  free(canonical_path);
-  return mod;
-}
-
-static esm_module_t *esm_create_module(const char *path, const char *resolved_path) {
-  bool is_url = esm_is_url(resolved_path);
-  char *canonical_path = is_url ? strdup(resolved_path) : esm_canonicalize_path(resolved_path);
-  if (!canonical_path) return NULL;
-  
-  esm_module_t *existing_mod = NULL;
-  HASH_FIND_STR(global_module_cache.modules, canonical_path, existing_mod);
-  if (existing_mod) {
-    free(canonical_path);
-    return existing_mod;
-  }
-  
-  esm_module_t *mod = (esm_module_t *)malloc(sizeof(esm_module_t));
-  if (!mod) {
-    free(canonical_path);
-    return NULL;
-  }
-  
-  mod->path = strdup(path);
-  mod->resolved_path = canonical_path;
-  mod->namespace_obj = js_mkundef();
-  mod->default_export = js_mkundef();
-  mod->is_loaded = false;
-  mod->is_loading = false;
-  mod->is_json = esm_is_json(resolved_path);
-  mod->is_text = esm_is_text(resolved_path);
-  mod->is_image = esm_is_image(resolved_path);
-  mod->is_url = is_url;
-  mod->url_content = NULL;
-  mod->url_content_len = 0;
-  mod->next = NULL;
-  
-  HASH_ADD_STR(global_module_cache.modules, resolved_path, mod);
-  global_module_cache.count++;
-  
-  return mod;
-}
-
-static void esm_cleanup_module_cache(void) {
-  esm_module_t *current, *tmp;
-  HASH_ITER(hh, global_module_cache.modules, current, tmp) {
-    HASH_DEL(global_module_cache.modules, current);
-    if (current->path) free(current->path);
-    if (current->resolved_path) free(current->resolved_path);
-    if (current->url_content) free(current->url_content);
-    free(current);
-  }
-  global_module_cache.count = 0;
-}
-
-typedef struct {
-  char *data;
-  size_t size;
-} esm_file_data_t;
-
-static jsval_t esm_read_file(struct js *js, const char *path, const char *kind, esm_file_data_t *out) {
-  FILE *fp = fopen(path, "rb");
-  if (!fp) return js_mkerr(js, "Cannot open %s: %s", kind, path);
-  
-  fseek(fp, 0, SEEK_END);
-  long fsize = ftell(fp);
-  fseek(fp, 0, SEEK_SET);
-  
-  char *buf = (char *)malloc((size_t)fsize + 1);
-  if (!buf) {
-    fclose(fp);
-    return js_mkerr(js, "OOM loading %s", kind);
-  }
-  
-  fread(buf, 1, (size_t)fsize, fp);
-  fclose(fp);
-  buf[fsize] = '\0';
-  
-  out->data = buf;
-  out->size = (size_t)fsize;
-  return js_mkundef();
-}
-
-static jsval_t esm_load_json(struct js *js, const char *path) {
-  esm_file_data_t file;
-  jsval_t err = esm_read_file(js, path, "JSON file", &file);
-  if (is_err(err)) return err;
-  
-  jsval_t json_str = js_mkstr(js, file.data, file.size);
-  free(file.data);
-  return js_json_parse(js, &json_str, 1);
-}
-
-static jsval_t esm_load_text(struct js *js, const char *path) {
-  esm_file_data_t file;
-  jsval_t err = esm_read_file(js, path, "text file", &file);
-  if (is_err(err)) return err;
-  
-  jsval_t result = js_mkstr(js, file.data, file.size);
-  free(file.data);
-  return result;
-}
-
-static jsval_t esm_load_image(struct js *js, const char *path) {
-  esm_file_data_t file;
-  jsval_t err = esm_read_file(js, path, "image file", &file);
-  if (is_err(err)) return err;
-  
-  unsigned char *content = (unsigned char *)file.data;
-  size_t size = file.size;
-  
-  jsval_t obj = mkobj(js, 0);
-  jsval_t data_arr = mkarr(js);
-  
-  for (size_t i = 0; i < size; i++) {
-    arr_set(js, data_arr, (jsoff_t)i, tov((double)content[i]));
-  }
-  
-  js_setprop(js, obj, js_mkstr(js, "data", 4), mkval(T_ARR, vdata(data_arr)));
-  js_setprop(js, obj, js_mkstr(js, "path", 4), js_mkstr(js, path, strlen(path)));
-  js_setprop(js, obj, js_mkstr(js, "size", 4), tov((double)size));
-  
-  free(file.data);
-  return obj;
-}
-
-static jsval_t esm_load_module(struct js *js, esm_module_t *mod) {
-  if (mod->is_loaded) return mod->namespace_obj;
-  if (mod->is_loading) return js_mkerr(js, "Circular dependency detected: %s", mod->path);
-  
-  mod->is_loading = true;
-  
-  if (mod->is_json) {
-    jsval_t json_val = esm_load_json(js, mod->resolved_path);
-    if (is_err(json_val)) {
-      mod->is_loading = false;
-      return json_val;
-    }
-    
-    mod->namespace_obj = json_val;
-    mod->default_export = json_val;
-    mod->is_loaded = true;
-    mod->is_loading = false;
-    return json_val;
-  }
-  
-  if (mod->is_text) {
-    jsval_t text_val = esm_load_text(js, mod->resolved_path);
-    if (is_err(text_val)) {
-      mod->is_loading = false;
-      return text_val;
-    }
-    
-    mod->namespace_obj = text_val;
-    mod->default_export = text_val;
-    mod->is_loaded = true;
-    mod->is_loading = false;
-    return text_val;
-  }
-  
-  if (mod->is_image) {
-    jsval_t img_val = esm_load_image(js, mod->resolved_path);
-    if (is_err(img_val)) {
-      mod->is_loading = false;
-      return img_val;
-    }
-    
-    mod->namespace_obj = img_val;
-    mod->default_export = img_val;
-    mod->is_loaded = true;
-    mod->is_loading = false;
-    return img_val;
-  }
-  
-  char *content = NULL;
-  size_t size = 0;
-  
-  if (mod->is_url) {
-    if (mod->url_content) {
-      content = strdup(mod->url_content);
-      size = mod->url_content_len;
-    } else {
-      char *error = NULL;
-      content = esm_fetch_url(mod->resolved_path, &size, &error);
-      if (!content) {
-        mod->is_loading = false;
-        jsval_t err = js_mkerr(js, "Cannot fetch module %s: %s", mod->resolved_path, error ? error : "unknown error");
-        if (error) free(error);
-        return err;
-      }
-      mod->url_content = strdup(content);
-      mod->url_content_len = size;
-    }
-  } else {
-    esm_file_data_t file;
-    jsval_t err = esm_read_file(js, mod->resolved_path, "module", &file);
-    if (is_err(err)) {
-      mod->is_loading = false;
-      return err;
-    }
-    content = file.data;
-    size = file.size;
-  }
-  content[size] = '\0';
-  
-  char *js_code = content;
-  size_t js_len = size;
-  
-  if (is_typescript_file(mod->resolved_path)) {
-    int result = OXC_strip_types(content, mod->resolved_path, content, size + 1);
-    if (result < 0) {
-      free(content);
-      mod->is_loading = false;
-      return js_mkerr(js, "TypeScript error: strip failed (%d)", result);
-    }
-    js_len = (size_t)result;
-  }
-  
-  jsval_t ns = mkobj(js, 0);
-  mod->namespace_obj = ns;
-  
-  jsval_t prev_module = js->module_ns;
-  js->module_ns = ns;
-  
-  const char *prev_filename = js->filename;
-  jsval_t saved_scope = js->scope;
-  
-  js_set_filename(js, mod->resolved_path);
-  mkscope(js); set_slot(js, js->scope, SLOT_MODULE_SCOPE, tov(1));
-  
-  jsval_t result = js_eval_cached(js, js_code, js_len);
-  free(content);
-  
-  js->scope = saved_scope;
-  js_set_filename(js, prev_filename);
-  js->module_ns = prev_module;
-  
-  if (is_err(result)) {
-    mod->is_loading = false;
-    return result;
-  }
-  
-  jsval_t default_val = js_get_slot(js, ns, SLOT_DEFAULT);
-  mod->default_export = vtype(default_val) != T_UNDEF ? default_val : ns;
-  
-  mod->is_loaded = true;
-  mod->is_loading = false;
-  
-  return ns;
-}
-
-static jsval_t esm_get_or_load(struct js *js, const char *specifier, const char *resolved_path) {
-  esm_module_t *mod = esm_find_module(resolved_path);
-  if (!mod) {
-    mod = esm_create_module(specifier, resolved_path);
-    if (!mod) return js_mkerr(js, "Cannot create module");
-  }
-  return esm_load_module(js, mod);
-}
-
-typedef struct {
-  const char *import_name;
-  size_t import_len;
-  const char *local_name;
-  size_t local_len;
-} esm_import_binding_t;
-
-static char *esm_jsval_to_cstr(struct js *js, jsval_t str, jsoff_t *out_len) {
-  jsoff_t len;
-  jsoff_t off = vstr(js, str, &len);
-  if (out_len) *out_len = len;
-  return strndup((char *)&js->mem[off], len);
-}
-
-static jsval_t esm_resolve_and_load(struct js *js, const char *spec_str, jsoff_t spec_len) {
-  ant_library_t *lib = find_library(spec_str, spec_len);
-  if (lib) return lib->init_fn(js);
-  
-  const char *base_path = js->filename ? js->filename : ".";
-  char *resolved_path = esm_resolve(spec_str, base_path, esm_resolve_path);
-  if (!resolved_path) return js_mkerr(js, "Cannot resolve module: %s", spec_str);
-  
-  jsval_t ns = esm_get_or_load(js, spec_str, resolved_path);
-  free(resolved_path);
-  return ns;
-}
-
-static jsval_t esm_make_file_url(struct js *js, const char *path) {
-  size_t url_len = strlen(path) + 8;
-  char *url = malloc(url_len);
-  if (!url) return js_mkerr(js, "oom");
-  
-  snprintf(url, url_len, "file://%s", path);
-  jsval_t val = js_mkstr(js, url, strlen(url));
-  free(url);
-  return val;
-}
-
-static bool esm_parse_name(struct js *js, const char **name, size_t *len, bool *is_string) {
-  if (next(js) == TOK_STRING) {
-    jsval_t sv = js_str_literal(js);
-    jsoff_t slen;  jsoff_t soff = vstr(js, sv, &slen);
-    *name = (const char *)&js->mem[soff]; *len = slen;
-    if (is_string) *is_string = true;
-  } else if (next(js) == TOK_IDENTIFIER || next(js) == TOK_DEFAULT) {
-    *name = &js->code[js->toff];
-    *len = js->tlen;
-    if (is_string) *is_string = false;
-  } else return false;
-  
-  js->consumed = 1;
-  return true;
-}
-
-static int esm_parse_named_imports(struct js *js, esm_import_binding_t *bindings, int max_bindings) {
-  int count = 0;
-  
-  while (next(js) != TOK_RBRACE && count < max_bindings) {
-    bool import_is_string = false;
-    const char *import_name;
-    size_t import_len;
-    
-    if (!esm_parse_name(js, &import_name, &import_len, &import_is_string))
-      return -1;
-    
-    const char *local_name = import_name;
-    size_t local_len = import_len;
-    
-    if (next(js) == TOK_AS) {
-      js->consumed = 1;
-      if (!esm_parse_name(js, &local_name, &local_len, NULL))
-        return -1;
-    } else if (import_is_string) {
-      return -1;
-    }
-    
-    bindings[count].import_name = import_name;
-    bindings[count].import_len = import_len;
-    bindings[count].local_name = local_name;
-    bindings[count].local_len = local_len;
-    count++;
-    
-    if (next(js) == TOK_COMMA) js->consumed = 1;
-  }
-  
-  if (next(js) != TOK_RBRACE) return -1;
-  js->consumed = 1;
-  return count;
-}
-
-static jsval_t builtin_import(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || vtype(args[0]) != T_STR) {
-    return js_mkerr(js, "import() requires a string specifier");
-  }
-  
-  jsoff_t spec_len;
-  char *specifier = esm_jsval_to_cstr(js, args[0], &spec_len);
-  jsval_t ns = esm_resolve_and_load(js, specifier, spec_len);
-  free(specifier);
-  
+static jsval_t builtin_import(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr(js, "import() requires a string specifier");
+  jsval_t ns = js_esm_import_sync(js, args[0]);
   if (is_err(ns)) return builtin_Promise_reject(js, &ns, 1);
-  
+
   jsval_t promise_args[] = { ns };
   return builtin_Promise_resolve(js, promise_args, 1);
 }
-
-static jsval_t builtin_import_meta_resolve(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || vtype(args[0]) != T_STR) {
-    return js_mkerr(js, "import.meta.resolve() requires a string specifier");
-  }
-  
-  char *specifier = esm_jsval_to_cstr(js, args[0], NULL);
-  
-  const char *base_path = js->filename ? js->filename : ".";
-  char *resolved_path = esm_resolve(specifier, base_path, esm_resolve_path);
-  if (!resolved_path) {
-    jsval_t err = js_mkerr(js, "Cannot resolve module: %s", specifier);
-    free(specifier); return err;
-  }
-  free(specifier);
-  
-  if (esm_is_url(resolved_path)) {
-    jsval_t result = js_mkstr(js, resolved_path, strlen(resolved_path));
-    free(resolved_path); return result;
-  }
-  
-  jsval_t result = esm_make_file_url(js, resolved_path);
-  free(resolved_path);
-  return result;
+
+static jsval_t builtin_import_meta_resolve(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr(js, "import.meta.resolve() requires a string specifier");
+  if (vtype(js->import_meta) == T_OBJ) {
+    jsval_t filename = js_get(js, js->import_meta, "filename");
+    if (vtype(filename) == T_STR) {
+      jsoff_t n = 0; jsoff_t off = vstr(js, filename, &n);
+      return js_esm_resolve_specifier(js, args[0], (const char *)&js->mem[off]);
+    }
+  } return js_esm_resolve_specifier(js, args[0], NULL);
 }
 
-void js_setup_import_meta(struct js *js, const char *filename) {
+void js_setup_import_meta(ant_t *js, const char *filename) {
   if (!filename) return;
   
   jsval_t import_meta = mkobj(js, 0);
   if (is_err(import_meta)) return;
   bool is_url = esm_is_url(filename);
   
-  jsval_t url_val = is_url ? js_mkstr(js, filename, strlen(filename)) : esm_make_file_url(js, filename);
+  jsval_t url_val = is_url ? js_mkstr(js, filename, strlen(filename)) : js_esm_make_file_url(js, filename);
   if (!is_err(url_val)) js_setprop(js, import_meta, js_mkstr(js, "url", 3), url_val);
   
   jsval_t filename_val = js_mkstr(js, filename, strlen(filename));
@@ -23115,383 +11394,12 @@ void js_setup_import_meta(struct js *js, const char *filename) {
   if (import_off != 0) {
     jsval_t import_fn = resolveprop(js, mkval(T_PROP, import_off));
     if (vtype(import_fn) == T_FUNC) {
-      jsval_t import_obj = mkval(T_OBJ, vdata(import_fn));
+      jsval_t import_obj = js_func_obj(import_fn);
       js_setprop(js, import_obj, js_mkstr(js, "meta", 4), import_meta);
     }
   }
 }
 
-static jsval_t js_import_stmt(struct js *js) {
-  js->consumed = 1;
-  
-  if (next(js) == TOK_LPAREN) {
-    js->consumed = 1;
-    jsval_t spec = js_expr(js);
-    EXPECT(TOK_RPAREN);
-    
-    if (vtype(spec) != T_STR) {
-      return js_mkerr(js, "import() requires string");
-    }
-    
-    jsval_t args[] = { spec };
-    return builtin_import(js, args, 1);
-  }
-  
-  if (next(js) == TOK_MUL) {
-    js->consumed = 1;
-    EXPECT(TOK_AS);
-    EXPECT(TOK_IDENTIFIER);
-    
-    const char *namespace_name = &js->code[js->toff];
-    size_t namespace_len = js->tlen;
-    js->consumed = 1;
-    
-    EXPECT(TOK_FROM);
-    EXPECT(TOK_STRING);
-    
-    jsval_t spec = js_str_literal(js);
-    jsoff_t spec_len;
-    char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len);
-    
-    js_parse_state_t saved;
-    JS_SAVE_STATE(js, saved);
-    jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len);
-    JS_RESTORE_STATE(js, saved);
-    free(spec_str);
-    
-    js->consumed = 1; next(js); js->consumed = 0;
-    if (is_err(ns)) return ns;
-    
-    if (vtype(ns) != T_OBJ) {
-      return js_mkerr_typed(js, JS_ERR_SYNTAX, "Cannot re-export from non-object module");
-    }
-    
-    js_setprop(js, js->scope, js_mkstr(js, namespace_name, namespace_len), ns);
-    return js_mkundef();
-  }
-  
-  if (next(js) == TOK_IDENTIFIER) {
-    const char *default_name = &js->code[js->toff];
-    size_t default_len = js->tlen;
-    js->consumed = 1;
-    
-    esm_import_binding_t bindings[64];
-    int binding_count = 0;
-    
-    if (next(js) == TOK_COMMA) {
-      js->consumed = 1;
-      
-      if (next(js) == TOK_LBRACE) {
-        js->consumed = 1;
-        binding_count = esm_parse_named_imports(js, bindings, 64);
-        if (binding_count < 0) return js_mkerr(js, "Failed to parse named imports");
-      } else if (next(js) == TOK_MUL) {
-        js->consumed = 1;
-        EXPECT(TOK_AS);
-        EXPECT(TOK_IDENTIFIER);
-        bindings[binding_count].import_name = NULL;
-        bindings[binding_count].import_len = 0;
-        bindings[binding_count].local_name = &js->code[js->toff];
-        bindings[binding_count].local_len = js->tlen;
-        binding_count++;
-        js->consumed = 1;
-      } else {
-        return js_mkerr(js, "Expected '{' or '*' after ',' in import");
-      }
-    }
-    
-    EXPECT(TOK_FROM);
-    EXPECT(TOK_STRING);
-    
-    jsval_t spec = js_str_literal(js);
-    jsoff_t spec_len;
-    char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len);
-    
-    js_parse_state_t saved;
-    JS_SAVE_STATE(js, saved);
-    jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len);
-    JS_RESTORE_STATE(js, saved);
-    free(spec_str);
-    
-    js->consumed = 1; next(js); js->consumed = 0;
-    if (is_err(ns)) return ns;
-    
-    jsval_t default_val;
-    if (vtype(ns) == T_OBJ) {
-      jsval_t slot_val = js_get_slot(js, ns, SLOT_DEFAULT);
-      default_val = vtype(slot_val) != T_UNDEF ? slot_val : ns;
-    } else default_val = ns;
-    js_setprop(js, js->scope, js_mkstr(js, default_name, default_len), default_val);
-    
-    for (int i = 0; i < binding_count; i++) {
-      if (bindings[i].import_name == NULL) {
-        js_setprop(js, js->scope, js_mkstr(js, bindings[i].local_name, bindings[i].local_len), ns);
-      } else if (vtype(ns) == T_OBJ) {
-        jsoff_t prop_off = lkp(js, ns, bindings[i].import_name, bindings[i].import_len);
-        if (prop_off == 0) return js_mkerr_typed(
-          js, JS_ERR_SYNTAX, "The requested module does not provide an export named '%.*s'",
-          (int)bindings[i].import_len, bindings[i].import_name
-        );
-        jsval_t imported_val = resolveprop(js, mkval(T_PROP, prop_off));
-        js_setprop(js, js->scope, js_mkstr(js, bindings[i].local_name, bindings[i].local_len), imported_val);
-      } else return js_mkerr_typed(js, JS_ERR_SYNTAX, "Cannot use named imports from non-object module");
-    }
-    
-    return js_mkundef();
-  }
-  
-  if (next(js) == TOK_LBRACE) {
-    js->consumed = 1;
-    
-    esm_import_binding_t bindings[64];
-    int binding_count = esm_parse_named_imports(js, bindings, 64);
-    if (binding_count < 0) return js_mkerr(js, "Failed to parse named imports");
-    
-    EXPECT(TOK_FROM);
-    EXPECT(TOK_STRING);
-    
-    jsval_t spec = js_str_literal(js);
-    jsoff_t spec_len;
-    char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len);
-    
-    js_parse_state_t saved;
-    JS_SAVE_STATE(js, saved);
-    jsoff_t saved_toff = js->toff, saved_tlen = js->tlen;
-    jsval_t saved_scope = js->scope;
-    
-    jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len);
-    
-    JS_RESTORE_STATE(js, saved);
-    js->toff = saved_toff;
-    js->tlen = saved_tlen;
-    js->scope = saved_scope;
-    free(spec_str);
-    
-    js->consumed = 1;
-    next(js);
-    js->consumed = 0;
-    
-    if (is_err(ns)) return ns;
-    if (vtype(ns) != T_OBJ) return js_mkerr(js, "Cannot use named imports from non-object module");
-    
-    for (int i = 0; i < binding_count; i++) {
-      jsoff_t prop_off = lkp(js, ns, bindings[i].import_name, bindings[i].import_len);
-      if (prop_off == 0) return js_mkerr_typed(
-        js, JS_ERR_SYNTAX, "The requested module does not provide an export named '%.*s'", 
-        (int)bindings[i].import_len, bindings[i].import_name
-      );
-      jsval_t imported_val = resolveprop(js, mkval(T_PROP, prop_off));
-      js_setprop(js, js->scope, js_mkstr(js, bindings[i].local_name, bindings[i].local_len), imported_val);
-    }
-    
-    return js_mkundef();
-  }
-
-  if (next(js) == TOK_STRING) {
-    jsval_t spec = js_str_literal(js);
-    jsoff_t spec_len;
-    char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len);
-
-    js_parse_state_t saved;
-    JS_SAVE_STATE(js, saved);
-    jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len);
-    JS_RESTORE_STATE(js, saved);
-    free(spec_str);
-
-    js->consumed = 1;
-    next(js);
-    js->consumed = 0;
-
-    if (is_err(ns)) return ns;
-    return js_mkundef();
-  }
-
-  return js_mkerr_typed(js, JS_ERR_SYNTAX, "Invalid import statement");
-}
-
-static jsval_t js_export_stmt(struct js *js) {
-  js->consumed = 1;
-  
-  if (vtype(js->module_ns) != T_OBJ) {
-    js->module_ns = mkobj(js, 0);
-  }
-  
-  if (next(js) == TOK_DEFAULT) {
-    js->consumed = 1;
-    jsval_t value = js_assignment(js);
-    if (is_err(value)) return value;
-    
-    jsval_t resolved = resolveprop(js, value);
-    js_set_slot(js, js->module_ns, SLOT_DEFAULT, resolved);
-    js_mkprop_fast(js, js->module_ns, "default", 7, resolved);
-    
-    return value;
-  }
-  
-  if (next(js) == TOK_CONST || next(js) == TOK_LET || next(js) == TOK_VAR) {
-    bool is_const = (next(js) == TOK_CONST);
-    js->consumed = 1;
-    
-    EXPECT(TOK_IDENTIFIER);
-    const char *name = &js->code[js->toff];
-    size_t name_len = js->tlen;
-    js->consumed = 1;
-    
-    jsval_t value = js_mkundef();
-    if (next(js) == TOK_ASSIGN) {
-      js->consumed = 1;
-      value = js_assignment(js);
-      if (is_err(value)) return value;
-    }
-    
-    jsval_t key = js_mkstr(js, name, name_len);
-    mkprop(js, js->scope, key, resolveprop(js, value), is_const ? CONSTMASK : 0);
-    js_setprop(js, js->module_ns, key, resolveprop(js, value));
-    
-    return value;
-  }
-  
-  if (next(js) == TOK_FUNC) {
-    jsval_t func = js_func_literal(js, false);
-    if (is_err(func)) return func;
-    
-    jsval_t func_obj = mkval(T_OBJ, vdata(func));
-    jsoff_t name_off = lkp(js, func_obj, "name", 4);
-    if (name_off != 0) {
-      jsval_t name_val = resolveprop(js, mkval(T_PROP, name_off));
-      if (vtype(name_val) == T_STR) {
-        js_setprop(js, js->scope, name_val, func);
-        js_setprop(js, js->module_ns, name_val, func);
-      }
-    }
-    
-    return func;
-  }
-  
-  if (next(js) == TOK_CLASS) {
-    jsval_t cls = js_class_decl(js);
-    if (is_err(cls)) return cls;
-    
-    jsval_t cls_obj = mkval(T_OBJ, vdata(cls));
-    jsoff_t name_off = lkp(js, cls_obj, "name", 4);
-    if (name_off != 0) {
-      jsval_t name_val = resolveprop(js, mkval(T_PROP, name_off));
-       if (vtype(name_val) == T_STR) {
-         js_setprop(js, js->scope, name_val, cls);
-         js_setprop(js, js->module_ns, name_val, cls);
-       }
-    }
-    
-    return cls;
-  }
-  
-  if (next(js) == TOK_MUL) {
-    js->consumed = 1;
-    
-    const char *alias_name = NULL;
-    size_t alias_len = 0;
-    
-    if (next(js) == TOK_AS) {
-      js->consumed = 1;
-      if (!esm_parse_name(js, &alias_name, &alias_len, NULL))
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "expected identifier or string after 'as'");
-    }
-    
-    EXPECT(TOK_FROM);
-    EXPECT(TOK_STRING);
-    
-    jsval_t spec = js_str_literal(js);
-    jsoff_t spec_len;
-    char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len);
-    
-    js_parse_state_t saved;
-    JS_SAVE_STATE(js, saved);
-    jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len);
-    JS_RESTORE_STATE(js, saved);
-    free(spec_str);
-    
-    js->consumed = 1; next(js); js->consumed = 0;
-    if (is_err(ns)) return ns;
-    
-    if (alias_name) {
-      js_setprop(js, js->module_ns, js_mkstr(js, alias_name, alias_len), ns);
-    } else if (vtype(ns) == T_OBJ) {
-      ant_iter_t iter = js_prop_iter_begin(js, ns);
-      const char *key; size_t key_len; jsval_t value;
-      
-      while (js_prop_iter_next(&iter, &key, &key_len, &value)) {
-        js_setprop(js, js->module_ns, js_mkstr(js, key, key_len), resolveprop(js, value));
-      }
-      js_prop_iter_end(&iter);
-    }
-    
-    return js_mkundef();
-  }
-  
-  if (next(js) == TOK_LBRACE) {
-    js->consumed = 1;
-    
-    typedef struct { const char *local; size_t local_len; const char *exported; size_t export_len; } export_spec_t;
-    export_spec_t specs[64];
-    int spec_count = 0;
-    
-    while (next(js) != TOK_RBRACE) {
-      if (spec_count >= 64) return js_mkerr(js, "too many export specifiers");
-      
-      if (!esm_parse_name(js, &specs[spec_count].local, &specs[spec_count].local_len, NULL))
-        return js_mkerr_typed(js, JS_ERR_SYNTAX, "expected identifier, string, or 'default' in export list");
-      specs[spec_count].exported = specs[spec_count].local;
-      specs[spec_count].export_len = specs[spec_count].local_len;
-      
-      if (next(js) == TOK_AS) {
-        js->consumed = 1;
-        if (!esm_parse_name(js, &specs[spec_count].exported, &specs[spec_count].export_len, NULL))
-          return js_mkerr_typed(js, JS_ERR_SYNTAX, "expected identifier, string, or 'default' after 'as'");
-      }
-      
-      spec_count++;
-      if (next(js) == TOK_COMMA) js->consumed = 1;
-    }
-    
-    EXPECT(TOK_RBRACE);
-    
-    if (next(js) == TOK_FROM) {
-      js->consumed = 1;
-      EXPECT(TOK_STRING);
-      jsval_t spec = js_str_literal(js);
-      jsoff_t spec_len;
-      char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len);
-      
-      js_parse_state_t saved;
-      JS_SAVE_STATE(js, saved);
-      jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len);
-      JS_RESTORE_STATE(js, saved);
-      free(spec_str);
-      
-      js->consumed = 1; next(js); js->consumed = 0;
-      if (is_err(ns)) return ns;
-      
-      for (int i = 0; i < spec_count; i++) {
-        jsoff_t prop_off = lkp(js, ns, specs[i].local, specs[i].local_len);
-        jsval_t import_val = prop_off != 0 ? resolveprop(js, mkval(T_PROP, prop_off)) : js_mkundef();
-        esm_export_binding(js, specs[i].exported, specs[i].export_len, import_val);
-      }
-    } else {
-      for (int i = 0; i < spec_count; i++) {
-        jsval_t local_val = lookup(js, specs[i].local, specs[i].local_len);
-        if (is_err(local_val)) return local_val;
-        jsval_t export_val = resolveprop(js, local_val);
-        esm_export_binding(js, specs[i].exported, specs[i].export_len, export_val);
-      }
-    }
-    
-    if (next(js) == TOK_SEMICOLON) js->consumed = 1;
-    return js_mkundef();
-  }
-  
-  return js_mkerr(js, "Invalid export statement");
-}
-
 static proxy_data_t *get_proxy_data(jsval_t obj) {
   if (vtype(obj) != T_OBJ) return NULL;
   jsoff_t off = (jsoff_t)vdata(obj);
@@ -23500,17 +11408,17 @@ static proxy_data_t *get_proxy_data(jsval_t obj) {
   return data;
 }
 
-static bool is_proxy(struct js *js, jsval_t obj) {
+bool is_proxy(ant_t *js, jsval_t obj) {
   (void)js;
   return get_proxy_data(obj) != NULL;
 }
 
-static jsval_t proxy_read_target(struct js *js, jsval_t obj) {
+static jsval_t proxy_read_target(ant_t *js, jsval_t obj) {
   proxy_data_t *data = get_proxy_data(obj);
   return data ? data->target : obj;
 }
 
-static jsoff_t proxy_aware_length(struct js *js, jsval_t obj) {
+static jsoff_t proxy_aware_length(ant_t *js, jsval_t obj) {
   jsval_t src = is_proxy(js, obj) ? proxy_read_target(js, obj) : obj;
   if (vtype(src) == T_ARR) {
     jsoff_t doff = get_dense_buf(js, src);
@@ -23522,20 +11430,49 @@ static jsoff_t proxy_aware_length(struct js *js, jsval_t obj) {
   return vtype(len_val) == T_NUM ? (jsoff_t)tod(len_val) : 0;
 }
 
-static jsval_t proxy_aware_get_elem(struct js *js, jsval_t obj, const char *key, size_t key_len) {
+static jsval_t proxy_aware_get_elem(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
   jsval_t src = is_proxy(js, obj) ? proxy_read_target(js, obj) : obj;
   jsoff_t off = lkp(js, src, key, key_len);
   return off ? resolveprop(js, mkval(T_PROP, off)) : js_mkundef();
 }
 
-static jsval_t throw_proxy_error(struct js *js, const char *message) {
+static jsval_t throw_proxy_error(ant_t *js, const char *message) {
   jsval_t err_obj = mkobj(js, 0);
   js_setprop(js, err_obj, js_mkstr(js, "message", 7), js_mkstr(js, message, strlen(message)));
   js_setprop(js, err_obj, js_mkstr(js, "name", 4), js_mkstr(js, "TypeError", 9));
   return js_throw(js, err_obj);
 }
 
-static jsval_t proxy_get(struct js *js, jsval_t proxy, const char *key, size_t key_len) {
+static bool proxy_target_is_extensible(ant_t *js, jsval_t obj) {
+  uint8_t t = vtype(obj);
+  if (t != T_OBJ && t != T_ARR && t != T_FUNC) return false;
+
+  jsval_t as_obj = js_as_obj(obj);
+  if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return false;
+  if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return false;
+
+  jsval_t ext_slot = get_slot(js, as_obj, SLOT_EXTENSIBLE);
+  if (vtype(ext_slot) != T_UNDEF) return js_truthy(js, ext_slot);
+  return true;
+}
+
+static jsoff_t proxy_target_prop_flags(ant_t *js, jsval_t target, jsoff_t prop_off) {
+  if (prop_off == 0) return 0;
+  jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(target));
+  jsoff_t head = loadoff(js, obj_off);
+  if ((head & ~(3U | FLAGMASK)) == prop_off) return head;
+  return loadoff(js, prop_off);
+}
+
+static bool proxy_target_prop_is_nonconfig(ant_t *js, jsval_t target, jsoff_t prop_off) {
+  return (proxy_target_prop_flags(js, target, prop_off) & NONCONFIGMASK) != 0;
+}
+
+static bool proxy_target_prop_is_const(ant_t *js, jsval_t target, jsoff_t prop_off) {
+  return (proxy_target_prop_flags(js, target, prop_off) & CONSTMASK) != 0;
+}
+
+static jsval_t proxy_get(ant_t *js, jsval_t proxy, const char *key, size_t key_len) {
   proxy_data_t *data = get_proxy_data(proxy);
   if (!data) return js_mkundef();
   if (data->revoked) return throw_proxy_error(js, "Cannot perform 'get' on a proxy that has been revoked");
@@ -23550,14 +11487,32 @@ static jsval_t proxy_get(struct js *js, jsval_t proxy, const char *key, size_t k
   if (get_trap_off != 0) {
     jsval_t get_trap = resolveprop(js, mkval(T_PROP, get_trap_off));
     if (vtype(get_trap) == T_FUNC || vtype(get_trap) == T_CFUNC) {
-      jsval_t key_val;
-      if (is_symbol_key(key, key_len)) {
-        key_val = get_wellknown_sym_by_key(key, key_len);
-        if (key_val == 0) key_val = js_mkstr(js, key, key_len);
-      } else key_val = js_mkstr(js, key, key_len);
+      jsval_t key_val = js_mkstr(js, key, key_len);
       
       jsval_t args[3] = { target, key_val, proxy };
-      return js_call(js, get_trap, args, 3);
+      jsval_t result = sv_vm_call(js->vm, js, get_trap, js_mkundef(), args, 3, NULL, false);
+      if (is_err(result)) return result;
+
+      jsoff_t prop_off = lkp(js, target, key, key_len);
+      if (prop_off != 0 && proxy_target_prop_is_nonconfig(js, target, prop_off) &&
+          proxy_target_prop_is_const(js, target, prop_off)) {
+        jsval_t target_value = resolveprop(js, mkval(T_PROP, prop_off));
+        if (!strict_eq_values(js, result, target_value))
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'get' on proxy: trap returned invalid value for non-configurable, non-writable property");
+      }
+
+      descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(js_as_obj(target)), key, key_len);
+      if (desc && !desc->configurable) {
+        if (!desc->has_getter && !desc->has_setter && !desc->writable && prop_off != 0) {
+          jsval_t target_value = resolveprop(js, mkval(T_PROP, prop_off));
+          if (!strict_eq_values(js, result, target_value))
+            return js_mkerr_typed(js, JS_ERR_TYPE, "'get' on proxy: trap returned invalid value for non-configurable, non-writable property");
+        }
+        if ((desc->has_getter || desc->has_setter) && !desc->has_getter && vtype(result) != T_UNDEF)
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'get' on proxy: trap returned non-undefined for property with undefined getter");
+      }
+
+      return result;
     }
   }
   
@@ -23575,7 +11530,7 @@ static jsval_t proxy_get(struct js *js, jsval_t proxy, const char *key, size_t k
   return js_mkundef();
 }
 
-static jsval_t proxy_set(struct js *js, jsval_t proxy, const char *key, size_t key_len, jsval_t value) {
+static jsval_t proxy_set(ant_t *js, jsval_t proxy, const char *key, size_t key_len, jsval_t value) {
   proxy_data_t *data = get_proxy_data(proxy);
   if (!data) return js_mkundef();
   if (data->revoked) return throw_proxy_error(js, "Cannot perform 'set' on a proxy that has been revoked");
@@ -23589,8 +11544,28 @@ static jsval_t proxy_set(struct js *js, jsval_t proxy, const char *key, size_t k
     if (vtype(set_trap) == T_FUNC || vtype(set_trap) == T_CFUNC) {
       jsval_t key_val = js_mkstr(js, key, key_len);
       jsval_t args[4] = { target, key_val, value, proxy };
-      jsval_t result = js_call(js, set_trap, args, 4);
+      jsval_t result = sv_vm_call(js->vm, js, set_trap, js_mkundef(), args, 4, NULL, false);
       if (is_err(result)) return result;
+      if (js_truthy(js, result)) {
+        jsoff_t prop_off = lkp(js, target, key, key_len);
+        if (prop_off != 0 && proxy_target_prop_is_nonconfig(js, target, prop_off) &&
+            proxy_target_prop_is_const(js, target, prop_off)) {
+          jsval_t target_value = resolveprop(js, mkval(T_PROP, prop_off));
+          if (!strict_eq_values(js, value, target_value))
+            return js_mkerr_typed(js, JS_ERR_TYPE, "'set' on proxy: trap returned truthy for non-configurable, non-writable property with different value");
+        }
+
+        descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(js_as_obj(target)), key, key_len);
+        if (desc && !desc->configurable) {
+          if (!desc->has_getter && !desc->has_setter && !desc->writable && prop_off != 0) {
+            jsval_t target_value = resolveprop(js, mkval(T_PROP, prop_off));
+            if (!strict_eq_values(js, value, target_value))
+              return js_mkerr_typed(js, JS_ERR_TYPE, "'set' on proxy: trap returned truthy for non-configurable, non-writable property with different value");
+          }
+          if ((desc->has_getter || desc->has_setter) && !desc->has_setter)
+            return js_mkerr_typed(js, JS_ERR_TYPE, "'set' on proxy: trap returned truthy for property with undefined setter");
+        }
+      }
       return js_true;
     }
   }
@@ -23600,7 +11575,7 @@ static jsval_t proxy_set(struct js *js, jsval_t proxy, const char *key, size_t k
   return js_true;
 }
 
-static jsval_t proxy_has(struct js *js, jsval_t proxy, const char *key, size_t key_len) {
+static jsval_t proxy_has(ant_t *js, jsval_t proxy, const char *key, size_t key_len) {
   proxy_data_t *data = get_proxy_data(proxy);
   if (!data) return js_false;
   if (data->revoked) return throw_proxy_error(js, "Cannot perform 'has' on a proxy that has been revoked");
@@ -23614,7 +11589,22 @@ static jsval_t proxy_has(struct js *js, jsval_t proxy, const char *key, size_t k
     if (vtype(has_trap) == T_FUNC || vtype(has_trap) == T_CFUNC) {
       jsval_t key_val = js_mkstr(js, key, key_len);
       jsval_t args[2] = { target, key_val };
-      return js_call(js, has_trap, args, 2);
+      jsval_t result = sv_vm_call(js->vm, js, has_trap, js_mkundef(), args, 2, NULL, false);
+      if (is_err(result)) return result;
+
+      if (!js_truthy(js, result)) {
+        jsoff_t prop_off = lkp(js, target, key, key_len);
+        descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(js_as_obj(target)), key, key_len);
+        bool has_own = (prop_off != 0) || (desc != NULL);
+
+        if ((prop_off != 0 && proxy_target_prop_is_nonconfig(js, target, prop_off)) || (desc && !desc->configurable))
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'has' on proxy: trap returned falsy for non-configurable property");
+
+        if (has_own && !proxy_target_is_extensible(js, target))
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'has' on proxy: trap returned falsy for existing property on non-extensible target");
+      }
+
+      return result;
     }
   }
   
@@ -23627,30 +11617,200 @@ static jsval_t proxy_has(struct js *js, jsval_t proxy, const char *key, size_t k
   return js_bool(off != 0);
 }
 
-static jsval_t proxy_delete(struct js *js, jsval_t proxy, const char *key, size_t key_len) {
+static jsval_t proxy_delete(ant_t *js, jsval_t proxy, const char *key, size_t key_len) {
+  proxy_data_t *data = get_proxy_data(proxy);
+  if (!data) return js_true;
+  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'deleteProperty' on a proxy that has been revoked");
+  
+  jsval_t target = data->target;
+  jsval_t handler = data->handler;
+  
+  jsoff_t delete_trap_off = vtype(handler) == T_OBJ ? lkp(js, handler, "deleteProperty", 14) : 0;
+  if (delete_trap_off != 0) {
+    jsval_t delete_trap = resolveprop(js, mkval(T_PROP, delete_trap_off));
+    if (vtype(delete_trap) == T_FUNC || vtype(delete_trap) == T_CFUNC) {
+      jsval_t key_val = js_mkstr(js, key, key_len);
+      jsval_t args[2] = { target, key_val };
+      jsval_t result = sv_vm_call(js->vm, js, delete_trap, js_mkundef(), args, 2, NULL, false);
+      if (is_err(result)) return result;
+      if (js_truthy(js, result)) {
+        jsoff_t prop_off = lkp(js, target, key, key_len);
+        if (prop_off != 0 && is_nonconfig_prop(js, prop_off))
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'deleteProperty' on proxy: trap returned truthy for non-configurable property");
+        descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(js_as_obj(target)), key, key_len);
+        if (desc && !desc->configurable)
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'deleteProperty' on proxy: trap returned truthy for non-configurable property");
+      }
+      return result;
+    }
+  }
+  
+  jsval_t key_str = js_mkstr(js, key, key_len);
+  js_setprop(js, target, key_str, js_mkundef());
+  return js_true;
+}
+
+static jsval_t proxy_get_val(ant_t *js, jsval_t proxy, jsval_t key_val) {
+  proxy_data_t *data = get_proxy_data(proxy);
+  if (!data) return js_mkundef();
+  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'get' on a proxy that has been revoked");
+
+  jsval_t target = data->target;
+  jsval_t handler = data->handler;
+
+  jsoff_t get_trap_off = vtype(handler) == T_OBJ
+    ? lkp_interned(js, handler, INTERN_GET, 3) : 0;
+  if (get_trap_off != 0) {
+    jsval_t get_trap = resolveprop(js, mkval(T_PROP, get_trap_off));
+    if (vtype(get_trap) == T_FUNC || vtype(get_trap) == T_CFUNC) {
+      jsval_t args[3] = { target, key_val, proxy };
+      return sv_vm_call(js->vm, js, get_trap, js_mkundef(), args, 3, NULL, false);
+    }
+  }
+
+  if (vtype(key_val) == T_SYMBOL) {
+    jsoff_t off = lkp_sym_proto(js, target, (jsoff_t)vdata(key_val));
+    return off != 0 ? resolveprop(js, mkval(T_PROP, off)) : js_mkundef();
+  }
+
+  return proxy_get(js, proxy, "", 0);
+}
+
+static jsval_t proxy_has_val(ant_t *js, jsval_t proxy, jsval_t key_val) {
+  proxy_data_t *data = get_proxy_data(proxy);
+  if (!data) return js_false;
+  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'has' on a proxy that has been revoked");
+
+  jsval_t target = data->target;
+  jsval_t handler = data->handler;
+
+  jsoff_t has_trap_off = vtype(handler) == T_OBJ ? lkp(js, handler, "has", 3) : 0;
+  if (has_trap_off != 0) {
+    jsval_t has_trap = resolveprop(js, mkval(T_PROP, has_trap_off));
+    if (vtype(has_trap) == T_FUNC || vtype(has_trap) == T_CFUNC) {
+      jsval_t args[2] = { target, key_val };
+      return sv_vm_call(js->vm, js, has_trap, js_mkundef(), args, 2, NULL, false);
+    }
+  }
+
+  if (vtype(key_val) == T_SYMBOL) {
+    jsoff_t off = lkp_sym_proto(js, target, (jsoff_t)vdata(key_val));
+    return js_bool(off != 0);
+  }
+  return js_false;
+}
+
+static jsval_t proxy_delete_val(ant_t *js, jsval_t proxy, jsval_t key_val) {
+  proxy_data_t *data = get_proxy_data(proxy);
+  if (!data) return js_true;
+  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'deleteProperty' on a proxy that has been revoked");
+
+  jsval_t target = data->target;
+  jsval_t handler = data->handler;
+
+  jsoff_t delete_trap_off = vtype(handler) == T_OBJ ? lkp(js, handler, "deleteProperty", 14) : 0;
+  if (delete_trap_off != 0) {
+    jsval_t delete_trap = resolveprop(js, mkval(T_PROP, delete_trap_off));
+    if (vtype(delete_trap) == T_FUNC || vtype(delete_trap) == T_CFUNC) {
+      jsval_t args[2] = { target, key_val };
+      jsval_t result = sv_vm_call(js->vm, js, delete_trap, js_mkundef(), args, 2, NULL, false);
+      if (is_err(result)) return result;
+      if (js_truthy(js, result) && vtype(key_val) == T_SYMBOL) {
+        jsoff_t prop_off = lkp_sym(js, target, (jsoff_t)vdata(key_val));
+        if (prop_off != 0 && is_nonconfig_prop(js, prop_off))
+          return js_mkerr_typed(js, JS_ERR_TYPE, "'deleteProperty' on proxy: trap returned truthy for non-configurable property");
+      }
+      return result;
+    }
+  }
+
+  if (vtype(key_val) == T_SYMBOL) {
+    jsoff_t sym_off = (jsoff_t)vdata(key_val);
+    jsoff_t prop_off = lkp_sym(js, target, sym_off);
+    if (prop_off != 0) {
+      jsoff_t obj_off = (jsoff_t)vdata(js_as_obj(target));
+      jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
+      if (first_prop == prop_off) {
+        unlink_prop(js, obj_off, prop_off, 0);
+      } else {
+        for (jsoff_t prev = first_prop; prev != 0; ) {
+          jsoff_t np = loadoff(js, prev) & ~(3U | FLAGMASK);
+          if (np == prop_off) { unlink_prop(js, obj_off, prop_off, prev); break; }
+          prev = np;
+        }
+      }
+    }
+  }
+  return js_true;
+}
+
+jsval_t js_proxy_apply(ant_t *js, jsval_t proxy, jsval_t this_arg, jsval_t *args, int argc) {
+  proxy_data_t *data = get_proxy_data(proxy);
+  if (!data) return js_mkerr_typed(js, JS_ERR_TYPE, "object is not a function");
+  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'apply' on a proxy that has been revoked");
+
+  jsval_t target = data->target;
+  jsval_t handler = data->handler;
+  uint8_t target_type = vtype(target);
+
+  if (target_type != T_FUNC && target_type != T_CFUNC && !(target_type == T_OBJ && is_proxy(js, target)))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "%s is not a function", typestr(target_type));
+
+  jsoff_t trap_off = vtype(handler) == T_OBJ ? lkp(js, handler, "apply", 5) : 0;
+  if (trap_off != 0) {
+    jsval_t trap = resolveprop(js, mkval(T_PROP, trap_off));
+    if (vtype(trap) == T_FUNC || vtype(trap) == T_CFUNC) {
+      jsval_t args_arr = mkarr(js);
+      for (int i = 0; i < argc; i++)
+        js_arr_push(js, args_arr, args[i]);
+      jsval_t trap_args[3] = { target, this_arg, args_arr };
+      return sv_vm_call(js->vm, js, trap, handler, trap_args, 3, NULL, false);
+    }
+  }
+
+  return sv_vm_call(js->vm, js, target, this_arg, args, argc, NULL, false);
+}
+
+jsval_t js_proxy_construct(ant_t *js, jsval_t proxy, jsval_t *args, int argc, jsval_t new_target) {
   proxy_data_t *data = get_proxy_data(proxy);
-  if (!data) return js_true;
-  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'deleteProperty' on a proxy that has been revoked");
-  
+  if (!data) return js_mkerr_typed(js, JS_ERR_TYPE, "not a constructor");
+  if (data->revoked) return throw_proxy_error(js, "Cannot perform 'construct' on a proxy that has been revoked");
+
   jsval_t target = data->target;
   jsval_t handler = data->handler;
-  
-  jsoff_t delete_trap_off = vtype(handler) == T_OBJ ? lkp(js, handler, "deleteProperty", 14) : 0;
-  if (delete_trap_off != 0) {
-    jsval_t delete_trap = resolveprop(js, mkval(T_PROP, delete_trap_off));
-    if (vtype(delete_trap) == T_FUNC || vtype(delete_trap) == T_CFUNC) {
-      jsval_t key_val = js_mkstr(js, key, key_len);
-      jsval_t args[2] = { target, key_val };
-      return js_call(js, delete_trap, args, 2);
+
+  if (vtype(target) != T_FUNC)
+    return js_mkerr_typed(js, JS_ERR_TYPE, "not a constructor");
+
+  jsoff_t trap_off = vtype(handler) == T_OBJ ? lkp(js, handler, "construct", 9) : 0;
+  if (trap_off != 0) {
+    jsval_t trap = resolveprop(js, mkval(T_PROP, trap_off));
+    if (vtype(trap) == T_FUNC || vtype(trap) == T_CFUNC) {
+      jsval_t args_arr = mkarr(js);
+      for (int i = 0; i < argc; i++)
+        js_arr_push(js, args_arr, args[i]);
+      jsval_t trap_args[3] = { target, args_arr, new_target };
+      jsval_t result = sv_vm_call(js->vm, js, trap, js_mkundef(), trap_args, 3, NULL, false);
+      if (is_err(result)) return result;
+      if (!is_object_type(result))
+        return js_mkerr_typed(js, JS_ERR_TYPE, "'construct' on proxy: trap returned non-Object");
+      return result;
     }
   }
-  
-  jsval_t key_str = js_mkstr(js, key, key_len);
-  js_setprop(js, target, key_str, js_mkundef());
-  return js_true;
+
+  jsval_t obj = mkobj(js, 0);
+  jsval_t proto = js_getprop_fallback(js, target, "prototype");
+  if (is_object_type(proto)) js_set_proto(js, obj, proto);
+  jsval_t saved = js->new_target;
+  js->new_target = new_target;
+  jsval_t ctor_this = obj;
+  jsval_t result = sv_vm_call(js->vm, js, target, obj, args, argc, &ctor_this, true);
+  js->new_target = saved;
+  if (is_err(result)) return result;
+  return is_object_type(result) ? result : (is_object_type(ctor_this) ? ctor_this : obj);
 }
 
-static jsval_t mkproxy(struct js *js, jsval_t target, jsval_t handler) {
+static jsval_t mkproxy(ant_t *js, jsval_t target, jsval_t handler) {
   jsval_t proxy_obj = mkobj(js, 0);
   jsoff_t off = (jsoff_t)vdata(proxy_obj);
   
@@ -23666,7 +11826,7 @@ static jsval_t mkproxy(struct js *js, jsval_t target, jsval_t handler) {
   return proxy_obj;
 }
 
-static jsval_t create_proxy_checked(struct js *js, jsval_t *args, int nargs, bool require_new) {
+static jsval_t create_proxy_checked(ant_t *js, jsval_t *args, int nargs, bool require_new) {
   if (require_new && vtype(js->new_target) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Proxy constructor requires 'new'");
   }
@@ -23688,11 +11848,11 @@ static jsval_t create_proxy_checked(struct js *js, jsval_t *args, int nargs, boo
   return mkproxy(js, target, handler);
 }
 
-static jsval_t builtin_Proxy(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Proxy(ant_t *js, jsval_t *args, int nargs) {
   return create_proxy_checked(js, args, nargs, true);
 }
 
-static jsval_t proxy_revoke_fn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t proxy_revoke_fn(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t func = js->current_func;
   jsval_t ref_slot = get_slot(js, func, SLOT_PROXY_REF);
@@ -23706,7 +11866,7 @@ static jsval_t proxy_revoke_fn(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_Proxy_revocable(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Proxy_revocable(ant_t *js, jsval_t *args, int nargs) {
   jsval_t proxy = create_proxy_checked(js, args, nargs, false);
   if (is_err(proxy)) return proxy;
   
@@ -23714,7 +11874,7 @@ static jsval_t builtin_Proxy_revocable(struct js *js, jsval_t *args, int nargs)
   set_slot(js, revoke_obj, SLOT_CFUNC, js_mkfun(proxy_revoke_fn));
   set_slot(js, revoke_obj, SLOT_PROXY_REF, proxy);
   
-  jsval_t revoke_func = mkval(T_FUNC, vdata(revoke_obj));
+  jsval_t revoke_func = js_obj_to_func(revoke_obj);
   
   jsval_t result = mkobj(js, 0);
   js_setprop(js, result, js_mkstr(js, "proxy", 5), proxy);
@@ -23726,7 +11886,7 @@ static jsval_t builtin_Proxy_revocable(struct js *js, jsval_t *args, int nargs)
 ant_t *js_create(void *buf, size_t len) {
   assert(
     (uintptr_t)buf <= ((1ULL << 53) - 1) &&
-    "ANT_PTR: pointer exceeds 53-bit NaN-boxing limit"
+    "ANT_PTR: pointer exceeds 53-bit double-precision integer limit"
   );
   
   intern_init();
@@ -23735,33 +11895,17 @@ ant_t *js_create(void *buf, size_t len) {
   if (len < sizeof(*js) + esize(T_OBJ)) return js;
   memset(buf, 0, len);
   
-  js = (struct js *) buf;
+  js = (ant_t *) buf;
   js->mem = (uint8_t *) (js + 1);
   js->size = (jsoff_t) (len - sizeof(*js));
+  js->brk = NANBOX_HEAP_OFFSET;
   js->global = mkobj(js, 0);
-  js->scope = js->global;
   js->size = js->size / 8U * 8U;
-  js->this_val = js->scope;
-  js->super_val = js_mkundef();
+  js->this_val = js->global;
   js->new_target = js_mkundef();
-  js->pending_ntg = js_mkundef();
-  js->errmsg_size = 4096;
-  js->errmsg = (char *)malloc(js->errmsg_size);
-  if (js->errmsg) js->errmsg[0] = '\0';
   js->length_str = ANT_STRING("length");
 
-#ifdef _WIN32
-  js->stack_limit = 512 * 1024;
-#else
-  struct rlimit rl;
-  if (getrlimit(RLIMIT_STACK, &rl) == 0 && rl.rlim_cur != RLIM_INFINITY) {
-    js->stack_limit = rl.rlim_cur / 2;
-  } else {
-    js->stack_limit = 512 * 1024;
-  }
-#endif
-  
-  jsval_t glob = js->scope;
+  jsval_t glob = js->global;
   jsval_t object_proto = js_mkobj(js);
   set_proto(js, object_proto, js_mknull());
   
@@ -23785,7 +11929,6 @@ ant_t *js_create(void *buf, size_t len) {
   
   jsval_t proto_getter = js_mkfun(builtin_proto_getter);
   jsval_t proto_setter = js_mkfun(builtin_proto_setter);
-  js_setprop(js, object_proto, js_mkstr(js, STR_PROTO, STR_PROTO_LEN), js_mkundef());
   js_set_accessor_desc(js, object_proto, STR_PROTO, STR_PROTO_LEN, proto_getter, proto_setter, JS_DESC_C);
   
   jsval_t function_proto_obj = js_mkobj(js);
@@ -23795,7 +11938,7 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, function_proto_obj, ANT_STRING("apply"), js_mkfun(builtin_function_apply));
   js_setprop(js, function_proto_obj, ANT_STRING("bind"), js_mkfun(builtin_function_bind));
   js_setprop(js, function_proto_obj, ANT_STRING("toString"), js_mkfun(builtin_function_toString));
-  jsval_t function_proto = mkval(T_FUNC, vdata(function_proto_obj));
+  jsval_t function_proto = js_obj_to_func(function_proto_obj);
   set_slot(js, glob, SLOT_FUNC_PROTO, function_proto);
   
   jsval_t array_proto = js_mkobj(js);
@@ -23851,7 +11994,6 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, string_proto, js_mkstr(js, "endsWith", 8), js_mkfun(builtin_string_endsWith));
   js_setprop(js, string_proto, js_mkstr(js, "replace", 7), js_mkfun(builtin_string_replace));
   js_setprop(js, string_proto, js_mkstr(js, "replaceAll", 10), js_mkfun(builtin_string_replaceAll));
-  js_setprop(js, string_proto, js_mkstr(js, "match", 5), js_mkfun(builtin_string_match));
   js_setprop(js, string_proto, js_mkstr(js, "template", 8), js_mkfun(builtin_string_template));
   js_setprop(js, string_proto, js_mkstr(js, "charCodeAt", 10), js_mkfun(builtin_string_charCodeAt));
   js_setprop(js, string_proto, js_mkstr(js, "codePointAt", 11), js_mkfun(builtin_string_codePointAt));
@@ -23869,8 +12011,8 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, string_proto, js_mkstr(js, "at", 2), js_mkfun(builtin_string_at));
   js_setprop(js, string_proto, js_mkstr(js, "lastIndexOf", 11), js_mkfun(builtin_string_lastIndexOf));
   js_setprop(js, string_proto, js_mkstr(js, "concat", 6), js_mkfun(builtin_string_concat));
-  js_setprop(js, string_proto, js_mkstr(js, "search", 6), js_mkfun(builtin_string_search));
   js_setprop(js, string_proto, js_mkstr(js, "localeCompare", 13), js_mkfun(builtin_string_localeCompare));
+  js_setprop(js, string_proto, js_mkstr(js, "normalize", 9), js_mkfun(builtin_string_normalize));
   js_setprop(js, string_proto, js_mkstr(js, "valueOf", 7), js_mkfun(builtin_string_valueOf));
   js_setprop(js, string_proto, js_mkstr(js, "toString", 8), js_mkfun(builtin_string_toString));
 
@@ -23903,8 +12045,9 @@ ant_t *js_create(void *buf, size_t len) {
   set_slot(js, err_ctor_obj, SLOT_CFUNC, js_mkfun(builtin_Error));
   js_setprop_nonconfigurable(js, err_ctor_obj, "prototype", 9, error_proto);
   js_setprop(js, err_ctor_obj, ANT_STRING("name"), ANT_STRING("Error"));
-  js_setprop(js, glob, ANT_STRING("Error"), mkval(T_FUNC, vdata(err_ctor_obj)));
-  js_setprop(js, error_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(err_ctor_obj)));
+  jsval_t err_ctor_func = js_obj_to_func(err_ctor_obj);
+  js_setprop(js, glob, ANT_STRING("Error"), err_ctor_func);
+  js_setprop(js, error_proto, js_mkstr(js, "constructor", 11), err_ctor_func);
   js_set_descriptor(js, error_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
   #define REGISTER_ERROR_SUBTYPE(name_str) do { \
@@ -23916,9 +12059,10 @@ ant_t *js_create(void *buf, size_t len) {
     set_slot(js, ctor, SLOT_CFUNC, js_mkfun(builtin_Error)); \
     js_setprop_nonconfigurable(js, ctor, "prototype", 9, proto); \
     js_setprop(js, ctor, ANT_STRING("name"), ANT_STRING(name_str)); \
-    js_setprop(js, proto, ANT_STRING("constructor"), mkval(T_FUNC, vdata(ctor))); \
+    jsval_t ctor_func = js_obj_to_func(ctor); \
+    js_setprop(js, proto, ANT_STRING("constructor"), ctor_func); \
     js_set_descriptor(js, proto, "constructor", 11, JS_DESC_W | JS_DESC_C); \
-    js_setprop(js, glob, ANT_STRING(name_str), mkval(T_FUNC, vdata(ctor))); \
+    js_setprop(js, glob, ANT_STRING(name_str), ctor_func); \
   } while(0)
   
   REGISTER_ERROR_SUBTYPE("EvalError");
@@ -23939,72 +12083,9 @@ ant_t *js_create(void *buf, size_t len) {
   set_slot(js, ctor, SLOT_CFUNC, js_mkfun(builtin_AggregateError));
   js_setprop_nonconfigurable(js, ctor, "prototype", 9, proto);
   js_setprop(js, ctor, ANT_STRING("name"), ANT_STRING("AggregateError"));
-  js_setprop(js, proto, ANT_STRING("constructor"), mkval(T_FUNC, vdata(ctor)));
+  js_setprop(js, proto, ANT_STRING("constructor"), js_obj_to_func(ctor));
   js_set_descriptor(js, proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
-  js_setprop(js, glob, ANT_STRING("AggregateError"), mkval(T_FUNC, vdata(ctor)));
-  
-  jsval_t date_proto = js_mkobj(js);
-  set_proto(js, date_proto, object_proto);
-  js_setprop(js, date_proto, js_mkstr(js, "getTime", 7), js_mkfun(builtin_Date_getTime));
-  js_setprop(js, date_proto, js_mkstr(js, "getFullYear", 11), js_mkfun(builtin_Date_getFullYear));
-  js_setprop(js, date_proto, js_mkstr(js, "getMonth", 8), js_mkfun(builtin_Date_getMonth));
-  js_setprop(js, date_proto, js_mkstr(js, "getDate", 7), js_mkfun(builtin_Date_getDate));
-  js_setprop(js, date_proto, js_mkstr(js, "getHours", 8), js_mkfun(builtin_Date_getHours));
-  js_setprop(js, date_proto, js_mkstr(js, "getMinutes", 10), js_mkfun(builtin_Date_getMinutes));
-  js_setprop(js, date_proto, js_mkstr(js, "getSeconds", 10), js_mkfun(builtin_Date_getSeconds));
-  js_setprop(js, date_proto, js_mkstr(js, "getMilliseconds", 15), js_mkfun(builtin_Date_getMilliseconds));
-  js_setprop(js, date_proto, js_mkstr(js, "getDay", 6), js_mkfun(builtin_Date_getDay));
-  js_setprop(js, date_proto, js_mkstr(js, "getTimezoneOffset", 17), js_mkfun(builtin_Date_getTimezoneOffset));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCFullYear", 14), js_mkfun(builtin_Date_getUTCFullYear));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCMonth", 11), js_mkfun(builtin_Date_getUTCMonth));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCDate", 10), js_mkfun(builtin_Date_getUTCDate));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCHours", 11), js_mkfun(builtin_Date_getUTCHours));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCMinutes", 13), js_mkfun(builtin_Date_getUTCMinutes));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCSeconds", 13), js_mkfun(builtin_Date_getUTCSeconds));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCMilliseconds", 18), js_mkfun(builtin_Date_getUTCMilliseconds));
-  js_setprop(js, date_proto, js_mkstr(js, "getUTCDay", 9), js_mkfun(builtin_Date_getUTCDay));
-  js_setprop(js, date_proto, js_mkstr(js, "setTime", 7), js_mkfun(builtin_Date_setTime));
-  js_setprop(js, date_proto, js_mkstr(js, "setMilliseconds", 15), js_mkfun(builtin_Date_setMilliseconds));
-  js_setprop(js, date_proto, js_mkstr(js, "setSeconds", 10), js_mkfun(builtin_Date_setSeconds));
-  js_setprop(js, date_proto, js_mkstr(js, "setMinutes", 10), js_mkfun(builtin_Date_setMinutes));
-  js_setprop(js, date_proto, js_mkstr(js, "setHours", 8), js_mkfun(builtin_Date_setHours));
-  js_setprop(js, date_proto, js_mkstr(js, "setDate", 7), js_mkfun(builtin_Date_setDate));
-  js_setprop(js, date_proto, js_mkstr(js, "setMonth", 8), js_mkfun(builtin_Date_setMonth));
-  js_setprop(js, date_proto, js_mkstr(js, "setFullYear", 11), js_mkfun(builtin_Date_setFullYear));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCMilliseconds", 18), js_mkfun(builtin_Date_setUTCMilliseconds));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCSeconds", 13), js_mkfun(builtin_Date_setUTCSeconds));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCMinutes", 13), js_mkfun(builtin_Date_setUTCMinutes));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCHours", 11), js_mkfun(builtin_Date_setUTCHours));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCDate", 10), js_mkfun(builtin_Date_setUTCDate));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCMonth", 11), js_mkfun(builtin_Date_setUTCMonth));
-  js_setprop(js, date_proto, js_mkstr(js, "setUTCFullYear", 14), js_mkfun(builtin_Date_setUTCFullYear));
-  js_setprop(js, date_proto, js_mkstr(js, "valueOf", 7), js_mkfun(builtin_Date_valueOf));
-  js_setprop(js, date_proto, js_mkstr(js, "toISOString", 11), js_mkfun(builtin_Date_toISOString));
-  js_setprop(js, date_proto, js_mkstr(js, "toUTCString", 11), js_mkfun(builtin_Date_toUTCString));
-  js_setprop(js, date_proto, js_mkstr(js, "toGMTString", 11), js_mkfun(builtin_Date_toUTCString));
-  js_setprop(js, date_proto, js_mkstr(js, "toString", 8), js_mkfun(builtin_Date_toString));
-  js_setprop(js, date_proto, js_mkstr(js, "toDateString", 12), js_mkfun(builtin_Date_toDateString));
-  js_setprop(js, date_proto, js_mkstr(js, "toTimeString", 12), js_mkfun(builtin_Date_toTimeString));
-  js_setprop(js, date_proto, js_mkstr(js, "toLocaleDateString", 18), js_mkfun(builtin_Date_toLocaleDateString));
-  js_setprop(js, date_proto, js_mkstr(js, "toLocaleTimeString", 18), js_mkfun(builtin_Date_toLocaleTimeString));
-  js_setprop(js, date_proto, js_mkstr(js, "getYear", 7), js_mkfun(builtin_Date_getYear));
-  js_setprop(js, date_proto, js_mkstr(js, "setYear", 7), js_mkfun(builtin_Date_setYear));
-  js_setprop(js, date_proto, js_mkstr(js, "toJSON", 6), js_mkfun(builtin_Date_toJSON));
-  
-  jsval_t regexp_proto = js_mkobj(js);
-  set_proto(js, regexp_proto, object_proto);
-  js_setprop(js, regexp_proto, js_mkstr(js, "test", 4), js_mkfun(builtin_regexp_test));
-  js_setprop(js, regexp_proto, js_mkstr(js, "exec", 4), js_mkfun(builtin_regexp_exec));
-  js_setprop(js, regexp_proto, js_mkstr(js, "toString", 8), js_mkfun(builtin_regexp_toString));
-  
-  js_mkprop_fast(js, regexp_proto, "global", 6, js_false);
-  js_mkprop_fast(js, regexp_proto, "ignoreCase", 10, js_false);
-  js_mkprop_fast(js, regexp_proto, "multiline", 9, js_false);
-  js_mkprop_fast(js, regexp_proto, "dotAll", 6, js_false);
-  js_mkprop_fast(js, regexp_proto, "unicode", 7, js_false);
-  js_mkprop_fast(js, regexp_proto, "sticky", 6, js_false);
-  js_mkprop_fast(js, regexp_proto, "hasIndices", 10, js_false);
-  js_mkprop_fast(js, regexp_proto, "unicodeSets", 11, js_false);
+  js_setprop(js, glob, ANT_STRING("AggregateError"), js_obj_to_func(ctor));
   
   jsval_t promise_proto = js_mkobj(js);
   set_proto(js, promise_proto, object_proto);
@@ -24024,6 +12105,7 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, obj_func_obj, js_mkstr(js, "setPrototypeOf", 14), js_mkfun(builtin_object_setPrototypeOf));
   js_setprop(js, obj_func_obj, js_mkstr(js, "create", 6), js_mkfun(builtin_object_create));
   js_setprop(js, obj_func_obj, js_mkstr(js, "hasOwn", 6), js_mkfun(builtin_object_hasOwn));
+  js_setprop(js, obj_func_obj, js_mkstr(js, "groupBy", 7), js_mkfun(builtin_object_groupBy));
   js_setprop(js, obj_func_obj, js_mkstr(js, "defineProperty", 14), js_mkfun(builtin_object_defineProperty));
   js_setprop(js, obj_func_obj, js_mkstr(js, "defineProperties", 16), js_mkfun(builtin_object_defineProperties));
   js_setprop(js, obj_func_obj, js_mkstr(js, "assign", 6), js_mkfun(builtin_object_assign));
@@ -24039,7 +12121,8 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, obj_func_obj, js_mkstr(js, "preventExtensions", 17), js_mkfun(builtin_object_preventExtensions));
   js_setprop(js, obj_func_obj, ANT_STRING("name"), ANT_STRING("Object"));
   js_setprop_nonconfigurable(js, obj_func_obj, "prototype", 9, object_proto);
-  js_setprop(js, glob, js_mkstr(js, "Object", 6), mkval(T_FUNC, vdata(obj_func_obj)));
+  jsval_t obj_func = js_obj_to_func(obj_func_obj);
+  js_setprop(js, glob, js_mkstr(js, "Object", 6), obj_func);
   
   jsval_t func_ctor_obj = mkobj(js, 0);
   set_proto(js, func_ctor_obj, function_proto);
@@ -24048,12 +12131,13 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, func_ctor_obj, js->length_str, tov(1.0));
   js_set_descriptor(js, func_ctor_obj, "length", 6, JS_DESC_C);
   js_setprop(js, func_ctor_obj, ANT_STRING("name"), ANT_STRING("Function"));
-  js_setprop(js, glob, js_mkstr(js, "Function", 8), mkval(T_FUNC, vdata(func_ctor_obj)));
+  jsval_t func_ctor_func = js_obj_to_func(func_ctor_obj);
+  js_setprop(js, glob, js_mkstr(js, "Function", 8), func_ctor_func);
   
   jsval_t async_func_proto_obj = js_mkobj(js);
   set_proto(js, async_func_proto_obj, function_proto);
   set_slot(js, async_func_proto_obj, SLOT_ASYNC, js_true);
-  jsval_t async_func_proto = mkval(T_FUNC, vdata(async_func_proto_obj));
+  jsval_t async_func_proto = js_obj_to_func(async_func_proto_obj);
   set_slot(js, glob, SLOT_ASYNC_PROTO, async_func_proto);
   
   jsval_t async_func_ctor_obj = mkobj(js, 0);
@@ -24063,7 +12147,7 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, async_func_ctor_obj, js->length_str, tov(1.0));
   js_set_descriptor(js, async_func_ctor_obj, "length", 6, JS_DESC_C);
   js_setprop(js, async_func_ctor_obj, ANT_STRING("name"), ANT_STRING("AsyncFunction"));
-  jsval_t async_func_ctor = mkval(T_FUNC, vdata(async_func_ctor_obj));
+  jsval_t async_func_ctor = js_obj_to_func(async_func_ctor_obj);
   
   js_setprop(js, async_func_proto_obj, js_mkstr(js, "constructor", 11), async_func_ctor);
   js_set_descriptor(js, async_func_proto_obj, "constructor", 11, JS_DESC_W | JS_DESC_C);
@@ -24074,8 +12158,10 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop_nonconfigurable(js, str_ctor_obj, "prototype", 9, string_proto);
   js_setprop(js, str_ctor_obj, js_mkstr(js, "fromCharCode", 12), js_mkfun(builtin_string_fromCharCode));
   js_setprop(js, str_ctor_obj, js_mkstr(js, "fromCodePoint", 13), js_mkfun(builtin_string_fromCodePoint));
+  js_setprop(js, str_ctor_obj, js_mkstr(js, "raw", 3), js_mkfun(builtin_string_raw));
   js_setprop(js, str_ctor_obj, ANT_STRING("name"), ANT_STRING("String"));
-  js_setprop(js, glob, js_mkstr(js, "String", 6), mkval(T_FUNC, vdata(str_ctor_obj)));
+  jsval_t str_ctor_func = js_obj_to_func(str_ctor_obj);
+  js_setprop(js, glob, js_mkstr(js, "String", 6), str_ctor_func);
   
   jsval_t number_ctor_obj = mkobj(js, 0);
   set_proto(js, number_ctor_obj, function_proto);
@@ -24099,14 +12185,16 @@ ant_t *js_create(void *buf, size_t len) {
   
   js_setprop_nonconfigurable(js, number_ctor_obj, "prototype", 9, number_proto);
   js_setprop(js, number_ctor_obj, ANT_STRING("name"), ANT_STRING("Number"));
-  js_setprop(js, glob, js_mkstr(js, "Number", 6), mkval(T_FUNC, vdata(number_ctor_obj)));
+  jsval_t number_ctor_func = js_obj_to_func(number_ctor_obj);
+  js_setprop(js, glob, js_mkstr(js, "Number", 6), number_ctor_func);
   
   jsval_t bool_ctor_obj = mkobj(js, 0);
   set_proto(js, bool_ctor_obj, function_proto);
   set_slot(js, bool_ctor_obj, SLOT_CFUNC, js_mkfun(builtin_Boolean));
   js_setprop_nonconfigurable(js, bool_ctor_obj, "prototype", 9, boolean_proto);
   js_setprop(js, bool_ctor_obj, ANT_STRING("name"), ANT_STRING("Boolean"));
-  js_setprop(js, glob, js_mkstr(js, "Boolean", 7), mkval(T_FUNC, vdata(bool_ctor_obj)));
+  jsval_t bool_ctor_func = js_obj_to_func(bool_ctor_obj);
+  js_setprop(js, glob, js_mkstr(js, "Boolean", 7), bool_ctor_func);
   
   jsval_t arr_ctor_obj = mkobj(js, 0);
   set_proto(js, arr_ctor_obj, function_proto);
@@ -24118,30 +12206,15 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, arr_ctor_obj, js->length_str, tov(1.0));
   js_set_descriptor(js, arr_ctor_obj, "length", 6, JS_DESC_C);
   js_setprop(js, arr_ctor_obj, ANT_STRING("name"), ANT_STRING("Array"));
-  js_setprop(js, glob, js_mkstr(js, "Array", 5), mkval(T_FUNC, vdata(arr_ctor_obj)));
+  jsval_t arr_ctor_func = js_obj_to_func(arr_ctor_obj);
+  js_setprop(js, glob, js_mkstr(js, "Array", 5), arr_ctor_func);
   
   jsval_t proxy_ctor_obj = mkobj(js, 0);
   set_proto(js, proxy_ctor_obj, function_proto);
   set_slot(js, proxy_ctor_obj, SLOT_CFUNC, js_mkfun(builtin_Proxy));
   js_setprop(js, proxy_ctor_obj, js_mkstr(js, "revocable", 9), js_mkfun(builtin_Proxy_revocable));
   js_setprop(js, proxy_ctor_obj, ANT_STRING("name"), ANT_STRING("Proxy"));
-  js_setprop(js, glob, js_mkstr(js, "Proxy", 5), mkval(T_FUNC, vdata(proxy_ctor_obj)));
-  
-  jsval_t regex_ctor_obj = mkobj(js, 0);
-  set_proto(js, regex_ctor_obj, function_proto);
-  set_slot(js, regex_ctor_obj, SLOT_CFUNC, js_mkfun(builtin_RegExp));
-  js_setprop_nonconfigurable(js, regex_ctor_obj, "prototype", 9, regexp_proto);
-  js_setprop(js, regex_ctor_obj, ANT_STRING("name"), ANT_STRING("RegExp"));
-  js_setprop(js, glob, js_mkstr(js, "RegExp", 6), mkval(T_FUNC, vdata(regex_ctor_obj)));
-  
-  jsval_t date_ctor_obj = mkobj(js, 0);
-  set_proto(js, date_ctor_obj, function_proto);
-  set_slot(js, date_ctor_obj, SLOT_CFUNC, js_mkfun(builtin_Date));
-  js_setprop(js, date_ctor_obj, js_mkstr(js, "now", 3), js_mkfun(builtin_Date_now));
-  js_setprop(js, date_ctor_obj, js_mkstr(js, "UTC", 3), js_mkfun(builtin_Date_UTC));
-  js_setprop_nonconfigurable(js, date_ctor_obj, "prototype", 9, date_proto);
-  js_setprop(js, date_ctor_obj, ANT_STRING("name"), ANT_STRING("Date"));
-  js_setprop(js, glob, js_mkstr(js, "Date", 4), mkval(T_FUNC, vdata(date_ctor_obj)));
+  js_setprop(js, glob, js_mkstr(js, "Proxy", 5), js_obj_to_func(proxy_ctor_obj));
   
   jsval_t p_ctor_obj = mkobj(js, 0);
   set_proto(js, p_ctor_obj, function_proto);
@@ -24149,12 +12222,13 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, p_ctor_obj, js_mkstr(js, "resolve", 7), js_mkfun(builtin_Promise_resolve));
   js_setprop(js, p_ctor_obj, js_mkstr(js, "reject", 6), js_mkfun(builtin_Promise_reject));
   js_setprop(js, p_ctor_obj, js_mkstr(js, "try", 3), js_mkfun(builtin_Promise_try));
+  js_setprop(js, p_ctor_obj, js_mkstr(js, "withResolvers", 13), js_mkfun(builtin_Promise_withResolvers));
   js_setprop(js, p_ctor_obj, js_mkstr(js, "all", 3), js_mkfun(builtin_Promise_all));
   js_setprop(js, p_ctor_obj, js_mkstr(js, "race", 4), js_mkfun(builtin_Promise_race));
   js_setprop(js, p_ctor_obj, js_mkstr(js, "any", 3), js_mkfun(builtin_Promise_any));
   js_setprop_nonconfigurable(js, p_ctor_obj, "prototype", 9, promise_proto);
   js_setprop(js, p_ctor_obj, ANT_STRING("name"), ANT_STRING("Promise"));
-  js_setprop(js, glob, js_mkstr(js, "Promise", 7), mkval(T_FUNC, vdata(p_ctor_obj)));
+  js_setprop(js, glob, js_mkstr(js, "Promise", 7), js_obj_to_func(p_ctor_obj));
   
   jsval_t bigint_ctor_obj = mkobj(js, 0);
   set_proto(js, bigint_ctor_obj, function_proto);
@@ -24163,18 +12237,21 @@ ant_t *js_create(void *buf, size_t len) {
   js_setprop(js, bigint_ctor_obj, js_mkstr(js, "asUintN", 7), js_mkfun(builtin_BigInt_asUintN));
   js_setprop_nonconfigurable(js, bigint_ctor_obj, "prototype", 9, bigint_proto);
   js_setprop(js, bigint_ctor_obj, ANT_STRING("name"), ANT_STRING("BigInt"));
-  js_setprop(js, glob, js_mkstr(js, "BigInt", 6), mkval(T_FUNC, vdata(bigint_ctor_obj)));
+  js_setprop(js, glob, js_mkstr(js, "BigInt", 6), js_obj_to_func(bigint_ctor_obj));
   
-  js_setprop(js, glob, js_mkstr(js, "eval", 4), js_mkfun(builtin_eval));
   js_setprop(js, glob, js_mkstr(js, "parseInt", 8), js_mkfun(builtin_parseInt));
   js_setprop(js, glob, js_mkstr(js, "parseFloat", 10), js_mkfun(builtin_parseFloat));
+  js_setprop(js, glob, js_mkstr(js, "eval", 4), js_mkfun(builtin_eval));
   js_setprop(js, glob, js_mkstr(js, "isNaN", 5), js_mkfun(builtin_global_isNaN));
   js_setprop(js, glob, js_mkstr(js, "isFinite", 8), js_mkfun(builtin_global_isFinite));
   js_setprop(js, glob, js_mkstr(js, "btoa", 4), js_mkfun(builtin_btoa));
   js_setprop(js, glob, js_mkstr(js, "atob", 4), js_mkfun(builtin_atob));
   js_setprop(js, glob, js_mkstr(js, "NaN", 3), tov(JS_NAN));
+  js_set_descriptor(js, glob, "NaN", 3, 0);
   js_setprop(js, glob, js_mkstr(js, "Infinity", 8), tov(JS_INF));
+  js_set_descriptor(js, glob, "Infinity", 8, 0);
   js_setprop(js, glob, js_mkstr(js, "undefined", 9), js_mkundef());
+  js_set_descriptor(js, glob, "undefined", 9, 0);
   
   jsval_t math_obj = mkobj(js, 0);
   set_proto(js, math_obj, object_proto);
@@ -24227,33 +12304,29 @@ ant_t *js_create(void *buf, size_t len) {
   set_proto(js, import_obj, function_proto);
   
   set_slot(js, import_obj, SLOT_CFUNC, js_mkfun(builtin_import));
-  js_setprop(js, glob, js_mkstr(js, "import", 6), mkval(T_FUNC, vdata(import_obj)));
+  js_setprop(js, glob, js_mkstr(js, "import", 6), js_obj_to_func(import_obj));
+  
   js->module_ns = js_mkundef();
+  js->import_meta = js_mkundef();
   
-  js_setprop(js, object_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(obj_func_obj)));
+  js_setprop(js, object_proto, js_mkstr(js, "constructor", 11), obj_func);
   js_set_descriptor(js, object_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
-  js_setprop(js, function_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(func_ctor_obj)));
+  js_setprop(js, function_proto, js_mkstr(js, "constructor", 11), func_ctor_func);
   js_set_descriptor(js, function_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
-  js_setprop(js, array_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(arr_ctor_obj)));
+  js_setprop(js, array_proto, js_mkstr(js, "constructor", 11), arr_ctor_func);
   js_set_descriptor(js, array_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
-  js_setprop(js, string_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(str_ctor_obj)));
+  js_setprop(js, string_proto, js_mkstr(js, "constructor", 11), str_ctor_func);
   js_set_descriptor(js, string_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
-  js_setprop(js, number_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(number_ctor_obj)));
+  js_setprop(js, number_proto, js_mkstr(js, "constructor", 11), number_ctor_func);
   js_set_descriptor(js, number_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
-  js_setprop(js, boolean_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(bool_ctor_obj)));
+  js_setprop(js, boolean_proto, js_mkstr(js, "constructor", 11), bool_ctor_func);
   js_set_descriptor(js, boolean_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
   
-  js_setprop(js, date_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(date_ctor_obj)));
-  js_set_descriptor(js, date_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
-  
-  js_setprop(js, regexp_proto, js_mkstr(js, "constructor", 11), mkval(T_FUNC, vdata(regex_ctor_obj)));
-  js_set_descriptor(js, regexp_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
-  
   set_proto(js, glob, object_proto);
   
   js->object = object_proto;
@@ -24263,11 +12336,11 @@ ant_t *js_create(void *buf, size_t len) {
   return js;
 }
 
-struct js *js_create_dynamic() {
+ant_t *js_create_dynamic() {
   void *init_buf = ant_calloc(ANT_ARENA_MIN);
   if (init_buf == NULL) return NULL;
   
-  struct js *js = js_create(init_buf, ANT_ARENA_MIN);
+  ant_t *js = js_create(init_buf, ANT_ARENA_MIN);
   if (js == NULL) { free(init_buf); return NULL; }
   
   uint8_t *arena = (uint8_t *)ant_arena_reserve(ANT_ARENA_MAX);
@@ -24284,38 +12357,35 @@ struct js *js_create_dynamic() {
   js->owns_mem = true;
   js->max_size = (jsoff_t) ANT_ARENA_MAX;
   
-  struct js *new_js = (struct js *)malloc(sizeof(struct js));
+  ant_t *new_js = (ant_t *)malloc(sizeof(ant_t));
   if (new_js == NULL) {
     ant_arena_free(arena, ANT_ARENA_MAX);
     free(init_buf);
     return NULL;
   }
   
-  memcpy(new_js, js, sizeof(struct js));
+  memcpy(new_js, js, sizeof(ant_t));
   free(init_buf);
 
+  new_js->vm = sv_vm_create(new_js, SV_VM_MAIN);
+
   return new_js;
 }
 
-void js_destroy(struct js *js) {
+void js_destroy(ant_t *js) {
   if (js == NULL) return;
   
-  esm_cleanup_module_cache();
+  if (js->vm) {
+    sv_vm_destroy(js->vm);
+    js->vm = NULL;
+  }
+  
+  js_esm_cleanup_module_cache();
   code_arena_reset();
   cleanup_buffer_module();
   cleanup_collections_module();
   cleanup_lmdb_module();
   
-  if (js->errmsg) {
-    free(js->errmsg);
-    js->errmsg = NULL;
-  }
-  
-  if (js->for_let_stack) {
-    free(js->for_let_stack);
-    js->for_let_stack = NULL;
-  }
-  
   if (js->owns_mem) {
     ant_arena_free(js->mem, js->max_size);
     free(js);
@@ -24325,33 +12395,32 @@ void js_destroy(struct js *js) {
 }
 
 inline double js_getnum(jsval_t value) { return tod(value); }
-inline void js_setstacklimit(struct js *js, size_t max) { js->stack_limit = max; }
-inline void js_setstackbase(struct js *js, void *base) { js->cstk = base; }
-inline void js_set_filename(struct js *js, const char *filename) { js->filename = filename; }
+inline void js_setstackbase(ant_t *js, void *base) { js->cstk.base = base; js->cstk.main_base = base; }
+inline void js_setstacklimit(ant_t *js, size_t max) { js->cstk.limit = max; }
+inline void js_set_filename(ant_t *js, const char *filename) { js->filename = filename; }
 
 inline jsval_t js_mkundef(void) { return mkval(T_UNDEF, 0); }
 inline jsval_t js_mknull(void) { return mkval(T_NULL, 0); }
 inline jsval_t js_mknum(double value) { return tov(value); }
-inline jsval_t js_mkobj(struct js *js) { return mkobj(js, 0); }
-inline jsval_t js_glob(struct js *js) { return js->global; }
-inline jsval_t js_getscope(struct js *js) { return js->scope; }
-inline jsval_t js_mkfun(jsval_t (*fn)(struct js *, jsval_t *, int)) { return mkval(T_CFUNC, (size_t) (void *) fn); }
+inline jsval_t js_mkobj(ant_t *js) { return mkobj(js, 0); }
+inline jsval_t js_glob(ant_t *js) { return js->global; }
+inline jsval_t js_mkfun(jsval_t (*fn)(ant_t *, jsval_t *, int)) { return mkval(T_CFUNC, (size_t) (void *) fn); }
 
-inline jsval_t js_getthis(struct js *js) { return js->this_val; }
-inline void js_setthis(struct js *js, jsval_t val) { js->this_val = val; }
-inline jsval_t js_getcurrentfunc(struct js *js) { return js->current_func; }
+inline jsval_t js_getthis(ant_t *js) { return js->this_val; }
+inline void js_setthis(ant_t *js, jsval_t val) { js->this_val = val; }
+inline jsval_t js_getcurrentfunc(ant_t *js) { return js->current_func; }
 
-jsval_t js_heavy_mkfun(struct js *js, jsval_t (*fn)(struct js *, jsval_t *, int), jsval_t data) {
+jsval_t js_heavy_mkfun(ant_t *js, jsval_t (*fn)(ant_t *, jsval_t *, int), jsval_t data) {
   jsval_t cfunc = js_mkfun(fn);
   jsval_t fn_obj = mkobj(js, 0);
   
   set_slot(js, fn_obj, SLOT_CFUNC, cfunc);
   set_slot(js, fn_obj, SLOT_DATA, data);
   
-  return mkval(T_FUNC, (unsigned long)vdata(fn_obj));
+  return js_obj_to_func(fn_obj);
 }
 
-void js_set(struct js *js, jsval_t obj, const char *key, jsval_t val) {
+void js_set(ant_t *js, jsval_t obj, const char *key, jsval_t val) {
   size_t key_len = strlen(key);
   
   if (vtype(obj) == T_OBJ) {
@@ -24367,7 +12436,7 @@ void js_set(struct js *js, jsval_t obj, const char *key, jsval_t val) {
       mkprop(js, obj, key_str, val, 0);
     }
   } else if (vtype(obj) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(obj));
+    jsval_t func_obj = js_func_obj(obj);
     jsoff_t existing = lkp(js, func_obj, key, key_len);
     if (existing > 0) {
       if (is_const_prop(js, existing)) {
@@ -24382,14 +12451,77 @@ void js_set(struct js *js, jsval_t obj, const char *key, jsval_t val) {
   }
 }
 
-bool js_del(struct js *js, jsval_t obj, const char *key) {
+void js_set_sym(ant_t *js, jsval_t obj, jsval_t sym, jsval_t val) {
+  if (vtype(sym) != T_SYMBOL) return;
+  jsoff_t sym_off = (jsoff_t)vdata(sym);
+  
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
+  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR) return;
+  
+  jsoff_t existing = lkp_sym(js, obj, sym_off);
+  if (existing > 0) {
+    if (is_const_prop(js, existing)) return;
+    saveval(js, existing + sizeof(jsoff_t) * 2, val);
+  } else mkprop(js, obj, sym, val, 0);
+}
+
+jsval_t js_get_sym(ant_t *js, jsval_t obj, jsval_t sym) {
+  if (vtype(sym) != T_SYMBOL) return js_mkundef();
+  jsoff_t sym_off = (jsoff_t)vdata(sym);
+  
+  jsval_t receiver = obj;
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
+  uint8_t ot = vtype(obj);
+  if (!is_object_type(obj)) {
+    if (ot == T_STR || ot == T_NUM || ot == T_BOOL || ot == T_BIGINT || ot == T_SYMBOL) {
+      jsval_t proto = get_prototype_for_type(js, ot);
+      if (!is_object_type(proto)) return js_mkundef();
+      obj = js_as_obj(proto);
+    } else {
+      return js_mkundef();
+    }
+  } else {
+    obj = js_as_obj(obj);
+  }
+  
+  if (is_proxy(js, obj)) return proxy_get_val(js, obj, sym);
+  
+  jsval_t cur = obj;
+  for (int i = 0; i < MAX_PROTO_CHAIN_DEPTH; i++) {
+    jsoff_t cur_off = (jsoff_t)vdata(cur);
+    descriptor_entry_t *sd = lookup_sym_descriptor(cur_off, sym_off);
+    if (sd && sd->has_getter) {
+      jsval_t g = sd->getter;
+      if (vtype(g) == T_FUNC || vtype(g) == T_CFUNC)
+        return sv_vm_call(js->vm, js, g, receiver, NULL, 0, NULL, false);
+      return js_mkundef();
+    }
+    jsval_t proto = get_proto(js, cur);
+    if (!is_object_type(proto)) break;
+    cur = js_as_obj(proto);
+  }
+  
+  jsoff_t off = lkp_sym_proto(js, obj, sym_off);
+  if (off == 0) return js_mkundef();
+  return resolveprop(js, mkval(T_PROP, off));
+}
+
+bool js_del(ant_t *js, jsval_t obj, const char *key) {
   size_t len = strlen(key);
   jsoff_t obj_off;
   
   if (vtype(obj) == T_OBJ) {
     obj_off = (jsoff_t)vdata(obj);
   } else if (vtype(obj) == T_ARR || vtype(obj) == T_FUNC) {
-    obj_off = (jsoff_t)vdata(obj);
+    obj_off = (jsoff_t)vdata(js_as_obj(obj));
+    if (vtype(obj) == T_ARR) {
+      unsigned long del_idx;
+      jsoff_t arr_len = get_array_length(js, obj);
+      if (parse_array_index(key, len, arr_len, &del_idx)) {
+        arr_del(js, obj, (jsoff_t)del_idx);
+        return true;
+      }
+    }
     obj = mkval(T_OBJ, obj_off);
   } else {
     return false;
@@ -24439,18 +12571,60 @@ bool js_del(struct js *js, jsval_t obj, const char *key) {
   return false;
 }
 
-static bool js_try_get(struct js *js, jsval_t obj, const char *key, jsval_t *out) {
+static bool js_try_get(ant_t *js, jsval_t obj, const char *key, jsval_t *out) {
   size_t key_len = strlen(key);
   
   if (vtype(obj) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(obj));
+    if (sv_vm_is_strict(js->vm) &&
+        ((key_len == 6 && memcmp(key, "caller", 6) == 0) ||
+         (key_len == 9 && memcmp(key, "arguments", 9) == 0))) {
+      *out = js_mkerr_typed(js, JS_ERR_TYPE,
+                            "'%.*s' not allowed on functions in strict mode",
+                            (int)key_len, key);
+      return true;
+    }
+
+    jsval_t func_obj = js_func_obj(obj);
+    if (key_len == 4 && memcmp(key, "meta", 4) == 0 && vtype(js->import_meta) != T_UNDEF) {
+      jsval_t cfunc = js_get_slot(js, func_obj, SLOT_CFUNC);
+      if (vtype(cfunc) == T_CFUNC && js_as_cfunc(cfunc) == builtin_import) {
+        *out = js->import_meta;
+        return true;
+      }
+    }
     jsoff_t off = lkp(js, func_obj, key, key_len);
-    if (off == 0) return false;
+    if (off == 0) {
+      jsval_t accessor_result;
+      if (try_accessor_getter(js, obj, key, key_len, &accessor_result)) {
+        *out = accessor_result;
+        return true;
+      }
+      return false;
+    }
+
+    descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(func_obj), key, key_len);
+    if (desc && desc->has_getter) {
+      jsval_t accessor_result;
+      if (try_accessor_getter(js, obj, key, key_len, &accessor_result)) {
+        *out = accessor_result;
+        return true;
+      }
+    }
+
     *out = resolveprop(js, mkval(T_PROP, off));
     return true;
   }
   
   if (vtype(obj) == T_ARR) {
+    if (((key_len == 6 && memcmp(key, "callee", 6) == 0) ||
+         (key_len == 6 && memcmp(key, "caller", 6) == 0)) &&
+        vtype(get_slot(js, obj, SLOT_STRICT_ARGS)) != T_UNDEF) {
+      *out = js_mkerr_typed(js, JS_ERR_TYPE,
+                            "'%.*s' not allowed on strict arguments",
+                            (int)key_len, key);
+      return true;
+    }
+
     if (key_len == 6 && memcmp(key, "length", 6) == 0) {
       *out = tov((double)get_array_length(js, obj));
       return true;
@@ -24464,7 +12638,7 @@ static bool js_try_get(struct js *js, jsval_t obj, const char *key, jsval_t *out
       } return false;
     }
     
-    jsval_t arr_obj = mkval(T_OBJ, vdata(obj));
+    jsval_t arr_obj = js_as_obj(obj);
     jsoff_t off = lkp(js, arr_obj, key, key_len);
     if (off == 0) {
       jsval_t accessor_result;
@@ -24491,7 +12665,7 @@ static bool js_try_get(struct js *js, jsval_t obj, const char *key, jsval_t *out
     *out = proxy_get(js, obj, key, key_len);
     return true;
   }
-  if (is_promise) obj = mkval(T_OBJ, vdata(obj));
+  if (is_promise) obj = js_as_obj(obj);
   else if (t != T_OBJ) return false;
   jsoff_t off = lkp(js, obj, key, key_len);
   
@@ -24516,7 +12690,7 @@ static bool js_try_get(struct js *js, jsval_t obj, const char *key, jsval_t *out
     return false;
   }
   
-  descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(obj), key, key_len);
+  descriptor_entry_t *desc = lookup_descriptor(js, (jsoff_t)vdata(js_as_obj(obj)), key, key_len);
   if (desc && desc->has_getter) {
     jsval_t accessor_result;
     if (try_accessor_getter(js, obj, key, key_len, &accessor_result)) {
@@ -24528,48 +12702,85 @@ static bool js_try_get(struct js *js, jsval_t obj, const char *key, jsval_t *out
   return true;
 }
 
-jsval_t js_get(struct js *js, jsval_t obj, const char *key) {
+jsval_t js_get(ant_t *js, jsval_t obj, const char *key) {
   jsval_t val;
   if (js_try_get(js, obj, key, &val)) return val;
   return js_mkundef();
 }
 
-jsval_t js_getprop_proto(struct js *js, jsval_t obj, const char *key) {
+jsval_t js_getprop_proto(ant_t *js, jsval_t obj, const char *key) {
   size_t key_len = strlen(key);
   jsoff_t off = lkp_proto(js, obj, key, key_len);
   return off == 0 ? js_mkundef() : resolveprop(js, mkval(T_PROP, off));
 }
 
-jsval_t js_getprop_fallback(struct js *js, jsval_t obj, const char *name) {
+jsval_t js_getprop_fallback(ant_t *js, jsval_t obj, const char *name) {
   jsval_t val;
   if (js_try_get(js, obj, name, &val)) return val;
   return js_getprop_proto(js, obj, name);
 }
 
+jsval_t js_getprop_super(ant_t *js, jsval_t super_obj, jsval_t receiver, const char *name) {
+  if (!name) return js_mkundef();
+
+  if (vtype(super_obj) == T_FUNC) super_obj = js_func_obj(super_obj);
+  if (!is_object_type(super_obj)) return js_mkundef();
+
+  size_t key_len = strlen(name);
+  if (is_proxy(js, super_obj)) return proxy_get(js, super_obj, name, key_len);
+
+  const char *key_intern = intern_string(name, key_len);
+  if (!key_intern) return js_mkundef();
+
+  jsval_t cur = js_as_obj(super_obj);
+  for (int i = 0; i < MAX_PROTO_CHAIN_DEPTH; i++) {
+    jsoff_t cur_off = (jsoff_t)vdata(cur);
+    descriptor_entry_t *desc = lookup_descriptor(js, cur_off, name, key_len);
+    if (desc) {
+      if (desc->has_getter) {
+        jsval_t getter = desc->getter;
+        if (vtype(getter) == T_FUNC || vtype(getter) == T_CFUNC)
+          return sv_vm_call(js->vm, js, getter, receiver, NULL, 0, NULL, false);
+        return js_mkundef();
+      }
+      if (desc->has_setter) return js_mkundef();
+    }
+
+    jsoff_t prop_off = lkp_interned(js, cur, key_intern, key_len);
+    if (prop_off != 0) return resolveprop(js, mkval(T_PROP, prop_off));
+
+    jsval_t proto = get_proto(js, cur);
+    if (!is_object_type(proto)) break;
+    cur = js_as_obj(proto);
+  }
+
+  return js_mkundef();
+}
+
 typedef struct {
-  bool (*callback)(struct js *js, jsval_t value, void *udata);
+  bool (*callback)(ant_t *js, jsval_t value, void *udata);
   void *udata;
 } js_iter_ctx_t;
 
-static iter_action_t js_iter_cb(struct js *js, jsval_t value, void *ctx, jsval_t *out) {
+static iter_action_t js_iter_cb(ant_t *js, jsval_t value, void *ctx, jsval_t *out) {
   js_iter_ctx_t *ictx = (js_iter_ctx_t *)ctx;
   return ictx->callback(js, value, ictx->udata) ? ITER_CONTINUE : ITER_BREAK;
 }
 
-bool js_iter(struct js *js, jsval_t iterable, bool (*callback)(struct js *js, jsval_t value, void *udata), void *udata) {
+bool js_iter(ant_t *js, jsval_t iterable, bool (*callback)(ant_t *js, jsval_t value, void *udata), void *udata) {
   js_iter_ctx_t ctx = { .callback = callback, .udata = udata };
   jsval_t result = iter_foreach(js, iterable, js_iter_cb, &ctx);
   return !is_err(result);
 }
 
-char *js_getstr(struct js *js, jsval_t value, size_t *len) {
+char *js_getstr(ant_t *js, jsval_t value, size_t *len) {
   if (vtype(value) != T_STR) return NULL;
   jsoff_t n, off = vstr(js, value, &n);
   if (len != NULL) *len = n;
   return (char *) &js->mem[off];
 }
 
-void js_merge_obj(struct js *js, jsval_t dst, jsval_t src) {
+void js_merge_obj(ant_t *js, jsval_t dst, jsval_t src) {
   if (vtype(dst) != T_OBJ || vtype(src) != T_OBJ) return;
   jsoff_t next = loadoff(js, (jsoff_t) vdata(src)) & ~(3U | FLAGMASK);
   while (next < js->brk && next != 0) {
@@ -24633,28 +12844,18 @@ static inline jsoff_t gc_weak_off_cb(void *cb_ctx, jsoff_t old) {
   return c->weak_off(c->ctx, old);
 }
 
-static void gc_roots_common(gc_off_op_t op_off, gc_val_op_t op_val, gc_cb_ctx_t *c) {
-  UTARRAY_EACH(global_scope_stack, jsoff_t, off) op_off(c, off);
-  UTARRAY_EACH(saved_scope_stack, jsval_t, val) op_val(c, val);
-
-  for (int i = 0; i < global_this_stack.depth; i++)
-    op_val(c, &global_this_stack.stack[i]);
-
-  UTARRAY_EACH(propref_stack, propref_data_t, pref) {
-    op_off(c, &pref->obj_off);
-    op_off(c, &pref->key_off);
-  }
-
-  UTARRAY_EACH(prim_propref_stack, prim_propref_data_t, ppref) {
-    op_val(c, &ppref->prim_val);
-    op_off(c, &ppref->key_off);
+void js_gc_visit_frame_funcs(ant_t *js, void (*visitor)(void *, sv_func_t *), void *ctx) {
+  sv_vm_visit_frame_funcs(js->vm, visitor, ctx);
+  for (coroutine_t *coro = pending_coroutines.head; coro; coro = coro->next) {
+    if (coro->sv_vm) sv_vm_visit_frame_funcs(coro->sv_vm, visitor, ctx);
   }
+}
 
+static void gc_roots_common(gc_off_op_t op_off, gc_val_op_t op_val, gc_cb_ctx_t *c) {
   if (rt && rt->js == c->js)
     op_val(c, &rt->ant_obj);
 
   for (coroutine_t *coro = pending_coroutines.head; coro; coro = coro->next) {
-    op_val(c, &coro->scope);
     op_val(c, &coro->this_val);
     op_val(c, &coro->super_val);
     op_val(c, &coro->new_target);
@@ -24662,30 +12863,11 @@ static void gc_roots_common(gc_off_op_t op_off, gc_val_op_t op_val, gc_cb_ctx_t
     op_val(c, &coro->result);
     op_val(c, &coro->async_func);
     op_val(c, &coro->yield_value);
-
-    for (int i = 0; i < coro->for_let_stack_len; i++) {
-      op_val(c, &coro->for_let_stack[i].body_scope);
-      op_off(c, &coro->for_let_stack[i].prop_off);
-    }
-
-    if (coro->scope_stack) {
-      UTARRAY_EACH(coro->scope_stack, jsoff_t, off) op_off(c, off);
-    }
-
-    async_exec_context_t *actx;
-    if (coro->mco && (actx = mco_get_user_data(coro->mco))) {
-      op_val(c, &actx->closure_scope);
-      op_val(c, &actx->result);
-      op_val(c, &actx->promise);
-    }
-  }
-
-  esm_module_t *mod, *mod_tmp;
-  HASH_ITER(hh, global_module_cache.modules, mod, mod_tmp) {
-    op_val(c, &mod->namespace_obj);
-    op_val(c, &mod->default_export);
+    op_val(c, &coro->async_promise);
   }
 
+  js_esm_gc_roots(op_val, c);
+  op_val(c, &c->js->import_meta);
   timer_gc_update_roots(op_val, c);
   ffi_gc_update_roots(op_val, c);
   fetch_gc_update_roots(op_val, c);
@@ -24697,30 +12879,21 @@ static void gc_roots_common(gc_off_op_t op_off, gc_val_op_t op_val, gc_cb_ctx_t
   server_gc_update_roots(op_val, c);
   events_gc_update_roots(op_val, c);
   lmdb_gc_update_roots(op_val, c);
+  symbol_gc_update_roots(op_val, c);
 
-  for (int i = 0; i < c->js->for_let_stack_len; i++) {
-    op_val(c, &c->js->for_let_stack[i].body_scope);
-    op_off(c, &c->js->for_let_stack[i].prop_off);
-  }
-  
+  op_val(c, &c->js->global);
   op_val(c, &c->js->object);
-  op_val(c, &c->js->tval);
-  op_val(c, &c->js->scope);
   op_val(c, &c->js->this_val);
-  op_val(c, &c->js->super_val);
   op_val(c, &c->js->new_target);
   op_val(c, &c->js->module_ns);
   op_val(c, &c->js->current_func);
   op_val(c, &c->js->thrown_value);
   op_val(c, &c->js->length_str);
 
-  for (jshdl_t i = 0; i < c->js->gc_roots_len; i++) op_val(c, &c->js->gc_roots[i]);
-  if (c->js->ascii_cache_init) for (int i = 0; i < 128; i++) op_val(c, &c->js->ascii_char_cache[i]);
+  sv_vm_gc_roots(c->js->vm, op_val, c);
+  sv_vm_gc_roots_pending(op_val, c);
 
-  if (c->js->tc.pending) {
-    op_val(c, &c->js->tc.func); op_val(c, &c->js->tc.closure_scope);
-    for (int i = 0; i < c->js->tc.argc; i++) op_val(c, &c->js->tc.args[i]);
-  }
+  for (jshdl_t i = 0; i < c->js->gc_roots_len; i++) op_val(c, &c->js->gc_roots[i]);
 }
 
 void js_gc_reserve_roots(GC_RESERVE_ARGS) {
@@ -24852,13 +13025,20 @@ void js_gc_update_roots(GC_UPDATE_ARGS) {
       if (new_off == (jsoff_t)~0) { free(desc); continue; }
       if (desc->has_getter) FWD_VAL(desc->getter);
       if (desc->has_setter) FWD_VAL(desc->setter);
-      desc->key = ((uint64_t)new_off << 32) | (uint32_t)(desc->key & 0xFFFFFFFF);
+      if (desc->prop_name) {
+        desc->key = ((uint64_t)new_off << 32) | (uint32_t)(desc->key & 0xFFFFFFFF);
+      } else {
+        jsoff_t new_sym = fwd_off(ctx, desc->sym_off);
+        desc->sym_off = new_sym;
+        desc->key = make_sym_desc_key(new_off, new_sym);
+      }
       desc->obj_off = new_off;
       HASH_ADD(hh, new_desc_registry, key, sizeof(uint64_t), desc);
     }
 
   intern_prop_cache_gen++;
   collections_gc_update_roots(gc_weak_off_cb, gc_update_val_cb, &cb_ctx);
+  regex_gc_update_roots(gc_weak_off_cb, gc_update_val_cb, &cb_ctx);
   
   #undef FWD_OFF
   #undef FWD_VAL
@@ -24878,288 +13058,107 @@ bool js_chkargs(jsval_t *args, int nargs, const char *spec) {
   return ok;
 }
 
-static jsval_t js_eval_inherit_strict(struct js *js, const char *buf, size_t len, bool inherit_strict) {
-  jsval_t res = js_mkundef();
-  if (len == (size_t) ~0U) len = strlen(buf);
-  js->eval_depth++;
-  js->consumed = 1;
-  js->tok = TOK_ERR;
-  js->code = buf;
-  js->clen = (jsoff_t) len;
-  js->pos = 0;
-  
-  if (js->token_stream && js->code == js->token_stream_code) {
-    js->token_stream_pos = 0;
-  }
-  
-  uint8_t saved_tok = js->tok;
-  jsoff_t saved_pos = js->pos;
-  uint8_t saved_consumed = js->consumed;
-  int saved_stream_pos = js->token_stream_pos;
-  js->consumed = 1;
-  
-  bool is_strict = inherit_strict;
-  if (inherit_strict) js->flags |= F_STRICT;
-  
-  if (next(js) == TOK_STRING) {
-    const char *str = &js->code[js->toff + 1];
-    size_t str_len = js->tlen - 2;
-    if (str_len == 10 && memcmp(str, "use strict", 10) == 0) {
-      js->flags |= F_STRICT;
-      is_strict = true;
-    }
-  }
-  
-  js->tok = saved_tok;
-  js->pos = saved_pos;
-  js->consumed = saved_consumed;
-  js->token_stream_pos = saved_stream_pos;
-  
-  if (is_strict) {
-    mkscope(js);
-    set_slot(js, js->scope, SLOT_STRICT_EVAL_SCOPE, tov(1));
+static jsval_t js_eval_bytecode_mode(ant_t *js, const char *buf, size_t len, sv_compile_mode_t mode, bool parse_strict) {
+  if (len == (size_t)~0U) len = strlen(buf);
+  sv_ast_t *program = sv_parse(js, buf, (jsoff_t)len, parse_strict);
+
+  if (!program) {
+    if (js->thrown_exists) return mkval(T_ERR, 0);
+    return js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "Unexpected parse error");
   }
-  
-  hoist_function_declarations(js);
-  if (!(js->flags & F_CALL)) hoist_var_declarations(js, js->scope);
 
-  while (next(js) != TOK_EOF && !is_err(res)) {
-    res = js_stmt(js);
-    if (js->needs_gc && js->eval_depth == 1) js_gc_safepoint(js);
-    if (js->flags & F_RETURN) break;
+  sv_func_t *func = sv_compile(js, program, mode, buf, (jsoff_t)len);
+  if (!func) {
+    if (js->thrown_exists) return mkval(T_ERR, 0);
+    return js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "Unexpected compile error");
   }
   
-  if (is_strict) delscope(js);
-  js->eval_depth--;
-  return res;
+  js_clear_error_site(js);   
+  jsval_t result;
+
+  if (sv_dump_bytecode_unlikely) sv_disasm(js, func, js->filename);
+  if (func->is_tla) result = sv_execute_entry_tla(js, func, js->this_val);
+  else result = sv_execute_entry(js->vm, func, js->this_val, NULL, 0);
+
+  return result;
 }
 
-inline jsval_t js_eval(struct js *js, const char *buf, size_t len) {
-  return js_eval_inherit_strict(js, buf, len, false);
+jsval_t js_eval_bytecode(ant_t *js, const char *buf, size_t len) {
+  return js_eval_bytecode_mode(js, buf, len, SV_COMPILE_SCRIPT, false);
 }
 
-jsval_t js_eval_cached(struct js *js, const char *buf, size_t len) {
-  if (len == (size_t)~0U) len = strlen(buf);
-  
-  void *saved_stream = js->token_stream;
-  int saved_pos = js->token_stream_pos;
-  const char *saved_code = js->token_stream_code;
-  
-  token_stream_t *ts = tokenize_body(js, buf, (jsoff_t)len);
-  if (ts) {
-    js->token_stream = ts;
-    js->token_stream_pos = 0;
-    js->token_stream_code = buf;
-  }
-  
-  jsval_t result = js_eval_inherit_strict(js, buf, len, false);
-  if (ts) { free(ts->tokens); free(ts); }
-  
-  js->token_stream = saved_stream;
-  js->token_stream_pos = saved_pos;
-  js->token_stream_code = saved_code;
-  
-  return result;
+jsval_t js_eval_bytecode_module(ant_t *js, const char *buf, size_t len) {
+  return js_eval_bytecode_mode(js, buf, len, SV_COMPILE_MODULE, false);
+}
+
+jsval_t js_eval_bytecode_eval(ant_t *js, const char *buf, size_t len) {
+  return js_eval_bytecode_mode(js, buf, len, SV_COMPILE_EVAL, false);
+}
+
+jsval_t js_eval_bytecode_eval_with_strict(ant_t *js, const char *buf, size_t len, bool inherit_strict) {
+  return js_eval_bytecode_mode(js, buf, len, SV_COMPILE_EVAL, inherit_strict);
+}
+
+jsval_t js_eval_bytecode_repl(ant_t *js, const char *buf, size_t len) {
+  return js_eval_bytecode_mode(js, buf, len, SV_COMPILE_REPL, false);
 }
 
-static jsval_t js_call_internal(struct js *js, jsval_t func, jsval_t bound_this, jsval_t *args, int nargs, bool use_bound_this) {
-  if (vtype(func) == T_FFI) {
+jsval_t sv_call_native(
+  ant_t *js, jsval_t func, jsval_t this_val,
+  jsval_t *args, int nargs
+) {
+  if (vtype(func) == T_FFI)
     return ffi_call_by_index(js, (unsigned int)vdata(func), args, nargs);
-  } else if (vtype(func) == T_CFUNC) {
+
+  if (vtype(func) == T_CFUNC) {
     jsval_t saved_this = js->this_val;
-    if (use_bound_this) js->this_val = bound_this;
-    jsval_t (*fn)(struct js *, jsval_t *, int) = (jsval_t(*)(struct js *, jsval_t *, int)) vdata(func);
+    js->this_val = this_val;
+    jsval_t (*fn)(ant_t *, jsval_t *, int) = (jsval_t(*)(ant_t *, jsval_t *, int))vdata(func);
     jsval_t res = fn(js, args, nargs);
-    js->this_val = saved_this; return res;
-  } else if (vtype(func) == T_FUNC) {
-    jsval_t func_obj = mkval(T_OBJ, vdata(func));
+    js->this_val = saved_this;
+    return res;
+  }
+
+  if (vtype(func) == T_FUNC) {
+    jsval_t func_obj = js_func_obj(func);
+
     jsval_t cfunc_slot = get_slot(js, func_obj, SLOT_CFUNC);
-    
     if (vtype(cfunc_slot) == T_CFUNC) {
       jsval_t slot_bound_this = get_slot(js, func_obj, SLOT_BOUND_THIS);
-      bool has_slot_bound_this = vtype(slot_bound_this) != T_UNDEF;
-      
       int final_nargs;
-      jsval_t *combined_args = resolve_bound_args(js, func_obj, args, nargs, &final_nargs);
-      jsval_t *final_args = combined_args ? combined_args : args;
-      
+      jsval_t *combined = resolve_bound_args(js, func_obj, args, nargs, &final_nargs);
+      jsval_t *final_args = combined ? combined : args;
       jsval_t saved_func = js->current_func;
       jsval_t saved_this = js->this_val;
       js->current_func = func;
-      
-      if (has_slot_bound_this) {
-        js->this_val = slot_bound_this;
-      } else if (use_bound_this) js->this_val = bound_this;
-      
-      jsval_t (*fn)(struct js *, jsval_t *, int) = (jsval_t(*)(struct js *, jsval_t *, int)) vdata(cfunc_slot);
+      js->this_val = (vtype(slot_bound_this) != T_UNDEF) ? slot_bound_this : this_val;
+      jsval_t (*fn)(ant_t *, jsval_t *, int) = (jsval_t(*)(ant_t *, jsval_t *, int))vdata(cfunc_slot);
       jsval_t res = fn(js, final_args, final_nargs);
       js->current_func = saved_func;
       js->this_val = saved_this;
-      
-      if (combined_args) free(combined_args);
+      if (combined) free(combined);
       return res;
     }
-    
+
     jsval_t builtin_slot = get_slot(js, func_obj, SLOT_BUILTIN);
     if (vtype(builtin_slot) == T_NUM && (int)tod(builtin_slot) == BUILTIN_OBJECT) {
       jsval_t saved_this = js->this_val;
-      if (use_bound_this) js->this_val = bound_this;
+      js->this_val = this_val;
       jsval_t res = builtin_Object(js, args, nargs);
       js->this_val = saved_this;
       return res;
     }
-    
-    jsoff_t fnlen;
-    const char *fn = get_func_code(js, func_obj, &fnlen);
-    if (!fn) return js_mkerr(js, "function has no code");
-    
-    jsval_t slot_bound_this = get_slot(js, func_obj, SLOT_BOUND_THIS);
-    bool has_slot_bound_this = vtype(slot_bound_this) != T_UNDEF;
-    
-    int final_nargs;
-    jsval_t *combined_args = resolve_bound_args(js, func_obj, args, nargs, &final_nargs);
-    jsval_t *final_args = combined_args ? combined_args : args;
-    
-    jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
-    bool is_async = vtype(async_slot) == T_BOOL && vdata(async_slot) == 1;
-    
-    if (is_async) {
-      jsval_t closure_scope = get_slot(js, func_obj, SLOT_SCOPE);
-      jsval_t res = start_async_in_coroutine(js, fn, fnlen, closure_scope, final_args, final_nargs);
-      if (combined_args) free(combined_args);
-      return res;
-    }
-    
-    jsval_t saved_scope = js->scope;
-    jsval_t closure_scope = get_slot(js, func_obj, SLOT_SCOPE);
-    if (vtype(closure_scope) == T_OBJ) js->scope = closure_scope;
-    
-    uint8_t saved_flags = js->flags;
-    js->flags = 0;
-    mkscope(js);
-    js->flags = saved_flags;
-    
-    if (global_scope_stack == NULL) utarray_new(global_scope_stack, &jsoff_icd);
-    jsoff_t function_scope_offset = (jsoff_t) vdata(js->scope);
-    
-    utarray_push_back(global_scope_stack, &function_scope_offset);
-    hoist_var_declarations_from_slot(js, js->scope, func_obj);
-    
-    parsed_func_t *pf = get_or_parse_func(js, fn, fnlen);
-    if (!pf) {
-      if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-      delscope(js); js->scope = saved_scope;
-      if (combined_args) free(combined_args);
-      return js_mkerr(js, "failed to parse function");
-    }
-    
-    int arg_idx = 0;
-    for (unsigned int i = 0; i < (unsigned int)pf->param_count; i++) {
-      parsed_param_t *pp = (parsed_param_t *)utarray_eltptr(pf->params, i);
-      
-      if (pp->is_destruct) {
-        jsval_t arg_val = (arg_idx < final_nargs) ? final_args[arg_idx++] : js_mkundef();
-        if (vtype(arg_val) == T_UNDEF && pp->default_len > 0) {
-          arg_val = js_eval_str(js, &fn[pp->default_start], pp->default_len);
-        }
-        bind_destruct_pattern(js, &fn[pp->pattern_off], pp->pattern_len, arg_val, js->scope);
-      } else {
-        jsval_t v = arg_idx < final_nargs ? final_args[arg_idx++] : js_mkundef();
-        if (vtype(v) == T_UNDEF && pp->default_len > 0) {
-          v = js_eval_str(js, &fn[pp->default_start], pp->default_len);
-        }
-        js_setprop(js, js->scope, js_mkstr(js, &fn[pp->name_off], pp->name_len), v);
-      }
-    }
-    
-    if (pf->has_rest && pf->rest_param_len > 0) {
-      jsval_t rest_array = mkarr(js);
-      if (!is_err(rest_array)) {
-        jsoff_t idx = 0;
-        while (arg_idx < final_nargs) {
-          char idxstr[16];
-          size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)idx);
-          jsval_t key = js_mkstr(js, idxstr, idxlen);
-          js_setprop(js, rest_array, key, final_args[arg_idx]);
-          idx++;
-          arg_idx++;
-        }
-        js_setprop(js, rest_array, js->length_str, tov((double) idx));
-        rest_array = mkval(T_ARR, vdata(rest_array));
-        js_setprop(js, js->scope, js_mkstr(js, &fn[pf->rest_param_start], pf->rest_param_len), rest_array);
-      }
-    }
-    
-    if (pf->uses_arguments) {
-      setup_arguments(js, js->scope, final_args, final_nargs, pf->is_strict);
-    }
-    
-    jsval_t saved_this = js->this_val;
-    if (has_slot_bound_this) {
-      js->this_val = slot_bound_this;
-    } else if (use_bound_this) {
-      js->this_val = bound_this;
-    } else js->this_val = js_glob(js);
-    
-    js_parse_state_t saved_state;
-    JS_SAVE_STATE(js, saved_state);
-    uint8_t caller_flags = js->flags;
-    
-    js->flags = F_CALL | (pf->is_strict ? F_STRICT : 0);
-    jsval_t res;
-    
-    void *saved_token_stream = js->token_stream;
-    int saved_token_stream_pos = js->token_stream_pos;
-    const char *saved_token_stream_code = js->token_stream_code;
-    
-    if (pf->tokens) {
-      js->token_stream = pf->tokens;
-      js->token_stream_pos = 0;
-      js->token_stream_code = &fn[pf->body_start];
-    } else {
-      js->token_stream = NULL;
-      js->token_stream_code = NULL;
-    }
-    
-    if (pf->is_expr) {
-      res = js_eval_str(js, &fn[pf->body_start], pf->body_len);
-      res = resolveprop(js, res);
-    } else {
-      res = js_eval(js, &fn[pf->body_start], pf->body_len);
-      if (!is_err(res) && !(js->flags & F_RETURN)) res = js_mkundef();
-    }
-    
-    js->token_stream = saved_token_stream;
-    js->token_stream_pos = saved_token_stream_pos;
-    js->token_stream_code = saved_token_stream_code;
-    
-    JS_RESTORE_STATE(js, saved_state);
-    js->flags = caller_flags;
-    
-    js->this_val = saved_this;
-    if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
-    delscope(js); js->scope = saved_scope;
-    if (combined_args) free(combined_args);
-    return res;
   }
-  
-  return js_mkerr(js, "not a function");
-}
-
-jsval_t js_call(struct js *js, jsval_t func, jsval_t *args, int nargs) {
-  return js_call_internal(js, func, js_mkundef(), args, nargs, false);
-}
 
-jsval_t js_call_with_this(struct js *js, jsval_t func, jsval_t bound_this, jsval_t *args, int nargs) {
-  return js_call_internal(js, func, bound_this, args, nargs, true);
+  return js_mkerr_typed(js, JS_ERR_TYPE, "%s is not a function", typestr(vtype(func)));
 }
 
-ant_iter_t js_prop_iter_begin(struct js *js, jsval_t obj) {
+ant_iter_t js_prop_iter_begin(ant_t *js, jsval_t obj) {
   ant_iter_t iter = {.ctx = js, .off = 0};
   
   uint8_t t = vtype(obj);
   if (t == T_OBJ || t == T_ARR || t == T_FUNC) {
-    iter.off = (jsoff_t)vdata(obj);
+    iter.off = (jsoff_t)vdata(js_as_obj(obj));
   }
   
   return iter;
@@ -25173,7 +13172,7 @@ bool js_prop_iter_next(ant_iter_t *iter, const char **key, size_t *key_len, jsva
   
   while (next < js->brk && next != 0) {
     jsoff_t header = loadoff(js, next);
-    if (!is_slot_prop(header)) break;
+    if (!is_slot_prop(header) && !is_sym_key_prop(js, next)) break;
     next = next_prop(header);
   }
   
@@ -25197,11 +13196,11 @@ void js_prop_iter_end(ant_iter_t *iter) {
   if (iter) { iter->off = 0; iter->ctx = NULL; }
 }
 
-jsval_t js_mkpromise(struct js *js) { return mkpromise(js); }
-void js_resolve_promise(struct js *js, jsval_t promise, jsval_t value) { resolve_promise(js, promise, value); }
-void js_reject_promise(struct js *js, jsval_t promise, jsval_t value) { reject_promise(js, promise, value); }
+jsval_t js_mkpromise(ant_t *js) { return mkpromise(js); }
+void js_resolve_promise(ant_t *js, jsval_t promise, jsval_t value) { resolve_promise(js, promise, value); }
+void js_reject_promise(ant_t *js, jsval_t promise, jsval_t value) { reject_promise(js, promise, value); }
 
-void js_check_unhandled_rejections(struct js *js) {
+void js_check_unhandled_rejections(ant_t *js) {
   promise_data_entry_t *pd, *tmp;
   
   HASH_ITER(hh_unhandled, unhandled_rejections, pd, tmp) {
@@ -25218,14 +13217,13 @@ void js_check_unhandled_rejections(struct js *js) {
     }
     
     if (js->fatal_error) {
-      fprintf(stderr, "%s\n", js->errmsg ? js->errmsg : js_str(js, pd->value));
+      js->thrown_exists = true;
+      js->thrown_value = pd->value;
+      print_uncaught_throw(js);
       js_destroy(js); exit(1);
     }
     
-    char buf[1024];
-    buf[tostr(js, pd->value, buf, sizeof(buf) - 1)] = '\0';
-    fprintf(stderr, "Uncaught (in promise) %s\n", buf);
-    
+    print_unhandled_promise_rejection(js, pd->value);
     pd->has_rejection_handler = true;
     HASH_DELETE(hh_unhandled, unhandled_rejections, pd);
   }
@@ -25233,11 +13231,11 @@ void js_check_unhandled_rejections(struct js *js) {
 
 bool js_is_slot_prop(jsoff_t header) { return is_slot_prop(header); }
 jsoff_t js_next_prop(jsoff_t header) { return next_prop(header); }
-jsoff_t js_loadoff(struct js *js, jsoff_t off) { return loadoff(js, off); }
+jsoff_t js_loadoff(ant_t *js, jsoff_t off) { return loadoff(js, off); }
 
-void js_set_getter(struct js *js, jsval_t obj, js_getter_fn getter) {
+void js_set_getter(ant_t *js, jsval_t obj, js_getter_fn getter) {
   if (!is_object_type(obj)) return;
-  if (vtype(obj) != T_OBJ) obj = mkval(T_OBJ, vdata(obj));
+  if (vtype(obj) != T_OBJ) obj = js_as_obj(obj);
   jsoff_t obj_off = (jsoff_t)vdata(obj);
   dynamic_accessors_t *entry = NULL;
   HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
@@ -25252,9 +13250,9 @@ void js_set_getter(struct js *js, jsval_t obj, js_getter_fn getter) {
   entry->getter = getter;
 }
 
-void js_set_setter(struct js *js, jsval_t obj, js_setter_fn setter) {
+void js_set_setter(ant_t *js, jsval_t obj, js_setter_fn setter) {
   if (!is_object_type(obj)) return;
-  if (vtype(obj) != T_OBJ) obj = mkval(T_OBJ, vdata(obj));
+  if (vtype(obj) != T_OBJ) obj = js_as_obj(obj);
   jsoff_t obj_off = (jsoff_t)vdata(obj);
   dynamic_accessors_t *entry = NULL;
   HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
@@ -25269,9 +13267,9 @@ void js_set_setter(struct js *js, jsval_t obj, js_setter_fn setter) {
   entry->setter = setter;
 }
 
-void js_set_deleter(struct js *js, jsval_t obj, js_deleter_fn deleter) {
+void js_set_deleter(ant_t *js, jsval_t obj, js_deleter_fn deleter) {
   if (!is_object_type(obj)) return;
-  if (vtype(obj) != T_OBJ) obj = mkval(T_OBJ, vdata(obj));
+  if (vtype(obj) != T_OBJ) obj = js_as_obj(obj);
   jsoff_t obj_off = (jsoff_t)vdata(obj);
   dynamic_accessors_t *entry = NULL;
   HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
@@ -25286,9 +13284,9 @@ void js_set_deleter(struct js *js, jsval_t obj, js_deleter_fn deleter) {
   entry->deleter = deleter;
 }
 
-void js_set_keys(struct js *js, jsval_t obj, js_keys_fn keys) {
+void js_set_keys(ant_t *js, jsval_t obj, js_keys_fn keys) {
   if (!is_object_type(obj)) return;
-  if (vtype(obj) != T_OBJ) obj = mkval(T_OBJ, vdata(obj));
+  if (vtype(obj) != T_OBJ) obj = js_as_obj(obj);
   jsoff_t obj_off = (jsoff_t)vdata(obj);
   dynamic_accessors_t *entry = NULL;
   HASH_FIND(hh, accessor_registry, &obj_off, sizeof(jsoff_t), entry);
@@ -25302,96 +13300,3 @@ void js_set_keys(struct js *js, jsval_t obj, js_keys_fn keys) {
   }
   entry->keys = keys;
 }
-
-static inline uint64_t make_desc_key(jsoff_t obj_off, const char *key, size_t klen) {
-  uint32_t key_hash = (uint32_t)hash_key(key, klen);
-  return ((uint64_t)obj_off << 32) | key_hash;
-}
-
-static descriptor_entry_t arr_length_desc = {
-  .key = 0, .obj_off = 0,
-  .prop_name = "length", .prop_len = 6,
-  .writable = true, .enumerable = false, .configurable = false,
-  .has_getter = false, .has_setter = false,
-  .getter = 0, .setter = 0,
-};
-
-static descriptor_entry_t *lookup_descriptor(struct js *js, jsoff_t obj_off, const char *key, size_t klen) {
-  if (klen == 6 
-    && memcmp(key, "length", 6) == 0 
-    && is_arr_off(js, obj_off)
-  ) return &arr_length_desc;
-  
-  descriptor_entry_t *entry = NULL;
-  uint64_t desc_key = make_desc_key(obj_off, key, klen);
-  HASH_FIND(hh, desc_registry, &desc_key, sizeof(uint64_t), entry);
-  
-  return entry;
-}
-
-static descriptor_entry_t *get_or_create_desc(struct js *js, jsval_t obj, const char *key, size_t klen) {
-  if (vtype(obj) != T_OBJ && vtype(obj) != T_FUNC && vtype(obj) != T_ARR) return NULL;
-  jsoff_t obj_off = (jsoff_t)vdata(obj);
-  uint64_t desc_key = make_desc_key(obj_off, key, klen);
-  
-  descriptor_entry_t *entry = NULL;
-  HASH_FIND(hh, desc_registry, &desc_key, sizeof(uint64_t), entry);
-  if (!entry) {
-    entry = (descriptor_entry_t *)ant_calloc(sizeof(descriptor_entry_t) + klen + 1);
-    if (!entry) return NULL;
-    
-    entry->key = desc_key;
-    entry->obj_off = obj_off;
-    entry->prop_name = (char *)(entry + 1);
-    memcpy(entry->prop_name, key, klen);
-    entry->prop_name[klen] = '\0';
-    entry->prop_len = klen;
-    entry->writable = true;
-    entry->enumerable = true;
-    entry->configurable = true;
-    entry->has_getter = false;
-    entry->has_setter = false;
-    entry->getter = js_mkundef();
-    entry->setter = js_mkundef();
-    
-    HASH_ADD(hh, desc_registry, key, sizeof(uint64_t), entry);
-  }
-  return entry;
-}
-
-void js_set_descriptor(struct js *js, jsval_t obj, const char *key, size_t klen, int flags) {
-  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
-  if (!entry) return;
-  entry->writable = (flags & JS_DESC_W) != 0;
-  entry->enumerable = (flags & JS_DESC_E) != 0;
-  entry->configurable = (flags & JS_DESC_C) != 0;
-}
-
-void js_set_getter_desc(struct js *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, int flags) {
-  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
-  if (!entry) return;
-  entry->enumerable = (flags & JS_DESC_E) != 0;
-  entry->configurable = (flags & JS_DESC_C) != 0;
-  entry->has_getter = true;
-  entry->getter = getter;
-}
-
-void js_set_setter_desc(struct js *js, jsval_t obj, const char *key, size_t klen, jsval_t setter, int flags) {
-  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
-  if (!entry) return;
-  entry->enumerable = (flags & JS_DESC_E) != 0;
-  entry->configurable = (flags & JS_DESC_C) != 0;
-  entry->has_setter = true;
-  entry->setter = setter;
-}
-
-void js_set_accessor_desc(struct js *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, jsval_t setter, int flags) {
-  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
-  if (!entry) return;
-  entry->enumerable = (flags & JS_DESC_E) != 0;
-  entry->configurable = (flags & JS_DESC_C) != 0;
-  entry->has_getter = true;
-  entry->has_setter = true;
-  entry->getter = getter;
-  entry->setter = setter;
-}
diff --git a/src/cli/pkg.c b/src/cli/pkg.c
index 4433bcb..c971b38 100644
--- a/src/cli/pkg.c
+++ b/src/cli/pkg.c
@@ -18,8 +18,12 @@
 #include "progress.h"
 #include "modules/io.h"
 
+// migrate this file to crprintf for colors
+
 bool pkg_verbose = false;
 
+static void print_bin_callback(const char *name, void *user_data);
+
 static void progress_callback(void *user_data, pkg_phase_t phase, uint32_t current, uint32_t total, const char *message) {
   progress_t *progress = (progress_t *)user_data;
   if (!progress || !message || !message[0]) return;
@@ -43,23 +47,33 @@ static void progress_callback(void *user_data, pkg_phase_t phase, uint32_t curre
   progress_update(progress, msg);
 }
 
+static void print_latest_available_hint(pkg_context_t *ctx, const char *pkg_name, const char *installed_version) {
+  if (!ctx || !pkg_name || !installed_version || !pkg_name[0] || !installed_version[0]) return;
+
+  char latest[64];
+  if (pkg_get_latest_available_version(ctx, pkg_name, installed_version, latest, sizeof(latest)) <= 0) return;
+  printf(" %s(v%s available)%s", C_BLUE, latest, C_RESET);
+}
+
 static void print_added_packages(pkg_context_t *ctx) {
   uint32_t count = pkg_get_added_count(ctx);
   uint32_t printed = 0;
-  if (count > 0) printf("\n");
+  if (count > 0) fputc('\n', stdout);
   
   for (uint32_t i = 0; i < count; i++) {
     pkg_added_package_t pkg;
     if (pkg_get_added_package(ctx, i, &pkg) == PKG_OK && pkg.direct) {
-      printf("%s+%s %s%s%s@%s%s%s\n", 
+      printf("%s+%s %s%s%s@%s%s%s", 
         C_GREEN, C_RESET,
         C_BOLD, pkg.name, C_RESET,
         C_DIM, pkg.version, C_RESET
-      ); printed++;
+      );
+      print_latest_available_hint(ctx, pkg.name, pkg.version);
+      fputc('\n', stdout); printed++;
     }
   }
   
-  if (printed > 0) printf("\n");
+  if (printed > 0) fputc('\n', stdout);
 }
 
 static uint64_t timespec_diff_ms(struct timespec *start, struct timespec *end) {
@@ -108,6 +122,56 @@ static void prompt_with_default(const char *prompt, const char *def, char *buf,
   }
 }
 
+static void print_direct_installed_packages(pkg_context_t *ctx) {
+  if (!ctx) return;
+
+  fputc('\n', stdout);
+
+  uint32_t added_count = pkg_get_added_count(ctx);
+  for (uint32_t i = 0; i < added_count; i++) {
+    pkg_added_package_t pkg;
+    if (pkg_get_added_package(ctx, i, &pkg) != PKG_OK || !pkg.direct) continue;
+
+    int bin_count = pkg_list_package_bins("node_modules", pkg.name, NULL, NULL);
+    printf("%sinstalled%s %s%s@%s%s",
+      C_GREEN, C_RESET,
+      C_BOLD, pkg.name, pkg.version, C_RESET);
+    print_latest_available_hint(ctx, pkg.name, pkg.version);
+    if (bin_count > 0) {
+      printf(" with binaries:\n");
+      pkg_list_package_bins("node_modules", pkg.name, print_bin_callback, NULL);
+    } else fputc('\n', stdout);
+  }
+}
+
+static void print_add_summary(pkg_context_t *ctx, const pkg_install_result_t *result, bool include_done_suffix) {
+  if (!ctx || !result) return;
+
+  if (result->packages_installed > 0) {
+    print_direct_installed_packages(ctx);
+
+    printf("\n%s%u%s package%s installed %s[%s",
+      C_GREEN, result->packages_installed, C_RESET,
+      result->packages_installed == 1 ? "" : "s",
+      C_DIM, C_RESET);
+    print_elapsed(result->elapsed_ms);
+    printf("%s]%s", C_DIM, C_RESET);
+    if (include_done_suffix) printf(" done");
+    
+    fputc('\n', stdout);
+    return;
+  }
+
+  printf("\n%sChecked%s %s%u%s installs across %s%u%s packages %s(no changes)%s %s[%s",
+    C_DIM, C_RESET,
+    C_GREEN, result->packages_installed + result->packages_skipped, C_RESET,
+    C_GREEN, result->package_count, C_RESET,
+    C_DIM, C_RESET,
+    C_DIM, C_RESET);
+  print_elapsed(result->elapsed_ms);
+  printf("%s]%s\n", C_DIM, C_RESET);
+}
+
 typedef struct {
   const char *target;
   int count;
@@ -157,6 +221,103 @@ static void print_bin_name(const char *name, void *ud) {
   printf("  %s\n", name);
 }
 
+static void print_pkg_error(pkg_context_t *ctx) {
+  const char *msg = pkg_error_string(ctx);
+  if (!msg || !msg[0]) {
+    fprintf(stderr, "Error: unknown error\n");
+    return;
+  }
+  if (strncmp(msg, "error:", 6) == 0) {
+    fprintf(stderr, "%s\n", msg);
+  } else fprintf(stderr, "Error: %s\n", msg);
+}
+
+static size_t package_name_from_spec(const char *spec, char *out, size_t out_size) {
+  if (!spec || !out || out_size == 0) return 0;
+
+  const char *split = NULL;
+  if (spec[0] == '@') {
+    split = strchr(spec + 1, '@');
+  } else split = strchr(spec, '@');
+
+  size_t len = split ? (size_t)(split - spec) : strlen(spec);
+  if (len == 0 || len >= out_size) return 0;
+
+  memcpy(out, spec, len);
+  out[len] = '\0';
+  return len;
+}
+
+static bool pkg_json_has_dep(yyjson_val *root, const char *section, const char *name) {
+  yyjson_val *deps = yyjson_obj_get(root, section);
+  if (!deps || !yyjson_is_obj(deps)) return false;
+  return yyjson_obj_get(deps, name) != NULL;
+}
+
+static int classify_update_specs(
+  const char *const *package_specs,
+  int count,
+  const char ***deps_specs_out,
+  int *deps_count_out,
+  const char ***dev_specs_out,
+  int *dev_count_out
+) {
+  *deps_specs_out = NULL;
+  *deps_count_out = 0;
+  *dev_specs_out = NULL;
+  *dev_count_out = 0;
+
+  yyjson_read_err err;
+  yyjson_doc *doc = yyjson_read_file("package.json", 0, NULL, &err);
+  if (!doc) {
+    fprintf(stderr, "Error: No package.json found\n");
+    return EXIT_FAILURE;
+  }
+
+  yyjson_val *root = yyjson_doc_get_root(doc);
+  if (!root || !yyjson_is_obj(root)) {
+    yyjson_doc_free(doc);
+    fprintf(stderr, "Error: Invalid package.json format\n");
+    return EXIT_FAILURE;
+  }
+
+  const char **deps_specs = try_oom((size_t)count * sizeof(char *));
+  const char **dev_specs = try_oom((size_t)count * sizeof(char *));
+  if (!deps_specs || !dev_specs) {
+    free((void *)deps_specs);
+    free((void *)dev_specs);
+    yyjson_doc_free(doc);
+    fprintf(stderr, "Error: out of memory\n");
+    return EXIT_FAILURE;
+  }
+
+  int deps_count = 0;
+  int dev_count = 0;
+  for (int i = 0; i < count; i++) {
+    char pkg_name[512];
+    if (package_name_from_spec(package_specs[i], pkg_name, sizeof(pkg_name)) == 0) {
+      free((void *)deps_specs);
+      free((void *)dev_specs);
+      yyjson_doc_free(doc);
+      fprintf(stderr, "Error: Invalid package spec '%s'\n", package_specs[i]);
+      return EXIT_FAILURE;
+    }
+
+    bool in_deps = pkg_json_has_dep(root, "dependencies", pkg_name);
+    bool in_dev = pkg_json_has_dep(root, "devDependencies", pkg_name);
+    if (in_deps) deps_specs[deps_count++] = package_specs[i];
+    else if (in_dev) dev_specs[dev_count++] = package_specs[i];
+    else deps_specs[deps_count++] = package_specs[i];
+  }
+
+  yyjson_doc_free(doc);
+  *deps_specs_out = deps_specs;
+  *deps_count_out = deps_count;
+  *dev_specs_out = dev_specs;
+  *dev_count_out = dev_count;
+  return EXIT_SUCCESS;
+}
+
 bool pkg_script_exists(const char *package_json_path, const char *script_name) {
   char script_cmd[4096];
   return pkg_get_script(package_json_path, script_name, script_cmd, sizeof(script_cmd)) >= 0;
@@ -196,7 +357,7 @@ static int cmd_add_global(const char *const *package_specs, int count) {
   if (!pkg_verbose) progress_stop(&progress);
   
   if (err != PKG_OK) {
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -245,7 +406,7 @@ static int cmd_remove_global(const char *package_name) {
   }
   
   if (err != PKG_OK) {
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -290,7 +451,7 @@ static int cmd_install(void) {
     pkg_error_t err = pkg_resolve_and_install(ctx, "package.json", "ant.lockb", "node_modules");
     if (err != PKG_OK) {
       if (!pkg_verbose) { progress_stop(&progress);  }
-      fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+      print_pkg_error(ctx);
       pkg_free(ctx);
       return EXIT_FAILURE;
     }
@@ -298,7 +459,7 @@ static int cmd_install(void) {
     pkg_error_t err = pkg_install(ctx, "package.json", "ant.lockb", "node_modules");
     if (err != PKG_OK) {
       if (!pkg_verbose) { progress_stop(&progress);  }
-      fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+      print_pkg_error(ctx);
       pkg_free(ctx);
       return EXIT_FAILURE;
     }
@@ -360,6 +521,166 @@ static int cmd_install(void) {
   return EXIT_SUCCESS;
 }
 
+static int cmd_update(void) {
+  print_install_header("update");
+  
+  progress_t progress;
+  
+  if (!pkg_verbose) {
+    progress_start(&progress, "🔍 Resolving [1/1]");
+  }
+  
+  pkg_options_t opts = { 
+    .progress_callback = pkg_verbose ? NULL : progress_callback,
+    .user_data = pkg_verbose ? NULL : &progress,
+    .verbose = pkg_verbose 
+  };
+  pkg_context_t *ctx = pkg_init(&opts);
+  if (!ctx) {
+    fprintf(stderr, "Error: Failed to initialize package manager\n");
+    return EXIT_FAILURE;
+  }
+
+  struct stat st;
+  if (stat("package.json", &st) != 0) {
+    if (!pkg_verbose) progress_stop(&progress);
+    fprintf(stderr, "Error: No package.json found\n");
+    pkg_free(ctx);
+    return EXIT_FAILURE;
+  }
+
+  pkg_error_t err = pkg_resolve_and_install(ctx, "package.json", "ant.lockb", "node_modules");
+  if (err != PKG_OK) {
+    if (!pkg_verbose) progress_stop(&progress);
+    print_pkg_error(ctx);
+    pkg_free(ctx);
+    return EXIT_FAILURE;
+  }
+  
+  if (!pkg_verbose) {
+    progress_stop(&progress);
+  }
+
+  pkg_install_result_t result;
+  if (pkg_get_install_result(ctx, &result) == PKG_OK) {
+    if (result.packages_installed > 0) {
+      print_added_packages(ctx);
+      printf("%s%u%s package%s installed", 
+        C_GREEN, result.packages_installed, C_RESET,
+        result.packages_installed == 1 ? "" : "s");
+      if (result.cache_hits > 0) {
+        printf(" %s(%u cached)%s", C_DIM, result.cache_hits, C_RESET);
+      }
+      printf(" %s[%s", C_DIM, C_RESET);
+      print_elapsed(result.elapsed_ms);
+      printf("%s]%s\n", C_DIM, C_RESET);
+    } else {
+      printf("\n%sChecked%s %s%u%s installs across %s%u%s packages %s(no changes)%s %s[%s",
+        C_DIM, C_RESET,
+        C_GREEN, result.packages_installed + result.packages_skipped, C_RESET,
+        C_GREEN, result.package_count, C_RESET,
+        C_DIM, C_RESET,
+        C_DIM, C_RESET);
+      print_elapsed(result.elapsed_ms);
+      printf("%s]%s\n", C_DIM, C_RESET);
+    }
+  }
+
+  if (pkg_discover_lifecycle_scripts(ctx, "node_modules") == PKG_OK) {
+    uint32_t script_count = pkg_get_lifecycle_script_count(ctx);
+    if (script_count > 0) {
+      printf("\n%s%u%s package%s need%s to run lifecycle scripts:\n",
+        C_YELLOW, script_count, C_RESET,
+        script_count == 1 ? "" : "s",
+        script_count == 1 ? "s" : "");
+      
+      for (uint32_t i = 0; i < script_count; i++) {
+        pkg_lifecycle_script_t script;
+        if (pkg_get_lifecycle_script(ctx, i, &script) == PKG_OK) {
+          printf("  %s•%s %s%s%s %s(%s)%s\n", 
+            C_DIM, C_RESET,
+            C_CYAN, script.name, C_RESET,
+            C_DIM, script.script, C_RESET);
+        }
+      }
+      
+      printf("\nRun: %sant trust <pkg>%s or %sant trust --all%s\n", C_DIM, C_RESET, C_DIM, C_RESET);
+    }
+  }
+
+  pkg_free(ctx);
+  return EXIT_SUCCESS;
+}
+
+static int cmd_update_many(const char *const *package_specs, int count) {
+  print_install_header("update");
+
+  const char **deps_specs = NULL;
+  const char **dev_specs = NULL;
+  int deps_count = 0;
+  int dev_count = 0;
+  if (classify_update_specs(package_specs, count, &deps_specs, &deps_count, &dev_specs, &dev_count) != EXIT_SUCCESS) {
+    return EXIT_FAILURE;
+  }
+
+  char resolve_msg[64];
+  snprintf(resolve_msg, sizeof(resolve_msg), "🔍 Resolving [%d/%d]", count, count);
+  
+  progress_t progress;
+  if (!pkg_verbose) {
+    progress_start(&progress, resolve_msg);
+  }
+  
+  pkg_options_t opts = {
+    .progress_callback = pkg_verbose ? NULL : progress_callback,
+    .user_data = pkg_verbose ? NULL : &progress,
+    .verbose = pkg_verbose
+  };
+  pkg_context_t *ctx = pkg_init(&opts);
+  if (!ctx) {
+    free((void *)deps_specs);
+    free((void *)dev_specs);
+    if (!pkg_verbose) progress_stop(&progress);
+    fprintf(stderr, "Error: Failed to initialize package manager\n");
+    return EXIT_FAILURE;
+  }
+
+  pkg_error_t err = PKG_OK;
+  if (deps_count > 0) {
+    err = pkg_add_many(ctx, "package.json", deps_specs, (uint32_t)deps_count, false);
+  }
+  if (err == PKG_OK && dev_count > 0) {
+    err = pkg_add_many(ctx, "package.json", dev_specs, (uint32_t)dev_count, true);
+  }
+  free((void *)deps_specs);
+  free((void *)dev_specs);
+
+  if (err != PKG_OK) {
+    if (!pkg_verbose) progress_stop(&progress);
+    print_pkg_error(ctx);
+    pkg_free(ctx);
+    return EXIT_FAILURE;
+  }
+
+  err = pkg_resolve_and_install(ctx, "package.json", "ant.lockb", "node_modules");
+  if (err != PKG_OK) {
+    if (!pkg_verbose) progress_stop(&progress);
+    print_pkg_error(ctx);
+    pkg_free(ctx);
+    return EXIT_FAILURE;
+  }
+  
+  if (!pkg_verbose) progress_stop(&progress);
+
+  pkg_install_result_t result;
+  if (pkg_get_install_result(ctx, &result) == PKG_OK) {
+    print_add_summary(ctx, &result, true);
+  }
+
+  pkg_free(ctx);
+  return EXIT_SUCCESS;
+}
+
 static int cmd_add(const char *const *package_specs, int count, bool dev) {
   print_install_header(dev ? "add -D" : "add");
   
@@ -385,7 +706,7 @@ static int cmd_add(const char *const *package_specs, int count, bool dev) {
   pkg_error_t err = pkg_add_many(ctx, "package.json", package_specs, (uint32_t)count, dev);
   if (err != PKG_OK) {
     if (!pkg_verbose) { progress_stop(&progress);  }
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -393,7 +714,7 @@ static int cmd_add(const char *const *package_specs, int count, bool dev) {
   err = pkg_resolve_and_install(ctx, "package.json", "ant.lockb", "node_modules");
   if (err != PKG_OK) {
     if (!pkg_verbose) { progress_stop(&progress);  }
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -402,32 +723,7 @@ static int cmd_add(const char *const *package_specs, int count, bool dev) {
 
   pkg_install_result_t result;
   if (pkg_get_install_result(ctx, &result) == PKG_OK) {
-    printf("\n");
-    
-    uint32_t added_count = pkg_get_added_count(ctx);
-    for (uint32_t i = 0; i < added_count; i++) {
-      pkg_added_package_t pkg;
-      if (pkg_get_added_package(ctx, i, &pkg) == PKG_OK && pkg.direct) {
-        int bin_count = pkg_list_package_bins("node_modules", pkg.name, NULL, NULL);
-        if (bin_count > 0) {
-          printf("%sinstalled%s %s%s@%s%s with binaries:\n", 
-            C_GREEN, C_RESET,
-            C_BOLD, pkg.name, pkg.version, C_RESET);
-          pkg_list_package_bins("node_modules", pkg.name, print_bin_callback, NULL);
-        } else {
-          printf("%sinstalled%s %s%s@%s%s\n", 
-            C_GREEN, C_RESET,
-            C_BOLD, pkg.name, pkg.version, C_RESET);
-        }
-      }
-    }
-    
-    printf("\n%s%u%s package%s installed %s[%s",
-      C_GREEN, result.packages_installed, C_RESET,
-      result.packages_installed == 1 ? "" : "s",
-      C_DIM, C_RESET);
-    print_elapsed(result.elapsed_ms);
-    printf("%s]%s\n", C_DIM, C_RESET);
+    print_add_summary(ctx, &result, false);
   }
 
   pkg_free(ctx);
@@ -456,7 +752,7 @@ static int cmd_remove(const char *package_name) {
   pkg_error_t err = pkg_remove(ctx, "package.json", package_name);
   if (err != PKG_OK && err != PKG_NOT_FOUND) {
     if (!pkg_verbose) { progress_stop(&progress);  }
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -473,7 +769,7 @@ static int cmd_remove(const char *package_name) {
   err = pkg_resolve_and_install(ctx, "package.json", "ant.lockb", "node_modules");
   if (err != PKG_OK) {
     if (!pkg_verbose) { progress_stop(&progress);  }
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -641,7 +937,7 @@ static int cmd_init(void) {
     prompt_with_default("version", "1.0.0", version, sizeof(version));
     prompt_with_default("entry point", "index.js", entry, sizeof(entry));
     
-    printf("\n");
+    fputc('\n', stdout);
   } else {
     strncpy(name, default_name, sizeof(name) - 1);
     strncpy(version, "1.0.0", sizeof(version) - 1);
@@ -721,7 +1017,7 @@ static int cmd_why(const char *package_name) {
     printf("  %s(no dependents)%s\n", C_DIM, C_RESET);
   }
   
-  printf("\n");
+  fputc('\n', stdout);
   return EXIT_SUCCESS;
 }
 
@@ -779,6 +1075,29 @@ int pkg_cmd_install(int argc, char **argv) {
   return exitcode;
 }
 
+int pkg_cmd_update(int argc, char **argv) {
+  struct arg_str *pkgs = arg_strn(NULL, NULL, "<package[@version]>", 0, 100, NULL);
+  struct arg_lit *help = arg_lit0("h", "help", "display help");
+  struct arg_end *end = arg_end(5);
+  
+  void *argtable[] = { pkgs, help, end };
+  int nerrors = arg_parse(argc, argv, argtable);
+  
+  int exitcode = EXIT_SUCCESS;
+  if (help->count > 0) {
+    printf("Usage: ant update [packages...] [--verbose]\n\n");
+    printf("Re-resolve all dependencies, or upgrade specific packages in place.\n");
+  } else if (nerrors > 0) {
+    arg_print_errors(stdout, end, "ant update");
+    exitcode = EXIT_FAILURE;
+  } else {
+    exitcode = pkgs->count > 0 ? cmd_update_many(pkgs->sval, pkgs->count) : cmd_update();
+  }
+  
+  arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
+  return exitcode;
+}
+
 int pkg_cmd_add(int argc, char **argv) {
   struct arg_str *pkgs = arg_strn(NULL, NULL, "<package[@version]>", 1, 100, NULL);
   struct arg_lit *global = arg_lit0("g", "global", "install globally");
@@ -863,7 +1182,7 @@ int pkg_cmd_trust(int argc, char **argv) {
 
 int pkg_cmd_run(int argc, char **argv) {
   if (argc < 2) {
-    printf("Usage: ant run <script> [-- args...]\n\n");
+    printf("Usage: ant run <script> [args...]\n\n");
     printf("Run a script from package.json\n\n");
     printf("Available scripts:\n");
     
@@ -890,31 +1209,24 @@ int pkg_cmd_run(int argc, char **argv) {
   
   char extra_args[4096] = {0};
   int extra_args_len = 0;
-  bool found_separator = false;
   
-  for (int i = 2; i < argc; i++) {
-    if (!found_separator && strcmp(argv[i], "--") == 0) {
-      found_separator = true;
-      continue;
-    }
-    if (found_separator) {
-      if (extra_args_len > 0) {
-        extra_args[extra_args_len++] = ' ';
-      }
-      size_t arg_len = strlen(argv[i]);
-      if ((size_t)extra_args_len + arg_len < sizeof(extra_args) - 1) {
-        memcpy(extra_args + extra_args_len, argv[i], arg_len);
-        extra_args_len += (int)arg_len;
-      }
+  int arg_start = 2;
+  if (arg_start < argc && strcmp(argv[arg_start], "--") == 0) arg_start++;
+
+  for (int i = arg_start; i < argc; i++) {
+    if (extra_args_len > 0) extra_args[extra_args_len++] = ' ';
+    size_t arg_len = strlen(argv[i]);
+    if ((size_t)extra_args_len + arg_len < sizeof(extra_args) - 1) {
+      memcpy(extra_args + extra_args_len, argv[i], arg_len);
+      extra_args_len += (int)arg_len;
     }
   }
-  extra_args[extra_args_len] = '\0';
   
+  extra_args[extra_args_len] = '\0';
   printf("%s$%s %s%s%s", C_MAGENTA, C_RESET, C_BOLD, script_cmd, C_RESET);
-  if (extra_args_len > 0) {
-    printf(" %s", extra_args);
-  }
-  printf("\n");
+  
+  if (extra_args_len > 0) printf(" %s", extra_args);
+  fputc('\n', stdout);
   
   pkg_script_result_t result = {0};
   pkg_error_t err = pkg_run_script(
@@ -1088,7 +1400,7 @@ static int cmd_info(const char *package_spec) {
   pkg_info_t info;
   pkg_error_t err = pkg_info(ctx, package_spec, &info);
   if (err != PKG_OK) {
-    fprintf(stderr, "Error: %s\n", pkg_error_string(ctx));
+    print_pkg_error(ctx);
     pkg_free(ctx);
     return EXIT_FAILURE;
   }
@@ -1142,12 +1454,11 @@ static int cmd_info(const char *package_spec) {
       if (pkg_info_get_maintainer(ctx, i, &maint) == PKG_OK) {
         printf("- %s", maint.name);
         if (maint.email[0]) printf(" <%s>", maint.email);
-        printf("\n");
+        fputc('\n', stdout);
       }
     }
   }
   
-  // Published date
   if (info.published[0]) printf("\n%sPublished:%s %s\n", C_BOLD, C_RESET, info.published);
   
   pkg_free(ctx);
diff --git a/src/core/ant.ts b/src/core/ant.ts
index 22786c1..40d8f8d 100644
--- a/src/core/ant.ts
+++ b/src/core/ant.ts
@@ -11,21 +11,20 @@ Ant.typeof = function (t) {
     T_OBJ: 'object',
     T_PROP: 'prop',
     T_STR: 'string',
-    T_UNDEF: 'undefined',
-    T_NULL: 'null',
-    T_NUM: 'number',
-    T_BOOL: 'boolean',
+    T_ARR: 'array',
     T_FUNC: 'function',
-    T_CODEREF: 'coderef',
     T_CFUNC: 'cfunc',
-    T_ERR: 'err',
-    T_ARR: 'array',
+    T_CLOSURE: 'closure',
     T_PROMISE: 'promise',
-    T_TYPEDARRAY: 'typedarray',
+    T_GENERATOR: 'generator',
+    T_UNDEF: 'undefined',
+    T_NULL: 'null',
+    T_BOOL: 'boolean',
+    T_NUM: 'number',
     T_BIGINT: 'bigint',
-    T_PROPREF: 'propref',
     T_SYMBOL: 'symbol',
-    T_GENERATOR: 'generator',
+    T_ERR: 'err',
+    T_TYPEDARRAY: 'typedarray',
     T_FFI: 'ffi',
     T_NTARG: 'ntarg'
   } as const;
diff --git a/src/core/features.ts b/src/core/features.ts
index ca1341f..e957987 100644
--- a/src/core/features.ts
+++ b/src/core/features.ts
@@ -3,3 +3,13 @@ process.features = {
   tls_mbedtls: import.meta.env.MBEDTLS as unknown as boolean,
   typescript: 'transform'
 };
+
+// polyfill process.versions to satisfy modules that rely on node
+// runtime detection. values mirror node 25.2.0 defaults
+process.versions = {
+  node: '25.2.0',
+  ant: import.meta.env.VERSION,
+  v8: '14.1.146.11-node.14',
+  uv: '1.52.0',
+  modules: '141'
+};
diff --git a/src/core/messages.toml b/src/core/messages.toml
index c7ba08b..8e73ec0 100644
--- a/src/core/messages.toml
+++ b/src/core/messages.toml
@@ -6,7 +6,7 @@ unknown_flag_warn = "{warn}: <bold>Unknown ANT_DEBUG flag: \"%s\"</>\n"
 
 failed_to_fetch = "{error}: <bold>Could not fetch \"%s\"</>: %s\n"
 module_not_found = "{error}: <bold>Module not found: \"%s\"</>\n"
-type_strip_failed = "{error}: <bold>Type stripping failed (%d)</>\n"
+type_strip_failed = "{error}: <bold>Type stripping failed (%d)</>: %s\n"
 watch_entrypoint_error = "{error}: <bold>--watch requires a local file entrypoint.</>\n"
 watch_module_error = "{error}: <bold>--watch only supports module file execution.</>\n"
 watch_subcommand_error = "{error}: <bold>--watch is only supported when executing a module file.</>\n"
diff --git a/src/debug.c b/src/debug.c
new file mode 100644
index 0000000..cf55de7
--- /dev/null
+++ b/src/debug.c
@@ -0,0 +1,20 @@
+#include "debug.h"
+
+static unsigned sv_debug_flags = 0;
+
+bool sv_debug_enabled(sv_debug_flag_t flag) {
+  return (sv_debug_flags & (unsigned)flag) != 0;
+}
+
+void sv_debug_set(sv_debug_flag_t flag, bool enabled) {
+  if (enabled) sv_debug_enable(flag);
+  else sv_debug_disable(flag);
+}
+
+void sv_debug_enable(sv_debug_flag_t flag) {
+  sv_debug_flags |= (unsigned)flag;
+}
+
+void sv_debug_disable(sv_debug_flag_t flag) {
+  sv_debug_flags &= ~(unsigned)flag;
+}
diff --git a/src/descriptors.c b/src/descriptors.c
new file mode 100644
index 0000000..d80e65c
--- /dev/null
+++ b/src/descriptors.c
@@ -0,0 +1,181 @@
+#include "descriptors.h"
+#include "silver/engine.h"
+#include "arena.h"
+#include "utils.h"
+
+descriptor_entry_t *desc_registry = NULL;
+
+static descriptor_entry_t arr_length_desc = {
+  .key = 0, .obj_off = 0,
+  .prop_name = "length", .prop_len = 6,
+  .writable = true, .enumerable = false, .configurable = false,
+  .has_getter = false, .has_setter = false,
+  .getter = 0, .setter = 0,
+};
+
+uint64_t make_desc_key(jsoff_t obj_off, const char *key, size_t klen) {
+  uint32_t key_hash = (uint32_t)hash_key(key, klen) & 0x7FFFFFFFu;
+  return ((uint64_t)obj_off << 32) | key_hash;
+}
+
+uint64_t make_sym_desc_key(jsoff_t obj_off, jsoff_t sym_off) {
+  return ((uint64_t)obj_off << 32) | ((uint32_t)sym_off | 0x80000000u);
+}
+
+descriptor_entry_t *lookup_descriptor(ant_t *js, jsoff_t obj_off, const char *key, size_t klen) {
+  if (klen == 6
+    && memcmp(key, "length", 6) == 0
+    && is_arr_off(js, obj_off)
+  ) return &arr_length_desc;
+
+  descriptor_entry_t *entry = NULL;
+  uint64_t desc_key = make_desc_key(obj_off, key, klen);
+  HASH_FIND(hh, desc_registry, &desc_key, sizeof(uint64_t), entry);
+
+  return entry;
+}
+
+descriptor_entry_t *lookup_sym_descriptor(jsoff_t obj_off, jsoff_t sym_off) {
+  descriptor_entry_t *entry = NULL;
+  uint64_t k = make_sym_desc_key(obj_off, sym_off);
+  HASH_FIND(hh, desc_registry, &k, sizeof(uint64_t), entry);
+  return entry;
+}
+
+static descriptor_entry_t *get_or_create_desc(ant_t *js, jsval_t obj, const char *key, size_t klen) {
+  if (vtype(obj) != T_OBJ && vtype(obj) != T_FUNC && vtype(obj) != T_ARR) return NULL;
+  obj = js_as_obj(obj);
+  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  uint64_t desc_key = make_desc_key(obj_off, key, klen);
+
+  descriptor_entry_t *entry = NULL;
+  HASH_FIND(hh, desc_registry, &desc_key, sizeof(uint64_t), entry);
+  if (!entry) {
+    entry = (descriptor_entry_t *)ant_calloc(sizeof(descriptor_entry_t) + klen + 1);
+    if (!entry) return NULL;
+
+    entry->key = desc_key;
+    entry->obj_off = obj_off;
+    entry->prop_name = (char *)(entry + 1);
+    memcpy(entry->prop_name, key, klen);
+    entry->prop_name[klen] = '\0';
+    entry->prop_len = klen;
+    entry->writable = true;
+    entry->enumerable = true;
+    entry->configurable = true;
+    entry->has_getter = false;
+    entry->has_setter = false;
+    entry->getter = js_mkundef();
+    entry->setter = js_mkundef();
+
+    HASH_ADD(hh, desc_registry, key, sizeof(uint64_t), entry);
+  }
+  return entry;
+}
+
+static void ensure_string_prop_node(ant_t *js, jsval_t obj, const char *key, size_t klen) {
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
+  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR) return;
+  if (lkp(js, obj, key, klen) != 0) return;
+
+  jsval_t key_val = js_mkstr(js, key, klen);
+  if (is_err(key_val)) return;
+  (void)mkprop(js, obj, key_val, js_mkundef(), 0);
+}
+
+static descriptor_entry_t *get_or_create_sym_desc(ant_t *js, jsval_t obj, jsoff_t sym_off) {
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
+  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR) return NULL;
+  jsoff_t obj_off = (jsoff_t)vdata(obj);
+  uint64_t k = make_sym_desc_key(obj_off, sym_off);
+
+  descriptor_entry_t *entry = NULL;
+  HASH_FIND(hh, desc_registry, &k, sizeof(uint64_t), entry);
+  if (!entry) {
+    entry = (descriptor_entry_t *)ant_calloc(sizeof(descriptor_entry_t));
+    if (!entry) return NULL;
+    entry->key = k;
+    entry->obj_off = obj_off;
+    entry->sym_off = sym_off;
+    entry->prop_name = NULL;
+    entry->prop_len = 0;
+    entry->writable = true;
+    entry->enumerable = true;
+    entry->configurable = true;
+    entry->getter = js_mkundef();
+    entry->setter = js_mkundef();
+    HASH_ADD(hh, desc_registry, key, sizeof(uint64_t), entry);
+  }
+  return entry;
+}
+
+static void ensure_symbol_prop_node(ant_t *js, jsval_t obj, jsoff_t sym_off) {
+  if (vtype(obj) == T_FUNC) obj = js_func_obj(obj);
+  if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR) return;
+  if (lkp_sym(js, obj, sym_off) != 0) return;
+
+  jsval_t sym = mkval(T_SYMBOL, sym_off);
+  (void)mkprop(js, obj, sym, js_mkundef(), 0);
+}
+
+void js_set_descriptor(ant_t *js, jsval_t obj, const char *key, size_t klen, int flags) {
+  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
+  if (!entry) return;
+  entry->writable = (flags & JS_DESC_W) != 0;
+  entry->enumerable = (flags & JS_DESC_E) != 0;
+  entry->configurable = (flags & JS_DESC_C) != 0;
+}
+
+void js_set_getter_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, int flags) {
+  ensure_string_prop_node(js, obj, key, klen);
+  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
+  if (!entry) return;
+  entry->enumerable = (flags & JS_DESC_E) != 0;
+  entry->configurable = (flags & JS_DESC_C) != 0;
+  entry->has_getter = true;
+  entry->getter = getter;
+}
+
+void js_set_setter_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t setter, int flags) {
+  ensure_string_prop_node(js, obj, key, klen);
+  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
+  if (!entry) return;
+  entry->enumerable = (flags & JS_DESC_E) != 0;
+  entry->configurable = (flags & JS_DESC_C) != 0;
+  entry->has_setter = true;
+  entry->setter = setter;
+}
+
+void js_set_accessor_desc(ant_t *js, jsval_t obj, const char *key, size_t klen, jsval_t getter, jsval_t setter, int flags) {
+  ensure_string_prop_node(js, obj, key, klen);
+  descriptor_entry_t *entry = get_or_create_desc(js, obj, key, klen);
+  if (!entry) return;
+  entry->enumerable = (flags & JS_DESC_E) != 0;
+  entry->configurable = (flags & JS_DESC_C) != 0;
+  entry->has_getter = true;
+  entry->has_setter = true;
+  entry->getter = getter;
+  entry->setter = setter;
+}
+
+void js_set_sym_getter_desc(ant_t *js, jsval_t obj, jsval_t sym, jsval_t getter, int flags) {
+  if (vtype(sym) != T_SYMBOL) return;
+  ensure_symbol_prop_node(js, obj, (jsoff_t)vdata(sym));
+  descriptor_entry_t *entry = get_or_create_sym_desc(js, obj, (jsoff_t)vdata(sym));
+  if (!entry) return;
+  entry->enumerable = (flags & JS_DESC_E) != 0;
+  entry->configurable = (flags & JS_DESC_C) != 0;
+  entry->has_getter = true;
+  entry->getter = getter;
+}
+
+void js_set_sym_setter_desc(ant_t *js, jsval_t obj, jsval_t sym, jsval_t setter, int flags) {
+  if (vtype(sym) != T_SYMBOL) return;
+  ensure_symbol_prop_node(js, obj, (jsoff_t)vdata(sym));
+  descriptor_entry_t *entry = get_or_create_sym_desc(js, obj, (jsoff_t)vdata(sym));
+  if (!entry) return;
+  entry->enumerable = (flags & JS_DESC_E) != 0;
+  entry->configurable = (flags & JS_DESC_C) != 0;
+  entry->has_setter = true;
+  entry->setter = setter;
+}
diff --git a/src/errors.c b/src/errors.c
index f314455..5d30e06 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -1,11 +1,64 @@
-#include "tokens.h"
-#include "stack.h"
 #include "errors.h"
 #include "internal.h"
+#include "silver/engine.h"
+#include "modules/io.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <limits.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#endif
+
+typedef struct { char *buf; size_t size; } errbuf_t;
+
+static void print_error_value(ant_t *js, jsval_t value, jsval_t fallback_stack, const char *prefix) {
+  const char *stack = NULL;
+  
+  if (vtype(value) == T_OBJ)
+    stack = get_str_prop(js, value, "stack", 5, NULL);
+  
+  if (!stack && vtype(fallback_stack) == T_STR) {
+    jsoff_t slen;
+    jsoff_t soff = vstr(js, fallback_stack, &slen);
+    stack = (const char *)&js->mem[soff];
+  }
+  
+  if (prefix) fputs(prefix, stderr);
+  
+  if (stack) {
+    fputs(stack, stderr);
+    size_t n = strlen(stack);
+    if (n == 0 || stack[n - 1] != '\n') fputc('\n', stderr);
+  } else if (vtype(value) == T_OBJ) {
+    const char *name = get_str_prop(js, value, "name", 4, NULL);
+    const char *msg = get_str_prop(js, value, "message", 7, NULL);
+    if (name && msg) fprintf(stderr, "%s%s%s: %s%s%s\n", C_RED, name, C_RESET, C_BOLD, msg, C_RESET);
+    else if (name) fprintf(stderr, "%s%s%s\n", C_RED, name, C_RESET);
+    else fprintf(stderr, "%s\n", js_str(js, value));
+  } else fprintf(stderr, "%s\n", js_str(js, value));
+}
+
+bool print_uncaught_throw(ant_t *js) {
+  if (!js->thrown_exists) return false;
+  print_error_value(js, js->thrown_value, js->thrown_stack, NULL);
+  
+  js->thrown_exists = false;
+  js->thrown_value = js_mkundef();
+  js->thrown_stack = js_mkundef();
+  
+  return true;
+}
+
+bool print_unhandled_promise_rejection(ant_t *js, jsval_t value) {
+  print_error_value(js, value, js_mkundef(), "Uncaught (in promise) ");
+  return true;
+}
 
 static const char *get_error_type_name(js_err_type_t err_type) {
   static const char *names[] = {
@@ -19,56 +72,48 @@ static const char *get_error_type_name(js_err_type_t err_type) {
     [JS_ERR_INTERNAL]  = "InternalError",
     [JS_ERR_AGGREGATE] = "AggregateError",
   };
-  
+
   return names[err_type] ?: "Error";
 }
 
-static bool ensure_errmsg_capacity(struct js *js, size_t needed) {
-  if (js->errmsg_size == 0) js->errmsg_size = 4096;
-
-  if (!js->errmsg) {
-    js->errmsg = (char *)malloc(js->errmsg_size);
-    if (!js->errmsg) return false;
-    js->errmsg[0] = '\0';
-  }
+static bool ensure_errbuf_capacity(errbuf_t *eb, size_t needed) {
+  if (needed <= eb->size) return true;
 
-  if (needed <= js->errmsg_size) return true;
-
-  size_t new_size = js->errmsg_size;
+  size_t new_size = eb->size;
   while (new_size < needed) {
     size_t next = new_size * 2;
     if (next < new_size) return false;
     new_size = next;
   }
 
-  char *next_buf = (char *)realloc(js->errmsg, new_size);
+  char *next_buf = (char *)realloc(eb->buf, new_size);
   if (!next_buf) return false;
-  js->errmsg = next_buf;
-  js->errmsg_size = new_size;
+  eb->buf = next_buf;
+  eb->size = new_size;
   return true;
 }
 
 __attribute__((format(printf, 3, 4)))
-static size_t append_errmsg_fmt(struct js *js, size_t used, const char *fmt, ...) {
+static size_t append_errbuf_fmt(errbuf_t *eb, size_t used, const char *fmt, ...) {
   int max_attempts = 3;
   int attempt = 0;
 
   for (;;) {
-    if (!ensure_errmsg_capacity(js, used + 1)) {
-      return js->errmsg_size ? js->errmsg_size - 1 : used;
+    if (!ensure_errbuf_capacity(eb, used + 1)) {
+      return eb->size ? eb->size - 1 : used;
     }
 
-    size_t remaining = js->errmsg_size - used;
+    size_t remaining = eb->size - used;
     va_list ap;
     va_start(ap, fmt);
-    int written = vsnprintf(js->errmsg + used, remaining, fmt, ap);
+    int written = vsnprintf(eb->buf + used, remaining, fmt, ap);
     va_end(ap);
 
     if (written < 0) return used;
     if ((size_t)written < remaining) return used + (size_t)written;
 
-    if (!ensure_errmsg_capacity(js, used + (size_t)written + 1)) {
-      if (++attempt >= max_attempts) return js->errmsg_size ? js->errmsg_size - 1 : used;
+    if (!ensure_errbuf_capacity(eb, used + (size_t)written + 1)) {
+      if (++attempt >= max_attempts) return eb->size ? eb->size - 1 : used;
     }
   }
 }
@@ -77,21 +122,40 @@ static inline size_t remaining_capacity(size_t used, size_t total) {
   return used >= total ? 0 : total - used;
 }
 
-static size_t append_error_header(struct js *js, size_t used, int line) {
-  if (js->filename) return append_errmsg_fmt(js, used, "%s:%d\n", js->filename, line);
-  return append_errmsg_fmt(js, used, "<eval>:%d\n", line);
+static size_t append_error_header(errbuf_t *eb, ant_t *js, size_t used, int line, int col) {
+  const char *file = (js->errsite.valid && js->errsite.filename) ? js->errsite.filename : js->filename;
+  if (file) return append_errbuf_fmt(eb, used, "%s:%d:%d\n", file, line, col);
+  return append_errbuf_fmt(eb, used, "<eval>:%d:%d\n", line, col);
 }
 
-static void get_line_col(const char *code, jsoff_t pos, int *line, int *col) {
-  int l = 1, c = 1;
-  for (jsoff_t i = 0; i < pos && code[i]; i++) code[i] == '\n' ? (l++, c = 1) : c++;
-  *line = l; *col = c;
+static void get_line_col(const char *code, jsoff_t code_len, jsoff_t pos, int *out_line, int *out_col) {
+  if (!out_line || !out_col) return;
+
+  *out_line = 1;
+  *out_col = 1;
+
+  if (!code || code_len <= 0 || pos <= 0) return;
+  if (pos > code_len) pos = code_len;
+
+  for (jsoff_t i = 0; i < pos; i++) {
+    char ch = code[i];
+    if (ch == '\0') break;
+    if (ch == '\n') {
+      *out_line += 1;
+      *out_col = 1;
+    } else *out_col += 1;
+  }
 }
 
-static void get_error_line(const char *code, jsoff_t clen, jsoff_t pos, char *buf, size_t bufsize, int *line_start_col) {
+static void get_error_line(
+  const char *code, jsoff_t clen, jsoff_t pos, char *buf, size_t bufsize,
+  int *line_start_col, jsoff_t *out_line_start, jsoff_t *out_line_end
+) {
   if (!code || bufsize == 0) {
     if (bufsize > 0) buf[0] = '\0';
     if (line_start_col) *line_start_col = 1;
+    if (out_line_start) *out_line_start = 0;
+    if (out_line_end) *out_line_end = 0;
     return;
   }
 
@@ -100,6 +164,8 @@ static void get_error_line(const char *code, jsoff_t clen, jsoff_t pos, char *bu
   if (clen == 0) {
     buf[0] = '\0';
     if (line_start_col) *line_start_col = 1;
+    if (out_line_start) *out_line_start = 0;
+    if (out_line_end) *out_line_end = 0;
     return;
   }
 
@@ -107,24 +173,27 @@ static void get_error_line(const char *code, jsoff_t clen, jsoff_t pos, char *bu
   while (line_start > 0 && code[line_start - 1] != '\n') {
     line_start--;
   }
-  
+
   jsoff_t line_end = pos;
   while (line_end < clen && code[line_end] != '\n' && code[line_end] != '\0') {
     line_end++;
   }
-  
+
   jsoff_t line_len = line_end - line_start;
   if (line_len >= bufsize) line_len = (jsoff_t)(bufsize - 1);
-  
+
   memcpy(buf, &code[line_start], line_len);
   buf[line_len] = '\0';
-  *line_start_col = (int)(pos - line_start) + 1;
+  
+  if (line_start_col) *line_start_col = (int)(pos - line_start) + 1;
+  if (out_line_start) *out_line_start = line_start;
+  if (out_line_end) *out_line_end = line_end;
 }
 
-static size_t append_error_value(struct js *js, size_t used, jsval_t value) {
+static size_t append_error_value(errbuf_t *eb, ant_t *js, size_t used, jsval_t value) {
   const char *name = "Error";
   const char *msg = NULL;
-  
+
   jsoff_t name_len = 5;
   jsoff_t msg_len = 0;
 
@@ -143,8 +212,6 @@ static size_t append_error_value(struct js *js, size_t used, jsval_t value) {
     [T_CFUNC] = &&l_type_default,
     [T_FFI] = &&l_type_default,
     [T_TYPEDARRAY] = &&l_type_default,
-    [T_CODEREF] = &&l_type_default,
-    [T_PROPREF] = &&l_type_default,
     [T_ERR] = &&l_type_default,
     [T_UNDEF] = &&l_type_default,
     [T_NULL] = &&l_type_default,
@@ -181,218 +248,550 @@ static size_t append_error_value(struct js *js, size_t used, jsval_t value) {
   goto *dispatch[key];
 
   l_with_msg:
-    return append_errmsg_fmt(js, used,
+    return append_errbuf_fmt(eb, used,
       ERR_FMT,
       (int)name_len, name, (int)msg_len, msg
     );
 
   l_name_only:
-    return append_errmsg_fmt(js, used,
+    return append_errbuf_fmt(eb, used,
       ERR_NAME_ONLY,
       (int)name_len, name
     );
 }
 
-static void append_error_caret(struct js *js, size_t *n, int error_col) {
-  if (!ensure_errmsg_capacity(js, *n + (size_t)error_col + 2)) return;
-  if (*n >= js->errmsg_size - 1) return;
+static int count_digits_int(int v) {
+  int n = 1;
+  while (v >= 10) { v /= 10; n++; }
+  return n;
+}
+
+static void append_error_caret(errbuf_t *eb, size_t *n, int error_col, int span_cols) {
+  if (span_cols < 1) span_cols = 1;
+  if (!ensure_errbuf_capacity(eb, *n + (size_t)error_col + (size_t)span_cols + 2)) return;
+  if (*n >= eb->size - 1) return;
 
-  size_t remaining = js->errmsg_size - *n;
+  size_t remaining = eb->size - *n;
   for (int i = 1; i < error_col && remaining > 1; i++) {
-    js->errmsg[(*n)++] = ' ';
+    eb->buf[(*n)++] = ' ';
     remaining--;
   }
-  if (remaining > 1) {
-    js->errmsg[(*n)++] = '^';
+  
+  for (int i = 0; i < span_cols && remaining > 1; i++) {
+    eb->buf[(*n)++] = '^';
+    remaining--;
   }
-  js->errmsg[*n] = '\0';
+  
+  eb->buf[*n] = '\0';
 }
 
-static void format_error_stack(struct js *js, size_t *n, int line, int col, bool include_source_line, const char *error_line, int error_col) {
-  if (!ensure_errmsg_capacity(js, *n + 1)) return;
-  
-  const char *dim = "\x1b[90m";
-  const char *reset = "\x1b[0m";
+static int error_span_cols_for_line(jsoff_t src_pos, jsoff_t span_len, jsoff_t line_start, jsoff_t line_end) {
+  if (line_end < line_start) return 1;
+  if (src_pos < line_start) src_pos = line_start;
+  if (src_pos > line_end) src_pos = line_end;
+  if (span_len <= 0) return 1;
+
+  jsoff_t span_end = src_pos + span_len;
+  if (span_end < src_pos) span_end = src_pos;
+  if (span_end > line_end) span_end = line_end;
+
+  jsoff_t width = span_end - src_pos;
+  if (width <= 0) width = 1;
+  if (width > INT_MAX) width = INT_MAX;
+  return (int)width;
+}
+
+static int error_terminal_columns(void) {
+#ifdef _WIN32
+  HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
+  if (h == NULL || h == INVALID_HANDLE_VALUE) h = GetStdHandle(STD_OUTPUT_HANDLE);
+  if (h && h != INVALID_HANDLE_VALUE) {
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    if (GetConsoleScreenBufferInfo(h, &csbi)) {
+      int cols = (int)(csbi.srWindow.Right - csbi.srWindow.Left + 1);
+      if (cols > 0) return cols;
+    }
+  }
+#else
+  struct winsize ws;
+  if (ioctl(STDERR_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) {
+    return (int)ws.ws_col;
+  }
+  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) {
+    return (int)ws.ws_col;
+  }
+#endif
+
+  const char *cols_env = getenv("COLUMNS");
+  if (cols_env && *cols_env) {
+    char *end = NULL;
+    long cols = strtol(cols_env, &end, 10);
+    if (end != cols_env && cols > 0 && cols <= INT_MAX) return (int)cols;
+  }
+  return 120;
+}
+
+static int error_context_src_cols_limit(int gutter_w) {
+  int cols = error_terminal_columns();
+  int half = cols / 2;
+  if (half < 40) half = 40;
+  int budget = half - (gutter_w + 3);
+  if (budget < 20) budget = 20;
+  return budget;
+}
+
+static const char *error_frame_name(ant_t *js, sv_frame_t *frame, sv_func_t *func) {
+  if (func && func->name && func->name[0]) return func->name;
+  if (js && frame && vtype(frame->callee) == T_FUNC) {
+    jsoff_t name_len = 0;
+    const char *name = get_str_prop(js, js_func_obj(frame->callee), "name", 4, &name_len);
+    if (name && name_len > 0) return name;
+  }
+  return "<anonymous>";
+}
+
+typedef struct {
+  const char *name;
+  const char *file;
+  int line;
+  int col;
+  int index;
+  int depth;
+} js_vm_frame_view_t;
+
+typedef bool 
+  (*js_vm_frame_visitor_fn)
+  (ant_t *js, const js_vm_frame_view_t *view, void *ctx);
+
+static bool error_skip_bottom_wrapper_frame(const js_vm_frame_view_t *view) {
+  return 
+    view &&
+    view->index == 0 &&
+    view->depth > 0 &&
+    strcmp(view->name, "<anonymous>") == 0 &&
+    view->line == 1 &&
+    view->col == 1;
+}
+
+static bool error_fill_vm_frame_view(
+  ant_t *js, sv_vm_t *vm, int depth, int i, 
+  const char *fallback_file, js_vm_frame_view_t *out
+) {
+  if (!js || !vm || i < 0 || i > depth || !out) return false;
+
+  sv_frame_t *frame = &vm->frames[i];
+  sv_func_t *func = frame->func;
+
+  out->name = error_frame_name(js, frame, func);
+  out->file = (func && func->filename) ? func->filename : fallback_file;
+  out->line = (func && func->source_line > 0) ? func->source_line : 1;
+  out->col = 1;
+  out->index = i;
+  out->depth = depth;
+
+  if (func && func->srcpos && frame->ip) {
+    uint32_t l, c;
+    if (sv_lookup_srcpos(func, (int)(frame->ip - func->code), &l, &c)) {
+      out->line = (int)l; out->col = (int)c;
+    }
+  }
+
+  return true;
+}
+
+static void error_visit_vm_stack_frames(
+  ant_t *js, const char *fallback_file, js_vm_frame_visitor_fn visitor, void *ctx
+) {
+  if (!js || !visitor) return;
+  sv_vm_t *vm = js->vm;
+  if (!vm) return;
+
+  int depth = vm->fp;
+  for (int i = depth; i >= 0; i--) {
+    js_vm_frame_view_t view;
+    if (!error_fill_vm_frame_view(js, vm, depth, i, fallback_file, &view)) continue;
+    if (error_skip_bottom_wrapper_frame(&view)) continue;
+    if (!visitor(js, &view, ctx)) break;
+  }
+}
+
+typedef struct {
+  errbuf_t *eb;
+  size_t *n;
+  size_t remaining;
+  const char *dim;
+  const char *reset;
+} error_frame_errbuf_ctx_t;
+
+static bool error_visit_frame_append_errbuf(ant_t *js, const js_vm_frame_view_t *view, void *ctx) {
+  (void)js;
+  error_frame_errbuf_ctx_t *c = (error_frame_errbuf_ctx_t *)ctx;
+  *c->n = append_errbuf_fmt(
+    c->eb, *c->n,
+    "\n    at %s %s(%s:%d:%d)%s",
+    view->name, c->dim, view->file, view->line, view->col, c->reset
+  );
+  c->remaining = remaining_capacity(*c->n, c->eb->size);
+  return c->remaining > 20;
+}
+
+static bool error_visit_frame_print_file(ant_t *js, const js_vm_frame_view_t *view, void *ctx) {
+  FILE *out = (FILE *)ctx;
+  fprintf(
+    out, "  at %s (%s%s:%d:%d%s)\n",
+    view->name, C_GRAY, view->file, view->line, view->col, C_RESET
+  );
+  return true;
+}
+
+static bool append_error_context(
+  errbuf_t *eb, size_t *n,
+  const char *src, jsoff_t src_len,
+  jsoff_t src_pos,
+  int error_line_no, int error_col, int error_span_cols
+) {
+  if (!src || src_len <= 0 || !n) return false;
+  if (src_pos < 0) src_pos = 0;
+  if (src_pos > src_len) src_pos = src_len;
+
+  jsoff_t err_line_start = src_pos;
+  while (err_line_start > 0 && src[err_line_start - 1] != '\n') err_line_start--;
   
-  if (include_source_line && error_line && *n < js->errmsg_size) {
-    *n = append_errmsg_fmt(js, *n, "\n%s\n", error_line);
-    append_error_caret(js, n, error_col);
+  jsoff_t err_line_end = src_pos;
+  while (err_line_end < src_len && src[err_line_end] != '\n' && src[err_line_end] != '\0') err_line_end++;
+
+  jsoff_t ctx_start = err_line_start;
+  int first_line_no = error_line_no;
+  for (int i = 0; i < 5 && ctx_start > 0; i++) {
+    jsoff_t prev = ctx_start - 1;
+    if (src[prev] == '\n') prev--;
+    while (prev >= 0 && src[prev] != '\n') prev--;
+    
+    ctx_start = prev + 1;
+    first_line_no--;
+    if (first_line_no < 1) { first_line_no = 1; break; }
   }
+
+  int gutter_w = count_digits_int(error_line_no);
+  int src_cols_limit = error_context_src_cols_limit(gutter_w);
+  int line_no = first_line_no;
+  jsoff_t cur = ctx_start;
   
-  size_t remaining = remaining_capacity(*n, js->errmsg_size);
-  if (remaining > 20) {
-    const char *file = js->filename ? js->filename : "<eval>";
+  while (cur <= err_line_end && cur < src_len) {
+    jsoff_t line_start = cur;
+    jsoff_t line_end = cur;
     
-    for (int i = global_call_stack.depth - 1; i >= 0 && remaining > 20; i--) {
-      call_frame_t *frame = &global_call_stack.frames[i];
-      const char *fname = frame->function_name ? frame->function_name : "<anonymous>";
-      const char *ffile = frame->filename ? frame->filename : "<eval>";
-      
-      if (frame->line < 0 && frame->code) {
-        get_line_col(frame->code, frame->pos, &frame->line, &frame->col);
-      }
-      int fline = frame->line > 0 ? frame->line : 1;
-      int fcol = frame->col > 0 ? frame->col : 1;
+    while (line_end < src_len && src[line_end] != '\n' && src[line_end] != '\0') line_end++;
+    int line_len = (int)(line_end - line_start);
+    bool clipped = (src_cols_limit > 0 && line_len > src_cols_limit);
+    int shown_len = clipped ? src_cols_limit : line_len;
+    
+    *n = append_errbuf_fmt(eb, *n, "\n%*d | %.*s", gutter_w, line_no, shown_len, src + line_start);
+    if (clipped) *n = append_errbuf_fmt(eb, *n, "...");
+
+    if (line_start == err_line_start) {
+      *n = append_errbuf_fmt(eb, *n, "\n%*s   ", gutter_w, "");
+      int caret_col = error_col;
+      int caret_span = error_span_cols;
       
-      *n = append_errmsg_fmt(js, *n,
-        "\n    at %s %s(%s:%d:%d)%s",
-        fname, dim, ffile, fline, fcol, reset
-      );
-      remaining = remaining_capacity(*n, js->errmsg_size);
+      if (clipped) {
+        int max_col = shown_len > 0 ? shown_len : 1;
+        if (caret_col > max_col) caret_col = max_col;
+        if (caret_span > max_col - caret_col + 1) caret_span = max_col - caret_col + 1;
+        if (caret_span < 1) caret_span = 1;
+      } append_error_caret(eb, n, caret_col, caret_span);
     }
+
+    if (line_end >= src_len || src[line_end] == '\0') break;
+    cur = line_end + 1; line_no++;
+  }
+
+  return true;
+}
+
+static void format_error_stack(errbuf_t *eb, ant_t *js, size_t *n, int line, int col, bool include_source_line, const char *error_line, int error_col, int error_span_cols) {
+  if (!ensure_errbuf_capacity(eb, *n + 1)) return;
+
+  const char *dim = C_GRAY;
+  const char *reset = C_RESET;
+
+  if (include_source_line && error_line && error_line[0] && *n < eb->size) {
+    *n = append_errbuf_fmt(eb, *n, "\n%s\n", error_line);
+    append_error_caret(eb, n, error_col, error_span_cols);
+  }
+
+  size_t remaining = remaining_capacity(*n, eb->size);
+  if (remaining > 20) {
+    const char *file = (js->errsite.valid && js->errsite.filename)
+      ? js->errsite.filename
+      : (js->filename ? js->filename : "<eval>");
+      
+    sv_vm_t *vm = js->vm;
+    int depth = vm ? vm->fp : -1;
     
-    if (global_call_stack.depth > 0 && remaining > 60) {
-      *n = append_errmsg_fmt(js, *n,
-        "\n    at Object.<anonymous> %s(%s:1:1)%s",
-        dim, file, reset
-      );
-      remaining = remaining_capacity(*n, js->errmsg_size);
+    if (depth >= 0) {
+      error_frame_errbuf_ctx_t ctx = { eb, n, remaining, dim, reset };
+      error_visit_vm_stack_frames(js, file, error_visit_frame_append_errbuf, &ctx);
+      remaining = ctx.remaining;
     }
-    
-    if (global_call_stack.depth == 0 && remaining > 20) {
-      *n = append_errmsg_fmt(js, *n,
+
+    if (depth <= 0 && remaining > 20) {
+      *n = append_errbuf_fmt(eb, *n,
         "\n    at %s%s:%d:%d%s",
         dim, file, line, col, reset
       );
-      remaining = remaining_capacity(*n, js->errmsg_size);
+      remaining = remaining_capacity(*n, eb->size);
     }
-    
+
     if (remaining > 60 && js->filename && strcmp(js->filename, "[eval]") != 0) {
-      *n = append_errmsg_fmt(js, *n,
-        "\n    at Module.executeUserEntryPoint [as runMain] %s(ant:internal/modules/run_main:149:5)%s",
+      *n = append_errbuf_fmt(eb, *n,
+        "\n    at silver.sv_execute_frame %s(ant:internal/silver/engine:323:5)%s",
         dim, reset
       );
-      remaining = remaining_capacity(*n, js->errmsg_size);
+      remaining = remaining_capacity(*n, eb->size);
     }
-    
+
     if (remaining > 40 && js->filename && strcmp(js->filename, "[eval]") != 0) {
-      *n = append_errmsg_fmt(js, *n,
-        "\n    at %sant:internal/call:21728:23%s",
-        dim, reset
-      );
+      *n = append_errbuf_fmt(eb, *n, "\n    at %sant:internal/call:13635:14%s", dim, reset);
     }
   }
+
+  eb->buf[eb->size - 1] = '\0';
+}
+
+void js_set_error_site(ant_t *js, const char *src, jsoff_t src_len, const char *filename, jsoff_t off, jsoff_t span_len) {
+  if (!js) return;
   
-  js->errmsg[js->errmsg_size - 1] = '\0';
+  js->errsite.src = src;
+  js->errsite.src_len = src_len;
+  js->errsite.filename = filename;
+  js->errsite.off = off < 0 ? 0 : off;
+  js->errsite.span_len = span_len < 0 ? 0 : span_len;
+  js->errsite.valid = (src != NULL && src_len >= 0);
+}
+
+void js_clear_error_site(ant_t *js) {
+  if (!js) return;
+  memset(&js->errsite, 0, sizeof(js->errsite));
+}
+
+static void resolve_error_site(
+  ant_t *js, const char **out_src, jsoff_t *out_src_len,
+  jsoff_t *out_src_pos, jsoff_t *out_span_len
+) {
+  if (js && !js->errsite.valid) js_set_error_site_from_vm_top(js);
+
+  const char *src = NULL;
+  jsoff_t src_len = 0;
+  jsoff_t src_pos = 0;
+  jsoff_t span_len = 0;
+
+  if (js->errsite.valid) {
+    src = js->errsite.src;
+    src_len = js->errsite.src_len;
+    src_pos = js->errsite.off;
+    span_len = js->errsite.span_len;
+  }
+
+  if (out_src) *out_src = src;
+  if (out_src_len) *out_src_len = src_len;
+  if (out_src_pos) *out_src_pos = src_pos;
+  if (out_span_len) *out_span_len = span_len;
 }
 
-js_err_type_t get_error_type(struct js *js) {
-  if (!(js->flags & F_THROW)) return JS_ERR_GENERIC;
+typedef struct {
+  const char *src;
+  jsoff_t src_len;
+  jsoff_t src_pos;
+  int error_col;
+  int error_span_cols;
+  int line;
+  int col;
+  char error_line[256];
+} js_error_render_site_t;
+
+static void js_prepare_error_render_site(ant_t *js, js_error_render_site_t *site) {
+  if (!site) return;
+  memset(site, 0, sizeof(*site));
+  site->line = 1;
+  site->col = 1;
+  site->error_col = 1;
+  site->error_span_cols = 1;
+
+  jsoff_t src_span_len = 0;
+  jsoff_t line_start = 0, line_end = 0;
+  resolve_error_site(js, &site->src, &site->src_len, &site->src_pos, &src_span_len);
+
+  get_line_col(site->src, site->src_len, site->src_pos, &site->line, &site->col);
+  get_error_line(
+    site->src, site->src_len, site->src_pos,
+    site->error_line, sizeof(site->error_line),
+    &site->error_col, &line_start, &line_end
+  );
+  site->error_span_cols = error_span_cols_for_line(site->src_pos, src_span_len, line_start, line_end);
+}
+
+typedef enum {
+  JS_STACK_TEXT_FROM_ERROR_OBJECT = 0,
+  JS_STACK_TEXT_FROM_THROW_VALUE = 1,
+} js_stack_text_kind_t;
+
+static jsval_t js_build_stack_text(ant_t *js, js_stack_text_kind_t kind, jsval_t value) {
+  js_error_render_site_t site;
+  js_prepare_error_render_site(js, &site);
+
+  errbuf_t eb = { malloc(4096), 4096 };
+  if (!eb.buf) return js_mkundef();
+  eb.buf[0] = '\0';
+
+  size_t n = 0;
+  n = append_error_header(&eb, js, 0, site.line, site.col);
+
+  if (n > 0 && eb.buf[n - 1] == '\n') {
+    n--;
+    eb.buf[n] = '\0';
+  }
+
+  bool rendered_context = append_error_context(
+    &eb, &n, site.src, site.src_len, site.src_pos,
+    site.line, site.error_col, site.error_span_cols
+  );
+
+  if (!rendered_context && site.error_line[0]) {
+    n = append_errbuf_fmt(&eb, n, "\n%s\n", site.error_line);
+    append_error_caret(&eb, &n, site.error_col, site.error_span_cols);
+  }
+
+  n = append_errbuf_fmt(&eb, n, "\n");
+
+  if (kind == JS_STACK_TEXT_FROM_ERROR_OBJECT) {
+    const char *err_name = "Error";
+    const char *err_msg = NULL;
+    
+    jsoff_t name_len = 5, msg_len = 0; 
+    const char *n_str = get_str_prop(js, value, "name", 4, &name_len);
+    
+    if (n_str) err_name = n_str;
+    err_msg = get_str_prop(js, value, "message", 7, &msg_len);
+
+    if (err_msg) {
+      n = append_errbuf_fmt(&eb, n,
+        "%s%.*s%s: %s%.*s%s",
+        C_RED, (int)name_len, err_name, C_RESET,
+        C_BOLD, (int)msg_len, err_msg, C_RESET);
+    } else {
+      n = append_errbuf_fmt(&eb, n,
+        "%s%.*s%s",
+        C_RED, (int)name_len, err_name, C_RESET);
+    }
+  } else n = append_error_value(&eb, js, n, value);
+
+  format_error_stack(
+    &eb, js, &n, site.line, site.col, false,
+    site.error_line, site.error_col, site.error_span_cols
+  );
+
+  jsval_t stack_str = js_mkstr(js, eb.buf, n);
+  free(eb.buf);
+  return stack_str;
+}
+
+static void js_capture_stack(ant_t *js, jsval_t err_obj) {
+  jsval_t stack_str = js_build_stack_text(js, JS_STACK_TEXT_FROM_ERROR_OBJECT, err_obj);
+  if (vtype(stack_str) != T_STR) return;
+
+  js_set(js, err_obj, "stack", stack_str);
+  js_clear_error_site(js);
+}
+
+js_err_type_t get_error_type(ant_t *js) {
+  if (!js->thrown_exists) return JS_ERR_GENERIC;
   jsval_t err_type = js_get_slot(js, js->thrown_value, SLOT_ERR_TYPE);
   if (vtype(err_type) != T_NUM) return JS_ERR_GENERIC;
-  return (js_err_type_t)(int)js_getnum(err_type);
+  return (js_err_type_t)((int)js_getnum(err_type) & ~JS_ERR_NO_STACK);
 }
 
 __attribute__((format(printf, 4, 5)))
-jsval_t js_create_error(struct js *js, js_err_type_t err_type, jsval_t props, const char *xx, ...) {
+jsval_t js_create_error(ant_t *js, js_err_type_t err_type, jsval_t props, const char *xx, ...) {
   va_list ap;
-  int line = 0, col = 0;
-  char error_line[256] = {0};
-  int error_col = 0;
   char error_msg[256] = {0};
-  
+
   bool no_stack = (err_type & JS_ERR_NO_STACK) != 0;
-  err_type = (js_err_type_t)(err_type & ~JS_ERR_NO_STACK);
-  
-  if (!js->errmsg) {
-    js->errmsg_size = 4096;
-    js->errmsg = (char *)malloc(js->errmsg_size);
-    if (!js->errmsg) return mkval(T_ERR, 0);
-  }
-  
-  get_line_col(js->code, js->toff > 0 ? js->toff : js->pos, &line, &col);
-  get_error_line(js->code, js->clen, js->toff > 0 ? js->toff : js->pos, error_line, sizeof(error_line), &error_col);
-  
+  js_err_type_t base_type = (js_err_type_t)(err_type & ~JS_ERR_NO_STACK);
+
   va_start(ap, xx);
-  vsnprintf(error_msg, sizeof(error_msg), xx, ap);
+    vsnprintf(error_msg, sizeof(error_msg), xx, ap);
   va_end(ap);
-  
-  const char *err_name = get_error_type_name(err_type);
+
+  const char *err_name = get_error_type_name(base_type);
   size_t err_name_len = strlen(err_name);
   size_t msg_len = strlen(error_msg);
-  
+
   jsval_t err_obj = js_mkobj(js);
   js_set(js, err_obj, "name", js_mkstr(js, err_name, err_name_len));
   js_set(js, err_obj, "message", js_mkstr(js, error_msg, msg_len));
   js_set_slot(js, err_obj, SLOT_ERR_TYPE, js_mknum((double)err_type));
-  
+
   int props_type = vtype(props);
-  if ((TYPE_FLAG(props_type) & T_SPECIAL_OBJECT_MASK) != 0) {
+  if ((JS_TYPE_FLAG(props_type) & T_SPECIAL_OBJECT_MASK) != 0) {
     js_merge_obj(js, err_obj, props);
   }
   jsval_t proto = js_get_ctor_proto(js, err_name, err_name_len);
   int proto_type = vtype(proto);
-  if ((TYPE_FLAG(proto_type) & T_SPECIAL_OBJECT_MASK) != 0) {
+  if ((JS_TYPE_FLAG(proto_type) & T_SPECIAL_OBJECT_MASK) != 0) {
     js_set_proto(js, err_obj, proto);
   }
-  
-  js->flags |= F_THROW;
+
+  js->thrown_exists = true;
   js->thrown_value = err_obj;
-  
-  size_t n = 0;
-  n = append_error_header(js, 0, line);
-  
-  if (n < js->errmsg_size - 1) n = append_errmsg_fmt(
-    js, n,
-    "\x1b[31m%s\x1b[0m: \x1b[1m%s\x1b[0m",
-    err_name, error_msg
-  );
-  
+
   if (!no_stack) {
-    format_error_stack(js, &n, line, col, true, error_line, error_col);
+    js_capture_stack(js, err_obj);
   }
-  
-  js->pos = js->clen, js->tok = TOK_EOF, js->consumed = 0;
-  return mkval(T_ERR, 0);
+
+  js_clear_error_site(js);
+  return mkval(T_ERR, vdata(err_obj));
 }
 
-jsval_t js_throw(struct js *js, jsval_t value) {
-  int line = 0, col = 0;
-  char error_line[256] = {0};
-  int error_col = 0;
-  
-  get_line_col(js->code, js->toff > 0 ? js->toff : js->pos, &line, &col);
-  get_error_line(js->code, js->clen, js->toff > 0 ? js->toff : js->pos, error_line, sizeof(error_line), &error_col);
-  
-  if (!js->errmsg) {
-    js->errmsg_size = 4096;
-    js->errmsg = (char *)malloc(js->errmsg_size);
-    if (!js->errmsg) return mkval(T_ERR, 0);
+jsval_t js_throw(ant_t *js, jsval_t value) {
+  if (vtype(value) == T_OBJ) {
+    jsval_t existing = js_get(js, value, "stack");
+    if (vtype(existing) == T_STR) {
+      js->thrown_exists = true;
+      js->thrown_value = value;
+      js_clear_error_site(js);
+      return mkval(T_ERR, vdata(value));
+    }
+    jsval_t slot = js_get_slot(js, value, SLOT_ERR_TYPE);
+    if (vtype(slot) == T_NUM && ((int)js_getnum(slot) & JS_ERR_NO_STACK)) {
+      js->thrown_exists = true;
+      js->thrown_value = value;
+      js_clear_error_site(js);
+      return mkval(T_ERR, vdata(value));
+    }
   }
-  
-  size_t n = 0;
-  
-  n = append_error_header(js, 0, line);
-  n = append_error_value(js, n, value);
-  
-  format_error_stack(js, &n, line, col, true, error_line, error_col);
-  
-  js->flags |= F_THROW;
+
+  jsval_t stack_str = js_build_stack_text(js, JS_STACK_TEXT_FROM_THROW_VALUE, value);
+  if (vtype(stack_str) != T_STR) return mkval(T_ERR, 0);
+
+  if (vtype(value) == T_OBJ) {
+    js_set(js, value, "stack", stack_str);
+  }
+
+  js->thrown_exists = true;
   js->thrown_value = value;
-  js->pos = js->clen;
-  js->tok = TOK_EOF;
-  js->consumed = 0;
+  js->thrown_stack = stack_str;
+  js_clear_error_site(js);
+  
   return mkval(T_ERR, 0);
 }
 
-void js_print_stack_trace(FILE *stream) {
-  int i = global_call_stack.depth;
-
-loop:
-  if (--i < 0) goto done;
-  call_frame_t *frame = &global_call_stack.frames[i];
+void js_print_stack_trace_vm(ant_t *js, FILE *stream) {
+  const char *fallback_file = js->filename ? js->filename : "<unknown>";
+  if (!stream) return;
   
-  if (frame->line >= 0 || !frame->code) goto print;
-  get_line_col(frame->code, frame->pos, &frame->line, &frame->col);
-
-print:
-  fprintf(stream, "  at %s (\x1b[90m%s:%d:%d\x1b[0m)\n",
-    frame->function_name ?: "<anonymous>",
-    frame->filename ?: "<unknown>",
-    frame->line > 0 ? frame->line : 1,
-    frame->col > 0 ? frame->col : 1);
-  goto loop;
-
-done:
-  return;
+  error_visit_vm_stack_frames(
+    js, fallback_file, 
+    error_visit_frame_print_file, stream
+  );
 }
diff --git a/src/escape.c b/src/escape.c
index f3ec4ba..25ef09b 100644
--- a/src/escape.c
+++ b/src/escape.c
@@ -2,7 +2,8 @@
 #include "escape.h"
 
 static inline size_t decode_hex_escape(const uint8_t *in, size_t pos, uint8_t *out, size_t *out_pos) {
-  out[(*out_pos)++] = (uint8_t)((unhex(in[pos + 2]) << 4U) | unhex(in[pos + 3]));
+  uint32_t cp = (unhex(in[pos + 2]) << 4U) | unhex(in[pos + 3]);
+  *out_pos += utf8_encode(cp, (char *)&out[*out_pos]);
   return 2;
 }
 
@@ -18,7 +19,7 @@ static size_t decode_octal_escape(const uint8_t *in, size_t pos, uint8_t *out, s
     }
   }
   
-  out[(*out_pos)++] = (uint8_t)val;
+  *out_pos += utf8_encode((uint32_t)val, (char *)&out[*out_pos]);
   return extra;
 }
 
@@ -36,11 +37,25 @@ static size_t decode_unicode_braced(const uint8_t *in, size_t pos, size_t end, u
   return 0;
 }
 
-static size_t decode_unicode_fixed(const uint8_t *in, size_t pos, uint8_t *out, size_t *out_pos) {
-  uint32_t cp = 
+static size_t decode_unicode_fixed(const uint8_t *in, size_t pos, size_t end, uint8_t *out, size_t *out_pos) {
+  uint32_t cp =
     (unhex(in[pos + 2]) << 12U) | (unhex(in[pos + 3]) << 8U) |
     (unhex(in[pos + 4]) << 4U)  |  unhex(in[pos + 5]);
-    
+
+  if (cp >= 0xD800 && cp <= 0xDBFF && pos + 11 < end &&
+      in[pos + 6] == '\\' && in[pos + 7] == 'u' &&
+      is_xdigit(in[pos + 8]) && is_xdigit(in[pos + 9]) &&
+      is_xdigit(in[pos + 10]) && is_xdigit(in[pos + 11])) {
+    uint32_t lo =
+      (unhex(in[pos + 8]) << 12U) | (unhex(in[pos + 9]) << 8U) |
+      (unhex(in[pos + 10]) << 4U)  |  unhex(in[pos + 11]);
+    if (lo >= 0xDC00 && lo <= 0xDFFF) {
+      cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00);
+      *out_pos += utf8_encode(cp, (char *)&out[*out_pos]);
+      return 10;
+    }
+  }
+
   *out_pos += utf8_encode(cp, (char *)&out[*out_pos]);
   return 4;
 }
@@ -74,7 +89,7 @@ size_t decode_escape(const uint8_t *in, size_t pos, size_t end, uint8_t *out, si
       } else if (
         pos + 5 < end && is_xdigit(in[pos + 2]) && is_xdigit(in[pos + 3]) &&
         is_xdigit(in[pos + 4]) && is_xdigit(in[pos + 5])
-      ) advance = decode_unicode_fixed(in, pos, out, out_pos);
+      ) advance = decode_unicode_fixed(in, pos, end, out, out_pos);
       else out[(*out_pos)++] = c;
       break;
     default:
diff --git a/src/esm/commonjs.c b/src/esm/commonjs.c
new file mode 100644
index 0000000..15affc0
--- /dev/null
+++ b/src/esm/commonjs.c
@@ -0,0 +1,184 @@
+#include "esm/commonjs.h"
+#include "esm/loader.h"
+
+#include "internal.h"
+#include "reactor.h"
+#include "errors.h"
+
+#include "silver/compiler.h"
+#include "silver/vm.h"
+
+#include <libgen.h>
+#include <string.h>
+#include <stdlib.h>
+
+static jsval_t esm_cjs_require(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR)
+    return js_mkerr(js, "require() expects a string specifier");
+
+  jsval_t fn = js_getcurrentfunc(js);
+  jsval_t data = js_get_slot(js, fn, SLOT_DATA);
+  const char *prev_filename = js->filename;
+
+  if (vtype(data) == T_STR) {
+    jsoff_t path_len = 0;
+    jsoff_t path_off = vstr(js, data, &path_len);
+    (void)path_len;
+    js_set_filename(js, (const char *)&js->mem[path_off]);
+  }
+
+  jsval_t ns = js_esm_import_sync(js, args[0]);
+  js_set_filename(js, prev_filename);
+  if (is_err(ns)) return ns;
+
+  if (vtype(ns) == T_OBJ) {
+    jsval_t default_export = js_get_slot(js, ns, SLOT_DEFAULT);
+    if (vtype(default_export) != T_UNDEF) return default_export;
+  }
+  return ns;
+}
+
+static jsval_t esm_cjs_require_resolve(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR) {
+    return js_mkerr(js, "require.resolve() expects a string specifier");
+  }
+
+  jsval_t fn = js_getcurrentfunc(js);
+  jsval_t data = js_get_slot(js, fn, SLOT_DATA);
+  const char *base_path = js->filename ? js->filename : ".";
+
+  if (vtype(data) == T_STR) {
+    jsoff_t data_len = 0;
+    jsoff_t data_off = vstr(js, data, &data_len);
+    base_path = (const char *)&js->mem[data_off];
+  }
+
+  jsval_t resolved = js_esm_resolve_specifier(js, args[0], base_path);
+  if (is_err(resolved)) return resolved;
+  if (vtype(resolved) != T_STR) return resolved;
+
+  jsoff_t len = 0;
+  jsoff_t off = vstr(js, resolved, &len);
+  
+  const char *s = (const char *)&js->mem[off];
+  static const char *prefix = "file://";
+
+  if ((size_t)len >= strlen(prefix) && strncmp(s, prefix, strlen(prefix)) == 0) {
+    const char *path_part = s + strlen(prefix);
+    size_t path_len = (size_t)len - strlen(prefix);
+    return js_mkstr(js, path_part, path_len);
+  }
+
+  return resolved;
+}
+
+static jsval_t esm_populate_cjs_namespace(ant_t *js, jsval_t ns, jsval_t exports_val) {
+  jsval_t set_default = setprop_cstr(js, ns, "default", 7, exports_val);
+  if (is_err(set_default)) return set_default;
+  
+  js_set_slot(js, ns, SLOT_DEFAULT, exports_val);
+  if (!is_object_type(exports_val)) return js_mkundef();
+
+  ant_iter_t iter = js_prop_iter_begin(js, exports_val);
+  const char *key = NULL;
+  size_t key_len = 0;
+  
+  while (js_prop_iter_next(&iter, &key, &key_len, NULL)) {
+    if (key_len == 7 && memcmp(key, "default", 7) == 0) continue;
+    
+    jsval_t value = js_get(js, exports_val, key);
+    if (is_err(value)) { js_prop_iter_end(&iter); return value; }
+    
+    jsval_t res = setprop_cstr(js, ns, key, key_len, value);
+    if (is_err(res)) { js_prop_iter_end(&iter); return res; }
+  }
+
+  js_prop_iter_end(&iter);
+  return js_mkundef();
+}
+
+static jsval_t esm_eval_commonjs_function(
+  ant_t *js,
+  const char *code,
+  size_t code_len,
+  jsval_t require_fn,
+  jsval_t module_obj,
+  jsval_t exports_obj,
+  jsval_t filename_val,
+  jsval_t dirname_val
+) {
+  static const char *cjs_params = "require,module,exports,__filename,__dirname";
+  
+  sv_func_t *compiled = sv_compile_function_parts(
+    js, cjs_params,
+    strlen(cjs_params),
+    code, code_len,
+    false
+  );
+
+  if (!compiled) {
+    if (js->thrown_exists) return mkval(T_ERR, 0);
+    return js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "Unexpected compile error");
+  }
+
+  js_clear_error_site(js);
+  jsval_t args[] = {require_fn, module_obj, exports_obj, filename_val, dirname_val};
+  return sv_execute_entry(js->vm, compiled, exports_obj, args, 5);
+}
+
+jsval_t esm_load_commonjs_module(
+  ant_t *js,
+  const char *module_path, const char *code,
+  size_t code_len, jsval_t ns
+) {
+  char *path_copy = strdup(module_path);
+  if (!path_copy) return js_mkerr(js, "OOM loading CommonJS module");
+
+  jsval_t module_obj = js_mkobj(js);
+  jsval_t exports_obj = js_mkobj(js);
+  
+  js_set(js, module_obj, "exports", exports_obj);
+  js_set(js, module_obj, "loaded", js_false);
+  js_set(js, module_obj, "id", js_mkstr(js, module_path, strlen(module_path)));
+  js_set(js, module_obj, "filename", js_mkstr(js, module_path, strlen(module_path)));
+
+  jsval_t require_fn = js_heavy_mkfun(
+    js, esm_cjs_require,
+    js_mkstr(js, module_path, strlen(module_path))
+  );
+  
+  jsval_t require_resolve_fn = js_heavy_mkfun(
+    js, esm_cjs_require_resolve,
+    js_mkstr(js, module_path, strlen(module_path))
+  );
+  
+  js_set(js, require_fn, "resolve", require_resolve_fn);
+
+  char *dir = dirname(path_copy);
+  jsval_t dirname_val = js_mkstr(js, dir, strlen(dir));
+  jsval_t filename_val = js_mkstr(js, module_path, strlen(module_path));
+
+  const char *prev_filename = js->filename;
+  js_set_filename(js, module_path);
+
+  jsval_t result = esm_eval_commonjs_function(
+    js, code, code_len,
+    require_fn, module_obj, exports_obj,
+    filename_val, dirname_val
+  );
+  
+  if (vtype(result) == T_PROMISE) js_run_event_loop(js);
+  js_set(js, module_obj, "loaded", js_true);
+  jsval_t exports_val = js_get(js, module_obj, "exports");
+  
+  if (!is_err(result) && !js->thrown_exists) {
+    jsval_t ns_res = esm_populate_cjs_namespace(js, ns, exports_val);
+    if (is_err(ns_res)) result = ns_res;
+  }
+
+  js_set_filename(js, prev_filename);
+  free(path_copy);
+
+  if (is_err(result)) return result;
+  return exports_val;
+}
diff --git a/src/esm/library.c b/src/esm/library.c
new file mode 100644
index 0000000..42bd1e0
--- /dev/null
+++ b/src/esm/library.c
@@ -0,0 +1,64 @@
+#include "esm/library.h"
+
+#include "ant.h"
+#include "arena.h"
+
+#include <stdarg.h>
+#include <string.h>
+#include <uthash.h>
+
+typedef struct ant_library_entry {
+  char name[256];
+  ant_library_init_fn init_fn;
+  UT_hash_handle hh;
+} ant_library_entry_t;
+
+static ant_library_entry_t *library_registry = NULL;
+
+void ant_register_library(ant_library_init_fn init_fn, const char *name, ...) {
+  va_list args;
+  const char *alias = name;
+
+  va_start(args, name);
+  while (alias != NULL) {
+    ant_library_entry_t *lib = (ant_library_entry_t *)ant_calloc(sizeof(ant_library_entry_t));
+    if (!lib) break;
+
+    strncpy(lib->name, alias, sizeof(lib->name) - 1);
+    lib->name[sizeof(lib->name) - 1] = '\0';
+    lib->init_fn = init_fn;
+
+    HASH_ADD_STR(library_registry, name, lib);
+    alias = va_arg(args, const char *);
+  }
+  va_end(args);
+}
+
+static ant_library_entry_t *find_library(const char *specifier, size_t spec_len) {
+  ant_library_entry_t *lib = NULL;
+  char key[256];
+
+  if (spec_len >= sizeof(key)) return NULL;
+  memcpy(key, specifier, spec_len);
+  key[spec_len] = '\0';
+
+  HASH_FIND_STR(library_registry, key, lib);
+  return lib;
+}
+
+void ant_library_foreach(ant_library_iter_fn cb, void *userdata) {
+  ant_library_entry_t *lib, *tmp;
+  HASH_ITER(hh, library_registry, lib, tmp) {
+    if (!strchr(lib->name, ':')) cb(lib->name, userdata);
+  }
+}
+
+jsval_t js_esm_load_registered_library(ant_t *js, const char *specifier, size_t spec_len, bool *loaded) {
+  ant_library_entry_t *lib = find_library(specifier, spec_len);
+  if (!lib) {
+    if (loaded) *loaded = false;
+    return js_mkundef();
+  }
+  if (loaded) *loaded = true;
+  return lib->init_fn(js);
+}
diff --git a/src/esm/loader.c b/src/esm/loader.c
new file mode 100644
index 0000000..95ee7d3
--- /dev/null
+++ b/src/esm/loader.c
@@ -0,0 +1,1181 @@
+#include "esm/loader.h"
+#include "esm/commonjs.h"
+#include "esm/library.h"
+#include "esm/remote.h"
+
+#include "silver/engine.h"
+#include "modules/json.h"
+#include "modules/napi.h"
+
+#include "errors.h"
+#include "internal.h"
+#include "reactor.h"
+#include "utils.h"
+
+#include <libgen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <uthash.h>
+#include <yyjson.h>
+
+typedef enum {
+  ESM_MODULE_KIND_CODE = 0,
+  ESM_MODULE_KIND_JSON,
+  ESM_MODULE_KIND_TEXT,
+  ESM_MODULE_KIND_IMAGE,
+  ESM_MODULE_KIND_NATIVE,
+  ESM_MODULE_KIND_URL,
+} esm_module_kind_t;
+
+typedef enum {
+  ESM_MODULE_FORMAT_UNKNOWN = 0,
+  ESM_MODULE_FORMAT_ESM,
+  ESM_MODULE_FORMAT_CJS,
+} esm_module_format_t;
+
+typedef struct esm_module {
+  char *path;
+  char *resolved_path;
+  char *url_content;
+  size_t url_content_len;
+  jsval_t namespace_obj;
+  jsval_t default_export;
+  UT_hash_handle hh;
+  esm_module_kind_t kind;
+  esm_module_format_t format;
+  bool is_loaded;
+  bool is_loading;
+} esm_module_t;
+
+typedef struct {
+  esm_module_t *modules;
+  int count;
+} esm_module_cache_t;
+
+typedef struct {
+  char *data;
+  size_t size;
+} esm_file_data_t;
+
+static esm_module_cache_t global_module_cache = {NULL, 0};
+static char *esm_resolve_node_module(const char *specifier, const char *base_path);
+
+static jsval_t esm_get_import_meta_raw(ant_t *js) {
+  jsval_t import_fn = js_get(js, js->global, "import");
+  if (vtype(import_fn) != T_FUNC) return js_mkundef();
+  return js_get(js, js_func_obj(import_fn), "meta");
+}
+
+static void esm_set_import_meta_main_flag(ant_t *js, bool is_main) {
+  jsval_t meta = esm_get_import_meta_raw(js);
+  if (vtype(meta) != T_OBJ) return;
+  js_set(js, meta, "main", is_main ? js_true : js_false);
+}
+
+static char *esm_file_url_to_path(const char *specifier) {
+  if (!specifier || strncmp(specifier, "file:", 5) != 0) return NULL;
+
+  const char *p = specifier + 5;
+  if (strncmp(p, "///", 3) == 0) p += 2;
+  else if (strncmp(p, "//localhost/", 12) == 0) p += 11;
+
+  if (*p == '\0') return NULL;
+  return strdup(p);
+}
+
+static char *esm_get_extension(const char *path) {
+  const char *dot = strrchr(path, '.');
+  const char *slash = strrchr(path, '/');
+
+  if (dot && (!slash || dot > slash)) {
+    return strdup(dot);
+  }
+  return strdup(".js");
+}
+
+static bool esm_is_relative_specifier(const char *specifier) {
+  return 
+    strcmp(specifier, ".") == 0 ||
+    strcmp(specifier, "..") == 0 ||
+    strncmp(specifier, "./", 2) == 0 ||
+    strncmp(specifier, "../", 3) == 0;
+}
+
+static char *esm_try_resolve(const char *dir, const char *spec, const char *suffix) {
+  char path[PATH_MAX];
+  snprintf(path, PATH_MAX, "%s/%s%s", dir, spec, suffix);
+  char *resolved = realpath(path, NULL);
+  if (resolved) {
+    struct stat st;
+    if (stat(resolved, &st) == 0 && S_ISREG(st.st_mode)) return resolved;
+    free(resolved);
+  }
+  return NULL;
+}
+
+static bool esm_has_extension(const char *spec) {
+  const char *slash = strrchr(spec, '/');
+  const char *dot = strrchr(slash ? slash : spec, '.');
+  
+  if (!dot) return false;
+  for (
+    const char *const *ext = module_resolve_extensions; 
+    *ext; ext++
+  ) if (strcmp(dot, *ext) == 0) return true;
+  
+  return false;
+}
+
+static char *esm_try_resolve_with_exts(const char *dir, const char *spec, bool has_ext) {
+  const char *const *exts = module_resolve_extensions;
+  char *result = NULL;
+
+  if ((result = esm_try_resolve(dir, spec, ""))) return result;
+  if (has_ext) return NULL;
+
+  for (int i = 0; exts[i]; i++) {
+    if ((result = esm_try_resolve(dir, spec, exts[i]))) return result;
+  }
+  return NULL;
+}
+
+static char *esm_try_resolve_index_with_exts(const char *dir, const char *spec) {
+  char idx[PATH_MAX];
+  snprintf(idx, sizeof(idx), "%s/index", spec);
+  return esm_try_resolve_with_exts(dir, idx, false);
+}
+
+static char *esm_try_resolve_from_extension_list(
+  const char *dir,
+  const char *spec,
+  const char *first_ext,
+  const char *skip_ext
+) {
+  char *result = NULL;
+  if (first_ext && first_ext[0]) {
+    if ((result = esm_try_resolve(dir, spec, first_ext))) return result;
+  }
+
+  const char *const *exts = module_resolve_extensions;
+  for (int i = 0; exts[i]; i++) {
+    if (skip_ext && strcmp(skip_ext, exts[i]) == 0) continue;
+    if ((result = esm_try_resolve(dir, spec, exts[i]))) return result;
+  }
+  return NULL;
+}
+
+static char *esm_resolve_absolute(const char *specifier) {
+  char *result = esm_try_resolve_with_exts("", specifier, esm_has_extension(specifier));
+  if (result) return result;
+  return esm_try_resolve_index_with_exts("", specifier);
+}
+
+static char *esm_get_base_dir(const char *base_path) {
+  if (!base_path || !base_path[0]) {
+    char cwd[PATH_MAX];
+    if (!getcwd(cwd, sizeof(cwd))) return NULL;
+    return strdup(cwd);
+  }
+
+  char candidate[PATH_MAX];
+  if (base_path[0] == '/') {
+    snprintf(candidate, sizeof(candidate), "%s", base_path);
+  } else {
+    char cwd[PATH_MAX];
+    if (!getcwd(cwd, sizeof(cwd))) return NULL;
+    snprintf(candidate, sizeof(candidate), "%s/%s", cwd, base_path);
+  }
+
+  char *resolved = realpath(candidate, NULL);
+  const char *resolved_or_candidate = resolved ? resolved : candidate;
+
+  struct stat st;
+  if (stat(resolved_or_candidate, &st) == 0 && S_ISDIR(st.st_mode)) {
+    char *out = realpath(resolved_or_candidate, NULL);
+    if (!out) out = strdup(resolved_or_candidate);
+    if (resolved) free(resolved);
+    return out;
+  }
+
+  char *tmp = strdup(resolved_or_candidate);
+  if (resolved) free(resolved);
+  if (!tmp) return NULL;
+
+  char *dir = dirname(tmp);
+  char *out = realpath(dir, NULL);
+  if (!out) out = strdup(dir);
+  
+  free(tmp);
+  return out;
+}
+
+static bool esm_split_package_specifier(
+  const char *specifier,
+  char *package_name,
+  size_t package_name_size,
+  const char **subpath_out
+) {
+  if (!specifier || !specifier[0]) return false;
+  if (specifier[0] == '.' || specifier[0] == '/' || specifier[0] == '#') return false;
+
+  const char *slash = NULL;
+  if (specifier[0] == '@') {
+    const char *first = strchr(specifier, '/');
+    if (!first || first == specifier + 1) return false;
+    slash = strchr(first + 1, '/');
+    if (first[1] == '\0') return false;
+    if (!slash) {
+      if (strlen(specifier) >= package_name_size) return false;
+      strcpy(package_name, specifier);
+      *subpath_out = NULL;
+      return true;
+    }
+  } else slash = strchr(specifier, '/');
+
+  size_t name_len = slash ? (size_t)(slash - specifier) : strlen(specifier);
+  if (name_len == 0 || name_len >= package_name_size) return false;
+  memcpy(package_name, specifier, name_len);
+  package_name[name_len] = '\0';
+
+  if (slash && slash[1] != '\0') *subpath_out = slash + 1;
+  else *subpath_out = NULL;
+  
+  return true;
+}
+
+static char *esm_find_node_module_dir(const char *start_dir, const char *package_name) {
+  if (!start_dir || !package_name) return NULL;
+
+  char current[PATH_MAX];
+  snprintf(current, sizeof(current), "%s", start_dir);
+
+  while (true) {
+    char candidate[PATH_MAX];
+    snprintf(candidate, sizeof(candidate), "%s/node_modules/%s", current, package_name);
+
+    struct stat st;
+    if (stat(candidate, &st) == 0 && S_ISDIR(st.st_mode)) {
+      char *resolved = realpath(candidate, NULL);
+      return resolved ? resolved : strdup(candidate);
+    }
+
+    if (strcmp(current, "/") == 0) break;
+    char *slash = strrchr(current, '/');
+    
+    if (!slash) break;
+    if (slash == current) current[1] = '\0';
+    else *slash = '\0';
+  }
+  
+  return NULL;
+}
+
+static bool esm_matches_pattern_key(const char *key, const char *request, const char **capture, size_t *capture_len) {
+  const char *star = strchr(key, '*');
+  if (!star) return false;
+
+  size_t key_len = strlen(key);
+  size_t req_len = strlen(request);
+  size_t prefix_len = (size_t)(star - key);
+  size_t suffix_len = key_len - prefix_len - 1;
+  
+  if (req_len < prefix_len + suffix_len) return false;
+  if (strncmp(request, key, prefix_len) != 0) return false;
+  if (suffix_len > 0 && strcmp(request + req_len - suffix_len, star + 1) != 0) return false;
+
+  *capture = request + prefix_len;
+  *capture_len = req_len - prefix_len - suffix_len;
+  
+  return true;
+}
+
+static char *esm_replace_star(const char *pattern, const char *capture, size_t capture_len) {
+  const char *star = strchr(pattern, '*');
+  if (!star) return strdup(pattern);
+
+  size_t prefix_len = (size_t)(star - pattern);
+  size_t suffix_len = strlen(star + 1);
+  size_t out_len = prefix_len + capture_len + suffix_len;
+  char *out = (char *)malloc(out_len + 1);
+  if (!out) return NULL;
+
+  memcpy(out, pattern, prefix_len);
+  memcpy(out + prefix_len, capture, capture_len);
+  memcpy(out + prefix_len + capture_len, star + 1, suffix_len);
+  out[out_len] = '\0';
+  
+  return out;
+}
+
+static char *esm_resolve_exports_target(
+  yyjson_val *target,
+  const char *package_dir,
+  const char *capture,
+  size_t capture_len,
+  const char *base_path,
+  bool allow_bare_specifiers
+) {
+  if (!target) return NULL;
+
+  if (yyjson_is_str(target)) {
+    const char *target_str = yyjson_get_str(target);
+    if (!target_str || !target_str[0]) return NULL;
+
+    if (target_str[0] == '.' && target_str[1] == '/') {
+      char *mapped = esm_replace_star(target_str + 2, capture, capture_len);
+      if (!mapped) return NULL;
+
+      char *resolved = esm_try_resolve_with_exts(package_dir, mapped, esm_has_extension(mapped));
+      if (!resolved) resolved = esm_try_resolve_index_with_exts(package_dir, mapped);
+      free(mapped);
+      return resolved;
+    }
+
+    if (!allow_bare_specifiers) return NULL;
+    if (target_str[0] == '#') return NULL;
+    return esm_resolve_node_module(target_str, base_path);
+  }
+
+  if (yyjson_is_arr(target)) {
+    size_t idx, max;
+    yyjson_val *item;
+    yyjson_arr_foreach(target, idx, max, item) {
+      char *resolved = esm_resolve_exports_target(
+        item, package_dir, capture,
+        capture_len, base_path, allow_bare_specifiers
+      );
+      if (resolved) return resolved;
+    }
+    return NULL;
+  }
+
+  if (yyjson_is_obj(target)) {
+    static const char *const conditions[] = {"import", "node", "default"};
+
+    for (size_t i = 0; i < sizeof(conditions) / sizeof(conditions[0]); i++) {
+      yyjson_val *cond_target = yyjson_obj_get(target, conditions[i]);
+      if (!cond_target) continue;
+      char *resolved = esm_resolve_exports_target(
+        cond_target, package_dir, capture,
+        capture_len, base_path, allow_bare_specifiers
+      );
+      if (resolved) return resolved;
+    }
+  }
+
+  return NULL;
+}
+
+static char *esm_resolve_package_map(
+  yyjson_val *map_obj,
+  const char *request_key,
+  const char *package_dir,
+  const char *base_path,
+  bool allow_bare_specifiers
+) {
+  if (!map_obj || !yyjson_is_obj(map_obj)) return NULL;
+
+  yyjson_val *exact = yyjson_obj_get(map_obj, request_key);
+  if (exact) return esm_resolve_exports_target(
+    exact, package_dir, "", 0, 
+    base_path, allow_bare_specifiers
+  );
+
+  const char *best_capture = NULL;
+  size_t best_capture_len = 0;
+  
+  yyjson_val *best_target = NULL;
+  size_t best_prefix_len = 0;
+
+  size_t idx, max;
+  yyjson_val *k, *v;
+  
+  yyjson_obj_foreach(map_obj, idx, max, k, v) {
+    if (!yyjson_is_str(k)) continue;
+    const char *key = yyjson_get_str(k);
+    if (!key) continue;
+
+    const char *capture = NULL;
+    size_t capture_len = 0;
+    if (!esm_matches_pattern_key(key, request_key, &capture, &capture_len)) continue;
+
+    const char *star = strchr(key, '*');
+    size_t prefix_len = (size_t)(star - key);
+    if (best_target && prefix_len < best_prefix_len) continue;
+
+    best_target = v;
+    best_capture = capture;
+    best_capture_len = capture_len;
+    best_prefix_len = prefix_len;
+  }
+
+  if (!best_target) return NULL;
+  return esm_resolve_exports_target(
+    best_target, package_dir, best_capture,
+    best_capture_len, base_path, allow_bare_specifiers
+  );
+}
+
+static char *esm_resolve_package_main_entry(yyjson_val *root, const char *package_dir) {
+  if (!root || !yyjson_is_obj(root)) return NULL;
+
+  yyjson_val *main = yyjson_obj_get(root, "main");
+  if (!main || !yyjson_is_str(main)) return NULL;
+
+  const char *main_str = yyjson_get_str(main);
+  if (!main_str || !main_str[0]) return NULL;
+
+  char *resolved = esm_try_resolve_with_exts(package_dir, main_str, esm_has_extension(main_str));
+  if (!resolved) resolved = esm_try_resolve_index_with_exts(package_dir, main_str);
+  return resolved;
+}
+
+static char *esm_resolve_package_entrypoint(const char *package_dir, const char *subpath, const char *base_path) {
+  char pkg_json_path[PATH_MAX];
+  snprintf(pkg_json_path, sizeof(pkg_json_path), "%s/package.json", package_dir);
+
+  yyjson_doc *doc = yyjson_read_file(pkg_json_path, 0, NULL, NULL);
+  yyjson_val *root = doc ? yyjson_doc_get_root(doc) : NULL;
+  yyjson_val *exports = (root && yyjson_is_obj(root)) ? yyjson_obj_get(root, "exports") : NULL;
+
+  if (exports) {
+    char subpath_key[PATH_MAX];
+    if (subpath && subpath[0]) snprintf(subpath_key, sizeof(subpath_key), "./%s", subpath);
+    else snprintf(subpath_key, sizeof(subpath_key), ".");
+
+    char *resolved = NULL;
+    if (yyjson_is_obj(exports)) {
+      bool has_subpath_keys = false;
+      size_t idx, max;
+      yyjson_val *k, *v;
+      yyjson_obj_foreach(exports, idx, max, k, v) {
+        if (!yyjson_is_str(k)) continue;
+        const char *key = yyjson_get_str(k);
+        if (key && key[0] == '.') { has_subpath_keys = true; break; }
+      }
+      if (has_subpath_keys) resolved = esm_resolve_package_map(exports, subpath_key, package_dir, base_path, false);
+      else if (!subpath || !subpath[0]) resolved = esm_resolve_exports_target(exports, package_dir, "", 0, base_path, false);
+    } else if (!subpath || !subpath[0]) resolved = esm_resolve_exports_target(exports, package_dir, "", 0, base_path, false);
+
+    if (doc) yyjson_doc_free(doc);
+    return resolved;
+  }
+
+  if (!subpath || !subpath[0]) {
+    char *resolved = esm_resolve_package_main_entry(root, package_dir);
+    if (resolved) {
+      if (doc) yyjson_doc_free(doc);
+      return resolved;
+    }
+    if (doc) yyjson_doc_free(doc);
+    return esm_try_resolve_index_with_exts(package_dir, ".");
+  }
+
+  char *resolved = esm_try_resolve_with_exts(package_dir, subpath, esm_has_extension(subpath));
+  if (!resolved) resolved = esm_try_resolve_index_with_exts(package_dir, subpath);
+  if (doc) yyjson_doc_free(doc);
+  return resolved;
+}
+
+static char *esm_resolve_package_imports(const char *specifier, const char *base_path) {
+  char *start_dir = esm_get_base_dir(base_path);
+  if (!start_dir) return NULL;
+
+  char current[PATH_MAX];
+  snprintf(current, sizeof(current), "%s", start_dir);
+  free(start_dir);
+
+  while (true) {
+    char pkg_json_path[PATH_MAX];
+    snprintf(pkg_json_path, sizeof(pkg_json_path), "%s/package.json", current);
+
+    yyjson_doc *doc = yyjson_read_file(pkg_json_path, 0, NULL, NULL);
+    if (doc) {
+      yyjson_val *root = yyjson_doc_get_root(doc);
+      yyjson_val *imports = (root && yyjson_is_obj(root)) ? yyjson_obj_get(root, "imports") : NULL;
+      char *resolved = NULL;
+      if (imports && yyjson_is_obj(imports)) {
+        resolved = esm_resolve_package_map(imports, specifier, current, base_path, true);
+      }
+      yyjson_doc_free(doc);
+      return resolved;
+    }
+
+    if (strcmp(current, "/") == 0) break;
+    char *slash = strrchr(current, '/');
+    if (!slash) break;
+    if (slash == current) current[1] = '\0';
+    else *slash = '\0';
+  }
+
+  return NULL;
+}
+
+static char *esm_resolve_node_module(const char *specifier, const char *base_path) {
+  char package_name[PATH_MAX];
+  const char *subpath = NULL;
+  if (!esm_split_package_specifier(specifier, package_name, sizeof(package_name), &subpath)) {
+    return NULL;
+  }
+
+  char *start_dir = esm_get_base_dir(base_path);
+  if (!start_dir) return NULL;
+
+  char *package_dir = esm_find_node_module_dir(start_dir, package_name);
+  free(start_dir);
+  if (!package_dir) return NULL;
+
+  char *resolved = esm_resolve_package_entrypoint(package_dir, subpath, base_path);
+  free(package_dir);
+  return resolved;
+}
+
+static char *esm_resolve_relative_path(const char *specifier, const char *base_path) {
+  char *base_copy = strdup(base_path);
+  if (!base_copy) return NULL;
+  char *dir = dirname(base_copy);
+  char *result = NULL;
+
+  const char *spec = specifier;
+  if (strncmp(specifier, "./", 2) == 0) spec = specifier + 2;
+  bool has_ext = esm_has_extension(spec);
+
+  if ((result = esm_try_resolve(dir, spec, ""))) goto cleanup;
+  if (has_ext) goto cleanup;
+
+  char *base_ext = esm_get_extension(base_path);
+  if (!base_ext) goto cleanup;
+
+  if ((result = esm_try_resolve_from_extension_list(dir, spec, base_ext, base_ext))) goto cleanup_ext;
+
+  char idx[PATH_MAX];
+  snprintf(idx, sizeof(idx), "%s/index%s", spec, base_ext);
+  if ((result = esm_try_resolve(dir, idx, ""))) goto cleanup_ext;
+
+  snprintf(idx, sizeof(idx), "%s/index", spec);
+  if ((result = esm_try_resolve_from_extension_list(dir, idx, base_ext, base_ext))) goto cleanup_ext;
+
+  cleanup_ext: {
+    free(base_ext);
+  }
+  
+  cleanup: {
+    free(base_copy);
+    return result;
+  }
+}
+
+static char *esm_resolve_path(const char *specifier, const char *base_path) {
+  if (!specifier || !specifier[0]) return NULL;
+
+  if (specifier[0] == '/') {
+    return esm_resolve_absolute(specifier);
+  }
+
+  if (esm_is_relative_specifier(specifier)) {
+    return esm_resolve_relative_path(specifier, base_path);
+  }
+
+  if (specifier[0] == '#') {
+    return esm_resolve_package_imports(specifier, base_path);
+  }
+
+  return esm_resolve_node_module(specifier, base_path);
+}
+
+static bool esm_has_suffix(const char *path, const char *ext) {
+  size_t len = strlen(path);
+  size_t elen = strlen(ext);
+  return len > elen && strcmp(path + len - elen, ext) == 0;
+}
+
+static inline bool esm_is_json(const char *path) {
+  return esm_has_suffix(path, ".json");
+}
+
+static inline bool esm_is_text(const char *path) {
+  return 
+    esm_has_suffix(path, ".txt") ||
+    esm_has_suffix(path, ".md") ||
+    esm_has_suffix(path, ".html") ||
+    esm_has_suffix(path, ".css");
+}
+
+static inline bool esm_is_image(const char *path) {
+  return
+    esm_has_suffix(path, ".png") ||
+    esm_has_suffix(path, ".jpg") ||
+    esm_has_suffix(path, ".jpeg") ||
+    esm_has_suffix(path, ".gif") ||
+    esm_has_suffix(path, ".svg") ||
+    esm_has_suffix(path, ".webp");
+}
+
+static inline bool esm_is_native(const char *path) {
+  return esm_has_suffix(path, ".node");
+}
+
+static inline bool esm_is_cjs_extension(const char *path) {
+  return
+    esm_has_suffix(path, ".cjs") ||
+    esm_has_suffix(path, ".cts");
+}
+
+static inline bool esm_is_esm_extension(const char *path) {
+  return
+    esm_has_suffix(path, ".mjs") ||
+    esm_has_suffix(path, ".mts");
+}
+
+static bool esm_path_contains_node_modules(const char *path) {
+  if (!path) return false;
+  if (strstr(path, "/node_modules/")) return true;
+  return strstr(path, "\\node_modules\\") != NULL;
+}
+
+static bool esm_read_package_json_type_module(const char *pkg_json_path, bool *has_type) {
+  if (has_type) *has_type = false;
+
+  yyjson_doc *doc = yyjson_read_file(pkg_json_path, 0, NULL, NULL);
+  if (!doc) return false;
+
+  yyjson_val *root = yyjson_doc_get_root(doc);
+  yyjson_val *type = (root && yyjson_is_obj(root)) ? yyjson_obj_get(root, "type") : NULL;
+
+  if (!type || !yyjson_is_str(type)) {
+    yyjson_doc_free(doc);
+    return false;
+  }
+
+  const char *type_str = yyjson_get_str(type);
+  if (has_type) *has_type = true;
+
+  bool is_module = type_str && strcmp(type_str, "module") == 0;
+  yyjson_doc_free(doc);
+  
+  return is_module;
+}
+
+static bool esm_lookup_package_type_module(const char *resolved_path, bool *is_module) {
+  if (is_module) *is_module = false;
+  if (!resolved_path || !resolved_path[0]) return false;
+
+  char path_copy[PATH_MAX];
+  snprintf(path_copy, sizeof(path_copy), "%s", resolved_path);
+  char *dir = dirname(path_copy);
+  if (!dir || !dir[0]) return false;
+
+  char current[PATH_MAX];
+  snprintf(current, sizeof(current), "%s", dir);
+
+  while (true) {
+    char pkg_json_path[PATH_MAX];
+    snprintf(pkg_json_path, sizeof(pkg_json_path), "%s/package.json", current);
+
+    struct stat st;
+    if (stat(pkg_json_path, &st) == 0 && S_ISREG(st.st_mode)) {
+      bool has_type = false;
+      bool pkg_is_module = esm_read_package_json_type_module(pkg_json_path, &has_type);
+      if (is_module) *is_module = has_type && pkg_is_module;
+      return true;
+    }
+
+    if (strcmp(current, "/") == 0) break;
+    char *slash = strrchr(current, '/');
+    if (!slash) break;
+    if (slash == current) current[1] = '\0';
+    else *slash = '\0';
+  }
+
+  return false;
+}
+
+static esm_module_format_t esm_decide_module_format(const char *resolved_path) {
+  if (!resolved_path || !resolved_path[0]) return ESM_MODULE_FORMAT_ESM;
+  if (esm_is_cjs_extension(resolved_path)) return ESM_MODULE_FORMAT_CJS;
+  if (esm_is_esm_extension(resolved_path)) return ESM_MODULE_FORMAT_ESM;
+
+  if (esm_has_suffix(resolved_path, ".js") && esm_path_contains_node_modules(resolved_path)) {
+    bool pkg_is_module = false;
+    bool has_package_json = esm_lookup_package_type_module(resolved_path, &pkg_is_module);
+    if (!has_package_json) return ESM_MODULE_FORMAT_CJS;
+    return pkg_is_module ? ESM_MODULE_FORMAT_ESM : ESM_MODULE_FORMAT_CJS;
+  }
+
+  return ESM_MODULE_FORMAT_ESM;
+}
+
+static jsval_t esm_eval_module_with_format(
+  ant_t *js,
+  const char *resolved_path,
+  const char *js_code,
+  size_t js_len,
+  jsval_t ns,
+  esm_module_format_t format
+) {
+  if (format == ESM_MODULE_FORMAT_CJS) {
+    return esm_load_commonjs_module(js, resolved_path, js_code, js_len, ns);
+  }
+  return js_eval_bytecode_module(js, js_code, js_len);
+}
+
+jsval_t js_esm_eval_module_source(
+  ant_t *js,
+  const char *resolved_path,
+  const char *js_code,
+  size_t js_len,
+  jsval_t ns
+) {
+  esm_module_format_t format = esm_decide_module_format(resolved_path);
+  jsval_t prev_module = js->module_ns;
+  js->module_ns = ns;
+
+  jsval_t result = esm_eval_module_with_format(
+    js, resolved_path, js_code, js_len, ns, format
+  );
+  
+  js->module_ns = prev_module;
+  return result;
+}
+
+static esm_module_kind_t esm_classify_module_kind(const char *resolved_path) {
+  if (esm_is_data_url(resolved_path)) return ESM_MODULE_KIND_URL;
+  if (esm_is_url(resolved_path)) return ESM_MODULE_KIND_URL;
+  if (esm_is_json(resolved_path)) return ESM_MODULE_KIND_JSON;
+  if (esm_is_text(resolved_path)) return ESM_MODULE_KIND_TEXT;
+  if (esm_is_image(resolved_path)) return ESM_MODULE_KIND_IMAGE;
+  if (esm_is_native(resolved_path)) return ESM_MODULE_KIND_NATIVE;
+  return ESM_MODULE_KIND_CODE;
+}
+
+static char *esm_canonicalize_path(const char *path) {
+  if (!path) return NULL;
+
+  char *canonical = strdup(path);
+  if (!canonical) return NULL;
+
+  char *src = canonical, *dst = canonical;
+
+  while (*src) {
+    if (*src == '/') {
+      *dst++ = '/';
+      while (*src == '/') src++;
+
+      if (strncmp(src, "./", 2) == 0) {
+        src += 2;
+      } else if (strncmp(src, "../", 3) == 0) {
+        src += 3;
+        if (dst > canonical + 1) {
+          dst--;
+          while (dst > canonical && *(dst - 1) != '/') dst--;
+        }
+      }
+    } else {
+      *dst++ = *src++;
+    }
+  }
+
+  *dst = '\0';
+
+  if (strlen(canonical) > 1 && canonical[strlen(canonical) - 1] == '/') {
+    canonical[strlen(canonical) - 1] = '\0';
+  }
+
+  return canonical;
+}
+
+static esm_module_t *esm_find_module(const char *resolved_path) {
+  char *canonical_path = esm_canonicalize_path(resolved_path);
+  if (!canonical_path) return NULL;
+
+  esm_module_t *mod = NULL;
+  HASH_FIND_STR(global_module_cache.modules, canonical_path, mod);
+
+  free(canonical_path);
+  return mod;
+}
+
+static esm_module_t *esm_create_module(const char *path, const char *resolved_path) {
+  bool is_url = esm_is_url(resolved_path) || esm_is_data_url(resolved_path);
+  char *canonical_path = is_url ? strdup(resolved_path) : esm_canonicalize_path(resolved_path);
+  if (!canonical_path) return NULL;
+
+  esm_module_t *existing_mod = NULL;
+  HASH_FIND_STR(global_module_cache.modules, canonical_path, existing_mod);
+  if (existing_mod) {
+    free(canonical_path);
+    return existing_mod;
+  }
+
+  esm_module_t *mod = (esm_module_t *)malloc(sizeof(esm_module_t));
+  if (!mod) {
+    free(canonical_path);
+    return NULL;
+  }
+
+  *mod = (esm_module_t){
+    .path = strdup(path),
+    .resolved_path = canonical_path,
+    .namespace_obj = js_mkundef(),
+    .default_export = js_mkundef(),
+    .is_loaded = false,
+    .is_loading = false,
+    .kind = esm_classify_module_kind(resolved_path),
+    .format = ESM_MODULE_FORMAT_UNKNOWN,
+    .url_content = NULL,
+    .url_content_len = 0,
+  };
+
+  HASH_ADD_STR(global_module_cache.modules, resolved_path, mod);
+  global_module_cache.count++;
+
+  return mod;
+}
+
+void js_esm_cleanup_module_cache(void) {
+  esm_module_t *current, *tmp;
+  HASH_ITER(hh, global_module_cache.modules, current, tmp) {
+    HASH_DEL(global_module_cache.modules, current);
+    if (current->path) free(current->path);
+    if (current->resolved_path) free(current->resolved_path);
+    if (current->url_content) free(current->url_content);
+    free(current);
+  }
+  global_module_cache.count = 0;
+}
+
+void js_esm_gc_roots(void (*visit)(void *ctx, jsval_t *val), void *ctx) {
+  if (!visit) return;
+  esm_module_t *mod = NULL, *tmp = NULL;
+  HASH_ITER(hh, global_module_cache.modules, mod, tmp) {
+    visit(ctx, &mod->namespace_obj);
+    visit(ctx, &mod->default_export);
+  }
+}
+
+static jsval_t esm_read_file(ant_t *js, const char *path, const char *kind, esm_file_data_t *out) {
+  FILE *fp = fopen(path, "rb");
+  if (!fp) return js_mkerr(js, "Cannot open %s: %s", kind, path);
+
+  fseek(fp, 0, SEEK_END);
+  long fsize = ftell(fp);
+  fseek(fp, 0, SEEK_SET);
+
+  char *buf = (char *)malloc((size_t)fsize + 1);
+  if (!buf) {
+    fclose(fp);
+    return js_mkerr(js, "OOM loading %s", kind);
+  }
+
+  fread(buf, 1, (size_t)fsize, fp);
+  fclose(fp);
+  buf[fsize] = '\0';
+
+  out->data = buf;
+  out->size = (size_t)fsize;
+  return js_mkundef();
+}
+
+static jsval_t esm_load_json(ant_t *js, const char *path) {
+  esm_file_data_t file;
+  jsval_t err = esm_read_file(js, path, "JSON file", &file);
+  if (is_err(err)) return err;
+
+  jsval_t json_str = js_mkstr(js, file.data, file.size);
+  free(file.data);
+  return js_json_parse(js, &json_str, 1);
+}
+
+static jsval_t esm_load_text(ant_t *js, const char *path) {
+  esm_file_data_t file;
+  jsval_t err = esm_read_file(js, path, "text file", &file);
+  if (is_err(err)) return err;
+
+  jsval_t result = js_mkstr(js, file.data, file.size);
+  free(file.data);
+  return result;
+}
+
+static jsval_t esm_load_image(ant_t *js, const char *path) {
+  esm_file_data_t file;
+  jsval_t err = esm_read_file(js, path, "image file", &file);
+  if (is_err(err)) return err;
+
+  unsigned char *content = (unsigned char *)file.data;
+  size_t size = file.size;
+
+  jsval_t obj = js_mkobj(js);
+  jsval_t data_arr = js_mkarr(js);
+
+  for (size_t i = 0; i < size; i++) {
+    js_arr_push(js, data_arr, tov((double)content[i]));
+  }
+
+  js_setprop(js, obj, js_mkstr(js, "data", 4), data_arr);
+  js_setprop(js, obj, js_mkstr(js, "path", 4), js_mkstr(js, path, strlen(path)));
+  js_setprop(js, obj, js_mkstr(js, "size", 4), tov((double)size));
+
+  free(file.data);
+  return obj;
+}
+
+static jsval_t esm_load_module(ant_t *js, esm_module_t *mod) {
+  if (mod->is_loaded) return mod->namespace_obj;
+  if (mod->is_loading) return mod->namespace_obj;
+
+  mod->is_loading = true;
+
+  switch (mod->kind) {
+    case ESM_MODULE_KIND_JSON: {
+      jsval_t json_val = esm_load_json(js, mod->resolved_path);
+      if (is_err(json_val)) {
+        mod->is_loading = false;
+        return json_val;
+      }
+      mod->namespace_obj = json_val;
+      mod->default_export = json_val;
+      mod->is_loaded = true;
+      mod->is_loading = false;
+      return json_val;
+    }
+    case ESM_MODULE_KIND_TEXT: {
+      jsval_t text_val = esm_load_text(js, mod->resolved_path);
+      if (is_err(text_val)) {
+        mod->is_loading = false;
+        return text_val;
+      }
+      mod->namespace_obj = text_val;
+      mod->default_export = text_val;
+      mod->is_loaded = true;
+      mod->is_loading = false;
+      return text_val;
+    }
+    case ESM_MODULE_KIND_IMAGE: {
+      jsval_t img_val = esm_load_image(js, mod->resolved_path);
+      if (is_err(img_val)) {
+        mod->is_loading = false;
+        return img_val;
+      }
+      mod->namespace_obj = img_val;
+      mod->default_export = img_val;
+      mod->is_loaded = true;
+      mod->is_loading = false;
+      return img_val;
+    }
+    case ESM_MODULE_KIND_NATIVE: {
+      jsval_t ns = js_mkobj(js);
+      mod->namespace_obj = ns;
+
+      jsval_t native_exports = napi_load_native_module(js, mod->resolved_path, ns);
+      if (is_err(native_exports)) {
+        mod->is_loading = false;
+        return native_exports;
+      }
+
+      jsval_t default_val = js_get_slot(js, ns, SLOT_DEFAULT);
+      mod->default_export = vtype(default_val) != T_UNDEF ? default_val : ns;
+      mod->is_loaded = true;
+      mod->is_loading = false;
+      return ns;
+    }
+    case ESM_MODULE_KIND_CODE:
+    case ESM_MODULE_KIND_URL:
+      break;
+  }
+
+  char *content = NULL;
+  size_t size = 0;
+
+  if (mod->kind == ESM_MODULE_KIND_URL && esm_is_data_url(mod->resolved_path)) {
+    content = esm_parse_data_url(mod->resolved_path, &size);
+    if (!content) {
+      mod->is_loading = false;
+      return js_mkerr(js, "Cannot parse data URL module");
+    }
+  } else if (mod->kind == ESM_MODULE_KIND_URL) {
+    if (mod->url_content) {
+      content = strdup(mod->url_content);
+      size = mod->url_content_len;
+    } else {
+      char *error = NULL;
+      content = esm_fetch_url(mod->resolved_path, &size, &error);
+      if (!content) {
+        mod->is_loading = false;
+        jsval_t err = js_mkerr(js, "Cannot fetch module %s: %s", mod->resolved_path, error ? error : "unknown error");
+        if (error) free(error);
+        return err;
+      }
+      mod->url_content = strdup(content);
+      mod->url_content_len = size;
+    }
+  } else {
+    esm_file_data_t file;
+    jsval_t err = esm_read_file(js, mod->resolved_path, "module", &file);
+    if (is_err(err)) {
+      mod->is_loading = false;
+      return err;
+    }
+    content = file.data;
+    size = file.size;
+  }
+  content[size] = '\0';
+
+  size_t js_len = size;
+  const char *strip_detail = NULL;
+  
+  int strip_result = strip_typescript_inplace(
+    &content, size, mod->resolved_path, &js_len, &strip_detail
+  );
+  
+  if (strip_result < 0) {
+    jsval_t err = js_mkerr(
+      js, "TypeScript error: strip failed (%d): %s",
+      strip_result, strip_detail
+    );
+    
+    free(content); 
+    mod->is_loading = false;
+    
+    return err;
+  }
+  
+  char *js_code = content;
+  jsval_t ns = js_mkobj(js);
+  mod->namespace_obj = ns;
+  
+  jsval_t prev_module = js->module_ns;
+  js->module_ns = ns;
+
+  const char *prev_filename = js->filename;
+  jshdl_t prev_import_meta_h = js_root(js, js->import_meta);
+  
+  js_set_filename(js, mod->resolved_path);
+  js_setup_import_meta(js, mod->resolved_path);
+  
+  esm_set_import_meta_main_flag(js, false);
+  js->import_meta = esm_get_import_meta_raw(js);
+
+  if (mod->format == ESM_MODULE_FORMAT_UNKNOWN) {
+    mod->format = esm_decide_module_format(mod->resolved_path);
+  }
+
+  jsval_t result = esm_eval_module_with_format(
+    js, mod->resolved_path, js_code, js_len, ns, mod->format
+  );
+  
+  free(content);
+  if (vtype(result) == T_PROMISE) js_run_event_loop(js);
+
+  js->import_meta = js_deref(js, prev_import_meta_h);
+  js_unroot(js, prev_import_meta_h);
+  js_set_filename(js, prev_filename);
+  js->module_ns = prev_module;
+
+  if (is_err(result)) {
+    mod->is_loading = false;
+    return result;
+  }
+
+  jsval_t default_val = js_get_slot(js, ns, SLOT_DEFAULT);
+  mod->default_export = vtype(default_val) != T_UNDEF ? default_val : ns;
+
+  mod->is_loaded = true;
+  mod->is_loading = false;
+
+  return ns;
+}
+
+static jsval_t esm_get_or_load(ant_t *js, const char *specifier, const char *resolved_path) {
+  esm_module_t *mod = esm_find_module(resolved_path);
+  if (!mod) {
+    mod = esm_create_module(specifier, resolved_path);
+    if (!mod) return js_mkerr(js, "Cannot create module");
+  }
+  return esm_load_module(js, mod);
+}
+
+jsval_t js_esm_import_sync_cstr(ant_t *js, const char *specifier, size_t spec_len) {
+  char *spec_copy = strndup(specifier, spec_len);
+  if (!spec_copy) return js_mkerr(js, "oom");
+
+  char *file_url_path = esm_file_url_to_path(spec_copy);
+  if (file_url_path) {
+    free(spec_copy);
+    spec_copy = file_url_path;
+  }
+
+  bool loaded = false;
+  jsval_t lib = js_esm_load_registered_library(js, spec_copy, spec_len, &loaded);
+  if (loaded) {
+    free(spec_copy);
+    return lib;
+  }
+
+  const char *base_path = js->filename ? js->filename : ".";
+  char *resolved_path = esm_resolve(spec_copy, base_path, esm_resolve_path);
+  if (!resolved_path) {
+    jsval_t err = js_mkerr(js, "Cannot resolve module: %s", spec_copy);
+    free(spec_copy);
+    return err;
+  }
+
+  jsval_t ns = esm_get_or_load(js, spec_copy, resolved_path);
+  free(resolved_path);
+  free(spec_copy);
+  return ns;
+}
+
+jsval_t js_esm_import_sync(ant_t *js, jsval_t specifier) {
+  if (vtype(specifier) != T_STR)
+    return js_mkerr(js, "import() requires a string specifier");
+
+  jsoff_t spec_len = 0;
+  jsoff_t spec_off = vstr(js, specifier, &spec_len);
+  const char *spec_str = (const char *)&js->mem[spec_off];
+
+  return js_esm_import_sync_cstr(js, spec_str, (size_t)spec_len);
+}
+
+jsval_t js_esm_make_file_url(ant_t *js, const char *path) {
+  size_t url_len = strlen(path) + 8;
+  char *url = malloc(url_len);
+  if (!url) return js_mkerr(js, "oom");
+
+  snprintf(url, url_len, "file://%s", path);
+  jsval_t val = js_mkstr(js, url, strlen(url));
+  free(url);
+  return val;
+}
+
+jsval_t js_esm_resolve_specifier(ant_t *js, jsval_t specifier, const char *base_path) {
+  if (vtype(specifier) != T_STR) {
+    return js_mkerr(js, "import.meta.resolve() requires a string specifier");
+  }
+
+  jsoff_t spec_len = 0;
+  jsoff_t spec_off = vstr(js, specifier, &spec_len);
+  const char *spec_str = (const char *)&js->mem[spec_off];
+  char *spec_copy = strndup(spec_str, (size_t)spec_len);
+  if (!spec_copy) return js_mkerr(js, "oom");
+
+  if (!base_path) base_path = js->filename ? js->filename : ".";
+  char *resolved_path = esm_resolve(spec_copy, base_path, esm_resolve_path);
+  free(spec_copy);
+
+  if (!resolved_path) {
+    return js_mkerr(js, "Cannot resolve module");
+  }
+
+  if (esm_is_url(resolved_path)) {
+    jsval_t result = js_mkstr(js, resolved_path, strlen(resolved_path));
+    free(resolved_path);
+    return result;
+  }
+
+  jsval_t result = js_esm_make_file_url(js, resolved_path);
+  free(resolved_path);
+  return result;
+}
diff --git a/src/esm/remote.c b/src/esm/remote.c
index f5f4ebc..0c03bd4 100644
--- a/src/esm/remote.c
+++ b/src/esm/remote.c
@@ -1,4 +1,6 @@
 #include "utils.h"
+#include "base64.h"
+#include "escape.h"
 #include "esm/remote.h"
 
 #include <stdio.h>
@@ -37,6 +39,58 @@ bool esm_is_url(const char *spec) {
   return (strncmp(spec, "http://", 7) == 0 || strncmp(spec, "https://", 8) == 0);
 }
 
+bool esm_is_data_url(const char *spec) {
+  return strncmp(spec, "data:", 5) == 0;
+}
+
+static char *esm_percent_decode(const char *src, size_t src_len, size_t *out_len) {
+  char *out = malloc(src_len + 1);
+  if (!out) return NULL;
+
+  size_t j = 0;
+  for (size_t i = 0; i < src_len; i++) {
+    if (src[i] == '%' && i + 2 < src_len &&
+        is_xdigit(src[i + 1]) && is_xdigit(src[i + 2])) {
+      out[j++] = (char)((unhex(src[i + 1]) << 4) | unhex(src[i + 2]));
+      i += 2;
+    } else out[j++] = src[i];
+  }
+
+  out[j] = '\0';
+  if (out_len) *out_len = j;
+  return out;
+}
+
+char *esm_parse_data_url(const char *url, size_t *out_len) {
+  if (!esm_is_data_url(url)) return NULL;
+
+  const char *comma = strchr(url + 5, ',');
+  if (!comma) return NULL;
+
+  const char *header = url + 5;
+  size_t header_len = (size_t)(comma - header);
+  
+  const char *body = comma + 1;
+  size_t body_len = strlen(body);
+
+  bool is_base64 = (header_len >= 7 && strncmp(comma - 7, ";base64", 7) == 0);
+  if (is_base64) {
+    uint8_t *decoded = ant_base64_decode(body, body_len, out_len);
+    if (!decoded) return NULL;
+    
+    char *result = malloc(*out_len + 1);
+    if (!result) { free(decoded); return NULL; }
+    
+    memcpy(result, decoded, *out_len);
+    result[*out_len] = '\0';
+    free(decoded);
+    
+    return result;
+  }
+
+  return esm_percent_decode(body, body_len, out_len);
+}
+
 static int is_path_sep(char c) {
   return c == '/' || c == '\\';
 }
@@ -126,9 +180,9 @@ static char *esm_get_cache_path(const char *url) {
   if (!cache_path) return NULL;
 
 #ifdef _WIN32
-  snprintf(cache_path, len, "%s\\.ant\\esm\\%016llx", home, (unsigned long long)hash);
+  snprintf(cache_path, len, "%s\\.ant\\remote\\%016llx", home, (unsigned long long)hash);
 #else
-  snprintf(cache_path, len, "%s/.ant/esm/%016llx", home, (unsigned long long)hash);
+  snprintf(cache_path, len, "%s/.ant/remote/%016llx", home, (unsigned long long)hash);
 #endif
   return cache_path;
 }
@@ -362,6 +416,7 @@ char *esm_resolve_url(const char *specifier, const char *base_url) {
 }
 
 char *esm_resolve(const char *specifier, const char *base_path, char FILE_RESOLVER) {
+  if (esm_is_data_url(specifier)) return strdup(specifier);
   if (esm_is_url(specifier) || esm_is_url(base_path)) return esm_resolve_url(specifier, base_path);
   return file_resolver(specifier, base_path);
 }
diff --git a/src/gc.c b/src/gc.c
index e596802..f09a05a 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -2,6 +2,8 @@
 #include "arena.h"
 #include "internal.h"
 #include "common.h"
+#include "sugar.h"
+#include "silver/engine.h"
 
 #include <string.h>
 #include <stdlib.h>
@@ -9,13 +11,23 @@
 #include <time.h>
 #include <setjmp.h>
 
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#include <sanitizer/asan_interface.h>
+#define ANT_HAS_ASAN 1
+#endif
+#endif
+
+#ifndef ANT_HAS_ASAN
+#define ANT_HAS_ASAN 0
+#endif
+
 #ifdef _WIN32
 #include <windows.h>
 static inline void *gc_mmap(size_t size) {
   return VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 }
 static inline void gc_munmap(void *ptr, size_t size) {
-  (void)size;
   VirtualFree(ptr, 0, MEM_RELEASE);
 }
 #else
@@ -32,24 +44,15 @@ static inline void gc_munmap(void *ptr, size_t size) {
 #define MCO_API extern
 #include "minicoro.h"
 
+uint32_t gc_epoch_counter;
 static uint8_t *gc_scratch_buf = NULL;
+
 static size_t gc_scratch_size = 0;
 static time_t gc_last_run_time = 0;
 
 static bool gc_throttled = false;
 void js_gc_throttle(bool enabled) { gc_throttled = enabled; }
 
-#define FWD_EMPTY ((jsoff_t)~0)
-#define FWD_TOMBSTONE ((jsoff_t)~1)
-
-#ifdef _WIN32
-#define RELEASE_PAGES(p, sz) VirtualAlloc(p, sz, MEM_RESET, PAGE_READWRITE)
-#elif defined(__APPLE__)
-#define RELEASE_PAGES(p, sz) madvise(p, sz, MADV_FREE)
-#else
-#define RELEASE_PAGES(p, sz) madvise(p, sz, MADV_DONTNEED)
-#endif
-
 typedef struct {
   jsoff_t *old_offs;
   jsoff_t *new_offs;
@@ -76,6 +79,34 @@ typedef struct {
 } gc_ctx_t;
 
 static jsval_t gc_update_val(gc_ctx_t *ctx, jsval_t val);
+static jsval_t gc_apply_val(gc_ctx_t *ctx, jsval_t val);
+
+/* inlined helpers from ant.c */
+static inline bool gc_func_const_count_sane(int n) {
+  return n >= 0 && n <= (1 << 20);
+}
+
+static inline bool gc_upvalue_is_closed(const sv_upvalue_t *uv) {
+  return uv && uv->location == &uv->closed;
+}
+
+static inline bool gc_is_tagged(jsval_t v) {
+  return v > NANBOX_PREFIX;
+}
+
+static inline uint8_t gc_vtype(jsval_t v) {
+  return gc_is_tagged(v) ? ((v >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK) : 255;
+}
+
+static inline size_t gc_vdata(jsval_t v) {
+  return (size_t)(v & NANBOX_DATA_MASK);
+}
+
+static inline jsval_t gc_mkval(uint8_t type, uint64_t data) {
+  return NANBOX_PREFIX 
+    | ((jsval_t)(type & NANBOX_TYPE_MASK) << NANBOX_TYPE_SHIFT)
+    | (data & NANBOX_DATA_MASK);
+}
 
 static inline void mark_set(gc_ctx_t *ctx, jsoff_t off) {
   jsoff_t idx = off >> 3;
@@ -92,6 +123,50 @@ static inline size_t next_pow2(size_t n) {
   return n + 1;
 }
 
+static void gc_update_func_constants(gc_ctx_t *ctx, sv_func_t *func, int depth) {
+  if (!func || depth > 1024) return;
+  if (func->gc_epoch == gc_epoch_counter) return;
+  
+  func->gc_epoch = gc_epoch_counter;
+  if (!func->constants || !gc_func_const_count_sane(func->const_count)) return;
+
+  for (int i = 0; i < func->const_count; i++) {
+    jsval_t c = func->constants[i];
+
+    if (vtype(c) == T_CFUNC) {
+      sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(c);
+      gc_update_func_constants(ctx, child, depth + 1);
+      continue;
+    }
+
+    func->constants[i] = gc_update_val(ctx, c);
+  }
+}
+
+static inline void gc_update_closure(gc_ctx_t *ctx, sv_closure_t *closure) {
+  if (!closure) return;
+  if (closure->gc_epoch == gc_epoch_counter) return;
+  
+  closure->gc_epoch = gc_epoch_counter;
+  closure->func_obj = gc_update_val(ctx, closure->func_obj);
+  closure->bound_this = gc_update_val(ctx, closure->bound_this);
+  
+  if (!closure->func) return;
+  gc_update_func_constants(ctx, closure->func, 0);
+  
+  if (!closure->upvalues) return;
+  int n = closure->func->upvalue_count;
+  if (n <= 0 || n > (int)UINT16_MAX) return;
+  
+  for (int i = 0; i < n; i++) {
+    sv_upvalue_t *uv = closure->upvalues[i];
+    if (!gc_upvalue_is_closed(uv)) continue;
+    if (uv->gc_epoch == gc_epoch_counter) continue;
+    uv->gc_epoch = gc_epoch_counter;
+    uv->closed = gc_update_val(ctx, uv->closed);
+  }
+}
+
 static bool fwd_init(gc_forward_table_t *fwd, size_t estimated) {
   size_t cap = next_pow2(estimated < 64 ? 64 : estimated);
   size_t size = cap * sizeof(jsoff_t);
@@ -268,22 +343,6 @@ static jsoff_t gc_alloc(gc_ctx_t *ctx, size_t size) {
   return off;
 }
 
-static inline bool gc_is_tagged(jsval_t v) {
-  return (v >> 53) == NANBOX_PREFIX_CHK;
-}
-
-static inline uint8_t gc_vtype(jsval_t v) {
-  return gc_is_tagged(v) ? ((v >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK) : 255;
-}
-
-static inline size_t gc_vdata(jsval_t v) {
-  return (size_t)(v & NANBOX_DATA_MASK);
-}
-
-static inline jsval_t gc_mkval(uint8_t type, uint64_t data) {
-  return NANBOX_PREFIX | ((jsval_t)(type & NANBOX_TYPE_MASK) << NANBOX_TYPE_SHIFT) | (data & NANBOX_DATA_MASK);
-}
-
 static jsoff_t gc_copy_string(gc_ctx_t *ctx, jsoff_t old_off) {
   if (old_off >= ctx->js->brk) return old_off;
   
@@ -347,6 +406,26 @@ static jsoff_t gc_copy_bigint(gc_ctx_t *ctx, jsoff_t old_off) {
   return new_off;
 }
 
+static jsoff_t gc_copy_symbol(gc_ctx_t *ctx, jsoff_t old_off) {
+  if (old_off >= ctx->js->brk) return old_off;
+  
+  jsoff_t new_off = fwd_lookup(&ctx->fwd, old_off);
+  if (new_off != (jsoff_t)~0) return new_off;
+  
+  jsoff_t header = gc_loadoff(ctx->js->mem, old_off);
+  size_t total = (header >> GC_SYM_HEADER_SHIFT) + sizeof(jsoff_t);
+  total = (total + 7) / 8 * 8;
+  
+  new_off = gc_alloc(ctx, total);
+  if (new_off == (jsoff_t)~0) return old_off;
+  
+  memcpy(&ctx->new_mem[new_off], &ctx->js->mem[old_off], total);
+  if (!fwd_add(&ctx->fwd, old_off, new_off)) ctx->failed = true;
+  mark_set(ctx, old_off);
+  
+  return new_off;
+}
+
 static jsoff_t gc_reserve_object(gc_ctx_t *ctx, jsoff_t old_off) {
   if (old_off >= ctx->js->brk) return old_off;
   
@@ -398,8 +477,8 @@ static void gc_process_prop(gc_ctx_t *ctx, jsoff_t old_off) {
   if (new_off == (jsoff_t)~0) return;
   
   jsoff_t header = gc_loadoff(ctx->js->mem, old_off);
-  
   jsoff_t next_prop = header & ~(3ULL | FLAGMASK);
+  
   if (next_prop != 0 && next_prop < ctx->js->brk) {
     jsoff_t new_next = gc_reserve_prop(ctx, next_prop);
     jsoff_t new_header = (new_next & ~3ULL) | (header & (3ULL | FLAGMASK));
@@ -411,7 +490,9 @@ static void gc_process_prop(gc_ctx_t *ctx, jsoff_t old_off) {
   if (!is_slot) {
     jsoff_t key_off = gc_loadoff(ctx->js->mem, old_off + sizeof(jsoff_t));
     if (key_off < ctx->js->brk) {
-      jsoff_t new_key = gc_copy_string(ctx, key_off);
+      jsoff_t key_hdr = gc_loadoff(ctx->js->mem, key_off); jsoff_t new_key;
+      if ((key_hdr & 3) == T_STR) new_key = gc_copy_string(ctx, key_off);
+      else new_key = gc_copy_symbol(ctx, key_off);
       gc_saveoff(ctx->new_mem, new_off + sizeof(jsoff_t), new_key);
     }
   }
@@ -500,7 +581,6 @@ static jsval_t gc_update_val(gc_ctx_t *ctx, jsval_t val) {
   
   switch (type) {
     case T_OBJ:
-    case T_FUNC:
     case T_ARR:
     case T_PROMISE:
     case T_GENERATOR: {
@@ -527,6 +607,17 @@ static jsval_t gc_update_val(gc_ctx_t *ctx, jsval_t val) {
       if (new_off != (jsoff_t)~0) return gc_mkval(type, new_off);
       break;
     }
+    case T_SYMBOL: {
+      if (old_off >= ctx->js->brk) return val;
+      jsoff_t new_off = gc_copy_symbol(ctx, old_off);
+      if (new_off != (jsoff_t)~0) return gc_mkval(type, new_off);
+      break;
+    }
+    case T_FUNC:
+    case T_CLOSURE: {
+      gc_update_closure(ctx, (sv_closure_t *)(uintptr_t)gc_vdata(val));
+      return val;
+    }
     default: break;
   }
   
@@ -571,18 +662,20 @@ static jsval_t gc_apply_val(gc_ctx_t *ctx, jsval_t val) {
   if (!gc_is_tagged(val)) return val;
   
   uint8_t type = gc_vtype(val);
+  if (type == T_FUNC || type == T_CLOSURE) return val;
+
   jsoff_t old_off = (jsoff_t)gc_vdata(val);
   if (old_off >= ctx->js->brk) return val;
   
   switch (type) {
     case T_OBJ:
-    case T_FUNC:
     case T_ARR:
     case T_PROMISE:
     case T_GENERATOR:
     case T_STR:
     case T_PROP:
-    case T_BIGINT: {
+    case T_BIGINT:
+    case T_SYMBOL: {
       jsoff_t new_off = fwd_lookup(&ctx->fwd, old_off);
       if (new_off != (jsoff_t)~0) return gc_mkval(type, new_off);
       break;
@@ -604,16 +697,87 @@ static jsoff_t gc_weak_off_callback(void *ctx_ptr, jsoff_t old_off) {
   return fwd_lookup(&ctx->fwd, old_off);
 }
 
-static inline bool gc_get_stack_bounds(void *base, uintptr_t *lo, uintptr_t *hi) {
-  if (!base) return false;
-  volatile uint8_t sp_marker;
-  uintptr_t bp = (uintptr_t)base;
-  uintptr_t sp = (uintptr_t)&sp_marker;
-  if (sp < bp) { *lo = sp; *hi = bp; }
-  else         { *lo = bp; *hi = sp; }
-  *lo &= ~(uintptr_t)7;
-  *hi &= ~(uintptr_t)7;
+static inline bool gc_get_stack_bounds(uintptr_t base, uintptr_t sp, uintptr_t *lo, uintptr_t *hi) {
+  if (base == 0 || sp == 0) return false;
+
+  uintptr_t minp = (sp < base) ? sp : base;
+  uintptr_t maxp = (sp < base) ? base : sp;
+
+  uintptr_t aligned_lo = (minp + (uintptr_t)sizeof(uint64_t) - 1u) & ~((uintptr_t)sizeof(uint64_t) - 1u);
+  uintptr_t aligned_hi = maxp & ~((uintptr_t)sizeof(uint64_t) - 1u);
+
+  if (aligned_lo >= aligned_hi) return false;
+  *lo = aligned_lo;
+  *hi = aligned_hi;
+  return true;
+}
+
+static inline bool gc_stack_word_readable(uintptr_t addr) {
+#if ANT_HAS_ASAN
+  return __asan_region_is_poisoned((void *)addr, sizeof(uint64_t)) == NULL;
+#else
   return true;
+#endif
+}
+
+static inline bool gc_off_has_bytes(jsoff_t off, jsoff_t need, jsoff_t brk) {
+  return off <= brk && need <= brk - off;
+}
+
+static inline bool gc_stack_word_valid(gc_ctx_t *ctx, uint8_t type, jsoff_t old_off, jsoff_t old_brk) {
+  if (old_off == 0 || old_off >= old_brk) return false;
+  if (!gc_off_has_bytes(old_off, (jsoff_t)sizeof(jsoff_t), old_brk)) return false;
+
+  jsoff_t header = gc_loadoff(ctx->js->mem, old_off);
+
+  switch (type) {
+    case T_OBJ:
+    case T_ARR:
+    case T_PROMISE:
+    case T_GENERATOR: {
+      if ((header & 3) != T_OBJ) return false;
+      jsoff_t size = esize(header);
+      return size != (jsoff_t)~0 && gc_off_has_bytes(old_off, size, old_brk);
+    }
+    case T_PROP: {
+      if ((header & 3) != T_PROP) return false;
+      jsoff_t size = esize(header);
+      return size != (jsoff_t)~0 && gc_off_has_bytes(old_off, size, old_brk);
+    }
+    case T_STR: {
+      if ((header & 3) != T_STR) return false;
+      if ((header & ROPE_FLAG) != 0)
+        return gc_off_has_bytes(old_off, (jsoff_t)sizeof(rope_node_t), old_brk);
+      jsoff_t size = esize(header);
+      return size != (jsoff_t)~0 && gc_off_has_bytes(old_off, size, old_brk);
+    }
+    case T_BIGINT: {
+      if ((header & GC_BIGINT_HEADER_LOW_MASK) != 0) return false;
+      jsoff_t payload = header >> GC_BIGINT_HEADER_SHIFT;
+      if (payload < 2) return false;
+      
+      jsoff_t total = payload + (jsoff_t)sizeof(jsoff_t);
+      total = (total + 7) & ~(jsoff_t)7;
+      if (!gc_off_has_bytes(old_off, total, old_brk)) return false;
+      
+      jsoff_t sign_off = old_off + (jsoff_t)sizeof(jsoff_t);
+      uint8_t sign = ctx->js->mem[sign_off];
+      if (sign > 1) return false;
+      
+      jsoff_t nul_off = sign_off + payload - 1;
+      return ctx->js->mem[nul_off] == 0;
+    }
+    case T_SYMBOL: {
+      if ((header & GC_SYM_HEADER_LOW_MASK) != 0) return false;
+      jsoff_t payload = header >> GC_SYM_HEADER_SHIFT;
+      if (payload < GC_SYM_HEAP_FIXED) return false;
+      
+      jsoff_t total = payload + (jsoff_t)sizeof(jsoff_t);
+      total = (total + 7) & ~(jsoff_t)7;
+      return gc_off_has_bytes(old_off, total, old_brk);
+    }
+    default: return false;
+  }
 }
 
 __attribute__((noinline))
@@ -621,16 +785,17 @@ static void gc_scan_stack_reserve(gc_ctx_t *ctx) {
   jmp_buf jb;
   if (setjmp(jb) != 0) return;
 
-  uintptr_t lo, hi;
-  if (!gc_get_stack_bounds(ctx->js->cstk, &lo, &hi)) return;
+  volatile uint8_t sp_marker = 0; uintptr_t lo, hi;
+  if (!gc_get_stack_bounds((uintptr_t)ctx->js->cstk.base, (uintptr_t)&sp_marker, &lo, &hi)) return;
 
   jsoff_t old_brk = ctx->js->brk;
 
   for (uintptr_t addr = lo; addr < hi; addr += sizeof(uint64_t)) {
+    if (!gc_stack_word_readable(addr)) continue;
     uint64_t w;
     memcpy(&w, (void *)addr, sizeof(w));
 
-    if ((w >> 53) != NANBOX_PREFIX_CHK) continue;
+    if (w <= NANBOX_PREFIX) continue;
 
     uint8_t type = (w >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK;
     if (type > T_FFI) continue;
@@ -638,6 +803,7 @@ static void gc_scan_stack_reserve(gc_ctx_t *ctx) {
 
     jsoff_t old_off = (jsoff_t)(w & NANBOX_DATA_MASK);
     if (old_off == 0 || old_off >= old_brk) continue;
+    if (!gc_stack_word_valid(ctx, type, old_off, old_brk)) continue;
 
     if (fwd_lookup(&ctx->fwd, old_off) != (jsoff_t)~0) continue;
     gc_update_val(ctx, w);
@@ -649,16 +815,17 @@ static void gc_scan_stack_update(gc_ctx_t *ctx) {
   jmp_buf jb;
   if (setjmp(jb) != 0) return;
 
-  uintptr_t lo, hi;
-  if (!gc_get_stack_bounds(ctx->js->cstk, &lo, &hi)) return;
+  volatile uint8_t sp_marker = 0; uintptr_t lo, hi;
+  if (!gc_get_stack_bounds((uintptr_t)ctx->js->cstk.base, (uintptr_t)&sp_marker, &lo, &hi)) return;
 
   jsoff_t old_brk = ctx->js->brk;
 
   for (uintptr_t addr = lo; addr < hi; addr += sizeof(uint64_t)) {
+    if (!gc_stack_word_readable(addr)) continue;
     uint64_t w;
     memcpy(&w, (void *)addr, sizeof(w));
 
-    if ((w >> 53) != NANBOX_PREFIX_CHK) continue;
+    if (w <= NANBOX_PREFIX) continue;
 
     uint8_t type = (w >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK;
     if (type > T_FFI) continue;
@@ -666,6 +833,7 @@ static void gc_scan_stack_update(gc_ctx_t *ctx) {
 
     jsoff_t old_off = (jsoff_t)(w & NANBOX_DATA_MASK);
     if (old_off == 0 || old_off >= old_brk) continue;
+    if (!gc_stack_word_valid(ctx, type, old_off, old_brk)) continue;
 
     jsoff_t new_off = fwd_lookup(&ctx->fwd, old_off);
     if (new_off == (jsoff_t)~0 || new_off == old_off) continue;
@@ -675,22 +843,103 @@ static void gc_scan_stack_update(gc_ctx_t *ctx) {
   }
 }
 
-static void gc_compact(ant_t *js) {
-  js->needs_gc = false;
-  
-  if (!js || js->brk == 0) return;
-  if (js->brk < 2 * 1024 * 1024) return;
+static void gc_scan_range_reserve(gc_ctx_t *ctx, uintptr_t lo, uintptr_t hi) {
+  jsoff_t old_brk = ctx->js->brk;
+  for (uintptr_t addr = lo; addr < hi; addr += sizeof(uint64_t)) {
+    if (!gc_stack_word_readable(addr)) continue;
+    uint64_t w;
+    memcpy(&w, (void *)addr, sizeof(w));
+    if (w <= NANBOX_PREFIX) continue;
+    uint8_t type = (w >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK;
+    if (type > T_FFI) continue;
+    if (!((1u << type) & GC_HEAP_TYPE_MASK)) continue;
+    jsoff_t old_off = (jsoff_t)(w & NANBOX_DATA_MASK);
+    if (old_off == 0 || old_off >= old_brk) continue;
+    if (!gc_stack_word_valid(ctx, type, old_off, old_brk)) continue;
+    if (fwd_lookup(&ctx->fwd, old_off) != (jsoff_t)~0) continue;
+    gc_update_val(ctx, w);
+  }
+}
 
-  if (!js->gc_safe) {
-    js->needs_gc = true; return;
+static void gc_scan_range_update(gc_ctx_t *ctx, uintptr_t lo, uintptr_t hi) {
+  jsoff_t old_brk = ctx->js->brk;
+  for (uintptr_t addr = lo; addr < hi; addr += sizeof(uint64_t)) {
+    if (!gc_stack_word_readable(addr)) continue;
+    uint64_t w;
+    memcpy(&w, (void *)addr, sizeof(w));
+    if (w <= NANBOX_PREFIX) continue;
+    uint8_t type = (w >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK;
+    if (type > T_FFI) continue;
+    if (!((1u << type) & GC_HEAP_TYPE_MASK)) continue;
+    jsoff_t old_off = (jsoff_t)(w & NANBOX_DATA_MASK);
+    if (old_off == 0 || old_off >= old_brk) continue;
+    if (!gc_stack_word_valid(ctx, type, old_off, old_brk)) continue;
+    jsoff_t new_off = fwd_lookup(&ctx->fwd, old_off);
+    if (new_off == (jsoff_t)~0 || new_off == old_off) continue;
+    uint64_t updated = gc_mkval(type, new_off);
+    memcpy((void *)addr, &updated, sizeof(updated));
   }
+}
+
+static inline void gc_scan_mco_stack(
+  gc_ctx_t *ctx, mco_coro *mco, mco_coro *skip,
+  void (*scan)(gc_ctx_t *, uintptr_t, uintptr_t)
+) {
+  if (!mco || mco == skip) return;
+  if (!mco->stack_base || mco->stack_size == 0) return;
+  uintptr_t lo = (uintptr_t)mco->stack_base;
+  uintptr_t hi = lo + mco->stack_size;
+  scan(ctx, lo, hi);
+}
 
+static void gc_scan_other_stacks_reserve(gc_ctx_t *ctx) {
   mco_coro *running = mco_running();
-  int in_coroutine = (running != NULL && running->stack_base != NULL);
-  
-  if (in_coroutine) {
-    js->needs_gc = true; return;
+  if (!running) return;
+
+  for (mco_coro *a = running->prev_co; a; a = a->prev_co)
+    gc_scan_mco_stack(ctx, a, running, gc_scan_range_reserve);
+
+  for (coroutine_t *c = pending_coroutines.head; c; c = c->next)
+    gc_scan_mco_stack(ctx, c->mco, running, gc_scan_range_reserve);
+
+  if (ctx->js->cstk.main_base && ctx->js->cstk.main_lo) {
+    uintptr_t lo, hi;
+    if (gc_get_stack_bounds(
+      (uintptr_t)ctx->js->cstk.main_base, 
+      (uintptr_t)ctx->js->cstk.main_lo, &lo, &hi)
+    ) gc_scan_range_reserve(ctx, lo, hi);
   }
+}
+
+static void gc_scan_other_stacks_update(gc_ctx_t *ctx) {
+  mco_coro *running = mco_running();
+  if (!running) return;
+
+  for (mco_coro *a = running->prev_co; a; a = a->prev_co)
+    gc_scan_mco_stack(ctx, a, running, gc_scan_range_update);
+
+  for (coroutine_t *c = pending_coroutines.head; c; c = c->next)
+    gc_scan_mco_stack(ctx, c->mco, running, gc_scan_range_update);
+
+  if (ctx->js->cstk.main_base && ctx->js->cstk.main_lo) {
+    uintptr_t lo, hi;
+    if (gc_get_stack_bounds(
+      (uintptr_t)ctx->js->cstk.main_base,
+      (uintptr_t)ctx->js->cstk.main_lo, &lo, &hi)
+    ) gc_scan_range_update(ctx, lo, hi);
+  }
+}
+
+static void gc_forward_func_cb(void *ctx_ptr, sv_func_t *func) {
+  gc_ctx_t *ctx = (gc_ctx_t *)ctx_ptr;
+  gc_update_func_constants(ctx, func, 0);
+}
+
+static void gc_compact(ant_t *js) {
+  js->needs_gc = false;
+  
+  if (!js || js->brk == 0) return;
+  if (js->brk < 2 * 1024 * 1024) return;
 
   time_t now = time(NULL);
   if (now != (time_t)-1 && gc_last_run_time != 0) {
@@ -730,7 +979,7 @@ static void gc_compact(ant_t *js) {
   gc_ctx_t ctx;
   ctx.js = js;
   ctx.new_mem = new_mem;
-  ctx.new_brk = 0;
+  ctx.new_brk = NANBOX_HEAP_OFFSET;
   ctx.new_size = (jsoff_t)new_size;
   ctx.mark_bits = mark_bits;
   
@@ -744,7 +993,8 @@ static void gc_compact(ant_t *js) {
   }
   
   ctx.failed = false;
-    
+  gc_epoch_counter++;
+  
   if (js->brk > 0) {
     jsoff_t header_at_0 = gc_loadoff(js->mem, 0);
     if ((header_at_0 & 3) == T_OBJ) gc_reserve_object(&ctx, 0);
@@ -757,6 +1007,7 @@ static void gc_compact(ant_t *js) {
   ); gc_drain_work_queue(&ctx);
   
   gc_scan_stack_reserve(&ctx);
+  gc_scan_other_stacks_reserve(&ctx);
   gc_drain_work_queue(&ctx);
   
   if (ctx.failed) {
@@ -764,7 +1015,10 @@ static void gc_compact(ant_t *js) {
     work_free(&ctx.work);
     fwd_free(&ctx.fwd); return;
   }
-  
+
+  js_gc_visit_frame_funcs(js, gc_forward_func_cb, &ctx);
+  gc_drain_work_queue(&ctx);
+
   js_gc_update_roots(js, 
     gc_apply_off_callback,
     gc_weak_off_callback,
@@ -772,9 +1026,10 @@ static void gc_compact(ant_t *js) {
   &ctx);
   
   gc_scan_stack_update(&ctx);
+  gc_scan_other_stacks_update(&ctx);
   memcpy(js->mem, new_mem, ctx.new_brk);
   js->brk = ctx.new_brk;
-  
+
   free(mark_bits);
   work_free(&ctx.work);
   fwd_free(&ctx.fwd);
diff --git a/src/main.c b/src/main.c
index 9f577c1..36850b7 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,24 +1,28 @@
 #include <compat.h> // IWYU pragma: keep
 #include <arena.h>
 
-#include <oxc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/stat.h>
+#include <sys/resource.h>
 #include <argtable3.h>
 #include <crprintf.h>
 
 #include "ant.h"
 #include "repl.h"
+#include "debug.h"
 #include "utils.h"
 #include "watch.h"
 #include "reactor.h"
 #include "runtime.h"
 #include "snapshot.h"
+#include "esm/loader.h"
+#include "esm/library.h"
 #include "esm/remote.h"
 #include "internal.h"
+#include "silver/vm.h"
 #include "messages.h"
 
 #include "cli/pkg.h"
@@ -38,6 +42,7 @@
 #include "modules/fetch.h"
 #include "modules/shell.h"
 #include "modules/process.h"
+#include "modules/tty.h"
 #include "modules/path.h"
 #include "modules/ffi.h"
 #include "modules/events.h"
@@ -47,6 +52,8 @@
 #include "modules/url.h"
 #include "modules/reflect.h"
 #include "modules/symbol.h"
+#include "modules/date.h"
+#include "modules/regex.h"
 #include "modules/textcodec.h"
 #include "modules/sessionstorage.h"
 #include "modules/localstorage.h"
@@ -55,6 +62,12 @@
 #include "modules/readline.h"
 #include "modules/observable.h"
 #include "modules/collections.h"
+#include "modules/module.h"
+#include "modules/util.h"
+#include "modules/async_hooks.h"
+#include "modules/net.h"
+#include "modules/dns.h"
+#include "modules/worker_threads.h"
 
 int js_result = EXIT_SUCCESS;
 typedef int (*cmd_fn)(int argc, char **argv);
@@ -67,29 +80,52 @@ typedef struct {
 } subcommand_t;
 
 static const subcommand_t subcommands[] = {
-  {"init",    NULL,      "Create a new package.json",              pkg_cmd_init},
-  {"install", "i",       "Install dependencies from lockfile",     pkg_cmd_install},
-  {"add",     "a",       "Add a package to dependencies",          pkg_cmd_add},
-  {"remove",  "rm",      "Remove a package from dependencies",     pkg_cmd_remove},
-  {"trust",   NULL,      "Run lifecycle scripts for packages",     pkg_cmd_trust},
-  {"run",     NULL,      "Run a script from package.json",         pkg_cmd_run},
-  {"exec",    "x",       "Run a command from node_modules/.bin",   pkg_cmd_exec},
-  {"why",     "explain", "Show why a package is installed",        pkg_cmd_why},
-  {"info",    NULL,      "Show package information from registry", pkg_cmd_info},
-  {"ls",      "list",    "List installed packages",                pkg_cmd_ls},
-  {"cache",   NULL,      "Manage the package cache",               pkg_cmd_cache},
-  {"create",  NULL,      "Scaffold a project from a template",     pkg_cmd_create},
+  {"init",    NULL,      "Create a new package.json",                    pkg_cmd_init},
+  {"install", "i",       "Install dependencies from lockfile",           pkg_cmd_install},
+  {"update",  "up",      "Re-resolve dependencies and refresh lockfile", pkg_cmd_update},
+  {"add",     "a",       "Add a package to dependencies",                pkg_cmd_add},
+  {"remove",  "rm",      "Remove a package from dependencies",           pkg_cmd_remove},
+  {"trust",   NULL,      "Run lifecycle scripts for packages",           pkg_cmd_trust},
+  {"run",     NULL,      "Run a script from package.json",               pkg_cmd_run},
+  {"exec",    "x",       "Run a command from node_modules/.bin",         pkg_cmd_exec},
+  {"why",     "explain", "Show why a package is installed",              pkg_cmd_why},
+  {"info",    NULL,      "Show package information from registry",       pkg_cmd_info},
+  {"ls",      "list",    "List installed packages",                      pkg_cmd_ls},
+  {"cache",   NULL,      "Manage the package cache",                     pkg_cmd_cache},
+  {"create",  NULL,      "Scaffold a project from a template",           pkg_cmd_create},
   {NULL, NULL, NULL, NULL}
 };
 
-static void parse_ant_debug(const char *flag) {
-  if (strncmp(flag, "dump-crprintf=", 14) == 0) {
-    const char *mode = flag + 14;
-    if (strcmp(mode, "bytecode") == 0 || strcmp(mode, "all") == 0) crprintf_set_debug(true);
-    if (strcmp(mode, "hex") == 0      || strcmp(mode, "all") == 0) crprintf_set_debug_hex(true);
-  }
+static void ant_debug_apply(const char *key, const char *val) {
+  if (strcmp(key, "dump/crprintf") == 0) {
+    if (strcmp(val, "bytecode") == 0 || strcmp(val, "all") == 0) crprintf_set_debug(true);
+    if (strcmp(val, "hex") == 0      || strcmp(val, "all") == 0) crprintf_set_debug_hex(true);
+  } 
   
-  else crfprintf(stderr, msg.unknown_flag_warn, flag);
+  else if (strcmp(key, "dump/vm") == 0) {
+    if (strcmp(val, "bytecode") == 0 || strcmp(val, "all") == 0) sv_debug_enable(SV_DEBUG_DUMP_BYTECODE);
+    if (strcmp(val, "jit") == 0      || strcmp(val, "all") == 0) sv_debug_enable(SV_DEBUG_DUMP_JIT);
+    if (strcmp(val, "op-warn") == 0  || strcmp(val, "all") == 0) sv_debug_enable(SV_DEBUG_JIT_WARN);
+  }
+}
+
+static void parse_ant_debug_flags(void) {
+  const char *env = getenv("ANT_DEBUG");
+  if (!env || !*env) return;
+
+  char *buf = strdup(env);
+  if (!buf) return;
+
+  char *sp = NULL, *vp = NULL;
+  for (char *e = strtok_r(buf, " ", &sp); e; e = strtok_r(NULL, " ", &sp)) {
+    char *sep = strchr(e, ':');
+    if (!sep) { crfprintf(stderr, msg.unknown_flag_warn, e); continue; }
+    *sep++ = '\0';
+    for (char *v = strtok_r(sep, ",", &vp); v; v = strtok_r(NULL, ",", &vp))
+      ant_debug_apply(e, v);
+  }
+
+  free(buf);
 }
 
 static const subcommand_t *find_subcommand(const char *name) {
@@ -145,14 +181,17 @@ static argv_split_t split_script_args(int *argc, char **argv) {
       *argc = i;
       return tail;
     }
+    
     if (argv[i][0] == '-') {
       if (is_valued_flag(argv[i]) && i + 1 < *argc) i++;
       continue;
     }
+    
     argv_split_t tail = { *argc - i - 1, argv + i + 1 };
     *argc = i + 1;
     return tail;
   }
+  
   return (argv_split_t){ 0, NULL };
 }
 
@@ -209,17 +248,21 @@ static char *read_file(const char *filename, size_t *len) {
   return buffer;
 }
 
-static void eval_code(struct js *js, const char *script, size_t len, const char *tag, bool should_print) {
+static void eval_code(ant_t *js, const char *script, size_t len, const char *tag, bool should_print) {
   js_set_filename(js, tag);
   js_setup_import_meta(js, tag);
-  js_mkscope(js);
   
   js_set(js, js_glob(js), "__dirname", js_mkstr(js, ".", 1));
   js_set(js, js_glob(js), "__filename", js_mkstr(js, tag, strlen(tag)));
   
-  jsval_t result = js_eval(js, script, len);
+  jsval_t result = js_eval_bytecode_eval(js, script, len);
   js_run_event_loop(js);
   
+  if (print_uncaught_throw(js)) {
+    js_result = EXIT_FAILURE;
+    return;
+  }
+  
   char cbuf_stack[512]; js_cstr_t cstr = js_to_cstr(
     js, result, cbuf_stack, sizeof(cbuf_stack)
   );
@@ -237,11 +280,11 @@ static void eval_code(struct js *js, const char *script, size_t len, const char
   if (cstr.needs_free) free((void *)cstr.ptr);
 }
 
-static int execute_module(struct js *js, const char *filename) {
+static int execute_module(ant_t *js, const char *filename) {
   char *buffer = NULL;
   size_t len = 0;
   
-  char abs_path[PATH_MAX];
+  char *use_path_owned = NULL;
   const char *use_path = filename;
   
   if (esm_is_url(filename)) {
@@ -266,40 +309,55 @@ static int execute_module(struct js *js, const char *filename) {
     js_set(js, js_glob(js), "__dirname", js_mkstr(js, dir, strlen(dir)));
     free(file_path);
     
-    if (realpath(filename, abs_path)) use_path = abs_path;
+    use_path_owned = realpath(filename, NULL);
+    if (use_path_owned) use_path = use_path_owned;
   }
   
-  char *js_code = buffer;
   size_t js_len = len;
+  const char *strip_detail = NULL;
   
-  if (is_typescript_file(filename)) {
-    int result = OXC_strip_types(buffer, filename, buffer, len + 1);
-    if (result < 0) {
-      crfprintf(stderr, msg.type_strip_failed, result);
-      free(buffer);
-      return EXIT_FAILURE;
-    }
-    js_len = (size_t)result;
+  int strip_result = strip_typescript_inplace(
+    &buffer, len, filename, &js_len, &strip_detail
+  );
+  
+  if (strip_result < 0) {
+    crfprintf(stderr, msg.type_strip_failed, strip_result, strip_detail);
+    free(buffer); free(use_path_owned);
+    return EXIT_FAILURE;
   }
-
-  js_set_filename(js, use_path);
-  js_set(js, js_glob(js), "__filename", js_mkstr(js, filename, strlen(filename)));
   
+  char *js_code = buffer;
+  js_set(js, js_glob(js), 
+    "__filename", 
+    js_mkstr(js, filename, strlen(filename))
+  );
+  
+  js_set_filename(js, use_path);
   js_setup_import_meta(js, use_path);
-  js_mkscope(js);
   
-  jsval_t result = js_eval_cached(js, js_code, js_len);
+  jsval_t import_fn = js_get(js, js->global, "import");
+  jsval_t module_ns = mkobj(js, 0);
+  
+  js->import_meta = (vtype(import_fn) == T_FUNC)
+    ? js_get(js, import_fn, "meta")
+    : js_mkundef();
+
+  jsval_t result = js_esm_eval_module_source(
+    js, use_path, js_code, 
+    js_len, module_ns
+  ); 
+  
   free(js_code);
   
-  if (vtype(result) == T_ERR) {
-    fprintf(stderr, "%s\n", js_str(js, result));
-    return EXIT_FAILURE;
-  }
+  if (print_uncaught_throw(js)) return EXIT_FAILURE;
+  if (vtype(result) == T_ERR) fprintf(stderr, "%s\n", js_str(js, result));
   
   return EXIT_SUCCESS;
 }
 
 int main(int argc, char *argv[]) {
+  parse_ant_debug_flags();
+  
   int filtered_argc = 0; int original_argc = argc;
   char **original_argv = argv;
   
@@ -314,6 +372,7 @@ int main(int argc, char *argv[]) {
   if (strcmp(binary_name, "antx") == 0) {
     char **exec_argv = try_oom(sizeof(char*) * (argc + 2));
     exec_argv[0] = argv[0]; exec_argv[1] = "x";
+    
     for (int i = 1; i < argc; i++) exec_argv[i + 1] = argv[i];
     exec_argv[argc + 1] = NULL;
     
@@ -325,7 +384,7 @@ int main(int argc, char *argv[]) {
   for (int i = 0; i < argc; i++) {
     if (strcmp(argv[i], "--verbose") == 0) pkg_verbose = true;
     else if (strcmp(argv[i], "--no-color") == 0) { crprintf_set_color(false); io_no_color = true; }
-    else if (strncmp(argv[i], "--ANT_DEBUG:", 12) == 0) parse_ant_debug(argv[i] + 12);
+    else if (strncmp(argv[i], "--stack-size=", 13) == 0) sv_user_stack_size_kb = atoi(argv[i] + 13);
     else filtered_argv[filtered_argc++] = argv[i];
   }
   
@@ -411,11 +470,24 @@ int main(int argc, char *argv[]) {
         CLEANUP_ARGS_AND_ARGV();
         return EXIT_FAILURE;
       }
+
+      int cmd_argc = argc - first_pos_idx;
+      char **cmd_argv = argv + first_pos_idx;
+      char **cmd_argv_full = NULL;
       
-      int exitcode = cmd->fn(
-        argc - first_pos_idx, 
-        argv + first_pos_idx
-      );
+      if (script_tail.argc > 0) {
+        cmd_argv_full = try_oom(sizeof(*cmd_argv_full) * (size_t)(cmd_argc + script_tail.argc + 1));
+        
+        memcpy(cmd_argv_full, cmd_argv, sizeof(*cmd_argv_full) * (size_t)cmd_argc);
+        memcpy(cmd_argv_full + cmd_argc, script_tail.argv, sizeof(*cmd_argv_full) * (size_t)script_tail.argc);
+        
+        cmd_argc += script_tail.argc;
+        cmd_argv_full[cmd_argc] = NULL;
+        cmd_argv = cmd_argv_full;
+      }
+
+      int exitcode = cmd->fn(cmd_argc, cmd_argv);
+      free(cmd_argv_full);
       
       CLEANUP_ARGS_AND_ARGV();
       return exitcode;
@@ -428,11 +500,16 @@ int main(int argc, char *argv[]) {
         return EXIT_FAILURE;
       }
 
-      int run_argc = argc - first_pos_idx + 1;
+      int run_argc = argc - first_pos_idx + 1 + script_tail.argc;
       char **run_argv = try_oom(sizeof(*run_argv) * (size_t)(run_argc + 1));
       
       run_argv[0] = argv[0];
-      memcpy(run_argv + 1, argv + first_pos_idx, sizeof(*run_argv) * (size_t)(run_argc - 1));
+      int copied = argc - first_pos_idx;
+      
+      memcpy(run_argv + 1, argv + first_pos_idx, sizeof(*run_argv) * (size_t)copied);
+      if (script_tail.argc > 0) {
+        memcpy(run_argv + 1 + copied, script_tail.argv, sizeof(*run_argv) * (size_t)script_tail.argc);
+      }
       
       run_argv[run_argc] = NULL;
       int exitcode = pkg_cmd_run(run_argc, run_argv);
@@ -454,9 +531,9 @@ int main(int argc, char *argv[]) {
     return EXIT_FAILURE;
   }
   
-  const char *module_file = repl_mode 
+  const char *module_file = (repl_mode || file->count == 0) 
     ? NULL 
-    : (file->count > 0 ? file->filename[0] : NULL);
+    : file->filename[0];
 
   if (watch->count > 0) {
     char *resolved_file = NULL;
@@ -487,10 +564,19 @@ int main(int argc, char *argv[]) {
   }
   
   js_setstackbase(js, (void *)&stack_base);
+  {
+    struct rlimit rl;
+    if (getrlimit(RLIMIT_STACK, &rl) == 0 && rl.rlim_cur != RLIM_INFINITY)
+      js_setstacklimit(js, (size_t)rl.rlim_cur * 3 / 4);
+    else
+      js_setstacklimit(js, 512 * 1024);
+  }
   proc_argv = build_process_argv(argc, argv, module_file, script_tail);
   ant_runtime_init(js, proc_argv.argc, proc_argv.argv, localstorage_file);
 
   init_symbol_module();
+  init_date_module();
+  init_regex_module();
   init_collections_module();
   init_builtin_module();
   init_buffer_module();
@@ -503,6 +589,7 @@ int main(int argc, char *argv[]) {
   init_server_module();
   init_timer_module();
   init_process_module();
+  init_tty_module();
   init_events_module();
   init_performance_module();
   init_uri_module();
@@ -518,14 +605,26 @@ int main(int argc, char *argv[]) {
   ant_register_library(ffi_library, "ant:ffi", NULL);
   ant_register_library(lmdb_library, "ant:lmdb", NULL);
 
+  ant_standard_library("util", util_library);
+  ant_standard_library("net", net_library);
+  ant_standard_library("dns", dns_library);
+  ant_standard_library("module", module_library);
+  ant_standard_library("buffer", buffer_library);
   ant_standard_library("path", path_library);
   ant_standard_library("fs", fs_library);
+  ant_standard_library("fs/promises", fs_promises_library);
   ant_standard_library("os", os_library);
+  ant_standard_library("url", url_library);
+  ant_standard_library("perf_hooks", perf_hooks_library);
+  ant_standard_library("process", process_library);
   ant_standard_library("crypto", crypto_library);
   ant_standard_library("events", events_library);
+  ant_standard_library("tty", tty_library);
   ant_standard_library("readline", readline_library);
   ant_standard_library("readline/promises", readline_promises_library);
   ant_standard_library("child_process", child_process_library);
+  ant_standard_library("worker_threads", worker_threads_library);
+  ant_standard_library("async_hooks", async_hooks_library);
 
   jsval_t snapshot_result = ant_load_snapshot(js);
   if (vtype(snapshot_result) == T_ERR) {
@@ -551,14 +650,21 @@ int main(int argc, char *argv[]) {
   } 
   
   else {
-    char *resolved_file = resolve_js_file(module_file);
-    if (resolved_file) module_file = resolved_file;
+  for (int fi = 0; fi < file->count; fi++) {
+    const char *fl = file->filename[fi];
+    char *resolved_file = resolve_js_file(fl);
+    if (!resolved_file) {
+      crfprintf(stderr, msg.module_not_found, fl);
+      js_result = EXIT_FAILURE; break;
+    }
     
-    js_result = execute_module(js, module_file);
+    fl = resolved_file;
+    js_result = execute_module(js, fl);
     js_run_event_loop(js);
     
-    if (resolved_file) free(resolved_file);
-  }
+    free(resolved_file);
+    if (js_result != EXIT_SUCCESS) break;
+  }}
     
   cleanup: {
     js_destroy(js);
diff --git a/src/modules/async_hooks.c b/src/modules/async_hooks.c
new file mode 100644
index 0000000..8d1e1d7
--- /dev/null
+++ b/src/modules/async_hooks.c
@@ -0,0 +1,185 @@
+// stub: minimal node:async_hooks implementation
+// just enough for react to render tree
+
+#include <stdlib.h>
+
+#include "ant.h"
+#include "internal.h"
+#include "silver/engine.h"
+
+#include "descriptors.h"
+#include "modules/async_hooks.h"
+#include "modules/symbol.h"
+
+static inline bool async_hooks_is_callable(jsval_t v) {
+  uint8_t t = vtype(v);
+  return t == T_FUNC || t == T_CFUNC;
+}
+
+static jsval_t async_hooks_call_with_tail_args(
+  ant_t *js, jsval_t fn, jsval_t this_arg, jsval_t *args, int nargs, int start_idx
+) {
+  int call_nargs = nargs - start_idx;
+  if (call_nargs <= 0) return sv_vm_call(js->vm, js, fn, this_arg, NULL, 0, NULL, false);
+
+  jsval_t *call_args = (jsval_t *)malloc((size_t)call_nargs * sizeof(jsval_t));
+  if (!call_args) return js_mkerr(js, "Out of memory");
+
+  for (int i = 0; i < call_nargs; i++) call_args[i] = args[start_idx + i];
+  jsval_t result = sv_vm_call(js->vm, js, fn, this_arg, call_args, call_nargs, NULL, false);
+  free(call_args);
+  return result;
+}
+
+static jsval_t async_local_storage_run(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2 || !async_hooks_is_callable(args[1])) {
+    return js_mkerr(js, "AsyncLocalStorage.run(store, callback, ...args) requires a callback");
+  }
+
+  jsval_t this_obj = js_getthis(js);
+  if (!is_object_type(this_obj)) {
+    return js_mkerr(js, "AsyncLocalStorage.run() requires an AsyncLocalStorage instance");
+  }
+
+  jsval_t prev = js_get_slot(js, this_obj, SLOT_DATA);
+  js_set_slot(js, this_obj, SLOT_DATA, args[0]);
+  jsval_t result = async_hooks_call_with_tail_args(js, args[1], js_mkundef(), args, nargs, 2);
+  js_set_slot(js, this_obj, SLOT_DATA, prev);
+  return result;
+}
+
+static jsval_t async_local_storage_exit(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || !async_hooks_is_callable(args[0])) {
+    return js_mkerr(js, "AsyncLocalStorage.exit(callback, ...args) requires a callback");
+  }
+
+  jsval_t this_obj = js_getthis(js);
+  if (!is_object_type(this_obj)) {
+    return js_mkerr(js, "AsyncLocalStorage.exit() requires an AsyncLocalStorage instance");
+  }
+
+  jsval_t prev = js_get_slot(js, this_obj, SLOT_DATA);
+  js_set_slot(js, this_obj, SLOT_DATA, js_mkundef());
+  jsval_t result = async_hooks_call_with_tail_args(js, args[0], js_mkundef(), args, nargs, 1);
+  js_set_slot(js, this_obj, SLOT_DATA, prev);
+  return result;
+}
+
+static jsval_t async_local_storage_enterWith(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (!is_object_type(this_obj)) {
+    return js_mkerr(js, "AsyncLocalStorage.enterWith() requires an AsyncLocalStorage instance");
+  }
+  js_set_slot(js, this_obj, SLOT_DATA, nargs > 0 ? args[0] : js_mkundef());
+  return js_mkundef();
+}
+
+static jsval_t async_local_storage_getStore(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t this_obj = js_getthis(js);
+  if (!is_object_type(this_obj)) return js_mkundef();
+  return js_get_slot(js, this_obj, SLOT_DATA);
+}
+
+static jsval_t async_local_storage_disable(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t this_obj = js_getthis(js);
+  if (is_object_type(this_obj)) js_set_slot(js, this_obj, SLOT_DATA, js_mkundef());
+  return js_mkundef();
+}
+
+static jsval_t async_resource_runInAsyncScope(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || !async_hooks_is_callable(args[0])) {
+    return js_mkerr(js, "AsyncResource.runInAsyncScope(fn[, thisArg, ...args]) requires a function");
+  }
+  jsval_t this_arg = nargs > 1 ? args[1] : js_mkundef();
+  return async_hooks_call_with_tail_args(js, args[0], this_arg, args, nargs, 2);
+}
+
+static jsval_t async_resource_emitDestroy(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  return js_getthis(js);
+}
+
+static jsval_t async_resource_asyncId(ant_t *js, jsval_t *args, int nargs) {
+  (void)js; (void)args; (void)nargs;
+  return js_mknum(0);
+}
+
+static jsval_t async_resource_triggerAsyncId(ant_t *js, jsval_t *args, int nargs) {
+  (void)js; (void)args; (void)nargs;
+  return js_mknum(0);
+}
+
+static jsval_t async_hook_enable(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  return js_getthis(js);
+}
+
+static jsval_t async_hook_disable(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  return js_getthis(js);
+}
+
+static jsval_t async_hooks_createHook(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t hook = js_mkobj(js);
+  js_set(js, hook, "enable", js_mkfun(async_hook_enable));
+  js_set(js, hook, "disable", js_mkfun(async_hook_disable));
+  return hook;
+}
+
+static jsval_t async_hooks_executionAsyncId(ant_t *js, jsval_t *args, int nargs) {
+  (void)js; (void)args; (void)nargs;
+  return js_mknum(1);
+}
+
+static jsval_t async_hooks_triggerAsyncId(ant_t *js, jsval_t *args, int nargs) {
+  (void)js; (void)args; (void)nargs;
+  return js_mknum(0);
+}
+
+static jsval_t async_hooks_executionAsyncResource(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  return js_mkobj(js);
+}
+
+jsval_t async_hooks_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+
+  jsval_t als_ctor = js_mkobj(js);
+  jsval_t als_proto = js_mkobj(js);
+  js_set(js, als_proto, "run", js_mkfun(async_local_storage_run));
+  js_set(js, als_proto, "exit", js_mkfun(async_local_storage_exit));
+  js_set(js, als_proto, "enterWith", js_mkfun(async_local_storage_enterWith));
+  js_set(js, als_proto, "getStore", js_mkfun(async_local_storage_getStore));
+  js_set(js, als_proto, "disable", js_mkfun(async_local_storage_disable));
+  js_set_sym(js, als_proto, get_toStringTag_sym(), ANT_STRING("AsyncLocalStorage"));
+  js_set_slot(js, als_ctor, SLOT_DEFAULT_CTOR, js_true);
+  js_mkprop_fast(js, als_ctor, "prototype", 9, als_proto);
+  js_mkprop_fast(js, als_ctor, "name", 4, ANT_STRING("AsyncLocalStorage"));
+  js_set_descriptor(js, als_ctor, "name", 4, 0);
+  js_set(js, lib, "AsyncLocalStorage", js_obj_to_func(als_ctor));
+
+  jsval_t resource_ctor = js_mkobj(js);
+  jsval_t resource_proto = js_mkobj(js);
+  js_set(js, resource_proto, "runInAsyncScope", js_mkfun(async_resource_runInAsyncScope));
+  js_set(js, resource_proto, "emitDestroy", js_mkfun(async_resource_emitDestroy));
+  js_set(js, resource_proto, "asyncId", js_mkfun(async_resource_asyncId));
+  js_set(js, resource_proto, "triggerAsyncId", js_mkfun(async_resource_triggerAsyncId));
+  js_set_sym(js, resource_proto, get_toStringTag_sym(), ANT_STRING("AsyncResource"));
+  js_set_slot(js, resource_ctor, SLOT_DEFAULT_CTOR, js_true);
+  js_mkprop_fast(js, resource_ctor, "prototype", 9, resource_proto);
+  js_mkprop_fast(js, resource_ctor, "name", 4, ANT_STRING("AsyncResource"));
+  js_set_descriptor(js, resource_ctor, "name", 4, 0);
+  js_set(js, lib, "AsyncResource", js_obj_to_func(resource_ctor));
+
+  js_set(js, lib, "createHook", js_mkfun(async_hooks_createHook));
+  js_set(js, lib, "executionAsyncId", js_mkfun(async_hooks_executionAsyncId));
+  js_set(js, lib, "triggerAsyncId", js_mkfun(async_hooks_triggerAsyncId));
+  js_set(js, lib, "executionAsyncResource", js_mkfun(async_hooks_executionAsyncResource));
+  js_set(js, lib, "asyncWrapProviders", js_mkobj(js));
+  js_set_sym(js, lib, get_toStringTag_sym(), ANT_STRING("async_hooks"));
+
+  return lib;
+}
diff --git a/src/modules/atomics.c b/src/modules/atomics.c
index a8562f2..22f5b6f 100644
--- a/src/modules/atomics.c
+++ b/src/modules/atomics.c
@@ -82,7 +82,7 @@ int wait_queue_notify(WaitQueue *queue, int32_t *address, int count) {
   return notified;
 }
 
-static bool get_atomic_array_data(struct js *js, jsval_t this_val, TypedArrayData **out_data, uint8_t **out_ptr) {
+static bool get_atomic_array_data(ant_t *js, jsval_t this_val, TypedArrayData **out_data, uint8_t **out_ptr) {
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
   if (!ta_data || !ta_data->buffer) return false;
@@ -93,7 +93,7 @@ static bool get_atomic_array_data(struct js *js, jsval_t this_val, TypedArrayDat
 }
 
 // Atomics.add(typedArray, index, value)
-static jsval_t js_atomics_add(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_add(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.add requires 3 arguments");
   }
@@ -151,7 +151,7 @@ static jsval_t js_atomics_add(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.and(typedArray, index, value)
-static jsval_t js_atomics_and(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_and(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.and requires 3 arguments");
   }
@@ -209,7 +209,7 @@ static jsval_t js_atomics_and(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)
-static jsval_t js_atomics_compareExchange(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_compareExchange(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 4) {
     return js_mkerr(js, "Atomics.compareExchange requires 4 arguments");
   }
@@ -277,7 +277,7 @@ static jsval_t js_atomics_compareExchange(struct js *js, jsval_t *args, int narg
 }
 
 // Atomics.exchange(typedArray, index, value)
-static jsval_t js_atomics_exchange(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_exchange(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.exchange requires 3 arguments");
   }
@@ -335,7 +335,7 @@ static jsval_t js_atomics_exchange(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.isLockFree(size)
-static jsval_t js_atomics_isLockFree(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_isLockFree(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Atomics.isLockFree requires 1 argument");
   }
@@ -364,7 +364,7 @@ static jsval_t js_atomics_isLockFree(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.load(typedArray, index)
-static jsval_t js_atomics_load(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_load(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "Atomics.load requires 2 arguments");
   }
@@ -421,7 +421,7 @@ static jsval_t js_atomics_load(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.or(typedArray, index, value)
-static jsval_t js_atomics_or(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_or(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.or requires 3 arguments");
   }
@@ -479,7 +479,7 @@ static jsval_t js_atomics_or(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.store(typedArray, index, value)
-static jsval_t js_atomics_store(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_store(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.store requires 3 arguments");
   }
@@ -536,7 +536,7 @@ static jsval_t js_atomics_store(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.sub(typedArray, index, value)
-static jsval_t js_atomics_sub(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_sub(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.sub requires 3 arguments");
   }
@@ -594,7 +594,7 @@ static jsval_t js_atomics_sub(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.xor(typedArray, index, value)
-static jsval_t js_atomics_xor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_xor(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.xor requires 3 arguments");
   }
@@ -652,7 +652,7 @@ static jsval_t js_atomics_xor(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.wait(typedArray, index, value, timeout)
-static jsval_t js_atomics_wait(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_wait(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.wait requires at least 3 arguments");
   }
@@ -725,7 +725,7 @@ static jsval_t js_atomics_wait(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.notify(typedArray, index, count)
-static jsval_t js_atomics_notify(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_notify(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "Atomics.notify requires at least 2 arguments");
   }
@@ -759,7 +759,7 @@ static jsval_t js_atomics_notify(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.waitAsync(typedArray, index, value, timeout)
-static jsval_t js_atomics_waitAsync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_waitAsync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Atomics.waitAsync requires at least 3 arguments");
   }
@@ -799,7 +799,7 @@ static jsval_t js_atomics_waitAsync(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Atomics.pause()
-static jsval_t js_atomics_pause(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_atomics_pause(ant_t *js, jsval_t *args, int nargs) {
   (void)js;
   (void)args;
   (void)nargs;
@@ -814,7 +814,7 @@ static jsval_t js_atomics_pause(struct js *js, jsval_t *args, int nargs) {
 }
 
 void init_atomics_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   
   jsval_t glob = js_glob(js);
   jsval_t atomics = js_mkobj(js);
@@ -834,6 +834,6 @@ void init_atomics_module(void) {
   js_set(js, atomics, "waitAsync", js_mkfun(js_atomics_waitAsync));
   js_set(js, atomics, "xor", js_mkfun(js_atomics_xor));
   
-  js_set(js, atomics, get_toStringTag_sym_key(), js_mkstr(js, "Atomics", 7));
+  js_set_sym(js, atomics, get_toStringTag_sym(), js_mkstr(js, "Atomics", 7));
   js_set(js, glob, "Atomics", atomics);
 }
diff --git a/src/modules/buffer.c b/src/modules/buffer.c
index b3b8770..372bfa6 100644
--- a/src/modules/buffer.c
+++ b/src/modules/buffer.c
@@ -14,7 +14,9 @@
 #include "arena.h"
 #include "base64.h"
 #include "internal.h"
+#include "silver/engine.h"
 #include "runtime.h"
+#include "descriptors.h"
 
 #include "modules/buffer.h"
 #include "modules/symbol.h"
@@ -96,26 +98,31 @@ static void *ta_arena_alloc(size_t size) {
   return ptr;
 }
 
-static jsval_t js_arraybuffer_slice(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_typedarray_slice(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_typedarray_subarray(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_typedarray_fill(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_typedarray_toReversed(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_typedarray_toSorted(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_typedarray_with(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_getUint8(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_setUint8(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_getInt16(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_setInt16(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_getInt32(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_setInt32(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_getFloat32(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_setFloat32(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_getFloat64(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_dataview_setFloat64(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_buffer_toString(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_buffer_toBase64(struct js *js, jsval_t *args, int nargs);
-static jsval_t js_buffer_write(struct js *js, jsval_t *args, int nargs);
+static jsval_t js_arraybuffer_slice(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_slice(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_subarray(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_fill(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_at(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_set(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_copyWithin(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_toReversed(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_toSorted(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_with(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_getUint8(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_setUint8(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_getInt16(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_setInt16(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_getInt32(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_setInt32(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_getFloat32(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_setFloat32(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_getFloat64(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_dataview_setFloat64(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_typedarray_toString(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_buffer_slice(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_buffer_toString(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_buffer_toBase64(ant_t *js, jsval_t *args, int nargs);
+static jsval_t js_buffer_write(ant_t *js, jsval_t *args, int nargs);
 
 ArrayBufferData *create_array_buffer_data(size_t length) {
   ArrayBufferData *data = ant_calloc(sizeof(ArrayBufferData) + length);
@@ -164,8 +171,44 @@ static size_t get_element_size(TypedArrayType type) {
   L_8: return 8;
 }
 
-// ArrayBuffer constructor
-static jsval_t js_arraybuffer_constructor(struct js *js, jsval_t *args, int nargs) {
+static const char *typedarray_type_name(TypedArrayType type) {
+switch (type) {
+  case TYPED_ARRAY_INT8: return "Int8Array";
+  case TYPED_ARRAY_UINT8: return "Uint8Array";
+  case TYPED_ARRAY_UINT8_CLAMPED: return "Uint8ClampedArray";
+  case TYPED_ARRAY_INT16: return "Int16Array";
+  case TYPED_ARRAY_UINT16: return "Uint16Array";
+  case TYPED_ARRAY_INT32: return "Int32Array";
+  case TYPED_ARRAY_UINT32: return "Uint32Array";
+  case TYPED_ARRAY_FLOAT32: return "Float32Array";
+  case TYPED_ARRAY_FLOAT64: return "Float64Array";
+  case TYPED_ARRAY_BIGINT64: return "BigInt64Array";
+  case TYPED_ARRAY_BIGUINT64: return "BigUint64Array";
+  default: return "Uint8Array";
+}}
+
+static jsval_t create_typed_array_like(
+  ant_t *js,
+  jsval_t this_val,
+  TypedArrayType type,
+  ArrayBufferData *buffer,
+  size_t byte_offset,
+  size_t length
+) {
+  jsval_t ab_obj = create_arraybuffer_obj(js, buffer);
+  jsval_t out = create_typed_array_with_buffer(
+    js,type, buffer, byte_offset,
+    length, typedarray_type_name(type), ab_obj
+  );
+  
+  if (is_err(out)) return out;
+  jsval_t proto = js_get_proto(js, this_val);
+  if (is_special_object(proto)) js_set_proto(js, out, proto);
+  
+  return out;
+}
+
+static jsval_t js_arraybuffer_constructor(ant_t *js, jsval_t *args, int nargs) {
   if (vtype(js->new_target) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "ArrayBuffer constructor requires 'new'");
   }
@@ -190,7 +233,7 @@ static jsval_t js_arraybuffer_constructor(struct js *js, jsval_t *args, int narg
 }
 
 // ArrayBuffer.prototype.slice(begin, end)
-static jsval_t js_arraybuffer_slice(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_arraybuffer_slice(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -228,7 +271,7 @@ static jsval_t js_arraybuffer_slice(struct js *js, jsval_t *args, int nargs) {
 }
 
 // ArrayBuffer.prototype.transfer(newLength)
-static jsval_t js_arraybuffer_transfer(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_arraybuffer_transfer(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -273,12 +316,12 @@ static jsval_t js_arraybuffer_transfer(struct js *js, jsval_t *args, int nargs)
 }
 
 // ArrayBuffer.prototype.transferToFixedLength(newLength)
-static jsval_t js_arraybuffer_transferToFixedLength(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_arraybuffer_transferToFixedLength(ant_t *js, jsval_t *args, int nargs) {
   return js_arraybuffer_transfer(js, args, nargs);
 }
 
 // ArrayBuffer.prototype.detached getter
-static jsval_t js_arraybuffer_detached_getter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_arraybuffer_detached_getter(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   if (vtype(data_val) != T_NUM) return js_false;
@@ -289,7 +332,7 @@ static jsval_t js_arraybuffer_detached_getter(struct js *js, jsval_t *args, int
   return js_bool(data->is_detached);
 }
 
-static jsval_t typedarray_index_getter(struct js *js, jsval_t obj, const char *key, size_t key_len) {
+static jsval_t typedarray_index_getter(ant_t *js, jsval_t obj, const char *key, size_t key_len) {
   if (key_len == 0 || key_len > 10) return js_mkundef();
   
   size_t index = 0;
@@ -327,7 +370,7 @@ static jsval_t typedarray_index_getter(struct js *js, jsval_t obj, const char *k
   L_DONE:    return js_mknum(value);
 }
 
-static bool typedarray_index_setter(struct js *js, jsval_t obj, const char *key, size_t key_len, jsval_t value) {
+static bool typedarray_index_setter(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t value) {
   if (key_len == 0 || key_len > 10) return false;
   
   size_t index = 0;
@@ -365,7 +408,53 @@ static bool typedarray_index_setter(struct js *js, jsval_t obj, const char *key,
   S_DONE:    return true;
 }
 
-jsval_t create_arraybuffer_obj(struct js *js, ArrayBufferData *buffer) {
+static bool typedarray_read_number(const TypedArrayData *ta_data, size_t index, double *out) {
+  if (!ta_data || !ta_data->buffer || ta_data->buffer->is_detached || index >= ta_data->length) return false;
+  uint8_t *data = ta_data->buffer->data + ta_data->byte_offset;
+
+  static const void *dispatch[] = {
+    &&R_INT8, &&R_UINT8, &&R_UINT8, &&R_INT16, &&R_UINT16,
+    &&R_INT32, &&R_UINT32, &&R_FLOAT32, &&R_FLOAT64, &&R_FAIL, &&R_FAIL
+  };
+
+  if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto R_FAIL;
+  goto *dispatch[ta_data->type];
+
+  R_INT8:    *out = (double)((int8_t *)data)[index];   return true;
+  R_UINT8:   *out = (double)data[index];               return true;
+  R_INT16:   *out = (double)((int16_t *)data)[index];  return true;
+  R_UINT16:  *out = (double)((uint16_t *)data)[index]; return true;
+  R_INT32:   *out = (double)((int32_t *)data)[index];  return true;
+  R_UINT32:  *out = (double)((uint32_t *)data)[index]; return true;
+  R_FLOAT32: *out = (double)((float *)data)[index];    return true;
+  R_FLOAT64: *out = ((double *)data)[index];           return true;
+  R_FAIL:    return false;
+}
+
+static bool typedarray_write_number(TypedArrayData *ta_data, size_t index, double value) {
+  if (!ta_data || !ta_data->buffer || ta_data->buffer->is_detached || index >= ta_data->length) return false;
+  uint8_t *data = ta_data->buffer->data + ta_data->byte_offset;
+
+  static const void *dispatch[] = {
+    &&W_INT8, &&W_UINT8, &&W_UINT8, &&W_INT16, &&W_UINT16,
+    &&W_INT32, &&W_UINT32, &&W_FLOAT32, &&W_FLOAT64, &&W_FAIL, &&W_FAIL
+  };
+
+  if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto W_FAIL;
+  goto *dispatch[ta_data->type];
+
+  W_INT8:    ((int8_t *)data)[index] = (int8_t)value;     return true;
+  W_UINT8:   data[index] = (uint8_t)value;                return true;
+  W_INT16:   ((int16_t *)data)[index] = (int16_t)value;   return true;
+  W_UINT16:  ((uint16_t *)data)[index] = (uint16_t)value; return true;
+  W_INT32:   ((int32_t *)data)[index] = (int32_t)value;   return true;
+  W_UINT32:  ((uint32_t *)data)[index] = (uint32_t)value; return true;
+  W_FLOAT32: ((float *)data)[index] = (float)value;       return true;
+  W_FLOAT64: ((double *)data)[index] = value;             return true;
+  W_FAIL:    return false;
+}
+
+jsval_t create_arraybuffer_obj(ant_t *js, ArrayBufferData *buffer) {
   jsval_t ab_obj = js_mkobj(js);
   jsval_t ab_proto = js_get_ctor_proto(js, "ArrayBuffer", 11);
   if (is_special_object(ab_proto)) js_set_proto(js, ab_obj, ab_proto);
@@ -378,7 +467,7 @@ jsval_t create_arraybuffer_obj(struct js *js, ArrayBufferData *buffer) {
 }
 
 jsval_t create_typed_array_with_buffer(
-  struct js *js, TypedArrayType type, ArrayBufferData *buffer,
+  ant_t *js, TypedArrayType type, ArrayBufferData *buffer,
   size_t byte_offset, size_t length, const char *type_name, jsval_t arraybuffer_obj
 ) {
   TypedArrayData *ta_data = ta_arena_alloc(sizeof(TypedArrayData));
@@ -410,7 +499,7 @@ jsval_t create_typed_array_with_buffer(
 }
 
 jsval_t create_typed_array(
-  struct js *js, TypedArrayType type, ArrayBufferData *buffer,
+  ant_t *js, TypedArrayType type, ArrayBufferData *buffer,
   size_t byte_offset, size_t length, const char *type_name
 ) {
   jsval_t ab_obj = create_arraybuffer_obj(js, buffer);
@@ -424,7 +513,7 @@ typedef struct {
   size_t capacity;
 } iter_collect_ctx_t;
 
-static bool iter_collect_callback(struct js *js, jsval_t value, void *udata) {
+static bool iter_collect_callback(ant_t *js, jsval_t value, void *udata) {
   (void)js;
   iter_collect_ctx_t *ctx = (iter_collect_ctx_t *)udata;
   if (ctx->length >= ctx->capacity) {
@@ -437,7 +526,7 @@ static bool iter_collect_callback(struct js *js, jsval_t value, void *udata) {
   return true;
 }
 
-static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs, TypedArrayType type, const char *type_name) {
+static jsval_t js_typedarray_constructor(ant_t *js, jsval_t *args, int nargs, TypedArrayType type, const char *type_name) {
   if (nargs == 0) {
     ArrayBufferData *buffer = create_array_buffer_data(0);
     return create_typed_array(js, type, buffer, 0, 0, type_name);
@@ -540,7 +629,42 @@ static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs
 }
 
 // TypedArray.prototype.slice(begin, end)
-static jsval_t js_typedarray_slice(struct js *js, jsval_t *args, int nargs) {
+// TypedArray.prototype.at(index)
+static jsval_t js_typedarray_at(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_val = js_getthis(js);
+  jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
+  
+  TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
+  if (!ta_data) return js_mkerr(js, "Invalid TypedArray");
+  
+  if (nargs == 0 || vtype(args[0]) != T_NUM) return js_mkundef();
+  
+  ssize_t len = (ssize_t)ta_data->length;
+  ssize_t idx = (ssize_t)js_getnum(args[0]);
+  if (idx < 0) idx += len;
+  if (idx < 0 || idx >= len) return js_mkundef();
+  if (!ta_data->buffer || ta_data->buffer->is_detached) return js_mkundef();
+  
+  size_t index = (size_t)idx;
+  uint8_t *data = ta_data->buffer->data + ta_data->byte_offset;
+  double value;
+  
+  switch (ta_data->type) {
+    case TYPED_ARRAY_INT8:         value = (double)((int8_t*)data)[index];   break;
+    case TYPED_ARRAY_UINT8:
+    case TYPED_ARRAY_UINT8_CLAMPED: value = (double)data[index];            break;
+    case TYPED_ARRAY_INT16:        value = (double)((int16_t*)data)[index];  break;
+    case TYPED_ARRAY_UINT16:       value = (double)((uint16_t*)data)[index]; break;
+    case TYPED_ARRAY_INT32:        value = (double)((int32_t*)data)[index];  break;
+    case TYPED_ARRAY_UINT32:       value = (double)((uint32_t*)data)[index]; break;
+    case TYPED_ARRAY_FLOAT32:      value = (double)((float*)data)[index];    break;
+    case TYPED_ARRAY_FLOAT64:      value = ((double*)data)[index];           break;
+    default: return js_mkundef();
+  }
+  return js_mknum(value);
+}
+
+static jsval_t js_typedarray_slice(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -568,11 +692,16 @@ static jsval_t js_typedarray_slice(struct js *js, jsval_t *args, int nargs) {
     new_length * element_size
   );
   
-  return create_typed_array(js, ta_data->type, new_buffer, 0, new_length, "TypedArray");
+  jsval_t out = create_typed_array_like(
+    js, this_val, ta_data->type, 
+    new_buffer, 0, new_length
+  ); free_array_buffer_data(new_buffer);
+  
+  return out;
 }
 
 // TypedArray.prototype.subarray(begin, end)
-static jsval_t js_typedarray_subarray(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_typedarray_subarray(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -593,11 +722,14 @@ static jsval_t js_typedarray_subarray(struct js *js, jsval_t *args, int nargs) {
   size_t element_size = get_element_size(ta_data->type);
   size_t new_offset = ta_data->byte_offset + (size_t)begin * element_size;
   
-  return create_typed_array(js, ta_data->type, ta_data->buffer, new_offset, new_length, "TypedArray");
+  return create_typed_array_like(
+    js, this_val, ta_data->type, 
+    ta_data->buffer, new_offset, new_length
+  );
 }
 
 // TypedArray.prototype.fill(value, start, end)
-static jsval_t js_typedarray_fill(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_typedarray_fill(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -655,8 +787,114 @@ static jsval_t js_typedarray_fill(struct js *js, jsval_t *args, int nargs) {
     return this_val;
 }
 
+// TypedArray.prototype.set(source, offset = 0)
+static jsval_t js_typedarray_set(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr(js, "set requires source argument");
+
+  jsval_t this_val = js_getthis(js);
+  jsval_t dst_ta_val = js_get_slot(js, this_val, SLOT_BUFFER);
+  TypedArrayData *dst = (TypedArrayData *)js_gettypedarray(dst_ta_val);
+  if (!dst) return js_mkerr(js, "Invalid TypedArray");
+  if (!dst->buffer || dst->buffer->is_detached) return js_mkerr(js, "Cannot operate on a detached TypedArray");
+
+  ssize_t offset_i = 0;
+  if (nargs > 1 && vtype(args[1]) == T_NUM) offset_i = (ssize_t)js_getnum(args[1]);
+  if (offset_i < 0) return js_mkerr(js, "Offset out of bounds");
+  size_t offset = (size_t)offset_i;
+  if (offset > dst->length) return js_mkerr(js, "Offset out of bounds");
+
+  jsval_t src_val = args[0];
+  jsval_t src_ta_val = js_get_slot(js, src_val, SLOT_BUFFER);
+  TypedArrayData *src_ta = (TypedArrayData *)js_gettypedarray(src_ta_val);
+
+  if (src_ta && src_ta->buffer && !src_ta->buffer->is_detached) {
+    size_t src_len = src_ta->length;
+    if (offset + src_len > dst->length) return js_mkerr(js, "Source is too large");
+
+    if (src_ta->type == dst->type) {
+      size_t el = get_element_size(dst->type);
+      uint8_t *dst_data = dst->buffer->data + dst->byte_offset + offset * el;
+      uint8_t *src_data = src_ta->buffer->data + src_ta->byte_offset;
+      memmove(dst_data, src_data, src_len * el);
+      return js_mkundef();
+    }
+
+    for (size_t i = 0; i < src_len; i++) {
+      double value = 0;
+      if (!typedarray_read_number(src_ta, i, &value)) value = 0;
+      (void)typedarray_write_number(dst, offset + i, value);
+    }
+    return js_mkundef();
+  }
+
+  if (!is_special_object(src_val) && vtype(src_val) != T_STR) {
+    return js_mkerr(js, "set source must be array-like or TypedArray");
+  }
+
+  size_t src_len = 0;
+  if (vtype(src_val) == T_STR) {
+    src_len = (size_t)vstrlen(js, src_val);
+  } else {
+    jsval_t len_val = js_get(js, src_val, "length");
+    src_len = vtype(len_val) == T_NUM ? (size_t)js_getnum(len_val) : 0;
+  }
+
+  if (offset + src_len > dst->length) return js_mkerr(js, "Source is too large");
+
+  for (size_t i = 0; i < src_len; i++) {
+    double value = 0;
+    if (vtype(src_val) == T_STR) {
+      jsoff_t slen = 0;
+      jsoff_t soff = vstr(js, src_val, &slen);
+      if (i < (size_t)slen) value = (unsigned char)js->mem[soff + (jsoff_t)i];
+    } else {
+      char idx[24];
+      size_t idx_len = uint_to_str(idx, sizeof(idx), (uint64_t)i);
+      idx[idx_len] = '\0';
+      jsval_t elem = js_get(js, src_val, idx);
+      value = vtype(elem) == T_NUM ? js_getnum(elem) : 0;
+    }
+    (void)typedarray_write_number(dst, offset + i, value);
+  }
+
+  return js_mkundef();
+}
+
+// TypedArray.prototype.copyWithin(target, start, end)
+static jsval_t js_typedarray_copyWithin(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_val = js_getthis(js);
+  jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
+  TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_data_val);
+  if (!ta) return js_mkerr(js, "Invalid TypedArray");
+  if (!ta->buffer || ta->buffer->is_detached) return js_mkerr(js, "Cannot operate on a detached TypedArray");
+
+  ssize_t len = (ssize_t)ta->length;
+  if (len <= 0) return this_val;
+
+  ssize_t target = 0, start = 0, end = len;
+  if (nargs > 0 && vtype(args[0]) == T_NUM) target = (ssize_t)js_getnum(args[0]);
+  if (nargs > 1 && vtype(args[1]) == T_NUM) start = (ssize_t)js_getnum(args[1]);
+  if (nargs > 2 && vtype(args[2]) == T_NUM) end = (ssize_t)js_getnum(args[2]);
+
+  target = normalize_index(target, len);
+  start = normalize_index(start, len);
+  end = normalize_index(end, len);
+  if (end < start) end = start;
+  if (target >= len || start >= len || end <= start) return this_val;
+
+  size_t count = (size_t)(end - start);
+  size_t max_to_end = (size_t)(len - target);
+  if (count > max_to_end) count = max_to_end;
+  if (count == 0) return this_val;
+
+  size_t el = get_element_size(ta->type);
+  uint8_t *base = ta->buffer->data + ta->byte_offset;
+  memmove(base + (size_t)target * el, base + (size_t)start * el, count * el);
+  return this_val;
+}
+
 // TypedArray.prototype.toReversed()
-static jsval_t js_typedarray_toReversed(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_typedarray_toReversed(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_val = js_getthis(js);
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
@@ -676,11 +914,16 @@ static jsval_t js_typedarray_toReversed(struct js *js, jsval_t *args, int nargs)
     memcpy(dst + i * element_size, src + (length - 1 - i) * element_size, element_size);
   }
   
-  return create_typed_array(js, ta_data->type, new_buffer, 0, length, "TypedArray");
+  jsval_t out = create_typed_array_like(
+    js, this_val, ta_data->type,
+    new_buffer, 0, length
+  ); free_array_buffer_data(new_buffer);
+  
+  return out;
 }
 
 // TypedArray.prototype.toSorted(comparefn)
-static jsval_t js_typedarray_toSorted(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_typedarray_toSorted(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -693,8 +936,11 @@ static jsval_t js_typedarray_toSorted(struct js *js, jsval_t *args, int nargs) {
   if (!new_buffer) return js_mkerr(js, "Failed to allocate new buffer");
   
   memcpy(new_buffer->data, ta_data->buffer->data + ta_data->byte_offset, length * element_size);
+  jsval_t result = create_typed_array_like(js, this_val, ta_data->type, new_buffer, 0, length);
+  
+  free_array_buffer_data(new_buffer);
+  if (is_err(result)) return result;
   
-  jsval_t result = create_typed_array(js, ta_data->type, new_buffer, 0, length, "TypedArray");
   jsval_t result_ta_val = js_get_slot(js, result, SLOT_BUFFER);
   TypedArrayData *result_ta = (TypedArrayData *)js_gettypedarray(result_ta_val);
   uint8_t *data = result_ta->buffer->data;
@@ -728,7 +974,7 @@ static jsval_t js_typedarray_toSorted(struct js *js, jsval_t *args, int nargs) {
       R_COMPARE:
       if (has_comparefn) {
         jsval_t cmp_args[2] = { js_mknum(a_val), js_mknum(b_val) };
-        jsval_t cmp_result = js_call(js, comparefn, cmp_args, 2);
+        jsval_t cmp_result = sv_vm_call(js->vm, js, comparefn, js_mkundef(), cmp_args, 2, NULL, false);
         cmp = (int)js_getnum(cmp_result);
       } else {
         cmp = (a_val > b_val) ? 1 : ((a_val < b_val) ? -1 : 0);
@@ -761,7 +1007,7 @@ static jsval_t js_typedarray_toSorted(struct js *js, jsval_t *args, int nargs) {
 }
 
 // TypedArray.prototype.with(index, value)
-static jsval_t js_typedarray_with(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_typedarray_with(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "with requires index and value");
   
   jsval_t this_val = js_getthis(js);
@@ -805,11 +1051,16 @@ static jsval_t js_typedarray_with(struct js *js, jsval_t *args, int nargs) {
   W_FLOAT64: ((double*)data)[index] = value; goto W_DONE;
   W_DONE:
   
-  return create_typed_array(js, ta_data->type, new_buffer, 0, length, "TypedArray");
+  jsval_t out = create_typed_array_like(
+    js, this_val, ta_data->type,
+    new_buffer, 0, length
+  ); free_array_buffer_data(new_buffer);
+  
+  return out;
 }
 
 #define DEFINE_TYPEDARRAY_CONSTRUCTOR(name, type) \
-  static jsval_t js_##name##_constructor(struct js *js, jsval_t *args, int nargs) { \
+  static jsval_t js_##name##_constructor(ant_t *js, jsval_t *args, int nargs) { \
     if (vtype(js->new_target) == T_UNDEF) return js_mkerr_typed(js, JS_ERR_TYPE, #name " constructor requires 'new'"); \
     return js_typedarray_constructor(js, args, nargs, type, #name); \
   }
@@ -826,7 +1077,7 @@ DEFINE_TYPEDARRAY_CONSTRUCTOR(Float64Array, TYPED_ARRAY_FLOAT64)
 DEFINE_TYPEDARRAY_CONSTRUCTOR(BigInt64Array, TYPED_ARRAY_BIGINT64)
 DEFINE_TYPEDARRAY_CONSTRUCTOR(BigUint64Array, TYPED_ARRAY_BIGUINT64)
 
-static jsval_t js_dataview_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_constructor(ant_t *js, jsval_t *args, int nargs) {
   if (vtype(js->new_target) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "DataView constructor requires 'new'");
   }
@@ -881,7 +1132,7 @@ static jsval_t js_dataview_constructor(struct js *js, jsval_t *args, int nargs)
 }
 
 // DataView.prototype.getUint8(byteOffset)
-static jsval_t js_dataview_getUint8(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_getUint8(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "getUint8 requires byteOffset");
   
   jsval_t this_val = js_getthis(js);
@@ -903,7 +1154,7 @@ static jsval_t js_dataview_getUint8(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.setUint8(byteOffset, value)
-static jsval_t js_dataview_setUint8(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_setUint8(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "setUint8 requires byteOffset and value");
   
   jsval_t this_val = js_getthis(js);
@@ -926,7 +1177,7 @@ static jsval_t js_dataview_setUint8(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.getInt16(byteOffset, littleEndian)
-static jsval_t js_dataview_getInt16(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_getInt16(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "getInt16 requires byteOffset");
   
   jsval_t this_val = js_getthis(js);
@@ -957,7 +1208,7 @@ static jsval_t js_dataview_getInt16(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.getInt32(byteOffset, littleEndian)
-static jsval_t js_dataview_getInt32(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_getInt32(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "getInt32 requires byteOffset");
   
   jsval_t this_val = js_getthis(js);
@@ -988,7 +1239,7 @@ static jsval_t js_dataview_getInt32(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.getFloat32(byteOffset, littleEndian)
-static jsval_t js_dataview_getFloat32(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_getFloat32(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "getFloat32 requires byteOffset");
   
   jsval_t this_val = js_getthis(js);
@@ -1021,7 +1272,7 @@ static jsval_t js_dataview_getFloat32(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.setInt16(byteOffset, value, littleEndian)
-static jsval_t js_dataview_setInt16(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_setInt16(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "setInt16 requires byteOffset and value");
   
   jsval_t this_val = js_getthis(js);
@@ -1054,7 +1305,7 @@ static jsval_t js_dataview_setInt16(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.setInt32(byteOffset, value, littleEndian)
-static jsval_t js_dataview_setInt32(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_setInt32(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "setInt32 requires byteOffset and value");
   
   jsval_t this_val = js_getthis(js);
@@ -1091,7 +1342,7 @@ static jsval_t js_dataview_setInt32(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.setFloat32(byteOffset, value, littleEndian)
-static jsval_t js_dataview_setFloat32(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_setFloat32(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "setFloat32 requires byteOffset and value");
   
   jsval_t this_val = js_getthis(js);
@@ -1130,7 +1381,7 @@ static jsval_t js_dataview_setFloat32(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.getFloat64(byteOffset, littleEndian)
-static jsval_t js_dataview_getFloat64(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_getFloat64(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "getFloat64 requires byteOffset");
   
   jsval_t this_val = js_getthis(js);
@@ -1165,7 +1416,7 @@ static jsval_t js_dataview_getFloat64(struct js *js, jsval_t *args, int nargs) {
 }
 
 // DataView.prototype.setFloat64(byteOffset, value, littleEndian)
-static jsval_t js_dataview_setFloat64(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dataview_setFloat64(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "setFloat64 requires byteOffset and value");
   
   jsval_t this_val = js_getthis(js);
@@ -1258,7 +1509,7 @@ static BufferEncoding parse_encoding(const char *enc, size_t len) {
 }
 
 // Buffer.from(array/string/buffer, encoding)
-static jsval_t js_buffer_from(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_from(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Buffer.from requires at least one argument");
   
   if (vtype(args[0]) == T_STR) {
@@ -1336,7 +1587,7 @@ static jsval_t js_buffer_from(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.alloc(size)
-static jsval_t js_buffer_alloc(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_alloc(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Buffer.alloc requires a size argument");
   }
@@ -1350,7 +1601,7 @@ static jsval_t js_buffer_alloc(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.allocUnsafe(size)
-static jsval_t js_buffer_allocUnsafe(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_allocUnsafe(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Buffer.allocUnsafe requires a size argument");
   }
@@ -1361,8 +1612,85 @@ static jsval_t js_buffer_allocUnsafe(struct js *js, jsval_t *args, int nargs) {
   return create_typed_array(js, TYPED_ARRAY_UINT8, buffer, 0, size, "Buffer");
 }
 
+static jsval_t typedarray_join_with(ant_t *js, jsval_t this_val, const char *sep, size_t sep_len) {
+  jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
+
+  TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
+  if (!ta_data) return js_mkstr(js, "", 0);
+  if (!ta_data->buffer || ta_data->buffer->is_detached || ta_data->length == 0)
+    return js_mkstr(js, "", 0);
+
+  uint8_t *data = ta_data->buffer->data + ta_data->byte_offset;
+  size_t len = ta_data->length;
+
+  size_t cap = len * 12;
+  char *buf = malloc(cap);
+  if (!buf) return js_mkerr(js, "Out of memory");
+  size_t pos = 0;
+
+  for (size_t i = 0; i < len; i++) {
+    if (i > 0) {
+      if (pos + sep_len + 32 > cap) {
+        cap *= 2;
+        char *tmp = realloc(buf, cap);
+        if (!tmp) { free(buf); return js_mkerr(js, "Out of memory"); }
+        buf = tmp;
+      }
+      memcpy(buf + pos, sep, sep_len);
+      pos += sep_len;
+    }
+
+    if (pos + 32 > cap) {
+      cap *= 2;
+      char *tmp = realloc(buf, cap);
+      if (!tmp) { free(buf); return js_mkerr(js, "Out of memory"); }
+      buf = tmp;
+    }
+
+    int written = 0;
+    switch (ta_data->type) {
+      case TYPED_ARRAY_INT8:          written = snprintf(buf + pos, cap - pos, "%d", ((int8_t*)data)[i]); break;
+      case TYPED_ARRAY_UINT8:
+      case TYPED_ARRAY_UINT8_CLAMPED: written = snprintf(buf + pos, cap - pos, "%u", data[i]); break;
+      case TYPED_ARRAY_INT16:         written = snprintf(buf + pos, cap - pos, "%d", ((int16_t*)data)[i]); break;
+      case TYPED_ARRAY_UINT16:        written = snprintf(buf + pos, cap - pos, "%u", ((uint16_t*)data)[i]); break;
+      case TYPED_ARRAY_INT32:         written = snprintf(buf + pos, cap - pos, "%d", ((int32_t*)data)[i]); break;
+      case TYPED_ARRAY_UINT32:        written = snprintf(buf + pos, cap - pos, "%u", ((uint32_t*)data)[i]); break;
+      case TYPED_ARRAY_FLOAT32:       written = snprintf(buf + pos, cap - pos, "%g", (double)((float*)data)[i]); break;
+      case TYPED_ARRAY_FLOAT64:       written = snprintf(buf + pos, cap - pos, "%g", ((double*)data)[i]); break;
+      case TYPED_ARRAY_BIGINT64:      written = snprintf(buf + pos, cap - pos, "%lld", ((long long*)data)[i]); break;
+      case TYPED_ARRAY_BIGUINT64:     written = snprintf(buf + pos, cap - pos, "%llu", ((unsigned long long*)data)[i]); break;
+      default: break;
+    }
+    if (written > 0) pos += (size_t)written;
+  }
+
+  jsval_t ret = js_mkstr(js, buf, pos);
+  free(buf);
+  return ret;
+}
+
+// TypedArray.prototype.toString()
+static jsval_t js_typedarray_toString(ant_t *js, jsval_t *args, int nargs) {
+  return typedarray_join_with(js, js_getthis(js), ",", 1);
+}
+
+// TypedArray.prototype.join(separator)
+static jsval_t js_typedarray_join(ant_t *js, jsval_t *args, int nargs) {
+  const char *sep = ",";
+  size_t sep_len = 1;
+  if (nargs > 0 && vtype(args[0]) == T_STR)
+    sep = js_getstr(js, args[0], &sep_len);
+  return typedarray_join_with(js, js_getthis(js), sep, sep_len);
+}
+
 // Buffer.prototype.toString(encoding)
-static jsval_t js_buffer_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_slice(ant_t *js, jsval_t *args, int nargs) {
+  return js_typedarray_subarray(js, args, nargs);
+}
+
+// Buffer.prototype.toString(encoding)
+static jsval_t js_buffer_toString(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t ta_data_val = js_get_slot(js, this_val, SLOT_BUFFER);
   
@@ -1414,7 +1742,7 @@ static jsval_t js_buffer_toString(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.prototype.toBase64()
-static jsval_t js_buffer_toBase64(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_toBase64(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t encoding_arg = js_mkstr(js, "base64", 6);
   jsval_t new_args[1] = {encoding_arg};
@@ -1422,7 +1750,7 @@ static jsval_t js_buffer_toBase64(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.prototype.write(string, offset, length, encoding)
-static jsval_t js_buffer_write(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_write(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "write requires a string");
   
   jsval_t this_val = js_getthis(js);
@@ -1457,7 +1785,7 @@ static jsval_t js_buffer_write(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.isBuffer(obj)
-static jsval_t js_buffer_isBuffer(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_isBuffer(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_false;
   if (!is_special_object(args[0])) return js_false;
   
@@ -1468,7 +1796,7 @@ static jsval_t js_buffer_isBuffer(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.isEncoding(encoding)
-static jsval_t js_buffer_isEncoding(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_isEncoding(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_STR) return js_false;
   
   size_t len;
@@ -1492,7 +1820,7 @@ static jsval_t js_buffer_isEncoding(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.byteLength(string, encoding)
-static jsval_t js_buffer_byteLength(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_byteLength(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mknum(0);
   
   jsval_t arg = args[0];
@@ -1515,7 +1843,7 @@ static jsval_t js_buffer_byteLength(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.concat(list, totalLength)
-static jsval_t js_buffer_concat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_concat(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || !is_special_object(args[0])) {
     return js_mkerr(js, "First argument must be an array");
   }
@@ -1567,7 +1895,7 @@ static jsval_t js_buffer_concat(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Buffer.compare(buf1, buf2)
-static jsval_t js_buffer_compare(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_buffer_compare(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "Buffer.compare requires two arguments");
   
   jsval_t ta1_val = js_get_slot(js, args[0], SLOT_BUFFER);
@@ -1595,7 +1923,7 @@ static jsval_t js_buffer_compare(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)cmp);
 }
 
-static jsval_t js_sharedarraybuffer_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sharedarraybuffer_constructor(ant_t *js, jsval_t *args, int nargs) {
   if (vtype(js->new_target) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "SharedArrayBuffer constructor requires 'new'");
   }
@@ -1619,6 +1947,10 @@ static jsval_t js_sharedarraybuffer_constructor(struct js *js, jsval_t *args, in
   return obj;
 }
 
+jsval_t buffer_library(ant_t *js) {
+  return js_get(js, js_glob(js), "Buffer");
+}
+
 void init_buffer_module() {
   ant_t *js = rt->js;
   
@@ -1633,7 +1965,7 @@ void init_buffer_module() {
   js_set(js, arraybuffer_proto, "transfer", js_mkfun(js_arraybuffer_transfer));
   js_set(js, arraybuffer_proto, "transferToFixedLength", js_mkfun(js_arraybuffer_transferToFixedLength));
   js_set_getter_desc(js, arraybuffer_proto, "detached", 8, js_mkfun(js_arraybuffer_detached_getter), JS_DESC_E);
-  js_set(js, arraybuffer_proto, get_toStringTag_sym_key(), js_mkstr(js, "ArrayBuffer", 11));
+  js_set_sym(js, arraybuffer_proto, get_toStringTag_sym(), js_mkstr(js, "ArrayBuffer", 11));
   
   js_set_slot(js, arraybuffer_ctor_obj, SLOT_CFUNC, js_mkfun(js_arraybuffer_constructor));
   js_mkprop_fast(js, arraybuffer_ctor_obj, "prototype", 9, arraybuffer_proto);
@@ -1645,13 +1977,23 @@ void init_buffer_module() {
   jsval_t typedarray_proto = js_mkobj(js);
   js_set_proto(js, typedarray_proto, object_proto);
   
+  js_set(js, typedarray_proto, "at", js_mkfun(js_typedarray_at));
+  js_set(js, typedarray_proto, "set", js_mkfun(js_typedarray_set));
+  js_set(js, typedarray_proto, "copyWithin", js_mkfun(js_typedarray_copyWithin));
   js_set(js, typedarray_proto, "slice", js_mkfun(js_typedarray_slice));
   js_set(js, typedarray_proto, "subarray", js_mkfun(js_typedarray_subarray));
   js_set(js, typedarray_proto, "fill", js_mkfun(js_typedarray_fill));
   js_set(js, typedarray_proto, "toReversed", js_mkfun(js_typedarray_toReversed));
   js_set(js, typedarray_proto, "toSorted", js_mkfun(js_typedarray_toSorted));
   js_set(js, typedarray_proto, "with", js_mkfun(js_typedarray_with));
-  js_set(js, typedarray_proto, get_toStringTag_sym_key(), js_mkstr(js, "TypedArray", 10));
+  js_set(js, typedarray_proto, "toString", js_mkfun(js_typedarray_toString));
+  js_set(js, typedarray_proto, "join", js_mkfun(js_typedarray_join));
+  js_set_sym(js, typedarray_proto, get_toStringTag_sym(), js_mkstr(js, "TypedArray", 10));
+
+  jsval_t array_proto = js_get(js, js_get(js, glob, "Array"), "prototype");
+  jsval_t iter_fn = js_get_sym(js, array_proto, get_iterator_sym());
+  js_set_sym(js, typedarray_proto, get_iterator_sym(), iter_fn);
+  js_set(js, typedarray_proto, "values", iter_fn);
   
   #define SETUP_TYPEDARRAY(name) \
     do { \
@@ -1692,7 +2034,7 @@ void init_buffer_module() {
   js_set(js, dataview_proto, "setFloat32", js_mkfun(js_dataview_setFloat32));
   js_set(js, dataview_proto, "getFloat64", js_mkfun(js_dataview_getFloat64));
   js_set(js, dataview_proto, "setFloat64", js_mkfun(js_dataview_setFloat64));
-  js_set(js, dataview_proto, get_toStringTag_sym_key(), js_mkstr(js, "DataView", 8));
+  js_set_sym(js, dataview_proto, get_toStringTag_sym(), js_mkstr(js, "DataView", 8));
 
   js_set_slot(js, dataview_ctor_obj, SLOT_CFUNC, js_mkfun(js_dataview_constructor));
   js_mkprop_fast(js, dataview_ctor_obj, "prototype", 9, dataview_proto);
@@ -1705,7 +2047,7 @@ void init_buffer_module() {
   js_set_proto(js, sharedarraybuffer_proto, object_proto);
   
   js_set(js, sharedarraybuffer_proto, "slice", js_mkfun(js_arraybuffer_slice));
-  js_set(js, sharedarraybuffer_proto, get_toStringTag_sym_key(), js_mkstr(js, "SharedArrayBuffer", 17));
+  js_set_sym(js, sharedarraybuffer_proto, get_toStringTag_sym(), js_mkstr(js, "SharedArrayBuffer", 17));
   
   js_set_slot(js, sharedarraybuffer_ctor_obj, SLOT_CFUNC, js_mkfun(js_sharedarraybuffer_constructor));
   js_mkprop_fast(js, sharedarraybuffer_ctor_obj, "prototype", 9, sharedarraybuffer_proto);
@@ -1715,12 +2057,20 @@ void init_buffer_module() {
   
   jsval_t buffer_ctor_obj = js_mkobj(js);
   jsval_t buffer_proto = js_mkobj(js);
-  js_set_proto(js, buffer_proto, object_proto);
   
+  jsval_t uint8array_ctor = js_get(js, glob, "Uint8Array");
+  jsval_t uint8array_proto = js_get(js, uint8array_ctor, "prototype");
+  
+  if (is_special_object(uint8array_proto)) js_set_proto(js, buffer_proto, uint8array_proto);
+  else js_set_proto(js, buffer_proto, typedarray_proto);
+  
+  js_set(js, buffer_proto, "slice", js_mkfun(js_buffer_slice));
   js_set(js, buffer_proto, "toString", js_mkfun(js_buffer_toString));
   js_set(js, buffer_proto, "toBase64", js_mkfun(js_buffer_toBase64));
   js_set(js, buffer_proto, "write", js_mkfun(js_buffer_write));
-  js_set(js, buffer_proto, get_toStringTag_sym_key(), js_mkstr(js, "Buffer", 6));
+  js_set_sym(js, buffer_proto, get_toStringTag_sym(), js_mkstr(js, "Buffer", 6));
+  js_set_sym(js, buffer_proto, get_iterator_sym(), iter_fn);
+  js_set(js, buffer_proto, "values", iter_fn);
   
   js_set(js, buffer_ctor_obj, "from", js_mkfun(js_buffer_from));
   js_set(js, buffer_ctor_obj, "alloc", js_mkfun(js_buffer_alloc));
diff --git a/src/modules/builtin.c b/src/modules/builtin.c
index 8d42d19..119b64d 100644
--- a/src/modules/builtin.c
+++ b/src/modules/builtin.c
@@ -17,30 +17,31 @@
 #include "errors.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/engine.h"
 #include "modules/builtin.h"
 #include "modules/buffer.h"
 #include "modules/collections.h"
 
 static struct {
-  struct js *js;
+  ant_t *js;
   jsval_t handler;
 } signal_handlers[NSIG] = {0};
 
 static void general_signal_handler(int signum) {
   if (signum < 0 || signum >= NSIG) return;
-  struct js *js = signal_handlers[signum].js;
+  ant_t *js = signal_handlers[signum].js;
   jsval_t handler = signal_handlers[signum].handler;
   
   if (js && vtype(handler) != T_UNDEF) {
     jsval_t args[] = {js_mknum(signum)};
-    js_call(js, handler, args, 1);
+    sv_vm_call(js->vm, js, handler, js_mkundef(), args, 1, NULL, false);
   }
   
   exit(0);
 }
 
 // Ant.signal(signal, handler)
-static jsval_t js_signal(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_signal(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "Ant.signal() requires 2 arguments");
   
   int signum = (int)js_getnum(args[0]);
@@ -55,21 +56,15 @@ static jsval_t js_signal(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-// Ant.gc()
-static jsval_t js_gc_trigger(struct js *js, jsval_t *args, int nargs) {
-  js->needs_gc = true;
-  return js_mkundef();
-}
-
 // Ant.raw.typeof(jsval_t)
-static jsval_t js_raw_typeof(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_raw_typeof(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Ant.raw.typeof() requires 1 argument");
   const uint8_t type = vtype(args[0]);
   return js_mknum((double)type);
 }
 
 // Ant.sleep(seconds)
-static jsval_t js_sleep(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sleep(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Ant.sleep() requires 1 argument");
   unsigned int seconds = (unsigned int)js_getnum(args[0]);
   sleep(seconds);
@@ -77,7 +72,7 @@ static jsval_t js_sleep(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Ant.msleep(milliseconds)
-static jsval_t js_msleep(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_msleep(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Ant.msleep() requires 1 argument");
   long ms = (long)js_getnum(args[0]);
   struct timespec ts = { .tv_sec = ms / 1000, .tv_nsec = (ms % 1000) * 1000000 };
@@ -87,7 +82,7 @@ static jsval_t js_msleep(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Ant.usleep(microseconds)
-static jsval_t js_usleep(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_usleep(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Ant.usleep() requires 1 argument");
   useconds_t us = (useconds_t)js_getnum(args[0]);
   usleep(us);
@@ -95,7 +90,7 @@ static jsval_t js_usleep(struct js *js, jsval_t *args, int nargs) {
 }
 
 // Ant.stats()
-static jsval_t js_stats_fn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_stats_fn(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   jsval_t result = js_newobj(js);
   
@@ -121,9 +116,19 @@ static jsval_t js_stats_fn(struct js *js, jsval_t *args, int nargs) {
   js_set(js, intern, "bytes", js_mknum((double)intern_stats.bytes));
   js_set(js, result, "intern", intern);
   
-  if (js->cstk != NULL) {
+  if (js->vm) {
+    sv_vm_t *vm = js->vm;
+    jsval_t vmobj = js_newobj(js);
+    js_set(js, vmobj, "stackSize", js_mknum((double)vm->stack_size));
+    js_set(js, vmobj, "stackUsed", js_mknum((double)vm->sp));
+    js_set(js, vmobj, "maxFrames", js_mknum((double)vm->max_frames));
+    js_set(js, vmobj, "framesUsed", js_mknum((double)(vm->fp + 1)));
+    js_set(js, result, "vm", vmobj);
+  }
+
+  if (js->cstk.base != NULL) {
     volatile char marker;
-    uintptr_t base = (uintptr_t)js->cstk;
+    uintptr_t base = (uintptr_t)js->cstk.base;
     uintptr_t curr = (uintptr_t)&marker;
     size_t used = (base > curr) ? (base - curr) : (curr - base);
     js_set(js, result, "cstack", js_mknum((double)used));
@@ -147,10 +152,9 @@ static jsval_t js_stats_fn(struct js *js, jsval_t *args, int nargs) {
 }
 
 void init_builtin_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t ant_obj = rt->ant_obj;
 
-  js_set(js, ant_obj, "gc", js_mkfun(js_gc_trigger));
   js_set(js, ant_obj, "stats", js_mkfun(js_stats_fn));
   js_set(js, ant_obj, "signal", js_mkfun(js_signal));
   js_set(js, ant_obj, "sleep", js_mkfun(js_sleep));
diff --git a/src/modules/child_process.c b/src/modules/child_process.c
index 2de1601..7acafef 100644
--- a/src/modules/child_process.c
+++ b/src/modules/child_process.c
@@ -25,13 +25,29 @@
 #include "ant.h"
 #include "errors.h"
 #include "internal.h"
+#include "silver/engine.h"
 
 #include "modules/child_process.h"
+#include "modules/buffer.h"
 #include "modules/symbol.h"
 
 #define MAX_CHILD_LISTENERS 16
 #define PIPE_READ_BUF_SIZE 65536
 
+typedef struct 
+  child_process_s child_process_t;
+
+typedef enum {
+  CHILD_STREAM_STDIN = 0,
+  CHILD_STREAM_STDOUT = 1,
+  CHILD_STREAM_STDERR = 2,
+} child_stream_kind_t;
+
+typedef struct {
+  child_process_t *cp;
+  child_stream_kind_t kind;
+} child_stream_ctx_t;
+
 typedef struct {
   jsval_t callback;
   bool once;
@@ -44,13 +60,19 @@ typedef struct {
   UT_hash_handle hh;
 } child_event_t;
 
-typedef struct child_process_s {
-  struct js *js;
+struct child_process_s {
+  ant_t *js;
   uv_process_t process;
   uv_pipe_t stdin_pipe;
   uv_pipe_t stdout_pipe;
   uv_pipe_t stderr_pipe;
   jsval_t child_obj;
+  jsval_t stdin_obj;
+  jsval_t stdout_obj;
+  jsval_t stderr_obj;
+  child_stream_ctx_t *stdin_ctx;
+  child_stream_ctx_t *stdout_ctx;
+  child_stream_ctx_t *stderr_ctx;
   jsval_t promise;
   child_event_t *events;
   char *stdout_buf;
@@ -68,15 +90,109 @@ typedef struct child_process_s {
   bool use_shell;
   bool detached;
   bool close_emitted;
+  bool keep_alive;
   int pending_closes;
   char *cwd;
   struct child_process_s *next;
   struct child_process_s *prev;
-} child_process_t;
+};
 
 static child_process_t *pending_children_head = NULL;
 static child_process_t *pending_children_tail = NULL;
 
+static void fprint_js_str_raw(FILE *out, ant_t *js, jsval_t s) {
+  if (vtype(s) != T_STR) {
+    fprintf(out, "%s\n", js_str(js, s));
+    return;
+  }
+
+  jsoff_t len = 0;
+  jsoff_t off = vstr(js, s, &len);
+  if (off > 0 && len > 0) fwrite(&js->mem[off], 1, (size_t)len, out);
+  if (len == 0 || js->mem[off + len - 1] != '\n') fputc('\n', out);
+}
+
+static void log_listener_error(ant_t *js, const char *event_name, jsval_t err) {
+  jsval_t thrown_stack = js->thrown_stack;
+  if (vtype(thrown_stack) == T_STR) {
+    fprintf(stderr, "Error in child_process '%s' listener:\n", event_name);
+    fprint_js_str_raw(stderr, js, thrown_stack);
+    return;
+  }
+
+  jsval_t thrown_value = js->thrown_value;
+  jsval_t src = (vtype(thrown_value) != T_UNDEF) ? thrown_value : err;
+  
+  jsval_t stack = js_get(js, src, "stack");
+  if (vtype(stack) == T_STR) {
+    fprintf(stderr, "Error in child_process '%s' listener:\n", event_name);
+    fprint_js_str_raw(stderr, js, stack);
+    return;
+  }
+
+  jsval_t name = js_get(js, src, "name");
+  jsval_t message = js_get(js, src, "message");
+
+  const char *detail = NULL;
+  if (vtype(name) == T_STR && vtype(message) == T_STR) {
+    const char *name_s = js_str(js, name);
+    const char *msg_s = js_str(js, message);
+    if (msg_s && msg_s[0]) fprintf(stderr, "Error in child_process '%s' listener: %s: %s\n", event_name, name_s, msg_s);
+    else detail = name_s;
+  } 
+  else if (vtype(message) == T_STR) detail = js_str(js, message);
+  else detail = js_str(js, src);
+  
+  if (detail) fprintf(stderr, "Error in child_process '%s' listener: %s\n", event_name, detail);
+  js_print_stack_trace_vm(js, stderr);
+}
+
+static void emit_event(child_process_t *cp, const char *name, jsval_t *args, int nargs) {
+  child_event_t *evt = NULL;
+  HASH_FIND_STR(cp->events, name, evt);
+  if (!evt || evt->count == 0) return;
+  
+  int i = 0;
+  while (i < evt->count) {
+    child_listener_t *l = &evt->listeners[i];
+    jsval_t result = sv_vm_call(cp->js->vm, cp->js, l->callback, js_mkundef(), args, nargs, NULL, false);
+    if (vtype(result) == T_ERR) log_listener_error(cp->js, name, result);
+    if (l->once) {
+      for (int j = i; j < evt->count - 1; j++) 
+        evt->listeners[j] = evt->listeners[j + 1];
+      evt->count--;
+    } else i++;
+  }
+}
+
+static const char *stream_kind_name(child_stream_kind_t kind) {
+  switch (kind) {
+    case CHILD_STREAM_STDIN: return "stdin";
+    case CHILD_STREAM_STDOUT: return "stdout";
+    case CHILD_STREAM_STDERR: return "stderr";
+    default: return "unknown";
+  }
+}
+
+static void emit_stream_event(
+  child_process_t *cp,
+  child_stream_kind_t kind,
+  const char *event,
+  jsval_t *args,
+  int nargs
+) {
+  char full_name[64];
+  snprintf(full_name, sizeof(full_name), "%s:%s", stream_kind_name(kind), event);
+  emit_event(cp, full_name, args, nargs);
+}
+
+static jsval_t make_uint8array_chunk(ant_t *js, const char *data, size_t len) {
+  ArrayBufferData *ab = create_array_buffer_data(len);
+  if (!ab) return js_mkerr(js, "Out of memory");
+  if (len > 0 && data) memcpy(ab->data, data, len);
+  return create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, len, "Uint8Array");
+}
+
 static void add_pending_child(child_process_t *cp) {
   cp->next = NULL;
   cp->prev = pending_children_tail;
@@ -97,9 +213,13 @@ static void remove_pending_child(child_process_t *cp) {
 
 static void free_child_process(child_process_t *cp) {
   if (!cp) return;
+  
   if (cp->stdout_buf) free(cp->stdout_buf);
   if (cp->stderr_buf) free(cp->stderr_buf);
   if (cp->cwd) free(cp->cwd);
+  if (cp->stdin_ctx) free(cp->stdin_ctx);
+  if (cp->stdout_ctx) free(cp->stdout_ctx);
+  if (cp->stderr_ctx) free(cp->stderr_ctx);
   
   child_event_t *evt, *tmp;
   HASH_ITER(hh, cp->events, evt, tmp) {
@@ -123,27 +243,6 @@ static child_event_t *find_or_create_event(child_process_t *cp, const char *name
   return evt;
 }
 
-static void emit_event(child_process_t *cp, const char *name, jsval_t *args, int nargs) {
-  child_event_t *evt = NULL;
-  HASH_FIND_STR(cp->events, name, evt);
-  if (!evt || evt->count == 0) return;
-  
-  int i = 0;
-  while (i < evt->count) {
-    child_listener_t *l = &evt->listeners[i];
-    jsval_t result = js_call(cp->js, l->callback, args, nargs);
-    if (vtype(result) == T_ERR) {
-      fprintf(stderr, "Error in child_process '%s' listener: %s\n", name, js_str(cp->js, result));
-    }
-    if (l->once) {
-      for (int j = i; j < evt->count - 1; j++) {
-        evt->listeners[j] = evt->listeners[j + 1];
-      }
-      evt->count--;
-    } else i++;
-  }
-}
-
 static void try_free_child(child_process_t *cp) {
   if (cp->exited && cp->stdout_closed && cp->stderr_closed && cp->pending_closes == 0) {
     remove_pending_child(cp);
@@ -157,9 +256,19 @@ static void check_completion(child_process_t *cp) {
     
     jsval_t stdout_val = js_mkstr(cp->js, cp->stdout_buf ? cp->stdout_buf : "", cp->stdout_len);
     jsval_t stderr_val = js_mkstr(cp->js, cp->stderr_buf ? cp->stderr_buf : "", cp->stderr_len);
+
+    if (vtype(cp->stdout_obj) == T_OBJ) {
+      js_set(cp->js, cp->stdout_obj, "text", stdout_val);
+      js_set(cp->js, cp->stdout_obj, "length", js_mknum((double)cp->stdout_len));
+    }
     
-    js_set(cp->js, cp->child_obj, "stdout", stdout_val);
-    js_set(cp->js, cp->child_obj, "stderr", stderr_val);
+    if (vtype(cp->stderr_obj) == T_OBJ) {
+      js_set(cp->js, cp->stderr_obj, "text", stderr_val);
+      js_set(cp->js, cp->stderr_obj, "length", js_mknum((double)cp->stderr_len));
+    }
+
+    js_set(cp->js, cp->child_obj, "stdoutText", stdout_val);
+    js_set(cp->js, cp->child_obj, "stderrText", stderr_val);
     js_set(cp->js, cp->child_obj, "exitCode", js_mknum((double)cp->exit_code));
     js_set(cp->js, cp->child_obj, "signalCode", cp->term_signal ? js_mknum((double)cp->term_signal) : js_mknull());
     
@@ -258,9 +367,18 @@ static void on_stdout_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *b
       cp->stdout_len += nread;
     }
     
-    jsval_t data = js_mkstr(cp->js, buf->base, nread);
-    jsval_t data_args[1] = { data };
-    emit_event(cp, "stdout", data_args, 1);
+    jsval_t text_data = js_mkstr(cp->js, buf->base, nread);
+    jsval_t text_args[1] = { text_data };
+    emit_event(cp, "stdout", text_args, 1);
+
+    jsval_t byte_data = make_uint8array_chunk(cp->js, buf->base, (size_t)nread);
+    jsval_t byte_args[1] = { byte_data };
+    emit_stream_event(cp, CHILD_STREAM_STDOUT, "data", byte_args, 1);
+    
+    if (vtype(cp->stdout_obj) == T_OBJ) js_set(
+      cp->js, cp->stdout_obj, "length", 
+      js_mknum((double)cp->stdout_len)
+    );
   }
   
   if (buf->base) free(buf->base);
@@ -269,9 +387,15 @@ static void on_stdout_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *b
     if (nread != UV_EOF) {
       jsval_t err_args[1] = { js_mkstr(cp->js, uv_strerror((int)nread), (int)strlen(uv_strerror((int)nread))) };
       emit_event(cp, "error", err_args, 1);
-    }
+      emit_stream_event(cp, CHILD_STREAM_STDOUT, "error", err_args, 1);
+    } else emit_stream_event(cp, CHILD_STREAM_STDOUT, "end", NULL, 0);
+    
+    if (nread != UV_EOF) 
+      emit_stream_event(cp, CHILD_STREAM_STDOUT, "end", NULL, 0);
+    
     cp->pending_closes++;
     uv_close((uv_handle_t *)stream, on_handle_close);
+    
     cp->stdout_closed = true;
     check_completion(cp);
   }
@@ -295,22 +419,41 @@ static void on_stderr_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *b
       cp->stderr_len += nread;
     }
     
-    jsval_t data = js_mkstr(cp->js, buf->base, nread);
-    jsval_t data_args[1] = { data };
-    emit_event(cp, "stderr", data_args, 1);
+    jsval_t text_data = js_mkstr(cp->js, buf->base, nread);
+    jsval_t text_args[1] = { text_data };
+    emit_event(cp, "stderr", text_args, 1);
+
+    jsval_t byte_data = make_uint8array_chunk(cp->js, buf->base, (size_t)nread);
+    jsval_t byte_args[1] = { byte_data };
+    emit_stream_event(cp, CHILD_STREAM_STDERR, "data", byte_args, 1);
+    
+    if (vtype(cp->stderr_obj) == T_OBJ) js_set(
+      cp->js, cp->stderr_obj, "length",
+      js_mknum((double)cp->stderr_len)
+    );
   }
   
   if (buf->base) free(buf->base);
   
   if (nread < 0) {
+    if (nread != UV_EOF) {
+      jsval_t err_args[1] = { 
+        js_mkstr(cp->js, uv_strerror((int)nread),
+        (int)strlen(uv_strerror((int)nread)))
+      };
+      emit_stream_event(cp, CHILD_STREAM_STDERR, "error", err_args, 1);
+    }
+    
+    emit_stream_event(cp, CHILD_STREAM_STDERR, "end", NULL, 0);
     cp->pending_closes++;
     uv_close((uv_handle_t *)stream, on_handle_close);
+    
     cp->stderr_closed = true;
     check_completion(cp);
   }
 }
 
-static jsval_t child_on(struct js *js, jsval_t *args, int nargs) {
+static jsval_t child_on(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   if (nargs < 2) return js_mkerr(js, "on() requires event name and callback");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Event name must be a string");
@@ -339,7 +482,7 @@ static jsval_t child_on(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t child_once(struct js *js, jsval_t *args, int nargs) {
+static jsval_t child_once(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   if (nargs < 2) return js_mkerr(js, "once() requires event name and callback");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Event name must be a string");
@@ -368,7 +511,7 @@ static jsval_t child_once(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t child_kill(struct js *js, jsval_t *args, int nargs) {
+static jsval_t child_kill(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
@@ -396,20 +539,25 @@ static jsval_t child_kill(struct js *js, jsval_t *args, int nargs) {
   return js_bool(result == 0);
 }
 
-static jsval_t child_write(struct js *js, jsval_t *args, int nargs) {
-  jsval_t this_obj = js_getthis(js);
-  if (nargs < 1) return js_mkerr(js, "write() requires data argument");
-  
-  jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
-  if (vtype(cp_ptr) == T_UNDEF) return js_mkerr(js, "Invalid child process object");
-  
-  child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
+static jsval_t child_write_impl(ant_t *js, child_process_t *cp, jsval_t data_arg) {
   if (cp->stdin_closed) return js_false;
   
-  size_t data_len;
-  char *data = js_getstr(js, args[0], &data_len);
-  if (!data) return js_mkerr(js, "Data must be a string");
+  const char *data = NULL;
+  size_t data_len = 0;
   
+  if (vtype(data_arg) == T_STR) {
+    data = js_getstr(js, data_arg, &data_len);
+    if (!data) return js_mkerr(js, "Data must be a string or Buffer");
+  } else {
+    jsval_t ta_data_val = js_get_slot(js, data_arg, SLOT_BUFFER);
+    TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
+    if (!ta_data || !ta_data->buffer || !ta_data->buffer->data) {
+      return js_mkerr(js, "Data must be a string or Buffer");
+    }
+    data = (const char *)(ta_data->buffer->data + ta_data->byte_offset);
+    data_len = ta_data->byte_length;
+  }
+
   uv_write_t *write_req = malloc(sizeof(uv_write_t));
   char *buf_data = malloc(data_len);
   memcpy(buf_data, data, data_len);
@@ -419,31 +567,267 @@ static jsval_t child_write(struct js *js, jsval_t *args, int nargs) {
   
   int result = uv_write(write_req, (uv_stream_t *)&cp->stdin_pipe, &buf, 1, NULL);
   if (result < 0) {
-    free(buf_data);
-    free(write_req);
+    jsval_t err_args[1] = { js_mkstr(js, uv_strerror(result), strlen(uv_strerror(result))) };
+    emit_stream_event(cp, CHILD_STREAM_STDIN, "error", err_args, 1);
+    free(buf_data); free(write_req);
     return js_false;
   }
   
   return js_true;
 }
 
-static jsval_t child_end(struct js *js, jsval_t *args, int nargs) {
-  (void)args; (void)nargs;
+static jsval_t child_end_impl(child_process_t *cp) {
+  if (!cp->stdin_closed) {
+    uv_close((uv_handle_t *)&cp->stdin_pipe, NULL);
+    cp->stdin_closed = true;
+  }
+  
+  return js_mkundef();
+}
+
+static jsval_t child_write(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 1) return js_mkerr(js, "write() requires data argument");
+  
+  jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(cp_ptr) == T_UNDEF) return js_mkerr(js, "Invalid child process object");
+  
+  child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
+  return child_write_impl(js, cp, args[0]);
+}
+
+static jsval_t child_ref(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(cp_ptr) == T_UNDEF) return this_obj;
+
+  child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
+  if (!cp) return this_obj;
+  cp->keep_alive = true;
+  
+  if (!uv_is_closing((uv_handle_t *)&cp->process)) uv_ref((uv_handle_t *)&cp->process);
+  if (!uv_is_closing((uv_handle_t *)&cp->stdin_pipe)) uv_ref((uv_handle_t *)&cp->stdin_pipe);
+  if (!uv_is_closing((uv_handle_t *)&cp->stdout_pipe)) uv_ref((uv_handle_t *)&cp->stdout_pipe);
+  if (!uv_is_closing((uv_handle_t *)&cp->stderr_pipe)) uv_ref((uv_handle_t *)&cp->stderr_pipe);
+  
+  return this_obj;
+}
+
+static jsval_t child_unref(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(cp_ptr) == T_UNDEF) return this_obj;
+
+  child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
+  if (!cp) return this_obj;
+  cp->keep_alive = false;
+  if (!uv_is_closing((uv_handle_t *)&cp->process)) uv_unref((uv_handle_t *)&cp->process);
+  if (!uv_is_closing((uv_handle_t *)&cp->stdin_pipe)) uv_unref((uv_handle_t *)&cp->stdin_pipe);
+  if (!uv_is_closing((uv_handle_t *)&cp->stdout_pipe)) uv_unref((uv_handle_t *)&cp->stdout_pipe);
+  if (!uv_is_closing((uv_handle_t *)&cp->stderr_pipe)) uv_unref((uv_handle_t *)&cp->stderr_pipe);
+  return this_obj;
+}
+
+static jsval_t child_end(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
   if (vtype(cp_ptr) == T_UNDEF) return js_mkundef();
   
   child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
-  if (!cp->stdin_closed) {
-    uv_close((uv_handle_t *)&cp->stdin_pipe, NULL);
-    cp->stdin_closed = true;
+  return child_end_impl(cp);
+}
+
+static uv_handle_t *child_stream_handle(child_process_t *cp, child_stream_kind_t kind) {
+  if (!cp) return NULL;
+  switch (kind) {
+    case CHILD_STREAM_STDIN: return (uv_handle_t *)&cp->stdin_pipe;
+    case CHILD_STREAM_STDOUT: return (uv_handle_t *)&cp->stdout_pipe;
+    case CHILD_STREAM_STDERR: return (uv_handle_t *)&cp->stderr_pipe;
+    default: return NULL;
+  }
+}
+
+static jsval_t child_stream_write(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 1) return js_mkerr(js, "write() requires data argument");
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return js_mkerr(js, "Invalid stream object");
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return js_mkerr(js, "Invalid stream context");
+  return child_write_impl(js, ctx->cp, args[0]);
+}
+
+static jsval_t child_stream_end(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t this_obj = js_getthis(js);
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return js_mkundef();
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return js_mkundef();
+  return child_end_impl(ctx->cp);
+}
+
+static jsval_t child_stream_ref(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t this_obj = js_getthis(js);
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return this_obj;
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return this_obj;
+
+  uv_handle_t *h = child_stream_handle(ctx->cp, ctx->kind);
+  if (h && !uv_is_closing(h)) uv_ref(h);
+  return this_obj;
+}
+
+static jsval_t child_stream_unref(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t this_obj = js_getthis(js);
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return this_obj;
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return this_obj;
+
+  uv_handle_t *h = child_stream_handle(ctx->cp, ctx->kind);
+  if (h && !uv_is_closing(h)) uv_unref(h);
+  return this_obj;
+}
+
+static jsval_t child_stream_destroy(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t this_obj = js_getthis(js);
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return this_obj;
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return this_obj;
+
+  child_process_t *cp = ctx->cp;
+  if (ctx->kind == CHILD_STREAM_STDIN) {
+    (void)child_end_impl(cp);
+    return this_obj;
+  }
+
+  uv_handle_t *h = child_stream_handle(cp, ctx->kind);
+  if (h && !uv_is_closing(h)) {
+    if (ctx->kind == CHILD_STREAM_STDOUT) {
+      uv_read_stop((uv_stream_t *)&cp->stdout_pipe);
+      cp->stdout_closed = true;
+    } else if (ctx->kind == CHILD_STREAM_STDERR) {
+      uv_read_stop((uv_stream_t *)&cp->stderr_pipe);
+      cp->stderr_closed = true;
+    }
+    cp->pending_closes++;
+    uv_close(h, on_handle_close);
+    check_completion(cp);
+  }
+
+  return this_obj;
+}
+
+static jsval_t child_stream_on(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 2) return js_mkerr(js, "on() requires event name and callback");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Event name must be a string");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "Callback must be a function");
+
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return js_mkerr(js, "Invalid stream object");
+  
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return js_mkerr(js, "Invalid stream context");
+  
+  child_process_t *cp = ctx->cp;
+  child_stream_kind_t kind = ctx->kind;
+  
+  size_t name_len = 0;
+  char *name = js_getstr(js, args[0], &name_len);
+  if (!name) return js_mkerr(js, "Event name must be a string");
+
+  char full_name[64];
+  snprintf(
+    full_name, sizeof(full_name),
+    "%s:%.*s", stream_kind_name(kind),
+    (int)name_len, name
+  );
+
+  child_event_t *evt = find_or_create_event(cp, full_name);
+  if (evt->count >= MAX_CHILD_LISTENERS) {
+    return js_mkerr(js, "Maximum listeners reached for event");
   }
+
+  evt->listeners[evt->count].callback = args[1];
+  evt->listeners[evt->count].once = false;
+  evt->count++;
+  return this_obj;
+}
+
+static jsval_t child_stream_once(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 2) return js_mkerr(js, "once() requires event name and callback");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Event name must be a string");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "Callback must be a function");
+
+  jsval_t ctx_ptr = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(ctx_ptr) == T_UNDEF) return js_mkerr(js, "Invalid stream object");
   
-  return js_mkundef();
+  child_stream_ctx_t *ctx = (child_stream_ctx_t *)(uintptr_t)js_getnum(ctx_ptr);
+  if (!ctx || !ctx->cp) return js_mkerr(js, "Invalid stream context");
+  
+  child_process_t *cp = ctx->cp;
+  child_stream_kind_t kind = ctx->kind;
+  
+  size_t name_len = 0;
+  char *name = js_getstr(js, args[0], &name_len);
+  if (!name) return js_mkerr(js, "Event name must be a string");
+
+  char full_name[64];
+  snprintf(
+    full_name, sizeof(full_name),
+    "%s:%.*s", stream_kind_name(kind),
+    (int)name_len, name
+  );
+
+  child_event_t *evt = find_or_create_event(cp, full_name);
+  if (evt->count >= MAX_CHILD_LISTENERS) {
+    return js_mkerr(js, "Maximum listeners reached for event");
+  }
+
+  evt->listeners[evt->count].callback = args[1];
+  evt->listeners[evt->count].once = true;
+  evt->count++;
+  return this_obj;
 }
 
-static jsval_t create_child_object(struct js *js, child_process_t *cp) {
+static jsval_t create_child_stream_object(ant_t *js, child_process_t *cp, child_stream_kind_t kind) {
+  jsval_t obj = js_mkobj(js);
+  child_stream_ctx_t *ctx = calloc(1, sizeof(child_stream_ctx_t));
+  if (!ctx) return js_mkerr(js, "Out of memory");
+  
+  ctx->cp = cp;
+  ctx->kind = kind;
+  
+  if (kind == CHILD_STREAM_STDIN) cp->stdin_ctx = ctx;
+  else if (kind == CHILD_STREAM_STDOUT) cp->stdout_ctx = ctx;
+  else cp->stderr_ctx = ctx;
+
+  js_set_slot(js, obj, SLOT_DATA, ANT_PTR(ctx));
+  js_set(js, obj, "on", js_mkfun(child_stream_on));
+  js_set(js, obj, "once", js_mkfun(child_stream_once));
+  js_set(js, obj, "ref", js_mkfun(child_stream_ref));
+  js_set(js, obj, "unref", js_mkfun(child_stream_unref));
+  js_set(js, obj, "destroy", js_mkfun(child_stream_destroy));
+  js_set(js, obj, "length", js_mknum(0));
+
+  if (kind == CHILD_STREAM_STDIN) {
+    js_set(js, obj, "write", js_mkfun(child_stream_write));
+    js_set(js, obj, "end", js_mkfun(child_stream_end));
+  }
+
+  return obj;
+}
+
+static jsval_t create_child_object(ant_t *js, child_process_t *cp) {
   jsval_t obj = js_mkobj(js);
   
   js_set_slot(js, obj, SLOT_DATA, ANT_PTR(cp));
@@ -452,19 +836,29 @@ static jsval_t create_child_object(struct js *js, child_process_t *cp) {
   js_set(js, obj, "signalCode", js_mknull());
   js_set(js, obj, "killed", js_false);
   js_set(js, obj, "connected", js_true);
+
+  cp->stdin_obj = create_child_stream_object(js, cp, CHILD_STREAM_STDIN);
+  cp->stdout_obj = create_child_stream_object(js, cp, CHILD_STREAM_STDOUT);
+  cp->stderr_obj = create_child_stream_object(js, cp, CHILD_STREAM_STDERR);
+  
+  js_set(js, obj, "stdin", cp->stdin_obj);
+  js_set(js, obj, "stdout", cp->stdout_obj);
+  js_set(js, obj, "stderr", cp->stderr_obj);
   
   js_set(js, obj, "on", js_mkfun(child_on));
   js_set(js, obj, "once", js_mkfun(child_once));
+  js_set(js, obj, "ref", js_mkfun(child_ref));
+  js_set(js, obj, "unref", js_mkfun(child_unref));
   js_set(js, obj, "kill", js_mkfun(child_kill));
   js_set(js, obj, "write", js_mkfun(child_write));
   js_set(js, obj, "end", js_mkfun(child_end));
   
-  js_set(js, obj, get_toStringTag_sym_key(), js_mkstr(js, "ChildProcess", 12));
+  js_set_sym(js, obj, get_toStringTag_sym(), js_mkstr(js, "ChildProcess", 12));
   
   return obj;
 }
 
-static char **parse_args_array(struct js *js, jsval_t arr, int *count) {
+static char **parse_args_array(ant_t *js, jsval_t arr, int *count) {
   jsval_t len_val = js_get(js, arr, "length");
   int len = (int)js_getnum(len_val);
   
@@ -498,7 +892,7 @@ static void free_args_array(char **args, int count) {
   free(args);
 }
 
-static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_spawn(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "spawn() requires a command");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
@@ -547,6 +941,7 @@ static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) {
   cp->detached = detached;
   cp->cwd = cwd;
   cp->promise = js_mkundef();
+  cp->keep_alive = true;
   
   uv_pipe_init(uv_default_loop(), &cp->stdin_pipe, 0);
   uv_pipe_init(uv_default_loop(), &cp->stdout_pipe, 0);
@@ -640,7 +1035,7 @@ static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) {
   return cp->child_obj;
 }
 
-static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_exec(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "exec() requires a command");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
@@ -669,6 +1064,7 @@ static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) {
   cp->use_shell = true;
   cp->cwd = cwd;
   cp->promise = js_mkpromise(js);
+  cp->keep_alive = true;
   
   uv_pipe_init(uv_default_loop(), &cp->stdin_pipe, 0);
   uv_pipe_init(uv_default_loop(), &cp->stdout_pipe, 0);
@@ -720,7 +1116,7 @@ static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) {
   return cp->promise;
 }
 
-static jsval_t builtin_execSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_execSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "execSync() requires a command");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
@@ -785,7 +1181,7 @@ static jsval_t builtin_execSync(struct js *js, jsval_t *args, int nargs) {
 }
 
 #ifdef _WIN32
-static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_spawnSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "spawnSync() requires a command");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
@@ -930,7 +1326,7 @@ static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 #else
-static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_spawnSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "spawnSync() requires a command");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
@@ -1070,7 +1466,7 @@ static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
 }
 #endif
 
-static jsval_t builtin_fork(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fork(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "fork() requires a module path");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "Module path must be a string");
   size_t path_len;
@@ -1124,7 +1520,7 @@ static jsval_t builtin_fork(struct js *js, jsval_t *args, int nargs) {
   return builtin_spawn(js, spawn_args, 3);
 }
 
-jsval_t child_process_library(struct js *js) {
+jsval_t child_process_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
   
   js_set(js, lib, "spawn", js_mkfun(builtin_spawn));
@@ -1132,23 +1528,27 @@ jsval_t child_process_library(struct js *js) {
   js_set(js, lib, "execSync", js_mkfun(builtin_execSync));
   js_set(js, lib, "spawnSync", js_mkfun(builtin_spawnSync));
   js_set(js, lib, "fork", js_mkfun(builtin_fork));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "child_process", 13));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "child_process", 13));
   
   return lib;
 }
 
 int has_pending_child_processes(void) {
-  return pending_children_head != NULL;
+  for (child_process_t *cp = pending_children_head; cp; cp = cp->next) 
+    if (cp->keep_alive) return 1;
+  return 0;
 }
 
 void child_process_gc_update_roots(GC_OP_VAL_ARGS) {
   for (child_process_t *cp = pending_children_head; cp; cp = cp->next) {
     op_val(ctx, &cp->child_obj);
+    op_val(ctx, &cp->stdin_obj);
+    op_val(ctx, &cp->stdout_obj);
+    op_val(ctx, &cp->stderr_obj);
     op_val(ctx, &cp->promise);
     
     child_event_t *evt, *tmp;
-    HASH_ITER(hh, cp->events, evt, tmp) {
+    HASH_ITER(hh, cp->events, evt, tmp) 
       for (int i = 0; i < evt->count; i++) op_val(ctx, &evt->listeners[i].callback);
-    }
   }
 }
diff --git a/src/modules/collections.c b/src/modules/collections.c
index 02ed8fb..27b40a7 100644
--- a/src/modules/collections.c
+++ b/src/modules/collections.c
@@ -3,11 +3,13 @@
 #include <stdio.h>
 
 #include "ant.h"
+#include "gc.h"
 #include "errors.h"
+#include "arena.h"
 #include "runtime.h"
 #include "internal.h"
-#include "arena.h"
-#include "gc.h"
+#include "silver/engine.h"
+#include "descriptors.h"
 
 #include "modules/collections.h"
 #include "modules/symbol.h"
@@ -20,10 +22,6 @@ static set_registry_entry_t *set_registry = NULL;
 static size_t set_registry_count = 0;
 static size_t set_registry_cap = 0;
 
-static jsval_t iter_return_this(ant_t *js, jsval_t *args, int nargs) {
-  return js->this_val;
-}
-
 static void register_map(map_entry_t **head, jsoff_t obj_offset) {
   if (!head) return;
   if (map_registry_count >= map_registry_cap) {
@@ -206,7 +204,7 @@ static jsval_t map_forEach(ant_t *js, jsval_t *args, int nargs) {
     HASH_ITER(hh, *map_ptr, entry, tmp) {
       jsval_t k = js_mkstr(js, entry->key, strlen(entry->key));
       jsval_t call_args[3] = { entry->value, k, this_val };
-      jsval_t result = js_call(js, callback, call_args, 3);
+      jsval_t result = sv_vm_call(js->vm, js, callback, js_mkundef(), call_args, 3, NULL, false);
       if (is_err(result)) return result;
     }
   }
@@ -271,10 +269,7 @@ static jsval_t create_map_iterator(ant_t *js, jsval_t map_obj, iter_type_t type)
   js_set_slot(js, iter, SLOT_ITER_STATE, ANT_PTR(state));
   js_set(js, iter, "next", js_mkfun(map_iter_next));
   
-  const char *iter_key = get_iterator_sym_key();
-  if (iter_key && iter_key[0]) {
-    js_set(js, iter, iter_key, js_mkfun(iter_return_this));
-  }
+  js_set_sym(js, iter, get_iterator_sym(), js_mkfun(sym_this_cb));
   
   return iter;
 }
@@ -347,10 +342,7 @@ static jsval_t create_set_iterator(ant_t *js, jsval_t set_obj, iter_type_t type)
   js_set_slot(js, iter, SLOT_ITER_STATE, ANT_PTR(state));
   js_set(js, iter, "next", js_mkfun(set_iter_next));
   
-  const char *iter_key = get_iterator_sym_key();
-  if (iter_key && iter_key[0]) {
-    js_set(js, iter, iter_key, js_mkfun(iter_return_this));
-  }
+  js_set_sym(js, iter, get_iterator_sym(), js_mkfun(sym_this_cb));
   
   return iter;
 }
@@ -466,7 +458,7 @@ static jsval_t set_forEach(ant_t *js, jsval_t *args, int nargs) {
     set_entry_t *entry, *tmp;
     HASH_ITER(hh, *set_ptr, entry, tmp) {
       jsval_t call_args[3] = { entry->value, entry->value, this_val };
-      jsval_t result = js_call(js, callback, call_args, 3);
+      jsval_t result = sv_vm_call(js->vm, js, callback, js_mkundef(), call_args, 3, NULL, false);
       if (is_err(result)) return result;
     }
   }
@@ -645,8 +637,8 @@ static jsval_t builtin_FinalizationRegistry(ant_t *js, jsval_t *args, int nargs)
   jsval_t fr_proto = js_get_ctor_proto(js, "FinalizationRegistry", 20);
   if (is_special_object(fr_proto)) js_set_proto(js, fr_obj, fr_proto);
   
-  js_set_slot(js, fr_obj, SLOT_DATA, args[0]);
   js_set_slot(js, fr_obj, SLOT_MAP, mkarr(js));
+  js_set_slot(js, fr_obj, SLOT_DATA, args[0]);
   
   return fr_obj;
 }
@@ -719,6 +711,55 @@ static jsval_t finreg_unregister(ant_t *js, jsval_t *args, int nargs) {
   return js_bool(removed);
 }
 
+static jsval_t map_groupBy(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2) return js_mkerr_typed(js, JS_ERR_TYPE, "Map.groupBy requires 2 arguments");
+  
+  jsval_t items = args[0];
+  jsval_t callback = args[1];
+  
+  if (vtype(callback) != T_FUNC && vtype(callback) != T_CFUNC)
+    return js_mkerr_typed(js, JS_ERR_TYPE, "callback is not a function");
+  
+  jsval_t map_obj = js_mkobj(js);
+  jsoff_t obj_offset = (jsoff_t)vdata(map_obj);
+  
+  jsval_t map_proto = js_get_ctor_proto(js, "Map", 3);
+  if (is_special_object(map_proto)) js_set_proto(js, map_obj, map_proto);
+  
+  map_entry_t **map_head = ant_calloc(sizeof(map_entry_t *));
+  if (!map_head) return js_mkerr(js, "out of memory");
+  *map_head = NULL;
+  register_map(map_head, obj_offset);
+  js_set_slot(js, map_obj, SLOT_MAP, ANT_PTR(map_head));
+  
+  jsoff_t len = js_arr_len(js, items);
+  for (jsoff_t i = 0; i < len; i++) {
+    jsval_t val = js_arr_get(js, items, i);
+    jsval_t cb_args[2] = { val, tov((double)i) };
+    jsval_t key = sv_vm_call(js->vm, js, callback, js_mkundef(), cb_args, 2, NULL, false);
+    if (is_err(key)) return key;
+    
+    const char *key_str = jsval_to_key(js, key);
+    
+    map_entry_t *entry;
+    HASH_FIND_STR(*map_head, key_str, entry);
+    jsval_t group;
+    if (entry) {
+      group = entry->value;
+    } else {
+      group = js_mkarr(js);
+      entry = ant_calloc(sizeof(map_entry_t));
+      if (!entry) return js_mkerr(js, "out of memory");
+      entry->key = strdup(key_str);
+      entry->value = group;
+      HASH_ADD_STR(*map_head, key, entry);
+    }
+    js_arr_push(js, group, val);
+  }
+  
+  return map_obj;
+}
+
 static jsval_t builtin_Map(ant_t *js, jsval_t *args, int nargs) {
   if (vtype(js->new_target) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Map constructor requires 'new'");
@@ -733,15 +774,15 @@ static jsval_t builtin_Map(ant_t *js, jsval_t *args, int nargs) {
   jsval_t instance_proto = js_instance_proto_from_new_target(js, map_proto);
   
   if (is_special_object(instance_proto)) js_set_proto(js, map_obj, instance_proto);
-  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    js_set_slot(js, map_obj, SLOT_CTOR, js->new_target);
-  }
   
   map_entry_t **map_head = ant_calloc(sizeof(map_entry_t *));
   if (!map_head) return js_mkerr(js, "out of memory");
   *map_head = NULL;
   
   register_map(map_head, obj_offset);
+  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
+    js_set_slot(js, map_obj, SLOT_CTOR, js->new_target);
+  }
   js_set_slot(js, map_obj, SLOT_MAP, ANT_PTR(map_head));
   
   if (nargs == 0 || vtype(args[0]) != T_ARR) return map_obj;
@@ -791,15 +832,15 @@ static jsval_t builtin_Set(ant_t *js, jsval_t *args, int nargs) {
   jsval_t instance_proto = js_instance_proto_from_new_target(js, set_proto);
   
   if (is_special_object(instance_proto)) js_set_proto(js, set_obj, instance_proto);
-  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    js_set_slot(js, set_obj, SLOT_CTOR, js->new_target);
-  }
   
   set_entry_t **set_head = ant_calloc(sizeof(set_entry_t *));
   if (!set_head) return js_mkerr(js, "out of memory");
   *set_head = NULL;
   
   register_set(set_head, obj_offset);
+  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
+    js_set_slot(js, set_obj, SLOT_CTOR, js->new_target);
+  }
   js_set_slot(js, set_obj, SLOT_SET, ANT_PTR(set_head));
   
   if (nargs == 0 || vtype(args[0]) != T_ARR) return set_obj;
@@ -838,14 +879,14 @@ static jsval_t builtin_WeakMap(ant_t *js, jsval_t *args, int nargs) {
   jsval_t instance_proto = js_instance_proto_from_new_target(js, wm_proto);
   
   if (is_special_object(instance_proto)) js_set_proto(js, wm_obj, instance_proto);
-  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    js_set_slot(js, wm_obj, SLOT_CTOR, js->new_target);
-  }
   
   weakmap_entry_t **wm_head = ant_calloc(sizeof(weakmap_entry_t *));
   if (!wm_head) return js_mkerr(js, "out of memory");
   *wm_head = NULL;
   
+  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
+    js_set_slot(js, wm_obj, SLOT_CTOR, js->new_target);
+  }
   js_set_slot(js, wm_obj, SLOT_DATA, ANT_PTR(wm_head));
   
   if (nargs == 0 || vtype(args[0]) != T_ARR) return wm_obj;
@@ -895,14 +936,14 @@ static jsval_t builtin_WeakSet(ant_t *js, jsval_t *args, int nargs) {
   jsval_t instance_proto = js_instance_proto_from_new_target(js, ws_proto);
   
   if (is_special_object(instance_proto)) js_set_proto(js, ws_obj, instance_proto);
-  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
-    js_set_slot(js, ws_obj, SLOT_CTOR, js->new_target);
-  }
   
   weakset_entry_t **ws_head = ant_calloc(sizeof(weakset_entry_t *));
   if (!ws_head) return js_mkerr(js, "out of memory");
   *ws_head = NULL;
   
+  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
+    js_set_slot(js, ws_obj, SLOT_CTOR, js->new_target);
+  }
   js_set_slot(js, ws_obj, SLOT_DATA, ANT_PTR(ws_head));
   
   if (nargs == 0 || vtype(args[0]) != T_ARR) return ws_obj;
@@ -934,8 +975,8 @@ void init_collections_module(void) {
   jsval_t glob = js->global;
   jsval_t object_proto = js->object;
   
-  const char *iter_key = get_iterator_sym_key();
-  const char *toStringTag_key = get_toStringTag_sym_key();
+  jsval_t iter_sym = get_iterator_sym();
+  jsval_t tag_sym = get_toStringTag_sym();
   
   jsval_t map_proto = js_mkobj(js);
   js_set_proto(js, map_proto, object_proto);
@@ -944,19 +985,20 @@ void init_collections_module(void) {
   js_set(js, map_proto, "has", js_mkfun(map_has));
   js_set(js, map_proto, "delete", js_mkfun(map_delete));
   js_set(js, map_proto, "clear", js_mkfun(map_clear));
-  js_set(js, map_proto, "size", js_mkfun(map_size));
+  js_set_getter_desc(js, map_proto, "size", 4, js_mkfun(map_size), JS_DESC_C);
   js_set(js, map_proto, "entries", js_mkfun(map_entries));
   js_set(js, map_proto, "keys", js_mkfun(map_keys));
   js_set(js, map_proto, "values", js_mkfun(map_values));
   js_set(js, map_proto, "forEach", js_mkfun(map_forEach));
-  js_set(js, map_proto, iter_key, js_mkfun(map_iterator));
-  js_set(js, map_proto, toStringTag_key, js_mkstr(js, "Map", 3));
+  js_set_sym(js, map_proto, iter_sym, js_mkfun(map_iterator));
+  js_set_sym(js, map_proto, tag_sym, js_mkstr(js, "Map", 3));
   
   jsval_t map_ctor = js_mkobj(js);
   js_set_slot(js, map_ctor, SLOT_CFUNC, js_mkfun(builtin_Map));
   js_mkprop_fast(js, map_ctor, "prototype", 9, map_proto);
   js_mkprop_fast(js, map_ctor, "name", 4, ANT_STRING("Map"));
   js_set_descriptor(js, map_ctor, "name", 4, 0);
+  js_set(js, map_ctor, "groupBy", js_mkfun(map_groupBy));
   js_define_species_getter(js, map_ctor);
   js_set(js, glob, "Map", js_obj_to_func(map_ctor));
   
@@ -966,13 +1008,13 @@ void init_collections_module(void) {
   js_set(js, set_proto, "has", js_mkfun(set_has));
   js_set(js, set_proto, "delete", js_mkfun(set_delete));
   js_set(js, set_proto, "clear", js_mkfun(set_clear));
-  js_set(js, set_proto, "size", js_mkfun(set_size));
+  js_set_getter_desc(js, set_proto, "size", 4, js_mkfun(set_size), JS_DESC_C);
   js_set(js, set_proto, "values", js_mkfun(set_values));
   js_set(js, set_proto, "keys", js_mkfun(set_values));
   js_set(js, set_proto, "entries", js_mkfun(set_entries));
   js_set(js, set_proto, "forEach", js_mkfun(set_forEach));
-  js_set(js, set_proto, iter_key, js_mkfun(set_iterator));
-  js_set(js, set_proto, toStringTag_key, js_mkstr(js, "Set", 3));
+  js_set_sym(js, set_proto, iter_sym, js_mkfun(set_iterator));
+  js_set_sym(js, set_proto, tag_sym, js_mkstr(js, "Set", 3));
   
   jsval_t set_ctor = js_mkobj(js);
   js_set_slot(js, set_ctor, SLOT_CFUNC, js_mkfun(builtin_Set));
@@ -988,7 +1030,7 @@ void init_collections_module(void) {
   js_set(js, weakmap_proto, "get", js_mkfun(weakmap_get));
   js_set(js, weakmap_proto, "has", js_mkfun(weakmap_has));
   js_set(js, weakmap_proto, "delete", js_mkfun(weakmap_delete));
-  js_set(js, weakmap_proto, toStringTag_key, js_mkstr(js, "WeakMap", 7));
+  js_set_sym(js, weakmap_proto, tag_sym, js_mkstr(js, "WeakMap", 7));
   
   jsval_t weakmap_ctor = js_mkobj(js);
   js_set_slot(js, weakmap_ctor, SLOT_CFUNC, js_mkfun(builtin_WeakMap));
@@ -1002,7 +1044,7 @@ void init_collections_module(void) {
   js_set(js, weakset_proto, "add", js_mkfun(weakset_add));
   js_set(js, weakset_proto, "has", js_mkfun(weakset_has));
   js_set(js, weakset_proto, "delete", js_mkfun(weakset_delete));
-  js_set(js, weakset_proto, toStringTag_key, js_mkstr(js, "WeakSet", 7));
+  js_set_sym(js, weakset_proto, tag_sym, js_mkstr(js, "WeakSet", 7));
   
   jsval_t weakset_ctor = js_mkobj(js);
   js_set_slot(js, weakset_ctor, SLOT_CFUNC, js_mkfun(builtin_WeakSet));
@@ -1014,7 +1056,7 @@ void init_collections_module(void) {
   jsval_t weakref_proto = js_mkobj(js);
   js_set_proto(js, weakref_proto, object_proto);
   js_set(js, weakref_proto, "deref", js_mkfun(weakref_deref));
-  js_set(js, weakref_proto, toStringTag_key, js_mkstr(js, "WeakRef", 7));
+  js_set_sym(js, weakref_proto, tag_sym, js_mkstr(js, "WeakRef", 7));
   
   jsval_t weakref_ctor = js_mkobj(js);
   js_set_slot(js, weakref_ctor, SLOT_CFUNC, js_mkfun(builtin_WeakRef));
@@ -1027,7 +1069,7 @@ void init_collections_module(void) {
   js_set_proto(js, finreg_proto, object_proto);
   js_set(js, finreg_proto, "register", js_mkfun(finreg_register));
   js_set(js, finreg_proto, "unregister", js_mkfun(finreg_unregister));
-  js_set(js, finreg_proto, toStringTag_key, js_mkstr(js, "FinalizationRegistry", 20));
+  js_set_sym(js, finreg_proto, tag_sym, js_mkstr(js, "FinalizationRegistry", 20));
   
   jsval_t finreg_ctor = js_mkobj(js);
   js_set_slot(js, finreg_ctor, SLOT_CFUNC, js_mkfun(builtin_FinalizationRegistry));
diff --git a/src/modules/crypto.c b/src/modules/crypto.c
index 5bdb517..a2f9d50 100644
--- a/src/modules/crypto.c
+++ b/src/modules/crypto.c
@@ -20,7 +20,7 @@
 #include "modules/buffer.h"
 #include "modules/symbol.h"
 
-static int ensure_crypto_init(struct js *js) {
+static int ensure_crypto_init(ant_t *js) {
   static int crypto_initialized = 0;
   
   if (!crypto_initialized) {
@@ -52,7 +52,7 @@ int uuidv7_new(uint8_t *uuid_out) {
 }
 
 // crypto.random()
-static jsval_t js_crypto_random(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_crypto_random(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   (void) js;
@@ -66,7 +66,7 @@ static jsval_t js_crypto_random(struct js *js, jsval_t *args, int nargs) {
 }
 
 // crypto.randomBytes(length)
-static jsval_t js_crypto_random_bytes(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_crypto_random_bytes(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "randomBytes requires a length argument");
   }
@@ -102,7 +102,7 @@ static jsval_t js_crypto_random_bytes(struct js *js, jsval_t *args, int nargs) {
 }
 
 // crypto.randomUUID()
-static jsval_t js_crypto_random_uuid(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_crypto_random_uuid(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   
@@ -130,7 +130,7 @@ static jsval_t js_crypto_random_uuid(struct js *js, jsval_t *args, int nargs) {
 }
 
 // crypto.randomUUIDv7()
-static jsval_t js_crypto_random_uuidv7(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_crypto_random_uuidv7(ant_t *js, jsval_t *args, int nargs) {
   (void) args;
   (void) nargs;
   
@@ -152,7 +152,7 @@ static jsval_t js_crypto_random_uuidv7(struct js *js, jsval_t *args, int nargs)
 }
 
 // crypto.getRandomValues(typedArray)
-static jsval_t js_crypto_get_random_values(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_crypto_get_random_values(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "getRandomValues requires a TypedArray argument");
   }
@@ -177,7 +177,7 @@ static jsval_t js_crypto_get_random_values(struct js *js, jsval_t *args, int nar
   return args[0];
 }
 
-static jsval_t create_crypto_obj(struct js *js) {
+static jsval_t create_crypto_obj(ant_t *js) {
   jsval_t crypto_obj = js_mkobj(js);
   
   js_set(js, crypto_obj, "random", js_mkfun(js_crypto_random));
@@ -186,17 +186,17 @@ static jsval_t create_crypto_obj(struct js *js) {
   js_set(js, crypto_obj, "randomUUIDv7", js_mkfun(js_crypto_random_uuidv7));
   js_set(js, crypto_obj, "getRandomValues", js_mkfun(js_crypto_get_random_values));
   
-  js_set(js, crypto_obj, get_toStringTag_sym_key(), js_mkstr(js, "Crypto", 6));
+  js_set_sym(js, crypto_obj, get_toStringTag_sym(), js_mkstr(js, "Crypto", 6));
   return crypto_obj;
 }
 
 void init_crypto_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t crypto_obj = create_crypto_obj(js);
   js_set(js, js_glob(js), "crypto", crypto_obj);
 }
 
-jsval_t crypto_library(struct js *js) {
+jsval_t crypto_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
   jsval_t webcrypto = create_crypto_obj(js);
   
@@ -204,7 +204,7 @@ jsval_t crypto_library(struct js *js) {
   js_set(js, lib, "randomBytes", js_mkfun(js_crypto_random_bytes));
   js_set(js, lib, "randomUUID", js_mkfun(js_crypto_random_uuid));
   js_set(js, lib, "getRandomValues", js_mkfun(js_crypto_get_random_values));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "crypto", 6));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "crypto", 6));
 
   return lib;
 }
diff --git a/src/modules/date.c b/src/modules/date.c
new file mode 100644
index 0000000..6744ecc
--- /dev/null
+++ b/src/modules/date.c
@@ -0,0 +1,1356 @@
+#include <compat.h> // IWYU pragma: keep
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <sys/timeb.h>
+#else
+#include <sys/time.h>
+#endif
+
+#include "ant.h"
+#include "internal.h"
+#include "errors.h"
+#include "descriptors.h"
+#include "runtime.h"
+#include "silver/engine.h"
+#include "modules/date.h"
+#include "modules/symbol.h"
+
+static const int month_days[] = {
+  31, 28, 31, 30, 31, 30,
+  31, 31, 30, 31, 30, 31
+};
+
+static const char month_names[] =
+  "Jan" "Feb" "Mar" "Apr" "May" "Jun"
+  "Jul" "Aug" "Sep" "Oct" "Nov" "Dec";
+
+static const char day_names[] =
+  "Sun" "Mon" "Tue" "Wed" "Thu" "Fri" "Sat";
+
+static inline double *date_fields_slot(date_fields_t *f, date_field_index_t index) {
+switch (index) {
+  case DATE_FIELD_YEAR: return &f->year;
+  case DATE_FIELD_MONTH: return &f->month;
+  case DATE_FIELD_DAY_OF_MONTH: return &f->day;
+  case DATE_FIELD_HOUR: return &f->hour;
+  case DATE_FIELD_MINUTE: return &f->minute;
+  case DATE_FIELD_SECOND: return &f->second;
+  case DATE_FIELD_MILLISECOND: return &f->millisecond;
+  case DATE_FIELD_DAY_OF_WEEK: return &f->weekday;
+  case DATE_FIELD_TZ_MINUTES: return &f->tz_minutes;
+  default: return NULL;
+}}
+
+static inline double date_fields_get(const date_fields_t *f, date_field_index_t index) {
+  double *slot = date_fields_slot((date_fields_t *)f, index);
+  return slot ? *slot : 0.0;
+}
+
+static inline void date_fields_set(date_fields_t *f, date_field_index_t index, double value) {
+  double *slot = date_fields_slot(f, index);
+  if (slot) *slot = value;
+}
+
+static inline int date_min_int(int a, int b) {
+  return (a < b) ? a : b;
+}
+
+static inline int to_upper_ascii(int c) {
+  if (c >= 'a' && c <= 'z') return c - ('a' - 'A');
+  return c;
+}
+
+static inline bool date_is_primitive(jsval_t v) {
+  uint8_t t = vtype(v);
+  return 
+    t == T_STR 
+    || t == T_NUM
+    || t == T_BOOL
+    || t == T_NULL
+    || t == T_UNDEF
+    || t == T_SYMBOL
+    || t == T_BIGINT;
+}
+
+static bool is_date_instance(ant_t *js, jsval_t value) {
+  if (!is_object_type(value)) return false;
+  jsval_t date_proto = js_get_ctor_proto(js, "Date", 4);
+  
+  if (!is_object_type(date_proto)) return false;
+  if (value == date_proto) return true;
+  
+  return proto_chain_contains(js, value, date_proto);
+}
+
+static bool date_this_time_value(ant_t *js, jsval_t this_val, double *out, jsval_t *err) {
+  if (!is_date_instance(js, this_val)) {
+    if (err) *err = js_mkerr_typed(js, JS_ERR_TYPE, "not a Date object");
+    return false;
+  }
+  
+  jsval_t t = js_get_slot(js, js_as_obj(this_val), SLOT_DATA);
+  *out = (vtype(t) == T_NUM) ? tod(t) : JS_NAN;
+  return true;
+}
+
+static jsval_t date_set_this_time_value(ant_t *js, jsval_t this_val, double v) {
+  if (!is_date_instance(js, this_val)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "not a Date object");
+  }
+  
+  js_set_slot(js, js_as_obj(this_val), SLOT_DATA, tov(v));
+  return tov(v);
+}
+
+static int64_t math_mod(int64_t a, int64_t b) {
+  int64_t m = a % b;
+  return m + (m < 0) * b;
+}
+
+static int64_t floor_div_int64(int64_t a, int64_t b) {
+  int64_t m = a % b;
+  return (a - (m + (m < 0) * b)) / b;
+}
+
+static double date_timeclip(double t) {
+  if (t >= -8.64e15 && t <= 8.64e15) return trunc(t) + 0.0;
+  return JS_NAN;
+}
+
+static int64_t days_in_year(int64_t y) {
+  return 365 + !(y % 4) - !(y % 100) + !(y % 400);
+}
+
+static int64_t days_from_year(int64_t y) {
+  return 365 * (y - 1970)
+    + floor_div_int64(y - 1969, 4)
+    - floor_div_int64(y - 1901, 100)
+    + floor_div_int64(y - 1601, 400);
+}
+
+static int64_t year_from_days(int64_t *days) {
+  int64_t y, d1, nd, d = *days;
+  y = floor_div_int64(d * 10000, 3652425) + 1970;
+  
+  while (true) {
+    d1 = d - days_from_year(y);
+    
+    if (d1 < 0) {
+      y--;
+      d1 += days_in_year(y);
+      continue;
+    }
+    
+    nd = days_in_year(y);
+    if (d1 < nd) break;
+    
+    d1 -= nd;
+    y++;
+  }
+  
+  *days = d1;
+  return y;
+}
+
+static int get_timezone_offset(int64_t time_ms) {
+#ifdef _WIN32
+  DWORD r;
+  TIME_ZONE_INFORMATION tzi;
+  r = GetTimeZoneInformation(&tzi);
+  if (r == TIME_ZONE_ID_INVALID) return 0;
+  if (r == TIME_ZONE_ID_DAYLIGHT) return (int)(tzi.Bias + tzi.DaylightBias);
+  return (int)tzi.Bias;
+#else
+  time_t ti;
+  struct tm tm_local;
+
+  int64_t time_s = time_ms / 1000;
+  if (sizeof(time_t) == 4) {
+    if ((time_t)-1 < 0) {
+      if (time_s < INT32_MIN) time_s = INT32_MIN;
+      else if (time_s > INT32_MAX) time_s = INT32_MAX;
+    } else {
+      if (time_s < 0) time_s = 0;
+      else if (time_s > UINT32_MAX) time_s = UINT32_MAX;
+    }
+  }
+
+  ti = (time_t)time_s;
+  localtime_r(&ti, &tm_local);
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__GLIBC__)
+  return (int)(-tm_local.tm_gmtoff / 60);
+#else
+  struct tm tm_gmt;
+  gmtime_r(&ti, &tm_gmt);
+  tm_local.tm_isdst = 0;
+  return (int)(difftime(mktime(&tm_gmt), mktime(&tm_local)) / 60);
+#endif
+#endif
+}
+
+static int date_extract_fields_from_time(double dval, date_fields_t *fields, int is_local, int force) {
+  int64_t d, days, wd, y, i, md, h, m, s, ms, tz = 0;
+
+  if (isnan(dval)) {
+    if (!force) return 0;
+    d = 0;
+  } else {
+    d = (int64_t)dval;
+    if (is_local) {
+      tz = -get_timezone_offset(d);
+      d += tz * 60000;
+    }
+  }
+
+  h = math_mod(d, 86400000);
+  days = (d - h) / 86400000;
+  ms = h % 1000;
+  h = (h - ms) / 1000;
+  s = h % 60;
+  h = (h - s) / 60;
+  m = h % 60;
+  h = (h - m) / 60;
+  wd = math_mod(days + 4, 7);
+  y = year_from_days(&days);
+
+  for (i = 0; i < 11; i++) {
+    md = month_days[i];
+    if (i == 1) md += (int)days_in_year(y) - 365;
+    if (days < md) break;
+    days -= md;
+  }
+
+  fields->year = (double)y;
+  fields->month = (double)i;
+  fields->day = (double)(days + 1);
+  fields->hour = (double)h;
+  fields->minute = (double)m;
+  fields->second = (double)s;
+  fields->millisecond = (double)ms;
+  fields->weekday = (double)wd;
+  fields->tz_minutes = (double)tz;
+  
+  return 1;
+}
+
+static int date_extract_fields(
+  ant_t *js, jsval_t this_val,
+  date_fields_t *fields,
+  int is_local, int force, jsval_t *err
+) {
+  double dval;
+  if (!date_this_time_value(js, this_val, &dval, err)) return -1;
+  return date_extract_fields_from_time(dval, fields, is_local, force);
+}
+
+static double date_make_fields(const date_fields_t *fields, int is_local) {
+  double y, m, dt, ym, mn, day, h, s, milli, time, tv;
+  int yi, mi, i;
+  int64_t days;
+  volatile double temp;
+  double d = JS_NAN;
+
+  y = fields->year;
+  m = fields->month;
+  dt = fields->day;
+
+  ym = y + floor(m / 12);
+  mn = fmod(m, 12);
+  if (mn < 0) mn += 12;
+
+  if (ym < -271821 || ym > 275760) return JS_NAN;
+
+  yi = (int)ym;
+  mi = (int)mn;
+
+  days = days_from_year(yi);
+  for (i = 0; i < mi; i++) {
+    days += month_days[i];
+    if (i == 1) days += days_in_year(yi) - 365;
+  }
+  day = (double)days + dt - 1;
+
+  h = fields->hour;
+  m = fields->minute;
+  s = fields->second;
+  milli = fields->millisecond;
+
+  time = h * 3600000;
+  time += (temp = m * 60000);
+  time += (temp = s * 1000);
+  time += milli;
+
+  tv = (temp = day * 86400000) + time;
+  if (!isfinite(tv)) return JS_NAN;
+
+  if (is_local) {
+    int64_t ti;
+    if (tv < (double)INT64_MIN) ti = INT64_MIN;
+    else if (tv >= 0x1p63) ti = INT64_MAX;
+    else ti = (int64_t)tv;
+    tv += (double)get_timezone_offset(ti) * 60000.0;
+  }
+
+  d = date_timeclip(tv);
+  return d;
+}
+
+jsval_t get_date_string(ant_t *js, jsval_t this_val, date_string_spec_t spec) {
+  char buf[96];
+  date_fields_t fields;
+  
+  int res, fmt, pos;
+  int y, mon, d, h, m, s, ms, wd, tz;
+  jsval_t err;
+
+  fmt = (int)spec.fmt;
+  res = date_extract_fields(
+    js, this_val,
+    &fields, spec.fmt == DATE_STRING_FMT_LOCAL,
+    0, &err
+  );
+  
+  if (res < 0) return err;
+  if (!res) {
+    if (spec.fmt == DATE_STRING_FMT_ISO) return js_mkerr_typed(js, JS_ERR_RANGE, "Date value is NaN");
+    return js_mkstr(js, "Invalid Date", 12);
+  }
+
+  y = (int)fields.year;
+  mon = (int)fields.month;
+  d = (int)fields.day;
+  h = (int)fields.hour;
+  m = (int)fields.minute;
+  s = (int)fields.second;
+  ms = (int)fields.millisecond;
+  wd = (int)fields.weekday;
+  tz = (int)fields.tz_minutes;
+  pos = 0;
+
+  if (spec.part & DATE_STRING_PART_DATE) {
+    switch (fmt) {
+      case 0:
+        pos += snprintf(
+          buf + pos, sizeof(buf) - (size_t)pos,
+          "%.3s, %02d %.3s %0*d ",
+          day_names + wd * 3, d, month_names + mon * 3, 4 + (y < 0), y);
+        break;
+      case 1:
+        pos += snprintf(
+          buf + pos, sizeof(buf) - (size_t)pos,
+          "%.3s %.3s %02d %0*d",
+          day_names + wd * 3, month_names + mon * 3, d, 4 + (y < 0), y);
+        if (spec.part == DATE_STRING_PART_ALL) buf[pos++] = ' ';
+        break;
+      case 2:
+        if (y >= 0 && y <= 9999) {
+          pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "%04d", y);
+        } else pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "%+07d", y);
+        pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "-%02d-%02dT", mon + 1, d);
+        break;
+      case 3:
+        pos += snprintf(
+          buf + pos, sizeof(buf) - (size_t)pos,
+          "%02d/%02d/%0*d", mon + 1, d, 4 + (y < 0), y);
+        if (spec.part == DATE_STRING_PART_ALL) {
+          buf[pos++] = ',';
+          buf[pos++] = ' ';
+        }
+        break;
+      default: break;
+    }
+  }
+
+  if (spec.part & DATE_STRING_PART_TIME) {
+    switch (fmt) {
+      case 0:
+        pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "%02d:%02d:%02d GMT", h, m, s);
+        break;
+      case 1:
+        pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "%02d:%02d:%02d GMT", h, m, s);
+        if (tz < 0) {
+          buf[pos++] = '-';
+          tz = -tz;
+        } else buf[pos++] = '+';
+        pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "%02d%02d", tz / 60, tz % 60);
+        break;
+      case 2:
+        pos += snprintf(buf + pos, sizeof(buf) - (size_t)pos, "%02d:%02d:%02d.%03dZ", h, m, s, ms);
+        break;
+      case 3:
+        pos += snprintf(
+          buf + pos, sizeof(buf) - (size_t)pos,
+          "%02d:%02d:%02d %cM", (h + 11) % 12 + 1, m, s, (h < 12) ? 'A' : 'P');
+        break;
+      default: break;
+    }
+  }
+
+  if (pos <= 0) return js_mkstr(js, "", 0);
+  return js_mkstr(js, buf, (size_t)pos);
+}
+
+static int64_t date_now(void) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return (int64_t)tv.tv_sec * 1000 + (int64_t)(tv.tv_usec / 1000);
+}
+
+static bool string_skip_char(const uint8_t *sp, int *pp, int c) {
+  if (sp[*pp] == c) { *pp += 1; return true; }
+  return false;
+}
+
+static int string_skip_spaces(const uint8_t *sp, int *pp) {
+  int c;
+  while ((c = sp[*pp]) == ' ') *pp += 1;
+  return c;
+}
+
+static int string_skip_separators(const uint8_t *sp, int *pp) {
+  int c;
+  while ((c = sp[*pp]) == '-' || c == '/' || c == '.' || c == ',') *pp += 1;
+  return c;
+}
+
+static int string_skip_until(const uint8_t *sp, int *pp, const char *stoplist) {
+  int c;
+  while (!strchr(stoplist, c = sp[*pp])) *pp += 1;
+  return c;
+}
+
+static bool string_get_digits(const uint8_t *sp, int *pp, int *pval, int min_digits, int max_digits) {
+  int v = 0; int c;
+  int p = *pp;
+  int p_start = p;
+
+  while ((c = sp[p]) >= '0' && c <= '9') {
+    if (v >= 100000000) return false;
+    v = v * 10 + c - '0';
+    p++;
+    if (max_digits > 0 && p - p_start == max_digits) break;
+  }
+
+  if (p - p_start < min_digits) return false;
+  *pval = v;
+  *pp = p;
+  
+  return true;
+}
+
+static bool string_get_milliseconds(const uint8_t *sp, int *pp, int *pval) {
+  int mul = 100; int ms = 0;
+  int c; int p_start; int p = *pp;
+
+  c = sp[p];
+  if (c == '.' || c == ',') {
+    p++;
+    p_start = p;
+    
+    while ((c = sp[p]) >= '0' && c <= '9') {
+      ms += (c - '0') * mul;
+      mul /= 10;
+      p++;
+      if (p - p_start == 9) break;
+    }
+    
+    if (p > p_start) {
+      *pval = ms;
+      *pp = p;
+    }
+  }
+  
+  return true;
+}
+
+static bool string_get_tzoffset(const uint8_t *sp, int *pp, int *tzp, bool strict) {
+  int tz = 0; int p = *pp;
+  int sgn; int hh; int mm;
+
+  sgn = sp[p++];
+  if (sgn == '+' || sgn == '-') {
+    int n = p;
+    if (!string_get_digits(sp, &p, &hh, 1, 0)) return false;
+    n = p - n;
+    if (strict && n != 2 && n != 4) return false;
+
+    while (n > 4) {
+      n -= 2;
+      hh /= 100;
+    }
+    
+    if (n > 2) {
+      mm = hh % 100;
+      hh = hh / 100;
+    } else {
+      mm = 0;
+      if (string_skip_char(sp, &p, ':') && !string_get_digits(sp, &p, &mm, 2, 2)) return false;
+    }
+    
+    if (hh > 23 || mm > 59) return false;
+    
+    tz = hh * 60 + mm;
+    if (sgn != '+') tz = -tz;
+  } else if (sgn != 'Z') return false;
+
+  *pp = p;
+  *tzp = tz;
+  
+  return true;
+}
+
+static bool string_match(const uint8_t *sp, int *pp, const char *s) {
+  int p = *pp;
+  
+  while (*s != '\0') {
+    if (to_upper_ascii(sp[p]) != to_upper_ascii(*s++)) return false;
+    p++;
+  }
+  
+  *pp = p;
+  return true;
+}
+
+static int find_abbrev(const uint8_t *sp, int p, const char *list, int count) {
+  int n; int i;
+  for (n = 0; n < count; n++) {
+    for (i = 0;; i++) {
+      if (to_upper_ascii(sp[p + i]) != to_upper_ascii(list[n * 3 + i])) break;
+      if (i == 2) return n;
+    }
+  }
+  return -1;
+}
+
+static bool string_get_month(const uint8_t *sp, int *pp, int *pval) {
+  int n = find_abbrev(sp, *pp, month_names, 12);
+  if (n < 0) return false;
+  *pval = n + 1;
+  *pp += 3;
+  return true;
+}
+
+static bool parse_isostring(const uint8_t *sp, int fields[9], bool *is_local) {
+  int sgn;
+  int i;
+  int p = 0;
+
+  for (i = 0; i < 9; i++) fields[i] = (i == 2);
+  *is_local = false;
+
+  sgn = sp[p];
+  if (sgn == '-' || sgn == '+') {
+    p++;
+    if (!string_get_digits(sp, &p, &fields[0], 6, 6)) return false;
+    if (sgn == '-') {
+      if (fields[0] == 0) return false;
+      fields[0] = -fields[0];
+    }
+  } else {
+    if (!string_get_digits(sp, &p, &fields[0], 4, 4)) return false;
+  }
+
+  if (string_skip_char(sp, &p, '-')) {
+    if (!string_get_digits(sp, &p, &fields[1], 2, 2)) return false;
+    if (fields[1] < 1) return false;
+    fields[1] -= 1;
+
+    if (string_skip_char(sp, &p, '-')) {
+      if (!string_get_digits(sp, &p, &fields[2], 2, 2)) return false;
+      if (fields[2] < 1) return false;
+    }
+  }
+
+  if (string_skip_char(sp, &p, 'T')) {
+    *is_local = true;
+    if (!string_get_digits(sp, &p, &fields[3], 2, 2)
+        || !string_skip_char(sp, &p, ':')
+        || !string_get_digits(sp, &p, &fields[4], 2, 2)) {
+      fields[3] = 100;
+      return true;
+    }
+
+    if (string_skip_char(sp, &p, ':')) {
+      if (!string_get_digits(sp, &p, &fields[5], 2, 2)) return false;
+      string_get_milliseconds(sp, &p, &fields[6]);
+    }
+  }
+
+  if (sp[p]) {
+    *is_local = false;
+    if (!string_get_tzoffset(sp, &p, &fields[8], true)) return false;
+  }
+
+  return sp[p] == '\0';
+}
+
+typedef struct {
+  char name[6];
+  int16_t offset;
+} tzabbr_t;
+
+static const tzabbr_t js_tzabbr[] = {
+  {"GMT", 0}, {"UTC", 0}, {"UT", 0}, {"Z", 0},
+  {"EDT", -4 * 60}, {"EST", -5 * 60},
+  {"CDT", -5 * 60}, {"CST", -6 * 60},
+  {"MDT", -6 * 60}, {"MST", -7 * 60},
+  {"PDT", -7 * 60}, {"PST", -8 * 60},
+  {"WET", 0},       {"WEST", +1 * 60},
+  {"CET", +1 * 60}, {"CEST", +2 * 60},
+  {"EET", +2 * 60}, {"EEST", +3 * 60},
+};
+
+static bool string_get_tzabbr(const uint8_t *sp, int *pp, int *offset) {
+  for (int i = 0; i < DATE_COUNT_OF(js_tzabbr); i++) {
+    if (string_match(sp, pp, js_tzabbr[i].name)) {
+      *offset = js_tzabbr[i].offset;
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool parse_otherstring(const uint8_t *sp, int fields[9], bool *is_local) {
+  int c; int i; int val;
+  int p = 0;
+  int p_start;
+  int num[3];
+  
+  bool has_year = false;
+  bool has_mon = false;
+  bool has_time = false;
+  int num_index = 0;
+
+  fields[0] = 2001;
+  fields[1] = 1;
+  fields[2] = 1;
+  
+  for (i = 3; i < 9; i++) fields[i] = 0;
+  *is_local = true;
+
+  while (string_skip_spaces(sp, &p)) {
+    p_start = p;
+
+    if ((c = sp[p]) == '+' || c == '-') {
+      if (has_time && string_get_tzoffset(sp, &p, &fields[8], false)) {
+        *is_local = false;
+      } else {
+        p++;
+        if (string_get_digits(sp, &p, &val, 1, 0)) {
+          if (c == '-') {
+            if (val == 0) return false;
+            val = -val;
+          }
+          fields[0] = val;
+          has_year = true;
+        }
+      }
+    } else if (string_get_digits(sp, &p, &val, 1, 0)) {
+      if (string_skip_char(sp, &p, ':')) {
+        fields[3] = val;
+        if (!string_get_digits(sp, &p, &fields[4], 1, 2)) return false;
+
+        if (string_skip_char(sp, &p, ':')) {
+          if (!string_get_digits(sp, &p, &fields[5], 1, 2)) return false;
+          string_get_milliseconds(sp, &p, &fields[6]);
+        } else if (sp[p] != '\0' && sp[p] != ' ') return false;
+
+        has_time = true;
+      } else {
+        if (p - p_start > 2) {
+          fields[0] = val;
+          has_year = true;
+        } else if (val < 1 || val > 31) {
+          fields[0] = val + (val < 100) * 1900 + (val < 50) * 100;
+          has_year = true;
+        } else {
+          if (num_index == 3) return false;
+          num[num_index++] = val;
+        }
+      }
+    } else if (string_get_month(sp, &p, &fields[1])) {
+      has_mon = true;
+      string_skip_until(sp, &p, "0123456789 -/(");
+    } else if (has_time && string_match(sp, &p, "PM")) {
+      if (fields[3] != 12) fields[3] += 12;
+      continue;
+    } else if (has_time && string_match(sp, &p, "AM")) {
+      if (fields[3] > 12) return false;
+      if (fields[3] == 12) fields[3] -= 12;
+      continue;
+    } else if (string_get_tzabbr(sp, &p, &fields[8])) {
+      *is_local = false;
+      continue;
+    } else if (c == '(') {
+      int level = 0;
+      while ((c = sp[p]) != '\0') {
+        p++;
+        level += (c == '(');
+        level -= (c == ')');
+        if (!level) break;
+      }
+      if (level > 0) return false;
+    } else if (c == ')') {
+      return false;
+    } else {
+      if ((int)has_year + (int)has_mon + (int)has_time + num_index) return false;
+      string_skip_until(sp, &p, " -/(");
+    }
+
+    string_skip_separators(sp, &p);
+  }
+
+  if (num_index + (int)has_year + (int)has_mon > 3) return false;
+
+  switch (num_index) {
+    case 0:
+      if (!has_year) return false;
+      break;
+    case 1:
+      if (has_mon) fields[2] = num[0];
+      else fields[1] = num[0];
+      break;
+    case 2:
+      if (has_year) {
+        fields[1] = num[0];
+        fields[2] = num[1];
+      } else if (has_mon) {
+        fields[0] = num[1] + (num[1] < 100) * 1900 + (num[1] < 50) * 100;
+        fields[2] = num[0];
+      } else {
+        fields[1] = num[0];
+        fields[2] = num[1];
+      }
+      break;
+    case 3:
+      fields[0] = num[2] + (num[2] < 100) * 1900 + (num[2] < 50) * 100;
+      fields[1] = num[0];
+      fields[2] = num[1];
+      break;
+    default: return false;
+  }
+
+  if (fields[1] < 1 || fields[2] < 1) return false;
+  fields[1] -= 1;
+  
+  return true;
+}
+
+static bool date_parse_string_to_ms(ant_t *js, jsval_t arg, double *out_ms) {
+  jsval_t s = coerce_to_str(js, arg);
+  if (is_err(s)) return false;
+
+  jsoff_t len = 0;
+  jsoff_t off = vstr(js, s, &len);
+
+  char *buf = (char *)malloc((size_t)len + 1);
+  if (!buf) {
+    *out_ms = JS_NAN;
+    return true;
+  }
+
+  memcpy(buf, &js->mem[off], (size_t)len);
+  buf[len] = '\0';
+
+  int fields[9];
+  date_fields_t fields1 = {0};
+  bool is_local = false;
+  bool ok = parse_isostring((const uint8_t *)buf, fields, &is_local)
+         || parse_otherstring((const uint8_t *)buf, fields, &is_local);
+
+  free(buf);
+
+  if (!ok) {
+    *out_ms = JS_NAN;
+    return true;
+  }
+
+  static const int field_max[6] = {0, 11, 31, 24, 59, 59};
+  bool valid = true;
+
+  for (int i = 1; i < 6; i++) {
+    if (fields[i] > field_max[i]) valid = false;
+  }
+  if (fields[3] == 24 && (fields[4] | fields[5] | fields[6])) valid = false;
+
+  if (!valid) {
+    *out_ms = JS_NAN;
+    return true;
+  }
+
+  fields1.year = (double)fields[0];
+  fields1.month = (double)fields[1];
+  fields1.day = (double)fields[2];
+  fields1.hour = (double)fields[3];
+  fields1.minute = (double)fields[4];
+  fields1.second = (double)fields[5];
+  fields1.millisecond = (double)fields[6];
+  *out_ms = date_make_fields(&fields1, is_local ? 1 : 0) - (double)fields[8] * 60000.0;
+  return true;
+}
+
+static jsval_t builtin_Date(ant_t *js, jsval_t *args, int nargs) {
+  double val;
+  static const date_string_spec_t kDateToStringSpec = {
+    DATE_STRING_FMT_LOCAL,
+    DATE_STRING_PART_ALL
+  };
+
+  if (vtype(js->new_target) == T_UNDEF) {
+    val = (double)date_now();
+    jsval_t tmp = js_mkobj(js);
+    jsval_t date_proto = js_get_ctor_proto(js, "Date", 4);
+    if (is_object_type(date_proto)) js_set_proto(js, tmp, date_proto);
+    js_set_slot(js, tmp, SLOT_DATA, tov(val));
+    return get_date_string(js, tmp, kDateToStringSpec);
+  }
+
+  if (nargs == 0) {
+    val = (double)date_now();
+  } else if (nargs == 1) {
+    jsval_t input = args[0];
+
+    if (is_object_type(input) && is_date_instance(js, input)) {
+      jsval_t tv = js_get_slot(js, js_as_obj(input), SLOT_DATA);
+      val = (vtype(tv) == T_NUM) ? tod(tv) : JS_NAN;
+      val = date_timeclip(val);
+    } else {
+      jsval_t prim = js_to_primitive(js, input, 0);
+      if (is_err(prim)) return prim;
+      if (vtype(prim) == T_STR) {
+        if (!date_parse_string_to_ms(js, prim, &val)) return js_mkerr_typed(js, JS_ERR_INTERNAL, "Date parse failed");
+      } else {
+        val = js_to_number(js, prim);
+      }
+      val = date_timeclip(val);
+    }
+  } else {
+    date_fields_t fields = {0};
+    fields.day = 1;
+    int n = nargs;
+    if (n > 7) n = 7;
+
+    int i;
+    for (i = 0; i < n; i++) {
+      double a = js_to_number(js, args[i]);
+      if (!isfinite(a)) break;
+      double t = trunc(a);
+      date_fields_set(&fields, (date_field_index_t)i, t);
+      if (i == 0 && fields.year >= 0 && fields.year < 100) fields.year += 1900;
+    }
+
+    val = (i == n) ? date_make_fields(&fields, 1) : JS_NAN;
+  }
+
+  js_set_slot(js, js_as_obj(js->this_val), SLOT_DATA, tov(val));
+  return js->this_val;
+}
+
+static jsval_t builtin_Date_UTC(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs == 0) return tov(JS_NAN);
+
+  date_fields_t fields = {0};
+  fields.day = 1;
+  int n = nargs;
+  if (n > 7) n = 7;
+
+  for (int i = 0; i < n; i++) {
+    double a = js_to_number(js, args[i]);
+    if (!isfinite(a)) return tov(JS_NAN);
+    double t = trunc(a);
+    date_fields_set(&fields, (date_field_index_t)i, t);
+    if (i == 0 && fields.year >= 0 && fields.year < 100) fields.year += 1900;
+  }
+
+  return tov(date_make_fields(&fields, 0));
+}
+
+static jsval_t builtin_Date_parse(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return tov(JS_NAN);
+  double v;
+  if (!date_parse_string_to_ms(js, args[0], &v)) {
+    return js_mkerr_typed(js, JS_ERR_INTERNAL, "Date parse failed");
+  }
+  return tov(v);
+}
+
+static jsval_t builtin_Date_now(ant_t *js, jsval_t *args, int nargs) {
+  return tov((double)date_now());
+}
+
+static jsval_t date_get_field(ant_t *js, date_get_field_spec_t spec) {
+  date_fields_t fields;
+  jsval_t err;
+
+  int res = date_extract_fields(js, js->this_val, &fields, spec.local_time, 0, &err);
+  if (res < 0) return err;
+  if (!res) return tov(JS_NAN);
+
+  if (spec.legacy_get_year) fields.year -= 1900;
+  return tov(date_fields_get(&fields, spec.field));
+}
+
+static jsval_t date_set_field(ant_t *js, jsval_t *args, int nargs, date_set_field_spec_t spec) {
+  date_fields_t fields;
+  jsval_t err;
+  double d = JS_NAN;
+
+  int res = date_extract_fields(
+    js, js->this_val,
+    &fields, spec.local_time,
+    spec.first_field == DATE_FIELD_YEAR, &err
+  );
+  
+  if (res < 0) return err;
+  int n = date_min_int(nargs, spec.end_field_exclusive - spec.first_field);
+  
+  for (int i = 0; i < n; i++) {
+    double a = js_to_number(js, args[i]);
+    if (!isfinite(a)) return date_set_this_time_value(js, js->this_val, JS_NAN);
+    date_fields_set(&fields, (date_field_index_t)(spec.first_field + i), trunc(a));
+  }
+
+  if (!res) return tov(JS_NAN);
+  if (nargs > 0) d = date_make_fields(&fields, spec.local_time);
+
+  return date_set_this_time_value(js, js->this_val, d);
+}
+
+static jsval_t builtin_Date_valueOf(ant_t *js, jsval_t *args, int nargs) {
+  double v;
+  jsval_t err;
+  if (!date_this_time_value(js, js->this_val, &v, &err)) return err;
+  return tov(v);
+}
+
+static jsval_t builtin_Date_getTime(ant_t *js, jsval_t *args, int nargs) {
+  return builtin_Date_valueOf(js, args, nargs);
+}
+
+static jsval_t builtin_Date_toUTCString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_UTC, DATE_STRING_PART_ALL};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_LOCAL, DATE_STRING_PART_ALL};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toISOString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_ISO, DATE_STRING_PART_ALL};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toDateString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_LOCAL, DATE_STRING_PART_DATE};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toTimeString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_LOCAL, DATE_STRING_PART_TIME};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toLocaleString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_LOCALE, DATE_STRING_PART_ALL};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toLocaleDateString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_LOCALE, DATE_STRING_PART_DATE};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_toLocaleTimeString(ant_t *js, jsval_t *args, int nargs) {
+  static const date_string_spec_t kSpec = {DATE_STRING_FMT_LOCALE, DATE_STRING_PART_TIME};
+  return get_date_string(js, js->this_val, kSpec);
+}
+
+static jsval_t builtin_Date_getTimezoneOffset(ant_t *js, jsval_t *args, int nargs) {
+  double v;
+  jsval_t err;
+  if (!date_this_time_value(js, js->this_val, &v, &err)) return err;
+  if (isnan(v)) return tov(JS_NAN);
+  return tov((double)get_timezone_offset((int64_t)trunc(v)));
+}
+
+static jsval_t builtin_Date_setTime(ant_t *js, jsval_t *args, int nargs) {
+  double cur;
+  jsval_t err;
+  if (!date_this_time_value(js, js->this_val, &cur, &err)) return err;
+
+  double v = (nargs > 0) ? js_to_number(js, args[0]) : JS_NAN;
+  return date_set_this_time_value(js, js->this_val, date_timeclip(v));
+}
+
+static jsval_t builtin_Date_getYear(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_YEAR, true, true};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getFullYear(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_YEAR, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCFullYear(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_YEAR, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getMonth(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_MONTH, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCMonth(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_MONTH, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getDate(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_DAY_OF_MONTH, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCDate(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_DAY_OF_MONTH, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getHours(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_HOUR, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCHours(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_HOUR, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getMinutes(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_MINUTE, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCMinutes(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_MINUTE, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getSeconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_SECOND, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCSeconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_SECOND, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getMilliseconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_MILLISECOND, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCMilliseconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_MILLISECOND, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getDay(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_DAY_OF_WEEK, true, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_getUTCDay(ant_t *js, jsval_t *args, int nargs) {
+  static const date_get_field_spec_t kSpec = {DATE_FIELD_DAY_OF_WEEK, false, false};
+  return date_get_field(js, kSpec);
+}
+
+static jsval_t builtin_Date_setMilliseconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_MILLISECOND, DATE_FIELD_DAY_OF_WEEK, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCMilliseconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_MILLISECOND, DATE_FIELD_DAY_OF_WEEK, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setSeconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_SECOND, DATE_FIELD_DAY_OF_WEEK, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCSeconds(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_SECOND, DATE_FIELD_DAY_OF_WEEK, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setMinutes(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_MINUTE, DATE_FIELD_DAY_OF_WEEK, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCMinutes(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_MINUTE, DATE_FIELD_DAY_OF_WEEK, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setHours(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_HOUR, DATE_FIELD_DAY_OF_WEEK, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCHours(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_HOUR, DATE_FIELD_DAY_OF_WEEK, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setDate(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_DAY_OF_MONTH, DATE_FIELD_HOUR, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCDate(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_DAY_OF_MONTH, DATE_FIELD_HOUR, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setMonth(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_MONTH, DATE_FIELD_DAY_OF_MONTH, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCMonth(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_MONTH, DATE_FIELD_DAY_OF_MONTH, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setFullYear(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_YEAR, DATE_FIELD_HOUR, true};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setUTCFullYear(ant_t *js, jsval_t *args, int nargs) {
+  static const date_set_field_spec_t kSpec = {DATE_FIELD_YEAR, DATE_FIELD_HOUR, false};
+  return date_set_field(js, args, nargs, kSpec);
+}
+
+static jsval_t builtin_Date_setYear(ant_t *js, jsval_t *args, int nargs) {
+  double y;
+  jsval_t err;
+  if (!date_this_time_value(js, js->this_val, &y, &err)) return err;
+
+  y = (nargs > 0) ? js_to_number(js, args[0]) : JS_NAN;
+  if (isnan(y)) return date_set_this_time_value(js, js->this_val, y);
+
+  if (isfinite(y)) {
+    y = trunc(y);
+    if (y >= 0 && y < 100) y += 1900;
+  }
+
+  jsval_t darg = tov(y);
+  static const date_set_field_spec_t kSetYearSpec = {
+    DATE_FIELD_YEAR, DATE_FIELD_MONTH, true
+  };
+  return date_set_field(js, &darg, 1, kSetYearSpec);
+}
+
+static jsval_t date_to_primitive_number(ant_t *js, jsval_t obj) {
+  jsval_t to_primitive_sym = get_toPrimitive_sym();
+  if (vtype(to_primitive_sym) == T_SYMBOL) {
+    jsval_t ex = js_get_sym(js, obj, to_primitive_sym);
+    uint8_t et = vtype(ex);
+    if (et == T_FUNC || et == T_CFUNC) {
+      jsval_t hint = js_mkstr(js, "number", 6);
+      jsval_t result = sv_vm_call(js->vm, js, ex, obj, &hint, 1, NULL, false);
+      if (is_err(result)) return result;
+      if (date_is_primitive(result)) return result;
+      return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
+    }
+    if (et != T_UNDEF) {
+      return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol.toPrimitive is not a function");
+    }
+  }
+
+  const char *methods[2] = {"valueOf", "toString"};
+  for (int i = 0; i < 2; i++) {
+    jsval_t method = js_getprop_fallback(js, obj, methods[i]);
+    uint8_t mt = vtype(method);
+    if (mt == T_FUNC || mt == T_CFUNC) {
+      jsval_t result = sv_vm_call(js->vm, js, method, obj, NULL, 0, NULL, false);
+      if (is_err(result)) return result;
+      if (date_is_primitive(result)) return result;
+    }
+  }
+
+  return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
+}
+
+static jsval_t builtin_Date_toJSON(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t obj = js->this_val;
+  if (!is_object_type(obj)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Date.prototype.toJSON called on non-object");
+  }
+
+  jsval_t tv = date_to_primitive_number(js, obj);
+  if (is_err(tv)) return tv;
+
+  if (vtype(tv) == T_NUM && !isfinite(tod(tv))) {
+    return js_mknull();
+  }
+
+  jsval_t method = js_getprop_fallback(js, obj, "toISOString");
+  uint8_t mt = vtype(method);
+  if (mt != T_FUNC && mt != T_CFUNC) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "object needs toISOString method");
+  }
+
+  return sv_vm_call(js->vm, js, method, obj, NULL, 0, NULL, false);
+}
+
+static jsval_t date_toPrimitive(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_val = js_getthis(js);
+  if (!is_object_type(this_val)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Not an object");
+  }
+
+  int hint_num;
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
+    size_t hint_len = 0;
+    const char *hint = js_getstr(js, args[0], &hint_len);
+    if (!hint) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid hint");
+
+    if ((hint_len == 6 && memcmp(hint, "number", 6) == 0)
+        || (hint_len == 7 && memcmp(hint, "integer", 7) == 0)) {
+      hint_num = 1;
+    } else if (
+      (hint_len == 6 && memcmp(hint, "string", 6) == 0)
+      || (hint_len == 7 && memcmp(hint, "default", 7) == 0)) {
+      hint_num = 0;
+    } else {
+      return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid hint");
+    }
+  } else return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid hint");
+
+  const char *methods0[2] = {"toString", "valueOf"};
+  const char *methods1[2] = {"valueOf", "toString"};
+  const char **methods = hint_num ? methods1 : methods0;
+
+  for (int i = 0; i < 2; i++) {
+    jsval_t method = js_getprop_fallback(js, this_val, methods[i]);
+    uint8_t mt = vtype(method);
+    if (mt == T_FUNC || mt == T_CFUNC) {
+      jsval_t result = sv_vm_call(js->vm, js, method, this_val, NULL, 0, NULL, false);
+      if (is_err(result)) return result;
+      if (date_is_primitive(result)) return result;
+    }
+  }
+
+  return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert object to primitive value");
+}
+
+static void date_define_methods(
+  ant_t *js, jsval_t target,
+  const date_method_entry_t *methods,
+  size_t count
+) {
+  for (size_t i = 0; i < count; i++) js_setprop(js,target,
+    js_mkstr(js, methods[i].name, methods[i].len),
+    js_mkfun(methods[i].fn)
+  );
+}
+
+void init_date_module(void) {
+  ant_t *js = rt->js;
+  jsval_t glob = js_glob(js);
+  jsval_t object_proto = js_get_ctor_proto(js, "Object", 6);
+  jsval_t function_proto = js_get_ctor_proto(js, "Function", 8);
+
+  jsval_t date_proto = js_mkobj(js);
+  js_set_proto(js, date_proto, object_proto);
+
+  static const date_method_entry_t kDateProtoMethods[] = {
+    DATE_METHOD_ENTRY("valueOf", builtin_Date_valueOf),
+    DATE_METHOD_ENTRY("toString", builtin_Date_toString),
+    DATE_METHOD_ENTRY("toUTCString", builtin_Date_toUTCString),
+    DATE_METHOD_ENTRY("toGMTString", builtin_Date_toUTCString),
+    DATE_METHOD_ENTRY("toISOString", builtin_Date_toISOString),
+    DATE_METHOD_ENTRY("toDateString", builtin_Date_toDateString),
+    DATE_METHOD_ENTRY("toTimeString", builtin_Date_toTimeString),
+    DATE_METHOD_ENTRY("toLocaleString", builtin_Date_toLocaleString),
+    DATE_METHOD_ENTRY("toLocaleDateString", builtin_Date_toLocaleDateString),
+    DATE_METHOD_ENTRY("toLocaleTimeString", builtin_Date_toLocaleTimeString),
+    DATE_METHOD_ENTRY("getTimezoneOffset", builtin_Date_getTimezoneOffset),
+    DATE_METHOD_ENTRY("getTime", builtin_Date_getTime),
+    DATE_METHOD_ENTRY("getYear", builtin_Date_getYear),
+    DATE_METHOD_ENTRY("getFullYear", builtin_Date_getFullYear),
+    DATE_METHOD_ENTRY("getUTCFullYear", builtin_Date_getUTCFullYear),
+    DATE_METHOD_ENTRY("getMonth", builtin_Date_getMonth),
+    DATE_METHOD_ENTRY("getUTCMonth", builtin_Date_getUTCMonth),
+    DATE_METHOD_ENTRY("getDate", builtin_Date_getDate),
+    DATE_METHOD_ENTRY("getUTCDate", builtin_Date_getUTCDate),
+    DATE_METHOD_ENTRY("getHours", builtin_Date_getHours),
+    DATE_METHOD_ENTRY("getUTCHours", builtin_Date_getUTCHours),
+    DATE_METHOD_ENTRY("getMinutes", builtin_Date_getMinutes),
+    DATE_METHOD_ENTRY("getUTCMinutes", builtin_Date_getUTCMinutes),
+    DATE_METHOD_ENTRY("getSeconds", builtin_Date_getSeconds),
+    DATE_METHOD_ENTRY("getUTCSeconds", builtin_Date_getUTCSeconds),
+    DATE_METHOD_ENTRY("getMilliseconds", builtin_Date_getMilliseconds),
+    DATE_METHOD_ENTRY("getUTCMilliseconds", builtin_Date_getUTCMilliseconds),
+    DATE_METHOD_ENTRY("getDay", builtin_Date_getDay),
+    DATE_METHOD_ENTRY("getUTCDay", builtin_Date_getUTCDay),
+    DATE_METHOD_ENTRY("setTime", builtin_Date_setTime),
+    DATE_METHOD_ENTRY("setMilliseconds", builtin_Date_setMilliseconds),
+    DATE_METHOD_ENTRY("setUTCMilliseconds", builtin_Date_setUTCMilliseconds),
+    DATE_METHOD_ENTRY("setSeconds", builtin_Date_setSeconds),
+    DATE_METHOD_ENTRY("setUTCSeconds", builtin_Date_setUTCSeconds),
+    DATE_METHOD_ENTRY("setMinutes", builtin_Date_setMinutes),
+    DATE_METHOD_ENTRY("setUTCMinutes", builtin_Date_setUTCMinutes),
+    DATE_METHOD_ENTRY("setHours", builtin_Date_setHours),
+    DATE_METHOD_ENTRY("setUTCHours", builtin_Date_setUTCHours),
+    DATE_METHOD_ENTRY("setDate", builtin_Date_setDate),
+    DATE_METHOD_ENTRY("setUTCDate", builtin_Date_setUTCDate),
+    DATE_METHOD_ENTRY("setMonth", builtin_Date_setMonth),
+    DATE_METHOD_ENTRY("setUTCMonth", builtin_Date_setUTCMonth),
+    DATE_METHOD_ENTRY("setYear", builtin_Date_setYear),
+    DATE_METHOD_ENTRY("setFullYear", builtin_Date_setFullYear),
+    DATE_METHOD_ENTRY("setUTCFullYear", builtin_Date_setUTCFullYear),
+    DATE_METHOD_ENTRY("toJSON", builtin_Date_toJSON),
+  };
+  date_define_methods(js, date_proto, kDateProtoMethods, DATE_COUNT_OF(kDateProtoMethods));
+
+  jsval_t to_primitive_sym = get_toPrimitive_sym();
+  if (vtype(to_primitive_sym) == T_SYMBOL) {
+    js_set_sym(js, date_proto, to_primitive_sym, js_mkfun(date_toPrimitive));
+  }
+
+  jsval_t date_ctor_obj = js_mkobj(js);
+  js_set_proto(js, date_ctor_obj, function_proto);
+  js_set_slot(js, date_ctor_obj, SLOT_CFUNC, js_mkfun(builtin_Date));
+  static const date_method_entry_t kDateCtorMethods[] = {
+    DATE_METHOD_ENTRY("now", builtin_Date_now),
+    DATE_METHOD_ENTRY("parse", builtin_Date_parse),
+    DATE_METHOD_ENTRY("UTC", builtin_Date_UTC),
+  };
+  date_define_methods(js, date_ctor_obj, kDateCtorMethods, DATE_COUNT_OF(kDateCtorMethods));
+  js_setprop_nonconfigurable(js, date_ctor_obj, "prototype", 9, date_proto);
+  js_setprop(js, date_ctor_obj, ANT_STRING("name"), ANT_STRING("Date"));
+
+  jsval_t date_ctor_func = js_obj_to_func(date_ctor_obj);
+  js_setprop(js, glob, js_mkstr(js, "Date", 4), date_ctor_func);
+
+  js_setprop(js, date_proto, js_mkstr(js, "constructor", 11), date_ctor_func);
+  js_set_descriptor(js, date_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
+}
diff --git a/src/modules/dns.c b/src/modules/dns.c
new file mode 100644
index 0000000..b40ea19
--- /dev/null
+++ b/src/modules/dns.c
@@ -0,0 +1,70 @@
+// stub: minimal node:dns implementation (dns.promises.lookup)
+// just enough for vite to resolve localhost addresses
+
+#include <string.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#endif
+
+#include "ant.h"
+#include "errors.h"
+
+static jsval_t dns_promises_lookup(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr(js, "hostname is required");
+
+  size_t len;
+  const char *hostname = js_getstr(js, args[0], &len);
+  if (!hostname) return js_mkerr(js, "hostname must be a string");
+
+  struct addrinfo hints = {0}, *res = NULL;
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+
+  int err = getaddrinfo(hostname, NULL, &hints, &res);
+  if (err != 0 || !res) {
+    return js_mkerr(js, "getaddrinfo failed for '%s'", hostname);
+  }
+
+  char addr_str[INET6_ADDRSTRLEN];
+  int family = 0;
+
+  if (res->ai_family == AF_INET) {
+    struct sockaddr_in *sa = (struct sockaddr_in *)res->ai_addr;
+    inet_ntop(AF_INET, &sa->sin_addr, addr_str, sizeof(addr_str));
+    family = 4;
+  } else if (res->ai_family == AF_INET6) {
+    struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)res->ai_addr;
+    inet_ntop(AF_INET6, &sa6->sin6_addr, addr_str, sizeof(addr_str));
+    family = 6;
+  } else {
+    freeaddrinfo(res);
+    return js_mkerr(js, "unsupported address family");
+  }
+
+  freeaddrinfo(res);
+
+  jsval_t result = js_mkobj(js);
+  js_set(js, result, "address", js_mkstr(js, addr_str, strlen(addr_str)));
+  js_set(js, result, "family", js_mknum(family));
+
+  jsval_t promise = js_mkpromise(js);
+  js_resolve_promise(js, promise, result);
+  return promise;
+}
+
+jsval_t dns_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+  jsval_t promises = js_mkobj(js);
+
+  js_set(js, promises, "lookup", js_mkfun(dns_promises_lookup));
+  js_set(js, lib, "promises", promises);
+
+  return lib;
+}
diff --git a/src/modules/events.c b/src/modules/events.c
index 620bb37..26b94dd 100644
--- a/src/modules/events.c
+++ b/src/modules/events.c
@@ -9,6 +9,8 @@
 #include "arena.h"
 #include "runtime.h"
 #include "internal.h"
+#include "descriptors.h"
+#include "silver/engine.h"
 
 #include "modules/events.h"
 #include "modules/symbol.h"
@@ -44,7 +46,7 @@ static inline void remove_listener_at(EventType *evt, int i) {
   evt->listener_count--;
 }
 
-static EventType **get_or_create_emitter_events(struct js *js, jsval_t this_obj) {
+static EventType **get_or_create_emitter_events(ant_t *js, jsval_t this_obj) {
   jsval_t slot = js_get_slot(js, this_obj, SLOT_DATA);
   
   if (vtype(slot) == T_UNDEF) {
@@ -66,7 +68,7 @@ static EventType **get_or_create_emitter_events(struct js *js, jsval_t this_obj)
   return (EventType **)(uintptr_t)js_getnum(slot);
 }
 
-static EventType *find_emitter_event_type(struct js *js, jsval_t this_obj, const char *event_type) {
+static EventType *find_emitter_event_type(ant_t *js, jsval_t this_obj, const char *event_type) {
   EventType **events = get_or_create_emitter_events(js, this_obj);
   if (events == NULL) return NULL;
   
@@ -75,7 +77,7 @@ static EventType *find_emitter_event_type(struct js *js, jsval_t this_obj, const
   return evt;
 }
 
-static EventType *find_or_create_emitter_event_type(struct js *js, jsval_t this_obj, const char *event_type) {
+static EventType *find_or_create_emitter_event_type(ant_t *js, jsval_t this_obj, const char *event_type) {
   EventType **events = get_or_create_emitter_events(js, this_obj);
   if (events == NULL) return NULL;
   
@@ -119,7 +121,7 @@ static inline EventType *find_global_event_type(const char *event_type) {
 }
 
 // addEventListener(eventType, listener, options)
-static jsval_t js_add_event_listener_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_add_event_listener_method(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 2) {
@@ -151,7 +153,7 @@ static jsval_t js_add_event_listener_method(struct js *js, jsval_t *args, int na
 }
 
 // addEventListener(eventType, listener, options)
-static jsval_t js_add_event_listener(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_add_event_listener(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "addEventListener requires at least 2 arguments (eventType, listener)");
   }
@@ -188,7 +190,7 @@ static jsval_t js_add_event_listener(struct js *js, jsval_t *args, int nargs) {
 }
 
 // removeEventListener(eventType, listener)
-static jsval_t js_remove_event_listener_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_remove_event_listener_method(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 2) {
@@ -211,7 +213,7 @@ static jsval_t js_remove_event_listener_method(struct js *js, jsval_t *args, int
 }
 
 // removeEventListener(eventType, listener)
-static jsval_t js_remove_event_listener(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_remove_event_listener(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "removeEventListener requires 2 arguments (eventType, listener)");
   }
@@ -232,7 +234,7 @@ static jsval_t js_remove_event_listener(struct js *js, jsval_t *args, int nargs)
 }
 
 // dispatchEvent(eventType, eventData)
-static jsval_t js_dispatch_event_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dispatch_event_method(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 1) {
@@ -248,7 +250,7 @@ static jsval_t js_dispatch_event_method(struct js *js, jsval_t *args, int nargs)
   jsval_t event_obj = js_mkobj(js);
   js_set(js, event_obj, "type", args[0]);
   js_set(js, event_obj, "target", this_obj);
-  js_set(js, event_obj, get_toStringTag_sym_key(), js_mkstr(js, "Event", 5));
+  js_set_sym(js, event_obj, get_toStringTag_sym(), js_mkstr(js, "Event", 5));
   
   if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
     js_set(js, event_obj, "detail", args[1]);
@@ -258,7 +260,7 @@ static jsval_t js_dispatch_event_method(struct js *js, jsval_t *args, int nargs)
   int i = 0;
   while (i < evt->listener_count) {
     EventListener *listener = &evt->listeners[i];
-    jsval_t result = js_call(js, listener->listener, listener_args, 1);
+    jsval_t result = sv_vm_call(js->vm, js, listener->listener, js_mkundef(), listener_args, 1, NULL, false);
     
     if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result));
@@ -273,7 +275,7 @@ static jsval_t js_dispatch_event_method(struct js *js, jsval_t *args, int nargs)
 }
 
 // dispatchEvent(eventType, eventData)
-static jsval_t js_dispatch_event(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_dispatch_event(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "dispatchEvent requires at least 1 argument (eventType)");
   }
@@ -288,7 +290,7 @@ static jsval_t js_dispatch_event(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t event_obj = js_mkobj(js);
   js_set(js, event_obj, "type", args[0]);
-  js_set(js, event_obj, get_toStringTag_sym_key(), js_mkstr(js, "Event", 5));
+  js_set_sym(js, event_obj, get_toStringTag_sym(), js_mkstr(js, "Event", 5));
   
   if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
     js_set(js, event_obj, "detail", args[1]);
@@ -298,7 +300,7 @@ static jsval_t js_dispatch_event(struct js *js, jsval_t *args, int nargs) {
   int i = 0;
   while (i < evt->listener_count) {
     EventListener *listener = &evt->listeners[i];
-    jsval_t result = js_call(js, listener->listener, listener_args, 1);
+    jsval_t result = sv_vm_call(js->vm, js, listener->listener, js_mkundef(), listener_args, 1, NULL, false);
     
     if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result));
@@ -312,7 +314,7 @@ static jsval_t js_dispatch_event(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t js_get_event_listeners(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_get_event_listeners(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   
   EventType *evt, *tmp;
@@ -340,7 +342,7 @@ static jsval_t js_get_event_listeners(struct js *js, jsval_t *args, int nargs) {
 }
 
 // EventEmitter.prototype.on(event, listener)
-static jsval_t js_eventemitter_on(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_on(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 2) {
@@ -373,7 +375,7 @@ static jsval_t js_eventemitter_on(struct js *js, jsval_t *args, int nargs) {
 }
 
 // EventEmitter.prototype.once(event, listener)
-static jsval_t js_eventemitter_once(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_once(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 2) {
@@ -406,7 +408,7 @@ static jsval_t js_eventemitter_once(struct js *js, jsval_t *args, int nargs) {
 }
 
 // EventEmitter.prototype.off(event, listener)
-static jsval_t js_eventemitter_off(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_off(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 2) {
@@ -433,7 +435,7 @@ static jsval_t js_eventemitter_off(struct js *js, jsval_t *args, int nargs) {
 }
 
 // EventEmitter.prototype.emit(event, ...args)
-static jsval_t js_eventemitter_emit(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_emit(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 1) {
@@ -456,7 +458,7 @@ static jsval_t js_eventemitter_emit(struct js *js, jsval_t *args, int nargs) {
   int i = 0;
   while (i < evt->listener_count) {
     EventListener *listener = &evt->listeners[i];
-    jsval_t result = js_call(js, listener->listener, listener_args, listener_nargs);
+    jsval_t result = sv_vm_call(js->vm, js, listener->listener, js_mkundef(), listener_args, listener_nargs, NULL, false);
     
     if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result));
@@ -471,7 +473,7 @@ static jsval_t js_eventemitter_emit(struct js *js, jsval_t *args, int nargs) {
 }
 
 // EventEmitter.prototype.removeAllListeners(event)
-static jsval_t js_eventemitter_removeAllListeners(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_removeAllListeners(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 1) {
@@ -492,7 +494,7 @@ static jsval_t js_eventemitter_removeAllListeners(struct js *js, jsval_t *args,
 }
 
 // EventEmitter.prototype.listenerCount(event)
-static jsval_t js_eventemitter_listenerCount(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_listenerCount(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   
   if (nargs < 1) {
@@ -513,7 +515,7 @@ static jsval_t js_eventemitter_listenerCount(struct js *js, jsval_t *args, int n
 }
 
 // EventEmitter.prototype.eventNames()
-static jsval_t js_eventemitter_eventNames(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_eventemitter_eventNames(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   
   jsval_t this_obj = js_getthis(js);
@@ -534,28 +536,7 @@ static jsval_t js_eventemitter_eventNames(struct js *js, jsval_t *args, int narg
   return result;
 }
 
-// EventEmitter constructor
-static jsval_t js_eventemitter_constructor(struct js *js, jsval_t *args, int nargs) {
-  (void)args; (void)nargs;
-  
-  jsval_t proto = js_get_ctor_proto(js, "EventEmitter", 12);
-  jsval_t obj = js_mkobj(js);
-  js_set_proto(js, obj, proto);
-  
-  return obj;
-}
-
-static jsval_t js_eventtarget_constructor(struct js *js, jsval_t *args, int nargs) {
-  (void)args; (void)nargs;
-  
-  jsval_t proto = js_get_ctor_proto(js, "EventTarget", 11);
-  jsval_t obj = js_mkobj(js);
-  js_set_proto(js, obj, proto);
-  
-  return obj;
-}
-
-jsval_t events_library(struct js *js) {
+jsval_t events_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
   
   jsval_t eventemitter_ctor = js_mkobj(js);
@@ -570,21 +551,23 @@ jsval_t events_library(struct js *js) {
   js_set(js, eventemitter_proto, "removeAllListeners", js_mkfun(js_eventemitter_removeAllListeners));
   js_set(js, eventemitter_proto, "listenerCount", js_mkfun(js_eventemitter_listenerCount));
   js_set(js, eventemitter_proto, "eventNames", js_mkfun(js_eventemitter_eventNames));
-  js_set(js, eventemitter_proto, get_toStringTag_sym_key(), js_mkstr(js, "EventEmitter", 12));
+  js_set_sym(js, eventemitter_proto, get_toStringTag_sym(), js_mkstr(js, "EventEmitter", 12));
   
-  js_set_slot(js, eventemitter_ctor, SLOT_CFUNC, js_mkfun(js_eventemitter_constructor));
+  js_set_slot(js, eventemitter_ctor, SLOT_DEFAULT_CTOR, js_true);
   js_mkprop_fast(js, eventemitter_ctor, "prototype", 9, eventemitter_proto);
   js_mkprop_fast(js, eventemitter_ctor, "name", 4, ANT_STRING("EventEmitter"));
   js_set_descriptor(js, eventemitter_ctor, "name", 4, 0);
   
-  js_set(js, lib, "EventEmitter", js_obj_to_func(eventemitter_ctor));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "events", 6));
+  jsval_t ctor_fn = js_obj_to_func(eventemitter_ctor);
+  js_set(js, lib, "EventEmitter", ctor_fn);
+  js_set(js, lib, "default", ctor_fn);
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "events", 6));
   
   return lib;
 }
 
 void init_events_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t global = js_glob(js);
   
   jsval_t eventtarget_ctor = js_mkobj(js);
@@ -593,9 +576,9 @@ void init_events_module() {
   js_set(js, eventtarget_proto, "addEventListener", js_mkfun(js_add_event_listener_method));
   js_set(js, eventtarget_proto, "removeEventListener", js_mkfun(js_remove_event_listener_method));
   js_set(js, eventtarget_proto, "dispatchEvent", js_mkfun(js_dispatch_event_method));
-  js_set(js, eventtarget_proto, get_toStringTag_sym_key(), js_mkstr(js, "EventTarget", 11));
+  js_set_sym(js, eventtarget_proto, get_toStringTag_sym(), js_mkstr(js, "EventTarget", 11));
   
-  js_set_slot(js, eventtarget_ctor, SLOT_CFUNC, js_mkfun(js_eventtarget_constructor));
+  js_set_slot(js, eventtarget_ctor, SLOT_DEFAULT_CTOR, js_true);
   js_mkprop_fast(js, eventtarget_ctor, "prototype", 9, eventtarget_proto);
   js_mkprop_fast(js, eventtarget_ctor, "name", 4, ANT_STRING("EventTarget"));
   js_set_descriptor(js, eventtarget_ctor, "name", 4, 0);
diff --git a/src/modules/fetch.c b/src/modules/fetch.c
index 4fdeaf0..204f3f6 100644
--- a/src/modules/fetch.c
+++ b/src/modules/fetch.c
@@ -24,7 +24,7 @@ typedef struct {
 } fetch_buffer_t;
 
 typedef struct fetch_request_s {
-  struct js *js;
+  ant_t *js;
   jsval_t promise;
   tlsuv_http_t http_client;
   tlsuv_http_req_t *http_req;
@@ -64,7 +64,7 @@ static void remove_pending_request(fetch_request_t *req) {
   }
 }
 
-static jsval_t fetch_fail_oom(struct js *js, jsval_t promise, fetch_request_t *req, bool close_http, const char *msg, size_t len) {
+static jsval_t fetch_fail_oom(ant_t *js, jsval_t promise, fetch_request_t *req, bool close_http, const char *msg, size_t len) {
   jsval_t err = js_mkstr(js, msg, len);
   js_reject_promise(js, promise, err);
   if (close_http) tlsuv_http_close(&req->http_client, NULL);
@@ -72,7 +72,7 @@ static jsval_t fetch_fail_oom(struct js *js, jsval_t promise, fetch_request_t *r
   return js_mkundef();
 }
 
-static jsval_t response_text(struct js *js, jsval_t *args, int nargs) {  
+static jsval_t response_text(ant_t *js, jsval_t *args, int nargs) {  
   jsval_t this = js_getthis(js);
   jsval_t body = js_get_slot(js, this, SLOT_DATA);
   
@@ -82,7 +82,7 @@ static jsval_t response_text(struct js *js, jsval_t *args, int nargs) {
   return promise;
 }
 
-static jsval_t response_json(struct js *js, jsval_t *args, int nargs) {  
+static jsval_t response_json(ant_t *js, jsval_t *args, int nargs) {  
   jsval_t this = js_getthis(js);
   jsval_t body = js_get_slot(js, this, SLOT_DATA);
   jsval_t parsed = js_json_parse(js, &body, 1);
@@ -95,7 +95,7 @@ static jsval_t response_json(struct js *js, jsval_t *args, int nargs) {
   return promise;
 }
 
-static jsval_t create_response(struct js *js, int status, const char *body, size_t body_len) {
+static jsval_t create_response(ant_t *js, int status, const char *body, size_t body_len) {
   jsval_t response_obj = js_mkobj(js);
   jsval_t body_str = js_mkstr(js, body, body_len);
 
@@ -184,7 +184,7 @@ static void resp_cb(tlsuv_http_resp_t *resp, void *data) {
   resp->body_cb = body_cb;
 }
 
-static jsval_t do_fetch_microtask(struct js *js, jsval_t *args, int nargs) {
+static jsval_t do_fetch_microtask(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   
@@ -315,7 +315,7 @@ static jsval_t do_fetch_microtask(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t js_fetch(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_fetch(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "fetch requires at least 1 argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "fetch URL must be a string");
   
@@ -325,8 +325,8 @@ static jsval_t js_fetch(struct js *js, jsval_t *args, int nargs) {
   jsval_t promise = js_mkpromise(js);
   jsval_t wrapper_obj = js_mkobj(js);
   
-  js_set_slot(js, wrapper_obj, SLOT_CFUNC, js_mkfun(do_fetch_microtask));
   js_set_slot(js, wrapper_obj, SLOT_DATA, promise);
+  js_set_slot(js, wrapper_obj, SLOT_CFUNC, js_mkfun(do_fetch_microtask));
   
   js_set(js, wrapper_obj, "url", url_val);
   js_set(js, wrapper_obj, "options", options_val);
diff --git a/src/modules/ffi.c b/src/modules/ffi.c
index c35bc71..786eb8c 100644
--- a/src/modules/ffi.c
+++ b/src/modules/ffi.c
@@ -17,6 +17,7 @@
 
 #include "errors.h"
 #include "internal.h"
+#include "silver/engine.h"
 
 #include "modules/ffi.h"
 #include "modules/symbol.h"
@@ -57,7 +58,7 @@ typedef struct ffi_callback {
   char ret_type_str[32];
   char **arg_type_strs;
   int arg_count;
-  struct js *js;
+  ant_t *js;
   jsval_t js_func;
   uint64_t cb_key;
   UT_hash_handle hh;
@@ -80,25 +81,25 @@ static const UT_icd ffi_func_icd = {
   .dtor = NULL,
 };
 
-static jsval_t ffi_dlopen(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_lib_call(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_call_function(struct js *js, ffi_func_t *func, jsval_t *args, int nargs);
-static jsval_t ffi_alloc_memory(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_free_memory(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_read_memory(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_write_memory(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_get_pointer(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_create_callback(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_free_callback(struct js *js, jsval_t *args, int nargs);
-static jsval_t ffi_read_ptr(struct js *js, jsval_t *args, int nargs);
+static jsval_t ffi_dlopen(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_define(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_lib_call(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_call_function(ant_t *js, ffi_func_t *func, jsval_t *args, int nargs);
+static jsval_t ffi_alloc_memory(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_free_memory(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_read_memory(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_write_memory(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_get_pointer(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_create_callback(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_free_callback(ant_t *js, jsval_t *args, int nargs);
+static jsval_t ffi_read_ptr(ant_t *js, jsval_t *args, int nargs);
 
 static ffi_type *get_ffi_type(const char *type_str);
-static void *js_to_ffi_value(struct js *js, jsval_t val, ffi_type *type, void *buffer);
-static jsval_t ffi_to_js_value(struct js *js, void *val, ffi_type *type, const char *type_str);
+static void *js_to_ffi_value(ant_t *js, jsval_t val, ffi_type *type, void *buffer);
+static jsval_t ffi_to_js_value(ant_t *js, void *val, ffi_type *type, const char *type_str);
 static void ffi_callback_handler(ffi_cif *cif, void *ret, void **args, void *user_data);
 
-jsval_t ffi_library(struct js *js) {
+jsval_t ffi_library(ant_t *js) {
   jsval_t ffi_obj = js_mkobj(js);
 
   js_set(js, ffi_obj, "dlopen", js_mkfun(ffi_dlopen));
@@ -138,7 +139,7 @@ jsval_t ffi_library(struct js *js) {
   js_set(js, ffi_types, "string", js_mkstr(js, "string", 6));
   js_set(js, ffi_types, "spread", js_mkstr(js, "...", 3));
   js_set(js, ffi_obj, "FFIType", ffi_types);
-  js_set(js, ffi_obj, get_toStringTag_sym_key(), js_mkstr(js, "FFI", 3));
+  js_set_sym(js, ffi_obj, get_toStringTag_sym(), js_mkstr(js, "FFI", 3));
 
   return ffi_obj;
 }
@@ -152,7 +153,7 @@ static void ffi_init_array(void) {
     utarray_new(ffi_functions_array, &ffi_func_icd);
 }
 
-static jsval_t ffi_dlopen(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_dlopen(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "dlopen() requires library name string");
   }
@@ -201,7 +202,7 @@ static jsval_t ffi_dlopen(struct js *js, jsval_t *args, int nargs) {
   return lib->js_obj;
 }
 
-static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_define(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "define() requires function name string and signature");
   }
@@ -348,7 +349,7 @@ static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t ffi_lib_call(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_lib_call(ant_t *js, jsval_t *args, int nargs) {
   jsval_t lib_obj = js_getthis(js);
   if (nargs < 1 || vtype(args[0]) != T_STR)
     return js_mkerr(js, "call() requires function name string");
@@ -365,7 +366,7 @@ static jsval_t ffi_lib_call(struct js *js, jsval_t *args, int nargs) {
   return ffi_call_by_index(js, (unsigned int)func_index, args + 1, nargs - 1);
 }
 
-static jsval_t ffi_call_function(struct js *js, ffi_func_t *func, jsval_t *args,int nargs) {
+static jsval_t ffi_call_function(ant_t *js, ffi_func_t *func, jsval_t *args,int nargs) {
   if (!func->is_variadic && nargs != func->arg_count) {
     return js_mkerr(js, "Function '%s' expects %d arguments, got %d", func->name, func->arg_count, nargs);
   }
@@ -430,7 +431,7 @@ static jsval_t ffi_call_function(struct js *js, ffi_func_t *func, jsval_t *args,
   return ffi_to_js_value(js, &result, func->ret_type, func->ret_type_str);
 }
 
-jsval_t ffi_call_by_index(struct js *js, unsigned int func_index, jsval_t *args, int nargs) {
+jsval_t ffi_call_by_index(ant_t *js, unsigned int func_index, jsval_t *args, int nargs) {
   pthread_mutex_lock(&ffi_functions_mutex);
   if (func_index >= utarray_len(ffi_functions_array)) {
     pthread_mutex_unlock(&ffi_functions_mutex);
@@ -443,7 +444,7 @@ jsval_t ffi_call_by_index(struct js *js, unsigned int func_index, jsval_t *args,
   return ffi_call_function(js, func, args, nargs);
 }
 
-static jsval_t ffi_alloc_memory(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_alloc_memory(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "alloc() requires size");
   }
@@ -476,7 +477,7 @@ static jsval_t ffi_alloc_memory(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)ffi_ptr->ptr_key);
 }
 
-static jsval_t ffi_free_memory(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_free_memory(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "free() requires pointer");
   }
@@ -503,7 +504,7 @@ static jsval_t ffi_free_memory(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t ffi_read_memory(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_read_memory(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) {
     return js_mkerr(js, "read() requires pointer and type");
   }
@@ -531,7 +532,7 @@ static jsval_t ffi_read_memory(struct js *js, jsval_t *args, int nargs) {
   return ffi_to_js_value(js, ptr, type, type_str);
 }
 
-static jsval_t ffi_write_memory(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_write_memory(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) {
     return js_mkerr(js, "write() requires pointer, type, and value");
   }
@@ -561,7 +562,7 @@ static jsval_t ffi_write_memory(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t ffi_get_pointer(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_get_pointer(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_NUM) return js_mkerr(js, "pointer() requires pointer");
   uint64_t ptr_key = (uint64_t)js_getnum(args[0]);
 
@@ -574,7 +575,7 @@ static jsval_t ffi_get_pointer(struct js *js, jsval_t *args, int nargs) {
   return js_bool(exists);
 }
 
-static jsval_t ffi_read_ptr(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_read_ptr(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) {
     return js_mkerr(js, "readPtr() requires pointer and type");
   }
@@ -598,7 +599,7 @@ static jsval_t ffi_read_ptr(struct js *js, jsval_t *args, int nargs) {
 static void ffi_callback_handler(ffi_cif *cif, void *ret, void **args, void *user_data) {
   (void)cif;
   ffi_callback_t *cb = (ffi_callback_t *)user_data;
-  struct js *js = cb->js;
+  ant_t *js = cb->js;
 
   jsval_t js_args[32];
   int arg_count = cb->arg_count > 32 ? 32 : cb->arg_count;
@@ -607,7 +608,7 @@ static void ffi_callback_handler(ffi_cif *cif, void *ret, void **args, void *use
     js_args[i] = ffi_to_js_value(js, args[i], cb->arg_types[i], cb->arg_type_strs[i]);
   }
 
-  jsval_t result = js_call(js, cb->js_func, js_args, arg_count);
+  jsval_t result = sv_vm_call(js->vm, js, cb->js_func, js_mkundef(), js_args, arg_count, NULL, false);
 
   if (cb->ret_type != &ffi_type_void) {
     if (cb->ret_type == &ffi_type_sint8) {
@@ -638,7 +639,7 @@ static void ffi_callback_handler(ffi_cif *cif, void *ret, void **args, void *use
   }
 }
 
-static jsval_t ffi_create_callback(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_create_callback(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "callback() requires function and signature");
 
   jsval_t js_func = args[0];
@@ -759,7 +760,7 @@ static jsval_t ffi_create_callback(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)cb->cb_key);
 }
 
-static jsval_t ffi_free_callback(struct js *js, jsval_t *args, int nargs) {
+static jsval_t ffi_free_callback(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "freeCallback() requires callback pointer");
   }
@@ -853,7 +854,7 @@ static ffi_type *get_ffi_type(const char *type_str) {
   return type_map[id];
 }
 
-static void *js_to_ffi_value(struct js *js, jsval_t val, ffi_type *type, void *buffer) {
+static void *js_to_ffi_value(ant_t *js, jsval_t val, ffi_type *type, void *buffer) {
   static const void *dispatch[] = {
     &&do_sint8, &&do_sint16, &&do_sint32, &&do_sint64,
     &&do_uint8, &&do_uint16, &&do_uint64,
@@ -936,7 +937,7 @@ do_done:
   return buffer;
 }
 
-static jsval_t ffi_to_js_value(struct js *js, void *val, ffi_type *type, const char *type_str) {
+static jsval_t ffi_to_js_value(ant_t *js, void *val, ffi_type *type, const char *type_str) {
   static const void *dispatch[] = {
     &&ret_void, &&ret_sint8, &&ret_sint16, &&ret_sint32, &&ret_sint64,
     &&ret_uint8, &&ret_uint16, &&ret_uint64,
diff --git a/src/modules/fs.c b/src/modules/fs.c
index 45c2567..53a43d4 100644
--- a/src/modules/fs.c
+++ b/src/modules/fs.c
@@ -17,6 +17,7 @@
 #include "errors.h"
 #include "internal.h"
 #include "runtime.h"
+#include "descriptors.h"
 
 #include "modules/fs.h"
 #include "modules/buffer.h"
@@ -39,7 +40,16 @@ typedef enum {
   FS_ENC_ASCII,
 } fs_encoding_t;
 
-static fs_encoding_t parse_encoding(struct js *js, jsval_t arg) {
+static jsval_t fs_coerce_path(ant_t *js, jsval_t arg) {
+  if (vtype(arg) == T_STR) return arg;
+  if (is_object_type(arg)) {
+    jsval_t pathname = js_get(js, arg, "pathname");
+    if (vtype(pathname) == T_STR) return pathname;
+  }
+  return js_mkundef();
+}
+
+static fs_encoding_t parse_encoding(ant_t *js, jsval_t arg) {
   size_t len;
   const char *str = NULL;
 
@@ -66,7 +76,7 @@ static fs_encoding_t parse_encoding(struct js *js, jsval_t arg) {
   return FS_ENC_NONE;
 }
 
-static jsval_t encode_data(struct js *js, const char *data, size_t len, fs_encoding_t enc) {
+static jsval_t encode_data(ant_t *js, const char *data, size_t len, fs_encoding_t enc) {
   switch (enc) {
     case FS_ENC_UTF8:
     case FS_ENC_LATIN1:
@@ -143,7 +153,7 @@ typedef enum {
 
 typedef struct fs_request_s {
   uv_fs_t uv_req;
-  struct js *js;
+  ant_t *js;
   jsval_t promise;
   char *path;
   char *data;
@@ -154,6 +164,7 @@ typedef struct fs_request_s {
   uv_file fd;
   int completed;
   int failed;
+  int recursive;
 } fs_request_t;
 
 static UT_array *pending_requests = NULL;
@@ -179,11 +190,11 @@ static void remove_pending_request(fs_request_t *req) {
   }
 }
 
-static jsval_t fs_read_to_uint8array(struct js *js, const char *data, size_t len) {
+static jsval_t fs_read_to_uint8array(ant_t *js, const char *data, size_t len) {
   ArrayBufferData *ab = create_array_buffer_data(len);
   if (!ab) return js_mkundef();
   memcpy(ab->data, data, len);
-  jsval_t result = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, len, "Uint8Array");
+  jsval_t result = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, len, "Buffer");
   if (vtype(result) == T_ERR) free_array_buffer_data(ab);
   return result;
 }
@@ -191,8 +202,16 @@ static jsval_t fs_read_to_uint8array(struct js *js, const char *data, size_t len
 static void complete_request(fs_request_t *req) {
   if (req->failed) {
     const char *err_msg = req->error_msg ? req->error_msg : "Unknown error";
-    jsval_t err = js_mkstr(req->js, err_msg, strlen(err_msg));
-    js_reject_promise(req->js, req->promise, err);
+    jsval_t reject_value = js_mkerr(req->js, "%s", err_msg);
+    if (is_err(reject_value)) {
+      reject_value = req->js->thrown_value;
+      if (vtype(reject_value) == T_UNDEF) {
+        reject_value = js_mkstr(req->js, err_msg, strlen(err_msg));
+      }
+      req->js->thrown_exists = false;
+      req->js->thrown_value = js_mkundef();
+    }
+    js_reject_promise(req->js, req->promise, reject_value);
   } else {
     jsval_t result = js_mkundef();
     if (req->op_type == FS_OP_READ && req->data) {
@@ -350,9 +369,10 @@ static void on_mkdir_complete(uv_fs_t *uv_req) {
   fs_request_t *req = (fs_request_t *)uv_req->data;
   
   if (uv_req->result < 0) {
+  if (!req->recursive || uv_req->result != UV_EEXIST) {
     req->failed = 1;
     req->error_msg = strdup(uv_strerror((int)uv_req->result));
-  }
+  }}
   
   uv_fs_req_cleanup(uv_req);
   req->completed = 1;
@@ -452,13 +472,14 @@ static void on_readdir_complete(uv_fs_t *uv_req) {
   free_fs_request(req);
 }
 
-static jsval_t builtin_fs_readFileSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readFileSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readFileSync() requires a path argument");
   
-  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readFileSync() path must be a string");
+  jsval_t path_val = fs_coerce_path(js, args[0]);
+  if (vtype(path_val) != T_STR) return js_mkerr(js, "readFileSync() path must be a string or URL");
   
   size_t path_len;
-  char *path = js_getstr(js, args[0], &path_len);
+  char *path = js_getstr(js, path_val, &path_len);
   if (!path) return js_mkerr(js, "Failed to get path string");
   
   char *path_cstr = strndup(path, path_len);
@@ -506,7 +527,7 @@ static jsval_t builtin_fs_readFileSync(struct js *js, jsval_t *args, int nargs)
   return result;
 }
 
-static jsval_t builtin_fs_readBytesSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readBytesSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readBytesSync() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytesSync() path must be a string");
   
@@ -556,7 +577,7 @@ static jsval_t builtin_fs_readBytesSync(struct js *js, jsval_t *args, int nargs)
   return result;
 }
 
-static jsval_t builtin_fs_readFile(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readFile(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readFile() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "readFile() path must be a string");
@@ -589,7 +610,7 @@ static jsval_t builtin_fs_readFile(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_readBytes(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readBytes(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readBytes() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytes() path must be a string");
@@ -621,7 +642,7 @@ static jsval_t builtin_fs_readBytes(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_writeFileSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_writeFileSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writeFileSync() requires path and data arguments");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFileSync() path must be a string");
@@ -654,7 +675,7 @@ static jsval_t builtin_fs_writeFileSync(struct js *js, jsval_t *args, int nargs)
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_copyFileSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_copyFileSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "copyFileSync() requires src and dest arguments");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "copyFileSync() src must be a string");
@@ -711,7 +732,7 @@ static jsval_t builtin_fs_copyFileSync(struct js *js, jsval_t *args, int nargs)
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_renameSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_renameSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "renameSync() requires oldPath and newPath arguments");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "renameSync() oldPath must be a string");
@@ -744,7 +765,7 @@ static jsval_t builtin_fs_renameSync(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_appendFileSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_appendFileSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "appendFileSync() requires path and data arguments");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "appendFileSync() path must be a string");
@@ -777,7 +798,7 @@ static jsval_t builtin_fs_appendFileSync(struct js *js, jsval_t *args, int nargs
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_writeFile(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_writeFile(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writeFile() requires path and data arguments");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFile() path must be a string");
@@ -821,7 +842,7 @@ static jsval_t builtin_fs_writeFile(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_unlinkSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_unlinkSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "unlinkSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlinkSync() path must be a string");
@@ -845,7 +866,7 @@ static jsval_t builtin_fs_unlinkSync(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_unlink(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_unlink(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "unlink() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlink() path must be a string");
@@ -877,7 +898,7 @@ static jsval_t builtin_fs_unlink(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_mkdirSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_mkdirSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "mkdirSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdirSync() path must be a string");
@@ -929,7 +950,7 @@ do_mkdir:
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_mkdir(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_mkdir(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "mkdir() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdir() path must be a string");
@@ -939,11 +960,22 @@ static jsval_t builtin_fs_mkdir(struct js *js, jsval_t *args, int nargs) {
   if (!path) return js_mkerr(js, "Failed to get path string");
   
   int mode = 0755;
-  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
-    mode = (int)js_getnum(args[1]);
+  int recursive = 0;
+  if (nargs >= 2) {
+    switch (vtype(args[1])) {
+      case T_NUM:
+        mode = (int)js_getnum(args[1]);
+        break;
+      case T_OBJ: {
+        jsval_t opt = args[1];
+        recursive = js_get(js, opt, "recursive") == js_true;
+        jsval_t mode_val = js_get(js, opt, "mode");
+        if (vtype(mode_val) == T_NUM) mode = (int)js_getnum(mode_val);
+        break;
+      }
+    }
   }
-  
-  
+
   fs_request_t *req = calloc(1, sizeof(fs_request_t));
   if (!req) return js_mkerr(js, "Out of memory");
   
@@ -951,22 +983,28 @@ static jsval_t builtin_fs_mkdir(struct js *js, jsval_t *args, int nargs) {
   req->op_type = FS_OP_MKDIR;
   req->promise = js_mkpromise(js);
   req->path = strndup(path, path_len);
+  req->recursive = recursive;
   req->uv_req.data = req;
   
   utarray_push_back(pending_requests, &req);
   int result = uv_fs_mkdir(uv_default_loop(), &req->uv_req, req->path, mode, on_mkdir_complete);
   
   if (result < 0) {
-    req->failed = 1;
-    req->error_msg = strdup(uv_strerror(result));
-    req->completed = 1;
-    complete_request(req);
+    if (recursive && result == UV_EEXIST) {
+      req->completed = 1;
+      complete_request(req);
+    } else {
+      req->failed = 1;
+      req->error_msg = strdup(uv_strerror(result));
+      req->completed = 1;
+      complete_request(req);
+    }
   }
   
   return req->promise;
 }
 
-static jsval_t builtin_fs_rmdirSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_rmdirSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "rmdirSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdirSync() path must be a string");
@@ -994,7 +1032,7 @@ static jsval_t builtin_fs_rmdirSync(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_rmdir(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_rmdir(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "rmdir() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdir() path must be a string");
@@ -1026,7 +1064,7 @@ static jsval_t builtin_fs_rmdir(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t stat_isFile(struct js *js, jsval_t *args, int nargs) {
+static jsval_t stat_isFile(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this = js_getthis(js);
   jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
   
@@ -1036,7 +1074,7 @@ static jsval_t stat_isFile(struct js *js, jsval_t *args, int nargs) {
   return js_bool(S_ISREG(mode));
 }
 
-static jsval_t stat_isDirectory(struct js *js, jsval_t *args, int nargs) {
+static jsval_t stat_isDirectory(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this = js_getthis(js);
   jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
   
@@ -1046,7 +1084,7 @@ static jsval_t stat_isDirectory(struct js *js, jsval_t *args, int nargs) {
   return js_bool(S_ISDIR(mode));
 }
 
-static jsval_t stat_isSymbolicLink(struct js *js, jsval_t *args, int nargs) {
+static jsval_t stat_isSymbolicLink(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this = js_getthis(js);
   jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
   
@@ -1056,7 +1094,7 @@ static jsval_t stat_isSymbolicLink(struct js *js, jsval_t *args, int nargs) {
   return js_bool(S_ISLNK(mode));
 }
 
-static jsval_t create_stats_object(struct js *js, struct stat *st) {
+static jsval_t create_stats_object(ant_t *js, struct stat *st) {
   jsval_t stat_obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "Stats", 5);
   if (is_special_object(proto)) js_set_proto(js, stat_obj, proto);
@@ -1091,7 +1129,7 @@ static const char *errno_to_code(int err_num) {
   }
 }
 
-static jsval_t builtin_fs_statSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_statSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "statSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "statSync() path must be a string");
@@ -1116,7 +1154,7 @@ static jsval_t builtin_fs_statSync(struct js *js, jsval_t *args, int nargs) {
   return create_stats_object(js, &st);
 }
 
-static jsval_t builtin_fs_stat(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_stat(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "stat() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "stat() path must be a string");
@@ -1148,7 +1186,7 @@ static jsval_t builtin_fs_stat(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_existsSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_existsSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "existsSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "existsSync() path must be a string");
@@ -1167,7 +1205,7 @@ static jsval_t builtin_fs_existsSync(struct js *js, jsval_t *args, int nargs) {
   return js_bool(result == 0);
 }
 
-static jsval_t builtin_fs_exists(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_exists(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "exists() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "exists() path must be a string");
@@ -1199,7 +1237,7 @@ static jsval_t builtin_fs_exists(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_accessSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_accessSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "accessSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "accessSync() path must be a string");
@@ -1227,7 +1265,7 @@ static jsval_t builtin_fs_accessSync(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t builtin_fs_access(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_access(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "access() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "access() path must be a string");
@@ -1264,7 +1302,7 @@ static jsval_t builtin_fs_access(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_readdirSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readdirSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readdirSync() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdirSync() path must be a string");
@@ -1298,7 +1336,7 @@ static jsval_t builtin_fs_readdirSync(struct js *js, jsval_t *args, int nargs) {
   return arr;
 }
 
-static jsval_t builtin_fs_readdir(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readdir(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readdir() requires a path argument");
   
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdir() path must be a string");
@@ -1347,7 +1385,53 @@ static void on_write_fd_complete(uv_fs_t *uv_req) {
   free_fs_request(req);
 }
 
-static jsval_t builtin_fs_writeSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_readSync(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2) return js_mkerr(js, "readSync() requires fd and buffer arguments");
+  if (vtype(args[0]) != T_NUM) return js_mkerr(js, "readSync() fd must be a number");
+  
+  int fd = (int)js_getnum(args[0]);
+  
+  jsval_t ta_data_val = js_get_slot(js, args[1], SLOT_BUFFER);
+  TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
+  if (!ta_data || !ta_data->buffer || !ta_data->buffer->data)
+    return js_mkerr(js, "readSync() second argument must be a Buffer, TypedArray, or DataView");
+  
+  uint8_t *buf_data = ta_data->buffer->data + ta_data->byte_offset;
+  size_t buf_len = ta_data->byte_length;
+  size_t offset = 0;
+  size_t length = buf_len;
+  int64_t position = -1;
+  
+  if (nargs >= 3) {
+    if (vtype(args[2]) == T_OBJ) {
+      jsval_t off_val = js_get(js, args[2], "offset");
+      jsval_t len_val = js_get(js, args[2], "length");
+      jsval_t pos_val = js_get(js, args[2], "position");
+      if (vtype(off_val) == T_NUM) offset = (size_t)js_getnum(off_val);
+      if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val);
+      else length = buf_len - offset;
+      if (vtype(pos_val) == T_NUM) position = (int64_t)js_getnum(pos_val);
+    } else if (vtype(args[2]) == T_NUM) {
+      offset = (size_t)js_getnum(args[2]);
+      length = buf_len - offset;
+      if (nargs >= 4 && vtype(args[3]) == T_NUM) length = (size_t)js_getnum(args[3]);
+      if (nargs >= 5 && vtype(args[4]) == T_NUM) position = (int64_t)js_getnum(args[4]);
+    }
+  }
+  
+  if (offset > buf_len) return js_mkerr(js, "offset is out of bounds");
+  if (offset + length > buf_len) return js_mkerr(js, "length extends beyond buffer");
+  
+  uv_fs_t req;
+  uv_buf_t buf = uv_buf_init((char *)(buf_data + offset), (unsigned int)length);
+  int result = uv_fs_read(uv_default_loop(), &req, fd, &buf, 1, position, NULL);
+  uv_fs_req_cleanup(&req);
+  
+  if (result < 0) return js_mkerr(js, "readSync failed: %s", uv_strerror(result));
+  return js_mknum((double)result);
+}
+
+static jsval_t builtin_fs_writeSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writeSync() requires fd and data arguments");
   if (vtype(args[0]) != T_NUM) return js_mkerr(js, "writeSync() fd must be a number");
   
@@ -1411,7 +1495,7 @@ static jsval_t builtin_fs_writeSync(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)result);
 }
 
-static jsval_t builtin_fs_write_fd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_write_fd(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "write() requires fd and data arguments");
   if (vtype(args[0]) != T_NUM) return js_mkerr(js, "write() fd must be a number");
   
@@ -1496,7 +1580,7 @@ static jsval_t builtin_fs_write_fd(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static jsval_t builtin_fs_writevSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_writevSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writevSync() requires fd and buffers arguments");
   if (vtype(args[0]) != T_NUM) return js_mkerr(js, "writevSync() fd must be a number");
   
@@ -1531,7 +1615,7 @@ static jsval_t builtin_fs_writevSync(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)result);
 }
 
-static jsval_t builtin_fs_writev_fd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_writev_fd(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writev() requires fd and buffers arguments");
   if (vtype(args[0]) != T_NUM) return js_mkerr(js, "writev() fd must be a number");
   
@@ -1598,7 +1682,7 @@ static jsval_t builtin_fs_writev_fd(struct js *js, jsval_t *args, int nargs) {
   return req->promise;
 }
 
-static int parse_open_flags(struct js *js, jsval_t arg) {
+static int parse_open_flags(ant_t *js, jsval_t arg) {
   if (vtype(arg) == T_NUM) return (int)js_getnum(arg);
   if (vtype(arg) != T_STR) return O_RDONLY;
   
@@ -1620,7 +1704,7 @@ static int parse_open_flags(struct js *js, jsval_t arg) {
   return O_RDONLY;
 }
 
-static jsval_t builtin_fs_openSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_openSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "openSync() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "openSync() path must be a string");
   
@@ -1643,7 +1727,7 @@ static jsval_t builtin_fs_openSync(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)result);
 }
 
-static jsval_t builtin_fs_closeSync(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_closeSync(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "closeSync() requires a fd argument");
   if (vtype(args[0]) != T_NUM) return js_mkerr(js, "closeSync() fd must be a number");
   
@@ -1674,7 +1758,7 @@ static void on_open_fd_complete(uv_fs_t *uv_req) {
   free_fs_request(req);
 }
 
-static jsval_t builtin_fs_open_fd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_open_fd(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "open() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "open() path must be a string");
   
@@ -1724,7 +1808,7 @@ static void on_close_fd_complete(uv_fs_t *uv_req) {
   free_fs_request(req);
 }
 
-static jsval_t builtin_fs_close_fd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_fs_close_fd(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "close() requires a fd argument");
   if (vtype(args[0]) != T_NUM) return js_mkerr(js, "close() fd must be a number");
   
@@ -1764,7 +1848,7 @@ void init_fs_module(void) {
   js_set(js, stats_proto, "isFile", js_mkfun(stat_isFile));
   js_set(js, stats_proto, "isDirectory", js_mkfun(stat_isDirectory));
   js_set(js, stats_proto, "isSymbolicLink", js_mkfun(stat_isSymbolicLink));
-  js_set(js, stats_proto, get_toStringTag_sym_key(), js_mkstr(js, "Stats", 5));
+  js_set_sym(js, stats_proto, get_toStringTag_sym(), js_mkstr(js, "Stats", 5));
   
   js_mkprop_fast(js, stats_ctor, "prototype", 9, stats_proto);
   js_mkprop_fast(js, stats_ctor, "name", 4, js_mkstr(js, "Stats", 5));
@@ -1773,41 +1857,23 @@ void init_fs_module(void) {
   js_set(js, glob, "Stats", js_obj_to_func(stats_ctor));
 }
 
-jsval_t fs_library(struct js *js) {
-  jsval_t lib = js_mkobj(js);
-  
+static void fs_set_promise_methods(ant_t *js, jsval_t lib) {
   js_set(js, lib, "readFile", js_mkfun(builtin_fs_readFile));
-  js_set(js, lib, "readFileSync", js_mkfun(builtin_fs_readFileSync));
-  js_set(js, lib, "stream", js_mkfun(builtin_fs_readBytes));
   js_set(js, lib, "open", js_mkfun(builtin_fs_open_fd));
-  js_set(js, lib, "openSync", js_mkfun(builtin_fs_openSync));
   js_set(js, lib, "close", js_mkfun(builtin_fs_close_fd));
-  js_set(js, lib, "closeSync", js_mkfun(builtin_fs_closeSync));
   js_set(js, lib, "writeFile", js_mkfun(builtin_fs_writeFile));
-  js_set(js, lib, "writeFileSync", js_mkfun(builtin_fs_writeFileSync));
   js_set(js, lib, "write", js_mkfun(builtin_fs_write_fd));
-  js_set(js, lib, "writeSync", js_mkfun(builtin_fs_writeSync));
   js_set(js, lib, "writev", js_mkfun(builtin_fs_writev_fd));
-  js_set(js, lib, "writevSync", js_mkfun(builtin_fs_writevSync));
-  js_set(js, lib, "appendFileSync", js_mkfun(builtin_fs_appendFileSync));
-  js_set(js, lib, "copyFileSync", js_mkfun(builtin_fs_copyFileSync));
-  js_set(js, lib, "renameSync", js_mkfun(builtin_fs_renameSync));
   js_set(js, lib, "unlink", js_mkfun(builtin_fs_unlink));
-  js_set(js, lib, "unlinkSync", js_mkfun(builtin_fs_unlinkSync));
   js_set(js, lib, "mkdir", js_mkfun(builtin_fs_mkdir));
-  js_set(js, lib, "mkdirSync", js_mkfun(builtin_fs_mkdirSync));
   js_set(js, lib, "rmdir", js_mkfun(builtin_fs_rmdir));
-  js_set(js, lib, "rmdirSync", js_mkfun(builtin_fs_rmdirSync));
   js_set(js, lib, "stat", js_mkfun(builtin_fs_stat));
-  js_set(js, lib, "statSync", js_mkfun(builtin_fs_statSync));
   js_set(js, lib, "exists", js_mkfun(builtin_fs_exists));
-  js_set(js, lib, "existsSync", js_mkfun(builtin_fs_existsSync));
   js_set(js, lib, "access", js_mkfun(builtin_fs_access));
-  js_set(js, lib, "accessSync", js_mkfun(builtin_fs_accessSync));
   js_set(js, lib, "readdir", js_mkfun(builtin_fs_readdir));
-  js_set(js, lib, "readdirSync", js_mkfun(builtin_fs_readdirSync));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "fs", 2));
-  
+}
+
+static jsval_t fs_make_constants(ant_t *js) {
   jsval_t constants = js_mkobj(js);
   js_set(js, constants, "F_OK", js_mknum(F_OK));
   js_set(js, constants, "R_OK", js_mknum(R_OK));
@@ -1820,8 +1886,62 @@ jsval_t fs_library(struct js *js) {
   js_set(js, constants, "O_EXCL", js_mknum(O_EXCL));
   js_set(js, constants, "O_TRUNC", js_mknum(O_TRUNC));
   js_set(js, constants, "O_APPEND", js_mknum(O_APPEND));
-  js_set(js, lib, "constants", constants);
+  return constants;
+}
+
+static jsval_t builtin_fs_promises_getter(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t getter_fn = js_getcurrentfunc(js);
+  jsval_t cached = js_get_slot(js, getter_fn, SLOT_DATA);
+  if (is_object_type(cached)) return cached;
+
+  jsval_t promises = fs_promises_library(js);
+  js_set_slot(js, getter_fn, SLOT_DATA, promises);
+  return promises;
+}
+
+jsval_t fs_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+  fs_set_promise_methods(js, lib);
+
+  js_set(js, lib, "readFileSync", js_mkfun(builtin_fs_readFileSync));
+  js_set(js, lib, "readSync", js_mkfun(builtin_fs_readSync));
+  js_set(js, lib, "stream", js_mkfun(builtin_fs_readBytes));
+  js_set(js, lib, "openSync", js_mkfun(builtin_fs_openSync));
+  js_set(js, lib, "closeSync", js_mkfun(builtin_fs_closeSync));
+  js_set(js, lib, "writeFileSync", js_mkfun(builtin_fs_writeFileSync));
+  js_set(js, lib, "writeSync", js_mkfun(builtin_fs_writeSync));
+  js_set(js, lib, "writevSync", js_mkfun(builtin_fs_writevSync));
+  js_set(js, lib, "appendFileSync", js_mkfun(builtin_fs_appendFileSync));
+  js_set(js, lib, "copyFileSync", js_mkfun(builtin_fs_copyFileSync));
+  js_set(js, lib, "renameSync", js_mkfun(builtin_fs_renameSync));
+  js_set(js, lib, "unlinkSync", js_mkfun(builtin_fs_unlinkSync));
+  js_set(js, lib, "mkdirSync", js_mkfun(builtin_fs_mkdirSync));
+  js_set(js, lib, "rmdirSync", js_mkfun(builtin_fs_rmdirSync));
+  js_set(js, lib, "statSync", js_mkfun(builtin_fs_statSync));
+  js_set(js, lib, "existsSync", js_mkfun(builtin_fs_existsSync));
+  js_set(js, lib, "accessSync", js_mkfun(builtin_fs_accessSync));
+  js_set(js, lib, "readdirSync", js_mkfun(builtin_fs_readdirSync));
+  
+  js_set_getter_desc(
+    js, lib,
+    "promises", 8,
+    js_heavy_mkfun(js, builtin_fs_promises_getter, js_mkundef()),
+    JS_DESC_E | JS_DESC_C
+  );
+  
+  js_set(js, lib, "constants", fs_make_constants(js));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "fs", 2));
+  
+  return lib;
+}
+
+jsval_t fs_promises_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+
+  fs_set_promise_methods(js, lib);
+  js_set(js, lib, "constants", fs_make_constants(js));
 
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "fs/promises", 11));
   return lib;
 }
 
diff --git a/src/modules/io.c b/src/modules/io.c
index d6dc54a..2f26991 100644
--- a/src/modules/io.c
+++ b/src/modules/io.c
@@ -12,6 +12,7 @@
 #include "errors.h"
 #include "internal.h"
 #include "runtime.h"
+#include "silver/engine.h"
 #include "modules/io.h"
 #include "modules/symbol.h"
 
@@ -28,6 +29,10 @@ bool io_no_color = false;
 #define JSON_REF    "\x1b[90m"
 #define JSON_WHITE  "\x1b[97m"
 
+static inline bool io_is_digit_ascii(char c) { 
+  return c >= '0' && c <= '9'; 
+}
+
 static void io_print(const char *str, FILE *stream) {
   if (!io_no_color) {
     fputs(str, stream);
@@ -98,6 +103,44 @@ static const uint8_t char_class_table[256] = {
   ['Y'] = CC_ALPHA, ['Z'] = CC_ALPHA,
 };
 
+static int io_iso_utc_token_len(const char *p) {
+  int i = 0;
+
+  if (*p == '+' || *p == '-') {
+    i++;
+    for (int d = 0; d < 6; d++, i++) if (!io_is_digit_ascii(p[i])) return 0;
+  } else for (int d = 0; d < 4; d++, i++) if (!io_is_digit_ascii(p[i])) return 0;
+
+  if (p[i++] != '-') return 0;
+  if (!io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++])) return 0;
+  if (p[i++] != '-') return 0;
+  if (!io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++])) return 0;
+  if (p[i++] != 'T') return 0;
+  if (!io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++])) return 0;
+  if (p[i++] != ':') return 0;
+  if (!io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++])) return 0;
+  if (p[i++] != ':') return 0;
+  if (!io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++])) return 0;
+  if (p[i++] != '.') return 0;
+  if (!io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++]) || !io_is_digit_ascii(p[i++])) return 0;
+  if (p[i++] != 'Z') return 0;
+
+  char boundary = p[i];
+  if (
+    !(boundary == '\0'
+    || boundary == ' '
+    || boundary == '\t'
+    || boundary == '\n'
+    || boundary == ','
+    || boundary == ']'
+    || boundary == '}'
+    || boundary == ')'
+    || boundary == '>')
+  ) return 0;
+
+  return i;
+}
+
 #define KEYWORD(kw, color) \
   if (memcmp(p, kw, sizeof(kw) - 1) == 0 && !isalnum((unsigned char)p[sizeof(kw) - 1]) && p[sizeof(kw) - 1] != '_') { \
     fputs(color, stream); fputs(kw, stream); fputs(C_RESET, stream); \
@@ -191,6 +234,15 @@ separator:
   goto next;
 
 number:
+  {
+    int iso_len = io_iso_utc_token_len(p);
+    if (iso_len > 0) {
+      fputs(C_MAGENTA, stream);
+      for (int k = 0; k < iso_len; k++) fputc(*p++, stream);
+      fputs(C_RESET, stream);
+      goto next;
+    }
+  }
   fputs(JSON_NUMBER, stream);
   while ((*p >= '0' && *p <= '9') || *p == '.' || *p == 'e' || *p == 'E' || *p == '+' || *p == '-')
     fputc(*p++, stream);
@@ -198,6 +250,19 @@ number:
   goto next;
 
 minus:
+  {
+    int iso_len = io_iso_utc_token_len(p);
+    if (iso_len > 0) {
+      fputs(C_MAGENTA, stream);
+      for (int k = 0; k < iso_len; k++) fputc(*p++, stream);
+      fputs(C_RESET, stream);
+      goto next;
+    }
+  }
+  if (memcmp(p + 1, "Infinity", 8) == 0 && !isalnum((unsigned char)p[9]) && p[9] != '_') {
+    fputs(JSON_NUMBER, stream); fputs("-Infinity", stream); fputs(C_RESET, stream);
+    p += 9; goto next;
+  }
   if (p[1] >= '0' && p[1] <= '9') {
     fputs(JSON_NUMBER, stream); fputc(*p++, stream);
     while ((*p >= '0' && *p <= '9') || *p == '.' || *p == 'e' || *p == 'E' || *p == '+' || *p == '-')
@@ -252,13 +317,22 @@ ident:
   fputc(*p++, stream); goto next;
 
 other:
+  if (*p == '+') {
+    int iso_len = io_iso_utc_token_len(p);
+    if (iso_len > 0) {
+      fputs(C_MAGENTA, stream);
+      for (int k = 0; k < iso_len; k++) fputc(*p++, stream);
+      fputs(C_RESET, stream);
+      goto next;
+    }
+  }
   fputc(*p++, stream); goto next;
 }
 
 #undef KEYWORD
 #undef EMIT_UNTIL
 
-void print_repl_value(struct js *js, jsval_t val, FILE *stream) {
+void print_repl_value(ant_t *js, jsval_t val, FILE *stream) {
   if (vtype(val) == T_STR) {
     char *str = js_getstr(js, val, NULL);
     fprintf(stream, "%s'%s'%s\n", C(JSON_STRING), str ? str : "", C(C_RESET));
@@ -276,14 +350,20 @@ void print_repl_value(struct js *js, jsval_t val, FILE *stream) {
   if (cstr.needs_free) free((void *)cstr.ptr);
 }
 
-jsval_t console_print(struct js *js, jsval_t *args, int nargs, const char *color, FILE *stream) {
+jsval_t console_print(ant_t *js, jsval_t *args, int nargs, const char *color, FILE *stream) {
   if (color && !io_no_color) fputs(color, stream);
   
   for (int i = 0; i < nargs; i++) {
     if (i) fputc(' ', stream);
+
+    if (vtype(args[i]) == T_OBJ) {
+      const char *stack = get_str_prop(js, args[i], "stack", 5, NULL);
+      if (stack) { io_print(stack, stream); continue; }
+    }
+
     char cbuf[512];
     js_cstr_t cstr = js_to_cstr(js, args[i], cbuf, sizeof(cbuf));
-    
+
     if (vtype(args[i]) == T_STR) io_print(cstr.ptr, stream); else {
       if (color && !io_no_color) fputs(C_RESET, stream);
       print_value_colored(cstr.ptr, stream);
@@ -299,19 +379,19 @@ jsval_t console_print(struct js *js, jsval_t *args, int nargs, const char *color
   return js_mkundef();
 }
 
-static jsval_t js_console_log(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_log(ant_t *js, jsval_t *args, int nargs) {
   return console_print(js, args, nargs, NULL, stdout);
 }
 
-static jsval_t js_console_error(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_error(ant_t *js, jsval_t *args, int nargs) {
   return console_print(js, args, nargs, C_RED, stderr);
 }
 
-static jsval_t js_console_warn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_warn(ant_t *js, jsval_t *args, int nargs) {
   return console_print(js, args, nargs, C_YELLOW, stderr);
 }
 
-static jsval_t js_console_assert(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_assert(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   bool is_truthy = js_truthy(js, args[0]);
@@ -328,26 +408,26 @@ static jsval_t js_console_assert(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t js_console_trace(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_trace(ant_t *js, jsval_t *args, int nargs) {
   fputs("Trace", stderr);
   if (nargs > 0) {
     fputs(": ", stderr);
     console_print(js, args, nargs, NULL, stderr);
   } else fputc('\n', stderr);
   
-  js_print_stack_trace(stderr);
+  js_print_stack_trace_vm(js, stderr);
   return js_mkundef();
 }
 
-static jsval_t js_console_info(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_info(ant_t *js, jsval_t *args, int nargs) {
   return console_print(js, args, nargs, C_CYAN, stdout);
 }
 
-static jsval_t js_console_debug(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_debug(ant_t *js, jsval_t *args, int nargs) {
   return console_print(js, args, nargs, C_MAGENTA, stdout);
 }
 
-static jsval_t js_console_clear(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_clear(ant_t *js, jsval_t *args, int nargs) {
   if (!io_no_color) {
     fprintf(stdout, "\033[2J\033[H");
     fflush(stdout);
@@ -358,7 +438,7 @@ static jsval_t js_console_clear(struct js *js, jsval_t *args, int nargs) {
 static struct { char *label; double start_time; } console_timers[64];
 static int console_timer_count = 0;
 
-static jsval_t js_console_time(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_time(ant_t *js, jsval_t *args, int nargs) {
   const char *label = "default";
   if (nargs > 0 && vtype(args[0]) == T_STR) {
     label = js_getstr(js, args[0], NULL);
@@ -380,7 +460,7 @@ static jsval_t js_console_time(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t js_console_timeEnd(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_timeEnd(ant_t *js, jsval_t *args, int nargs) {
   const char *label = "default";
   if (nargs > 0 && vtype(args[0]) == T_STR) {
     label = js_getstr(js, args[0], NULL);
@@ -409,13 +489,11 @@ static const char *get_slot_name(internal_slot_t slot) {
     [SLOT_PID] = "PID",
     [SLOT_ASYNC] = "ASYNC",
     [SLOT_WITH] = "WITH",
-    [SLOT_SCOPE] = "SCOPE",
     [SLOT_THIS] = "THIS",
     [SLOT_NEW_TARGET] = "NEW_TARGET",
     [SLOT_BOUND_THIS] = "BOUND_THIS",
     [SLOT_BOUND_ARGS] = "BOUND_ARGS",
     [SLOT_FIELD_COUNT] = "FIELD_COUNT",
-    [SLOT_SOURCE] = "SOURCE",
     [SLOT_FIELDS] = "FIELDS",
     [SLOT_STRICT] = "STRICT",
     [SLOT_CODE] = "CODE",
@@ -449,8 +527,6 @@ static const char *get_slot_name(internal_slot_t slot) {
     [SLOT_SUBSCRIPTION_CLEANUP] = "SUBSCRIPTION_CLEANUP",
     [SLOT_HOISTED_VARS] = "HOISTED_VARS",
     [SLOT_HOISTED_VARS_LEN] = "HOISTED_VARS_LEN",
-    [SLOT_STRICT_EVAL_SCOPE] = "STRICT_EVAL_SCOPE",
-    [SLOT_MODULE_SCOPE] = "MODULE_SCOPE",
     [SLOT_STRICT_ARGS] = "STRICT_ARGS",
     [SLOT_NO_FUNC_DECLS] = "NO_FUNC_DECLS",
     [SLOT_ITER_STATE] = "ITER_STATE",
@@ -474,14 +550,12 @@ static const char *get_type_name(int type) {
     [T_NUM]        = "number",
     [T_BOOL]       = "boolean",
     [T_FUNC]       = "function",
-    [T_CODEREF]    = "coderef",
     [T_CFUNC]      = "function",
     [T_ERR]        = "error",
     [T_ARR]        = "array",
     [T_PROMISE]    = "Promise",
     [T_TYPEDARRAY] = "TypedArray",
     [T_BIGINT]     = "bigint",
-    [T_PROPREF]    = "propref",
     [T_SYMBOL]     = "symbol",
     [T_GENERATOR]  = "Generator",
     [T_FFI]        = "ffi"
@@ -533,7 +607,7 @@ void inspect_value(ant_t *js, jsval_t val, FILE *stream, int depth, inspect_visi
   }
   
   if (t == T_OBJ || t == T_FUNC || t == T_PROMISE || t == T_ARR) {
-    if (depth > 10) fprintf(stream, "<%s @%" PRIu64 " ...>", get_type_name(t), (uint64_t)vdata(val));
+    if (depth > 10) fprintf(stream, "<%s @%" PRIu64 " ...>", get_type_name(t), (uint64_t)vdata(js_as_obj(val)));
     else inspect_object(js, val, stream, depth, visited);
     return;
   }
@@ -548,6 +622,7 @@ void inspect_value(ant_t *js, jsval_t val, FILE *stream, int depth, inspect_visi
 
 void inspect_object(ant_t *js, jsval_t obj, FILE *stream, int depth, inspect_visited_t *visited) {
   int type = vtype(obj);
+  obj = js_as_obj(obj);
   jsoff_t obj_off = (jsoff_t)vdata(obj);
   
   if (inspect_was_visited(visited, obj_off)) {
@@ -582,10 +657,10 @@ void inspect_object(ant_t *js, jsval_t obj, FILE *stream, int depth, inspect_vis
         fprintf(stream, "%.0f", js_getnum(slot_val));
         break;
       default:
-        if ((t == T_OBJ || t == T_FUNC || t == T_PROMISE) && inspect_was_visited(visited, (jsoff_t)vdata(slot_val)))
-          fprintf(stream, "[Circular *%llu]", (u64)vdata(slot_val));
+        if ((t == T_OBJ || t == T_FUNC || t == T_PROMISE) && inspect_was_visited(visited, (jsoff_t)vdata(js_as_obj(slot_val))))
+          fprintf(stream, "[Circular *%llu]", (u64)vdata(js_as_obj(slot_val)));
         else if (t == T_OBJ || t == T_FUNC || t == T_PROMISE)
-          fprintf(stream, "<%s @%llu>", get_type_name(t), (u64)vdata(slot_val));
+          fprintf(stream, "<%s @%llu>", get_type_name(t), (u64)vdata(js_as_obj(slot_val)));
         else
           inspect_value(js, slot_val, stream, inner_depth + 1, visited);
         break;
@@ -632,7 +707,7 @@ void inspect_object(ant_t *js, jsval_t obj, FILE *stream, int depth, inspect_vis
   fprintf(stream, "}");
 }
 
-static jsval_t js_console_inspect(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_console_inspect(ant_t *js, jsval_t *args, int nargs) {
   FILE *stream = stdout;
   inspect_visited_t visited = {0};
   
@@ -648,7 +723,7 @@ static jsval_t js_console_inspect(struct js *js, jsval_t *args, int nargs) {
 }
 
 void init_console_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t console_obj = js_mkobj(js);
   
   js_set(js, console_obj, "log", js_mkfun(js_console_log));
@@ -663,6 +738,6 @@ void init_console_module() {
   js_set(js, console_obj, "clear", js_mkfun(js_console_clear));
   js_set(js, console_obj, "inspect", js_mkfun(js_console_inspect));
   
-  js_set(js, console_obj, get_toStringTag_sym_key(), js_mkstr(js, "console", 7));
+  js_set_sym(js, console_obj, get_toStringTag_sym(), js_mkstr(js, "console", 7));
   js_set(js, js_glob(js), "console", console_obj);
 }
diff --git a/src/modules/json.c b/src/modules/json.c
index 5e404f3..40cc500 100644
--- a/src/modules/json.c
+++ b/src/modules/json.c
@@ -8,6 +8,7 @@
 #include "errors.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/engine.h"
 
 #include "modules/json.h"
 #include "modules/symbol.h"
@@ -19,7 +20,7 @@ typedef struct {
   UT_hash_handle hh;
 } json_key_entry_t;
 
-static jsval_t yyjson_to_jsval(struct js *js, yyjson_val *val) {
+static jsval_t yyjson_to_jsval(ant_t *js, yyjson_val *val) {
   if (!val) return js_mkundef();
   
   switch (yyjson_get_type(val)) {
@@ -80,7 +81,7 @@ typedef struct {
   int stack_size;
   int stack_cap;
   int has_cycle;
-  struct js *js;
+  ant_t *js;
   jsval_t replacer_func;
   jsval_t replacer_arr;
   int replacer_arr_len;
@@ -107,13 +108,13 @@ static inline void json_cycle_pop(json_cycle_ctx *ctx) {
 
 typedef struct { char *key; size_t key_len; jsval_t value; } prop_entry;
 
-static int should_skip_prop(struct js *js, const char *key, size_t key_len, jsval_t value) {
+static int should_skip_prop(ant_t *js, const char *key, size_t key_len, jsval_t value) {
   if (is_internal_prop(key, (jsoff_t)key_len)) return 1;
   if (!is_special_object(value)) return 0;
   return vtype(js_get_slot(js, value, SLOT_CODE)) == T_CFUNC;
 }
 
-static prop_entry *collect_props(struct js *js, jsval_t val, int *out_count) {
+static prop_entry *collect_props(ant_t *js, jsval_t val, int *out_count) {
   prop_entry *props = NULL;
   int count = 0, cap = 0;
   const char *key;
@@ -151,7 +152,7 @@ static inline int key_matches(const char *a, size_t a_len, const char *b, size_t
   return a_len == b_len && memcmp(a, b, a_len) == 0;
 }
 
-static int is_key_in_replacer_arr(struct js *js, json_cycle_ctx *ctx, const char *key, size_t key_len) {
+static int is_key_in_replacer_arr(ant_t *js, json_cycle_ctx *ctx, const char *key, size_t key_len) {
   if (!is_special_object(ctx->replacer_arr)) return 1;
   
   for (int i = 0; i < ctx->replacer_arr_len; i++) {
@@ -173,16 +174,16 @@ static int is_key_in_replacer_arr(struct js *js, json_cycle_ctx *ctx, const char
   return 0;
 }
 
-static yyjson_mut_val *jsval_to_yyjson_with_key(struct js *js, yyjson_mut_doc *doc, const char *key, jsval_t val, json_cycle_ctx *ctx, int in_array);
+static yyjson_mut_val *jsval_to_yyjson_with_key(ant_t *js, yyjson_mut_doc *doc, const char *key, jsval_t val, json_cycle_ctx *ctx, int in_array);
 
-static yyjson_mut_val *jsval_to_yyjson_impl(struct js *js, yyjson_mut_doc *doc, jsval_t val, json_cycle_ctx *ctx, int in_array) {
+static yyjson_mut_val *jsval_to_yyjson_impl(ant_t *js, yyjson_mut_doc *doc, jsval_t val, json_cycle_ctx *ctx, int in_array) {
   int type = vtype(val);
   yyjson_mut_val *result = NULL;
   
   if (is_special_object(val)) {
     jsval_t toJSON = js_get(js, val, "toJSON");
     if (vtype(toJSON) == T_FUNC) {
-      jsval_t r = js_call(js, toJSON, &val, 1);
+      jsval_t r = sv_vm_call(js->vm, js, toJSON, js_mkundef(), &val, 1, NULL, false);
       if (vtype(r) == T_ERR) { ctx->has_cycle = 1; return NULL; }
       return jsval_to_yyjson_impl(js, doc, r, ctx, in_array);
     }
@@ -276,13 +277,13 @@ done:
   return result;
 }
 
-static yyjson_mut_val *jsval_to_yyjson_with_key(struct js *js, yyjson_mut_doc *doc, const char *key, jsval_t val, json_cycle_ctx *ctx, int in_array) {
+static yyjson_mut_val *jsval_to_yyjson_with_key(ant_t *js, yyjson_mut_doc *doc, const char *key, jsval_t val, json_cycle_ctx *ctx, int in_array) {
   if (vtype(ctx->replacer_func) != T_FUNC)
     return jsval_to_yyjson_impl(js, doc, val, ctx, in_array);
   
   jsval_t key_str = js_mkstr(js, key, strlen(key));
   jsval_t call_args[2] = { key_str, val };
-  jsval_t transformed = js_call(js, ctx->replacer_func, call_args, 2);
+  jsval_t transformed = sv_vm_call(js->vm, js, ctx->replacer_func, js_mkundef(), call_args, 2, NULL, false);
   
   if (vtype(transformed) == T_ERR) {
     ctx->has_cycle = 1;
@@ -292,11 +293,11 @@ static yyjson_mut_val *jsval_to_yyjson_with_key(struct js *js, yyjson_mut_doc *d
   return jsval_to_yyjson_impl(js, doc, transformed, ctx, in_array);
 }
 
-static yyjson_mut_val *jsval_to_yyjson(struct js *js, yyjson_mut_doc *doc, jsval_t val, json_cycle_ctx *ctx) {
+static yyjson_mut_val *jsval_to_yyjson(ant_t *js, yyjson_mut_doc *doc, jsval_t val, json_cycle_ctx *ctx) {
   return jsval_to_yyjson_with_key(js, doc, "", val, ctx, 0);
 }
 
-static jsval_t apply_reviver(struct js *js, jsval_t holder, const char *key, jsval_t reviver) {
+static jsval_t apply_reviver(ant_t *js, jsval_t holder, const char *key, jsval_t reviver) {
   jsval_t val = js_get(js, holder, key);
   
   if (is_special_object(val)) {
@@ -343,10 +344,10 @@ static jsval_t apply_reviver(struct js *js, jsval_t holder, const char *key, jsv
   jsval_t key_str = js_mkstr(js, key, strlen(key));
   jsval_t call_args[2] = { key_str, js_get(js, holder, key) };
   
-  return js_call_with_this(js, reviver, holder, call_args, 2);
+  return sv_vm_call(js->vm, js, reviver, holder, call_args, 2, NULL, false);
 }
 
-jsval_t js_json_parse(struct js *js, jsval_t *args, int nargs) {
+jsval_t js_json_parse(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "JSON.parse() requires at least 1 argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "JSON.parse() argument must be a string");
   
@@ -383,7 +384,7 @@ static yyjson_write_flag get_write_flags(jsval_t *args, int nargs) {
   return YYJSON_WRITE_PRETTY;
 }
 
-jsval_t js_json_stringify(struct js *js, jsval_t *args, int nargs) {
+jsval_t js_json_stringify(ant_t *js, jsval_t *args, int nargs) {
   jsval_t result;
   yyjson_mut_doc *doc = NULL;
   json_cycle_ctx ctx = {0};
@@ -448,12 +449,12 @@ cleanup:
 }
 
 void init_json_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t json_obj = js_mkobj(js);
   
   js_set(js, json_obj, "parse", js_mkfun(js_json_parse));
   js_set(js, json_obj, "stringify", js_mkfun(js_json_stringify));
   
-  js_set(js, json_obj, get_toStringTag_sym_key(), js_mkstr(js, "JSON", 4));
+  js_set_sym(js, json_obj, get_toStringTag_sym(), js_mkstr(js, "JSON", 4));
   js_set(js, js_glob(js), "JSON", json_obj);
 }
diff --git a/src/modules/lmdb.c b/src/modules/lmdb.c
index 272b201..a453661 100644
--- a/src/modules/lmdb.c
+++ b/src/modules/lmdb.c
@@ -7,6 +7,7 @@
 #include "modules/lmdb.h"
 #include "modules/buffer.h"
 #include "modules/symbol.h"
+#include "descriptors.h"
 
 #include <lmdb.h>
 #include <stdbool.h>
@@ -68,9 +69,9 @@ static lmdb_env_ref_t *env_refs = NULL;
 static lmdb_db_ref_t *db_refs = NULL;
 static lmdb_txn_ref_t *txn_refs = NULL;
 
-static jsval_t make_env_obj(struct js *js, lmdb_env_handle_t *env);
-static jsval_t make_db_obj(struct js *js, lmdb_db_handle_t *db);
-static jsval_t make_txn_obj(struct js *js, lmdb_txn_handle_t *txn);
+static jsval_t make_env_obj(ant_t *js, lmdb_env_handle_t *env);
+static jsval_t make_db_obj(ant_t *js, lmdb_db_handle_t *db);
+static jsval_t make_txn_obj(ant_t *js, lmdb_txn_handle_t *txn);
 
 static void list_remove_db(lmdb_env_handle_t *env, lmdb_db_handle_t *target) {
   if (!env || !target) return;
@@ -240,35 +241,35 @@ static void env_handle_close(lmdb_env_handle_t *env) {
   unregister_txn_refs_by_env(env);
 }
 
-static lmdb_env_handle_t *get_env_handle(struct js *js, jsval_t obj, bool open_required) {
+static lmdb_env_handle_t *get_env_handle(ant_t *js, jsval_t obj, bool open_required) {
   lmdb_env_handle_t *env = find_env_by_obj(obj);
   if (!env) return NULL;
   if (open_required && env->closed) return NULL;
   return env;
 }
 
-static lmdb_db_handle_t *get_db_handle(struct js *js, jsval_t obj, bool open_required) {
+static lmdb_db_handle_t *get_db_handle(ant_t *js, jsval_t obj, bool open_required) {
   lmdb_db_handle_t *db = find_db_by_obj(obj);
   if (!db) return NULL;
   if (open_required && (db->closed || !db->env || db->env->closed)) return NULL;
   return db;
 }
 
-static lmdb_txn_handle_t *get_txn_handle(struct js *js, jsval_t obj, bool open_required) {
+static lmdb_txn_handle_t *get_txn_handle(ant_t *js, jsval_t obj, bool open_required) {
   lmdb_txn_handle_t *txn = find_txn_by_obj(obj);
   if (!txn) return NULL;
   if (open_required && (txn->closed || !txn->txn)) return NULL;
   return txn;
 }
 
-static bool option_bool(struct js *js, jsval_t options, const char *key, bool fallback) {
+static bool option_bool(ant_t *js, jsval_t options, const char *key, bool fallback) {
   if (vtype(options) != T_OBJ) return fallback;
   jsval_t val = js_get(js, options, key);
   if (vtype(val) == T_UNDEF) return fallback;
   return js_truthy(js, val);
 }
 
-static unsigned int option_uint(struct js *js, jsval_t options, const char *key, unsigned int fallback) {
+static unsigned int option_uint(ant_t *js, jsval_t options, const char *key, unsigned int fallback) {
   if (vtype(options) != T_OBJ) return fallback;
   jsval_t val = js_get(js, options, key);
   if (vtype(val) != T_NUM) return fallback;
@@ -277,7 +278,7 @@ static unsigned int option_uint(struct js *js, jsval_t options, const char *key,
   return (unsigned int)n;
 }
 
-static size_t option_size(struct js *js, jsval_t options, const char *key, size_t fallback) {
+static size_t option_size(ant_t *js, jsval_t options, const char *key, size_t fallback) {
   if (vtype(options) != T_OBJ) return fallback;
   jsval_t val = js_get(js, options, key);
   if (vtype(val) != T_NUM) return fallback;
@@ -286,7 +287,7 @@ static size_t option_size(struct js *js, jsval_t options, const char *key, size_
   return (size_t)n;
 }
 
-static bool js_to_mdb_val(struct js *js, jsval_t input, MDB_val *out) {
+static bool js_to_mdb_val(ant_t *js, jsval_t input, MDB_val *out) {
   if (vtype(input) == T_STR) {
     size_t len = 0;
     const char *str = js_getstr(js, input, &len);
@@ -319,7 +320,7 @@ static bool js_to_mdb_val(struct js *js, jsval_t input, MDB_val *out) {
   return false;
 }
 
-static jsval_t mdb_val_to_js(struct js *js, MDB_val *val, bool as_string) {
+static jsval_t mdb_val_to_js(ant_t *js, MDB_val *val, bool as_string) {
   if (as_string) {
     return js_mkstr(js, val->mv_data, val->mv_size);
   }
@@ -336,7 +337,7 @@ static jsval_t mdb_val_to_js(struct js *js, MDB_val *val, bool as_string) {
   return out;
 }
 
-static bool parse_get_encoding(struct js *js, jsval_t encoding, bool *as_string) {
+static bool parse_get_encoding(ant_t *js, jsval_t encoding, bool *as_string) {
   if (vtype(encoding) == T_UNDEF) return true;
   if (vtype(encoding) != T_STR) return false;
 
@@ -356,7 +357,7 @@ static bool parse_get_encoding(struct js *js, jsval_t encoding, bool *as_string)
   return false;
 }
 
-static jsval_t lmdb_open(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_open(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "lmdb.open(path, options?) requires a string path");
   }
@@ -443,7 +444,7 @@ static jsval_t lmdb_open(struct js *js, jsval_t *args, int nargs) {
   return make_env_obj(js, handle);
 }
 
-static jsval_t lmdb_env_open_db(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_open_db(ant_t *js, jsval_t *args, int nargs) {
   lmdb_env_handle_t *env = get_env_handle(js, js_getthis(js), true);
   if (!env) return js_mkerr(js, "Invalid or closed LMDB env");
 
@@ -513,7 +514,7 @@ static jsval_t lmdb_env_open_db(struct js *js, jsval_t *args, int nargs) {
   return make_db_obj(js, db);
 }
 
-static jsval_t lmdb_env_begin_txn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_begin_txn(ant_t *js, jsval_t *args, int nargs) {
   lmdb_env_handle_t *env = get_env_handle(js, js_getthis(js), true);
   if (!env) return js_mkerr(js, "Invalid or closed LMDB env");
 
@@ -547,7 +548,7 @@ static jsval_t lmdb_env_begin_txn(struct js *js, jsval_t *args, int nargs) {
   return make_txn_obj(js, handle);
 }
 
-static jsval_t lmdb_env_close_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_close_method(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   jsval_t self = js_getthis(js);
@@ -559,7 +560,7 @@ static jsval_t lmdb_env_close_method(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_env_sync_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_sync_method(ant_t *js, jsval_t *args, int nargs) {
   lmdb_env_handle_t *env = get_env_handle(js, js_getthis(js), true);
   if (!env) return js_mkerr(js, "Invalid or closed LMDB env");
 
@@ -571,7 +572,7 @@ static jsval_t lmdb_env_sync_method(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_env_stat_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_stat_method(ant_t *js, jsval_t *args, int nargs) {
   lmdb_env_handle_t *env = get_env_handle(js, js_getthis(js), true);
   if (!env) return js_mkerr(js, "Invalid or closed LMDB env");
 
@@ -595,7 +596,7 @@ static jsval_t lmdb_env_stat_method(struct js *js, jsval_t *args, int nargs) {
   return out;
 }
 
-static jsval_t lmdb_env_info_method(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_info_method(ant_t *js, jsval_t *args, int nargs) {
   lmdb_env_handle_t *env = get_env_handle(js, js_getthis(js), true);
   if (!env) return js_mkerr(js, "Invalid or closed LMDB env");
 
@@ -613,7 +614,7 @@ static jsval_t lmdb_env_info_method(struct js *js, jsval_t *args, int nargs) {
   return out;
 }
 
-static jsval_t lmdb_txn_get_impl(struct js *js, jsval_t *args, int nargs, bool as_string) {
+static jsval_t lmdb_txn_get_impl(ant_t *js, jsval_t *args, int nargs, bool as_string) {
   if (nargs < 2) return js_mkerr(js, "txn.getBytes/getString(db, key) requires db and key");
 
   lmdb_txn_handle_t *txn = get_txn_handle(js, js_getthis(js), true);
@@ -636,7 +637,7 @@ static jsval_t lmdb_txn_get_impl(struct js *js, jsval_t *args, int nargs, bool a
   return mdb_val_to_js(js, &value, as_string);
 }
 
-static jsval_t lmdb_txn_get(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_get(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "txn.get(db, key, encoding?) requires db and key");
   bool as_string = false;
   if (nargs > 2 && !parse_get_encoding(js, args[2], &as_string)) {
@@ -645,15 +646,15 @@ static jsval_t lmdb_txn_get(struct js *js, jsval_t *args, int nargs) {
   return lmdb_txn_get_impl(js, args, nargs, as_string);
 }
 
-static jsval_t lmdb_txn_get_bytes(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_get_bytes(ant_t *js, jsval_t *args, int nargs) {
   return lmdb_txn_get_impl(js, args, nargs, false);
 }
 
-static jsval_t lmdb_txn_get_string(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_get_string(ant_t *js, jsval_t *args, int nargs) {
   return lmdb_txn_get_impl(js, args, nargs, true);
 }
 
-static jsval_t lmdb_txn_put(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_put(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) return js_mkerr(js, "txn.put(db, key, value, options?) requires db, key, and value");
 
   lmdb_txn_handle_t *txn = get_txn_handle(js, js_getthis(js), true);
@@ -682,7 +683,7 @@ static jsval_t lmdb_txn_put(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t lmdb_txn_del(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_del(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "txn.del(db, key, value?) requires db and key");
 
   lmdb_txn_handle_t *txn = get_txn_handle(js, js_getthis(js), true);
@@ -709,7 +710,7 @@ static jsval_t lmdb_txn_del(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t lmdb_txn_commit(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_commit(ant_t *js, jsval_t *args, int nargs) {
   jsval_t self = js_getthis(js);
   lmdb_txn_handle_t *txn = get_txn_handle(js, self, true);
   if (!txn) return js_mkerr(js, "Invalid or closed LMDB transaction");
@@ -726,7 +727,7 @@ static jsval_t lmdb_txn_commit(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_txn_abort(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_abort(ant_t *js, jsval_t *args, int nargs) {
   jsval_t self = js_getthis(js);
   lmdb_txn_handle_t *txn = get_txn_handle(js, self, false);
   if (!txn) return js_mkerr(js, "Invalid LMDB transaction");
@@ -743,7 +744,7 @@ static jsval_t lmdb_txn_abort(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_db_get_impl(struct js *js, jsval_t *args, int nargs, bool as_string) {
+static jsval_t lmdb_db_get_impl(ant_t *js, jsval_t *args, int nargs, bool as_string) {
   if (nargs < 1) return js_mkerr(js, "db.getBytes/getString(key) requires key");
   lmdb_db_handle_t *db = get_db_handle(js, js_getthis(js), true);
   if (!db) return js_mkerr(js, "Invalid or closed LMDB database handle");
@@ -774,7 +775,7 @@ static jsval_t lmdb_db_get_impl(struct js *js, jsval_t *args, int nargs, bool as
   return out;
 }
 
-static jsval_t lmdb_db_get(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_get(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "db.get(key, encoding?) requires key");
   bool as_string = false;
   if (nargs > 1 && !parse_get_encoding(js, args[1], &as_string)) {
@@ -783,15 +784,15 @@ static jsval_t lmdb_db_get(struct js *js, jsval_t *args, int nargs) {
   return lmdb_db_get_impl(js, args, nargs, as_string);
 }
 
-static jsval_t lmdb_db_get_bytes(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_get_bytes(ant_t *js, jsval_t *args, int nargs) {
   return lmdb_db_get_impl(js, args, nargs, false);
 }
 
-static jsval_t lmdb_db_get_string(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_get_string(ant_t *js, jsval_t *args, int nargs) {
   return lmdb_db_get_impl(js, args, nargs, true);
 }
 
-static jsval_t lmdb_db_put(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_put(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "db.put(key, value, options?) requires key and value");
   lmdb_db_handle_t *db = get_db_handle(js, js_getthis(js), true);
   if (!db) return js_mkerr(js, "Invalid or closed LMDB database handle");
@@ -830,7 +831,7 @@ static jsval_t lmdb_db_put(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t lmdb_db_del(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_del(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "db.del(key, value?) requires key");
   lmdb_db_handle_t *db = get_db_handle(js, js_getthis(js), true);
   if (!db) return js_mkerr(js, "Invalid or closed LMDB database handle");
@@ -871,7 +872,7 @@ static jsval_t lmdb_db_del(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t lmdb_db_clear(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_clear(ant_t *js, jsval_t *args, int nargs) {
   lmdb_db_handle_t *db = get_db_handle(js, js_getthis(js), true);
   if (!db) return js_mkerr(js, "Invalid or closed LMDB database handle");
   if (db->env->read_only) return js_mkerr(js, "Cannot clear on read-only LMDB env");
@@ -891,7 +892,7 @@ static jsval_t lmdb_db_clear(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_db_drop(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_drop(ant_t *js, jsval_t *args, int nargs) {
   jsval_t self = js_getthis(js);
   lmdb_db_handle_t *db = get_db_handle(js, self, true);
   if (!db) return js_mkerr(js, "Invalid or closed LMDB database handle");
@@ -925,7 +926,7 @@ static jsval_t lmdb_db_drop(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_db_close(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_close(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   jsval_t self = js_getthis(js);
@@ -946,7 +947,7 @@ static jsval_t lmdb_db_close(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lmdb_strerror_fn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_strerror_fn(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "lmdb.strerror(code) requires a numeric code");
   }
@@ -955,19 +956,19 @@ static jsval_t lmdb_strerror_fn(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, err, strlen(err));
 }
 
-static jsval_t lmdb_env_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_env_constructor(ant_t *js, jsval_t *args, int nargs) {
   return js_mkerr(js, "LMDBEnv cannot be constructed directly; use lmdb.open()");
 }
 
-static jsval_t lmdb_db_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_db_constructor(ant_t *js, jsval_t *args, int nargs) {
   return js_mkerr(js, "LMDBDatabase cannot be constructed directly; use env.openDB()");
 }
 
-static jsval_t lmdb_txn_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lmdb_txn_constructor(ant_t *js, jsval_t *args, int nargs) {
   return js_mkerr(js, "LMDBTxn cannot be constructed directly; use env.beginTxn()");
 }
 
-static void ensure_lmdb_prototypes(struct js *js) {
+static void ensure_lmdb_prototypes(ant_t *js) {
   if (lmdb_types.ready) return;
   jsval_t object_proto = js->object;
 
@@ -981,7 +982,7 @@ static void ensure_lmdb_prototypes(struct js *js) {
   js_set(js, env_proto, "sync", js_mkfun(lmdb_env_sync_method));
   js_set(js, env_proto, "stat", js_mkfun(lmdb_env_stat_method));
   js_set(js, env_proto, "info", js_mkfun(lmdb_env_info_method));
-  js_set(js, env_proto, get_toStringTag_sym_key(), js_mkstr(js, "LMDBEnv", 7));
+  js_set_sym(js, env_proto, get_toStringTag_sym(), js_mkstr(js, "LMDBEnv", 7));
   js_set_slot(js, env_ctor_obj, SLOT_CFUNC, js_mkfun(lmdb_env_constructor));
   js_mkprop_fast(js, env_ctor_obj, "prototype", 9, env_proto);
   js_mkprop_fast(js, env_ctor_obj, "name", 4, ANT_STRING("LMDBEnv"));
@@ -999,7 +1000,7 @@ static void ensure_lmdb_prototypes(struct js *js) {
   js_set(js, db_proto, "clear", js_mkfun(lmdb_db_clear));
   js_set(js, db_proto, "drop", js_mkfun(lmdb_db_drop));
   js_set(js, db_proto, "close", js_mkfun(lmdb_db_close));
-  js_set(js, db_proto, get_toStringTag_sym_key(), js_mkstr(js, "LMDBDatabase", 12));
+  js_set_sym(js, db_proto, get_toStringTag_sym(), js_mkstr(js, "LMDBDatabase", 12));
   js_set_slot(js, db_ctor_obj, SLOT_CFUNC, js_mkfun(lmdb_db_constructor));
   js_mkprop_fast(js, db_ctor_obj, "prototype", 9, db_proto);
   js_mkprop_fast(js, db_ctor_obj, "name", 4, ANT_STRING("LMDBDatabase"));
@@ -1016,7 +1017,7 @@ static void ensure_lmdb_prototypes(struct js *js) {
   js_set(js, txn_proto, "del", js_mkfun(lmdb_txn_del));
   js_set(js, txn_proto, "commit", js_mkfun(lmdb_txn_commit));
   js_set(js, txn_proto, "abort", js_mkfun(lmdb_txn_abort));
-  js_set(js, txn_proto, get_toStringTag_sym_key(), js_mkstr(js, "LMDBTxn", 7));
+  js_set_sym(js, txn_proto, get_toStringTag_sym(), js_mkstr(js, "LMDBTxn", 7));
   js_set_slot(js, txn_ctor_obj, SLOT_CFUNC, js_mkfun(lmdb_txn_constructor));
   js_mkprop_fast(js, txn_ctor_obj, "prototype", 9, txn_proto);
   js_mkprop_fast(js, txn_ctor_obj, "name", 4, ANT_STRING("LMDBTxn"));
@@ -1031,7 +1032,7 @@ static void ensure_lmdb_prototypes(struct js *js) {
   lmdb_types.ready = true;
 }
 
-static jsval_t make_env_obj(struct js *js, lmdb_env_handle_t *env) {
+static jsval_t make_env_obj(ant_t *js, lmdb_env_handle_t *env) {
   ensure_lmdb_prototypes(js);
   jsval_t obj = js_mkobj(js);
   js_set_slot(js, obj, SLOT_DATA, ANT_PTR(env));
@@ -1040,7 +1041,7 @@ static jsval_t make_env_obj(struct js *js, lmdb_env_handle_t *env) {
   return obj;
 }
 
-static jsval_t make_db_obj(struct js *js, lmdb_db_handle_t *db) {
+static jsval_t make_db_obj(ant_t *js, lmdb_db_handle_t *db) {
   ensure_lmdb_prototypes(js);
   jsval_t obj = js_mkobj(js);
   js_set_slot(js, obj, SLOT_DATA, ANT_PTR(db));
@@ -1049,7 +1050,7 @@ static jsval_t make_db_obj(struct js *js, lmdb_db_handle_t *db) {
   return obj;
 }
 
-static jsval_t make_txn_obj(struct js *js, lmdb_txn_handle_t *txn) {
+static jsval_t make_txn_obj(ant_t *js, lmdb_txn_handle_t *txn) {
   ensure_lmdb_prototypes(js);
   jsval_t obj = js_mkobj(js);
   js_set_slot(js, obj, SLOT_DATA, ANT_PTR(txn));
@@ -1058,7 +1059,7 @@ static jsval_t make_txn_obj(struct js *js, lmdb_txn_handle_t *txn) {
   return obj;
 }
 
-jsval_t lmdb_library(struct js *js) {
+jsval_t lmdb_library(ant_t *js) {
   ensure_lmdb_prototypes(js);
   jsval_t lib = js_mkobj(js);
   js_set(js, lib, "open", js_mkfun(lmdb_open));
@@ -1091,7 +1092,7 @@ jsval_t lmdb_library(struct js *js) {
   js_set(js, constants, "NOMEMINIT", js_mknum((double)MDB_NOMEMINIT));
   js_set(js, lib, "constants", constants);
 
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "lmdb", 4));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "lmdb", 4));
   return lib;
 }
 
diff --git a/src/modules/localstorage.c b/src/modules/localstorage.c
index 0676b9e..ad75e12 100644
--- a/src/modules/localstorage.c
+++ b/src/modules/localstorage.c
@@ -9,6 +9,7 @@
 #include "arena.h"
 #include "runtime.h"
 #include "internal.h"
+#include "descriptors.h"
 
 #include "modules/symbol.h"
 #include "modules/localstorage.h"
@@ -157,7 +158,7 @@ static char *storage_key(size_t index) {
   }
 
 // localStorage.setItem(key, value)
-static jsval_t js_localstorage_setItem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_setItem(ant_t *js, jsval_t *args, int nargs) {
   CHECK_FILE_SET(js);
   
   if (nargs < 2) {
@@ -174,7 +175,7 @@ static jsval_t js_localstorage_setItem(struct js *js, jsval_t *args, int nargs)
 }
 
 // localStorage.getItem(key)
-static jsval_t js_localstorage_getItem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_getItem(ant_t *js, jsval_t *args, int nargs) {
   CHECK_FILE_SET(js);
   
   if (nargs < 1) {
@@ -191,7 +192,7 @@ static jsval_t js_localstorage_getItem(struct js *js, jsval_t *args, int nargs)
 }
 
 // localStorage.removeItem(key)
-static jsval_t js_localstorage_removeItem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_removeItem(ant_t *js, jsval_t *args, int nargs) {
   CHECK_FILE_SET(js);
   
   if (nargs < 1) {
@@ -206,7 +207,7 @@ static jsval_t js_localstorage_removeItem(struct js *js, jsval_t *args, int narg
 }
 
 // localStorage.clear()
-static jsval_t js_localstorage_clear(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_clear(ant_t *js, jsval_t *args, int nargs) {
   CHECK_FILE_SET(js);
   (void)args; (void)nargs;
   storage_clear();
@@ -215,7 +216,7 @@ static jsval_t js_localstorage_clear(struct js *js, jsval_t *args, int nargs) {
 }
 
 // localStorage.key(index)
-static jsval_t js_localstorage_key(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_key(ant_t *js, jsval_t *args, int nargs) {
   CHECK_FILE_SET(js);
   
   if (nargs < 1) {
@@ -238,14 +239,14 @@ static jsval_t js_localstorage_key(struct js *js, jsval_t *args, int nargs) {
 }
 
 // localStorage.length
-static jsval_t js_localstorage_length(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_length(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   CHECK_FILE_SET(js)
   return js_mknum((double)storage_length());
 }
 
 // localStorage.setFile(path)
-static jsval_t js_localstorage_setFile(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_localstorage_setFile(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Failed to execute 'setFile' on 'Storage': 1 argument required");
   }
@@ -272,7 +273,7 @@ static jsval_t js_localstorage_setFile(struct js *js, jsval_t *args, int nargs)
 }
 
 void init_localstorage_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   
   jsval_t glob = js_glob(js);
   const char *file_path = rt->ls_fp;
@@ -294,6 +295,6 @@ void init_localstorage_module() {
   jsval_t length_getter = js_mkfun(js_localstorage_length);
   js_set_getter_desc(js, storage_obj, "length", 6, length_getter, JS_DESC_E);
   
-  js_set(js, storage_obj, get_toStringTag_sym_key(), js_mkstr(js, "Storage", 7));
+  js_set_sym(js, storage_obj, get_toStringTag_sym(), js_mkstr(js, "Storage", 7));
   js_set(js, glob, "localStorage", storage_obj);
 }
diff --git a/src/modules/module.c b/src/modules/module.c
new file mode 100644
index 0000000..57520e7
--- /dev/null
+++ b/src/modules/module.c
@@ -0,0 +1,159 @@
+#include <compat.h> // IWYU pragma: keep
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libgen.h>
+
+#include "ant.h"
+#include "errors.h"
+#include "internal.h"
+#include "esm/loader.h"
+#include "esm/library.h"
+#include "modules/symbol.h"
+
+typedef struct { ant_t *js; jsval_t arr; } builtin_iter_ctx_t;
+
+static void push_builtin_name(const char *name, void *ud) {
+  builtin_iter_ctx_t *ctx = (builtin_iter_ctx_t *)ud;
+  js_arr_push(ctx->js, ctx->arr, js_mkstr(ctx->js, name, strlen(name)));
+}
+
+static jsval_t builtin_createRequire_call(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR)
+    return js_mkerr(js, "require() expects a string specifier");
+
+  jsval_t fn = js_getcurrentfunc(js);
+  jsval_t data = js_get_slot(js, fn, SLOT_DATA);
+  const char *prev_filename = js->filename;
+
+  if (vtype(data) == T_STR) {
+    jsoff_t plen = 0;
+    jsoff_t poff = vstr(js, data, &plen);
+    js_set_filename(js, (const char *)&js->mem[poff]);
+  }
+
+  jsval_t ns = js_esm_import_sync(js, args[0]);
+  js_set_filename(js, prev_filename);
+  if (is_err(ns)) return ns;
+
+  if (vtype(ns) == T_OBJ) {
+    jsval_t default_export = js_get_slot(js, ns, SLOT_DEFAULT);
+    if (vtype(default_export) != T_UNDEF) return default_export;
+  }
+  return ns;
+}
+
+// require.resolve(specifier)
+static jsval_t builtin_createRequire_resolve(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR)
+    return js_mkerr(js, "require.resolve() expects a string specifier");
+
+  jsval_t fn = js_getcurrentfunc(js);
+  jsval_t data = js_get_slot(js, fn, SLOT_DATA);
+  const char *base_path = js->filename ? js->filename : ".";
+
+  if (vtype(data) == T_STR) {
+    jsoff_t dlen = 0;
+    jsoff_t doff = vstr(js, data, &dlen);
+    base_path = (const char *)&js->mem[doff];
+  }
+
+  jsval_t resolved = js_esm_resolve_specifier(js, args[0], base_path);
+  if (is_err(resolved)) return resolved;
+  if (vtype(resolved) != T_STR) return resolved;
+
+  jsoff_t len = 0;
+  jsoff_t off = vstr(js, resolved, &len);
+  
+  const char *s = (const char *)&js->mem[off];
+  static const char *prefix = "file://";
+
+  if ((size_t)len >= strlen(prefix) && strncmp(s, prefix, strlen(prefix)) == 0) {
+    const char *path_part = s + strlen(prefix);
+    size_t plen = (size_t)len - strlen(prefix);
+    return js_mkstr(js, path_part, plen);
+  }
+
+  return resolved;
+}
+
+// createRequire(filename)
+static jsval_t builtin_createRequire(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr(js, "createRequire() requires a filename argument");
+
+  jsval_t filename_val = args[0];
+  if (vtype(filename_val) != T_STR)
+    return js_mkerr(js, "createRequire() filename must be a string");
+
+  size_t fname_len;
+  char *fname = js_getstr(js, filename_val, &fname_len);
+  if (!fname) return js_mkerr(js, "createRequire() invalid filename");
+
+  const char *path = fname;
+  size_t path_len = fname_len;
+  
+  static const char *file_prefix = "file://";
+  size_t prefix_len = strlen(file_prefix);
+
+  if (path_len >= prefix_len && strncmp(path, file_prefix, prefix_len) == 0) {
+    path += prefix_len;
+    path_len -= prefix_len;
+  }
+
+  jsval_t path_val = js_mkstr(js, path, path_len);
+  jsval_t require_fn = js_heavy_mkfun(js, builtin_createRequire_call, path_val);
+  jsval_t resolve_fn = js_heavy_mkfun(js, builtin_createRequire_resolve, path_val);
+  js_set(js, require_fn, "resolve", resolve_fn);
+
+  return require_fn;
+}
+
+// Module._resolveFilename(request, parent)
+static jsval_t builtin_resolveFilename(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR) 
+    return js_mkerr(js, "Module._resolveFilename() requires a string request");
+
+  const char *base_path = js->filename ? js->filename : ".";
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
+    jsval_t parent_filename = js_get(js, args[1], "filename");
+    if (vtype(parent_filename) == T_STR) {
+      jsoff_t plen = 0;
+      jsoff_t poff = vstr(js, parent_filename, &plen);
+      base_path = (const char *)&js->mem[poff];
+    }
+  }
+
+  jsval_t resolved = js_esm_resolve_specifier(js, args[0], base_path);
+  if (is_err(resolved)) return resolved;
+  if (vtype(resolved) != T_STR) return resolved;
+
+  jsoff_t len = 0;
+  jsoff_t off = vstr(js, resolved, &len);
+  
+  const char *s = (const char *)&js->mem[off];
+  static const char *prefix = "file://";
+
+  if ((size_t)len >= strlen(prefix) && strncmp(s, prefix, strlen(prefix)) == 0) {
+    const char *path_part = s + strlen(prefix);
+    size_t plen = (size_t)len - strlen(prefix);
+    return js_mkstr(js, path_part, plen);
+  }
+
+  return resolved;
+}
+
+jsval_t module_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+  js_set(js, lib, "createRequire", js_mkfun(builtin_createRequire));
+
+  jsval_t modules_arr = js_mkarr(js);
+  builtin_iter_ctx_t ctx = { js, modules_arr };
+  ant_library_foreach(push_builtin_name, &ctx);
+  
+  js_set(js, lib, "builtinModules", modules_arr);
+  js_set(js, lib, "_resolveFilename", js_mkfun(builtin_resolveFilename));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "Module", 6));
+
+  return lib;
+}
diff --git a/src/modules/napi.c b/src/modules/napi.c
new file mode 100644
index 0000000..9ccd356
--- /dev/null
+++ b/src/modules/napi.c
@@ -0,0 +1,2656 @@
+#include <compat.h> // IWYU pragma: keep
+
+#ifdef _WIN32
+#include <windows.h>
+#define NAPI_DLOPEN(name, flags) ((void*)LoadLibraryA(name))
+#define NAPI_DLSYM(handle, name) ((void*)GetProcAddress((HMODULE)(handle), (name)))
+#define NAPI_DLERROR() "LoadLibrary failed"
+#define NAPI_RTLD_NOW 0
+#define NAPI_RTLD_LOCAL 0
+#define NAPI_RTLD_GLOBAL 0
+#else
+#include <dlfcn.h>
+#define NAPI_DLOPEN(name, flags) dlopen((name), (flags))
+#define NAPI_DLSYM(handle, name) dlsym((handle), (name))
+#define NAPI_DLERROR() dlerror()
+#define NAPI_RTLD_NOW RTLD_NOW
+#define NAPI_RTLD_LOCAL RTLD_LOCAL
+#define NAPI_RTLD_GLOBAL RTLD_GLOBAL
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uthash.h>
+#include <uv.h>
+
+#include "ant.h"
+#include "descriptors.h"
+#include "errors.h"
+#include "internal.h"
+#include "silver/engine.h"
+
+#include "modules/buffer.h"
+#include "modules/napi.h"
+
+typedef struct napi_cleanup_hook_entry {
+  napi_cleanup_hook hook;
+  void *arg;
+  struct napi_cleanup_hook_entry *next;
+} napi_cleanup_hook_entry_t;
+
+typedef struct ant_napi_env__ {
+  ant_t *js;
+  napi_extended_error_info last_error;
+  char last_error_msg[256];
+  bool has_pending_exception;
+  napi_value pending_exception;
+  uint32_t version;
+  napi_cleanup_hook_entry_t *cleanup_hooks;
+} ant_napi_env_t;
+
+typedef struct napi_callback_binding {
+  ant_napi_env_t *env;
+  napi_callback cb;
+  void *data;
+} napi_callback_binding_t;
+
+struct napi_callback_info__ {
+  ant_napi_env_t *env;
+  const napi_value *argv;
+  size_t argc;
+  napi_value this_arg;
+  napi_value new_target;
+  void *data;
+};
+
+struct napi_ref__ {
+  ant_napi_env_t *env;
+  jshdl_t root;
+  napi_value value;
+  uint32_t refcount;
+};
+
+struct napi_deferred__ {
+  ant_napi_env_t *env;
+  jshdl_t promise_root;
+  bool settled;
+};
+
+struct napi_handle_scope__ {
+  ant_napi_env_t *env;
+};
+
+struct napi_escapable_handle_scope__ {
+  ant_napi_env_t *env;
+  bool escaped;
+};
+
+struct napi_async_context__ {
+  ant_napi_env_t *env;
+};
+
+struct napi_callback_scope__ {
+  ant_napi_env_t *env;
+};
+
+typedef struct napi_external_entry {
+  uint64_t id;
+  void *data;
+  node_api_basic_finalize finalize_cb;
+  void *finalize_hint;
+  UT_hash_handle hh;
+} napi_external_entry_t;
+
+typedef struct napi_wrap_entry {
+  uint64_t id;
+  void *native_object;
+  node_api_basic_finalize finalize_cb;
+  void *finalize_hint;
+  UT_hash_handle hh;
+} napi_wrap_entry_t;
+
+typedef struct napi_async_work_impl {
+  ant_napi_env_t *env;
+  napi_async_execute_callback execute;
+  napi_async_complete_callback complete;
+  void *data;
+  uv_work_t req;
+  bool queued;
+  bool delete_after_complete;
+} napi_async_work_impl_t;
+
+typedef struct napi_tsfn_item {
+  void *data;
+  struct napi_tsfn_item *next;
+} napi_tsfn_item_t;
+
+struct napi_threadsafe_function__ {
+  ant_napi_env_t *env;
+  jshdl_t func_root;
+  napi_threadsafe_function_call_js call_js_cb;
+  node_api_basic_finalize thread_finalize_cb;
+  void *thread_finalize_data;
+  void *context;
+  size_t max_queue_size;
+  size_t queue_size;
+  size_t thread_count;
+  bool closing;
+  bool aborted;
+  uv_async_t async;
+  uv_mutex_t mutex;
+  napi_tsfn_item_t *head;
+  napi_tsfn_item_t *tail;
+};
+
+typedef napi_value(NAPI_CDECL* napi_register_module_v1_fn)(napi_env env, napi_value exports);
+
+typedef struct napi_native_lib {
+  void *handle;
+  struct napi_native_lib *next;
+} napi_native_lib_t;
+
+static ant_napi_env_t *g_napi_env = NULL;
+static napi_external_entry_t *g_napi_externals = NULL;
+static napi_wrap_entry_t *g_napi_wraps = NULL;
+static uint64_t g_napi_external_next_id = 1;
+static uint64_t g_napi_wrap_next_id = 1;
+static napi_native_lib_t *g_napi_native_libs = NULL;
+static napi_module *g_pending_napi_module = NULL;
+static const napi_node_version g_napi_node_version = {
+  .major = 25,
+  .minor = 0,
+  .patch = 0,
+  .release = "ant",
+};
+static int64_t g_napi_external_memory = 0;
+
+static const char *napi_status_text(napi_status status) {
+  switch (status) {
+    case napi_ok: return "ok";
+    case napi_invalid_arg: return "invalid argument";
+    case napi_object_expected: return "object expected";
+    case napi_string_expected: return "string expected";
+    case napi_name_expected: return "name expected";
+    case napi_function_expected: return "function expected";
+    case napi_number_expected: return "number expected";
+    case napi_boolean_expected: return "boolean expected";
+    case napi_array_expected: return "array expected";
+    case napi_generic_failure: return "generic failure";
+    case napi_pending_exception: return "pending exception";
+    case napi_cancelled: return "cancelled";
+    case napi_escape_called_twice: return "escape called twice";
+    case napi_handle_scope_mismatch: return "handle scope mismatch";
+    case napi_callback_scope_mismatch: return "callback scope mismatch";
+    case napi_queue_full: return "queue full";
+    case napi_closing: return "closing";
+    case napi_bigint_expected: return "bigint expected";
+    case napi_date_expected: return "date expected";
+    case napi_arraybuffer_expected: return "arraybuffer expected";
+    case napi_detachable_arraybuffer_expected: return "detachable arraybuffer expected";
+    case napi_would_deadlock: return "would deadlock";
+    case napi_no_external_buffers_allowed: return "no external buffers allowed";
+    case napi_cannot_run_js: return "cannot run js";
+    default: return "unknown";
+  }
+}
+
+static napi_status napi_set_last(napi_env env, napi_status status, const char *message) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv) return status;
+
+  const char *msg = message ? message : napi_status_text(status);
+  snprintf(nenv->last_error_msg, sizeof(nenv->last_error_msg), "%s", msg);
+
+  nenv->last_error.error_message = nenv->last_error_msg;
+  nenv->last_error.engine_reserved = NULL;
+  nenv->last_error.engine_error_code = 0;
+  nenv->last_error.error_code = status;
+
+  return status;
+}
+
+static ant_napi_env_t *napi_get_or_create_env(ant_t *js) {
+  if (!g_napi_env) {
+    g_napi_env = (ant_napi_env_t *)calloc(1, sizeof(*g_napi_env));
+    if (!g_napi_env) return NULL;
+    g_napi_env->version = 8;
+    napi_set_last((napi_env)g_napi_env, napi_ok, NULL);
+  }
+  g_napi_env->js = js;
+  return g_napi_env;
+}
+
+napi_env ant_napi_get_env(ant_t *js) {
+  return (napi_env)napi_get_or_create_env(js);
+}
+
+static inline bool napi_is_callable(jsval_t v) {
+  uint8_t t = vtype(v);
+  return t == T_FUNC || t == T_CFUNC;
+}
+
+static void napi_mark_pending_exception(napi_env env, napi_value exception) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv) return;
+  nenv->has_pending_exception = true;
+  nenv->pending_exception = exception;
+  napi_set_last(env, napi_pending_exception, "pending exception");
+}
+
+static napi_status napi_check_pending_from_result(napi_env env, jsval_t result) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+
+  if (is_err(result) || nenv->js->thrown_exists) {
+    napi_mark_pending_exception(
+      env,
+      nenv->js->thrown_exists ? nenv->js->thrown_value : result
+    );
+    return napi_pending_exception;
+  }
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+static bool napi_slot_get_u64(ant_t *js, jsval_t obj, internal_slot_t slot, uint64_t *out) {
+  jsval_t value = js_get_slot(js, obj, slot);
+  if (vtype(value) != T_NUM) return false;
+  *out = (uint64_t)js_getnum(value);
+  return true;
+}
+
+static void napi_slot_set_u64(ant_t *js, jsval_t obj, internal_slot_t slot, uint64_t v) {
+  js_set_slot(js, obj, slot, js_mknum((double)v));
+}
+
+static napi_external_entry_t *napi_find_external(ant_t *js, napi_value value) {
+  if (!is_object_type((jsval_t)value)) return NULL;
+  uint64_t id = 0;
+  if (!napi_slot_get_u64(js, (jsval_t)value, SLOT_NAPI_EXTERNAL_ID, &id)) return NULL;
+  napi_external_entry_t *entry = NULL;
+  HASH_FIND(hh, g_napi_externals, &id, sizeof(id), entry);
+  return entry;
+}
+
+static napi_wrap_entry_t *napi_find_wrap(ant_t *js, napi_value value) {
+  if (!is_object_type((jsval_t)value)) return NULL;
+  uint64_t id = 0;
+  if (!napi_slot_get_u64(js, (jsval_t)value, SLOT_NAPI_WRAP_ID, &id)) return NULL;
+  napi_wrap_entry_t *entry = NULL;
+  HASH_FIND(hh, g_napi_wraps, &id, sizeof(id), entry);
+  return entry;
+}
+
+static bool napi_get_typedarray_data(
+  ant_t *js,
+  napi_value value,
+  TypedArrayData **out
+) {
+  jsval_t slot = js_get_slot(js, (jsval_t)value, SLOT_BUFFER);
+  if (vtype(slot) != T_TYPEDARRAY) return false;
+  TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot);
+  if (!ta || !ta->buffer || ta->buffer->is_detached) return false;
+  *out = ta;
+  return true;
+}
+
+static const char *napi_typed_array_name(TypedArrayType t) {
+  switch (t) {
+    case TYPED_ARRAY_INT8: return "Int8Array";
+    case TYPED_ARRAY_UINT8: return "Uint8Array";
+    case TYPED_ARRAY_UINT8_CLAMPED: return "Uint8ClampedArray";
+    case TYPED_ARRAY_INT16: return "Int16Array";
+    case TYPED_ARRAY_UINT16: return "Uint16Array";
+    case TYPED_ARRAY_INT32: return "Int32Array";
+    case TYPED_ARRAY_UINT32: return "Uint32Array";
+    case TYPED_ARRAY_FLOAT32: return "Float32Array";
+    case TYPED_ARRAY_FLOAT64: return "Float64Array";
+    case TYPED_ARRAY_BIGINT64: return "BigInt64Array";
+    case TYPED_ARRAY_BIGUINT64: return "BigUint64Array";
+    default: return "Uint8Array";
+  }
+}
+
+static bool napi_to_ant_typedarray_type(
+  napi_typedarray_type in,
+  TypedArrayType *out
+) {
+  switch (in) {
+    case napi_int8_array: *out = TYPED_ARRAY_INT8; return true;
+    case napi_uint8_array: *out = TYPED_ARRAY_UINT8; return true;
+    case napi_uint8_clamped_array: *out = TYPED_ARRAY_UINT8_CLAMPED; return true;
+    case napi_int16_array: *out = TYPED_ARRAY_INT16; return true;
+    case napi_uint16_array: *out = TYPED_ARRAY_UINT16; return true;
+    case napi_int32_array: *out = TYPED_ARRAY_INT32; return true;
+    case napi_uint32_array: *out = TYPED_ARRAY_UINT32; return true;
+    case napi_float32_array: *out = TYPED_ARRAY_FLOAT32; return true;
+    case napi_float64_array: *out = TYPED_ARRAY_FLOAT64; return true;
+    case napi_bigint64_array: *out = TYPED_ARRAY_BIGINT64; return true;
+    case napi_biguint64_array: *out = TYPED_ARRAY_BIGUINT64; return true;
+    default: return false;
+  }
+}
+
+static napi_typedarray_type napi_from_ant_typedarray_type(TypedArrayType in) {
+  switch (in) {
+    case TYPED_ARRAY_INT8: return napi_int8_array;
+    case TYPED_ARRAY_UINT8: return napi_uint8_array;
+    case TYPED_ARRAY_UINT8_CLAMPED: return napi_uint8_clamped_array;
+    case TYPED_ARRAY_INT16: return napi_int16_array;
+    case TYPED_ARRAY_UINT16: return napi_uint16_array;
+    case TYPED_ARRAY_INT32: return napi_int32_array;
+    case TYPED_ARRAY_UINT32: return napi_uint32_array;
+    case TYPED_ARRAY_FLOAT32: return napi_float32_array;
+    case TYPED_ARRAY_FLOAT64: return napi_float64_array;
+    case TYPED_ARRAY_BIGINT64: return napi_bigint64_array;
+    case TYPED_ARRAY_BIGUINT64: return napi_biguint64_array;
+    default: return napi_uint8_array;
+  }
+}
+
+static int napi_desc_flags(napi_property_attributes attributes) {
+  int flags = 0;
+  if (attributes & napi_writable) flags |= JS_DESC_W;
+  if (attributes & napi_enumerable) flags |= JS_DESC_E;
+  if (attributes & napi_configurable) flags |= JS_DESC_C;
+  return flags;
+}
+
+static jsval_t napi_callback_trampoline(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t current = js_getcurrentfunc(js);
+  jsval_t data_slot = js_get_slot(js, current, SLOT_DATA);
+  if (vtype(data_slot) != T_NUM) return js_mkundef();
+
+  napi_callback_binding_t *binding = (napi_callback_binding_t *)(uintptr_t)js_getnum(data_slot);
+  if (!binding || !binding->cb) return js_mkundef();
+
+  ant_napi_env_t *nenv = binding->env ? binding->env : napi_get_or_create_env(js);
+  if (!nenv) return js_mkerr(js, "napi OOM");
+
+  struct napi_callback_info__ info = {
+    .env = nenv,
+    .argv = (const napi_value *)args,
+    .argc = (size_t)(nargs < 0 ? 0 : nargs),
+    .this_arg = (napi_value)js_getthis(js),
+    .new_target = (napi_value)sv_vm_get_new_target(js->vm, js),
+    .data = binding->data,
+  };
+
+  napi_value ret = binding->cb((napi_env)nenv, (napi_callback_info)&info);
+  if (nenv->has_pending_exception) {
+    jsval_t ex = (jsval_t)nenv->pending_exception;
+    nenv->has_pending_exception = false;
+    nenv->pending_exception = (napi_value)js_mkundef();
+    return js_throw(js, ex);
+  }
+
+  if ((jsval_t)ret == 0) return js_mkundef();
+  return (jsval_t)ret;
+}
+
+static napi_status napi_create_function_common(
+  napi_env env,
+  const char *utf8name,
+  size_t length,
+  napi_callback cb,
+  void *data,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !cb || !result) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  napi_callback_binding_t *binding = (napi_callback_binding_t *)calloc(1, sizeof(*binding));
+  if (!binding) return napi_set_last(env, napi_generic_failure, "out of memory");
+
+  binding->env = nenv;
+  binding->cb = cb;
+  binding->data = data;
+
+  jsval_t fn = js_heavy_mkfun(nenv->js, napi_callback_trampoline, ANT_PTR(binding));
+  if (utf8name && utf8name[0]) {
+    size_t nlen = (length == NAPI_AUTO_LENGTH) ? strlen(utf8name) : length;
+    js_set(nenv->js, fn, "name", js_mkstr(nenv->js, utf8name, nlen));
+  }
+
+  *result = (napi_value)fn;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+static jsval_t napi_make_string(ant_t *js, const char *s, size_t len) {
+  if (!s) return js_mkstr(js, "", 0);
+  if (len == NAPI_AUTO_LENGTH) len = strlen(s);
+  return js_mkstr(js, s, len);
+}
+
+static napi_status napi_make_error_object(
+  napi_env env,
+  const char *name,
+  napi_value msg,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  ant_t *js = nenv->js;
+  jsval_t message = (jsval_t)msg;
+  if (vtype(message) != T_STR) {
+    message = coerce_to_str(js, message);
+    if (is_err(message)) return napi_check_pending_from_result(env, message);
+  }
+
+  jsval_t err = js_mkobj(js);
+  js_set(js, err, "name", js_mkstr(js, name, strlen(name)));
+  js_set(js, err, "message", message);
+
+  jsval_t proto = js_get_ctor_proto(js, name, strlen(name));
+  if (is_object_type(proto)) js_set_proto(js, err, proto);
+
+  *result = (napi_value)err;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+static napi_status napi_throw_with_message(
+  napi_env env,
+  js_err_type_t err_type,
+  const char *msg
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+
+  jsval_t error = js_mkerr_typed(nenv->js, err_type, "%s", msg ? msg : "");
+  if (is_err(error) && nenv->js->thrown_exists) {
+    napi_mark_pending_exception(env, (napi_value)nenv->js->thrown_value);
+    return napi_pending_exception;
+  }
+  return napi_set_last(env, napi_generic_failure, "failed to throw");
+}
+
+static void napi_tsfn_maybe_finish(struct napi_threadsafe_function__ *tsfn);
+
+static void napi_tsfn_async_cb(uv_async_t *handle) {
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)handle->data;
+  if (!tsfn || !tsfn->env || !tsfn->env->js) return;
+
+  ant_t *js = tsfn->env->js;
+  for (;;) {
+    napi_tsfn_item_t *item = NULL;
+
+    uv_mutex_lock(&tsfn->mutex);
+    if (tsfn->head) {
+      item = tsfn->head;
+      tsfn->head = item->next;
+      if (!tsfn->head) tsfn->tail = NULL;
+      tsfn->queue_size--;
+    }
+    bool done = tsfn->closing && tsfn->queue_size == 0;
+    uv_mutex_unlock(&tsfn->mutex);
+
+    if (!item) {
+      if (done) napi_tsfn_maybe_finish(tsfn);
+      break;
+    }
+
+    jsval_t cb = js_deref(js, tsfn->func_root);
+    if (tsfn->call_js_cb) {
+      tsfn->call_js_cb((napi_env)tsfn->env, (napi_value)cb, tsfn->context, item->data);
+    } else if (napi_is_callable(cb)) {
+      sv_vm_call(js->vm, js, cb, js_mkundef(), NULL, 0, NULL, false);
+    }
+
+    free(item);
+  }
+}
+
+static void napi_tsfn_close_cb(uv_handle_t *handle) {
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)handle->data;
+  if (!tsfn) return;
+
+  if (tsfn->thread_finalize_cb) {
+    tsfn->thread_finalize_cb((napi_env)tsfn->env, tsfn->thread_finalize_data, NULL);
+  }
+
+  if (tsfn->env && tsfn->env->js) {
+    js_root_update(tsfn->env->js, tsfn->func_root, js_mkundef());
+  }
+
+  uv_mutex_destroy(&tsfn->mutex);
+  free(tsfn);
+}
+
+static void napi_tsfn_maybe_finish(struct napi_threadsafe_function__ *tsfn) {
+  if (!tsfn) return;
+  uv_close((uv_handle_t *)&tsfn->async, napi_tsfn_close_cb);
+}
+
+static void napi_async_work_execute_cb(uv_work_t *req) {
+  napi_async_work_impl_t *work = (napi_async_work_impl_t *)req->data;
+  if (!work || !work->execute) return;
+  work->execute((napi_env)work->env, work->data);
+}
+
+static void napi_async_work_after_cb(uv_work_t *req, int status) {
+  napi_async_work_impl_t *work = (napi_async_work_impl_t *)req->data;
+  if (!work) return;
+
+  work->queued = false;
+  if (work->complete) {
+    napi_status st = (status == UV_ECANCELED) ? napi_cancelled : napi_ok;
+    work->complete((napi_env)work->env, st, work->data);
+  }
+
+  if (work->delete_after_complete) free(work);
+}
+
+static jsval_t napi_dlopen_common(ant_t *js, jsval_t module_obj, const char *filename) {
+  napi_env env = ant_napi_get_env(js);
+  if (!env) return js_mkerr(js, "napi env allocation failed");
+
+  if (!is_object_type(module_obj)) return js_mkerr(js, "process.dlopen module must be an object");
+  if (!filename || !filename[0]) return js_mkerr(js, "process.dlopen filename must be a non-empty string");
+
+  void *handle = NAPI_DLOPEN(filename, NAPI_RTLD_NOW | NAPI_RTLD_GLOBAL | NAPI_RTLD_LOCAL);
+  if (!handle) {
+    const char *msg = NAPI_DLERROR();
+    return js_mkerr(js, "Failed to load native module '%s': %s", filename, msg ? msg : "unknown");
+  }
+
+  g_pending_napi_module = NULL;
+  napi_register_module_v1_fn reg_fn = (napi_register_module_v1_fn)NAPI_DLSYM(handle, "napi_register_module_v1");
+
+  jsval_t exports = js_get(js, module_obj, "exports");
+  if (!is_object_type(exports)) {
+    exports = js_mkobj(js);
+    js_set(js, module_obj, "exports", exports);
+  }
+
+  jsval_t ret = js_mkundef();
+  if (reg_fn) {
+    ret = (jsval_t)reg_fn(env, (napi_value)exports);
+  } else if (g_pending_napi_module && g_pending_napi_module->nm_register_func) {
+    ret = (jsval_t)g_pending_napi_module->nm_register_func(env, (napi_value)exports);
+  } else {
+    return js_mkerr(js, "No N-API registration entrypoint found in '%s'", filename);
+  }
+
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (nenv->has_pending_exception || js->thrown_exists) {
+    jsval_t ex = nenv->has_pending_exception
+      ? (jsval_t)nenv->pending_exception
+      : js->thrown_value;
+    nenv->has_pending_exception = false;
+    nenv->pending_exception = (napi_value)js_mkundef();
+    return js_throw(js, ex);
+  }
+
+  if (is_object_type(ret)) exports = ret;
+  js_set(js, module_obj, "exports", exports);
+  js_set(js, module_obj, "loaded", js_true);
+
+  napi_native_lib_t *node = (napi_native_lib_t *)calloc(1, sizeof(*node));
+  if (node) {
+    node->handle = handle;
+    node->next = g_napi_native_libs;
+    g_napi_native_libs = node;
+  }
+
+  return exports;
+}
+
+jsval_t napi_process_dlopen_js(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2) return js_mkerr(js, "process.dlopen(module, filename) requires 2 arguments");
+  if (!is_object_type(args[0])) return js_mkerr(js, "process.dlopen module must be an object");
+  if (vtype(args[1]) != T_STR) return js_mkerr(js, "process.dlopen filename must be a string");
+
+  size_t path_len = 0;
+  const char *path = js_getstr(js, args[1], &path_len);
+  if (!path || path_len == 0) return js_mkerr(js, "process.dlopen filename must be non-empty");
+
+  jsval_t loaded = napi_dlopen_common(js, args[0], path);
+  if (is_err(loaded)) return loaded;
+  return js_mkundef();
+}
+
+jsval_t napi_load_native_module(ant_t *js, const char *module_path, jsval_t ns) {
+  if (!module_path) return js_mkerr(js, "native module path is null");
+
+  jsval_t module_obj = js_mkobj(js);
+  jsval_t exports_obj = js_mkobj(js);
+  js_set(js, module_obj, "exports", exports_obj);
+  js_set(js, module_obj, "filename", js_mkstr(js, module_path, strlen(module_path)));
+  js_set(js, module_obj, "id", js_mkstr(js, module_path, strlen(module_path)));
+  js_set(js, module_obj, "loaded", js_false);
+
+  jsval_t process_obj = js_get(js, js_glob(js), "process");
+  jsval_t dlopen_fn = is_object_type(process_obj) ? js_get(js, process_obj, "dlopen") : js_mkundef();
+
+  if (napi_is_callable(dlopen_fn)) {
+    jsval_t argv[2] = {module_obj, js_mkstr(js, module_path, strlen(module_path))};
+    jsval_t dl_res = sv_vm_call(js->vm, js, dlopen_fn, process_obj, argv, 2, NULL, false);
+    if (is_err(dl_res) || js->thrown_exists) return js_throw(js, js->thrown_value);
+  } else {
+    jsval_t load_res = napi_dlopen_common(js, module_obj, module_path);
+    if (is_err(load_res)) return load_res;
+  }
+
+  jsval_t exports_val = js_get(js, module_obj, "exports");
+  if (!is_object_type(ns)) return exports_val;
+
+  setprop_cstr(js, ns, "default", 7, exports_val);
+  js_set_slot(js, ns, SLOT_DEFAULT, exports_val);
+
+  if (!is_object_type(exports_val)) return exports_val;
+  ant_iter_t iter = js_prop_iter_begin(js, exports_val);
+  const char *key = NULL;
+  size_t key_len = 0;
+  jsval_t value = js_mkundef();
+
+  while (js_prop_iter_next(&iter, &key, &key_len, &value)) {
+    if (key_len == 7 && memcmp(key, "default", 7) == 0) continue;
+    setprop_cstr(js, ns, key, key_len, value);
+  }
+  js_prop_iter_end(&iter);
+
+  return exports_val;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info(
+  node_api_basic_env env,
+  const napi_extended_error_info **result
+) {
+  if (!env || !result) return napi_invalid_arg;
+  *result = &((ant_napi_env_t *)env)->last_error;
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mkundef();
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_null(napi_env env, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mknull();
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_global(napi_env env, napi_value *result) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_glob(nenv->js);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_boolean(napi_env env, bool value, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_bool(value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_object(napi_env env, napi_value *result) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mkobj(nenv->js);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_array(napi_env env, napi_value *result) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mkarr(nenv->js);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_array_with_length(
+  napi_env env,
+  size_t length,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  jsval_t arr = js_mkarr(nenv->js);
+  jsval_t r = js_setprop(
+    nenv->js, arr,
+    js_mkstr(nenv->js, "length", 6),
+    js_mknum((double)length)
+  );
+  if (is_err(r)) return napi_check_pending_from_result(env, r);
+  *result = (napi_value)arr;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_double(napi_env env, double value, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mknum(value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_int32(napi_env env, int32_t value, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mknum((double)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_uint32(napi_env env, uint32_t value, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mknum((double)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_int64(napi_env env, int64_t value, napi_value *result) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mknum((double)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_latin1(
+  napi_env env,
+  const char *str,
+  size_t length,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !str) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)napi_make_string(nenv->js, str, length);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf8(
+  napi_env env,
+  const char *str,
+  size_t length,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !str) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)napi_make_string(nenv->js, str, length);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(
+  napi_env env,
+  napi_value description,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  const char *desc = NULL;
+  if (vtype((jsval_t)description) == T_STR) {
+    desc = js_getstr(nenv->js, (jsval_t)description, NULL);
+  } else if (!is_undefined((jsval_t)description) && !is_null((jsval_t)description)) {
+    jsval_t s = coerce_to_str(nenv->js, (jsval_t)description);
+    if (is_err(s)) return napi_check_pending_from_result(env, s);
+    desc = js_getstr(nenv->js, s, NULL);
+  }
+
+  *result = (napi_value)js_mksym(nenv->js, desc);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_function(
+  napi_env env,
+  const char *utf8name,
+  size_t length,
+  napi_callback cb,
+  void *data,
+  napi_value *result
+) {
+  return napi_create_function_common(env, utf8name, length, cb, data, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_error(
+  napi_env env,
+  napi_value code,
+  napi_value msg,
+  napi_value *result
+) {
+  (void)code;
+  return napi_make_error_object(env, "Error", msg, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_type_error(
+  napi_env env,
+  napi_value code,
+  napi_value msg,
+  napi_value *result
+) {
+  (void)code;
+  return napi_make_error_object(env, "TypeError", msg, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_range_error(
+  napi_env env,
+  napi_value code,
+  napi_value msg,
+  napi_value *result
+) {
+  (void)code;
+  return napi_make_error_object(env, "RangeError", msg, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_external(
+  napi_env env,
+  void *data,
+  node_api_basic_finalize finalize_cb,
+  void *finalize_hint,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  napi_external_entry_t *entry = (napi_external_entry_t *)calloc(1, sizeof(*entry));
+  if (!entry) return napi_set_last(env, napi_generic_failure, "out of memory");
+
+  entry->id = g_napi_external_next_id++;
+  entry->data = data;
+  entry->finalize_cb = finalize_cb;
+  entry->finalize_hint = finalize_hint;
+  HASH_ADD(hh, g_napi_externals, id, sizeof(entry->id), entry);
+
+  jsval_t obj = js_mkobj(nenv->js);
+  napi_slot_set_u64(nenv->js, obj, SLOT_NAPI_EXTERNAL_ID, entry->id);
+  *result = (napi_value)obj;
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_promise(
+  napi_env env,
+  napi_deferred *deferred,
+  napi_value *promise
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !deferred || !promise) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  struct napi_deferred__ *def = (struct napi_deferred__ *)calloc(1, sizeof(*def));
+  if (!def) return napi_set_last(env, napi_generic_failure, "out of memory");
+
+  jsval_t p = js_mkpromise(nenv->js);
+  def->env = nenv;
+  def->promise_root = js_root(nenv->js, p);
+  def->settled = false;
+
+  *deferred = (napi_deferred)def;
+  *promise = (napi_value)p;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_resolve_deferred(
+  napi_env env,
+  napi_deferred deferred,
+  napi_value resolution
+) {
+  struct napi_deferred__ *def = (struct napi_deferred__ *)deferred;
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !def || def->settled) {
+    return napi_set_last(env, napi_invalid_arg, "invalid deferred");
+  }
+
+  jsval_t promise = js_deref(nenv->js, def->promise_root);
+  js_resolve_promise(nenv->js, promise, (jsval_t)resolution);
+  def->settled = true;
+  js_root_update(nenv->js, def->promise_root, js_mkundef());
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_reject_deferred(
+  napi_env env,
+  napi_deferred deferred,
+  napi_value rejection
+) {
+  struct napi_deferred__ *def = (struct napi_deferred__ *)deferred;
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !def || def->settled) {
+    return napi_set_last(env, napi_invalid_arg, "invalid deferred");
+  }
+
+  jsval_t promise = js_deref(nenv->js, def->promise_root);
+  js_reject_promise(nenv->js, promise, (jsval_t)rejection);
+  def->settled = true;
+  js_root_update(nenv->js, def->promise_root, js_mkundef());
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer(
+  napi_env env,
+  size_t length,
+  void **data,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  ArrayBufferData *buf = create_array_buffer_data(length);
+  if (!buf) return napi_set_last(env, napi_generic_failure, "allocation failed");
+
+  jsval_t value = create_typed_array(nenv->js, TYPED_ARRAY_UINT8, buf, 0, length, "Buffer");
+  if (is_err(value)) return napi_check_pending_from_result(env, value);
+
+  if (data) *data = buf->data;
+  *result = (napi_value)value;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer_copy(
+  napi_env env,
+  size_t length,
+  const void *data,
+  void **result_data,
+  napi_value *result
+) {
+  void *buf_ptr = NULL;
+  napi_status st = napi_create_buffer(env, length, &buf_ptr, result);
+  if (st != napi_ok) return st;
+
+  if (length > 0 && data && buf_ptr) memcpy(buf_ptr, data, length);
+  if (result_data) *result_data = buf_ptr;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_buffer(
+  napi_env env,
+  size_t length,
+  void *data,
+  node_api_basic_finalize finalize_cb,
+  void *finalize_hint,
+  napi_value *result
+) {
+  (void)finalize_cb;
+  (void)finalize_hint;
+  return napi_create_buffer_copy(env, length, data, NULL, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_arraybuffer(
+  napi_env env,
+  size_t byte_length,
+  void **data,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  ArrayBufferData *ab = create_array_buffer_data(byte_length);
+  if (!ab) return napi_set_last(env, napi_generic_failure, "allocation failed");
+
+  jsval_t ab_obj = create_arraybuffer_obj(nenv->js, ab);
+  free_array_buffer_data(ab);
+
+  if (data) *data = ab->data;
+  *result = (napi_value)ab_obj;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_arraybuffer(
+  napi_env env,
+  void *external_data,
+  size_t byte_length,
+  node_api_basic_finalize finalize_cb,
+  void *finalize_hint,
+  napi_value *result
+) {
+  (void)finalize_cb;
+  (void)finalize_hint;
+  void *out = NULL;
+  napi_status st = napi_create_arraybuffer(env, byte_length, &out, result);
+  if (st != napi_ok) return st;
+  if (external_data && out && byte_length > 0) memcpy(out, external_data, byte_length);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_typedarray(
+  napi_env env,
+  napi_typedarray_type type,
+  size_t length,
+  napi_value arraybuffer,
+  size_t byte_offset,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)arraybuffer)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t slot = js_get_slot(nenv->js, (jsval_t)arraybuffer, SLOT_BUFFER);
+  if (vtype(slot) != T_NUM) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected");
+
+  ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)js_getnum(slot);
+  if (!ab || ab->is_detached) return napi_set_last(env, napi_arraybuffer_expected, "invalid arraybuffer");
+
+  TypedArrayType ta_type;
+  if (!napi_to_ant_typedarray_type(type, &ta_type)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid typedarray type");
+  }
+
+  size_t element_size = 1;
+  switch (ta_type) {
+    case TYPED_ARRAY_INT16:
+    case TYPED_ARRAY_UINT16: element_size = 2; break;
+    case TYPED_ARRAY_INT32:
+    case TYPED_ARRAY_UINT32:
+    case TYPED_ARRAY_FLOAT32: element_size = 4; break;
+    case TYPED_ARRAY_FLOAT64:
+    case TYPED_ARRAY_BIGINT64:
+    case TYPED_ARRAY_BIGUINT64: element_size = 8; break;
+    default: break;
+  }
+
+  size_t byte_len = length * element_size;
+  if (byte_offset + byte_len > ab->length) {
+    return napi_set_last(env, napi_invalid_arg, "typedarray out of bounds");
+  }
+
+  jsval_t out = create_typed_array_with_buffer(
+    nenv->js,
+    ta_type,
+    ab,
+    byte_offset,
+    length,
+    napi_typed_array_name(ta_type),
+    (jsval_t)arraybuffer
+  );
+
+  if (is_err(out)) return napi_check_pending_from_result(env, out);
+  *result = (napi_value)out;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_reference(
+  napi_env env,
+  napi_value value,
+  uint32_t initial_refcount,
+  napi_ref *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  struct napi_ref__ *ref = (struct napi_ref__ *)calloc(1, sizeof(*ref));
+  if (!ref) return napi_set_last(env, napi_generic_failure, "out of memory");
+
+  ref->env = nenv;
+  ref->value = value;
+  ref->refcount = initial_refcount;
+  ref->root = js_root(nenv->js, (jsval_t)value);
+  if (initial_refcount == 0) js_root_update(nenv->js, ref->root, js_mkundef());
+
+  *result = (napi_ref)ref;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(
+  node_api_basic_env env,
+  napi_ref ref
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  struct napi_ref__ *r = (struct napi_ref__ *)ref;
+  if (!nenv || !nenv->js || !r) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+  js_root_update(nenv->js, r->root, js_mkundef());
+  free(r);
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_reference_ref(
+  napi_env env,
+  napi_ref ref,
+  uint32_t *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  struct napi_ref__ *r = (struct napi_ref__ *)ref;
+  if (!nenv || !nenv->js || !r) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  if (r->refcount == 0) js_root_update(nenv->js, r->root, (jsval_t)r->value);
+  r->refcount++;
+  if (result) *result = r->refcount;
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_reference_unref(
+  napi_env env,
+  napi_ref ref,
+  uint32_t *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  struct napi_ref__ *r = (struct napi_ref__ *)ref;
+  if (!nenv || !nenv->js || !r) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (r->refcount == 0) return napi_set_last(env, napi_invalid_arg, "reference count already zero");
+
+  r->refcount--;
+  if (r->refcount == 0) js_root_update(nenv->js, r->root, js_mkundef());
+  if (result) *result = r->refcount;
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_reference_value(
+  napi_env env,
+  napi_ref ref,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  struct napi_ref__ *r = (struct napi_ref__ *)ref;
+  if (!nenv || !nenv->js || !r || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  if (r->refcount > 0) *result = (napi_value)js_deref(nenv->js, r->root);
+  else *result = r->value;
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_double(
+  napi_env env,
+  napi_value value,
+  double *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (vtype((jsval_t)value) != T_NUM) return napi_set_last(env, napi_number_expected, "number expected");
+  *result = js_getnum((jsval_t)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int32(
+  napi_env env,
+  napi_value value,
+  int32_t *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (vtype((jsval_t)value) != T_NUM) return napi_set_last(env, napi_number_expected, "number expected");
+  *result = (int32_t)js_getnum((jsval_t)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_uint32(
+  napi_env env,
+  napi_value value,
+  uint32_t *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (vtype((jsval_t)value) != T_NUM) return napi_set_last(env, napi_number_expected, "number expected");
+  *result = (uint32_t)js_getnum((jsval_t)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int64(
+  napi_env env,
+  napi_value value,
+  int64_t *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (vtype((jsval_t)value) != T_NUM) return napi_set_last(env, napi_number_expected, "number expected");
+  *result = (int64_t)js_getnum((jsval_t)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bool(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (vtype((jsval_t)value) != T_BOOL) return napi_set_last(env, napi_boolean_expected, "boolean expected");
+  *result = ((jsval_t)value == js_true);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+static napi_status napi_get_string_common(
+  napi_env env,
+  napi_value value,
+  char *buf,
+  size_t bufsize,
+  size_t *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+  if (vtype((jsval_t)value) != T_STR) return napi_set_last(env, napi_string_expected, "string expected");
+
+  size_t len = 0;
+  const char *str = js_getstr(nenv->js, (jsval_t)value, &len);
+  if (!str) return napi_set_last(env, napi_string_expected, "string expected");
+
+  if (result) *result = len;
+  if (!buf || bufsize == 0) return napi_set_last(env, napi_ok, NULL);
+
+  size_t n = (len < (bufsize - 1)) ? len : (bufsize - 1);
+  memcpy(buf, str, n);
+  buf[n] = '\0';
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf8(
+  napi_env env,
+  napi_value value,
+  char *buf,
+  size_t bufsize,
+  size_t *result
+) {
+  return napi_get_string_common(env, value, buf, bufsize, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_latin1(
+  napi_env env,
+  napi_value value,
+  char *buf,
+  size_t bufsize,
+  size_t *result
+) {
+  return napi_get_string_common(env, value, buf, bufsize, result);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(
+  napi_env env,
+  napi_value value,
+  void **result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  napi_external_entry_t *entry = napi_find_external(nenv->js, value);
+  if (!entry) return napi_set_last(env, napi_invalid_arg, "not an external");
+  *result = entry->data;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info(
+  napi_env env,
+  napi_callback_info cbinfo,
+  size_t *argc,
+  napi_value *argv,
+  napi_value *this_arg,
+  void **data
+) {
+  struct napi_callback_info__ *info = (struct napi_callback_info__ *)cbinfo;
+  if (!env || !info) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  if (argc) {
+    size_t requested = *argc;
+    if (argv) {
+      size_t ncopy = requested < info->argc ? requested : info->argc;
+      if (ncopy > 0) memcpy(argv, info->argv, ncopy * sizeof(napi_value));
+    }
+    *argc = info->argc;
+  }
+
+  if (this_arg) *this_arg = info->this_arg;
+  if (data) *data = info->data;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_new_target(
+  napi_env env,
+  napi_callback_info cbinfo,
+  napi_value *result
+) {
+  struct napi_callback_info__ *info = (struct napi_callback_info__ *)cbinfo;
+  if (!env || !info || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  jsval_t nt = (jsval_t)info->new_target;
+  *result = is_undefined(nt) ? (napi_value)0 : info->new_target;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_array_length(
+  napi_env env,
+  napi_value value,
+  uint32_t *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  jsval_t v = (jsval_t)value;
+  if (vtype(v) == T_ARR) {
+    *result = (uint32_t)js_arr_len(nenv->js, v);
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  jsval_t len = js_get(nenv->js, v, "length");
+  if (vtype(len) != T_NUM) return napi_set_last(env, napi_array_expected, "array expected");
+  *result = (uint32_t)js_getnum(len);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_buffer_info(
+  napi_env env,
+  napi_value value,
+  void **data,
+  size_t *length
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+
+  TypedArrayData *ta = NULL;
+  if (!napi_get_typedarray_data(nenv->js, value, &ta)) {
+    return napi_set_last(env, napi_invalid_arg, "not a buffer");
+  }
+
+  if (data) *data = ta->buffer->data + ta->byte_offset;
+  if (length) *length = ta->byte_length;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info(
+  napi_env env,
+  napi_value arraybuffer,
+  void **data,
+  size_t *byte_length
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+  if (!is_object_type((jsval_t)arraybuffer)) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected");
+
+  jsval_t slot = js_get_slot(nenv->js, (jsval_t)arraybuffer, SLOT_BUFFER);
+  if (vtype(slot) != T_NUM) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected");
+
+  ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)js_getnum(slot);
+  if (!ab || ab->is_detached) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected");
+
+  if (data) *data = ab->data;
+  if (byte_length) *byte_length = ab->length;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_typedarray_info(
+  napi_env env,
+  napi_value typedarray,
+  napi_typedarray_type *type,
+  size_t *length,
+  void **data,
+  napi_value *arraybuffer,
+  size_t *byte_offset
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+
+  TypedArrayData *ta = NULL;
+  if (!napi_get_typedarray_data(nenv->js, typedarray, &ta)) {
+    return napi_set_last(env, napi_invalid_arg, "typedarray expected");
+  }
+
+  if (type) *type = napi_from_ant_typedarray_type(ta->type);
+  if (length) *length = ta->length;
+  if (data) *data = ta->buffer->data + ta->byte_offset;
+  if (arraybuffer) *arraybuffer = (napi_value)js_get(nenv->js, (jsval_t)typedarray, "buffer");
+  if (byte_offset) *byte_offset = ta->byte_offset;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_prototype(
+  napi_env env,
+  napi_value object,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_get_proto(nenv->js, (jsval_t)object);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_property_names(
+  napi_env env,
+  napi_value object,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t out = js_mkarr(nenv->js);
+  ant_iter_t iter = js_prop_iter_begin(nenv->js, (jsval_t)object);
+  const char *key = NULL;
+  size_t key_len = 0;
+
+  while (js_prop_iter_next(&iter, &key, &key_len, NULL)) {
+    js_arr_push(nenv->js, out, js_mkstr(nenv->js, key, key_len));
+  }
+  js_prop_iter_end(&iter);
+
+  *result = (napi_value)out;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(
+  node_api_basic_env env,
+  uint32_t *result
+) {
+  if (!env || !result) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+  *result = 8;
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version(
+  node_api_basic_env env,
+  const napi_node_version **version
+) {
+  if (!env || !version) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+  *version = &g_napi_node_version;
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_set_property(
+  napi_env env,
+  napi_value object,
+  napi_value key,
+  napi_value value
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  jsval_t r = js_setprop(nenv->js, (jsval_t)object, (jsval_t)key, (jsval_t)value);
+  if (is_err(r)) return napi_check_pending_from_result(env, r);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_property(
+  napi_env env,
+  napi_value object,
+  napi_value key,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t k = (jsval_t)key;
+  if (vtype(k) == T_SYMBOL) {
+    jsoff_t off = lkp_sym_proto(nenv->js, (jsval_t)object, (jsoff_t)vdata(k));
+    *result = (napi_value)(off ? resolveprop(nenv->js, mkval(T_PROP, off)) : js_mkundef());
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  jsval_t kstr = coerce_to_str(nenv->js, k);
+  if (is_err(kstr)) return napi_check_pending_from_result(env, kstr);
+  
+  size_t klen = 0;
+  const char *ks = js_getstr(nenv->js, kstr, &klen);
+  if (!ks) return napi_set_last(env, napi_string_expected, "string expected");
+
+  char *name = (char *)malloc(klen + 1);
+  if (!name) return napi_set_last(env, napi_generic_failure, "out of memory");
+  memcpy(name, ks, klen);
+  name[klen] = '\0';
+  
+  *result = (napi_value)js_getprop_fallback(nenv->js, (jsval_t)object, name);
+  free(name);
+  
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_property(
+  napi_env env,
+  napi_value object,
+  napi_value key,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t k = (jsval_t)key;
+  if (vtype(k) == T_SYMBOL) {
+    *result = lkp_sym_proto(nenv->js, (jsval_t)object, (jsoff_t)vdata(k)) != 0;
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  jsval_t kstr = coerce_to_str(nenv->js, k);
+  if (is_err(kstr)) return napi_check_pending_from_result(env, kstr);
+  size_t len = 0;
+  const char *s = js_getstr(nenv->js, kstr, &len);
+  *result = s && lkp_proto(nenv->js, (jsval_t)object, s, len) != 0;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_property(
+  napi_env env,
+  napi_value object,
+  napi_value key,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t k = (jsval_t)key;
+  jsval_t del_result = js_mkundef();
+
+  if (vtype(k) == T_SYMBOL) {
+    del_result = js_delete_sym_prop(nenv->js, (jsval_t)object, k);
+  } else {
+    jsval_t kstr = coerce_to_str(nenv->js, k);
+    if (is_err(kstr)) return napi_check_pending_from_result(env, kstr);
+    size_t len = 0;
+    const char *s = js_getstr(nenv->js, kstr, &len);
+    del_result = js_delete_prop(nenv->js, (jsval_t)object, s, len);
+  }
+
+  if (is_err(del_result)) return napi_check_pending_from_result(env, del_result);
+  *result = js_truthy(nenv->js, del_result);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_set_named_property(
+  napi_env env,
+  napi_value object,
+  const char *utf8name,
+  napi_value value
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !utf8name || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  js_set(nenv->js, (jsval_t)object, utf8name, (jsval_t)value);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_named_property(
+  napi_env env,
+  napi_value object,
+  const char *utf8name,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !utf8name || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  *result = (napi_value)js_getprop_fallback(nenv->js, (jsval_t)object, utf8name);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_named_property(
+  napi_env env,
+  napi_value object,
+  const char *utf8name,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !utf8name || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  *result = lkp_proto(nenv->js, (jsval_t)object, utf8name, strlen(utf8name)) != 0;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_set_element(
+  napi_env env,
+  napi_value object,
+  uint32_t index,
+  napi_value value
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  char idx[32];
+  int n = snprintf(idx, sizeof(idx), "%u", index);
+  if (n < 0) return napi_set_last(env, napi_generic_failure, "index conversion failed");
+  jsval_t key = js_mkstr(nenv->js, idx, (size_t)n);
+  jsval_t r = js_setprop(
+    nenv->js, (jsval_t)object,
+    key, (jsval_t)value
+  );
+  if (is_err(r)) return napi_check_pending_from_result(env, r);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_element(
+  napi_env env,
+  napi_value object,
+  uint32_t index,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  char idx[32];
+  snprintf(idx, sizeof(idx), "%u", index);
+  *result = (napi_value)js_get(nenv->js, (jsval_t)object, idx);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_element(
+  napi_env env,
+  napi_value object,
+  uint32_t index,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  char idx[32];
+  snprintf(idx, sizeof(idx), "%u", index);
+  *result = lkp_proto(nenv->js, (jsval_t)object, idx, strlen(idx)) != 0;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_element(
+  napi_env env,
+  napi_value object,
+  uint32_t index,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  char idx[32];
+  snprintf(idx, sizeof(idx), "%u", index);
+  jsval_t del = js_delete_prop(nenv->js, (jsval_t)object, idx, strlen(idx));
+  if (is_err(del)) return napi_check_pending_from_result(env, del);
+  *result = js_truthy(nenv->js, del);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_define_properties(
+  napi_env env,
+  napi_value object,
+  size_t property_count,
+  const napi_property_descriptor *properties
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !is_object_type((jsval_t)object) || (property_count > 0 && !properties)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  for (size_t i = 0; i < property_count; i++) {
+    const napi_property_descriptor *p = &properties[i];
+    jsval_t key = js_mkundef();
+    const char *key_str = NULL;
+    size_t key_len = 0;
+
+    if (p->utf8name) {
+      key_str = p->utf8name;
+      key_len = strlen(p->utf8name);
+      key = js_mkstr(nenv->js, key_str, key_len);
+    } else key = (jsval_t)p->name;
+
+    bool is_symbol = (vtype(key) == T_SYMBOL);
+    if (!is_symbol && !key_str) {
+      if (vtype(key) != T_STR) continue;
+      key_str = js_getstr(nenv->js, key, &key_len);
+    }
+
+    jsval_t value = js_mkundef();
+    if (p->method) {
+      napi_value fn = 0;
+      napi_status st = napi_create_function_common(
+        env,
+        p->utf8name,
+        NAPI_AUTO_LENGTH,
+        p->method,
+        p->data,
+        &fn
+      );
+      if (st != napi_ok) return st;
+      value = (jsval_t)fn;
+    } else if (p->getter || p->setter) {
+      napi_value getter_fn = 0;
+      napi_value setter_fn = 0;
+      if (p->getter) {
+        napi_status st = napi_create_function_common(env, p->utf8name, NAPI_AUTO_LENGTH, p->getter, p->data, &getter_fn);
+        if (st != napi_ok) return st;
+      }
+      if (p->setter) {
+        napi_status st = napi_create_function_common(env, p->utf8name, NAPI_AUTO_LENGTH, p->setter, p->data, &setter_fn);
+        if (st != napi_ok) return st;
+      }
+
+      int flags = napi_desc_flags(p->attributes);
+      if (is_symbol) {
+        if (p->getter) js_set_sym_getter_desc(nenv->js, (jsval_t)object, key, (jsval_t)getter_fn, flags);
+        if (p->setter) js_set_sym_setter_desc(nenv->js, (jsval_t)object, key, (jsval_t)setter_fn, flags);
+      } else {
+        js_set_accessor_desc(
+          nenv->js,
+          (jsval_t)object,
+          key_str,
+          key_len,
+          p->getter ? (jsval_t)getter_fn : js_mkundef(),
+          p->setter ? (jsval_t)setter_fn : js_mkundef(),
+          flags
+        );
+      }
+      continue;
+    } else {
+      value = (jsval_t)p->value;
+    }
+
+    if (is_symbol) {
+      js_set_sym(nenv->js, (jsval_t)object, key, value);
+    } else {
+      js_set(nenv->js, (jsval_t)object, key_str, value);
+      js_set_descriptor(nenv->js, (jsval_t)object, key_str, key_len, napi_desc_flags(p->attributes));
+    }
+  }
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_define_class(
+  napi_env env,
+  const char *utf8name,
+  size_t length,
+  napi_callback constructor,
+  void *data,
+  size_t property_count,
+  const napi_property_descriptor *properties,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !constructor || !result) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  napi_status st = napi_create_function_common(
+    env, utf8name, length, constructor, data, result
+  );
+  if (st != napi_ok) return st;
+
+  jsval_t ctor = (jsval_t)*result;
+  jsval_t proto = js_get(nenv->js, ctor, "prototype");
+  if (!is_object_type(proto)) {
+    proto = js_mkobj(nenv->js);
+    js_set(nenv->js, ctor, "prototype", proto);
+  }
+
+  for (size_t i = 0; i < property_count; i++) {
+    napi_property_descriptor tmp = properties[i];
+    bool is_static = (tmp.attributes & napi_static) != 0;
+    tmp.attributes = (napi_property_attributes)(tmp.attributes & ~napi_static);
+    st = napi_define_properties(env, (napi_value)(is_static ? ctor : proto), 1, &tmp);
+    if (st != napi_ok) return st;
+  }
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_own_property(
+  napi_env env,
+  napi_value object,
+  napi_value key,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t k = (jsval_t)key;
+  if (vtype(k) == T_SYMBOL) {
+    *result = lkp_sym(nenv->js, (jsval_t)object, (jsoff_t)vdata(k)) != 0;
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  jsval_t kstr = coerce_to_str(nenv->js, k);
+  if (is_err(kstr)) return napi_check_pending_from_result(env, kstr);
+  size_t len = 0;
+  const char *s = js_getstr(nenv->js, kstr, &len);
+  *result = s && lkp(nenv->js, (jsval_t)object, s, len) != 0;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_typeof(
+  napi_env env,
+  napi_value value,
+  napi_valuetype *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  jsval_t v = (jsval_t)value;
+  uint8_t t = vtype(v);
+
+  if (napi_find_external(nenv->js, value)) {
+    *result = napi_external;
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  switch (t) {
+    case T_UNDEF: *result = napi_undefined; break;
+    case T_NULL: *result = napi_null; break;
+    case T_BOOL: *result = napi_boolean; break;
+    case T_NUM: *result = napi_number; break;
+    case T_STR: *result = napi_string; break;
+    case T_SYMBOL: *result = napi_symbol; break;
+    case T_FUNC:
+    case T_CFUNC: *result = napi_function; break;
+    case T_BIGINT: *result = napi_bigint; break;
+    default: *result = napi_object; break;
+  }
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_array(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = vtype((jsval_t)value) == T_ARR;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_arraybuffer(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (!is_object_type((jsval_t)value)) { *result = false; return napi_set_last(env, napi_ok, NULL); }
+
+  jsval_t slot = js_get_slot(nenv->js, (jsval_t)value, SLOT_BUFFER);
+  if (vtype(slot) != T_NUM) {
+    *result = false;
+  } else {
+    jsval_t buf_prop = js_get(nenv->js, (jsval_t)value, "buffer");
+    *result = vtype(buf_prop) == T_UNDEF;
+  }
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_buffer(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  TypedArrayData *ta = NULL;
+  if (!napi_get_typedarray_data(nenv->js, value, &ta)) {
+    *result = false;
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  jsval_t buffer_proto = js_get_ctor_proto(nenv->js, "Buffer", 6);
+  *result = is_object_type(buffer_proto)
+    && proto_chain_contains(nenv->js, (jsval_t)value, buffer_proto);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_typedarray(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  TypedArrayData *ta = NULL;
+  *result = napi_get_typedarray_data(nenv->js, value, &ta);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_dataview(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (!is_object_type((jsval_t)value)) {
+    *result = false;
+  } else {
+    jsval_t slot = js_get_slot(nenv->js, (jsval_t)value, SLOT_DATA);
+    jsval_t byte_len = js_get(nenv->js, (jsval_t)value, "byteLength");
+    *result = vtype(slot) == T_NUM && vtype(byte_len) == T_NUM;
+  }
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_error(
+  napi_env env,
+  napi_value value,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (!is_object_type((jsval_t)value)) {
+    *result = false;
+  } else {
+    jsval_t et = js_get_slot(nenv->js, (jsval_t)value, SLOT_ERR_TYPE);
+    *result = vtype(et) == T_NUM;
+  }
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_promise(
+  napi_env env,
+  napi_value value,
+  bool *is_promise
+) {
+  if (!env || !is_promise) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *is_promise = vtype((jsval_t)value) == T_PROMISE;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_instanceof(
+  napi_env env,
+  napi_value object,
+  napi_value constructor,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  jsval_t r = do_instanceof(nenv->js, (jsval_t)object, (jsval_t)constructor);
+  if (is_err(r)) return napi_check_pending_from_result(env, r);
+  *result = js_truthy(nenv->js, r);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_strict_equals(
+  napi_env env,
+  napi_value lhs,
+  napi_value rhs,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = strict_eq_values(nenv->js, (jsval_t)lhs, (jsval_t)rhs);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_call_function(
+  napi_env env,
+  napi_value recv,
+  napi_value func,
+  size_t argc,
+  const napi_value *argv,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !napi_is_callable((jsval_t)func)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t out = sv_vm_call(
+    nenv->js->vm,
+    nenv->js,
+    (jsval_t)func,
+    (jsval_t)recv,
+    (jsval_t *)argv,
+    (int)argc,
+    NULL,
+    false
+  );
+
+  if (is_err(out) || nenv->js->thrown_exists) return napi_check_pending_from_result(env, out);
+  if (result) *result = (napi_value)out;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_new_instance(
+  napi_env env,
+  napi_value constructor,
+  size_t argc,
+  const napi_value *argv,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !napi_is_callable((jsval_t)constructor)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  jsval_t ctor = (jsval_t)constructor;
+  jsval_t obj = js_mkobj(nenv->js);
+  jsval_t proto = js_get(nenv->js, ctor, "prototype");
+  if (is_object_type(proto)) js_set_proto(nenv->js, obj, proto);
+
+  jsval_t saved = nenv->js->new_target;
+  nenv->js->new_target = ctor;
+  jsval_t out = sv_vm_call(
+    nenv->js->vm,
+    nenv->js,
+    ctor,
+    obj,
+    (jsval_t *)argv,
+    (int)argc,
+    NULL,
+    true
+  );
+  nenv->js->new_target = saved;
+
+  if (is_err(out) || nenv->js->thrown_exists) return napi_check_pending_from_result(env, out);
+  *result = (napi_value)(is_object_type(out) ? out : obj);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_bool(
+  napi_env env,
+  napi_value value,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_bool(js_truthy(nenv->js, (jsval_t)value));
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_number(
+  napi_env env,
+  napi_value value,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = (napi_value)js_mknum(js_to_number(nenv->js, (jsval_t)value));
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_object(
+  napi_env env,
+  napi_value value,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  if (is_object_type((jsval_t)value)) {
+    *result = value;
+    return napi_set_last(env, napi_ok, NULL);
+  }
+
+  jsval_t obj_ctor = js_get(nenv->js, js_glob(nenv->js), "Object");
+  if (!napi_is_callable(obj_ctor)) return napi_set_last(env, napi_generic_failure, "Object constructor missing");
+  jsval_t arg = (jsval_t)value;
+  jsval_t out = sv_vm_call(nenv->js->vm, nenv->js, obj_ctor, js_mkundef(), &arg, 1, NULL, false);
+  if (is_err(out) || nenv->js->thrown_exists) return napi_check_pending_from_result(env, out);
+  *result = (napi_value)out;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_string(
+  napi_env env,
+  napi_value value,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  jsval_t out = coerce_to_str(nenv->js, (jsval_t)value);
+  if (is_err(out) || nenv->js->thrown_exists) return napi_check_pending_from_result(env, out);
+  *result = (napi_value)out;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env");
+  js_throw(nenv->js, (jsval_t)error);
+  napi_mark_pending_exception(env, error);
+  return napi_pending_exception;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw_error(
+  napi_env env,
+  const char *code,
+  const char *msg
+) {
+  (void)code;
+  return napi_throw_with_message(env, JS_ERR_GENERIC, msg ? msg : "");
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw_type_error(
+  napi_env env,
+  const char *code,
+  const char *msg
+) {
+  (void)code;
+  return napi_throw_with_message(env, JS_ERR_TYPE, msg ? msg : "");
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw_range_error(
+  napi_env env,
+  const char *code,
+  const char *msg
+) {
+  (void)code;
+  return napi_throw_with_message(env, JS_ERR_RANGE, msg ? msg : "");
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_exception_pending(
+  napi_env env,
+  bool *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  *result = nenv->has_pending_exception || nenv->js->thrown_exists;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_and_clear_last_exception(
+  napi_env env,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  if (nenv->has_pending_exception) {
+    *result = nenv->pending_exception;
+    nenv->has_pending_exception = false;
+    nenv->pending_exception = (napi_value)js_mkundef();
+  } else if (nenv->js->thrown_exists) {
+    *result = (napi_value)nenv->js->thrown_value;
+    nenv->js->thrown_exists = false;
+    nenv->js->thrown_value = js_mkundef();
+    nenv->js->thrown_stack = js_mkundef();
+  } else {
+    *result = (napi_value)js_mkundef();
+  }
+
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN void NAPI_CDECL napi_fatal_error(
+  const char *location,
+  size_t location_len,
+  const char *message,
+  size_t message_len
+) {
+  fprintf(
+    stderr,
+    "N-API fatal error at %.*s: %.*s\n",
+    (int)location_len,
+    location ? location : "",
+    (int)message_len,
+    message ? message : ""
+  );
+  abort();
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env, napi_value err) {
+  return napi_throw(env, err);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(
+  napi_env env,
+  napi_value js_object,
+  void *native_object,
+  node_api_basic_finalize finalize_cb,
+  void *finalize_hint,
+  napi_ref *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !is_object_type((jsval_t)js_object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  napi_wrap_entry_t *entry = napi_find_wrap(nenv->js, js_object);
+  if (!entry) {
+    entry = (napi_wrap_entry_t *)calloc(1, sizeof(*entry));
+    if (!entry) return napi_set_last(env, napi_generic_failure, "out of memory");
+    entry->id = g_napi_wrap_next_id++;
+    HASH_ADD(hh, g_napi_wraps, id, sizeof(entry->id), entry);
+    napi_slot_set_u64(nenv->js, (jsval_t)js_object, SLOT_NAPI_WRAP_ID, entry->id);
+  }
+
+  entry->native_object = native_object;
+  entry->finalize_cb = finalize_cb;
+  entry->finalize_hint = finalize_hint;
+
+  if (result) {
+    return napi_create_reference(env, js_object, 0, result);
+  }
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(
+  napi_env env,
+  napi_value js_object,
+  void **result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result || !is_object_type((jsval_t)js_object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+  napi_wrap_entry_t *entry = napi_find_wrap(nenv->js, js_object);
+  if (!entry) return napi_set_last(env, napi_invalid_arg, "object not wrapped");
+  *result = entry->native_object;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(
+  napi_env env,
+  napi_value js_object,
+  void **result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !is_object_type((jsval_t)js_object)) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  napi_wrap_entry_t *entry = napi_find_wrap(nenv->js, js_object);
+  if (!entry) return napi_set_last(env, napi_invalid_arg, "object not wrapped");
+
+  if (result) *result = entry->native_object;
+  HASH_DEL(g_napi_wraps, entry);
+  free(entry);
+  js_set_slot(nenv->js, (jsval_t)js_object, SLOT_NAPI_WRAP_ID, js_mkundef());
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_open_handle_scope(
+  napi_env env,
+  napi_handle_scope *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  struct napi_handle_scope__ *scope = (struct napi_handle_scope__ *)calloc(1, sizeof(*scope));
+  if (!scope) return napi_set_last(env, napi_generic_failure, "out of memory");
+  scope->env = (ant_napi_env_t *)env;
+  *result = (napi_handle_scope)scope;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_close_handle_scope(
+  napi_env env,
+  napi_handle_scope scope
+) {
+  (void)env;
+  if (!scope) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  free(scope);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_open_escapable_handle_scope(
+  napi_env env,
+  napi_escapable_handle_scope *result
+) {
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  struct napi_escapable_handle_scope__ *scope = (struct napi_escapable_handle_scope__ *)calloc(1, sizeof(*scope));
+  if (!scope) return napi_set_last(env, napi_generic_failure, "out of memory");
+  scope->env = (ant_napi_env_t *)env;
+  scope->escaped = false;
+  *result = (napi_escapable_handle_scope)scope;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_close_escapable_handle_scope(
+  napi_env env,
+  napi_escapable_handle_scope scope
+) {
+  (void)env;
+  if (!scope) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  free(scope);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_escape_handle(
+  napi_env env,
+  napi_escapable_handle_scope scope,
+  napi_value escapee,
+  napi_value *result
+) {
+  struct napi_escapable_handle_scope__ *esc = (struct napi_escapable_handle_scope__ *)scope;
+  if (!env || !esc || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (esc->escaped) return napi_set_last(env, napi_escape_called_twice, "escape already called");
+  esc->escaped = true;
+  *result = escapee;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_async_work(
+  napi_env env,
+  napi_value async_resource,
+  napi_value async_resource_name,
+  napi_async_execute_callback execute,
+  napi_async_complete_callback complete,
+  void *data,
+  napi_async_work *result
+) {
+  (void)async_resource;
+  (void)async_resource_name;
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !execute || !result) {
+    return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  }
+
+  napi_async_work_impl_t *work = (napi_async_work_impl_t *)calloc(1, sizeof(*work));
+  if (!work) return napi_set_last(env, napi_generic_failure, "out of memory");
+
+  work->env = nenv;
+  work->execute = execute;
+  work->complete = complete;
+  work->data = data;
+  work->req.data = work;
+
+  *result = (napi_async_work)work;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(
+  napi_env env,
+  napi_async_work work
+) {
+  (void)env;
+  napi_async_work_impl_t *w = (napi_async_work_impl_t *)work;
+  if (!w) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (w->queued) {
+    w->delete_after_complete = true;
+    return napi_set_last(env, napi_ok, NULL);
+  }
+  free(w);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(
+  node_api_basic_env env,
+  napi_async_work work
+) {
+  napi_async_work_impl_t *w = (napi_async_work_impl_t *)work;
+  if (!env || !w) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+  if (w->queued) return napi_set_last((napi_env)env, napi_invalid_arg, "already queued");
+
+  int rc = uv_queue_work(uv_default_loop(), &w->req, napi_async_work_execute_cb, napi_async_work_after_cb);
+  if (rc != 0) return napi_set_last((napi_env)env, napi_generic_failure, "uv_queue_work failed");
+  w->queued = true;
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(
+  node_api_basic_env env,
+  napi_async_work work
+) {
+  napi_async_work_impl_t *w = (napi_async_work_impl_t *)work;
+  if (!env || !w) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+  int rc = uv_cancel((uv_req_t *)&w->req);
+  if (rc != 0) return napi_set_last((napi_env)env, napi_generic_failure, "uv_cancel failed");
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_threadsafe_function(
+  napi_env env,
+  napi_value func,
+  napi_value async_resource,
+  napi_value async_resource_name,
+  size_t max_queue_size,
+  size_t initial_thread_count,
+  void *thread_finalize_data,
+  napi_finalize thread_finalize_cb,
+  void *context,
+  napi_threadsafe_function_call_js call_js_cb,
+  napi_threadsafe_function *result
+) {
+  (void)async_resource;
+  (void)async_resource_name;
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+
+  struct napi_threadsafe_function__ *tsfn =
+    (struct napi_threadsafe_function__ *)calloc(1, sizeof(*tsfn));
+  if (!tsfn) return napi_set_last(env, napi_generic_failure, "out of memory");
+
+  tsfn->env = nenv;
+  tsfn->call_js_cb = call_js_cb;
+  tsfn->thread_finalize_cb = thread_finalize_cb;
+  tsfn->thread_finalize_data = thread_finalize_data;
+  tsfn->context = context;
+  tsfn->max_queue_size = max_queue_size;
+  tsfn->thread_count = initial_thread_count > 0 ? initial_thread_count : 1;
+  tsfn->func_root = js_root(nenv->js, (jsval_t)func);
+
+  uv_mutex_init(&tsfn->mutex);
+  int rc = uv_async_init(uv_default_loop(), &tsfn->async, napi_tsfn_async_cb);
+  if (rc != 0) {
+    uv_mutex_destroy(&tsfn->mutex);
+    free(tsfn);
+    return napi_set_last(env, napi_generic_failure, "uv_async_init failed");
+  }
+  tsfn->async.data = tsfn;
+
+  *result = (napi_threadsafe_function)tsfn;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_call_threadsafe_function(
+  napi_threadsafe_function func,
+  void *data,
+  napi_threadsafe_function_call_mode is_blocking
+) {
+  (void)is_blocking;
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)func;
+  if (!tsfn) return napi_invalid_arg;
+
+  uv_mutex_lock(&tsfn->mutex);
+  if (tsfn->closing || tsfn->aborted) {
+    uv_mutex_unlock(&tsfn->mutex);
+    return napi_closing;
+  }
+  if (tsfn->max_queue_size > 0 && tsfn->queue_size >= tsfn->max_queue_size) {
+    uv_mutex_unlock(&tsfn->mutex);
+    return napi_queue_full;
+  }
+
+  napi_tsfn_item_t *item = (napi_tsfn_item_t *)calloc(1, sizeof(*item));
+  if (!item) {
+    uv_mutex_unlock(&tsfn->mutex);
+    return napi_generic_failure;
+  }
+  item->data = data;
+  if (!tsfn->head) tsfn->head = item;
+  else tsfn->tail->next = item;
+  tsfn->tail = item;
+  tsfn->queue_size++;
+  uv_mutex_unlock(&tsfn->mutex);
+
+  uv_async_send(&tsfn->async);
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function(
+  napi_threadsafe_function func,
+  napi_threadsafe_function_release_mode mode
+) {
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)func;
+  if (!tsfn) return napi_invalid_arg;
+
+  uv_mutex_lock(&tsfn->mutex);
+  if (mode == napi_tsfn_abort) tsfn->aborted = true;
+  if (tsfn->thread_count > 0) tsfn->thread_count--;
+  if (tsfn->thread_count == 0 || tsfn->aborted) tsfn->closing = true;
+  uv_mutex_unlock(&tsfn->mutex);
+
+  uv_async_send(&tsfn->async);
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_acquire_threadsafe_function(
+  napi_threadsafe_function func
+) {
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)func;
+  if (!tsfn) return napi_invalid_arg;
+  uv_mutex_lock(&tsfn->mutex);
+  if (tsfn->closing) {
+    uv_mutex_unlock(&tsfn->mutex);
+    return napi_closing;
+  }
+  tsfn->thread_count++;
+  uv_mutex_unlock(&tsfn->mutex);
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function(
+  node_api_basic_env env,
+  napi_threadsafe_function func
+) {
+  (void)env;
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)func;
+  if (!tsfn) return napi_invalid_arg;
+  uv_ref((uv_handle_t *)&tsfn->async);
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function(
+  node_api_basic_env env,
+  napi_threadsafe_function func
+) {
+  (void)env;
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)func;
+  if (!tsfn) return napi_invalid_arg;
+  uv_unref((uv_handle_t *)&tsfn->async);
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context(
+  napi_threadsafe_function func,
+  void **result
+) {
+  struct napi_threadsafe_function__ *tsfn = (struct napi_threadsafe_function__ *)func;
+  if (!tsfn || !result) return napi_invalid_arg;
+  *result = tsfn->context;
+  return napi_ok;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(
+  napi_env env,
+  napi_value script,
+  napi_value *result
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  if (vtype((jsval_t)script) != T_STR) return napi_set_last(env, napi_string_expected, "script must be string");
+
+  size_t len = 0;
+  const char *src = js_getstr(nenv->js, (jsval_t)script, &len);
+  if (!src) return napi_set_last(env, napi_string_expected, "script must be string");
+
+  jsval_t out = js_eval_bytecode_eval(nenv->js, src, len);
+  if (is_err(out) || nenv->js->thrown_exists) return napi_check_pending_from_result(env, out);
+  *result = (napi_value)out;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory(
+  node_api_basic_env env,
+  int64_t change_in_bytes,
+  int64_t *adjusted_value
+) {
+  if (!env) return napi_invalid_arg;
+  g_napi_external_memory += change_in_bytes;
+  if (adjusted_value) *adjusted_value = g_napi_external_memory;
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook(
+  node_api_basic_env env,
+  napi_cleanup_hook fun,
+  void *arg
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !fun) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+
+  napi_cleanup_hook_entry_t *entry = (napi_cleanup_hook_entry_t *)calloc(1, sizeof(*entry));
+  if (!entry) return napi_set_last((napi_env)env, napi_generic_failure, "out of memory");
+  entry->hook = fun;
+  entry->arg = arg;
+  entry->next = nenv->cleanup_hooks;
+  nenv->cleanup_hooks = entry;
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook(
+  node_api_basic_env env,
+  napi_cleanup_hook fun,
+  void *arg
+) {
+  ant_napi_env_t *nenv = (ant_napi_env_t *)env;
+  if (!nenv || !fun) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+
+  napi_cleanup_hook_entry_t **pp = &nenv->cleanup_hooks;
+  while (*pp) {
+    if ((*pp)->hook == fun && (*pp)->arg == arg) {
+      napi_cleanup_hook_entry_t *victim = *pp;
+      *pp = victim->next;
+      free(victim);
+      return napi_set_last((napi_env)env, napi_ok, NULL);
+    }
+    pp = &(*pp)->next;
+  }
+  return napi_set_last((napi_env)env, napi_invalid_arg, "cleanup hook not found");
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_open_callback_scope(
+  napi_env env,
+  napi_value resource_object,
+  napi_async_context context,
+  napi_callback_scope *result
+) {
+  (void)resource_object;
+  (void)context;
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  struct napi_callback_scope__ *scope = (struct napi_callback_scope__ *)calloc(1, sizeof(*scope));
+  if (!scope) return napi_set_last(env, napi_generic_failure, "out of memory");
+  scope->env = (ant_napi_env_t *)env;
+  *result = (napi_callback_scope)scope;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_close_callback_scope(
+  napi_env env,
+  napi_callback_scope scope
+) {
+  (void)env;
+  if (!scope) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  free(scope);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_async_init(
+  napi_env env,
+  napi_value async_resource,
+  napi_value async_resource_name,
+  napi_async_context *result
+) {
+  (void)async_resource;
+  (void)async_resource_name;
+  if (!env || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  struct napi_async_context__ *ctx = (struct napi_async_context__ *)calloc(1, sizeof(*ctx));
+  if (!ctx) return napi_set_last(env, napi_generic_failure, "out of memory");
+  ctx->env = (ant_napi_env_t *)env;
+  *result = (napi_async_context)ctx;
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_async_destroy(
+  napi_env env,
+  napi_async_context async_context
+) {
+  (void)env;
+  if (!async_context) return napi_set_last(env, napi_invalid_arg, "invalid argument");
+  free(async_context);
+  return napi_set_last(env, napi_ok, NULL);
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_make_callback(
+  napi_env env,
+  napi_async_context async_context,
+  napi_value recv,
+  napi_value func,
+  size_t argc,
+  const napi_value *argv,
+  napi_value *result
+) {
+  (void)async_context;
+  return napi_call_function(env, recv, func, argc, argv, result);
+}
+
+NAPI_EXTERN void NAPI_CDECL napi_module_register(napi_module *mod) {
+  g_pending_napi_module = mod;
+}
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_uv_event_loop(
+  node_api_basic_env env,
+  struct uv_loop_s **loop
+) {
+  if (!env || !loop) return napi_set_last((napi_env)env, napi_invalid_arg, "invalid argument");
+  *loop = uv_default_loop();
+  return napi_set_last((napi_env)env, napi_ok, NULL);
+}
diff --git a/src/modules/navigator.c b/src/modules/navigator.c
index c78d3dc..53954de 100644
--- a/src/modules/navigator.c
+++ b/src/modules/navigator.c
@@ -15,6 +15,7 @@
 #include "errors.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/engine.h"
 #include "modules/navigator.h"
 #include "modules/symbol.h"
 
@@ -31,7 +32,7 @@ typedef struct lock_entry {
 } lock_entry_t;
 
 typedef struct lock_request {
-  struct js *js;
+  ant_t *js;
   char *name;
   lock_mode_t mode;
   jsval_t callback;
@@ -115,21 +116,21 @@ static void release_lock(const char *name) {
   free(entry);
 }
 
-static void process_pending_requests(struct js *js);
+static void process_pending_requests(ant_t *js);
 
-static jsval_t make_lock_handler(struct js *js, jsval_t cfunc, jsval_t lock_name, jsval_t outer_promise) {
+static jsval_t make_lock_handler(ant_t *js, jsval_t cfunc, jsval_t lock_name, jsval_t outer_promise) {
   jsval_t fn_obj = js_mkobj(js);
-  js_set_slot(js, fn_obj, SLOT_CFUNC, cfunc);
   
   jsval_t data_obj = js_mkobj(js);
   js_set(js, data_obj, "lockName", lock_name);
   js_set(js, data_obj, "outerPromise", outer_promise);
   js_set_slot(js, fn_obj, SLOT_DATA, data_obj);
+  js_set_slot(js, fn_obj, SLOT_CFUNC, cfunc);
   
   return js_obj_to_func(fn_obj);
 }
 
-static jsval_t lock_then_handler(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lock_then_handler(ant_t *js, jsval_t *args, int nargs) {
   jsval_t current_func = js_getcurrentfunc(js);
   jsval_t data_obj = js_get_slot(js, current_func, SLOT_DATA);
   
@@ -147,7 +148,7 @@ static jsval_t lock_then_handler(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t lock_catch_handler(struct js *js, jsval_t *args, int nargs) {
+static jsval_t lock_catch_handler(ant_t *js, jsval_t *args, int nargs) {
   jsval_t current_func = js_getcurrentfunc(js);
   jsval_t data_obj = js_get_slot(js, current_func, SLOT_DATA);
   
@@ -166,13 +167,13 @@ static jsval_t lock_catch_handler(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static void execute_lock_callback(struct js *js, const char *name, lock_mode_t mode, jsval_t callback, jsval_t outer_promise) {
+static void execute_lock_callback(ant_t *js, const char *name, lock_mode_t mode, jsval_t callback, jsval_t outer_promise) {
   jsval_t lock_obj = js_mkobj(js);
   js_set(js, lock_obj, "name", js_mkstr(js, name, strlen(name)));
   js_set(js, lock_obj, "mode", js_mkstr(js, mode == LOCK_MODE_EXCLUSIVE ? "exclusive" : "shared", mode == LOCK_MODE_EXCLUSIVE ? 9 : 6));
-  js_set(js, lock_obj, get_toStringTag_sym_key(), js_mkstr(js, "Lock", 4));
+  js_set_sym(js, lock_obj, get_toStringTag_sym(), js_mkstr(js, "Lock", 4));
   
-  jsval_t result = js_call(js, callback, &lock_obj, 1);
+  jsval_t result = sv_vm_call(js->vm, js, callback, js_mkundef(), &lock_obj, 1, NULL, false);
   
   if (vtype(result) == T_ERR) {
     release_lock(name);
@@ -192,7 +193,7 @@ static void execute_lock_callback(struct js *js, const char *name, lock_mode_t m
       jsval_t on_reject = make_lock_handler(js, js_mkfun(lock_catch_handler), name_str, outer_promise);
       
       jsval_t then_args[2] = { on_resolve, on_reject };
-      js_call_with_this(js, then_fn, result, then_args, 2);
+      sv_vm_call(js->vm, js, then_fn, result, then_args, 2, NULL, false);
       return;
     }
   }
@@ -202,7 +203,7 @@ static void execute_lock_callback(struct js *js, const char *name, lock_mode_t m
   process_pending_requests(js);
 }
 
-static void process_pending_requests(struct js *js) {
+static void process_pending_requests(ant_t *js) {
   lock_request_t *prev = NULL;
   lock_request_t *req = pending_requests;
   
@@ -236,7 +237,7 @@ static void process_pending_requests(struct js *js) {
   }
 }
 
-static jsval_t locks_request(struct js *js, jsval_t *args, int nargs) {
+static jsval_t locks_request(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "locks.request requires at least 2 arguments");
   }
@@ -278,7 +279,7 @@ static jsval_t locks_request(struct js *js, jsval_t *args, int nargs) {
   
   if (if_available && !can_acquire_lock(name, mode)) {
     jsval_t null_val = js_mknull();
-    jsval_t result = js_call(js, callback, &null_val, 1);
+    jsval_t result = sv_vm_call(js->vm, js, callback, js_mkundef(), &null_val, 1, NULL, false);
     
     if (vtype(result) == T_PROMISE) {
       jsval_t then_fn = js_get(js, result, "then");
@@ -288,7 +289,7 @@ static jsval_t locks_request(struct js *js, jsval_t *args, int nargs) {
           js, js_mkfun(lock_then_handler), 
           js_mkstr(js, "", 0), promise
         );
-        js_call_with_this(js, then_fn, result, &on_resolve, 1);
+        sv_vm_call(js->vm, js, then_fn, result, &on_resolve, 1, NULL, false);
         return promise;
       }
     }
@@ -327,7 +328,7 @@ static jsval_t locks_request(struct js *js, jsval_t *args, int nargs) {
   return promise;
 }
 
-static jsval_t locks_query(struct js *js, jsval_t *args, int nargs) {
+static jsval_t locks_query(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   
@@ -362,7 +363,7 @@ static jsval_t locks_query(struct js *js, jsval_t *args, int nargs) {
 }
 
 void init_navigator_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   
   jsval_t navigator_obj = js_mkobj(js);
   
@@ -383,10 +384,10 @@ void init_navigator_module(void) {
   jsval_t locks_obj = js_mkobj(js);
   js_set(js, locks_obj, "request", js_mkfun(locks_request));
   js_set(js, locks_obj, "query", js_mkfun(locks_query));
-  js_set(js, locks_obj, get_toStringTag_sym_key(), js_mkstr(js, "LockManager", 11));
+  js_set_sym(js, locks_obj, get_toStringTag_sym(), js_mkstr(js, "LockManager", 11));
   js_set(js, navigator_obj, "locks", locks_obj);
   
-  js_set(js, navigator_obj, get_toStringTag_sym_key(), js_mkstr(js, "Navigator", 9));
+  js_set_sym(js, navigator_obj, get_toStringTag_sym(), js_mkstr(js, "Navigator", 9));
   js_set(js, js_glob(js), "navigator", navigator_obj);
 }
 
diff --git a/src/modules/net.c b/src/modules/net.c
new file mode 100644
index 0000000..e18a9d7
--- /dev/null
+++ b/src/modules/net.c
@@ -0,0 +1,58 @@
+// stub: minimal node:net implementation (isIP, isIPv4, isIPv6)
+// just enough for vite to resolve the module and validate hostnames
+
+#include <string.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#include "ant.h"
+#include "internal.h" // IWYU pragma: keep
+
+static jsval_t net_isIP(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mknum(0);
+  size_t len;
+  const char *host = js_getstr(js, args[0], &len);
+  if (!host) return js_mknum(0);
+
+  struct in_addr addr4;
+  struct in6_addr addr6;
+
+  if (inet_pton(AF_INET, host, &addr4) == 1) return js_mknum(4);
+  if (inet_pton(AF_INET6, host, &addr6) == 1) return js_mknum(6);
+  return js_mknum(0);
+}
+
+static jsval_t net_isIPv4(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_false;
+  size_t len;
+  const char *host = js_getstr(js, args[0], &len);
+  if (!host) return js_false;
+
+  struct in_addr addr;
+  return inet_pton(AF_INET, host, &addr) == 1 ? js_true : js_false;
+}
+
+static jsval_t net_isIPv6(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_false;
+  size_t len;
+  const char *host = js_getstr(js, args[0], &len);
+  if (!host) return js_false;
+
+  struct in6_addr addr;
+  return inet_pton(AF_INET6, host, &addr) == 1 ? js_true : js_false;
+}
+
+jsval_t net_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+
+  js_set(js, lib, "isIP", js_mkfun(net_isIP));
+  js_set(js, lib, "isIPv4", js_mkfun(net_isIPv4));
+  js_set(js, lib, "isIPv6", js_mkfun(net_isIPv6));
+
+  return lib;
+}
diff --git a/src/modules/observable.c b/src/modules/observable.c
index 1038ecf..f794fd8 100644
--- a/src/modules/observable.c
+++ b/src/modules/observable.c
@@ -5,6 +5,8 @@
 #include "errors.h"
 #include "internal.h"
 #include "runtime.h"
+#include "silver/engine.h"
+#include "descriptors.h"
 
 #include "modules/symbol.h"
 #include "modules/observable.h"
@@ -14,31 +16,31 @@ static inline bool is_callable(jsval_t val) {
   return t == T_FUNC || t == T_CFUNC;
 }
 
-static bool subscription_closed(struct js *js, jsval_t subscription) {
+static bool subscription_closed(ant_t *js, jsval_t subscription) {
   jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER);
   return vtype(observer) == T_UNDEF;
 }
 
-static void cleanup_subscription(struct js *js, jsval_t subscription) {
+static void cleanup_subscription(ant_t *js, jsval_t subscription) {
   jsval_t cleanup = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP);
   if (vtype(cleanup) == T_UNDEF) return;
   if (!is_callable(cleanup)) return;
   
   js_set_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP, js_mkundef());
-  jsval_t result = js_call(js, cleanup, NULL, 0);
+  jsval_t result = sv_vm_call(js->vm, js, cleanup, js_mkundef(), NULL, 0, NULL, false);
   
   if (vtype(result) == T_ERR) fprintf(stderr, "Error in subscription cleanup: %s\n", js_str(js, result));
 }
 
-static jsval_t create_subscription(struct js *js, jsval_t observer) {
+static jsval_t create_subscription(ant_t *js, jsval_t observer) {
   jsval_t subscription = js_mkobj(js);
   js_set_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER, observer);
   js_set_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP, js_mkundef());
-  js_set(js, subscription, get_toStringTag_sym_key(), js_mkstr(js, "Subscription", 12));
+  js_set_sym(js, subscription, get_toStringTag_sym(), js_mkstr(js, "Subscription", 12));
   return subscription;
 }
 
-static jsval_t js_subscription_get_closed(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_subscription_get_closed(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t subscription = js_getthis(js);
   
@@ -48,7 +50,7 @@ static jsval_t js_subscription_get_closed(struct js *js, jsval_t *args, int narg
   return js_bool(subscription_closed(js, subscription));
 }
 
-static jsval_t js_subscription_unsubscribe(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_subscription_unsubscribe(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t subscription = js_getthis(js);
   
@@ -64,13 +66,13 @@ static jsval_t js_subscription_unsubscribe(struct js *js, jsval_t *args, int nar
   return js_mkundef();
 }
 
-static void setup_subscription_methods(struct js *js, jsval_t subscription) {
+static void setup_subscription_methods(ant_t *js, jsval_t subscription) {
   js_set(js, subscription, "unsubscribe", js_mkfun(js_subscription_unsubscribe));
   jsval_t closed_getter = js_mkfun(js_subscription_get_closed);
   js_set_getter_desc(js, subscription, "closed", 6, closed_getter, JS_DESC_E | JS_DESC_C);
 }
 
-static jsval_t js_subobs_get_closed(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_subobs_get_closed(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t O = js_getthis(js);
   
@@ -86,7 +88,7 @@ static jsval_t js_subobs_get_closed(struct js *js, jsval_t *args, int nargs) {
   return js_bool(subscription_closed(js, subscription));
 }
 
-static jsval_t js_subobs_next(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_subobs_next(ant_t *js, jsval_t *args, int nargs) {
   jsval_t O = js_getthis(js);
   
   if (!is_special_object(O)) {
@@ -107,14 +109,14 @@ static jsval_t js_subobs_next(struct js *js, jsval_t *args, int nargs) {
   if (is_callable(nextMethod)) {
     jsval_t value = (nargs > 0) ? args[0] : js_mkundef();
     jsval_t call_args[1] = {value};
-    jsval_t result = js_call_with_this(js, nextMethod, observer, call_args, 1);
+    jsval_t result = sv_vm_call(js->vm, js, nextMethod, observer, call_args, 1, NULL, false);
     if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.next: %s\n", js_str(js, result));
   }
   
   return js_mkundef();
 }
 
-static jsval_t js_subobs_error(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_subobs_error(ant_t *js, jsval_t *args, int nargs) {
   jsval_t O = js_getthis(js);
   
   if (!is_special_object(O)) {
@@ -136,7 +138,7 @@ static jsval_t js_subobs_error(struct js *js, jsval_t *args, int nargs) {
     if (is_callable(errorMethod)) {
       jsval_t exception = (nargs > 0) ? args[0] : js_mkundef();
       jsval_t call_args[1] = {exception};
-      jsval_t result = js_call_with_this(js, errorMethod, observer, call_args, 1);
+      jsval_t result = sv_vm_call(js->vm, js, errorMethod, observer, call_args, 1, NULL, false);
       if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.error: %s\n", js_str(js, result));
     }
   }
@@ -145,7 +147,7 @@ static jsval_t js_subobs_error(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t js_subobs_complete(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_subobs_complete(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t O = js_getthis(js);
   
@@ -166,7 +168,7 @@ static jsval_t js_subobs_complete(struct js *js, jsval_t *args, int nargs) {
   if (is_special_object(observer)) {
     jsval_t completeMethod = js_get(js, observer, "complete");
     if (is_callable(completeMethod)) {
-      jsval_t result = js_call_with_this(js, completeMethod, observer, NULL, 0);
+      jsval_t result = sv_vm_call(js->vm, js, completeMethod, observer, NULL, 0, NULL, false);
       if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.complete: %s\n", js_str(js, result));
     }
   }
@@ -175,14 +177,14 @@ static jsval_t js_subobs_complete(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t create_subscription_observer(struct js *js, jsval_t subscription) {
+static jsval_t create_subscription_observer(ant_t *js, jsval_t subscription) {
   jsval_t subobs = js_mkobj(js);
   
   js_set_slot(js, subobs, SLOT_DATA, subscription);
   js_set(js, subobs, "next", js_mkfun(js_subobs_next));
   js_set(js, subobs, "error", js_mkfun(js_subobs_error));
   js_set(js, subobs, "complete", js_mkfun(js_subobs_complete));
-  js_set(js, subobs, get_toStringTag_sym_key(), js_mkstr(js, "SubscriptionObserver", 20));
+  js_set_sym(js, subobs, get_toStringTag_sym(), js_mkstr(js, "SubscriptionObserver", 20));
   
   jsval_t closed_getter = js_mkfun(js_subobs_get_closed);
   js_set_getter_desc(js, subobs, "closed", 6, closed_getter, JS_DESC_E | JS_DESC_C);
@@ -190,7 +192,7 @@ static jsval_t create_subscription_observer(struct js *js, jsval_t subscription)
   return subobs;
 }
 
-static jsval_t js_cleanup_fn(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_cleanup_fn(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t F = js_getcurrentfunc(js);
   jsval_t subscription = js_get_slot(js, F, SLOT_DATA);
@@ -199,15 +201,15 @@ static jsval_t js_cleanup_fn(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t unsubscribe = js_get(js, subscription, "unsubscribe");
   if (is_callable(unsubscribe)) {
-    return js_call_with_this(js, unsubscribe, subscription, NULL, 0);
+    return sv_vm_call(js->vm, js, unsubscribe, subscription, NULL, 0, NULL, false);
   }
   
   return js_mkundef();
 }
 
-static jsval_t execute_subscriber(struct js *js, jsval_t subscriber, jsval_t observer) {
+static jsval_t execute_subscriber(ant_t *js, jsval_t subscriber, jsval_t observer) {
   jsval_t call_args[1] = {observer};
-  jsval_t subscriberResult = js_call(js, subscriber, call_args, 1);
+  jsval_t subscriberResult = sv_vm_call(js->vm, js, subscriber, js_mkundef(), call_args, 1, NULL, false);
   
   if (vtype(subscriberResult) == T_ERR) return subscriberResult;
   if (vtype(subscriberResult) == T_NULL || vtype(subscriberResult) == T_UNDEF) return js_mkundef();
@@ -228,7 +230,7 @@ static jsval_t execute_subscriber(struct js *js, jsval_t subscriber, jsval_t obs
   return js_mkerr_typed(js, JS_ERR_TYPE, "Subscriber must return a function, an object with unsubscribe, or undefined");
 }
 
-static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_observable_subscribe(ant_t *js, jsval_t *args, int nargs) {
   jsval_t O = js_getthis(js);
   
   if (!is_special_object(O)) {
@@ -261,7 +263,7 @@ static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs)
   jsval_t start = js_get(js, observer, "start");
   if (is_callable(start)) {
     jsval_t start_args[1] = {subscription};
-    jsval_t result = js_call_with_this(js, start, observer, start_args, 1);
+    jsval_t result = sv_vm_call(js->vm, js, start, observer, start_args, 1, NULL, false);
     if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in observer.start: %s\n", js_str(js, result));
     }
@@ -274,11 +276,11 @@ static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs)
   if (vtype(subscriberResult) == T_ERR) {
     jsval_t thrown_error = js->thrown_value;
     js->thrown_value = js_mkundef();
-    js->flags &= ~F_THROW;
+    js->thrown_exists = false;
     
     jsval_t error_args[1] = {thrown_error};
     jsval_t error_method = js_get(js, subscriptionObserver, "error");
-    if (is_callable(error_method)) js_call_with_this(js, error_method, subscriptionObserver, error_args, 1);
+    if (is_callable(error_method)) sv_vm_call(js->vm, js, error_method, subscriptionObserver, error_args, 1, NULL, false);
   } else js_set_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP, subscriberResult);
   
   if (subscription_closed(js, subscription)) cleanup_subscription(js, subscription);
@@ -286,12 +288,12 @@ static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs)
   return subscription;
 }
 
-static jsval_t js_observable_symbol_observable(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_observable_symbol_observable(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   return js_getthis(js);
 }
 
-static jsval_t js_observable_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_observable_constructor(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Observable constructor requires a subscriber function");
   }
@@ -310,7 +312,7 @@ static jsval_t js_observable_constructor(struct js *js, jsval_t *args, int nargs
   return observable;
 }
 
-static jsval_t js_of_subscriber(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_of_subscriber(ant_t *js, jsval_t *args, int nargs) {
   jsval_t F = js_getcurrentfunc(js);
   jsval_t items = js_get_slot(js, F, SLOT_DATA);
   
@@ -330,19 +332,19 @@ static jsval_t js_of_subscriber(struct js *js, jsval_t *args, int nargs) {
     jsval_t next = js_get(js, observer, "next");
     if (is_callable(next)) {
       jsval_t next_args[1] = {value};
-      js_call_with_this(js, next, observer, next_args, 1);
+      sv_vm_call(js->vm, js, next, observer, next_args, 1, NULL, false);
     }
     
     if (is_special_object(subscription) && subscription_closed(js, subscription)) return js_mkundef();
   }
   
   jsval_t complete = js_get(js, observer, "complete");
-  if (is_callable(complete)) js_call_with_this(js, complete, observer, NULL, 0);
+  if (is_callable(complete)) sv_vm_call(js->vm, js, complete, observer, NULL, 0, NULL, false);
   
   return js_mkundef();
 }
 
-static jsval_t js_observable_of(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_observable_of(ant_t *js, jsval_t *args, int nargs) {
   jsval_t items = js_mkarr(js);
   for (int i = 0; i < nargs; i++) js_arr_push(js, items, args[i]);
   
@@ -352,7 +354,7 @@ static jsval_t js_observable_of(struct js *js, jsval_t *args, int nargs) {
   return js_observable_constructor(js, ctor_args, 1);
 }
 
-static jsval_t js_from_delegating(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_from_delegating(ant_t *js, jsval_t *args, int nargs) {
   jsval_t F = js_getcurrentfunc(js);
   
   jsval_t observable = js_get_slot(js, F, SLOT_DATA);
@@ -360,13 +362,13 @@ static jsval_t js_from_delegating(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t subscribe = js_get(js, observable, "subscribe");
   if (is_callable(subscribe)) {
-    return js_call_with_this(js, subscribe, observable, args, nargs);
+    return sv_vm_call(js->vm, js, subscribe, observable, args, nargs, NULL, false);
   }
   
   return js_mkundef();
 }
 
-static jsval_t js_from_iteration(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_from_iteration(ant_t *js, jsval_t *args, int nargs) {
   jsval_t F = js_getcurrentfunc(js);
   jsval_t data = js_get_slot(js, F, SLOT_DATA);
   
@@ -382,7 +384,7 @@ static jsval_t js_from_iteration(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Object is not iterable");
   }
   
-  jsval_t iterator = js_call_with_this(js, iteratorMethod, iterable, NULL, 0);
+  jsval_t iterator = sv_vm_call(js->vm, js, iteratorMethod, iterable, NULL, 0, NULL, false);
   if (!is_special_object(iterator)) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Iterator must return an object");
   }
@@ -393,13 +395,13 @@ static jsval_t js_from_iteration(struct js *js, jsval_t *args, int nargs) {
   }
   
   while (true) {
-    jsval_t next = js_call_with_this(js, nextMethod, iterator, NULL, 0);
+    jsval_t next = sv_vm_call(js->vm, js, nextMethod, iterator, NULL, 0, NULL, false);
     if (vtype(next) == T_ERR) return next;
     
     jsval_t done = js_get(js, next, "done");
     if (js_truthy(js, done)) {
       jsval_t complete = js_get(js, observer, "complete");
-      if (is_callable(complete)) js_call_with_this(js, complete, observer, NULL, 0);
+      if (is_callable(complete)) sv_vm_call(js->vm, js, complete, observer, NULL, 0, NULL, false);
       return js_mkundef();
     }
     
@@ -407,18 +409,18 @@ static jsval_t js_from_iteration(struct js *js, jsval_t *args, int nargs) {
     jsval_t obs_next = js_get(js, observer, "next");
     if (is_callable(obs_next)) {
       jsval_t next_args[1] = {nextValue};
-      js_call_with_this(js, obs_next, observer, next_args, 1);
+      sv_vm_call(js->vm, js, obs_next, observer, next_args, 1, NULL, false);
     }
     
     if (is_special_object(subscription) && subscription_closed(js, subscription)) {
       jsval_t returnMethod = js_getprop_fallback(js, iterator, "return");
-      if (is_callable(returnMethod)) js_call_with_this(js, returnMethod, iterator, NULL, 0);
+      if (is_callable(returnMethod)) sv_vm_call(js->vm, js, returnMethod, iterator, NULL, 0, NULL, false);
       return js_mkundef();
     }
   }
 }
 
-static jsval_t js_observable_from(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_observable_from(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "Observable.from requires an argument");
   jsval_t x = args[0];
   
@@ -426,10 +428,10 @@ static jsval_t js_observable_from(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert null or undefined to observable");
   }
   
-  jsval_t observableMethod = js_getprop_proto(js, x, get_observable_sym_key());
+  jsval_t observableMethod = js_get_sym(js, x, get_observable_sym());
   
   if (is_callable(observableMethod)) {
-    jsval_t observable = js_call_with_this(js, observableMethod, x, NULL, 0);
+    jsval_t observable = sv_vm_call(js->vm, js, observableMethod, x, NULL, 0, NULL, false);
     
     if (!is_special_object(observable)) {
       return js_mkerr_typed(js, JS_ERR_TYPE, "@@observable must return an object");
@@ -444,12 +446,12 @@ static jsval_t js_observable_from(struct js *js, jsval_t *args, int nargs) {
     return js_observable_constructor(js, ctor_args, 1);
   }
   
-  jsval_t iteratorMethod = js_get(js, x, get_iterator_sym_key());
+  jsval_t iteratorMethod = js_get_sym(js, x, get_iterator_sym());
   
   if (!is_callable(iteratorMethod) && vtype(x) == T_ARR) {
     jsval_t array_ctor = js_get(js, js_glob(js), "Array");
     jsval_t array_proto = js_get(js, array_ctor, "prototype");
-    iteratorMethod = js_get(js, array_proto, get_iterator_sym_key());
+    iteratorMethod = js_get_sym(js, array_proto, get_iterator_sym());
   }
   
   if (!is_callable(iteratorMethod)) {
@@ -467,15 +469,15 @@ static jsval_t js_observable_from(struct js *js, jsval_t *args, int nargs) {
 }
 
 void init_observable_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t global = js_glob(js);
   
   jsval_t observable_ctor = js_mkobj(js);
   jsval_t observable_proto = js_mkobj(js);
   
   js_set(js, observable_proto, "subscribe", js_mkfun(js_observable_subscribe));
-  js_set(js, observable_proto, get_observable_sym_key(), js_mkfun(js_observable_symbol_observable));
-  js_set(js, observable_proto, get_toStringTag_sym_key(), js_mkstr(js, "Observable", 10));
+  js_set_sym(js, observable_proto, get_observable_sym(), js_mkfun(js_observable_symbol_observable));
+  js_set_sym(js, observable_proto, get_toStringTag_sym(), js_mkstr(js, "Observable", 10));
   
   js_set_slot(js, observable_ctor, SLOT_CFUNC, js_mkfun(js_observable_constructor));
   js_mkprop_fast(js, observable_ctor, "prototype", 9, observable_proto);
diff --git a/src/modules/os.c b/src/modules/os.c
index 636076d..2074524 100644
--- a/src/modules/os.c
+++ b/src/modules/os.c
@@ -48,7 +48,7 @@
 #define OS_DEVNULL "/dev/null"
 #endif
 
-static jsval_t os_arch(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_arch(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #if defined(__x86_64__) || defined(_M_X64)
   return js_mkstr(js, "x64", 3);
@@ -75,7 +75,7 @@ static jsval_t os_arch(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_platform(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_platform(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #if defined(__APPLE__)
   return js_mkstr(js, "darwin", 6);
@@ -96,7 +96,7 @@ static jsval_t os_platform(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_type(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_type(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #if defined(__APPLE__)
   return js_mkstr(js, "Darwin", 6);
@@ -113,7 +113,7 @@ static jsval_t os_type(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_release(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_release(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   OSVERSIONINFOA osvi;
@@ -137,7 +137,7 @@ static jsval_t os_release(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_version(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_version(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   OSVERSIONINFOA osvi;
@@ -161,7 +161,7 @@ static jsval_t os_version(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_machine(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_machine(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   SYSTEM_INFO sysinfo;
@@ -182,7 +182,7 @@ static jsval_t os_machine(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_hostname(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_hostname(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   char hostname[256];
   if (gethostname(hostname, sizeof(hostname)) == 0) {
@@ -191,7 +191,7 @@ static jsval_t os_hostname(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, "", 0);
 }
 
-static jsval_t os_homedir(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_homedir(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   const char *userprofile = getenv("USERPROFILE");
@@ -219,7 +219,7 @@ static jsval_t os_homedir(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_tmpdir(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_tmpdir(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   const char *tmpdir = getenv("TMPDIR");
   if (!tmpdir) tmpdir = getenv("TMP");
@@ -228,7 +228,7 @@ static jsval_t os_tmpdir(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, tmpdir, strlen(tmpdir));
 }
 
-static jsval_t os_endianness(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_endianness(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   uint16_t test = 1;
   if (*(uint8_t *)&test == 1) {
@@ -237,7 +237,7 @@ static jsval_t os_endianness(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, "BE", 2);
 }
 
-static jsval_t os_uptime(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_uptime(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   return js_mknum((double)GetTickCount64() / 1000.0);
@@ -261,7 +261,7 @@ static jsval_t os_uptime(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_totalmem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_totalmem(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   MEMORYSTATUSEX memInfo;
@@ -288,7 +288,7 @@ static jsval_t os_totalmem(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_freemem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_freemem(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   MEMORYSTATUSEX memInfo;
@@ -319,7 +319,7 @@ static jsval_t os_freemem(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_availableParallelism(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_availableParallelism(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef _WIN32
   SYSTEM_INFO sysinfo;
@@ -344,7 +344,7 @@ typedef struct {
   double user, nice, sys, idle, irq;
 } cpu_times_t;
 
-static void push_cpu_entry(struct js *js, jsval_t arr, const char *model, double speed, cpu_times_t *times) {
+static void push_cpu_entry(ant_t *js, jsval_t arr, const char *model, double speed, cpu_times_t *times) {
   jsval_t cpu = js_mkobj(js);
   js_set(js, cpu, "model", js_mkstr(js, model, strlen(model)));
   js_set(js, cpu, "speed", js_mknum(speed));
@@ -361,7 +361,7 @@ static void push_cpu_entry(struct js *js, jsval_t arr, const char *model, double
 }
 
 #ifdef __APPLE__
-static jsval_t os_cpus_darwin(struct js *js) {
+static jsval_t os_cpus_darwin(ant_t *js) {
   jsval_t arr = js_mkarr(js);
   
   natural_t ncpu;
@@ -410,7 +410,7 @@ static char *parse_colon_value(char *line) {
   return colon;
 }
 
-static jsval_t os_cpus_linux(struct js *js) {
+static jsval_t os_cpus_linux(ant_t *js) {
   jsval_t arr = js_mkarr(js);
   char model[256] = "Unknown";
   double speed = 0;
@@ -461,7 +461,7 @@ read_stat:
 }
 #endif
 
-static jsval_t os_cpus(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_cpus(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
 #ifdef __APPLE__
   return os_cpus_darwin(js);
@@ -472,7 +472,7 @@ static jsval_t os_cpus(struct js *js, jsval_t *args, int nargs) {
 #endif
 }
 
-static jsval_t os_loadavg(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_loadavg(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t arr = js_mkarr(js);
   
@@ -498,7 +498,7 @@ static jsval_t os_loadavg(struct js *js, jsval_t *args, int nargs) {
 
 #ifdef _WIN32
 
-static jsval_t os_networkInterfaces(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_networkInterfaces(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t result = js_mkobj(js);
   
@@ -575,7 +575,7 @@ static jsval_t os_networkInterfaces(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t os_userInfo(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_userInfo(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t info = js_mkobj(js);
   
@@ -602,12 +602,12 @@ static jsval_t os_userInfo(struct js *js, jsval_t *args, int nargs) {
   return info;
 }
 
-static jsval_t os_getPriority(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_getPriority(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   return js_mknum(0);
 }
 
-static jsval_t os_setPriority(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_setPriority(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   return js_mkundef();
 }
@@ -635,7 +635,7 @@ static int calc_prefix_len(struct sockaddr *netmask, int family) {
   return prefix;
 }
 
-static void add_iface_entry(struct js *js, jsval_t iface_arr, struct ifaddrs *ifa, int family) {
+static void add_iface_entry(ant_t *js, jsval_t iface_arr, struct ifaddrs *ifa, int family) {
   char addr_str[INET6_ADDRSTRLEN] = "";
   char netmask_str[INET6_ADDRSTRLEN] = "";
   char cidr[128];
@@ -698,7 +698,7 @@ static unsigned char *get_mac_bytes(struct ifaddrs *ifa) {
 #endif
 }
 
-static void apply_mac_to_iface(struct js *js, jsval_t result, const char *name, unsigned char *mac_bytes) {
+static void apply_mac_to_iface(ant_t *js, jsval_t result, const char *name, unsigned char *mac_bytes) {
   char mac_str[18];
   format_mac_address(mac_str, sizeof(mac_str), mac_bytes);
   
@@ -718,7 +718,7 @@ static void apply_mac_to_iface(struct js *js, jsval_t result, const char *name,
   }
 }
 
-static jsval_t os_networkInterfaces(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_networkInterfaces(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t result = js_mkobj(js);
   
@@ -752,7 +752,7 @@ static jsval_t os_networkInterfaces(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t os_userInfo(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_userInfo(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t info = js_mkobj(js);
   
@@ -781,7 +781,7 @@ static jsval_t os_userInfo(struct js *js, jsval_t *args, int nargs) {
   return info;
 }
 
-static jsval_t os_getPriority(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_getPriority(ant_t *js, jsval_t *args, int nargs) {
   int pid = 0;
   if (nargs > 0 && vtype(args[0]) == T_NUM) {
     pid = (int)js_getnum(args[0]);
@@ -795,7 +795,7 @@ static jsval_t os_getPriority(struct js *js, jsval_t *args, int nargs) {
   return js_mknum((double)priority);
 }
 
-static jsval_t os_setPriority(struct js *js, jsval_t *args, int nargs) {
+static jsval_t os_setPriority(ant_t *js, jsval_t *args, int nargs) {
   int pid = 0;
   int priority = 0;
   
@@ -822,7 +822,7 @@ static jsval_t os_setPriority(struct js *js, jsval_t *args, int nargs) {
 
 #endif
 
-static void add_signal_constants(struct js *js, jsval_t signals) {
+static void add_signal_constants(ant_t *js, jsval_t signals) {
 #ifdef SIGHUP
   js_set(js, signals, "SIGHUP", js_mknum(SIGHUP));
 #endif
@@ -915,7 +915,7 @@ static void add_signal_constants(struct js *js, jsval_t signals) {
 #endif
 }
 
-static void add_errno_constants(struct js *js, jsval_t errn) {
+static void add_errno_constants(ant_t *js, jsval_t errn) {
   js_set(js, errn, "E2BIG", js_mknum(E2BIG));
   js_set(js, errn, "EACCES", js_mknum(EACCES));
   js_set(js, errn, "EADDRINUSE", js_mknum(EADDRINUSE));
@@ -984,7 +984,7 @@ static void add_errno_constants(struct js *js, jsval_t errn) {
   js_set(js, errn, "EXDEV", js_mknum(EXDEV));
 }
 
-static void add_priority_constants(struct js *js, jsval_t priority) {
+static void add_priority_constants(ant_t *js, jsval_t priority) {
   js_set(js, priority, "PRIORITY_LOW", js_mknum(19));
   js_set(js, priority, "PRIORITY_BELOW_NORMAL", js_mknum(10));
   js_set(js, priority, "PRIORITY_NORMAL", js_mknum(0));
@@ -993,7 +993,7 @@ static void add_priority_constants(struct js *js, jsval_t priority) {
   js_set(js, priority, "PRIORITY_HIGHEST", js_mknum(-20));
 }
 
-static void add_dlopen_constants(struct js *js, jsval_t dlopen_obj) {
+static void add_dlopen_constants(ant_t *js, jsval_t dlopen_obj) {
 #ifdef RTLD_LAZY
   js_set(js, dlopen_obj, "RTLD_LAZY", js_mknum(RTLD_LAZY));
 #endif
@@ -1011,7 +1011,7 @@ static void add_dlopen_constants(struct js *js, jsval_t dlopen_obj) {
 #endif
 }
 
-jsval_t os_library(struct js *js) {
+jsval_t os_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
   
   js_set(js, lib, "EOL", js_mkstr(js, OS_EOL, strlen(OS_EOL)));
@@ -1055,7 +1055,7 @@ jsval_t os_library(struct js *js) {
   js_set(js, constants, "dlopen", dlopen_obj);
   js_set(js, constants, "UV_UDP_REUSEADDR", js_mknum(4));
   js_set(js, lib, "constants", constants);
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "os", 2));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "os", 2));
 
   return lib;
 }
diff --git a/src/modules/path.c b/src/modules/path.c
index 4972bf1..5053ca3 100644
--- a/src/modules/path.c
+++ b/src/modules/path.c
@@ -38,7 +38,7 @@ static char* normalize_separators(const char *path, size_t len) {
   return result;
 }
 
-static jsval_t builtin_path_basename(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_basename(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "basename() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "basename() path must be a string");
   
@@ -66,7 +66,7 @@ static jsval_t builtin_path_basename(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.dirname(path)
-static jsval_t builtin_path_dirname(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_dirname(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "dirname() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "dirname() path must be a string");
   
@@ -84,7 +84,7 @@ static jsval_t builtin_path_dirname(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.extname(path)
-static jsval_t builtin_path_extname(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_extname(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "extname() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "extname() path must be a string");
   
@@ -192,7 +192,7 @@ fail:
 }
 
 // path.normalize(path)
-static jsval_t builtin_path_normalize(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_normalize(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "normalize() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "normalize() path must be a string");
   
@@ -209,7 +209,7 @@ static jsval_t builtin_path_normalize(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.join(...paths)
-static jsval_t builtin_path_join(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_join(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkstr(js, ".", 1);
   
   size_t total_len = 0;
@@ -280,7 +280,7 @@ static jsval_t builtin_path_join(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.resolve(...paths)
-static jsval_t builtin_path_resolve(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_resolve(ant_t *js, jsval_t *args, int nargs) {
   char cwd[PATH_MAX];
   if (getcwd(cwd, sizeof(cwd)) == NULL) {
     return js_mkerr(js, "Failed to get current working directory");
@@ -321,7 +321,7 @@ static jsval_t builtin_path_resolve(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.relative(from, to)
-static jsval_t builtin_path_relative(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_relative(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "relative() requires from and to arguments");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "relative() from must be a string");
   if (vtype(args[1]) != T_STR) return js_mkerr(js, "relative() to must be a string");
@@ -337,7 +337,7 @@ static jsval_t builtin_path_relative(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.isAbsolute(path)
-static jsval_t builtin_path_isAbsolute(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_isAbsolute(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "isAbsolute() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "isAbsolute() path must be a string");
   
@@ -355,7 +355,7 @@ static jsval_t builtin_path_isAbsolute(struct js *js, jsval_t *args, int nargs)
 }
 
 // path.parse(path)
-static jsval_t builtin_path_parse(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_parse(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "parse() requires a path argument");
   if (vtype(args[0]) != T_STR) return js_mkerr(js, "parse() path must be a string");
   
@@ -397,7 +397,7 @@ static jsval_t builtin_path_parse(struct js *js, jsval_t *args, int nargs) {
 }
 
 // path.format(pathObject)
-static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_path_format(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "format() requires a path object argument");
   if (!is_special_object(args[0])) return js_mkerr(js, "format() argument must be an object");
   
@@ -460,7 +460,7 @@ static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, result, pos);
 }
 
-jsval_t path_library(struct js *js) {
+jsval_t path_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
   
   js_set(js, lib, "basename", js_mkfun(builtin_path_basename));
@@ -477,7 +477,7 @@ jsval_t path_library(struct js *js) {
   js_set(js, lib, "sep", js_mkstr(js, PATH_SEP_STR, 1));
   char delimiter_str[2] = {PATH_DELIMITER, '\0'};
   js_set(js, lib, "delimiter", js_mkstr(js, delimiter_str, 1));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "path", 4));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "path", 4));
   
   return lib;
 }
diff --git a/src/modules/performance.c b/src/modules/performance.c
index f60caf1..c984d0a 100644
--- a/src/modules/performance.c
+++ b/src/modules/performance.c
@@ -28,20 +28,27 @@ static double get_current_time_ms(void) {
 }
 
 // performance.now()
-static jsval_t js_performance_now(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_performance_now(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   double now = get_current_time_ms() - time_origin_ms;
   return js_mknum(now);
 }
 
 // performance.timeOrigin
-static jsval_t js_performance_time_origin(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_performance_time_origin(ant_t *js, jsval_t *args, int nargs) {
   (void) args; (void) nargs;
   return js_mknum(time_origin_ms);
 }
 
+jsval_t perf_hooks_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+  js_set(js, lib, "performance", js_get(js, js_glob(js), "performance"));
+  js_set_sym(js, lib, get_toStringTag_sym(), ANT_STRING("perf_hooks"));
+  return lib;
+}
+
 void init_performance_module() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   
   jsval_t glob = js_glob(js);
   jsval_t perf_obj = js_mkobj(js);
@@ -51,6 +58,6 @@ void init_performance_module() {
   js_set(js, perf_obj, "now", js_mkfun(js_performance_now));
   js_set(js, perf_obj, "timeOrigin", js_mknum(time_origin_ms));
   
-  js_set(js, perf_obj, get_toStringTag_sym_key(), ANT_STRING("Performance"));
+  js_set_sym(js, perf_obj, get_toStringTag_sym(), ANT_STRING("Performance"));
   js_set(js, glob, "performance", perf_obj);
 }
diff --git a/src/modules/process.c b/src/modules/process.c
index 2cf2366..8b770b6 100644
--- a/src/modules/process.c
+++ b/src/modules/process.c
@@ -28,12 +28,16 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "utils.h"
 #include "internal.h"
+#include "descriptors.h"
 #include "runtime.h"
-#include "utils.h"
+#include "silver/engine.h"
 
 #include "modules/process.h"
 #include "modules/symbol.h"
+#include "modules/buffer.h"
+#include "modules/napi.h"
 
 #ifndef _WIN32
 extern char **environ;
@@ -267,7 +271,7 @@ void emit_process_event(const char *event_type, jsval_t *args, int nargs) {
   
   while (i < evt->listener_count) {
     ProcessEventListener *listener = &evt->listeners[i];
-    js_call(rt->js, listener->listener, args, nargs);
+    sv_vm_call(rt->js->vm, rt->js, listener->listener, js_mkundef(), args, nargs, NULL, false);
     
     if (listener->once) {
       for (int j = i; j < evt->listener_count - 1; j++) {
@@ -304,7 +308,7 @@ static void emit_stdio_event(ProcessEventType **events, const char *event_type,
   int i = 0;
   while (i < evt->listener_count) {
     ProcessEventListener *listener = &evt->listeners[i];
-    js_call(rt->js, listener->listener, args, nargs);
+    sv_vm_call(rt->js->vm, rt->js, listener->listener, js_mkundef(), args, nargs, NULL, false);
     if (listener->once) {
       for (int j = i; j < evt->listener_count - 1; j++) 
         evt->listeners[j] = evt->listeners[j + 1];
@@ -405,7 +409,7 @@ static const char *stdin_escape_name(const char *seq, int len) {
 }
 
 static void emit_keypress_event(
-  struct js *js,
+  ant_t *js,
   const char *str,
   size_t str_len,
   const char *name,
@@ -436,7 +440,7 @@ static void emit_keypress_event(
   emit_stdio_event(&stdin_events, "keypress", args, 2);
 }
 
-static void process_keypress_data(struct js *js, const char *data, size_t len) {
+static void process_keypress_data(ant_t *js, const char *data, size_t len) {
   for (size_t i = 0; i < len; i++) {
     unsigned char c = (unsigned char)data[i];
 
@@ -602,7 +606,11 @@ static void stdin_alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_bu
 static void on_stdin_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
   (void)stream;
   if (nread > 0 && rt->js) {
-    jsval_t data_val = js_mkstr(rt->js, buf->base, (size_t)nread);
+    ArrayBufferData *ab = create_array_buffer_data((size_t)nread);
+    if (ab) memcpy(ab->data, buf->base, (size_t)nread);
+    jsval_t data_val = ab
+      ? create_typed_array(rt->js, TYPED_ARRAY_UINT8, ab, 0, (size_t)nread, "Buffer")
+      : js_mkstr(rt->js, buf->base, (size_t)nread);
     emit_stdio_event(&stdin_events, "data", &data_val, 1);
     if (stdin_state.keypress_enabled) process_keypress_data(rt->js, buf->base, (size_t)nread);
   }
@@ -1614,6 +1622,10 @@ static jsval_t process_get_max_listeners(ant_t *js, jsval_t *args, int nargs) {
   return js_mknum(max_listeners);
 }
 
+jsval_t process_library(ant_t *js) {
+  return js_get(js, js_glob(js), "process");
+}
+
 void init_process_module() {
   ant_t *js = rt->js;
   jsval_t global = js_glob(js);
@@ -1647,6 +1659,7 @@ void init_process_module() {
   jsval_t hrtime_fn = js_heavy_mkfun(js, process_hrtime, js_mkundef());
   js_set(js, hrtime_fn, "bigint", js_mkfun(process_hrtime_bigint));
   js_set(js, process_proto, "hrtime", hrtime_fn);
+  js_set(js, process_proto, "dlopen", js_mkfun(napi_process_dlopen_js));
   
 #ifndef _WIN32
   js_set(js, process_proto, "getuid", js_mkfun(process_getuid));
@@ -1662,7 +1675,7 @@ void init_process_module() {
   js_set(js, process_proto, "initgroups", js_mkfun(process_initgroups));
 #endif
   
-  js_set(js, process_proto, get_toStringTag_sym_key(), js_mkstr(js, "process", 7));
+  js_set_sym(js, process_proto, get_toStringTag_sym(), js_mkstr(js, "process", 7));
   
   jsval_t process_obj = js_mkobj(js);
   jsval_t env_obj = js_mkobj(js);
@@ -1741,7 +1754,7 @@ void init_process_module() {
   js_set(js, stdin_proto, "removeListener", js_mkfun(js_stdin_remove_listener));
   js_set(js, stdin_proto, "off", js_mkfun(js_stdin_remove_listener));
   js_set(js, stdin_proto, "removeAllListeners", js_mkfun(js_stdin_remove_all_listeners));
-  js_set(js, stdin_proto, get_toStringTag_sym_key(), js_mkstr(js, "ReadStream", 10));
+  js_set_sym(js, stdin_proto, get_toStringTag_sym(), js_mkstr(js, "ReadStream", 10));
   
   jsval_t stdin_obj = js_mkobj(js);
   js_set_proto(js, stdin_obj, stdin_proto);
@@ -1756,7 +1769,7 @@ void init_process_module() {
   js_set(js, stdout_proto, "off", js_mkfun(js_stdout_remove_listener));
   js_set(js, stdout_proto, "removeAllListeners", js_mkfun(js_stdout_remove_all_listeners));
   js_set(js, stdout_proto, "getWindowSize", js_mkfun(js_stdout_get_window_size));
-  js_set(js, stdout_proto, get_toStringTag_sym_key(), js_mkstr(js, "WriteStream", 11));
+  js_set_sym(js, stdout_proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11));
   
   jsval_t stdout_obj = js_mkobj(js);
   js_set_proto(js, stdout_obj, stdout_proto);
@@ -1772,7 +1785,7 @@ void init_process_module() {
   js_set(js, stderr_proto, "removeListener", js_mkfun(js_stderr_remove_listener));
   js_set(js, stderr_proto, "off", js_mkfun(js_stderr_remove_listener));
   js_set(js, stderr_proto, "removeAllListeners", js_mkfun(js_stderr_remove_all_listeners));
-  js_set(js, stderr_proto, get_toStringTag_sym_key(), js_mkstr(js, "WriteStream", 11));
+  js_set_sym(js, stderr_proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11));
   
   jsval_t stderr_obj = js_mkobj(js);
   js_set_proto(js, stderr_obj, stderr_proto);
diff --git a/src/modules/readline.c b/src/modules/readline.c
index 24ad07a..cc51adc 100644
--- a/src/modules/readline.c
+++ b/src/modules/readline.c
@@ -25,6 +25,8 @@
 #include "errors.h"
 #include "runtime.h"
 #include "internal.h"
+#include "descriptors.h"
+#include "silver/engine.h"
 
 #include "modules/readline.h"
 #include "modules/process.h"
@@ -174,7 +176,7 @@ static RLEventType *find_or_create_event_type(rl_interface_t *iface, const char
   return evt;
 }
 
-static void emit_event(struct js *js, rl_interface_t *iface, const char *event_type, jsval_t *args, int nargs) {
+static void emit_event(ant_t *js, rl_interface_t *iface, const char *event_type, jsval_t *args, int nargs) {
   RLEventType *evt = NULL;
   HASH_FIND_STR(iface->events, event_type, evt);
   
@@ -183,7 +185,7 @@ static void emit_event(struct js *js, rl_interface_t *iface, const char *event_t
   int i = 0;
   while (i < evt->listener_count) {
     RLEventListener *listener = &evt->listeners[i];
-    js_call(js, listener->listener, args, nargs);
+    sv_vm_call(js->vm, js, listener->listener, js_mkundef(), args, nargs, NULL, false);
     
     if (listener->once) {
       for (int j = i; j < evt->listener_count - 1; j++) {
@@ -194,7 +196,7 @@ static void emit_event(struct js *js, rl_interface_t *iface, const char *event_t
   }
 }
 
-static jsval_t get_history_array(struct js *js, rl_interface_t *iface) {
+static jsval_t get_history_array(ant_t *js, rl_interface_t *iface) {
   jsval_t arr = js_mkarr(js);
   for (int i = 0; i < iface->history.count; i++) {
     js_arr_push(js, arr, js_mkstr(js, iface->history.lines[i], strlen(iface->history.lines[i])));
@@ -202,7 +204,7 @@ static jsval_t get_history_array(struct js *js, rl_interface_t *iface) {
   return arr;
 }
 
-static void emit_history_event(struct js *js, rl_interface_t *iface) {
+static void emit_history_event(ant_t *js, rl_interface_t *iface) {
   jsval_t history_arr = get_history_array(js, iface);
   emit_event(js, iface, "history", &history_arr, 1);
 }
@@ -438,7 +440,7 @@ static void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *b
 
 static void on_stdin_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
   rl_interface_t *iface = (rl_interface_t *)stream->data;
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
 
   if (!iface) {
     if (buf->base) free(buf->base);
@@ -503,7 +505,7 @@ static void on_stdin_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *bu
       emit_event(js, iface, "line", &line_val, 1);
       
       if (vtype(iface->pending_question_resolve) == T_FUNC) {
-        js_call(js, iface->pending_question_resolve, &line_val, 1);
+        sv_vm_call(js->vm, js, iface->pending_question_resolve, js_mkundef(), &line_val, 1, NULL, false);
         iface->pending_question_resolve = js_mkundef();
         iface->pending_question_reject = js_mkundef();
       }
@@ -586,7 +588,7 @@ static void stop_reading(rl_interface_t *iface) {
   iface->reading = false;
 }
 
-static void process_line(struct js *js, rl_interface_t *iface) {
+static void process_line(ant_t *js, rl_interface_t *iface) {
   char *line = strdup(iface->line_buffer);
   
   rl_history_add(&iface->history, line, iface->remove_history_duplicates);
@@ -596,7 +598,7 @@ static void process_line(struct js *js, rl_interface_t *iface) {
   emit_event(js, iface, "line", &line_val, 1);
   
   if (vtype(iface->pending_question_resolve) == T_FUNC) {
-    js_call(js, iface->pending_question_resolve, &line_val, 1);
+    sv_vm_call(js->vm, js, iface->pending_question_resolve, js_mkundef(), &line_val, 1, NULL, false);
     iface->pending_question_resolve = js_mkundef();
     iface->pending_question_reject = js_mkundef();
   }
@@ -608,7 +610,7 @@ static void process_line(struct js *js, rl_interface_t *iface) {
   free(line);
 }
 
-static rl_interface_t *get_interface(struct js *js, jsval_t this_obj) {
+static rl_interface_t *get_interface(ant_t *js, jsval_t this_obj) {
   jsval_t id_val = js_get(js, this_obj, "_rl_id");
   if (vtype(id_val) != T_NUM) return NULL;
   
@@ -618,7 +620,7 @@ static rl_interface_t *get_interface(struct js *js, jsval_t this_obj) {
   return iface;
 }
 
-static jsval_t rl_interface_on(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_on(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -642,7 +644,7 @@ static jsval_t rl_interface_on(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t rl_interface_once(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_once(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -666,7 +668,7 @@ static jsval_t rl_interface_once(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t rl_interface_off(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_off(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -693,7 +695,7 @@ static jsval_t rl_interface_off(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t rl_interface_emit(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_emit(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -707,7 +709,7 @@ static jsval_t rl_interface_emit(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t rl_interface_close(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_close(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -732,7 +734,7 @@ static jsval_t rl_interface_close(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t rl_interface_pause(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_pause(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -748,7 +750,7 @@ static jsval_t rl_interface_pause(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t rl_interface_resume(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_resume(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -764,7 +766,7 @@ static jsval_t rl_interface_resume(struct js *js, jsval_t *args, int nargs) {
   return this_obj;
 }
 
-static jsval_t rl_interface_prompt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_prompt(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -794,7 +796,7 @@ static jsval_t rl_interface_prompt(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t rl_interface_set_prompt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_set_prompt(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -810,7 +812,7 @@ static jsval_t rl_interface_set_prompt(struct js *js, jsval_t *args, int nargs)
   return js_mkundef();
 }
 
-static jsval_t rl_interface_get_prompt(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_get_prompt(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -861,7 +863,7 @@ static void process_key_sequence(rl_interface_t *iface, const char *name, bool c
   }
 }
 
-static jsval_t rl_interface_write(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_write(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -916,7 +918,7 @@ static jsval_t rl_interface_write(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t rl_interface_line_getter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_line_getter(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -925,7 +927,7 @@ static jsval_t rl_interface_line_getter(struct js *js, jsval_t *args, int nargs)
   return js_mkstr(js, iface->line_buffer, strlen(iface->line_buffer));
 }
 
-static jsval_t rl_interface_cursor_getter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_cursor_getter(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -934,7 +936,7 @@ static jsval_t rl_interface_cursor_getter(struct js *js, jsval_t *args, int narg
   return js_mknum((double)iface->line_pos);
 }
 
-static jsval_t rl_interface_question_callback(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_question_callback(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -964,7 +966,7 @@ static jsval_t rl_interface_question_callback(struct js *js, jsval_t *args, int
   return js_mkundef();
 }
 
-static jsval_t rl_interface_question_promise(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_question_promise(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
   
@@ -985,7 +987,7 @@ static jsval_t rl_interface_question_promise(struct js *js, jsval_t *args, int n
   return promise;
 }
 
-static jsval_t rl_interface_get_cursor_pos(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_get_cursor_pos(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -1022,7 +1024,7 @@ static jsval_t rl_interface_get_cursor_pos(struct js *js, jsval_t *args, int nar
   return result;
 }
 
-static jsval_t rl_interface_closed_getter(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_closed_getter(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -1031,7 +1033,7 @@ static jsval_t rl_interface_closed_getter(struct js *js, jsval_t *args, int narg
   return js_bool(iface->closed);
 }
 
-static jsval_t rl_interface_async_iterator(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_interface_async_iterator(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t this_obj = js_getthis(js);
   rl_interface_t *iface = get_interface(js, this_obj);
@@ -1065,7 +1067,7 @@ static void free_interface(rl_interface_t *iface) {
   free(iface);
 }
 
-static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_create_interface(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "createInterface requires options");
   
   jsval_t options = args[0];
@@ -1174,13 +1176,13 @@ static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
   js_set_getter_desc(js, obj, "closed", 6, js_mkfun(rl_interface_closed_getter), JS_DESC_E | JS_DESC_C);
   
   js_set(js, obj, "terminal", js_bool(iface->terminal));
-  js_set(js, obj, get_asyncIterator_sym_key(), js_mkfun(rl_interface_async_iterator));
-  js_set(js, obj, get_toStringTag_sym_key(), js_mkstr(js, "Interface", 9));
+  js_set_sym(js, obj, get_asyncIterator_sym(), js_mkfun(rl_interface_async_iterator));
+  js_set_sym(js, obj, get_toStringTag_sym(), js_mkstr(js, "Interface", 9));
   
   return obj;
 }
 
-static jsval_t rl_create_interface_promises(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_create_interface_promises(ant_t *js, jsval_t *args, int nargs) {
   jsval_t iface_obj = rl_create_interface(js, args, nargs);
   if (vtype(iface_obj) == T_ERR) return iface_obj;
   js_set(js, iface_obj, "question", js_mkfun(rl_interface_question_promise));
@@ -1188,7 +1190,7 @@ static jsval_t rl_create_interface_promises(struct js *js, jsval_t *args, int na
   return iface_obj;
 }
 
-static jsval_t rl_clear_line(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_clear_line(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_false;
   int dir = (int)js_getnum(args[1]);
   
@@ -1206,7 +1208,7 @@ static jsval_t rl_clear_line(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t rl_clear_screen_down(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_clear_screen_down(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   
   printf("\033[J");
@@ -1215,7 +1217,7 @@ static jsval_t rl_clear_screen_down(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t rl_cursor_to(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_cursor_to(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_false;
   int x = (int)js_getnum(args[1]);
   
@@ -1230,7 +1232,7 @@ static jsval_t rl_cursor_to(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t rl_move_cursor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_move_cursor(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) return js_false;
   
   int dx = (int)js_getnum(args[1]);
@@ -1246,7 +1248,7 @@ static jsval_t rl_move_cursor(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t rl_emit_keypress_events(struct js *js, jsval_t *args, int nargs) {
+static jsval_t rl_emit_keypress_events(ant_t *js, jsval_t *args, int nargs) {
   if (nargs > 0) {
     jsval_t stdin_obj = js_get(js, js_get(js, js_glob(js), "process"), "stdin");
     if (stdin_obj != args[0]) {
@@ -1282,7 +1284,7 @@ void readline_gc_update_roots(GC_OP_VAL_ARGS) {
   }
 }
 
-jsval_t readline_library(struct js *js) {
+jsval_t readline_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
 
   js_set(js, lib, "createInterface", js_mkfun(rl_create_interface));
@@ -1291,12 +1293,12 @@ jsval_t readline_library(struct js *js) {
   js_set(js, lib, "cursorTo", js_mkfun(rl_cursor_to));
   js_set(js, lib, "moveCursor", js_mkfun(rl_move_cursor));
   js_set(js, lib, "emitKeypressEvents", js_mkfun(rl_emit_keypress_events));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "readline", 8));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "readline", 8));
   
   return lib;
 }
 
-jsval_t readline_promises_library(struct js *js) {
+jsval_t readline_promises_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
 
   js_set(js, lib, "createInterface", js_mkfun(rl_create_interface_promises));
@@ -1305,7 +1307,7 @@ jsval_t readline_promises_library(struct js *js) {
   js_set(js, lib, "cursorTo", js_mkfun(rl_cursor_to));
   js_set(js, lib, "moveCursor", js_mkfun(rl_move_cursor));
   js_set(js, lib, "emitKeypressEvents", js_mkfun(rl_emit_keypress_events));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "readline/promises", 17));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "readline/promises", 17));
   
   return lib;
 }
diff --git a/src/modules/reflect.c b/src/modules/reflect.c
index f0ac362..afed5fb 100644
--- a/src/modules/reflect.c
+++ b/src/modules/reflect.c
@@ -5,11 +5,12 @@
 #include "errors.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/engine.h"
 
 #include "modules/reflect.h"
 #include "modules/symbol.h"
 
-static jsval_t reflect_get(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_get(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkundef();
   
   jsval_t target = args[0];
@@ -26,7 +27,7 @@ static jsval_t reflect_get(struct js *js, jsval_t *args, int nargs) {
   return js_get(js, target, key_str);
 }
 
-static jsval_t reflect_set(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_set(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) return js_false;
   
   jsval_t target = args[0];
@@ -45,7 +46,7 @@ static jsval_t reflect_set(struct js *js, jsval_t *args, int nargs) {
   return js_true; 
 }
 
-static jsval_t reflect_has(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_has(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_false;
   
   jsval_t target = args[0];
@@ -64,7 +65,7 @@ static jsval_t reflect_has(struct js *js, jsval_t *args, int nargs) {
   return js_bool(off > 0);
 }
 
-static jsval_t reflect_delete_property(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_delete_property(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_false;
   
   jsval_t target = args[0];
@@ -82,7 +83,7 @@ static jsval_t reflect_delete_property(struct js *js, jsval_t *args, int nargs)
   return js_bool(deleted);
 }
 
-static jsval_t reflect_own_keys(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_own_keys(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkarr(js);
   
   jsval_t target = args[0];
@@ -106,7 +107,7 @@ static jsval_t reflect_own_keys(struct js *js, jsval_t *args, int nargs) {
   return keys_arr;
 }
 
-static jsval_t reflect_construct(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_construct(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "Reflect.construct requires at least 2 arguments");
   }
@@ -147,8 +148,8 @@ static jsval_t reflect_construct(struct js *js, jsval_t *args, int nargs) {
 
   jsval_t saved_new_target = js->new_target;
   js->new_target = new_target;
-  
-  jsval_t result = js_call_with_this(js, target, new_obj, call_args, arg_count);
+
+  jsval_t result = sv_vm_call(js->vm, js, target, new_obj, call_args, arg_count, NULL, true);
   js->new_target = saved_new_target;
   
   if (call_args) free(call_args);
@@ -157,7 +158,7 @@ static jsval_t reflect_construct(struct js *js, jsval_t *args, int nargs) {
   return new_obj;
 }
 
-static jsval_t reflect_apply(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_apply(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) {
     return js_mkerr(js, "Reflect.apply requires 3 arguments");
   }
@@ -188,13 +189,13 @@ static jsval_t reflect_apply(struct js *js, jsval_t *args, int nargs) {
     }
   }
   
-  jsval_t result = js_call_with_this(js, target, this_arg, call_args, arg_count);
+  jsval_t result = sv_vm_call(js->vm, js, target, this_arg, call_args, arg_count, NULL, false);
   
   if (call_args) free(call_args);
   return result;
 }
 
-static jsval_t reflect_get_own_property_descriptor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_get_own_property_descriptor(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkundef();
   
   jsval_t target = args[0];
@@ -222,7 +223,7 @@ static jsval_t reflect_get_own_property_descriptor(struct js *js, jsval_t *args,
   return desc;
 }
 
-static jsval_t reflect_define_property(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_define_property(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 3) return js_false;
   
   jsval_t target = args[0];
@@ -244,7 +245,7 @@ static jsval_t reflect_define_property(struct js *js, jsval_t *args, int nargs)
   return js_true;
 }
 
-static jsval_t reflect_get_prototype_of(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_get_prototype_of(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Reflect.getPrototypeOf requires an argument");
   }
@@ -258,7 +259,7 @@ static jsval_t reflect_get_prototype_of(struct js *js, jsval_t *args, int nargs)
   return js_get_proto(js, target);
 }
 
-static jsval_t reflect_set_prototype_of(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_set_prototype_of(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_false;
   
   jsval_t target = args[0];
@@ -274,7 +275,7 @@ static jsval_t reflect_set_prototype_of(struct js *js, jsval_t *args, int nargs)
   return js_true;
 }
 
-static jsval_t reflect_is_extensible(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_is_extensible(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_false;
   
   jsval_t target = args[0];
@@ -289,7 +290,7 @@ static jsval_t reflect_is_extensible(struct js *js, jsval_t *args, int nargs) {
   return js_true;
 }
 
-static jsval_t reflect_prevent_extensions(struct js *js, jsval_t *args, int nargs) {
+static jsval_t reflect_prevent_extensions(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_false;
   
   jsval_t target = args[0];
@@ -302,7 +303,7 @@ static jsval_t reflect_prevent_extensions(struct js *js, jsval_t *args, int narg
 }
 
 void init_reflect_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t reflect_obj = js_mkobj(js);
   
   js_set(js, reflect_obj, "get", js_mkfun(reflect_get));
@@ -319,6 +320,6 @@ void init_reflect_module(void) {
   js_set(js, reflect_obj, "isExtensible", js_mkfun(reflect_is_extensible));
   js_set(js, reflect_obj, "preventExtensions", js_mkfun(reflect_prevent_extensions));
   
-  js_set(js, reflect_obj, get_toStringTag_sym_key(), js_mkstr(js, "Reflect", 7));
+  js_set_sym(js, reflect_obj, get_toStringTag_sym(), js_mkstr(js, "Reflect", 7));
   js_set(js, js_glob(js), "Reflect", reflect_obj);
 }
diff --git a/src/modules/regex.c b/src/modules/regex.c
new file mode 100644
index 0000000..aa32fe9
--- /dev/null
+++ b/src/modules/regex.c
@@ -0,0 +1,1551 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "ant.h"
+#include "errors.h"
+#include "runtime.h"
+#include "internal.h"
+#include "silver/engine.h"
+#include "arena.h"
+#include "utils.h"
+#include "gc.h"
+#include "utf8.h"
+#include "descriptors.h"
+
+#include "escape.h"
+#include "modules/regex.h"
+#include "modules/symbol.h"
+
+#include <pcre2.h>
+
+typedef struct {
+  jsoff_t obj_offset;
+  pcre2_code *code;
+  pcre2_match_data *match_data;
+} regex_cache_entry_t;
+
+static regex_cache_entry_t *regex_cache = NULL;
+static size_t regex_cache_count = 0;
+static size_t regex_cache_cap = 0;
+
+static void update_regexp_statics(ant_t *js, const char *str_ptr, PCRE2_SIZE *ovector, uint32_t ovcount) {
+  jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
+  if (is_err(regexp_ctor) || vtype(regexp_ctor) == T_UNDEF) return;
+
+  jsval_t empty = js_mkstr(js, "", 0);
+  for (int i = 1; i <= 9; i++) {
+    char key[3] = {'$', (char)('0' + i), '\0'};
+    jsval_t val = empty;
+    if ((uint32_t)i < ovcount && ovector[2*i] != PCRE2_UNSET)
+      val = js_mkstr(js, str_ptr + ovector[2*i], ovector[2*i+1] - ovector[2*i]);
+    js_set(js, regexp_ctor, key, val);
+  }
+
+  jsval_t match0 = empty;
+  if (ovcount > 0 && ovector[0] != PCRE2_UNSET)
+    match0 = js_mkstr(js, str_ptr + ovector[0], ovector[1] - ovector[0]);
+  js_set(js, regexp_ctor, "lastMatch", match0);
+  js_set(js, regexp_ctor, "$&", match0);
+}
+
+static inline bool is_pcre2_passthrough_escape(char c) {
+switch (c) {
+  case 'd': case 'D': case 'w': case 'W': case 's': case 'S':
+  case 'b': case 'B': case 'n': case 'r': case 't': case 'f':
+  case '1': case '2': case '3': case '4': case '5':
+  case '6': case '7': case '8': case '9':
+  case '.': case '*': case '+': case '?':
+  case '(': case ')': case '[': case ']':
+  case '{': case '}': case '|': case '^':
+  case '$': case '\\': case '/': case '-': return true;
+  default: return false;
+}}
+
+static inline bool is_class_shorthand(char c) {
+  return c == 'w' || c == 'W' || c == 'd' || c == 'D' || c == 's' || c == 'S';
+}
+
+size_t js_to_pcre2_pattern(const char *src, size_t src_len, char *dst, size_t dst_size) {
+  size_t di = 0;
+  bool in_charclass = false;
+
+#define OUT(ch) do { if (di < dst_size - 1) dst[di++] = (ch); } while(0)
+
+  for (size_t si = 0; si < src_len && di < dst_size - 1; si++) {
+    if (src[si] == '[' && !in_charclass) {
+      in_charclass = true;
+      OUT('[');
+      continue;
+    }
+    if (src[si] == ']' && in_charclass) {
+      in_charclass = false;
+      OUT(']');
+      continue;
+    }
+
+    if (in_charclass && src[si] == '-' && si > 0 && src[si - 1] != '[' &&
+        si + 1 < src_len && src[si + 1] != ']') {
+      bool prev_is_shorthand = (si >= 2 && src[si - 2] == '\\' && is_class_shorthand(src[si - 1]));
+      bool next_is_shorthand = (si + 2 < src_len && src[si + 1] == '\\' && is_class_shorthand(src[si + 2]));
+      if (prev_is_shorthand || next_is_shorthand) {
+        OUT('\\'); OUT('-');
+        continue;
+      }
+      OUT('-');
+      continue;
+    }
+
+    if (src[si] != '\\' || si + 1 >= src_len) {
+      OUT(src[si]);
+      continue;
+    }
+
+    char next = src[si + 1];
+
+    if (next == 'v') {
+      OUT('\\'); OUT('x'); OUT('{'); OUT('0'); OUT('b'); OUT('}');
+      si++;
+      continue;
+    }
+
+    if (next == 'u' && si + 2 < src_len && src[si + 2] == '{') {
+      size_t brace_start = si + 3;
+      size_t brace_end = brace_start;
+      while (brace_end < src_len && src[brace_end] != '}' && is_xdigit(src[brace_end])) brace_end++;
+      if (brace_end < src_len && src[brace_end] == '}' && brace_end > brace_start) {
+        OUT('\\'); OUT('x'); OUT('{');
+        for (size_t k = brace_start; k < brace_end; k++) OUT(src[k]);
+        OUT('}');
+        si = brace_end;
+        continue;
+      }
+    }
+
+    if (next == 'u' && si + 5 < src_len &&
+        is_xdigit(src[si+2]) && is_xdigit(src[si+3]) &&
+        is_xdigit(src[si+4]) && is_xdigit(src[si+5])) {
+      OUT('\\'); OUT('x'); OUT('{');
+      OUT(src[si+2]); OUT(src[si+3]); OUT(src[si+4]); OUT(src[si+5]);
+      OUT('}');
+      si += 5;
+      continue;
+    }
+
+    if (next == 'u') {
+      si++;
+      OUT('u');
+      continue;
+    }
+
+    if (next == 'x' && si + 3 < src_len &&
+        is_xdigit(src[si+2]) && is_xdigit(src[si+3])) {
+      OUT('\\'); OUT('x'); OUT(src[si+2]); OUT(src[si+3]);
+      si += 3;
+      continue;
+    }
+
+    if (next == 'x') {
+      si++;
+      OUT('x');
+      continue;
+    }
+
+    if (next == '0' && (si + 2 >= src_len || src[si+2] < '0' || src[si+2] > '9')) {
+      OUT('\\'); OUT('x'); OUT('{'); OUT('0'); OUT('}');
+      si++;
+      continue;
+    }
+
+    if (next >= '0' && next <= '7') {
+      unsigned int octal = next - '0';
+      size_t advance = 1;
+      if (si + 2 < src_len && src[si+2] >= '0' && src[si+2] <= '7') {
+        octal = octal * 8 + (src[si+2] - '0');
+        advance = 2;
+        if (si + 3 < src_len && src[si+3] >= '0' && src[si+3] <= '7' && octal * 8 + (src[si+3] - '0') <= 255) {
+          octal = octal * 8 + (src[si+3] - '0');
+          advance = 3;
+        }
+      }
+      
+      if (advance > 1 || next == '0') {
+        char hex[8];
+        int hlen = snprintf(hex, sizeof(hex), "\\x{%02x}", octal);
+        for (int k = 0; k < hlen && di < dst_size - 1; k++) OUT(hex[k]);
+        si += advance;
+        continue;
+      }
+    }
+
+    if (next == 'c' && si + 2 < src_len &&
+        ((src[si+2] >= 'A' && src[si+2] <= 'Z') || (src[si+2] >= 'a' && src[si+2] <= 'z'))) {
+      OUT('\\'); OUT('c'); OUT(src[si+2]);
+      si += 2;
+      continue;
+    }
+
+    if (next == 'c') {
+      OUT('\\'); OUT('\\'); OUT('c');
+      si++;
+      continue;
+    }
+
+    if ((next == 'p' || next == 'P') && si + 2 < src_len && src[si + 2] == '{') {
+      size_t brace_start = si + 3;
+      size_t brace_end = brace_start;
+      while (brace_end < src_len && src[brace_end] != '}') brace_end++;
+      if (brace_end < src_len && src[brace_end] == '}') {
+        const char *prop = &src[brace_start];
+        size_t prop_len = brace_end - brace_start;
+        static const struct { const char *name; const char *code; } gc_map[] = {
+          {"Letter","L"},{"Cased_Letter","LC"},{"Uppercase_Letter","Lu"},
+          {"Lowercase_Letter","Ll"},{"Titlecase_Letter","Lt"},
+          {"Modifier_Letter","Lm"},{"Other_Letter","Lo"},
+          {"Mark","M"},{"Nonspacing_Mark","Mn"},{"Spacing_Mark","Mc"},
+          {"Enclosing_Mark","Me"},
+          {"Number","N"},{"Decimal_Number","Nd"},{"Letter_Number","Nl"},
+          {"Other_Number","No"},
+          {"Punctuation","P"},{"Connector_Punctuation","Pc"},
+          {"Dash_Punctuation","Pd"},{"Open_Punctuation","Ps"},
+          {"Close_Punctuation","Pe"},{"Initial_Punctuation","Pi"},
+          {"Final_Punctuation","Pf"},{"Other_Punctuation","Po"},
+          {"Symbol","S"},{"Math_Symbol","Sm"},{"Currency_Symbol","Sc"},
+          {"Modifier_Symbol","Sk"},{"Other_Symbol","So"},
+          {"Separator","Z"},{"Space_Separator","Zs"},
+          {"Line_Separator","Zl"},{"Paragraph_Separator","Zp"},
+          {"Other","C"},{"Control","Cc"},{"Format","Cf"},
+          {"Surrogate","Cs"},{"Private_Use","Co"},{"Unassigned","Cn"},
+        };
+        static const struct { const char *script; const char *range; } u17_scripts[] = {
+          {"Sidetic",       "\\x{10940}-\\x{1095F}"},
+          {"Garay",         "\\x{10D40}-\\x{10D8F}"},
+          {"Gurung_Khema",  "\\x{16100}-\\x{1613F}"},
+          {"Kirat_Rai",     "\\x{16D40}-\\x{16D7F}"},
+          {"Ol_Onal",       "\\x{1E5D0}-\\x{1E5FF}"},
+          {"Sunuwar",       "\\x{11BC0}-\\x{11BFF}"},
+          {"Tulu_Tigalari", "\\x{11380}-\\x{113FF}"},
+        };
+        bool has_eq = (memchr(prop, '=', prop_len) != NULL);
+        bool has_colon = (memchr(prop, ':', prop_len) != NULL);
+        if (has_eq || has_colon) {
+          char sep = has_eq ? '=' : ':';
+          const char *val = memchr(prop, sep, prop_len);
+          if (val) {
+            val++;
+            size_t val_len = prop_len - (size_t)(val - prop);
+            for (size_t m = 0; m < sizeof(u17_scripts)/sizeof(u17_scripts[0]); m++) {
+              if (strlen(u17_scripts[m].script) == val_len &&
+                  memcmp(u17_scripts[m].script, val, val_len) == 0) {
+                const char *r = u17_scripts[m].range;
+                OUT('[');
+                if (next == 'P') OUT('^');
+                for (; *r; r++) OUT(*r);
+                OUT(']');
+                si = brace_end;
+                goto next_char;
+              }
+            }
+          }
+        }
+        const char *replacement = NULL;
+        if (!has_eq && !has_colon) {
+          for (size_t m = 0; m < sizeof(gc_map)/sizeof(gc_map[0]); m++) {
+            if (strlen(gc_map[m].name) == prop_len &&
+                memcmp(gc_map[m].name, prop, prop_len) == 0) {
+              replacement = gc_map[m].code;
+              break;
+            }
+          }
+        }
+        static const struct { const char *prop; const char *extra; } u17_props[] = {
+          {"Emoji", "\\x{1FACD}-\\x{1FACE}\\x{1FAE9}\\x{1FAF9}"},
+        };
+        const char *extra_range = NULL;
+        if (!has_eq && !has_colon && !replacement) {
+          for (size_t m = 0; m < sizeof(u17_props)/sizeof(u17_props[0]); m++) {
+            if (strlen(u17_props[m].prop) == prop_len &&
+                memcmp(u17_props[m].prop, prop, prop_len) == 0) {
+              extra_range = u17_props[m].extra;
+              break;
+            }
+          }
+        }
+        if (extra_range && !in_charclass) {
+          const char *pfx = (next == 'p') ? "(?:\\p{" : "(?:\\P{";
+          for (const char *r = pfx; *r; r++) OUT(*r);
+          for (size_t k = brace_start; k < brace_end; k++) OUT(src[k]);
+          OUT('}'); OUT('|'); OUT('[');
+          if (next == 'P') OUT('^');
+          for (const char *r = extra_range; *r; r++) OUT(*r);
+          OUT(']'); OUT(')');
+        } else {
+          OUT('\\'); OUT(next); OUT('{');
+          if (replacement) {
+            for (const char *r = replacement; *r; r++) OUT(*r);
+          } else {
+            for (size_t k = brace_start; k < brace_end; k++) OUT(src[k]);
+          }
+          OUT('}');
+        }
+        si = brace_end;
+        continue;
+      }
+      OUT('\\'); OUT(next);
+      si++;
+      continue;
+    }
+
+    if (is_pcre2_passthrough_escape(next)) {
+      OUT('\\'); OUT(next);
+      si++;
+      continue;
+    }
+
+    si++;
+    OUT(next);
+    next_char:;
+  }
+
+#undef OUT
+  dst[di] = '\0';
+  return di;
+}
+
+#define REGEXP_SET_PROP(js, obj, key, klen, val, is_new) \
+  ((is_new) ? js_mkprop_fast(js, obj, key, klen, val) \
+            : js_setprop(js, obj, js_mkstr(js, key, klen), val))
+
+static void regexp_init_flags(ant_t *js, jsval_t obj, const char *fstr, jsoff_t flen, bool is_new) {
+  bool g = false, i = false, m = false, s = false, u = false, y = false;
+  for (jsoff_t k = 0; k < flen; k++) {
+    if (fstr[k] == 'g') g = true;
+    if (fstr[k] == 'i') i = true;
+    if (fstr[k] == 'm') m = true;
+    if (fstr[k] == 's') s = true;
+    if (fstr[k] == 'u') u = true;
+    if (fstr[k] == 'y') y = true;
+  }
+
+  char sorted[8]; int si = 0;
+  if (g) sorted[si++] = 'g';
+  if (i) sorted[si++] = 'i';
+  if (m) sorted[si++] = 'm';
+  if (s) sorted[si++] = 's';
+  if (u) sorted[si++] = 'u';
+  if (y) sorted[si++] = 'y';
+
+  REGEXP_SET_PROP(js, obj, "flags", 5, js_mkstr(js, sorted, si), is_new);
+  REGEXP_SET_PROP(js, obj, "global", 6, mkval(T_BOOL, g ? 1 : 0), is_new);
+  REGEXP_SET_PROP(js, obj, "ignoreCase", 10, mkval(T_BOOL, i ? 1 : 0), is_new);
+  REGEXP_SET_PROP(js, obj, "multiline", 9, mkval(T_BOOL, m ? 1 : 0), is_new);
+  REGEXP_SET_PROP(js, obj, "dotAll", 6, mkval(T_BOOL, s ? 1 : 0), is_new);
+  REGEXP_SET_PROP(js, obj, "unicode", 7, mkval(T_BOOL, u ? 1 : 0), is_new);
+  REGEXP_SET_PROP(js, obj, "sticky", 6, mkval(T_BOOL, y ? 1 : 0), is_new);
+  REGEXP_SET_PROP(js, obj, "lastIndex", 9, tov(0), is_new);
+}
+
+jsval_t is_regexp_like(ant_t *js, jsval_t value) {
+  if (!is_object_type(value)) return js_false;
+
+  jsval_t match_sym = get_match_sym();
+  if (vtype(match_sym) == T_SYMBOL) {
+    jsval_t match_val = js_get_sym(js, value, match_sym);
+    if (is_err(match_val)) return match_val;
+    if (vtype(match_val) != T_UNDEF) return js_bool(js_truthy(js, match_val));
+  }
+
+  jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
+  if (is_err(regexp_ctor)) return regexp_ctor;
+
+  jsval_t regexp_proto = js_get(js, regexp_ctor, "prototype");
+  if (is_err(regexp_proto)) return regexp_proto;
+  if (!is_object_type(regexp_proto)) return js_false;
+
+  return js_bool(proto_chain_contains(js, value, regexp_proto));
+}
+
+static jsval_t should_regexp_passthrough(ant_t *js, jsval_t *args, int nargs) {
+  if (vtype(js->new_target) != T_UNDEF) return js_false;
+  if (nargs <= 0) return js_false;
+
+  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) return js_false;
+  if (!is_object_type(args[0])) return js_false;
+
+  jsval_t is_re = is_regexp_like(js, args[0]);
+  if (is_err(is_re)) return is_re;
+  if (!js_truthy(js, is_re)) return js_false;
+
+  jsval_t ctor = js_getprop_fallback(js, args[0], "constructor");
+  if (is_err(ctor)) return ctor;
+
+  jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
+  if (is_err(regexp_ctor)) return regexp_ctor;
+
+  return js_bool(same_ctor_identity(js, ctor, regexp_ctor));
+}
+
+jsval_t reject_regexp_arg(ant_t *js, jsval_t value, const char *method_name) {
+  jsval_t is_re = is_regexp_like(js, value);
+  if (is_err(is_re)) return is_re;
+  if (js_truthy(js, is_re)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "First argument to %s must not be a RegExp", method_name);
+  }
+  return js_mkundef();
+}
+
+static jsval_t regexp_species_construct(ant_t *js, jsval_t rx, jsval_t ctor, jsval_t *ctor_args, int nargs) {
+  jsval_t seed = js_mkobj(js);
+  if (is_err(seed)) return seed;
+
+  jsval_t proto = js_get(js, ctor, "prototype");
+  if (is_err(proto)) return proto;
+  if (is_object_type(proto)) js_set_proto(js, seed, proto);
+
+  jsval_t saved = js->new_target;
+  js->new_target = ctor;
+  jsval_t result = sv_vm_call(js->vm, js, ctor, seed, ctor_args, nargs, NULL, true);
+  js->new_target = saved;
+
+  if (is_err(result)) return result;
+  if (!is_object_type(result))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp species constructor returned non-object");
+
+  return result;
+}
+
+static jsval_t regexp_exec_abstract(ant_t *js, jsval_t rx, jsval_t str);
+static jsval_t builtin_regexp_exec(ant_t *js, jsval_t *args, int nargs);
+
+static regex_cache_entry_t *regex_cache_lookup(jsoff_t obj_offset) {
+  for (size_t i = 0; i < regex_cache_count; i++) {
+    if (regex_cache[i].obj_offset == obj_offset) return &regex_cache[i];
+  }
+  return NULL;
+}
+
+static regex_cache_entry_t *regex_cache_insert(jsoff_t obj_offset, pcre2_code *code, pcre2_match_data *match_data) {
+  if (regex_cache_count >= regex_cache_cap) {
+    size_t new_cap = regex_cache_cap ? regex_cache_cap * 2 : 64;
+    regex_cache_entry_t *new_cache = realloc(regex_cache, new_cap * sizeof(regex_cache_entry_t));
+    if (!new_cache) return NULL;
+    regex_cache = new_cache;
+    regex_cache_cap = new_cap;
+  }
+  regex_cache_entry_t *entry = &regex_cache[regex_cache_count++];
+  entry->obj_offset = obj_offset;
+  entry->code = code;
+  entry->match_data = match_data;
+  return entry;
+}
+
+typedef struct {
+  pcre2_code *code;
+  pcre2_match_data *match_data;
+} compiled_regex_t;
+
+static bool regex_get_or_compile(ant_t *js, jsval_t regexp_obj, compiled_regex_t *out) {
+  jsoff_t obj_off = (jsoff_t)vdata(regexp_obj);
+
+  regex_cache_entry_t *cached = regex_cache_lookup(obj_off);
+  if (cached) {
+    out->code = cached->code;
+    out->match_data = cached->match_data;
+    return true;
+  }
+
+  jsoff_t source_off = lkp(js, regexp_obj, "source", 6);
+  if (source_off == 0) return false;
+  jsval_t source_val = resolveprop(js, mkval(T_PROP, source_off));
+  if (vtype(source_val) != T_STR) return false;
+
+  jsoff_t plen, poff = vstr(js, source_val, &plen);
+  const char *pattern_ptr = (char *)&js->mem[poff];
+
+  bool ignore_case = false, multiline = false, dotall = false, sticky = false, unicode = false;
+  jsoff_t flags_off = lkp(js, regexp_obj, "flags", 5);
+  if (flags_off != 0) {
+    jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
+    if (vtype(flags_val) == T_STR) {
+      jsoff_t flen, foff = vstr(js, flags_val, &flen);
+      const char *flags_str = (char *)&js->mem[foff];
+      for (jsoff_t i = 0; i < flen; i++) {
+        if (flags_str[i] == 'i') ignore_case = true;
+        if (flags_str[i] == 'm') multiline = true;
+        if (flags_str[i] == 's') dotall = true;
+        if (flags_str[i] == 'y') sticky = true;
+        if (flags_str[i] == 'u') unicode = true;
+      }
+    }
+  }
+
+  char pcre2_pattern[4096];
+  size_t pcre2_len = js_to_pcre2_pattern(pattern_ptr, plen, pcre2_pattern, sizeof(pcre2_pattern));
+
+  uint32_t options = PCRE2_UTF | PCRE2_UCP | PCRE2_MATCH_UNSET_BACKREF | PCRE2_DUPNAMES;
+  if (ignore_case) options |= PCRE2_CASELESS;
+  if (multiline) options |= PCRE2_MULTILINE;
+  if (dotall) options |= PCRE2_DOTALL;
+  (void)sticky;
+  (void)unicode;
+
+  int errcode;
+  PCRE2_SIZE erroffset;
+  pcre2_code *re = pcre2_compile((PCRE2_SPTR)pcre2_pattern, pcre2_len, options, &errcode, &erroffset, NULL);
+  if (re == NULL) return false;
+
+  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
+  regex_cache_insert(obj_off, re, match_data);
+
+  out->code = re;
+  out->match_data = match_data;
+  return true;
+}
+
+static jsval_t builtin_RegExp(ant_t *js, jsval_t *args, int nargs) {
+  bool pattern_is_regexp = false;
+  if (nargs > 0) {
+    jsval_t is_re = is_regexp_like(js, args[0]);
+    if (is_err(is_re)) return is_re;
+    pattern_is_regexp = js_truthy(js, is_re);
+  }
+
+  if (vtype(js->new_target) == T_UNDEF && nargs > 0 && pattern_is_regexp) {
+    if (nargs < 2 || vtype(args[1]) == T_UNDEF) {
+      jsval_t ctor = js_getprop_fallback(js, args[0], "constructor");
+      if (is_err(ctor)) return ctor;
+      jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
+      if (is_err(regexp_ctor)) return regexp_ctor;
+      if (same_ctor_identity(js, ctor, regexp_ctor)) return args[0];
+    }
+  }
+
+  jsval_t regexp_obj = js->this_val;
+  bool use_this = (vtype(js->new_target) != T_UNDEF && vtype(regexp_obj) == T_OBJ);
+
+  if (!use_this) {
+    regexp_obj = mkobj(js, 0);
+    if (is_err(regexp_obj)) return regexp_obj;
+  }
+
+  jsval_t regexp_proto = js_get_ctor_proto(js, "RegExp", 6);
+  jsval_t instance_proto = js_instance_proto_from_new_target(js, regexp_proto);
+
+  if (is_object_type(instance_proto)) js_set_proto(js, regexp_obj, instance_proto);
+  if (vtype(js->new_target) == T_FUNC || vtype(js->new_target) == T_CFUNC) {
+    js_set_slot(js, regexp_obj, SLOT_CTOR, js->new_target);
+  }
+
+  jsval_t pattern = js_mkstr(js, "", 0);
+  jsval_t flags = js_mkstr(js, "", 0);
+  if (nargs > 0) {
+    if (pattern_is_regexp) {
+      jsval_t src = js_getprop_fallback(js, args[0], "source");
+      if (is_err(src)) return src;
+      pattern = js_tostring_val(js, src);
+      if (is_err(pattern)) return pattern;
+      if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
+        flags = js_tostring_val(js, args[1]);
+      } else {
+        jsval_t fl = js_getprop_fallback(js, args[0], "flags");
+        if (is_err(fl)) return fl;
+        flags = js_tostring_val(js, fl);
+      }
+      if (is_err(flags)) return flags;
+    } else if (vtype(args[0]) == T_STR) {
+      pattern = args[0];
+      if (nargs > 1 && vtype(args[1]) == T_STR) flags = args[1];
+    } else if (vtype(args[0]) != T_UNDEF) {
+      jsval_t s = js_tostring_val(js, args[0]);
+      if (is_err(s)) return s;
+      pattern = s;
+      if (nargs > 1 && vtype(args[1]) == T_STR) flags = args[1];
+    }
+  }
+
+  js_mkprop_fast(js, regexp_obj, "source", 6, pattern);
+  jsoff_t flags_len, flags_off = vstr(js, flags, &flags_len);
+  regexp_init_flags(js, regexp_obj, (const char *)&js->mem[flags_off], flags_len, true);
+
+  return regexp_obj;
+}
+
+static jsval_t builtin_regexp_exec(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t regexp = js->this_val;
+  if (vtype(regexp) != T_OBJ) return js_mkerr(js, "exec called on non-regexp");
+  if (nargs < 1) return js_mknull();
+
+  jsval_t str_arg = args[0];
+  if (vtype(str_arg) != T_STR) return js_mknull();
+
+  jsoff_t str_len, str_off = vstr(js, str_arg, &str_len);
+  const char *str_ptr = (char *)&js->mem[str_off];
+
+  bool global_flag = false, sticky_flag = false;
+  jsoff_t flags_off = lkp(js, regexp, "flags", 5);
+  if (flags_off != 0) {
+    jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
+    if (vtype(flags_val) == T_STR) {
+      jsoff_t flen, foff = vstr(js, flags_val, &flen);
+      const char *flags_str = (char *)&js->mem[foff];
+      for (jsoff_t i = 0; i < flen; i++) {
+        if (flags_str[i] == 'g') global_flag = true;
+        if (flags_str[i] == 'y') sticky_flag = true;
+      }
+    }
+  }
+
+  PCRE2_SIZE start_offset = 0;
+  if (global_flag || sticky_flag) {
+    jsoff_t lastindex_off = lkp(js, regexp, "lastIndex", 9);
+    if (lastindex_off != 0) {
+      jsval_t li_val = resolveprop(js, mkval(T_PROP, lastindex_off));
+      if (vtype(li_val) == T_NUM) {
+        double li = tod(li_val);
+        if (li >= 0 && li <= (double)str_len) start_offset = (PCRE2_SIZE)li;
+        else {
+          js_setprop(js, regexp, js_mkstr(js, "lastIndex", 9), tov(0));
+          return js_mknull();
+        }
+      }
+    }
+  }
+
+  compiled_regex_t compiled;
+  if (!regex_get_or_compile(js, regexp, &compiled)) return js_mknull();
+
+  uint32_t match_options = 0;
+  if (sticky_flag) match_options |= PCRE2_ANCHORED;
+
+  int rc = pcre2_match(compiled.code, (PCRE2_SPTR)str_ptr, str_len, start_offset, match_options, compiled.match_data, NULL);
+
+  if (rc < 0) {
+    if (global_flag || sticky_flag) {
+      js_setprop(js, regexp, js_mkstr(js, "lastIndex", 9), tov(0));
+    }
+    return js_mknull();
+  }
+
+  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(compiled.match_data);
+  uint32_t ovcount = pcre2_get_ovector_count(compiled.match_data);
+
+  jsval_t result_arr = js_mkarr(js);
+  for (uint32_t i = 0; i < ovcount && i < 32; i++) {
+    PCRE2_SIZE start = ovector[2*i];
+    PCRE2_SIZE end = ovector[2*i+1];
+    if (start == PCRE2_UNSET) {
+      js_arr_push(js, result_arr, js_mkundef());
+    } else {
+      jsval_t match_str = js_mkstr(js, str_ptr + start, end - start);
+      js_arr_push(js, result_arr, match_str);
+    }
+  }
+
+  js_setprop(js, result_arr, js_mkstr(js, "index", 5), tov((double)ovector[0]));
+  js_setprop(js, result_arr, js_mkstr(js, "input", 5), str_arg);
+
+  uint32_t namecount = 0;
+  pcre2_pattern_info(compiled.code, PCRE2_INFO_NAMECOUNT, &namecount);
+  if (namecount > 0) {
+    uint32_t nameentrysize = 0;
+    PCRE2_SPTR nametable = NULL;
+    pcre2_pattern_info(compiled.code, PCRE2_INFO_NAMEENTRYSIZE, &nameentrysize);
+    pcre2_pattern_info(compiled.code, PCRE2_INFO_NAMETABLE, (void *)&nametable);
+
+    jsval_t groups = js_mkobj(js);
+    js_set_proto(js, groups, js_mknull());
+
+    PCRE2_SPTR tabptr = nametable;
+    for (uint32_t i = 0; i < namecount; i++) {
+      int n = (tabptr[0] << 8) | tabptr[1];
+      const char *name = (const char *)(tabptr + 2);
+      jsval_t val = ((uint32_t)n < ovcount) ? js_arr_get(js, result_arr, n) : js_mkundef();
+      js_setprop(js, groups, js_mkstr(js, name, strlen(name)), val);
+      tabptr += nameentrysize;
+    }
+    js_setprop(js, result_arr, js_mkstr(js, "groups", 6), groups);
+  } else {
+    js_setprop(js, result_arr, js_mkstr(js, "groups", 6), js_mkundef());
+  }
+
+  update_regexp_statics(js, str_ptr, ovector, ovcount);
+
+  if (global_flag || sticky_flag) {
+    js_setprop(js, regexp, js_mkstr(js, "lastIndex", 9), tov((double)ovector[1]));
+  }
+
+  return result_arr;
+}
+
+static jsval_t builtin_regexp_toString(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t regexp = js->this_val;
+  if (!is_object_type(regexp))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "toString called on non-object");
+
+  jsval_t source_val = js_getprop_fallback(js, regexp, "source");
+  if (is_err(source_val)) return source_val;
+  jsval_t source_str = js_tostring_val(js, source_val);
+  if (is_err(source_str)) return source_str;
+
+  jsval_t flags_val = js_getprop_fallback(js, regexp, "flags");
+  if (is_err(flags_val)) return flags_val;
+  jsval_t flags_str = js_tostring_val(js, flags_val);
+  if (is_err(flags_str)) return flags_str;
+
+  jsoff_t src_len, src_off = vstr(js, source_str, &src_len);
+  jsoff_t fl_len, fl_off = vstr(js, flags_str, &fl_len);
+
+  size_t total = 1 + src_len + 1 + fl_len;
+  char *buf = ant_calloc(total + 1);
+  if (!buf) return js_mkerr(js, "oom");
+  size_t n = 0;
+  buf[n++] = '/';
+  memcpy(buf + n, &js->mem[src_off], src_len); n += src_len;
+  buf[n++] = '/';
+  memcpy(buf + n, &js->mem[fl_off], fl_len); n += fl_len;
+
+  jsval_t result = js_mkstr(js, buf, n);
+  free(buf);
+  return result;
+}
+
+static jsval_t builtin_regexp_compile(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t rx = js->this_val;
+  if (!is_object_type(rx))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "compile called on non-object");
+
+  jsval_t pattern = js_mkstr(js, "", 0);
+  jsval_t flags = js_mkstr(js, "", 0);
+
+  if (nargs > 0 && vtype(args[0]) != T_UNDEF) {
+    jsval_t is_re = is_regexp_like(js, args[0]);
+    if (is_err(is_re)) return is_re;
+    if (js_truthy(js, is_re)) {
+      jsval_t src = js_getprop_fallback(js, args[0], "source");
+      if (is_err(src)) return src;
+      pattern = js_tostring_val(js, src);
+      if (is_err(pattern)) return pattern;
+      jsval_t fl = js_getprop_fallback(js, args[0], "flags");
+      if (is_err(fl)) return fl;
+      flags = js_tostring_val(js, fl);
+      if (is_err(flags)) return flags;
+    } else {
+      pattern = js_tostring_val(js, args[0]);
+      if (is_err(pattern)) return pattern;
+    }
+  }
+  if (nargs > 1 && vtype(args[1]) != T_UNDEF) {
+    flags = js_tostring_val(js, args[1]);
+    if (is_err(flags)) return flags;
+  }
+
+  js_setprop(js, rx, js_mkstr(js, "source", 6), pattern);
+  jsoff_t flen, foff = vstr(js, flags, &flen);
+  regexp_init_flags(js, rx, (const char *)&js->mem[foff], flen, false);
+
+  jsoff_t obj_off = (jsoff_t)vdata(rx);
+  for (size_t i = 0; i < regex_cache_count; i++) {
+    if (regex_cache[i].obj_offset == obj_off) {
+      pcre2_match_data_free(regex_cache[i].match_data);
+      pcre2_code_free(regex_cache[i].code);
+      regex_cache[i] = regex_cache[--regex_cache_count];
+      break;
+    }
+  }
+
+  return rx;
+}
+
+static inline bool is_syntax_char(char c) {
+  return 
+    c == '^' || c == '$' || c == '\\' || c == '.' || c == '*' ||
+    c == '+' || c == '?' || c == '(' || c == ')' || c == '[' ||
+    c == ']' || c == '{' || c == '}' || c == '|' || c == '/';
+}
+
+static inline bool is_other_punctuator(char c) {
+  return
+    c == ',' || c == '-' || c == ':' || c == ';' || c == '<' ||
+    c == '=' || c == '>' || c == '@' || c == '!' || c == '"' ||
+    c == '#' || c == '%' || c == '&' || c == '\'' || c == '`' || c == '~';
+}
+
+static jsval_t builtin_regexp_escape(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR)
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.escape requires a string argument");
+
+  jsoff_t slen, soff = vstr(js, args[0], &slen);
+  const char *src = (const char *)&js->mem[soff];
+
+  size_t buf_cap = slen * 6 + 1;
+  char *buf = ant_calloc(buf_cap);
+  if (!buf) return js_mkerr(js, "oom");
+  size_t di = 0;
+  bool first = true;
+
+  for (size_t si = 0; si < slen; ) {
+    unsigned char c = (unsigned char)src[si];
+
+    if (c >= 0x80) {
+      utf8proc_int32_t cp;
+      int bytes = (int)utf8_next(
+        (const utf8proc_uint8_t *)&src[si],
+        (utf8proc_ssize_t)(slen - si), &cp
+      );
+      for (int b = 0; b < bytes && si < slen; b++)
+        buf[di++] = src[si++];
+      first = false;
+      continue;
+    }
+
+    if (first && ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
+      di += snprintf(buf + di, buf_cap - di, "\\x%02x", c);
+      si++; first = false;
+      continue;
+    }
+
+    if (is_syntax_char(c)) {
+      buf[di++] = '\\'; buf[di++] = c;
+      si++; first = false;
+      continue;
+    }
+
+    if (is_other_punctuator(c) || c == ' ' || c == '\t' || c == '\n' ||
+        c == '\r' || c == '\v' || c == '\f') {
+      di += snprintf(buf + di, buf_cap - di, "\\x%02x", c);
+      si++; first = false;
+      continue;
+    }
+
+    buf[di++] = c;
+    si++; first = false;
+  }
+
+  jsval_t result = js_mkstr(js, buf, di);
+  free(buf);
+  return result;
+}
+
+static jsval_t regexp_exec_abstract(ant_t *js, jsval_t rx, jsval_t str) {
+  jsval_t exec_fn = js_get(js, rx, "exec");
+  if (is_err(exec_fn)) return exec_fn;
+
+  if (vtype(exec_fn) == T_FUNC || vtype(exec_fn) == T_CFUNC) {
+    jsval_t call_args[1] = { str };
+    jsval_t result = sv_vm_call(js->vm, js, exec_fn, rx, call_args, 1, NULL, false);
+    if (is_err(result)) return result;
+    if (!is_object_type(result) && vtype(result) != T_NULL)
+      return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp exec returned non-object");
+    return result;
+  }
+
+  jsval_t call_args[1] = { str };
+  jsval_t saved = js->this_val;
+  js->this_val = rx;
+  jsval_t result = builtin_regexp_exec(js, call_args, 1);
+  js->this_val = saved;
+
+  return result;
+}
+
+static jsval_t builtin_regexp_test(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t regexp = js->this_val;
+  if (!is_object_type(regexp))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "test called on non-object");
+  jsval_t str_arg = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
+  if (is_err(str_arg)) return str_arg;
+  jsval_t result = regexp_exec_abstract(js, regexp, str_arg);
+  if (is_err(result)) return result;
+  return mkval(T_BOOL, vtype(result) != T_NULL ? 1 : 0);
+}
+
+jsval_t builtin_regexp_flags_getter(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+  jsval_t rx = js->this_val;
+  if (!is_object_type(rx))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype.flags called on non-object");
+
+  char buf[16];
+  int n = 0;
+
+  static const struct { const char *name; size_t len; char flag; } flag_props[] = {
+    {"hasIndices", 10, 'd'}, {"global", 6, 'g'}, {"ignoreCase", 10, 'i'},
+    {"multiline", 9, 'm'}, {"dotAll", 6, 's'}, {"unicode", 7, 'u'},
+    {"unicodeSets", 11, 'v'}, {"sticky", 6, 'y'},
+  };
+
+  for (int i = 0; i < 8; i++) {
+    jsval_t v = js_getprop_fallback(js, rx, flag_props[i].name);
+    if (is_err(v)) return v;
+    if (js_truthy(js, v)) buf[n++] = flag_props[i].flag;
+  }
+
+  return js_mkstr(js, buf, n);
+}
+
+jsval_t builtin_regexp_symbol_match(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t rx = js->this_val;
+  if (!is_object_type(rx))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@match] called on non-object");
+
+  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
+  if (is_err(str)) return str;
+
+  jsval_t global_val = js_getprop_fallback(js, rx, "global");
+  if (is_err(global_val)) return global_val;
+
+  if (!js_truthy(js, global_val))
+    return regexp_exec_abstract(js, rx, str);
+
+  jsval_t unicode_val = js_getprop_fallback(js, rx, "unicode");
+  if (is_err(unicode_val)) return unicode_val;
+
+  bool full_unicode = js_truthy(js, unicode_val);
+  js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(0));
+
+  jsval_t A = mkarr(js);
+  if (is_err(A)) return A;
+  jsoff_t n = 0;
+
+  for (;;) {
+    jsval_t result = regexp_exec_abstract(js, rx, str);
+    if (is_err(result)) return result;
+    if (vtype(result) == T_NULL) return n == 0 ? js_mknull() : mkval(T_ARR, vdata(A));
+
+    jsval_t match_str = js_tostring_val(js, js_arr_get(js, result, 0));
+    if (is_err(match_str)) return match_str;
+    js_arr_push(js, A, match_str);
+    n++;
+
+    jsoff_t mlen;
+    vstr(js, match_str, &mlen);
+    if (mlen == 0) {
+      jsval_t li_val = js_getprop_fallback(js, rx, "lastIndex");
+      if (is_err(li_val)) return li_val;
+      double li = vtype(li_val) == T_NUM ? tod(li_val) : 0;
+      jsoff_t str_len, str_off = vstr(js, str, &str_len);
+      double advance = 1;
+      if (full_unicode && li < (double)str_len) {
+        advance = (double)utf8_char_len_at((const char *)&js->mem[str_off], str_len, (jsoff_t)li);
+      } js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(li + advance));
+    }
+  }
+}
+
+jsval_t builtin_regexp_symbol_replace(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t rx = js->this_val;
+  if (!is_object_type(rx))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@replace] called on non-object");
+
+  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
+  if (is_err(str)) return str;
+  jsval_t replace_value = nargs > 1 ? args[1] : js_mkundef();
+  bool func_replace = (vtype(replace_value) == T_FUNC || vtype(replace_value) == T_CFUNC);
+  jsval_t replace_str = js_mkundef();
+  if (!func_replace) {
+    replace_str = js_tostring_val(js, replace_value);
+    if (is_err(replace_str)) return replace_str;
+  }
+
+  jsval_t global_val = js_getprop_fallback(js, rx, "global");
+  if (is_err(global_val)) return global_val;
+  bool global = js_truthy(js, global_val);
+
+  bool full_unicode = false;
+  if (global) {
+    jsval_t unicode_val = js_getprop_fallback(js, rx, "unicode");
+    if (is_err(unicode_val)) return unicode_val;
+    full_unicode = js_truthy(js, unicode_val);
+    js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(0));
+  }
+
+  jsval_t results = mkarr(js);
+  if (is_err(results)) return results;
+  jsoff_t nresults = 0;
+
+  for (;;) {
+    jsval_t result = regexp_exec_abstract(js, rx, str);
+    if (is_err(result)) return result;
+    if (vtype(result) == T_NULL) break;
+    js_arr_push(js, results, result);
+    nresults++;
+    if (!global) break;
+
+    jsval_t match_str = js_tostring_val(js, js_arr_get(js, result, 0));
+    if (is_err(match_str)) return match_str;
+    jsoff_t mlen; vstr(js, match_str, &mlen);
+    if (mlen == 0) {
+      jsval_t li_val = js_getprop_fallback(js, rx, "lastIndex");
+      if (is_err(li_val)) return li_val;
+      double li = vtype(li_val) == T_NUM ? tod(li_val) : 0;
+      jsoff_t sl, so = vstr(js, str, &sl);
+      double advance = 1;
+      if (full_unicode && li < (double)sl) {
+        advance = (double)utf8_char_len_at((const char *)&js->mem[so], sl, (jsoff_t)li);
+      }
+      js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(li + advance));
+    }
+  }
+
+  jsoff_t str_len, str_off = vstr(js, str, &str_len);
+  size_t buf_cap = str_len + 256;
+  char *buf = ant_calloc(buf_cap);
+  if (!buf) return js_mkerr(js, "oom");
+  size_t buf_len = 0;
+  jsoff_t next_src_pos = 0;
+
+#define SB_APPEND(data, dlen) do { \
+  if (buf_len + (dlen) >= buf_cap) { \
+    buf_cap = (buf_len + (dlen) + 1) * 2; \
+    char *nb = ant_realloc(buf, buf_cap); \
+    if (!nb) { free(buf); return js_mkerr(js, "oom"); } \
+    buf = nb; \
+  } \
+  memcpy(buf + buf_len, data, dlen); buf_len += (dlen); \
+} while(0)
+
+  for (jsoff_t i = 0; i < nresults; i++) {
+    jsval_t result = js_arr_get(js, results, i);
+    jsval_t matched = js_tostring_val(js, js_arr_get(js, result, 0));
+    if (is_err(matched)) { free(buf); return matched; }
+    jsoff_t matched_len; vstr(js, matched, &matched_len);
+
+    jsval_t pos_val = js_getprop_fallback(js, result, "index");
+    jsoff_t position = 0;
+    if (!is_err(pos_val) && vtype(pos_val) == T_NUM) {
+      double d = tod(pos_val);
+      position = d < 0 ? 0 : (jsoff_t)d;
+    }
+    if (position > str_len) position = str_len;
+
+    jsval_t replacement;
+    if (func_replace) {
+      jsoff_t ncaptures = js_arr_len(js, result);
+      jsval_t call_args[32];
+      int ca = 0;
+      for (jsoff_t c = 0; c < ncaptures && ca < 30; c++)
+        call_args[ca++] = js_arr_get(js, result, c);
+      call_args[ca++] = tov((double)position);
+      call_args[ca++] = str;
+      replacement = sv_vm_call(js->vm, js, replace_value, js_mkundef(), call_args, ca, NULL, false);
+    } else {
+      replacement = replace_str;
+    }
+    if (is_err(replacement)) { free(buf); return replacement; }
+    jsval_t rep_str = js_tostring_val(js, replacement);
+    if (is_err(rep_str)) { free(buf); return rep_str; }
+
+    if (position >= next_src_pos) {
+      str_off = vstr(js, str, &str_len);
+      if (position > next_src_pos)
+        SB_APPEND((const char *)&js->mem[str_off + next_src_pos], position - next_src_pos);
+      jsoff_t rep_len, rep_off = vstr(js, rep_str, &rep_len);
+      if (func_replace) {
+        SB_APPEND((const char *)&js->mem[rep_off], rep_len);
+      } else {
+        jsoff_t ncap = js_arr_len(js, result);
+        int num_caps = ncap > 1 ? (int)(ncap - 1) : 0;
+        repl_capture_t caps_buf[16], *caps = num_caps <= 16 ? caps_buf : ant_calloc(sizeof(repl_capture_t) * (size_t)num_caps);
+        for (int ci = 0; ci < num_caps; ci++) {
+          jsval_t cap = js_arr_get(js, result, (jsoff_t)(ci + 1));
+          if (vtype(cap) == T_STR) { jsoff_t cl, co = vstr(js, cap, &cl); caps[ci] = (repl_capture_t){ (const char *)&js->mem[co], cl }; }
+          else caps[ci] = (repl_capture_t){ NULL, 0 };
+        }
+        jsoff_t mlen, moff = vstr(js, matched, &mlen);
+        str_off = vstr(js, str, &str_len);
+        repl_template((const char *)&js->mem[rep_off], rep_len, (const char *)&js->mem[moff], mlen,
+          (const char *)&js->mem[str_off], str_len, position, caps, num_caps, &buf, &buf_len, &buf_cap);
+        if (caps != caps_buf) free(caps);
+      }
+      next_src_pos = position + matched_len;
+    }
+  }
+
+  str_off = vstr(js, str, &str_len);
+  if (next_src_pos < str_len)
+    SB_APPEND((const char *)&js->mem[str_off + next_src_pos], str_len - next_src_pos);
+
+#undef SB_APPEND
+
+  jsval_t ret = js_mkstr(js, buf, buf_len);
+  free(buf);
+  return ret;
+}
+
+jsval_t builtin_regexp_symbol_search(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t rx = js->this_val;
+  if (!is_object_type(rx))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@search] called on non-object");
+
+  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "undefined", 9);
+  if (is_err(str)) return str;
+
+  jsval_t prev_li = js_getprop_fallback(js, rx, "lastIndex");
+  if (is_err(prev_li)) return prev_li;
+  js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), tov(0));
+
+  jsval_t result = regexp_exec_abstract(js, rx, str);
+  if (is_err(result)) return result;
+
+  jsval_t cur_li = js_getprop_fallback(js, rx, "lastIndex");
+  if (is_err(cur_li)) return cur_li;
+  js_setprop(js, rx, js_mkstr(js, "lastIndex", 9), prev_li);
+
+  if (vtype(result) == T_NULL) return tov(-1);
+
+  jsval_t idx = js_getprop_fallback(js, result, "index");
+  if (is_err(idx)) return idx;
+  return vtype(idx) == T_NUM ? idx : tov(-1);
+}
+
+jsval_t builtin_regexp_symbol_split(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t rx = js_getthis(js);
+  if (!is_object_type(rx))
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@split] called on non-object");
+
+  jsval_t str = nargs > 0 ? js_tostring_val(js, args[0]) : js_mkstr(js, "", 0);
+  if (is_err(str)) return str;
+
+  jsval_t ctor = js_get(js, rx, "constructor");
+  if (is_err(ctor)) return ctor;
+
+  jsval_t C;
+  if (vtype(ctor) == T_UNDEF) {
+    C = js_get(js, js_glob(js), "RegExp");
+  } else if (!is_object_type(ctor)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp.prototype[@@split]: constructor is not an object");
+  } else {
+    jsval_t species = get_ctor_species_value(js, ctor);
+    if (is_err(species)) return species;
+    if (vtype(species) == T_UNDEF || vtype(species) == T_NULL)
+      C = js_get(js, js_glob(js), "RegExp");
+    else C = species;
+  }
+
+  if (is_err(C)) return C;
+  if (vtype(C) != T_FUNC && vtype(C) != T_CFUNC)
+    return js_mkerr_typed(js, JS_ERR_TYPE, "RegExp species is not a constructor");
+
+  jsval_t flags_val = js_get(js, rx, "flags");
+  if (is_err(flags_val)) return flags_val;
+  jsval_t flags_str = js_tostring_val(js, flags_val);
+  if (is_err(flags_str)) return flags_str;
+
+  jsoff_t flen, foff = vstr(js, flags_str, &flen);
+  const char *fptr = (const char *)&js->mem[foff];
+  bool unicode_matching = false, has_sticky = false;
+  for (jsoff_t i = 0; i < flen; i++) {
+    if (fptr[i] == 'u' || fptr[i] == 'v') unicode_matching = true;
+    if (fptr[i] == 'y') has_sticky = true;
+  }
+
+  jsval_t new_flags;
+  if (has_sticky) new_flags = flags_str; else {
+    char fbuf[16];
+    if (flen > 14) flen = 14;
+    foff = vstr(js, flags_str, &flen);
+    fptr = (const char *)&js->mem[foff];
+    memcpy(fbuf, fptr, flen);
+    fbuf[flen] = 'y';
+    new_flags = js_mkstr(js, fbuf, flen + 1);
+  }
+
+  jsval_t ctor_args[2] = { rx, new_flags };
+  jsval_t splitter = regexp_species_construct(js, rx, C, ctor_args, 2);
+  if (is_err(splitter)) return splitter;
+
+  jsval_t A = mkarr(js);
+  if (is_err(A)) return A;
+  jsoff_t lengthA = 0;
+
+  uint32_t lim = UINT32_MAX;
+  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
+    double d = tod(args[1]);
+    if (d >= 0 && d <= UINT32_MAX) lim = (uint32_t)d;
+  } if (lim == 0) return mkval(T_ARR, vdata(A));
+
+  jsoff_t str_len, str_off = vstr(js, str, &str_len);
+  jsoff_t size = str_len;
+
+  if (size == 0) {
+    jsval_t z = regexp_exec_abstract(js, splitter, str);
+    if (is_err(z)) return z;
+    if (vtype(z) == T_NULL) js_arr_push(js, A, str);
+    return mkval(T_ARR, vdata(A));
+  }
+
+  jsoff_t p = 0, q = p;
+  jsval_t lastIndex_key = js_mkstr(js, "lastIndex", 9);
+
+  while (q < size) {
+    js_setprop(js, splitter, lastIndex_key, tov((double)q));
+
+    jsval_t z = regexp_exec_abstract(js, splitter, str);
+    if (is_err(z)) return z;
+
+    if (vtype(z) == T_NULL) {
+      if (unicode_matching) {
+        str_off = vstr(js, str, &str_len);
+        q += utf8_char_len_at((const char *)&js->mem[str_off], str_len, q);
+      } else q++;
+      continue;
+    }
+
+    jsval_t li_val = js_get(js, splitter, "lastIndex");
+    if (is_err(li_val)) return li_val;
+    double e_raw = vtype(li_val) == T_NUM ? tod(li_val) : 0;
+    jsoff_t e = (jsoff_t)(e_raw < 0 ? 0 : (e_raw > (double)size ? (double)size : e_raw));
+
+    if (e == p) {
+      if (unicode_matching) {
+        str_off = vstr(js, str, &str_len);
+        q += utf8_char_len_at((const char *)&js->mem[str_off], str_len, q);
+      } else q++;
+      continue;
+    }
+
+    str_off = vstr(js, str, NULL);
+    jsval_t T_val = js_mkstr(js, (char *)&js->mem[str_off + p], q - p);
+    js_arr_push(js, A, T_val);
+    lengthA++;
+    if (lengthA == lim) return mkval(T_ARR, vdata(A));
+
+    jsoff_t num_caps = js_arr_len(js, z);
+    for (jsoff_t i = 1; i < num_caps; i++) {
+      jsval_t cap = js_arr_get(js, z, i);
+      js_arr_push(js, A, cap);
+      lengthA++;
+      if (lengthA == lim) return mkval(T_ARR, vdata(A));
+    }
+
+    p = e;
+    q = p;
+  }
+
+  str_off = vstr(js, str, &str_len);
+  jsval_t trailing = js_mkstr(js, (char *)&js->mem[str_off + p], str_len - p);
+  js_arr_push(js, A, trailing);
+  return mkval(T_ARR, vdata(A));
+}
+
+jsval_t do_regex_match_pcre2(
+  ant_t *js, const char *pattern_ptr, jsoff_t pattern_len,
+  const char *str_ptr, jsoff_t str_len,
+  bool global_flag, bool ignore_case, bool multiline
+) {
+  char pcre2_pattern[4096];
+  size_t pcre2_len = js_to_pcre2_pattern(pattern_ptr, pattern_len, pcre2_pattern, sizeof(pcre2_pattern));
+
+  uint32_t options = PCRE2_UTF | PCRE2_UCP | PCRE2_MATCH_UNSET_BACKREF | PCRE2_DUPNAMES;
+  if (ignore_case) options |= PCRE2_CASELESS;
+  if (multiline) options |= PCRE2_MULTILINE;
+
+  int errcode;
+  PCRE2_SIZE erroffset;
+  pcre2_code *re = pcre2_compile((PCRE2_SPTR)pcre2_pattern, pcre2_len, options, &errcode, &erroffset, NULL);
+  if (re == NULL) return js_mknull();
+
+  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
+  uint32_t capture_count;
+  pcre2_pattern_info(re, PCRE2_INFO_CAPTURECOUNT, &capture_count);
+
+  jsval_t result_arr = js_mkarr(js);
+  if (is_err(result_arr)) {
+    pcre2_match_data_free(match_data);
+    pcre2_code_free(re);
+    return result_arr;
+  }
+
+  PCRE2_SIZE pos = 0;
+  int match_count = 0;
+
+  while (pos <= str_len) {
+    int rc = pcre2_match(re, (PCRE2_SPTR)str_ptr, str_len, pos, 0, match_data, NULL);
+    if (rc < 0) break;
+
+    PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
+    PCRE2_SIZE match_start = ovector[0];
+    PCRE2_SIZE match_end = ovector[1];
+
+    if (global_flag) {
+      jsval_t match_str = js_mkstr(js, str_ptr + match_start, match_end - match_start);
+      if (is_err(match_str)) {
+        pcre2_match_data_free(match_data);
+        pcre2_code_free(re);
+        return match_str;
+      }
+      js_arr_push(js, result_arr, match_str);
+    } else {
+      for (uint32_t i = 0; i <= capture_count; i++) {
+        PCRE2_SIZE start = ovector[2*i];
+        PCRE2_SIZE end = ovector[2*i+1];
+        if (start == PCRE2_UNSET) {
+          js_arr_push(js, result_arr, js_mkundef());
+        } else {
+          jsval_t match_str = js_mkstr(js, str_ptr + start, end - start);
+          if (is_err(match_str)) {
+            pcre2_match_data_free(match_data);
+            pcre2_code_free(re);
+            return match_str;
+          }
+          js_arr_push(js, result_arr, match_str);
+        }
+      }
+      js_setprop(js, result_arr, js_mkstr(js, "index", 5), tov((double)match_start));
+    }
+    match_count++;
+
+    if (!global_flag) break;
+    if (match_start == match_end) {
+      pos = match_end + 1;
+    } else { pos = match_end; }
+  }
+
+  pcre2_match_data_free(match_data);
+  pcre2_code_free(re);
+
+  if (match_count == 0) return js_mknull();
+  return result_arr;
+}
+
+static jsval_t builtin_string_search(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
+  jsval_t str = js_tostring_val(js, this_unwrapped);
+  if (is_err(str)) return str;
+  if (nargs < 1) return tov(-1);
+
+  if (is_object_type(args[0])) {
+    bool called = false;
+    jsval_t call_args[1] = { str };
+    jsval_t dispatched = maybe_call_symbol_method(
+      js, args[0], get_search_sym(), args[0], call_args, 1, &called
+    );
+    if (is_err(dispatched)) return dispatched;
+    if (called) return dispatched;
+  }
+
+  jsval_t pattern = args[0];
+  const char *pattern_ptr = NULL;
+  jsoff_t pattern_len = 0;
+  bool ignore_case = false, multiline = false;
+
+  if (vtype(pattern) == T_OBJ) {
+    jsoff_t source_off = lkp(js, pattern, "source", 6);
+    if (source_off == 0) return tov(-1);
+    jsval_t source_val = resolveprop(js, mkval(T_PROP, source_off));
+    if (vtype(source_val) != T_STR) return tov(-1);
+
+    jsoff_t poff;
+    poff = vstr(js, source_val, &pattern_len);
+    pattern_ptr = (char *)&js->mem[poff];
+
+    jsoff_t flags_off = lkp(js, pattern, "flags", 5);
+    if (flags_off != 0) {
+      jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
+      if (vtype(flags_val) == T_STR) {
+        jsoff_t flen, foff = vstr(js, flags_val, &flen);
+        const char *flags_str = (char *)&js->mem[foff];
+        for (jsoff_t i = 0; i < flen; i++) {
+          if (flags_str[i] == 'i') ignore_case = true;
+          if (flags_str[i] == 'm') multiline = true;
+        }
+      }
+    }
+  } else if (vtype(pattern) == T_STR) {
+    jsoff_t poff;
+    poff = vstr(js, pattern, &pattern_len);
+    pattern_ptr = (char *)&js->mem[poff];
+  } else {
+    return tov(-1);
+  }
+
+  jsoff_t str_len, str_off = vstr(js, str, &str_len);
+  const char *str_ptr = (char *)&js->mem[str_off];
+
+  char pcre2_pattern[4096];
+  size_t pcre2_len = js_to_pcre2_pattern(pattern_ptr, pattern_len, pcre2_pattern, sizeof(pcre2_pattern));
+
+  uint32_t options = PCRE2_UTF | PCRE2_UCP | PCRE2_MATCH_UNSET_BACKREF | PCRE2_DUPNAMES;
+  if (ignore_case) options |= PCRE2_CASELESS;
+  if (multiline) options |= PCRE2_MULTILINE;
+
+  int errcode;
+  PCRE2_SIZE erroffset;
+  pcre2_code *re = pcre2_compile((PCRE2_SPTR)pcre2_pattern, pcre2_len, options, &errcode, &erroffset, NULL);
+  if (re == NULL) return tov(-1);
+
+  pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
+  int rc = pcre2_match(re, (PCRE2_SPTR)str_ptr, str_len, 0, 0, match_data, NULL);
+
+  if (rc < 0) {
+    pcre2_match_data_free(match_data);
+    pcre2_code_free(re);
+    return tov(-1);
+  }
+
+  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
+  double result = (double)ovector[0];
+
+  pcre2_match_data_free(match_data);
+  pcre2_code_free(re);
+
+  return tov(result);
+}
+
+static jsval_t builtin_string_match(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_unwrapped = unwrap_primitive(js, js->this_val);
+  jsval_t str = js_tostring_val(js, this_unwrapped);
+  if (is_err(str)) return str;
+  if (nargs < 1) return js_mknull();
+
+  if (is_object_type(args[0])) {
+    bool called = false;
+    jsval_t call_args[1] = { str };
+    jsval_t dispatched = maybe_call_symbol_method(
+      js, args[0], get_match_sym(), args[0], call_args, 1, &called
+    );
+    if (is_err(dispatched)) return dispatched;
+    if (called) return dispatched;
+  }
+
+  jsval_t pattern = args[0];
+  const char *pattern_ptr = NULL;
+  jsoff_t pattern_len = 0;
+  bool global_flag = false;
+  bool ignore_case = false;
+  bool multiline = false;
+
+  if (vtype(pattern) == T_OBJ) {
+    jsoff_t source_off = lkp(js, pattern, "source", 6);
+    if (source_off == 0) return js_mknull();
+
+    jsval_t source_val = resolveprop(js, mkval(T_PROP, source_off));
+    if (vtype(source_val) != T_STR) return js_mknull();
+
+    jsoff_t poff;
+    poff = vstr(js, source_val, &pattern_len);
+    pattern_ptr = (char *)&js->mem[poff];
+
+    jsoff_t flags_off = lkp(js, pattern, "flags", 5);
+    if (flags_off != 0) {
+      jsval_t flags_val = resolveprop(js, mkval(T_PROP, flags_off));
+      if (vtype(flags_val) == T_STR) {
+        jsoff_t flen, foff = vstr(js, flags_val, &flen);
+        const char *flags_str = (char *)&js->mem[foff];
+        for (jsoff_t i = 0; i < flen; i++) {
+          if (flags_str[i] == 'g') global_flag = true;
+          if (flags_str[i] == 'i') ignore_case = true;
+          if (flags_str[i] == 'm') multiline = true;
+        }
+      }
+    }
+  } else if (vtype(pattern) == T_STR) {
+    jsoff_t poff;
+    poff = vstr(js, pattern, &pattern_len);
+    pattern_ptr = (char *)&js->mem[poff];
+  } else {
+    return js_mknull();
+  }
+
+  jsoff_t str_len, str_off = vstr(js, str, &str_len);
+  const char *str_ptr = (char *)&js->mem[str_off];
+
+  jsval_t result = do_regex_match_pcre2(
+    js, pattern_ptr, pattern_len, 
+    str_ptr, str_len, global_flag, ignore_case, multiline
+  );
+
+  if (!global_flag && vtype(result) == T_ARR) {
+    js_setprop(js, result, js_mkstr(js, "input", 5), str);
+  }
+
+  return result;
+}
+
+void init_regex_module(void) {
+  ant_t *js = rt->js;
+  jsval_t glob = js->global;
+  jsval_t object_proto = js->object;
+
+  jsval_t regexp_proto = js_mkobj(js);
+  js_set_proto(js, regexp_proto, object_proto);
+  js_setprop(js, regexp_proto, js_mkstr(js, "test", 4), js_mkfun(builtin_regexp_test));
+  js_setprop(js, regexp_proto, js_mkstr(js, "exec", 4), js_mkfun(builtin_regexp_exec));
+  js_setprop(js, regexp_proto, js_mkstr(js, "toString", 8), js_mkfun(builtin_regexp_toString));
+
+  js_mkprop_fast(js, regexp_proto, "global", 6, js_false);
+  js_mkprop_fast(js, regexp_proto, "ignoreCase", 10, js_false);
+  js_mkprop_fast(js, regexp_proto, "multiline", 9, js_false);
+  js_mkprop_fast(js, regexp_proto, "dotAll", 6, js_false);
+  js_mkprop_fast(js, regexp_proto, "unicode", 7, js_false);
+  js_mkprop_fast(js, regexp_proto, "sticky", 6, js_false);
+  js_mkprop_fast(js, regexp_proto, "hasIndices", 10, js_false);
+  js_mkprop_fast(js, regexp_proto, "unicodeSets", 11, js_false);
+
+  js_set_sym(js, regexp_proto, get_split_sym(), js_mkfun(builtin_regexp_symbol_split));
+  js_set_sym(js, regexp_proto, get_match_sym(), js_mkfun(builtin_regexp_symbol_match));
+  js_set_sym(js, regexp_proto, get_replace_sym(), js_mkfun(builtin_regexp_symbol_replace));
+  js_set_sym(js, regexp_proto, get_search_sym(), js_mkfun(builtin_regexp_symbol_search));
+  js_set_getter_desc(js, regexp_proto, "flags", 5, js_mkfun(builtin_regexp_flags_getter), JS_DESC_C);
+  js_setprop(js, regexp_proto, js_mkstr(js, "compile", 7), js_mkfun(builtin_regexp_compile));
+
+  jsval_t regexp_ctor = js_mkobj(js);
+  js_set_slot(js, regexp_ctor, SLOT_CFUNC, js_mkfun(builtin_RegExp));
+  js_mkprop_fast(js, regexp_ctor, "prototype", 9, regexp_proto);
+  js_mkprop_fast(js, regexp_ctor, "name", 4, js_mkstr(js, "RegExp", 6));
+  js_set_descriptor(js, regexp_ctor, "name", 4, 0);
+  js_define_species_getter(js, regexp_ctor);
+
+  jsval_t regexp_func = js_obj_to_func(regexp_ctor);
+  js_setprop(js, regexp_proto, js_mkstr(js, "constructor", 11), regexp_func);
+  js_set_descriptor(js, regexp_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
+
+  js_set(js, regexp_ctor, "escape", js_mkfun(builtin_regexp_escape));
+
+  jsval_t empty = js_mkstr(js, "", 0);
+  for (int i = 1; i <= 9; i++) {
+    char key[3] = {'$', (char)('0' + i), '\0'};
+    js_set(js, regexp_ctor, key, empty);
+  }
+  js_set(js, regexp_ctor, "lastMatch", empty);
+  js_set(js, regexp_ctor, "$&", empty);
+
+  js_set(js, glob, "RegExp", regexp_func);
+
+  jsval_t string_ctor = js_get(js, glob, "String");
+  jsval_t string_proto = js_get(js, string_ctor, "prototype");
+  js_setprop(js, string_proto, js_mkstr(js, "search", 6), js_mkfun(builtin_string_search));
+  js_setprop(js, string_proto, js_mkstr(js, "match", 5), js_mkfun(builtin_string_match));
+}
+
+void regex_gc_update_roots(jsoff_t (*weak_off)(void *ctx, jsoff_t old), GC_OP_VAL_ARGS) {
+  size_t write_idx = 0;
+
+  for (size_t i = 0; i < regex_cache_count; i++) {
+    jsoff_t old_off = regex_cache[i].obj_offset;
+    jsoff_t new_off = weak_off(ctx, old_off);
+
+    if (new_off == (jsoff_t)~0) {
+      pcre2_match_data_free(regex_cache[i].match_data);
+      pcre2_code_free(regex_cache[i].code);
+      continue;
+    }
+
+    regex_cache[i].obj_offset = new_off;
+    if (write_idx != i) regex_cache[write_idx] = regex_cache[i];
+    write_idx++;
+  }
+  regex_cache_count = write_idx;
+}
+
+void cleanup_regex_module(void) {
+  for (size_t i = 0; i < regex_cache_count; i++) {
+    pcre2_match_data_free(regex_cache[i].match_data);
+    pcre2_code_free(regex_cache[i].code);
+  }
+  free(regex_cache);
+  regex_cache = NULL;
+  regex_cache_count = 0;
+  regex_cache_cap = 0;
+}
diff --git a/src/modules/server.c b/src/modules/server.c
index e623dba..150f727 100644
--- a/src/modules/server.c
+++ b/src/modules/server.c
@@ -14,6 +14,7 @@
 #include "reactor.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/engine.h"
 
 #include "modules/server.h"
 #include "modules/json.h"
@@ -85,7 +86,7 @@ static void res_set_body(response_ctx_t *ctx, const char *src, size_t len) {
 }
 
 typedef struct http_server_s {
-  struct js *js;
+  ant_t *js;
   jsval_t handler;
   jsval_t store_obj;
   jsval_t server_obj;
@@ -344,7 +345,7 @@ static void free_http_request(http_request_t *req) {
 static void on_close(uv_handle_t *handle);
 static void send_response(uv_stream_t *client, response_ctx_t *res_ctx);
 
-static jsval_t js_set_prop(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_set_prop(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -360,7 +361,7 @@ static jsval_t js_set_prop(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t js_get_prop(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_get_prop(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -376,7 +377,7 @@ static jsval_t js_get_prop(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t req_header(struct js *js, jsval_t *args, int nargs) {
+static jsval_t req_header(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -400,7 +401,7 @@ static jsval_t req_header(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_header(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_header(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -420,7 +421,7 @@ static jsval_t res_header(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_status(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_status(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -437,7 +438,7 @@ static jsval_t res_status(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_body(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_body(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -466,7 +467,7 @@ static jsval_t res_body(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_html(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_html(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -492,7 +493,7 @@ static jsval_t res_html(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_json(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_json(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -524,7 +525,7 @@ static jsval_t res_json(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_notFound(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_notFound(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -543,7 +544,7 @@ static jsval_t res_notFound(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t res_redirect(struct js *js, jsval_t *args, int nargs) {
+static jsval_t res_redirect(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   
   jsval_t fn = js_getcurrentfunc(js);
@@ -705,7 +706,7 @@ static void send_response(uv_stream_t *client, response_ctx_t *res_ctx) {
   uv_write((uv_write_t *)write_req, client, &write_req->buf, 1, on_write);
 }
 
-static jsval_t js_server_stop(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_server_stop(ant_t *js, jsval_t *args, int nargs) {
   server_signal_cb(NULL, 0);
   return js_mkundef();
 }
@@ -765,7 +766,7 @@ static void handle_http_request(client_t *client, http_request_t *http_req) {
     js_set(server->js, ctx, "get", js_heavy_mkfun(server->js, js_get_prop, server->store_obj));
   
     jsval_t args[2] = {ctx, server->server_obj};
-    result = js_call(server->js, server->handler, args, 2);
+    result = sv_vm_call(server->js->vm, server->js, server->handler, js_mkundef(), args, 2, NULL, false);
     if (vtype(result) == T_PROMISE) return;
     
     if (vtype(result) == T_ERR) {
@@ -943,7 +944,7 @@ static void on_connection(uv_stream_t *server, int status) {
 }
 
 // Ant.serve(port, handler)
-jsval_t js_serve(struct js *js, jsval_t *args, int nargs) {
+jsval_t js_serve(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     fprintf(stderr, "Error: Ant.serve() requires at least 1 argument (port)\n");
     return js_mkundef();
diff --git a/src/modules/sessionstorage.c b/src/modules/sessionstorage.c
index f0e40f2..8d552f6 100644
--- a/src/modules/sessionstorage.c
+++ b/src/modules/sessionstorage.c
@@ -7,6 +7,7 @@
 #include "arena.h"
 #include "runtime.h"
 #include "internal.h"
+#include "descriptors.h"
 
 #include "modules/symbol.h"
 #include "modules/sessionstorage.h"
@@ -84,7 +85,7 @@ static char *storage_key(size_t index) {
 }
 
 // sessionStorage.setItem(key, value)
-static jsval_t js_sessionstorage_setItem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sessionstorage_setItem(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "Failed to execute 'setItem' on 'Storage': 2 arguments required");
   }
@@ -99,7 +100,7 @@ static jsval_t js_sessionstorage_setItem(struct js *js, jsval_t *args, int nargs
 }
 
 // sessionStorage.getItem(key)
-static jsval_t js_sessionstorage_getItem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sessionstorage_getItem(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Failed to execute 'getItem' on 'Storage': 1 argument required");
   }
@@ -114,7 +115,7 @@ static jsval_t js_sessionstorage_getItem(struct js *js, jsval_t *args, int nargs
 }
 
 // sessionStorage.removeItem(key)
-static jsval_t js_sessionstorage_removeItem(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sessionstorage_removeItem(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Failed to execute 'removeItem' on 'Storage': 1 argument required");
   }
@@ -127,14 +128,14 @@ static jsval_t js_sessionstorage_removeItem(struct js *js, jsval_t *args, int na
 }
 
 // sessionStorage.clear()
-static jsval_t js_sessionstorage_clear(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sessionstorage_clear(ant_t *js, jsval_t *args, int nargs) {
   (void)js; (void)args; (void)nargs;
   storage_clear();
   return js_mkundef();
 }
 
 // sessionStorage.key(index)
-static jsval_t js_sessionstorage_key(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sessionstorage_key(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "Failed to execute 'key' on 'Storage': 1 argument required");
   }
@@ -155,13 +156,13 @@ static jsval_t js_sessionstorage_key(struct js *js, jsval_t *args, int nargs) {
 }
 
 // sessionStorage.length
-static jsval_t js_sessionstorage_length(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_sessionstorage_length(ant_t *js, jsval_t *args, int nargs) {
   (void)js; (void)args; (void)nargs;
   return js_mknum((double)storage_length());
 }
 
 void init_sessionstorage_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   
   jsval_t glob = js_glob(js);
   jsval_t storage_obj = js_mkobj(js);
@@ -175,6 +176,6 @@ void init_sessionstorage_module(void) {
   jsval_t length_getter = js_mkfun(js_sessionstorage_length);
   js_set_getter_desc(js, storage_obj, "length", 6, length_getter, JS_DESC_E);
   
-  js_set(js, storage_obj, get_toStringTag_sym_key(), ANT_STRING("Storage"));
+  js_set_sym(js, storage_obj, get_toStringTag_sym(), ANT_STRING("Storage"));
   js_set(js, glob, "sessionStorage", storage_obj);
 }
diff --git a/src/modules/shell.c b/src/modules/shell.c
index 1829169..e97cc42 100644
--- a/src/modules/shell.c
+++ b/src/modules/shell.c
@@ -16,10 +16,10 @@
 #include "internal.h"
 #include "modules/symbol.h"
 
-static jsval_t builtin_shell_text(struct js *js, jsval_t *args, int nargs);
-static jsval_t builtin_shell_lines(struct js *js, jsval_t *args, int nargs);
+static jsval_t builtin_shell_text(ant_t *js, jsval_t *args, int nargs);
+static jsval_t builtin_shell_lines(ant_t *js, jsval_t *args, int nargs);
 
-static jsval_t shell_exec(struct js *js, const char *cmd, size_t cmd_len) {
+static jsval_t shell_exec(ant_t *js, const char *cmd, size_t cmd_len) {
   jsval_t result = js_mkobj(js);
   
   FILE *fp = popen(cmd, "r");
@@ -75,7 +75,7 @@ static jsval_t shell_exec(struct js *js, const char *cmd, size_t cmd_len) {
   return result;
 }
 
-static jsval_t builtin_shell_text(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_shell_text(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   
@@ -83,7 +83,7 @@ static jsval_t builtin_shell_text(struct js *js, jsval_t *args, int nargs) {
   return js_get_slot(js, fn, SLOT_DATA);
 }
 
-static jsval_t builtin_shell_lines(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_shell_lines(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   
@@ -109,7 +109,7 @@ static jsval_t builtin_shell_lines(struct js *js, jsval_t *args, int nargs) {
   return lines_array;
 }
 
-static jsval_t builtin_shell_dollar(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_shell_dollar(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "$() requires at least one argument");
     
   if (!is_special_object(args[0])) {
@@ -194,11 +194,11 @@ static jsval_t builtin_shell_dollar(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-jsval_t shell_library(struct js *js) {
+jsval_t shell_library(ant_t *js) {
   jsval_t lib = js_mkobj(js);
   
   js_set(js, lib, "$", js_mkfun(builtin_shell_dollar));
-  js_set(js, lib, get_toStringTag_sym_key(), js_mkstr(js, "shell", 5));
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "shell", 5));
   
   return lib;
 }
diff --git a/src/modules/symbol.c b/src/modules/symbol.c
index 454ac91..0d6aa8b 100644
--- a/src/modules/symbol.c
+++ b/src/modules/symbol.c
@@ -7,107 +7,23 @@
 #include "errors.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/engine.h"
 #include "modules/symbol.h"
-
-typedef struct {
-  jsval_t sym;
-  char key[32];
-} wellknown_sym_t;
-
-static wellknown_sym_t g_iterator = {0};
-static wellknown_sym_t g_asyncIterator = {0};
-static wellknown_sym_t g_toStringTag = {0};
-static wellknown_sym_t g_hasInstance = {0};
-static wellknown_sym_t g_match = {0};
-static wellknown_sym_t g_replace = {0};
-static wellknown_sym_t g_search = {0};
-static wellknown_sym_t g_split = {0};
-static wellknown_sym_t g_isConcatSpreadable = {0};
-static wellknown_sym_t g_observable = {0};
-static wellknown_sym_t g_toPrimitive = {0};
-static wellknown_sym_t g_species = {0};
-static wellknown_sym_t g_unscopables = {0};
+#include "descriptors.h"
 
 static jsval_t g_iterator_proto_obj = {0};
 static jsval_t g_array_iterator_proto_obj = {0};
 static jsval_t g_string_iterator_proto_obj = {0};
 
-const char *get_iterator_sym_key(void) { return g_iterator.key; }
-const char *get_asyncIterator_sym_key(void) { return g_asyncIterator.key; }
-const char *get_toStringTag_sym_key(void) { return g_toStringTag.key; }
-const char *get_observable_sym_key(void) { return g_observable.key; }
-const char *get_toPrimitive_sym_key(void) { return g_toPrimitive.key; }
-const char *get_hasInstance_sym_key(void) { return g_hasInstance.key; }
-const char *get_match_sym_key(void) { return g_match.key; }
-const char *get_replace_sym_key(void) { return g_replace.key; }
-const char *get_search_sym_key(void) { return g_search.key; }
-const char *get_split_sym_key(void) { return g_split.key; }
-const char *get_isConcatSpreadable_sym_key(void) { return g_isConcatSpreadable.key; }
-const char *get_species_sym_key(void) { return g_species.key; }
-const char *get_unscopables_sym_key(void) { return g_unscopables.key; }
-
-static const struct { jsval_t *sym; const char *name; } sym_table[] = {
-  { &g_iterator.sym, "Symbol.iterator" },
-  { &g_asyncIterator.sym, "Symbol.asyncIterator" },
-  { &g_toStringTag.sym, "Symbol.toStringTag" },
-  { &g_hasInstance.sym, "Symbol.hasInstance" },
-  { &g_match.sym, "Symbol.match" },
-  { &g_replace.sym, "Symbol.replace" },
-  { &g_search.sym, "Symbol.search" },
-  { &g_split.sym, "Symbol.split" },
-  { &g_isConcatSpreadable.sym, "Symbol.isConcatSpreadable" },
-  { &g_observable.sym, "Symbol.observable" },
-  { &g_toPrimitive.sym, "Symbol.toPrimitive" },
-  { &g_species.sym, "Symbol.species" },
-  { &g_unscopables.sym, "Symbol.unscopables" },
-};
-
-bool is_symbol_key(const char *key, size_t key_len) {
-  return 
-    key_len > 7 
-    && memcmp(key, "__sym_", 6) == 0 
-    && key[key_len - 1] == '_' 
-    && key[key_len - 2] == '_';
-}
-
-int sym_to_prop_key(jsval_t sym, char *buf, size_t bufsz) {
-  return snprintf(buf, bufsz, "__sym_%llu__", (unsigned long long)js_sym_id(sym));
-}
+#define DECL_SYM(name, _desc) static jsval_t g_##name = {0};
+WELLKNOWN_SYMBOLS(DECL_SYM)
+#undef DECL_SYM
 
-jsval_t get_wellknown_sym_by_key(const char *key, size_t key_len) {
-  static const struct { wellknown_sym_t *sym; } table[] = {
-    { &g_iterator }, { &g_asyncIterator }, { &g_toStringTag },
-    { &g_hasInstance }, { &g_match }, { &g_replace }, { &g_search }, { &g_split },
-    { &g_isConcatSpreadable }, { &g_observable }, { &g_toPrimitive },
-    { &g_species }, { &g_unscopables }
-  };
-  for (size_t i = 0; i < sizeof(table)/sizeof(table[0]); i++) {
-    if (table[i].sym->key[0] && strlen(table[i].sym->key) == key_len &&
-        memcmp(table[i].sym->key, key, key_len) == 0)
-      return table[i].sym->sym;
-  }
-  return (jsval_t)0;
-}
+#define DEF_GET_SYM(name, _desc) jsval_t get_##name##_sym(void) { return g_##name; }
+WELLKNOWN_SYMBOLS(DEF_GET_SYM)
+#undef DEF_GET_SYM
 
-const char *get_symbol_description_from_key(const char *sym_key, size_t key_len) {
-  if (!is_symbol_key(sym_key, key_len)) return NULL;
-  
-  uint64_t id = 0;
-  for (const char *p = sym_key + 6; *p >= '0' && *p <= '9'; p++) id = id * 10 + (*p - '0');
-  
-  for (size_t i = 0; i < sizeof(sym_table) / sizeof(sym_table[0]); i++) {
-    if (js_sym_id(*sym_table[i].sym) == id) return sym_table[i].name;
-  }
-  
-  return "Symbol()";
-}
-
-static inline void init_symbol(struct js *js, wellknown_sym_t *sym_var, const char *name) {
-  sym_var->sym = js_mksym(js, name);
-  sym_to_prop_key(sym_var->sym, sym_var->key, sizeof(sym_var->key));
-}
-
-static jsval_t builtin_Symbol(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Symbol(ant_t *js, jsval_t *args, int nargs) {
   const char *desc = NULL;
   if (nargs > 0 && vtype(args[0]) == T_STR) {
     desc = js_getstr(js, args[0], NULL);
@@ -115,7 +31,7 @@ static jsval_t builtin_Symbol(struct js *js, jsval_t *args, int nargs) {
   return js_mksym(js, desc);
 }
 
-static jsval_t builtin_Symbol_for(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Symbol_for(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "Symbol.for requires a string argument");
   }
@@ -126,7 +42,7 @@ static jsval_t builtin_Symbol_for(struct js *js, jsval_t *args, int nargs) {
   return js_mksym_for(js, key);
 }
 
-static jsval_t builtin_Symbol_keyFor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Symbol_keyFor(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1 || vtype(args[0]) != T_SYMBOL) {
     return js_mkundef();
   }
@@ -137,7 +53,7 @@ static jsval_t builtin_Symbol_keyFor(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, key, strlen(key));
 }
 
-static jsval_t builtin_Symbol_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t builtin_Symbol_toString(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   
   if (vtype(this_val) != T_SYMBOL) {
@@ -147,9 +63,10 @@ static jsval_t builtin_Symbol_toString(struct js *js, jsval_t *args, int nargs)
   return js_symbol_to_string(js, this_val);
 }
 
-static jsval_t iterator_next(struct js *js, jsval_t *args, int nargs) {
+static jsval_t iterator_next(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   
+  // migrate to slots
   jsval_t arr = js_get(js, this_val, "__arr");
   jsval_t idx_val = js_get(js, this_val, "__idx");
   jsval_t len_val = js_get(js, this_val, "__len");
@@ -174,21 +91,17 @@ static jsval_t iterator_next(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t iter_return_this(struct js *js, jsval_t *args, int nargs) {
-  return js->this_val;
-}
-
-static jsval_t get_iterator_prototype(struct js *js) {
+static jsval_t get_iterator_prototype(ant_t *js) {
   if (vtype(g_iterator_proto_obj) == T_OBJ) return g_iterator_proto_obj;
 
   g_iterator_proto_obj = js_mkobj(js);
   js_set_proto(js, g_iterator_proto_obj, js->object);
-  if (g_iterator.key[0]) js_set(js, g_iterator_proto_obj, g_iterator.key, js_mkfun(iter_return_this));
+  js_set_sym(js, g_iterator_proto_obj, g_iterator, js_mkfun(sym_this_cb));
   
   return g_iterator_proto_obj;
 }
 
-static jsval_t get_array_iterator_prototype(struct js *js) {
+static jsval_t get_array_iterator_prototype(ant_t *js) {
   if (vtype(g_array_iterator_proto_obj) == T_OBJ) return g_array_iterator_proto_obj;
 
   jsval_t iterator_proto = get_iterator_prototype(js);
@@ -199,7 +112,7 @@ static jsval_t get_array_iterator_prototype(struct js *js) {
   return g_array_iterator_proto_obj;
 }
 
-static jsval_t array_iterator(struct js *js, jsval_t *args, int nargs) {
+static jsval_t array_iterator(ant_t *js, jsval_t *args, int nargs) {
   jsval_t arr = js_getthis(js);
   jsval_t len_val = js_get(js, arr, "length");
   int len = vtype(len_val) == T_NUM ? (int)js_getnum(len_val) : 0;
@@ -213,7 +126,7 @@ static jsval_t array_iterator(struct js *js, jsval_t *args, int nargs) {
   return iter;
 }
 
-static jsval_t string_iterator_next(struct js *js, jsval_t *args, int nargs) {
+static jsval_t string_iterator_next(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   
   jsval_t str = js_get(js, this_val, "__str");
@@ -244,7 +157,7 @@ static jsval_t string_iterator_next(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t get_string_iterator_prototype(struct js *js) {
+static jsval_t get_string_iterator_prototype(ant_t *js) {
   if (vtype(g_string_iterator_proto_obj) == T_OBJ) return g_string_iterator_proto_obj;
 
   jsval_t iterator_proto = get_iterator_prototype(js);
@@ -255,7 +168,7 @@ static jsval_t get_string_iterator_prototype(struct js *js) {
   return g_string_iterator_proto_obj;
 }
 
-static jsval_t string_iterator(struct js *js, jsval_t *args, int nargs) {
+static jsval_t string_iterator(ant_t *js, jsval_t *args, int nargs) {
   jsval_t str = js_getthis(js);
   size_t len; js_getstr(js, str, &len);
   
@@ -268,62 +181,44 @@ static jsval_t string_iterator(struct js *js, jsval_t *args, int nargs) {
   return iter;
 }
 
-static jsval_t species_getter(struct js *js, jsval_t *args, int nargs) {
-  (void)args; (void)nargs;
-  return js_getthis(js);
-}
+jsval_t maybe_call_symbol_method(
+  ant_t *js, jsval_t target,
+  jsval_t sym,
+  jsval_t this_arg, jsval_t *args,
+  int nargs, bool *called
+) {
+  *called = false;
+  if (vtype(sym) != T_SYMBOL || !is_object_type(target)) return js_mkundef();
+
+  jsval_t method = js_get_sym(js, target, sym);
+  if (is_err(method)) return method;
+
+  uint8_t mt = vtype(method);
+  if (mt == T_UNDEF || mt == T_NULL) return js_mkundef();
+  if (mt != T_FUNC && mt != T_CFUNC) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol method is not callable");
+  }
 
-void js_define_species_getter(struct js *js, jsval_t ctor) {
-  if (vtype(ctor) == T_FUNC) ctor = mkval(T_OBJ, vdata(ctor));
-  if (vtype(ctor) != T_OBJ || g_species.key[0] == '\0') return;
-  js_set_getter_desc(js, ctor, g_species.key, strlen(g_species.key), js_mkfun(species_getter), JS_DESC_C);
+  *called = true;
+  return sv_vm_call(js->vm, js, method, this_arg, args, nargs, NULL, false);
 }
 
-static jsval_t date_toPrimitive(struct js *js, jsval_t *args, int nargs) {
-  jsval_t this_val = js_getthis(js);
-  
-  const char *hint = "default";
-  if (nargs > 0 && vtype(args[0]) == T_STR) {
-    hint = js_getstr(js, args[0], NULL);
-  } bool prefer_string = (hint == NULL || strcmp(hint, "number") != 0);
-  
-  const char *methods[2] = {
-    prefer_string ? "toString" : "valueOf",
-    prefer_string ? "valueOf" : "toString"
-  };
-  
-  for (int i = 0; i < 2; i++) {
-    jsval_t method = js_getprop_fallback(js, this_val, methods[i]);
-    if (vtype(method) == T_FUNC || vtype(method) == T_CFUNC) {
-      jsval_t result = js_call_with_this(js, method, this_val, NULL, 0);
-      if (is_err(result) || !is_object_type(result)) return result;
-    }
-  }
-  
-  return js_mkerr(js, "Cannot convert object to primitive value");
+void js_define_species_getter(ant_t *js, jsval_t ctor) {
+  if (vtype(ctor) == T_FUNC) ctor = js_func_obj(ctor);
+  if (vtype(ctor) != T_OBJ || vtype(g_species) != T_SYMBOL) return;
+  js_set_sym_getter_desc(js, ctor, g_species, js_mkfun(sym_this_cb), JS_DESC_C);
 }
 
-
 void init_symbol_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
 
   g_iterator_proto_obj = js_mkundef();
   g_array_iterator_proto_obj = js_mkundef();
   g_string_iterator_proto_obj = js_mkundef();
   
-  init_symbol(js, &g_iterator, "Symbol.iterator");
-  init_symbol(js, &g_asyncIterator, "Symbol.asyncIterator");
-  init_symbol(js, &g_toStringTag, "Symbol.toStringTag");
-  init_symbol(js, &g_observable, "Symbol.observable");
-  init_symbol(js, &g_toPrimitive, "Symbol.toPrimitive");
-  init_symbol(js, &g_hasInstance, "Symbol.hasInstance");
-  init_symbol(js, &g_match, "Symbol.match");
-  init_symbol(js, &g_replace, "Symbol.replace");
-  init_symbol(js, &g_search, "Symbol.search");
-  init_symbol(js, &g_split, "Symbol.split");
-  init_symbol(js, &g_isConcatSpreadable, "Symbol.isConcatSpreadable");
-  init_symbol(js, &g_species, "Symbol.species");
-  init_symbol(js, &g_unscopables, "Symbol.unscopables");
+  #define INIT_SYM(name, desc) g_##name = js_mksym(js, desc);
+  WELLKNOWN_SYMBOLS(INIT_SYM)
+  #undef INIT_SYM
 
   jsval_t symbol_proto = js_mkobj(js);
   js_set(js, symbol_proto, "toString", js_mkfun(builtin_Symbol_toString));
@@ -334,32 +229,22 @@ void init_symbol_module(void) {
   js_set(js, symbol_ctor, "keyFor", js_mkfun(builtin_Symbol_keyFor));
   js_set(js, symbol_ctor, "prototype", symbol_proto);
   
-  js_set(js, symbol_ctor, "iterator", g_iterator.sym);
-  js_set(js, symbol_ctor, "asyncIterator", g_asyncIterator.sym);
-  js_set(js, symbol_ctor, "toStringTag", g_toStringTag.sym);
-  js_set(js, symbol_ctor, "hasInstance", g_hasInstance.sym);
-  js_set(js, symbol_ctor, "match", g_match.sym);
-  js_set(js, symbol_ctor, "replace", g_replace.sym);
-  js_set(js, symbol_ctor, "search", g_search.sym);
-  js_set(js, symbol_ctor, "split", g_split.sym);
-  js_set(js, symbol_ctor, "isConcatSpreadable", g_isConcatSpreadable.sym);
-  js_set(js, symbol_ctor, "observable", g_observable.sym);
-  js_set(js, symbol_ctor, "toPrimitive", g_toPrimitive.sym);
-  js_set(js, symbol_ctor, "species", g_species.sym);
-  js_set(js, symbol_ctor, "unscopables", g_unscopables.sym);
+  #define SET_CTOR_SYM(name, _desc) js_set(js, symbol_ctor, #name, g_##name);
+  WELLKNOWN_SYMBOLS(SET_CTOR_SYM)
+  #undef SET_CTOR_SYM
   
   jsval_t func_symbol = js_obj_to_func(symbol_ctor);
   js_set(js, js_glob(js), "Symbol", func_symbol);
   
   // set internal types before ant module snapshot
-  js_set(js, rt->ant_obj, get_toStringTag_sym_key(), js_mkstr(js, "Ant", 3));
+  js_set_sym(js, rt->ant_obj, g_toStringTag, js_mkstr(js, "Ant", 3));
   
   jsval_t array_ctor = js_get(js, js_glob(js), "Array");
   jsval_t array_proto = js_get(js, array_ctor, "prototype");
   
   (void)get_array_iterator_prototype(js);
   (void)get_string_iterator_prototype(js);
-  js_set(js, array_proto, g_iterator.key, js_mkfun(array_iterator));
+  js_set_sym(js, array_proto, g_iterator, js_mkfun(array_iterator));
 
   jsval_t array_unscopables = js_mkobj(js);
   js_set(js, array_unscopables, "find", js_true);
@@ -371,32 +256,31 @@ void init_symbol_module(void) {
   js_set(js, array_unscopables, "values", js_true);
   js_set(js, array_unscopables, "flat", js_true);
   js_set(js, array_unscopables, "flatMap", js_true);
-  js_set(js, array_proto, g_unscopables.key, array_unscopables);
+  js_set_sym(js, array_proto, g_unscopables, array_unscopables);
   
   jsval_t string_ctor = js_get(js, js_glob(js), "String");
   jsval_t string_proto = js_get(js, string_ctor, "prototype");
-  js_set(js, string_proto, g_iterator.key, js_mkfun(string_iterator));
-  
-  jsval_t date_ctor = js_get(js, js_glob(js), "Date");
-  jsval_t date_proto = js_get(js, date_ctor, "prototype");
-  js_set(js, date_proto, g_toPrimitive.key, js_mkfun(date_toPrimitive));
-
-  jsval_t regexp_ctor = js_get(js, js_glob(js), "RegExp");
-  jsval_t regexp_proto = js_get(js, regexp_ctor, "prototype");
-  js_set(js, regexp_proto, g_split.key, js_mkfun(builtin_regexp_symbol_split));
-  js_set(js, regexp_proto, g_match.key, js_mkfun(builtin_regexp_symbol_match));
-  js_set(js, regexp_proto, g_replace.key, js_mkfun(builtin_regexp_symbol_replace));
-  js_set(js, regexp_proto, g_search.key, js_mkfun(builtin_regexp_symbol_search));
-  js_set_getter_desc(js, regexp_proto, "flags", 5, js_mkfun(builtin_regexp_flags_getter), JS_DESC_C);
+  js_set_sym(js, string_proto, g_iterator, js_mkfun(string_iterator));
   
   jsval_t promise_ctor = js_get(js, js_glob(js), "Promise");
   jsval_t promise_proto = js_get(js, promise_ctor, "prototype");
-  js_set(js, promise_proto, g_toStringTag.key, js_mkstr(js, "Promise", 7));
+  js_set_sym(js, promise_proto, g_toStringTag, js_mkstr(js, "Promise", 7));
 
   jsval_t math_obj = js_get(js, js_glob(js), "Math");
-  if (is_object_type(math_obj)) js_set(js, math_obj, g_toStringTag.key, js_mkstr(js, "Math", 4));
+  if (is_object_type(math_obj)) js_set_sym(js, math_obj, g_toStringTag, js_mkstr(js, "Math", 4));
 
   js_define_species_getter(js, promise_ctor);
   js_define_species_getter(js, array_ctor);
-  js_define_species_getter(js, regexp_ctor);
+}
+
+void symbol_gc_update_roots(GC_OP_VAL_ARGS) {
+  op_val(ctx, &g_iterator_proto_obj);
+  op_val(ctx, &g_array_iterator_proto_obj);
+  op_val(ctx, &g_string_iterator_proto_obj);
+
+  #define GC_SYM(name, _desc) op_val(ctx, &g_##name);
+  WELLKNOWN_SYMBOLS(GC_SYM)
+  #undef GC_SYM
+
+  sym_gc_update_all(op_val, ctx);
 }
diff --git a/src/modules/textcodec.c b/src/modules/textcodec.c
index 496f6eb..9fcc315 100644
--- a/src/modules/textcodec.c
+++ b/src/modules/textcodec.c
@@ -5,13 +5,14 @@
 #include "runtime.h"
 #include "errors.h"
 #include "internal.h"
+#include "silver/engine.h"
 
 #include "modules/textcodec.h"
 #include "modules/buffer.h"
 #include "modules/symbol.h"
 
 // TextEncoder.prototype.encode(string)
-static jsval_t js_textencoder_encode(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_textencoder_encode(ant_t *js, jsval_t *args, int nargs) {
   size_t str_len = 0;
   const char *str = "";
   
@@ -31,7 +32,7 @@ static jsval_t js_textencoder_encode(struct js *js, jsval_t *args, int nargs) {
   jsval_t saved_new_target = js->new_target;
   
   js->new_target = uint8array_ctor;
-  jsval_t arr = js_call(js, uint8array_ctor, &len_arg, 1);
+  jsval_t arr = sv_vm_call(js->vm, js, uint8array_ctor, js_mkundef(), &len_arg, 1, NULL, true);
   
   js->new_target = saved_new_target;
   if (vtype(arr) == T_ERR) return arr;
@@ -46,7 +47,7 @@ static jsval_t js_textencoder_encode(struct js *js, jsval_t *args, int nargs) {
 }
 
 // TextEncoder.prototype.encodeInto(string, uint8array)
-static jsval_t js_textencoder_encodeInto(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_textencoder_encodeInto(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "encodeInto requires string and Uint8Array arguments");
   }
@@ -80,7 +81,7 @@ static jsval_t js_textencoder_encodeInto(struct js *js, jsval_t *args, int nargs
   return result;
 }
 
-static jsval_t js_textencoder_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_textencoder_constructor(ant_t *js, jsval_t *args, int nargs) {
   (void)args;
   (void)nargs;
   
@@ -88,13 +89,13 @@ static jsval_t js_textencoder_constructor(struct js *js, jsval_t *args, int narg
   js_set(js, obj, "encoding", js_mkstr(js, "utf-8", 5));
   js_set(js, obj, "encode", js_mkfun(js_textencoder_encode));
   js_set(js, obj, "encodeInto", js_mkfun(js_textencoder_encodeInto));
-  js_set(js, obj, get_toStringTag_sym_key(), js_mkstr(js, "TextEncoder", 11));
+  js_set_sym(js, obj, get_toStringTag_sym(), js_mkstr(js, "TextEncoder", 11));
   
   return obj;
 }
 
 // TextDecoder.prototype.decode(bufferSource)
-static jsval_t js_textdecoder_decode(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_textdecoder_decode(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkstr(js, "", 0);
   }
@@ -118,7 +119,7 @@ static jsval_t js_textdecoder_decode(struct js *js, jsval_t *args, int nargs) {
   return js_mkstr(js, "", 0);
 }
 
-static jsval_t js_textdecoder_constructor(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_textdecoder_constructor(ant_t *js, jsval_t *args, int nargs) {
   const char *encoding = "utf-8";
   size_t encoding_len = 5;
   
@@ -135,13 +136,13 @@ static jsval_t js_textdecoder_constructor(struct js *js, jsval_t *args, int narg
   js_set(js, obj, "fatal", js_false);
   js_set(js, obj, "ignoreBOM", js_false);
   js_set(js, obj, "decode", js_mkfun(js_textdecoder_decode));
-  js_set(js, obj, get_toStringTag_sym_key(), js_mkstr(js, "TextDecoder", 11));
+  js_set_sym(js, obj, get_toStringTag_sym(), js_mkstr(js, "TextDecoder", 11));
   
   return obj;
 }
 
 void init_textcodec_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t glob = js_glob(js);
   
   jsval_t textencoder_constructor = js_mkfun(js_textencoder_constructor);
diff --git a/src/modules/timer.c b/src/modules/timer.c
index 5556596..a144048 100644
--- a/src/modules/timer.c
+++ b/src/modules/timer.c
@@ -8,7 +8,7 @@
 
 #include "arena.h"
 #include "errors.h"
-#include "internal.h"
+#include "silver/engine.h"
 #include "runtime.h"
 #include "modules/timer.h"
 
@@ -19,6 +19,7 @@ typedef struct timer_entry {
   int nargs;
   int timer_id;
   int active;
+  int closed;
   int is_interval;
   struct timer_entry *next;
   struct timer_entry *prev;
@@ -38,7 +39,7 @@ typedef struct immediate_entry {
 } immediate_entry_t;
 
 static struct {
-  struct js *js;
+  ant_t *js;
   timer_entry_t *timers;
   microtask_entry_t *microtasks;
   microtask_entry_t *microtasks_tail;
@@ -64,6 +65,13 @@ static void remove_timer_entry(timer_entry_t *entry) {
   if (entry->next) entry->next->prev = entry->prev;
 }
 
+static int timer_entry_is_registered(timer_entry_t *entry) {
+  for (timer_entry_t *it = timer_state.timers; it != NULL; it = it->next) {
+    if (it == entry) return 1;
+  }
+  return 0;
+}
+
 static int timer_copy_args(timer_entry_t *entry, jsval_t *args, int nargs) {
   entry->nargs = nargs > 2 ? nargs - 2 : 0;
   if (entry->nargs > 0) {
@@ -77,34 +85,43 @@ static int timer_copy_args(timer_entry_t *entry, jsval_t *args, int nargs) {
 static void timer_close_cb(uv_handle_t *h) {
   timer_entry_t *entry = (timer_entry_t *)h->data;
   if (!entry) return;
-  
-  remove_timer_entry(entry);
+  if (entry->closed) return;
+  if (timer_entry_is_registered(entry)) remove_timer_entry(entry);
+  entry->closed = 1;
+  entry->active = 0;
   entry->callback = 0;
   entry->next = NULL;
   entry->prev = NULL;
-  h->data = NULL;
   
-  if (entry->args) free(entry->args);
-  free(entry);
+  if (entry->args) {
+    free(entry->args);
+    entry->args = NULL;
+  }
+  entry->nargs = 0;
 }
 
 static void timer_callback(uv_timer_t *handle) {
   timer_entry_t *entry = (timer_entry_t *)handle->data;
-  if (!entry || !entry->active) return;
-  
-  struct js *js = timer_state.js;
-  js_call(js, entry->callback, entry->args, entry->nargs);
-  process_microtasks(js);
+  if (!entry || entry->closed || !timer_entry_is_registered(entry) || !entry->active) return;
   
+  ant_t *js = timer_state.js;
   if (!entry->is_interval) {
     entry->active = 0;
     timer_state.active_timer_count--;
-    uv_close((uv_handle_t *)&entry->handle, timer_close_cb);
+  }
+
+  sv_vm_call(js->vm, js, entry->callback, js_mkundef(), entry->args, entry->nargs, NULL, false);
+  process_microtasks(js);
+  
+  if (!entry->is_interval) {
+    if (!uv_is_closing((uv_handle_t *)&entry->handle)) {
+      uv_close((uv_handle_t *)&entry->handle, timer_close_cb);
+    }
   }
 }
 
 // setTimeout(callback, delay, ...args)
-static jsval_t js_set_timeout(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_set_timeout(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "setTimeout requires 2 arguments (callback, delay)");
   }
@@ -126,6 +143,7 @@ static jsval_t js_set_timeout(struct js *js, jsval_t *args, int nargs) {
   entry->callback = callback;
   entry->timer_id = timer_state.next_timer_id++;
   entry->active = 1;
+  entry->closed = 0;
   entry->is_interval = 0;
   
   add_timer_entry(entry);
@@ -136,7 +154,7 @@ static jsval_t js_set_timeout(struct js *js, jsval_t *args, int nargs) {
 }
 
 // setInterval(callback, delay, ...args)
-static jsval_t js_set_interval(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_set_interval(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) {
     return js_mkerr(js, "setInterval requires 2 arguments (callback, delay)");
   }
@@ -158,6 +176,7 @@ static jsval_t js_set_interval(struct js *js, jsval_t *args, int nargs) {
   entry->callback = callback;
   entry->timer_id = timer_state.next_timer_id++;
   entry->active = 1;
+  entry->closed = 0;
   entry->is_interval = 1;
   
   add_timer_entry(entry);
@@ -168,14 +187,16 @@ static jsval_t js_set_interval(struct js *js, jsval_t *args, int nargs) {
 }
 
 // clearTimeout(timerId)
-static jsval_t js_clear_timeout(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_clear_timeout(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   int timer_id = (int)js_getnum(args[0]);
   
   for (timer_entry_t *entry = timer_state.timers; entry != NULL; entry = entry->next) {
     if (entry->timer_id == timer_id && entry->active) {
       entry->active = 0; timer_state.active_timer_count--;
-      uv_close((uv_handle_t *)&entry->handle, timer_close_cb); break;
+      if (!uv_is_closing((uv_handle_t *)&entry->handle)) {
+        uv_close((uv_handle_t *)&entry->handle, timer_close_cb);
+      } break;
     }
   }
   
@@ -183,7 +204,7 @@ static jsval_t js_clear_timeout(struct js *js, jsval_t *args, int nargs) {
 }
 
 // setImmediate(callback)
-static jsval_t js_set_immediate(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_set_immediate(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "setImmediate requires 1 argument (callback)");
   }
@@ -212,7 +233,7 @@ static jsval_t js_set_immediate(struct js *js, jsval_t *args, int nargs) {
 }
 
 // clearImmediate(immediateId)
-static jsval_t js_clear_immediate(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_clear_immediate(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();  
   int immediate_id = (int)js_getnum(args[0]);
   
@@ -224,7 +245,7 @@ static jsval_t js_clear_immediate(struct js *js, jsval_t *args, int nargs) {
 }
 
 // queueMicrotask(callback)
-static jsval_t js_queue_microtask(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_queue_microtask(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) {
     return js_mkerr(js, "queueMicrotask requires 1 argument (callback)");
   }
@@ -233,7 +254,7 @@ static jsval_t js_queue_microtask(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-void queue_microtask(struct js *js, jsval_t callback) {
+void queue_microtask(ant_t *js, jsval_t callback) {
   microtask_entry_t *entry = ant_calloc(sizeof(microtask_entry_t));
   if (entry == NULL) return;
   
@@ -267,7 +288,7 @@ void queue_promise_trigger(uint32_t promise_id) {
   }
 }
 
-void process_microtasks(struct js *js) {
+void process_microtasks(ant_t *js) {
   while (timer_state.microtasks != NULL) {
     microtask_entry_t *entry = timer_state.microtasks;
     timer_state.microtasks = entry->next;
@@ -280,7 +301,7 @@ void process_microtasks(struct js *js) {
       js_process_promise_handlers(js, entry->promise_id);
     } else {
       jsval_t args[0];
-      js_call(js, entry->callback, args, 0);
+      sv_vm_call(js->vm, js, entry->callback, js_mkundef(), args, 0, NULL, false);
     }
     
     free(entry);
@@ -289,7 +310,7 @@ void process_microtasks(struct js *js) {
   js_check_unhandled_rejections(js);
 }
 
-void process_immediates(struct js *js) {
+void process_immediates(ant_t *js) {
   while (timer_state.immediates != NULL) {
     immediate_entry_t *entry = timer_state.immediates;
     timer_state.immediates = entry->next;
@@ -300,7 +321,7 @@ void process_immediates(struct js *js) {
     
     if (entry->active) {
       jsval_t args[0];
-      js_call(js, entry->callback, args, 0);
+      sv_vm_call(js->vm, js, entry->callback, js_mkundef(), args, 0, NULL, false);
       process_microtasks(js);
     }
     
@@ -325,7 +346,7 @@ int has_pending_microtasks(void) {
 }
 
 void init_timer_module() {  
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
 
   timer_state.js = js;
   jsval_t global = js_glob(js);
diff --git a/src/modules/tty.c b/src/modules/tty.c
new file mode 100644
index 0000000..dbe8667
--- /dev/null
+++ b/src/modules/tty.c
@@ -0,0 +1,763 @@
+#include <compat.h> // IWYU pragma: keep
+
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <uv.h>
+
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#define ANT_WRITE_FD _write
+#define ANT_ISATTY _isatty
+#define ANT_STDIN_FD 0
+#define ANT_STDOUT_FD 1
+#define ANT_STDERR_FD 2
+#else
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <unistd.h>
+#define ANT_WRITE_FD write
+#define ANT_ISATTY isatty
+#define ANT_STDIN_FD STDIN_FILENO
+#define ANT_STDOUT_FD STDOUT_FILENO
+#define ANT_STDERR_FD STDERR_FILENO
+#endif
+
+#include "ant.h"
+#include "descriptors.h"
+#include "errors.h"
+#include "internal.h"
+#include "runtime.h"
+#include "silver/engine.h"
+
+#include "modules/symbol.h"
+#include "modules/tty.h"
+
+static inline bool is_callable(jsval_t value) {
+  uint8_t t = vtype(value);
+  return t == T_FUNC || t == T_CFUNC;
+}
+
+static bool parse_int(jsval_t value, int *out) {
+  if (vtype(value) != T_NUM) return false;
+  double d = js_getnum(value);
+  if (!isfinite(d)) return false;
+  if (d < (double)INT_MIN || d > (double)INT_MAX) return false;
+  int i = (int)d;
+  if ((double)i != d) return false;
+  *out = i;
+  return true;
+}
+
+static bool parse_fd(jsval_t value, int *fd_out) {
+  int fd = 0;
+  if (!parse_int(value, &fd)) return false;
+  if (fd < 0) return false;
+  *fd_out = fd;
+  return true;
+}
+
+static bool is_tty_fd(int fd) {
+  if (fd < 0) return false;
+  return uv_guess_handle(fd) == UV_TTY;
+}
+
+static int stream_fd_from_this(ant_t *js, int fallback_fd) {
+  jsval_t this_obj = js_getthis(js);
+  if (!is_special_object(this_obj)) return fallback_fd;
+
+  jsval_t fd_val = js_get(js, this_obj, "fd");
+  int fd = 0;
+  if (!parse_fd(fd_val, &fd)) return fallback_fd;
+  return fd;
+}
+
+static bool write_to_fd(int fd, const char *data, size_t len) {
+  if (fd < 0 || !data) return false;
+  if (len == 0) return true;
+
+  size_t off = 0;
+  while (off < len) {
+#ifdef _WIN32
+    size_t rem = len - off;
+    unsigned int chunk = (rem > (size_t)INT_MAX) ? (unsigned int)INT_MAX : (unsigned int)rem;
+    int wrote = ANT_WRITE_FD(fd, data + off, chunk);
+    if (wrote <= 0) return false;
+    off += (size_t)wrote;
+#else
+    ssize_t wrote = ANT_WRITE_FD(fd, data + off, len - off);
+    if (wrote < 0) {
+      if (errno == EINTR) continue;
+      return false;
+    }
+    if (wrote == 0) return false;
+    off += (size_t)wrote;
+#endif
+  }
+  return true;
+}
+
+static void get_tty_size(int fd, int *rows, int *cols) {
+  int out_rows = 24;
+  int out_cols = 80;
+
+#ifdef _WIN32
+  HANDLE handle = INVALID_HANDLE_VALUE;
+  if (fd == ANT_STDOUT_FD) {
+    handle = GetStdHandle(STD_OUTPUT_HANDLE);
+  } else if (fd == ANT_STDERR_FD) {
+    handle = GetStdHandle(STD_ERROR_HANDLE);
+  } else {
+    intptr_t os_handle = _get_osfhandle(fd);
+    if (os_handle != -1) handle = (HANDLE)os_handle;
+  }
+
+  if (handle != INVALID_HANDLE_VALUE) {
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    if (GetConsoleScreenBufferInfo(handle, &csbi)) {
+      int width = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+      int height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+      if (height > 0) out_rows = height;
+      if (width > 0) out_cols = width;
+    }
+  }
+#else
+  struct winsize ws;
+  if (ioctl(fd, TIOCGWINSZ, &ws) == 0) {
+    if (ws.ws_row > 0) out_rows = (int)ws.ws_row;
+    if (ws.ws_col > 0) out_cols = (int)ws.ws_col;
+  }
+#endif
+
+  if (rows) *rows = out_rows;
+  if (cols) *cols = out_cols;
+}
+
+static bool str_case_eq(const char *a, const char *b) {
+  if (!a || !b) return false;
+  while (*a && *b) {
+    int ca = tolower((unsigned char)*a);
+    int cb = tolower((unsigned char)*b);
+    if (ca != cb) return false;
+    a++;
+    b++;
+  }
+  return *a == '\0' && *b == '\0';
+}
+
+static bool str_case_contains(const char *haystack, const char *needle) {
+  if (!haystack || !needle) return false;
+  size_t needle_len = strlen(needle);
+  if (needle_len == 0) return true;
+
+  size_t hay_len = strlen(haystack);
+  if (needle_len > hay_len) return false;
+
+  for (size_t i = 0; i + needle_len <= hay_len; i++) {
+    bool match = true;
+    for (size_t j = 0; j < needle_len; j++) {
+      int ca = tolower((unsigned char)haystack[i + j]);
+      int cb = tolower((unsigned char)needle[j]);
+      if (ca != cb) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return true;
+  }
+  return false;
+}
+
+static bool read_env_object_value(
+  ant_t *js,
+  jsval_t env_obj,
+  const char *key,
+  char *buf,
+  size_t buf_len
+) {
+  if (!is_special_object(env_obj) || !key || !buf || buf_len == 0) return false;
+
+  jsval_t value = js_get(js, env_obj, key);
+  if (vtype(value) == T_UNDEF || vtype(value) == T_NULL) return false;
+
+  jsval_t str_val = js_tostring_val(js, value);
+  size_t len = 0;
+  char *str = js_getstr(js, str_val, &len);
+  if (!str) return false;
+
+  if (len >= buf_len) len = buf_len - 1;
+  memcpy(buf, str, len);
+  buf[len] = '\0';
+  return true;
+}
+
+static const char *get_env_value(
+  ant_t *js,
+  jsval_t env_obj,
+  const char *key,
+  char *buf,
+  size_t buf_len
+) {
+  if (read_env_object_value(js, env_obj, key, buf, buf_len)) return buf;
+  return getenv(key);
+}
+
+static int force_color_depth(const char *force_color) {
+  if (!force_color) return 0;
+  if (*force_color == '\0') return 4;
+  if (strcmp(force_color, "0") == 0) return 1;
+  if (strcmp(force_color, "1") == 0) return 4;
+  if (strcmp(force_color, "2") == 0) return 8;
+  if (strcmp(force_color, "3") == 0) return 24;
+  return 4;
+}
+
+static int detect_color_depth(ant_t *js, int fd, jsval_t env_obj) {
+  if (!is_tty_fd(fd)) return 1;
+
+  char scratch[128];
+  const char *force_color = get_env_value(js, env_obj, "FORCE_COLOR", scratch, sizeof(scratch));
+  int forced = force_color_depth(force_color);
+  if (forced > 0) return forced;
+
+  const char *no_color = get_env_value(js, env_obj, "NO_COLOR", scratch, sizeof(scratch));
+  if (no_color && *no_color) return 1;
+
+  const char *colorterm = get_env_value(js, env_obj, "COLORTERM", scratch, sizeof(scratch));
+  if (colorterm) {
+    if (str_case_contains(colorterm, "truecolor") || str_case_contains(colorterm, "24bit")) {
+      return 24;
+    }
+  }
+
+#ifdef _WIN32
+  return 24;
+#else
+  const char *term = get_env_value(js, env_obj, "TERM", scratch, sizeof(scratch));
+  if (!term) return 4;
+  if (str_case_eq(term, "dumb")) return 1;
+  if (str_case_contains(term, "256color")) return 8;
+  if (str_case_contains(term, "color")
+    || str_case_contains(term, "xterm")
+    || str_case_contains(term, "screen")
+    || str_case_contains(term, "ansi")
+    || str_case_contains(term, "linux")
+    || str_case_contains(term, "cygwin")
+    || str_case_contains(term, "vt100")
+  ) return 4;
+  return 4;
+#endif
+}
+
+static int palette_size_for_depth(int depth) {
+  switch (depth) {
+    case 1: return 2;
+    case 4: return 16;
+    case 8: return 256;
+    case 24: return 16777216;
+    default: return 2;
+  }
+}
+
+static jsval_t make_stream_error(ant_t *js, const char *op, int fd) {
+  return js_mkerr_typed(js, JS_ERR_GENERIC, "tty stream %s failed for fd %d", op, fd);
+}
+
+static void invoke_callback_if_needed(ant_t *js, jsval_t cb, jsval_t arg) {
+  if (!is_callable(cb)) return;
+  jsval_t cb_args[1] = { arg };
+  sv_vm_call(js->vm, js, cb, js_mkundef(), cb_args, 1, NULL, false);
+}
+
+static jsval_t maybe_callback_or_throw(
+  ant_t *js,
+  jsval_t this_obj,
+  jsval_t cb,
+  bool ok,
+  const char *op,
+  int fd
+) {
+  if (is_callable(cb)) {
+    if (ok) {
+      invoke_callback_if_needed(js, cb, js_mknull());
+    } else {
+      jsval_t err = make_stream_error(js, op, fd);
+      invoke_callback_if_needed(js, cb, err);
+    }
+    return this_obj;
+  }
+  if (!ok) return make_stream_error(js, op, fd);
+  return this_obj;
+}
+
+#ifndef _WIN32
+static struct {
+  int fd;
+  bool active;
+  struct termios saved;
+} raw_state = { .fd = -1, .active = false };
+#endif
+
+static bool set_raw_mode_fd(int fd, bool enable) {
+#ifdef _WIN32
+  intptr_t os_handle = _get_osfhandle(fd);
+  if (os_handle == -1) return false;
+  HANDLE handle = (HANDLE)os_handle;
+
+  DWORD mode = 0;
+  if (!GetConsoleMode(handle, &mode)) return false;
+
+  if (enable) {
+    mode &= ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
+  } else {
+    mode |= ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
+  }
+
+  return SetConsoleMode(handle, mode) != 0;
+#else
+  if (!is_tty_fd(fd)) return false;
+
+  if (enable) {
+    if (raw_state.active && raw_state.fd == fd) return true;
+
+    struct termios saved;
+    if (tcgetattr(fd, &saved) == -1) return false;
+
+    struct termios raw = saved;
+    raw.c_lflag &= ~(ICANON | ECHO | ISIG);
+    raw.c_iflag &= ~(IXON | ICRNL);
+    raw.c_cc[VMIN] = 1;
+    raw.c_cc[VTIME] = 0;
+
+    if (tcsetattr(fd, TCSANOW, &raw) == -1) return false;
+    raw_state.fd = fd;
+    raw_state.saved = saved;
+    raw_state.active = true;
+    return true;
+  }
+
+  if (!(raw_state.active && raw_state.fd == fd)) return true;
+  if (tcsetattr(fd, TCSANOW, &raw_state.saved) == -1) return false;
+  raw_state.fd = -1;
+  raw_state.active = false;
+  return true;
+#endif
+}
+
+static jsval_t get_process_stream(ant_t *js, const char *name) {
+  jsval_t process_obj = js_get(js, js_glob(js), "process");
+  if (!is_special_object(process_obj)) return js_mkundef();
+
+  jsval_t stream = js_get(js, process_obj, name);
+  if (!is_special_object(stream)) return js_mkundef();
+  return stream;
+}
+
+static void ensure_stream_common_props(ant_t *js, jsval_t stream, int fd) {
+  if (!is_special_object(stream)) return;
+  js_set(js, stream, "fd", js_mknum((double)fd));
+  js_set(js, stream, "isTTY", js_bool(is_tty_fd(fd)));
+}
+
+static jsval_t tty_isatty(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_false;
+
+  int fd = 0;
+  if (!parse_fd(args[0], &fd)) return js_false;
+  return js_bool(ANT_ISATTY(fd) != 0);
+}
+
+static jsval_t tty_stream_write(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 1) return js_false;
+
+  size_t len = 0;
+  char *data = js_getstr(js, args[0], &len);
+  if (!data) return js_false;
+
+  jsval_t cb = js_mkundef();
+  if (nargs > 1 && is_callable(args[1])) cb = args[1];
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  bool ok = write_to_fd(fd, data, len);
+
+  if (is_callable(cb)) {
+    if (ok) invoke_callback_if_needed(js, cb, js_mknull());
+    else invoke_callback_if_needed(js, cb, make_stream_error(js, "write", fd));
+  }
+
+  if (!ok) return js_false;
+  (void)this_obj;
+  return js_true;
+}
+
+static jsval_t tty_write_stream_rows_getter(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  if (!is_tty_fd(fd)) return js_mkundef();
+
+  int rows = 0;
+  int cols = 0;
+  get_tty_size(fd, &rows, &cols);
+  return js_mknum((double)rows);
+}
+
+static jsval_t tty_write_stream_columns_getter(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  if (!is_tty_fd(fd)) return js_mkundef();
+
+  int rows = 0;
+  int cols = 0;
+  get_tty_size(fd, &rows, &cols);
+  return js_mknum((double)cols);
+}
+
+static jsval_t tty_write_stream_get_window_size(ant_t *js, jsval_t *args, int nargs) {
+  (void)args; (void)nargs;
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  int rows = 0;
+  int cols = 0;
+  get_tty_size(fd, &rows, &cols);
+
+  jsval_t arr = js_mkarr(js);
+  js_arr_push(js, arr, js_mknum((double)cols));
+  js_arr_push(js, arr, js_mknum((double)rows));
+  return arr;
+}
+
+static jsval_t tty_write_stream_clear_line(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+
+  int dir = 0;
+  if (nargs > 0 && vtype(args[0]) != T_UNDEF && !parse_int(args[0], &dir)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "clearLine(dir) requires a numeric dir");
+  }
+
+  jsval_t cb = js_mkundef();
+  if (nargs > 1 && is_callable(args[1])) cb = args[1];
+
+  const char *seq = "\033[2K\r";
+  if (dir < 0) seq = "\033[1K";
+  else if (dir > 0) seq = "\033[0K";
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  bool ok = write_to_fd(fd, seq, strlen(seq));
+  return maybe_callback_or_throw(js, this_obj, cb, ok, "clearLine", fd);
+}
+
+static jsval_t tty_write_stream_clear_screen_down(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+
+  jsval_t cb = js_mkundef();
+  if (nargs > 0 && is_callable(args[0])) cb = args[0];
+
+  static const char seq[] = "\033[0J";
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  bool ok = write_to_fd(fd, seq, sizeof(seq) - 1);
+  return maybe_callback_or_throw(js, this_obj, cb, ok, "clearScreenDown", fd);
+}
+
+static jsval_t tty_write_stream_cursor_to(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 1 || !parse_int(args[0], &(int){0})) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "cursorTo(x[, y][, callback]) requires numeric x");
+  }
+
+  int x = 0;
+  (void)parse_int(args[0], &x);
+  if (x < 0) x = 0;
+
+  bool has_y = false;
+  int y = 0;
+  jsval_t cb = js_mkundef();
+
+  if (nargs > 1) {
+    if (is_callable(args[1])) {
+      cb = args[1];
+    } else if (vtype(args[1]) == T_UNDEF) {
+      // no-op
+    } else if (parse_int(args[1], &y)) {
+      has_y = true;
+      if (y < 0) y = 0;
+      if (nargs > 2 && is_callable(args[2])) cb = args[2];
+    } else {
+      return js_mkerr_typed(js, JS_ERR_TYPE, "cursorTo y must be a number when provided");
+    }
+  }
+
+  char seq[64];
+  int n = 0;
+  if (has_y) n = snprintf(seq, sizeof(seq), "\033[%d;%dH", y + 1, x + 1);
+  else n = snprintf(seq, sizeof(seq), "\033[%dG", x + 1);
+
+  if (n < 0 || (size_t)n >= sizeof(seq)) return js_mkerr(js, "Failed to build cursor sequence");
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  bool ok = write_to_fd(fd, seq, (size_t)n);
+  return maybe_callback_or_throw(js, this_obj, cb, ok, "cursorTo", fd);
+}
+
+static jsval_t tty_write_stream_move_cursor(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (nargs < 2) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "moveCursor(dx, dy[, callback]) requires dx and dy");
+  }
+
+  int dx = 0;
+  int dy = 0;
+  if (!parse_int(args[0], &dx) || !parse_int(args[1], &dy)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "moveCursor(dx, dy[, callback]) requires numeric dx and dy");
+  }
+
+  jsval_t cb = js_mkundef();
+  if (nargs > 2 && is_callable(args[2])) cb = args[2];
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  bool ok = true;
+
+  if (dx != 0) {
+    char seq_x[32];
+    int n_x = 0;
+    if (dx > 0) n_x = snprintf(seq_x, sizeof(seq_x), "\033[%dC", dx);
+    else n_x = snprintf(seq_x, sizeof(seq_x), "\033[%dD", -dx);
+    if (n_x < 0 || (size_t)n_x >= sizeof(seq_x)) return js_mkerr(js, "Failed to build moveCursor sequence");
+    if (!write_to_fd(fd, seq_x, (size_t)n_x)) ok = false;
+  }
+
+  if (ok && dy != 0) {
+    char seq_y[32];
+    int n_y = 0;
+    if (dy > 0) n_y = snprintf(seq_y, sizeof(seq_y), "\033[%dB", dy);
+    else n_y = snprintf(seq_y, sizeof(seq_y), "\033[%dA", -dy);
+    if (n_y < 0 || (size_t)n_y >= sizeof(seq_y)) return js_mkerr(js, "Failed to build moveCursor sequence");
+    if (!write_to_fd(fd, seq_y, (size_t)n_y)) ok = false;
+  }
+
+  return maybe_callback_or_throw(js, this_obj, cb, ok, "moveCursor", fd);
+}
+
+static jsval_t tty_write_stream_get_color_depth(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t env_obj = js_mkundef();
+  if (nargs > 0 && is_special_object(args[0])) env_obj = args[0];
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  int depth = detect_color_depth(js, fd, env_obj);
+  return js_mknum((double)depth);
+}
+
+static jsval_t tty_write_stream_has_colors(ant_t *js, jsval_t *args, int nargs) {
+  int count = 16;
+  jsval_t env_obj = js_mkundef();
+
+  if (nargs > 0) {
+    if (vtype(args[0]) == T_NUM) {
+      int parsed_count = 16;
+      if (!parse_int(args[0], &parsed_count)) {
+        return js_mkerr_typed(js, JS_ERR_TYPE, "hasColors(count[, env]) count must be an integer");
+      }
+      count = parsed_count;
+    } else if (is_special_object(args[0])) {
+      env_obj = args[0];
+    } else if (vtype(args[0]) != T_UNDEF) {
+      return js_mkerr_typed(js, JS_ERR_TYPE, "hasColors(count[, env]) invalid first argument");
+    }
+  }
+
+  if (nargs > 1 && is_special_object(args[1])) env_obj = args[1];
+  if (count < 1) count = 1;
+
+  int fd = stream_fd_from_this(js, ANT_STDOUT_FD);
+  int depth = detect_color_depth(js, fd, env_obj);
+  int max_colors = palette_size_for_depth(depth);
+  return js_bool(max_colors >= count);
+}
+
+static jsval_t tty_read_stream_set_raw_mode(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (!is_special_object(this_obj)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "setRawMode() requires a ReadStream receiver");
+  }
+
+  bool enable = nargs > 0 ? js_truthy(js, args[0]) : true;
+
+  jsval_t native_fn = js_get(js, this_obj, "__antNativeSetRawMode");
+  if (is_callable(native_fn)) {
+    jsval_t call_args[1];
+    int call_nargs = 0;
+    if (nargs > 0) {
+      call_args[0] = args[0];
+      call_nargs = 1;
+    }
+    jsval_t result = sv_vm_call(
+      js->vm, js, native_fn, this_obj,
+      call_nargs > 0 ? call_args : NULL, call_nargs,
+      NULL, false
+    );
+    if (vtype(result) == T_ERR) return result;
+    js_set(js, this_obj, "isRaw", js_bool(js_truthy(js, result) && enable));
+    return this_obj;
+  }
+
+  int fd = stream_fd_from_this(js, ANT_STDIN_FD);
+  if (!set_raw_mode_fd(fd, enable)) {
+    return js_mkerr_typed(js, JS_ERR_GENERIC, "Failed to set raw mode for fd %d", fd);
+  }
+  js_set(js, this_obj, "isRaw", js_bool(enable));
+  return this_obj;
+}
+
+static jsval_t tty_read_stream_constructor(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "ReadStream(fd) requires a file descriptor");
+
+  int fd = 0;
+  if (!parse_fd(args[0], &fd)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "ReadStream(fd) requires an integer file descriptor");
+  }
+  if (!is_tty_fd(fd)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "ReadStream fd %d is not a TTY", fd);
+  }
+
+  if (fd == ANT_STDIN_FD) {
+    jsval_t stdin_obj = get_process_stream(js, "stdin");
+    if (is_special_object(stdin_obj)) {
+      ensure_stream_common_props(js, stdin_obj, fd);
+      if (vtype(js_get(js, stdin_obj, "isRaw")) == T_UNDEF) js_set(js, stdin_obj, "isRaw", js_false);
+      return stdin_obj;
+    }
+  }
+
+  jsval_t ctor = js_getcurrentfunc(js);
+  jsval_t proto = js_get(js, ctor, "prototype");
+  jsval_t obj = js_mkobj(js);
+  if (is_special_object(proto)) js_set_proto(js, obj, proto);
+
+  ensure_stream_common_props(js, obj, fd);
+  js_set(js, obj, "isRaw", js_false);
+  return obj;
+}
+
+static jsval_t tty_write_stream_constructor(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "WriteStream(fd) requires a file descriptor");
+
+  int fd = 0;
+  if (!parse_fd(args[0], &fd)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "WriteStream(fd) requires an integer file descriptor");
+  }
+  if (!is_tty_fd(fd)) {
+    return js_mkerr_typed(js, JS_ERR_TYPE, "WriteStream fd %d is not a TTY", fd);
+  }
+
+  if (fd == ANT_STDOUT_FD || fd == ANT_STDERR_FD) {
+    jsval_t stream = get_process_stream(js, fd == ANT_STDOUT_FD ? "stdout" : "stderr");
+    if (is_special_object(stream)) {
+      ensure_stream_common_props(js, stream, fd);
+      return stream;
+    }
+  }
+
+  jsval_t ctor = js_getcurrentfunc(js);
+  jsval_t proto = js_get(js, ctor, "prototype");
+  jsval_t obj = js_mkobj(js);
+  if (is_special_object(proto)) js_set_proto(js, obj, proto);
+
+  ensure_stream_common_props(js, obj, fd);
+  return obj;
+}
+
+static void setup_readstream_proto(ant_t *js, jsval_t proto) {
+  if (!is_special_object(proto)) return;
+  js_set(js, proto, "setRawMode", js_mkfun(tty_read_stream_set_raw_mode));
+  js_set_sym(js, proto, get_toStringTag_sym(), js_mkstr(js, "ReadStream", 10));
+}
+
+static void setup_writestream_proto(ant_t *js, jsval_t proto) {
+  if (!is_special_object(proto)) return;
+
+  js_set(js, proto, "write", js_mkfun(tty_stream_write));
+  js_set(js, proto, "clearLine", js_mkfun(tty_write_stream_clear_line));
+  js_set(js, proto, "clearScreenDown", js_mkfun(tty_write_stream_clear_screen_down));
+  js_set(js, proto, "cursorTo", js_mkfun(tty_write_stream_cursor_to));
+  js_set(js, proto, "moveCursor", js_mkfun(tty_write_stream_move_cursor));
+  js_set(js, proto, "getWindowSize", js_mkfun(tty_write_stream_get_window_size));
+  js_set(js, proto, "getColorDepth", js_mkfun(tty_write_stream_get_color_depth));
+  js_set(js, proto, "hasColors", js_mkfun(tty_write_stream_has_colors));
+  js_set_getter_desc(js, proto, "rows", 4, js_mkfun(tty_write_stream_rows_getter), JS_DESC_E | JS_DESC_C);
+  js_set_getter_desc(js, proto, "columns", 7, js_mkfun(tty_write_stream_columns_getter), JS_DESC_E | JS_DESC_C);
+  js_set_sym(js, proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11));
+}
+
+void init_tty_module(void) {
+  ant_t *js = rt->js;
+  if (!js) return;
+
+  jsval_t process_obj = js_get(js, js_glob(js), "process");
+  if (!is_special_object(process_obj)) return;
+
+  jsval_t stdin_obj = js_get(js, process_obj, "stdin");
+  if (is_special_object(stdin_obj)) {
+    ensure_stream_common_props(js, stdin_obj, ANT_STDIN_FD);
+    if (vtype(js_get(js, stdin_obj, "isRaw")) == T_UNDEF) js_set(js, stdin_obj, "isRaw", js_false);
+
+    jsval_t stdin_proto = js_get_proto(js, stdin_obj);
+    if (is_special_object(stdin_proto)) {
+      jsval_t native_set_raw = js_get(js, stdin_proto, "setRawMode");
+      if (is_callable(native_set_raw)) {
+        js_set(js, stdin_proto, "__antNativeSetRawMode", native_set_raw);
+      }
+      setup_readstream_proto(js, stdin_proto);
+    }
+  }
+
+  jsval_t stdout_obj = js_get(js, process_obj, "stdout");
+  if (is_special_object(stdout_obj)) {
+    ensure_stream_common_props(js, stdout_obj, ANT_STDOUT_FD);
+    js_set_getter_desc(js, stdout_obj, "rows", 4, js_mkfun(tty_write_stream_rows_getter), JS_DESC_E | JS_DESC_C);
+    js_set_getter_desc(js, stdout_obj, "columns", 7, js_mkfun(tty_write_stream_columns_getter), JS_DESC_E | JS_DESC_C);
+
+    jsval_t stdout_proto = js_get_proto(js, stdout_obj);
+    setup_writestream_proto(js, stdout_proto);
+  }
+
+  jsval_t stderr_obj = js_get(js, process_obj, "stderr");
+  if (is_special_object(stderr_obj)) {
+    ensure_stream_common_props(js, stderr_obj, ANT_STDERR_FD);
+    js_set_getter_desc(js, stderr_obj, "rows", 4, js_mkfun(tty_write_stream_rows_getter), JS_DESC_E | JS_DESC_C);
+    js_set_getter_desc(js, stderr_obj, "columns", 7, js_mkfun(tty_write_stream_columns_getter), JS_DESC_E | JS_DESC_C);
+
+    jsval_t stderr_proto = js_get_proto(js, stderr_obj);
+    setup_writestream_proto(js, stderr_proto);
+  }
+}
+
+jsval_t tty_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+
+  jsval_t read_ctor = js_mkfun(tty_read_stream_constructor);
+  jsval_t read_proto = js_mkobj(js);
+  setup_readstream_proto(js, read_proto);
+  js_set(js, read_proto, "constructor", read_ctor);
+  js_set(js, read_ctor, "prototype", read_proto);
+
+  jsval_t write_ctor = js_mkfun(tty_write_stream_constructor);
+  jsval_t write_proto = js_mkobj(js);
+  setup_writestream_proto(js, write_proto);
+  js_set(js, write_proto, "constructor", write_ctor);
+  js_set(js, write_ctor, "prototype", write_proto);
+
+  js_set(js, lib, "isatty", js_mkfun(tty_isatty));
+  js_set(js, lib, "ReadStream", read_ctor);
+  js_set(js, lib, "WriteStream", write_ctor);
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "tty", 3));
+
+  return lib;
+}
diff --git a/src/modules/uri.c b/src/modules/uri.c
index bc39035..c3825a3 100644
--- a/src/modules/uri.c
+++ b/src/modules/uri.c
@@ -74,7 +74,7 @@ static int decode_escape_sequence(const char *str, size_t len, size_t *pos, unsi
 }
 
 // encodeURIComponent()
-static jsval_t js_encodeURIComponent(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_encodeURIComponent(ant_t *js, jsval_t *args, int nargs) {
   jsval_t result;
   char *out = NULL;
   
@@ -127,7 +127,7 @@ malformed:
 }
 
 // encodeURI()
-static jsval_t js_encodeURI(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_encodeURI(ant_t *js, jsval_t *args, int nargs) {
   jsval_t result;
   char *out = NULL;
   
@@ -180,7 +180,7 @@ malformed:
 }
 
 // decodeURIComponent()
-static jsval_t js_decodeURIComponent(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_decodeURIComponent(ant_t *js, jsval_t *args, int nargs) {
   jsval_t result;
   char *out = NULL;
   
@@ -229,7 +229,7 @@ malformed:
 }
 
 // decodeURI()
-static jsval_t js_decodeURI(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_decodeURI(ant_t *js, jsval_t *args, int nargs) {
   jsval_t result;
   char *out = NULL;
   
@@ -299,7 +299,7 @@ static int is_escape_unreserved(unsigned char c) {
          c == '-' || c == '.' || c == '/';
 }
 
-static jsval_t js_escape(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_escape(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkstr(js, "undefined", 9);
   
   char *str = js_getstr(js, args[0], NULL);
@@ -326,7 +326,7 @@ static jsval_t js_escape(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t js_unescape(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_unescape(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkstr(js, "undefined", 9);
   
   char *str = js_getstr(js, args[0], NULL);
@@ -359,7 +359,7 @@ static jsval_t js_unescape(struct js *js, jsval_t *args, int nargs) {
 }
 
 void init_uri_module(void) {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   jsval_t glob = js_glob(js);
 
   js_set(js, glob, "encodeURI", js_mkfun(js_encodeURI));
diff --git a/src/modules/url.c b/src/modules/url.c
index fda7e8c..fe83629 100644
--- a/src/modules/url.c
+++ b/src/modules/url.c
@@ -4,12 +4,14 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
+#include <uriparser/Uri.h>
 
 #include "ant.h"
 #include "errors.h"
 #include "internal.h"
 #include "runtime.h"
 #include "utils.h"
+#include "descriptors.h"
 
 #include "modules/url.h"
 #include "modules/symbol.h"
@@ -67,128 +69,122 @@ static char *url_decode_component(const char *str) {
       int lo = isdigit(str[i+2]) ? str[i+2] - '0' : tolower(str[i+2]) - 'a' + 10;
       out[j++] = (char)((hi << 4) | lo);
       i += 2;
-    } else if (str[i] == '+') {
-      out[j++] = ' ';
-    } else {
-      out[j++] = str[i];
     }
+    else if (str[i] == '+') out[j++] = ' ';
+    else out[j++] = str[i];
   }
   out[j] = '\0';
   return out;
 }
 
-static int parse_url(const char *url_str, const char *base_str, parsed_url_t *out) {
-  memset(out, 0, sizeof(*out));
-
-  const char *p = url_str;
-  const char *end = url_str + strlen(url_str);
-
-  if (base_str && *p == '/') {
-    parsed_url_t base = {0};
-    if (parse_url(base_str, NULL, &base) < 0) return -1;
-    out->protocol = base.protocol ? strdup(base.protocol) : NULL;
-    out->username = base.username ? strdup(base.username) : strdup("");
-    out->password = base.password ? strdup(base.password) : strdup("");
-    out->hostname = base.hostname ? strdup(base.hostname) : NULL;
-    out->port = base.port ? strdup(base.port) : strdup("");
-
-    char *path_copy = strdup(p);
-    char *q = strchr(path_copy, '?');
-    char *h = strchr(path_copy, '#');
-
-    if (h) {
-      out->hash = strdup(h);
-      *h = '\0';
-    } else {
-      out->hash = strdup("");
-    }
-
-    if (q) {
-      out->search = strdup(q);
-      *q = '\0';
-    } else {
-      out->search = strdup("");
-    }
-
-    out->pathname = strdup(path_copy);
-    free(path_copy);
-
-    free(base.protocol); free(base.username); free(base.password);
-    free(base.hostname); free(base.port); free(base.pathname);
-    free(base.search); free(base.hash);
-    return 0;
-  }
+static char *uri_range_dup(const UriTextRangeA *range) {
+  if (!range->first || !range->afterLast) return strdup("");
+  size_t len = (size_t)(range->afterLast - range->first);
+  return strndup(range->first, len);
+}
 
-  const char *scheme_end = strstr(p, "://");
-  if (!scheme_end) return -1;
-
-  size_t scheme_len = scheme_end - p;
-  out->protocol = malloc(scheme_len + 2);
-  memcpy(out->protocol, p, scheme_len);
-  out->protocol[scheme_len] = ':';
-  out->protocol[scheme_len + 1] = '\0';
-  p = scheme_end + 3;
-
-  out->username = strdup("");
-  out->password = strdup("");
-
-  const char *at = strchr(p, '@');
-  const char *slash = strchr(p, '/');
-  if (at && (!slash || at < slash)) {
-    const char *colon = strchr(p, ':');
-    if (colon && colon < at) {
-      free(out->username);
-      out->username = strndup(p, colon - p);
-      free(out->password);
-      out->password = strndup(colon + 1, at - colon - 1);
-    } else {
-      free(out->username);
-      out->username = strndup(p, at - p);
-    }
-    p = at + 1;
+static void uri_to_parsed(const UriUriA *uri, parsed_url_t *out) {
+  char *scheme = uri_range_dup(&uri->scheme);
+  size_t slen = strlen(scheme);
+  out->protocol = malloc(slen + 2);
+  memcpy(out->protocol, scheme, slen);
+  out->protocol[slen] = ':';
+  out->protocol[slen + 1] = '\0';
+  free(scheme);
+
+  char *userinfo = uri_range_dup(&uri->userInfo);
+  char *colon = strchr(userinfo, ':');
+  if (colon) {
+    *colon = '\0';
+    out->username = strdup(userinfo);
+    out->password = strdup(colon + 1);
+  } else {
+    out->username = strdup(userinfo);
+    out->password = strdup("");
   }
+  free(userinfo);
 
-  slash = strchr(p, '/');
-  const char *qmark = strchr(p, '?');
-  const char *hash = strchr(p, '#');
+  out->hostname = uri_range_dup(&uri->hostText);
+  out->port = uri_range_dup(&uri->portText);
 
-  const char *host_end = slash ? slash : (qmark ? qmark : (hash ? hash : end));
-  char *host_part = strndup(p, host_end - p);
-
-  char *port_sep = strrchr(host_part, ':');
-  if (port_sep && strchr(port_sep, ']') == NULL) {
-    *port_sep = '\0';
-    out->port = strdup(port_sep + 1);
-    out->hostname = strdup(host_part);
-  } else {
-    out->hostname = strdup(host_part);
-    out->port = strdup("");
+  size_t path_cap = 1;
+  for (UriPathSegmentA *seg = uri->pathHead; seg; seg = seg->next)
+    path_cap += (size_t)(seg->text.afterLast - seg->text.first) + 1;
+  char *path = malloc(path_cap + 1);
+  size_t pos = 0;
+  for (UriPathSegmentA *seg = uri->pathHead; seg; seg = seg->next) {
+    path[pos++] = '/';
+    size_t slen_uri = (size_t)(seg->text.afterLast - seg->text.first);
+    memcpy(path + pos, seg->text.first, slen_uri);
+    pos += slen_uri;
   }
-  free(host_part);
-  p = host_end;
+  if (pos == 0) path[pos++] = '/';
+  path[pos] = '\0';
+  out->pathname = path;
+
+  char *query = uri_range_dup(&uri->query);
+  if (*query) {
+    out->search = malloc(strlen(query) + 2);
+    out->search[0] = '?';
+    strcpy(out->search + 1, query);
+  } else out->search = strdup("");
+  free(query);
+
+  char *frag = uri_range_dup(&uri->fragment);
+  if (*frag) {
+    out->hash = malloc(strlen(frag) + 2);
+    out->hash[0] = '#';
+    strcpy(out->hash + 1, frag);
+  } else out->hash = strdup("");
+  free(frag);
+}
 
-  if (slash) {
-    const char *path_end = qmark ? qmark : (hash ? hash : end);
-    out->pathname = strndup(slash, path_end - slash);
-    p = path_end;
-  } else {
-    out->pathname = strdup("/");
+static const char *coerce_to_string(ant_t *js, jsval_t val, size_t *len) {
+  if (vtype(val) == T_STR) return js_getstr(js, val, len);
+  if (is_object_type(val)) {
+    jsval_t href = js_get(js, val, "href");
+    if (vtype(href) == T_STR) return js_getstr(js, href, len);
   }
+  return NULL;
+}
 
-  if (qmark && (!hash || qmark < hash)) {
-    const char *search_end = hash ? hash : end;
-    out->search = strndup(qmark, search_end - qmark);
-    p = search_end;
-  } else {
-    out->search = strdup("");
-  }
+static int parse_url(const char *url_str, const char *base_str, parsed_url_t *out) {
+  memset(out, 0, sizeof(*out));
 
-  if (hash) {
-    out->hash = strdup(hash);
-  } else {
-    out->hash = strdup("");
+  UriUriA uri;
+  const char *errorPos;
+
+  if (base_str && !strstr(url_str, "://")) {
+    UriUriA base_uri, rel_uri, resolved;
+    
+    if (uriParseSingleUriA(&base_uri, base_str, &errorPos) != URI_SUCCESS)
+      return -1;
+      
+    if (uriParseSingleUriA(&rel_uri, url_str, &errorPos) != URI_SUCCESS) {
+      uriFreeUriMembersA(&base_uri);
+      return -1;
+    }
+    
+    if (uriAddBaseUriA(&resolved, &rel_uri, &base_uri) != URI_SUCCESS) {
+      uriFreeUriMembersA(&base_uri);
+      uriFreeUriMembersA(&rel_uri);
+      return -1;
+    }
+    
+    uriNormalizeSyntaxA(&resolved);
+    uri_to_parsed(&resolved, out);
+    
+    uriFreeUriMembersA(&resolved);
+    uriFreeUriMembersA(&rel_uri);
+    uriFreeUriMembersA(&base_uri);
+    return 0;
   }
 
+  if (uriParseSingleUriA(&uri, url_str, &errorPos) != URI_SUCCESS)
+    return -1;
+    
+  uri_to_parsed(&uri, out);
+  uriFreeUriMembersA(&uri);
   return 0;
 }
 
@@ -256,7 +252,7 @@ static char *build_href(
   return href;
 }
 
-static void update_url_href(struct js *js, jsval_t url_obj) {
+static void update_url_href(ant_t *js, jsval_t url_obj) {
   char *protocol = js_getstr(js, js_get(js, url_obj, "protocol"), NULL);
   char *username = js_getstr(js, js_get(js, url_obj, "username"), NULL);
   char *password = js_getstr(js, js_get(js, url_obj, "password"), NULL);
@@ -302,11 +298,11 @@ static void update_url_href(struct js *js, jsval_t url_obj) {
   free(href);
 }
 
-static jsval_t url_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t url_toString(ant_t *js, jsval_t *args, int nargs) {
   return js_get(js, js_getthis(js), "href");
 }
 
-static jsval_t js_URLSearchParams(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_URLSearchParams(ant_t *js, jsval_t *args, int nargs) {
   jsval_t usp = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "URLSearchParams", 15);
   if (is_special_object(proto)) js_set_proto(js, usp, proto);
@@ -340,11 +336,11 @@ parse_pair:
   goto parse_pair;
 }
 
-static jsval_t js_URL(struct js *js, jsval_t *args, int nargs) {
+static jsval_t js_URL(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "TypeError: URL requires at least 1 argument");
 
   char *url_str = js_getstr(js, args[0], NULL);
-  char *base_str = (nargs > 1) ? js_getstr(js, args[1], NULL) : NULL;
+  char *base_str = (nargs > 1) ? (char *)coerce_to_string(js, args[1], NULL) : NULL;
   if (!url_str) return js_mkerr(js, "TypeError: Invalid URL");
 
   parsed_url_t parsed;
@@ -367,21 +363,25 @@ static jsval_t js_URL(struct js *js, jsval_t *args, int nargs) {
 
   update_url_href(js, url_obj);
 
-  jsval_t search_params;
+  jsval_t search_params = js_mkobj(js);
+  jsval_t usp_proto = js_get_ctor_proto(js, "URLSearchParams", 15);
+  if (is_special_object(usp_proto)) js_set_proto(js, search_params, usp_proto);
+  js_set_slot(js, search_params, SLOT_DATA, url_obj);
   if (parsed.search && *parsed.search) {
     const char *qs = parsed.search[0] == '?' ? parsed.search + 1 : parsed.search;
     jsval_t arg = js_mkstr(js, qs, strlen(qs));
-    search_params = js_URLSearchParams(js, &arg, 1);
-  } else search_params = js_URLSearchParams(js, NULL, 0);
-  
-  js_set_slot(js, search_params, SLOT_DATA, url_obj);
+    jsval_t tmp = js_URLSearchParams(js, &arg, 1);
+    js_set_slot(js, search_params, SLOT_ENTRIES, js_get_slot(js, tmp, SLOT_ENTRIES));
+  } else {
+    js_set_slot(js, search_params, SLOT_ENTRIES, js_mkarr(js));
+  }
   js_set(js, url_obj, "searchParams", search_params);
 
   free_parsed_url(&parsed);
   return url_obj;
 }
 
-static jsval_t usp_get(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_get(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mknull();
   jsval_t this_val = js_getthis(js);
   
@@ -401,7 +401,7 @@ static jsval_t usp_get(struct js *js, jsval_t *args, int nargs) {
   return js_mknull();
 }
 
-static jsval_t usp_getAll(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_getAll(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkarr(js);
   jsval_t this_val = js_getthis(js);
   
@@ -422,7 +422,7 @@ static jsval_t usp_getAll(struct js *js, jsval_t *args, int nargs) {
   return result;
 }
 
-static jsval_t usp_has(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_has(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_false;
   jsval_t this_val = js_getthis(js);
   
@@ -442,7 +442,7 @@ static jsval_t usp_has(struct js *js, jsval_t *args, int nargs) {
   return js_false;
 }
 
-static void usp_sync_url(struct js *js, jsval_t this_val) {
+static void usp_sync_url(ant_t *js, jsval_t this_val) {
   jsval_t url_obj = js_get_slot(js, this_val, SLOT_DATA);
   if (!is_special_object(url_obj)) return;
 
@@ -480,7 +480,7 @@ static void usp_sync_url(struct js *js, jsval_t this_val) {
   free(buf);
 }
 
-static jsval_t usp_set(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_set(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkundef();
   jsval_t this_val = js_getthis(js);
   
@@ -520,7 +520,7 @@ static jsval_t usp_set(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t usp_append(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_append(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkundef();
   jsval_t this_val = js_getthis(js);
 
@@ -534,7 +534,7 @@ static jsval_t usp_append(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t usp_delete(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_delete(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkundef();
   jsval_t this_val = js_getthis(js);
   char *key = js_getstr(js, args[0], NULL);
@@ -557,7 +557,7 @@ static jsval_t usp_delete(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-static jsval_t usp_toString(struct js *js, jsval_t *args, int nargs) {
+static jsval_t usp_toString(ant_t *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t entries = js_get_slot(js, this_val, SLOT_ENTRIES);
   jsoff_t len = js_arr_len(js, entries);
@@ -603,7 +603,7 @@ void init_url_module(void) {
   jsval_t url_proto = js_mkobj(js);
   
   js_set(js, url_proto, "toString", js_mkfun(url_toString));
-  js_set(js, url_proto, get_toStringTag_sym_key(), js_mkstr(js, "URL", 3));
+  js_set_sym(js, url_proto, get_toStringTag_sym(), js_mkstr(js, "URL", 3));
   
   js_set_slot(js, url_ctor, SLOT_CFUNC, js_mkfun(js_URL));
   js_mkprop_fast(js, url_ctor, "prototype", 9, url_proto);
@@ -622,7 +622,7 @@ void init_url_module(void) {
   js_set(js, usp_proto, "append", js_mkfun(usp_append));
   js_set(js, usp_proto, "delete", js_mkfun(usp_delete));
   js_set(js, usp_proto, "toString", js_mkfun(usp_toString));
-  js_set(js, usp_proto, get_toStringTag_sym_key(), js_mkstr(js, "URLSearchParams", 15));
+  js_set_sym(js, usp_proto, get_toStringTag_sym(), js_mkstr(js, "URLSearchParams", 15));
   
   js_set_slot(js, usp_ctor, SLOT_CFUNC, js_mkfun(js_URLSearchParams));
   js_mkprop_fast(js, usp_ctor, "prototype", 9, usp_proto);
@@ -631,3 +631,62 @@ void init_url_module(void) {
   
   js_set(js, glob, "URLSearchParams", js_obj_to_func(usp_ctor));
 }
+
+static jsval_t builtin_fileURLToPath(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkerr(js, "fileURLToPath requires a string or URL argument");
+
+  size_t len;
+  const char *str = coerce_to_string(js, args[0], &len);
+  if (!str) return js_mkerr(js, "fileURLToPath requires a string or URL argument");
+
+  parsed_url_t parsed;
+  if (parse_url(str, NULL, &parsed) != 0)
+    return js_mkerr(js, "Invalid URL");
+
+  if (strcmp(parsed.protocol, "file:") != 0) {
+    free_parsed_url(&parsed);
+    return js_mkerr(js, "fileURLToPath requires a file: URL");
+  }
+
+  char *decoded = url_decode_component(parsed.pathname);
+  free_parsed_url(&parsed);
+  if (!decoded) return js_mkerr(js, "allocation failure");
+
+  jsval_t ret = js_mkstr(js, decoded, strlen(decoded));
+  free(decoded);
+  return ret;
+}
+
+static jsval_t builtin_pathToFileURL(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || vtype(args[0]) != T_STR)
+    return js_mkerr(js, "pathToFileURL requires a string argument");
+
+  size_t len;
+  const char *path = js_getstr(js, args[0], &len);
+
+  size_t total = 7 + len;
+  char *buf = malloc(total + 1);
+  if (!buf) return js_mkerr(js, "allocation failure");
+
+  memcpy(buf, "file://", 7);
+  memcpy(buf + 7, path, len);
+  buf[total] = '\0';
+
+  jsval_t url_args[1] = { js_mkstr(js, buf, total) };
+  free(buf);
+
+  return js_URL(js, url_args, 1);
+}
+
+jsval_t url_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+  jsval_t glob = js_glob(js);
+
+  js_set(js, lib, "URL", js_get(js, glob, "URL"));
+  js_set(js, lib, "URLSearchParams", js_get(js, glob, "URLSearchParams"));
+  js_set(js, lib, "fileURLToPath", js_mkfun(builtin_fileURLToPath));
+  js_set(js, lib, "pathToFileURL", js_mkfun(builtin_pathToFileURL));
+  js_set(js, lib, "default", lib);
+
+  return lib;
+}
diff --git a/src/modules/util.c b/src/modules/util.c
new file mode 100644
index 0000000..21ee9fe
--- /dev/null
+++ b/src/modules/util.c
@@ -0,0 +1,407 @@
+#include <compat.h> // IWYU pragma: keep
+
+#include <ctype.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ant.h"
+#include "internal.h"
+#include "silver/engine.h"
+
+#include "modules/json.h"
+#include "modules/symbol.h"
+#include "modules/util.h"
+
+
+typedef struct {
+  char *buf;
+  size_t len;
+  size_t cap;
+} util_sb_t;
+
+typedef struct {
+  const char *name;
+  const char *open;
+  const char *close;
+} util_style_entry_t;
+
+// migrate to crprintf
+static const util_style_entry_t util_styles[] = {
+  {"bold", "\x1b[1m", "\x1b[22m"},
+  {"dim", "\x1b[2m", "\x1b[22m"},
+  {"italic", "\x1b[3m", "\x1b[23m"},
+  {"underline", "\x1b[4m", "\x1b[24m"},
+  {"inverse", "\x1b[7m", "\x1b[27m"},
+  {"hidden", "\x1b[8m", "\x1b[28m"},
+  {"strikethrough", "\x1b[9m", "\x1b[29m"},
+  {"black", "\x1b[30m", "\x1b[39m"},
+  {"red", "\x1b[31m", "\x1b[39m"},
+  {"green", "\x1b[32m", "\x1b[39m"},
+  {"yellow", "\x1b[33m", "\x1b[39m"},
+  {"blue", "\x1b[34m", "\x1b[39m"},
+  {"magenta", "\x1b[35m", "\x1b[39m"},
+  {"cyan", "\x1b[36m", "\x1b[39m"},
+  {"white", "\x1b[37m", "\x1b[39m"},
+  {"gray", "\x1b[90m", "\x1b[39m"},
+  {"grey", "\x1b[90m", "\x1b[39m"},
+  {"bgBlack", "\x1b[40m", "\x1b[49m"},
+  {"bgRed", "\x1b[41m", "\x1b[49m"},
+  {"bgGreen", "\x1b[42m", "\x1b[49m"},
+  {"bgYellow", "\x1b[43m", "\x1b[49m"},
+  {"bgBlue", "\x1b[44m", "\x1b[49m"},
+  {"bgMagenta", "\x1b[45m", "\x1b[49m"},
+  {"bgCyan", "\x1b[46m", "\x1b[49m"},
+  {"bgWhite", "\x1b[47m", "\x1b[49m"},
+};
+
+static inline bool util_is_callable(jsval_t v) {
+  uint8_t t = vtype(v);
+  return t == T_FUNC || t == T_CFUNC;
+}
+
+static bool util_sb_reserve(util_sb_t *sb, size_t extra) {
+  size_t need = sb->len + extra + 1;
+  if (need <= sb->cap) return true;
+
+  size_t next = sb->cap ? sb->cap : 128;
+  while (next < need) next *= 2;
+
+  char *buf = (char *)realloc(sb->buf, next);
+  if (!buf) return false;
+
+  sb->buf = buf;
+  sb->cap = next;
+  return true;
+}
+
+static bool util_sb_append_n(util_sb_t *sb, const char *s, size_t n) {
+  if (n == 0) return true;
+  if (!util_sb_reserve(sb, n)) return false;
+  memcpy(sb->buf + sb->len, s, n);
+  sb->len += n;
+  sb->buf[sb->len] = '\0';
+  return true;
+}
+
+static bool util_sb_append_c(util_sb_t *sb, char c) {
+  if (!util_sb_reserve(sb, 1)) return false;
+  sb->buf[sb->len++] = c;
+  sb->buf[sb->len] = '\0';
+  return true;
+}
+
+static bool util_sb_append_jsval(ant_t *js, util_sb_t *sb, jsval_t v) {
+  char cbuf[512];
+  js_cstr_t cstr = js_to_cstr(js, v, cbuf, sizeof(cbuf));
+  size_t len = strlen(cstr.ptr);
+  bool ok = util_sb_append_n(sb, cstr.ptr, len);
+  if (cstr.needs_free) free((void *)cstr.ptr);
+  return ok;
+}
+
+static bool util_sb_append_json(ant_t *js, util_sb_t *sb, jsval_t v) {
+  jsval_t stringify_args[1] = {v};
+  jsval_t json = js_json_stringify(js, stringify_args, 1);
+  if (vtype(json) != T_STR) {
+    return util_sb_append_n(sb, "[Circular]", 10);
+  }
+  size_t len = 0;
+  const char *s = js_getstr(js, json, &len);
+  return s ? util_sb_append_n(sb, s, len) : util_sb_append_n(sb, "[Circular]", 10);
+}
+
+static jsval_t util_format_impl(ant_t *js, jsval_t *args, int nargs, int fmt_index) {
+  util_sb_t sb = {0};
+  if (fmt_index >= nargs) {
+    jsval_t out = js_mkstr(js, "", 0);
+    free(sb.buf);
+    return out;
+  }
+
+  if (vtype(args[fmt_index]) != T_STR) {
+    for (int i = fmt_index; i < nargs; i++) {
+      if (i > fmt_index) util_sb_append_c(&sb, ' ');
+      util_sb_append_jsval(js, &sb, args[i]);
+    }
+    jsval_t out = js_mkstr(js, sb.buf ? sb.buf : "", sb.len);
+    free(sb.buf);
+    return out;
+  }
+
+  size_t fmt_len = 0;
+  const char *fmt = js_getstr(js, args[fmt_index], &fmt_len);
+  int argi = fmt_index + 1;
+
+  for (size_t i = 0; i < fmt_len; i++) {
+    if (fmt[i] != '%' || i + 1 >= fmt_len) {
+      util_sb_append_c(&sb, fmt[i]);
+      continue;
+    }
+
+    char spec = fmt[i + 1];
+    if (spec == '%') {
+      util_sb_append_c(&sb, '%');
+      i++;
+      continue;
+    }
+
+    bool known = (
+      spec == 's' || spec == 'd' || spec == 'i' || spec == 'f' ||
+      spec == 'j' || spec == 'o' || spec == 'O' || spec == 'c'
+    );
+
+    if (!known) {
+      util_sb_append_c(&sb, '%');
+      util_sb_append_c(&sb, spec);
+      i++;
+      continue;
+    }
+
+    jsval_t v = (argi < nargs) ? args[argi++] : js_mkundef();
+
+    if (spec == 's') {
+      util_sb_append_jsval(js, &sb, v);
+    } else if (spec == 'd' || spec == 'i') {
+      double d = js_to_number(js, v);
+      char nb[64];
+      if (isnan(d)) snprintf(nb, sizeof(nb), "NaN");
+      else if (!isfinite(d)) snprintf(nb, sizeof(nb), d < 0 ? "-Infinity" : "Infinity");
+      else snprintf(nb, sizeof(nb), "%lld", (long long)d);
+      util_sb_append_n(&sb, nb, strlen(nb));
+    } else if (spec == 'f') {
+      double d = js_to_number(js, v);
+      char nb[64];
+      if (isnan(d)) snprintf(nb, sizeof(nb), "NaN");
+      else if (!isfinite(d)) snprintf(nb, sizeof(nb), d < 0 ? "-Infinity" : "Infinity");
+      else snprintf(nb, sizeof(nb), "%g", d);
+      util_sb_append_n(&sb, nb, strlen(nb));
+    } else if (spec == 'j') {
+      util_sb_append_json(js, &sb, v);
+    } else if (spec == 'o' || spec == 'O') {
+      util_sb_append_jsval(js, &sb, v);
+    } else if (spec == 'c') // style placeholder: consume arg, emit nothing
+
+    i++;
+  }
+
+  for (; argi < nargs; argi++) {
+    util_sb_append_c(&sb, ' ');
+    util_sb_append_jsval(js, &sb, args[argi]);
+  }
+
+  jsval_t out = js_mkstr(js, sb.buf ? sb.buf : "", sb.len);
+  free(sb.buf);
+  return out;
+}
+
+static jsval_t util_format(ant_t *js, jsval_t *args, int nargs) {
+  return util_format_impl(js, args, nargs, 0);
+}
+
+static jsval_t util_format_with_options(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs <= 1) return js_mkstr(js, "", 0);
+  return util_format_impl(js, args, nargs, 1);
+}
+
+static jsval_t util_inspect(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkstr(js, "undefined", 9);
+  char cbuf[512];
+  js_cstr_t cstr = js_to_cstr(js, args[0], cbuf, sizeof(cbuf));
+  jsval_t out = js_mkstr(js, cstr.ptr, strlen(cstr.ptr));
+  if (cstr.needs_free) free((void *)cstr.ptr);
+  return out;
+}
+
+static jsval_t util_strip_vt_control_characters(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkstr(js, "", 0);
+
+  char cbuf[512];
+  js_cstr_t cstr = js_to_cstr(js, args[0], cbuf, sizeof(cbuf));
+  const char *src = cstr.ptr;
+  size_t len = strlen(src);
+
+  util_sb_t sb = {0};
+  for (size_t i = 0; i < len; i++) {
+    unsigned char ch = (unsigned char)src[i];
+    if (ch != 0x1b) {
+      util_sb_append_c(&sb, (char)ch);
+      continue;
+    }
+
+    if (i + 1 < len && src[i + 1] == '[') {
+      i += 2;
+      while (i < len) {
+        unsigned char c = (unsigned char)src[i];
+        if (c >= '@' && c <= '~') break;
+        i++;
+      }
+      continue;
+    }
+
+    if (i + 1 < len && src[i + 1] == ']') {
+      i += 2;
+      while (i < len) {
+        if ((unsigned char)src[i] == 0x07) break;
+        if ((unsigned char)src[i] == 0x1b && i + 1 < len && src[i + 1] == '\\') {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+  }
+
+  jsval_t out = js_mkstr(js, sb.buf ? sb.buf : "", sb.len);
+  if (cstr.needs_free) free((void *)cstr.ptr);
+  free(sb.buf);
+  return out;
+}
+
+static const util_style_entry_t *util_find_style(const char *name) {
+  for (size_t i = 0; i < sizeof(util_styles) / sizeof(util_styles[0]); i++) {
+    if (strcmp(name, util_styles[i].name) == 0) return &util_styles[i];
+  }
+  return NULL;
+}
+
+static jsval_t util_style_text(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2) return js_mkstr(js, "", 0);
+
+  char text_buf[512];
+  js_cstr_t text_cstr = js_to_cstr(js, args[1], text_buf, sizeof(text_buf));
+
+  const util_style_entry_t *picked[16];
+  int picked_n = 0;
+
+  if (vtype(args[0]) == T_STR) {
+    const char *name = js_getstr(js, args[0], NULL);
+    const util_style_entry_t *e = name ? util_find_style(name) : NULL;
+    if (e) picked[picked_n++] = e;
+  } else if (vtype(args[0]) == T_ARR) {
+    jsoff_t len = js_arr_len(js, args[0]);
+    for (jsoff_t i = 0; i < len && picked_n < (int)(sizeof(picked) / sizeof(picked[0])); i++) {
+      jsval_t item = js_arr_get(js, args[0], i);
+      if (vtype(item) != T_STR) continue;
+      const char *name = js_getstr(js, item, NULL);
+      const util_style_entry_t *e = name ? util_find_style(name) : NULL;
+      if (e) picked[picked_n++] = e;
+    }
+  }
+
+  if (picked_n == 0) {
+    jsval_t out = js_mkstr(js, text_cstr.ptr, strlen(text_cstr.ptr));
+    if (text_cstr.needs_free) free((void *)text_cstr.ptr);
+    return out;
+  }
+
+  util_sb_t sb = {0};
+  for (int i = 0; i < picked_n; i++) {
+    util_sb_append_n(&sb, picked[i]->open, strlen(picked[i]->open));
+  }
+  util_sb_append_n(&sb, text_cstr.ptr, strlen(text_cstr.ptr));
+  for (int i = picked_n - 1; i >= 0; i--) {
+    util_sb_append_n(&sb, picked[i]->close, strlen(picked[i]->close));
+  }
+
+  jsval_t out = js_mkstr(js, sb.buf ? sb.buf : "", sb.len);
+  if (text_cstr.needs_free) free((void *)text_cstr.ptr);
+  free(sb.buf);
+  return out;
+}
+
+static jsval_t util_promisify_callback(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t fn = js_getcurrentfunc(js);
+  jsval_t ctx = js_get_slot(js, fn, SLOT_DATA);
+  if (!is_object_type(ctx)) return js_mkundef();
+
+  jsval_t settled = js_get_slot(js, ctx, SLOT_SETTLED);
+  if (vtype(settled) == T_BOOL && settled == js_true) return js_mkundef();
+  js_set_slot(js, ctx, SLOT_SETTLED, js_true);
+
+  jsval_t promise = js_get_slot(js, ctx, SLOT_DATA);
+  if (!is_object_type(promise)) return js_mkundef();
+
+  if (nargs > 0 && !is_null(args[0]) && !is_undefined(args[0])) {
+    js_reject_promise(js, promise, args[0]);
+    return js_mkundef();
+  }
+
+  if (nargs <= 1) {
+    js_resolve_promise(js, promise, js_mkundef());
+    return js_mkundef();
+  }
+
+  if (nargs == 2) {
+    js_resolve_promise(js, promise, args[1]);
+    return js_mkundef();
+  }
+
+  jsval_t arr = js_mkarr(js);
+  for (int i = 1; i < nargs; i++) js_arr_push(js, arr, args[i]);
+  js_resolve_promise(js, promise, arr);
+  return js_mkundef();
+}
+
+static jsval_t util_promisified_call(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t fn = js_getcurrentfunc(js);
+  jsval_t original = js_get_slot(js, fn, SLOT_DATA);
+  if (!util_is_callable(original)) return js_mkerr(js, "promisified target is not callable");
+
+  jsval_t promise = js_mkpromise(js);
+  jsval_t ctx = js_mkobj(js);
+  js_set_slot(js, ctx, SLOT_DATA, promise);
+  js_set_slot(js, ctx, SLOT_SETTLED, js_false);
+  jsval_t cb = js_heavy_mkfun(js, util_promisify_callback, ctx);
+
+  jsval_t *call_args = (jsval_t *)malloc((size_t)(nargs + 1) * sizeof(jsval_t));
+  if (!call_args) {
+    js_reject_promise(js, promise, js_mkerr(js, "Out of memory"));
+    return promise;
+  }
+  for (int i = 0; i < nargs; i++) call_args[i] = args[i];
+  call_args[nargs] = cb;
+
+  jsval_t this_arg = js_getthis(js);
+  jsval_t call_result = sv_vm_call(
+    js->vm, js, original, this_arg, call_args, nargs + 1, NULL, false
+  );
+  free(call_args);
+
+  jsval_t settled = js_get_slot(js, ctx, SLOT_SETTLED);
+  bool is_settled = (vtype(settled) == T_BOOL && settled == js_true);
+  if (!is_settled && (is_err(call_result) || js->thrown_exists)) {
+    jsval_t ex = js->thrown_exists ? js->thrown_value : call_result;
+    js->thrown_exists = false;
+    js->thrown_value = js_mkundef();
+    js->thrown_stack = js_mkundef();
+    js_set_slot(js, ctx, SLOT_SETTLED, js_true);
+    js_reject_promise(js, promise, ex);
+  }
+
+  return promise;
+}
+
+static jsval_t util_promisify(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || !util_is_callable(args[0])) {
+    return js_mkerr(js, "promisify(fn) requires a function");
+  }
+  return js_heavy_mkfun(js, util_promisified_call, args[0]);
+}
+
+jsval_t util_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+
+  js_set(js, lib, "format", js_mkfun(util_format));
+  js_set(js, lib, "formatWithOptions", js_mkfun(util_format_with_options));
+  js_set(js, lib, "inspect", js_mkfun(util_inspect));
+  js_set(js, lib, "promisify", js_mkfun(util_promisify));
+  js_set(js, lib, "stripVTControlCharacters", js_mkfun(util_strip_vt_control_characters));
+  js_set(js, lib, "styleText", js_mkfun(util_style_text));
+
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "util", 4));
+  return lib;
+}
diff --git a/src/modules/worker_threads.c b/src/modules/worker_threads.c
new file mode 100644
index 0000000..c355ff0
--- /dev/null
+++ b/src/modules/worker_threads.c
@@ -0,0 +1,1042 @@
+// stub: minimal node:worker_threads implementation
+// just enough for rolldown to run transforms
+
+#include <compat.h> // IWYU pragma: keep
+
+#include <uv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#ifdef _WIN32
+#include <io.h>
+#define WT_WRITE _write
+#define WT_STDOUT_FD 1
+extern char **_environ;
+#define environ _environ
+#else
+#include <unistd.h>
+#define WT_WRITE write
+#define WT_STDOUT_FD STDOUT_FILENO
+extern char **environ;
+#endif
+
+#include "ant.h"
+#include "internal.h"
+#include "runtime.h"
+#include "descriptors.h"
+#include "silver/engine.h"
+#include "modules/json.h"
+#include "modules/symbol.h"
+#include "modules/worker_threads.h"
+
+#define WT_ENV_MODE "ANT_WORKER_THREADS_MODE"
+#define WT_ENV_DATA_JSON "ANT_WORKER_DATA_JSON"
+#define WT_ENV_STORE_JSON "ANT_WORKER_ENV_DATA_JSON"
+#define WT_MSG_PREFIX "ANT_WT_MSG:"
+
+typedef struct ant_worker_thread {
+  ant_t *js;
+  uv_process_t process;
+  uv_pipe_t stdout_pipe;
+  bool spawned;
+  bool exited;
+  bool closing;
+  bool closed;
+  bool refed;
+  int close_pending;
+  int64_t exit_status;
+  int term_signal;
+  char *line_buf;
+  size_t line_len;
+  size_t line_cap;
+  jshdl_t self_root;
+  jshdl_t terminate_root;
+  bool has_terminate_root;
+} ant_worker_thread_t;
+
+static inline bool wt_is_callable(jsval_t v) {
+  uint8_t t = vtype(v);
+  return t == T_FUNC || t == T_CFUNC;
+}
+
+static bool wt_is_worker_mode(void) {
+  const char *mode = getenv(WT_ENV_MODE);
+  return mode && strcmp(mode, "1") == 0;
+}
+
+static jsval_t wt_get_or_create_env_store(ant_t *js) {
+  jsval_t store = js_get_slot(js, js->global, SLOT_WT_ENV_STORE);
+  if (!is_object_type(store)) {
+    store = js_mkobj(js);
+    js_set_slot(js, js->global, SLOT_WT_ENV_STORE, store);
+  }
+  return store;
+}
+
+static void wt_init_env_store(ant_t *js, bool is_worker) {
+  jsval_t store = js_mkobj(js);
+  if (is_worker) {
+    const char *raw = getenv(WT_ENV_STORE_JSON);
+    if (raw && raw[0]) {
+      jsval_t input = js_mkstr(js, raw, strlen(raw));
+      jsval_t parse_args[1] = {input};
+      jsval_t parsed = js_json_parse(js, parse_args, 1);
+      if (is_object_type(parsed)) store = parsed;
+    }
+  }
+  js_set_slot(js, js->global, SLOT_WT_ENV_STORE, store);
+}
+
+static ant_worker_thread_t *wt_get_worker(ant_t *js, jsval_t this_obj) {
+  if (!is_object_type(this_obj)) return NULL;
+  jsval_t data = js_get_slot(js, this_obj, SLOT_DATA);
+  if (vtype(data) != T_NUM) return NULL;
+  return (ant_worker_thread_t *)(uintptr_t)js_getnum(data);
+}
+
+static bool wt_is_message_port(ant_t *js, jsval_t obj) {
+  if (!is_object_type(obj)) return false;
+  jsval_t tag = js_get_slot(js, obj, SLOT_WT_PORT_TAG);
+  return js_truthy(js, tag);
+}
+
+static jsval_t wt_get_message_port_proto(ant_t *js) {
+  jsval_t proto = js_get_slot(js, js->global, SLOT_WT_PORT_PROTO);
+  if (!is_object_type(proto)) proto = js_mkobj(js);
+  return proto;
+}
+
+static jsval_t wt_make_message_port(ant_t *js) {
+  jsval_t port = js_mkobj(js);
+  js_set_proto(js, port, wt_get_message_port_proto(js));
+  js_set_slot(js, port, SLOT_WT_PORT_TAG, js_true);
+  js_set_slot(js, port, SLOT_WT_PORT_QUEUE, js_mkarr(js));
+  js_set_slot(js, port, SLOT_WT_PORT_HEAD, js_mknum(0));
+  js_set_slot(js, port, SLOT_WT_PORT_PEER, js_mknull());
+  js_set_slot(js, port, SLOT_WT_PORT_CLOSED, js_false);
+  js_set_slot(js, port, SLOT_WT_PORT_STARTED, js_false);
+  js_set_slot(js, port, SLOT_WT_PORT_ON_MESSAGE, js_mkundef());
+  js_set_slot(js, port, SLOT_WT_PORT_ONCE_MESSAGE, js_mkundef());
+  js_set(js, port, "onmessage", js_mkundef());
+  return port;
+}
+
+static bool wt_port_is_closed(ant_t *js, jsval_t port) {
+  return js_truthy(js, js_get_slot(js, port, SLOT_WT_PORT_CLOSED));
+}
+
+static void wt_port_set_closed(ant_t *js, jsval_t port, bool closed) {
+  js_set_slot(js, port, SLOT_WT_PORT_CLOSED, js_bool(closed));
+}
+
+static bool wt_port_queue_dequeue(ant_t *js, jsval_t port, jsval_t *out) {
+  jsval_t queue = js_get_slot(js, port, SLOT_WT_PORT_QUEUE);
+  if (vtype(queue) != T_ARR) return false;
+
+  jsval_t head_val = js_get_slot(js, port, SLOT_WT_PORT_HEAD);
+  jsoff_t head = (vtype(head_val) == T_NUM) ? (jsoff_t)js_getnum(head_val) : 0;
+  jsoff_t len = js_arr_len(js, queue);
+  if (len <= 0 || head >= len) {
+    js_set_slot(js, port, SLOT_WT_PORT_QUEUE, js_mkarr(js));
+    js_set_slot(js, port, SLOT_WT_PORT_HEAD, js_mknum(0));
+    return false;
+  }
+
+  if (out) *out = js_arr_get(js, queue, head);
+  jsoff_t next_head = head + 1;
+
+  if (next_head >= len) {
+    js_set_slot(js, port, SLOT_WT_PORT_QUEUE, js_mkarr(js));
+    js_set_slot(js, port, SLOT_WT_PORT_HEAD, js_mknum(0));
+    return true;
+  }
+
+  if (next_head > 32 && next_head * 2 >= len) {
+    jsval_t compact = js_mkarr(js);
+    for (jsoff_t i = next_head; i < len; i++) js_arr_push(js, compact, js_arr_get(js, queue, i));
+    js_set_slot(js, port, SLOT_WT_PORT_QUEUE, compact);
+    js_set_slot(js, port, SLOT_WT_PORT_HEAD, js_mknum(0));
+    return true;
+  }
+
+  js_set_slot(js, port, SLOT_WT_PORT_HEAD, js_mknum((double)next_head));
+  return true;
+}
+
+static void wt_port_queue_push(ant_t *js, jsval_t port, jsval_t value) {
+  jsval_t queue = js_get_slot(js, port, SLOT_WT_PORT_QUEUE);
+  if (vtype(queue) != T_ARR) {
+    queue = js_mkarr(js);
+    js_set_slot(js, port, SLOT_WT_PORT_QUEUE, queue);
+    js_set_slot(js, port, SLOT_WT_PORT_HEAD, js_mknum(0));
+  }
+  js_arr_push(js, queue, value);
+}
+
+static void wt_port_call_listener(ant_t *js, jsval_t this_obj, jsval_t fn, jsval_t arg) {
+  if (!wt_is_callable(fn)) return;
+  jsval_t argv[1] = {arg};
+  
+  sv_vm_call(js->vm, js, fn, this_obj, argv, 1, NULL, false);
+}
+
+static bool wt_port_should_deliver(ant_t *js, jsval_t port) {
+  if (wt_port_is_closed(js, port)) return false;
+  bool started = js_truthy(js, js_get_slot(js, port, SLOT_WT_PORT_STARTED));
+  jsval_t on_fn = js_get_slot(js, port, SLOT_WT_PORT_ON_MESSAGE);
+  jsval_t once_fn = js_get_slot(js, port, SLOT_WT_PORT_ONCE_MESSAGE);
+  jsval_t onmessage = js_get(js, port, "onmessage");
+
+  bool has_event_listener = wt_is_callable(on_fn) || wt_is_callable(once_fn);
+  if (wt_is_callable(onmessage)) return true;
+  return started && has_event_listener;
+}
+
+static void wt_port_drain(ant_t *js, jsval_t port) {
+  if (!wt_is_message_port(js, port)) return;
+
+  while (wt_port_should_deliver(js, port)) {
+    jsval_t msg = js_mkundef();
+    if (!wt_port_queue_dequeue(js, port, &msg)) break;
+
+    jsval_t on_fn = js_get_slot(js, port, SLOT_WT_PORT_ON_MESSAGE);
+    wt_port_call_listener(js, port, on_fn, msg);
+
+    jsval_t once_fn = js_get_slot(js, port, SLOT_WT_PORT_ONCE_MESSAGE);
+    if (wt_is_callable(once_fn)) {
+      wt_port_call_listener(js, port, once_fn, msg);
+      js_set_slot(js, port, SLOT_WT_PORT_ONCE_MESSAGE, js_mkundef());
+    }
+
+    jsval_t onmessage = js_get(js, port, "onmessage");
+    if (wt_is_callable(onmessage)) {
+      jsval_t event_obj = js_mkobj(js);
+      js_set(js, event_obj, "data", msg);
+      wt_port_call_listener(js, port, onmessage, event_obj);
+    }
+
+    if (wt_port_is_closed(js, port)) break;
+  }
+}
+
+static jsval_t wt_make_resolved_promise(ant_t *js, jsval_t value) {
+  jsval_t p = js_mkpromise(js);
+  js_resolve_promise(js, p, value);
+  return p;
+}
+
+static void wt_call_listener(ant_t *js, jsval_t this_obj, jsval_t fn, jsval_t arg) {
+  if (!wt_is_callable(fn)) return;
+  jsval_t argv[1] = {arg};
+
+  sv_vm_call(js->vm, js, fn, this_obj, argv, 1, NULL, false);
+}
+
+static void wt_emit(ant_worker_thread_t *wt, const char *event, jsval_t arg) {
+  if (!wt || !wt->js) return;
+  ant_t *js = wt->js;
+  jsval_t this_obj = js_deref(js, wt->self_root);
+  if (!is_object_type(this_obj)) return;
+
+  internal_slot_t on_slot, once_slot;
+  if (strcmp(event, "message") == 0) {
+    on_slot = SLOT_WT_ON_MESSAGE;
+    once_slot = SLOT_WT_ONCE_MESSAGE;
+  } else if (strcmp(event, "exit") == 0) {
+    on_slot = SLOT_WT_ON_EXIT;
+    once_slot = SLOT_WT_ONCE_EXIT;
+  } else return;
+
+  jsval_t on_fn = js_get_slot(js, this_obj, on_slot);
+  wt_call_listener(js, this_obj, on_fn, arg);
+
+  jsval_t once_fn = js_get_slot(js, this_obj, once_slot);
+  if (wt_is_callable(once_fn)) {
+    wt_call_listener(js, this_obj, once_fn, arg);
+    js_set_slot(js, this_obj, once_slot, js_mkundef());
+  }
+}
+
+static void wt_free_env(char **env) {
+  if (!env) return;
+  for (char **p = env; *p; p++) free(*p);
+  free(env);
+}
+
+static char **wt_build_worker_env(const char *worker_data_json, const char *env_store_json) {
+  size_t count = 0;
+  if (environ) {
+    while (environ[count]) count++;
+  }
+
+  size_t extra = 2;
+  if (worker_data_json) extra++;
+  if (env_store_json) extra++;
+  char **env = (char **)calloc(count + extra, sizeof(char *));
+  if (!env) return NULL;
+
+  size_t out = 0;
+  for (size_t i = 0; i < count; i++) {
+    env[out] = strdup(environ[i]);
+    if (!env[out]) {
+      wt_free_env(env);
+      return NULL;
+    }
+    out++;
+  }
+
+  env[out++] = strdup(WT_ENV_MODE "=1");
+  if (!env[out - 1]) {
+    wt_free_env(env);
+    return NULL;
+  }
+
+  if (worker_data_json) {
+    size_t key_len = strlen(WT_ENV_DATA_JSON);
+    size_t val_len = strlen(worker_data_json);
+    char *entry = (char *)malloc(key_len + 1 + val_len + 1);
+    if (!entry) {
+      wt_free_env(env);
+      return NULL;
+    }
+    memcpy(entry, WT_ENV_DATA_JSON, key_len);
+    entry[key_len] = '=';
+    memcpy(entry + key_len + 1, worker_data_json, val_len);
+    entry[key_len + 1 + val_len] = '\0';
+    env[out++] = entry;
+  }
+
+  if (env_store_json) {
+    size_t key_len = strlen(WT_ENV_STORE_JSON);
+    size_t val_len = strlen(env_store_json);
+    char *entry = (char *)malloc(key_len + 1 + val_len + 1);
+    if (!entry) {
+      wt_free_env(env);
+      return NULL;
+    }
+    memcpy(entry, WT_ENV_STORE_JSON, key_len);
+    entry[key_len] = '=';
+    memcpy(entry + key_len + 1, env_store_json, val_len);
+    entry[key_len + 1 + val_len] = '\0';
+    env[out++] = entry;
+  }
+
+  env[out] = NULL;
+  return env;
+}
+
+static void wt_cleanup(ant_worker_thread_t *wt) {
+  if (!wt) return;
+  if (wt->js) {
+    if (wt->self_root) js_unroot(wt->js, wt->self_root);
+    if (wt->has_terminate_root) js_unroot(wt->js, wt->terminate_root);
+  }
+  free(wt->line_buf);
+  free(wt);
+}
+
+static void wt_detach(ant_worker_thread_t *wt) {
+  if (!wt) return;
+  if (wt->js) {
+    if (wt->self_root) js_unroot(wt->js, wt->self_root);
+    if (wt->has_terminate_root) js_unroot(wt->js, wt->terminate_root);
+  }
+  wt->self_root = 0;
+  wt->terminate_root = 0;
+  wt->has_terminate_root = false;
+  free(wt->line_buf);
+  wt->line_buf = NULL;
+  wt->line_len = 0;
+  wt->line_cap = 0;
+  wt->spawned = false;
+  wt->refed = false;
+  wt->closed = true;
+  wt->js = NULL;
+}
+
+static void wt_on_handle_closed(uv_handle_t *h) {
+  ant_worker_thread_t *wt = (ant_worker_thread_t *)h->data;
+  if (!wt) return;
+  if (wt->close_pending > 0) wt->close_pending--;
+  if (wt->close_pending == 0) wt_detach(wt);
+}
+
+static void wt_finish_exit(ant_worker_thread_t *wt) {
+  if (!wt) return;
+  if (wt->closed || wt->closing) return;
+  wt->closing = true;
+  wt->spawned = false;
+  wt->refed = false;
+  wt->close_pending = 0;
+
+  if (!uv_is_closing((uv_handle_t *)&wt->stdout_pipe)) {
+    wt->close_pending++;
+    uv_close((uv_handle_t *)&wt->stdout_pipe, wt_on_handle_closed);
+  }
+  if (!uv_is_closing((uv_handle_t *)&wt->process)) {
+    wt->close_pending++;
+    uv_close((uv_handle_t *)&wt->process, wt_on_handle_closed);
+  }
+
+  if (wt->close_pending == 0) wt_detach(wt);
+}
+
+static void wt_on_process_exit(uv_process_t *proc, int64_t exit_status, int term_signal) {
+  ant_worker_thread_t *wt = (ant_worker_thread_t *)proc->data;
+  if (!wt || !wt->js) return;
+
+  wt->exited = true;
+  wt->exit_status = exit_status;
+  wt->term_signal = term_signal;
+
+  if (wt->has_terminate_root) {
+    jsval_t p = js_deref(wt->js, wt->terminate_root);
+    js_resolve_promise(wt->js, p, js_mknum((double)exit_status));
+    js_root_update(wt->js, wt->terminate_root, js_mkundef());
+    wt->has_terminate_root = false;
+  }
+
+  wt_emit(wt, "exit", js_mknum((double)exit_status));
+  wt_finish_exit(wt);
+}
+
+static void wt_alloc_cb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
+  buf->base = (char *)malloc(suggested_size);
+  buf->len = buf->base ? suggested_size : 0;
+}
+
+static void wt_emit_message_from_json(ant_worker_thread_t *wt, const char *json, size_t len) {
+  if (!wt || !wt->js) return;
+  ant_t *js = wt->js;
+
+  jsval_t s = js_mkstr(js, json, len);
+  jsval_t parse_args[1] = {s};
+  jsval_t msg = js_json_parse(js, parse_args, 1);
+  if (is_err(msg)) msg = s;
+
+  wt_emit(wt, "message", msg);
+}
+
+static void wt_process_lines(ant_worker_thread_t *wt) {
+  if (!wt || !wt->line_buf) return;
+
+  for (;;) {
+    char *nl = memchr(wt->line_buf, '\n', wt->line_len);
+    if (!nl) break;
+
+    size_t line_len = (size_t)(nl - wt->line_buf);
+    if (line_len > 0 && wt->line_buf[line_len - 1] == '\r') line_len--;
+
+    size_t prefix_len = strlen(WT_MSG_PREFIX);
+    if (line_len >= prefix_len && memcmp(wt->line_buf, WT_MSG_PREFIX, prefix_len) == 0) {
+      const char *payload = wt->line_buf + prefix_len;
+      size_t payload_len = line_len - prefix_len;
+      wt_emit_message_from_json(wt, payload, payload_len);
+    }
+
+    size_t consumed = (size_t)(nl - wt->line_buf) + 1;
+    size_t remain = wt->line_len - consumed;
+    memmove(wt->line_buf, wt->line_buf + consumed, remain);
+    wt->line_len = remain;
+  }
+}
+
+static bool wt_append_stdout(ant_worker_thread_t *wt, const char *data, size_t len) {
+  if (!wt || !data || len == 0) return true;
+
+  size_t needed = wt->line_len + len;
+  if (needed + 1 > wt->line_cap) {
+    size_t cap = wt->line_cap ? wt->line_cap : 1024;
+    while (cap < needed + 1) cap *= 2;
+    char *next = (char *)realloc(wt->line_buf, cap);
+    if (!next) return false;
+    wt->line_buf = next;
+    wt->line_cap = cap;
+  }
+
+  memcpy(wt->line_buf + wt->line_len, data, len);
+  wt->line_len += len;
+  wt->line_buf[wt->line_len] = '\0';
+  return true;
+}
+
+static void wt_read_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
+  ant_worker_thread_t *wt = (ant_worker_thread_t *)stream->data;
+  if (!wt) {
+    free(buf->base);
+    return;
+  }
+
+  if (nread > 0) {
+    if (wt_append_stdout(wt, buf->base, (size_t)nread)) wt_process_lines(wt);
+  } else if (nread < 0) {
+    uv_read_stop(stream);
+  }
+
+  free(buf->base);
+}
+
+static char *wt_path_from_specifier(ant_t *js, jsval_t spec) {
+  const char *raw = NULL;
+  size_t len = 0;
+
+  if (vtype(spec) == T_STR) {
+    raw = js_getstr(js, spec, &len);
+  } else if (is_object_type(spec)) {
+    jsval_t pathname = js_get(js, spec, "pathname");
+    if (vtype(pathname) == T_STR) raw = js_getstr(js, pathname, &len);
+    if (!raw) {
+      jsval_t href = js_get(js, spec, "href");
+      if (vtype(href) == T_STR) raw = js_getstr(js, href, &len);
+    }
+  }
+
+  if (!raw || len == 0) return NULL;
+
+  if (len >= 7 && strncmp(raw, "file://", 7) == 0) {
+    const char *p = raw + 7;
+    if (strncmp(p, "localhost/", 10) == 0) p += 9;
+    if (*p == '\0') return NULL;
+    return strndup(p, len - (size_t)(p - raw));
+  }
+
+  return strndup(raw, len);
+}
+
+static int wt_spawn_worker(
+  ant_worker_thread_t *wt,
+  const char *script_path,
+  const char *worker_data_json,
+  const char *env_store_json
+) {
+  if (!wt || !wt->js || !script_path || !rt || !rt->argv || rt->argc <= 0) return UV_EINVAL;
+
+  uv_loop_t *loop = uv_default_loop();
+  uv_pipe_init(loop, &wt->stdout_pipe, 0);
+
+  uv_stdio_container_t stdio[3];
+  stdio[0].flags = UV_IGNORE;
+  stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
+  stdio[1].data.stream = (uv_stream_t *)&wt->stdout_pipe;
+  stdio[2].flags = UV_INHERIT_FD;
+  stdio[2].data.fd = 2;
+
+  char *argv0 = strdup(rt->argv[0]);
+  char *argv1 = strdup(script_path);
+  if (!argv0 || !argv1) {
+    free(argv0);
+    free(argv1);
+    uv_close((uv_handle_t *)&wt->stdout_pipe, NULL);
+    return UV_ENOMEM;
+  }
+
+  char *args[3] = {argv0, argv1, NULL};
+  char **env = wt_build_worker_env(worker_data_json, env_store_json);
+  if (!env) {
+    free(argv0);
+    free(argv1);
+    uv_close((uv_handle_t *)&wt->stdout_pipe, NULL);
+    return UV_ENOMEM;
+  }
+
+  uv_process_options_t options;
+  memset(&options, 0, sizeof(options));
+  options.file = argv0;
+  options.args = args;
+  options.env = env;
+  options.stdio_count = 3;
+  options.stdio = stdio;
+  options.exit_cb = wt_on_process_exit;
+
+  wt->process.data = wt;
+  wt->stdout_pipe.data = wt;
+
+  int rc = uv_spawn(loop, &wt->process, &options);
+
+  wt_free_env(env);
+  free(argv0);
+  free(argv1);
+
+  if (rc != 0) {
+    uv_close((uv_handle_t *)&wt->stdout_pipe, NULL);
+    return rc;
+  }
+
+  wt->spawned = true;
+  wt->refed = true;
+
+  rc = uv_read_start((uv_stream_t *)&wt->stdout_pipe, wt_alloc_cb, wt_read_cb);
+  if (rc != 0) {
+    uv_process_kill(&wt->process, SIGTERM);
+  }
+  return rc;
+}
+
+static jsval_t worker_threads_worker_on(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2 || vtype(args[0]) != T_STR || !wt_is_callable(args[1])) {
+    return js_mkerr(js, "Worker.on(event, listener) requires (string, function)");
+  }
+
+  jsval_t this_obj = js_getthis(js);
+  if (!is_object_type(this_obj)) return js_mkerr(js, "invalid Worker receiver");
+
+  size_t len = 0;
+  const char *event = js_getstr(js, args[0], &len);
+  if (!event) return js_mkerr(js, "invalid event name");
+
+  if (len == 7 && memcmp(event, "message", 7) == 0) {
+    js_set_slot(js, this_obj, SLOT_WT_ON_MESSAGE, args[1]);
+  } else if (len == 4 && memcmp(event, "exit", 4) == 0) {
+    js_set_slot(js, this_obj, SLOT_WT_ON_EXIT, args[1]);
+  }
+
+  return this_obj;
+}
+
+static jsval_t worker_threads_worker_once(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2 || vtype(args[0]) != T_STR || !wt_is_callable(args[1])) {
+    return js_mkerr(js, "Worker.once(event, listener) requires (string, function)");
+  }
+
+  jsval_t this_obj = js_getthis(js);
+  if (!is_object_type(this_obj)) return js_mkerr(js, "invalid Worker receiver");
+
+  size_t len = 0;
+  const char *event = js_getstr(js, args[0], &len);
+  if (!event) return js_mkerr(js, "invalid event name");
+
+  if (len == 7 && memcmp(event, "message", 7) == 0) {
+    js_set_slot(js, this_obj, SLOT_WT_ONCE_MESSAGE, args[1]);
+  } else if (len == 4 && memcmp(event, "exit", 4) == 0) {
+    js_set_slot(js, this_obj, SLOT_WT_ONCE_EXIT, args[1]);
+  }
+
+  return this_obj;
+}
+
+static jsval_t worker_threads_worker_unref(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  ant_worker_thread_t *wt = wt_get_worker(js, this_obj);
+  if (!wt) return js_mkerr(js, "invalid Worker receiver");
+  if (wt->spawned && wt->refed) {
+    if (!uv_is_closing((uv_handle_t *)&wt->process)) uv_unref((uv_handle_t *)&wt->process);
+    if (!uv_is_closing((uv_handle_t *)&wt->stdout_pipe)) uv_unref((uv_handle_t *)&wt->stdout_pipe);
+    wt->refed = false;
+  }
+  return this_obj;
+}
+
+static jsval_t worker_threads_worker_ref(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  ant_worker_thread_t *wt = wt_get_worker(js, this_obj);
+  if (!wt) return js_mkerr(js, "invalid Worker receiver");
+  if (wt->spawned && !wt->refed) {
+    if (!uv_is_closing((uv_handle_t *)&wt->process)) uv_ref((uv_handle_t *)&wt->process);
+    if (!uv_is_closing((uv_handle_t *)&wt->stdout_pipe)) uv_ref((uv_handle_t *)&wt->stdout_pipe);
+    wt->refed = true;
+  }
+  return this_obj;
+}
+
+static jsval_t worker_threads_worker_terminate(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  ant_worker_thread_t *wt = wt_get_worker(js, this_obj);
+  if (!wt) return js_mkerr(js, "invalid Worker receiver");
+
+  if (wt->exited) return wt_make_resolved_promise(js, js_mknum((double)wt->exit_status));
+
+  if (!wt->has_terminate_root) {
+    jsval_t p = js_mkpromise(js);
+    wt->terminate_root = js_root(js, p);
+    wt->has_terminate_root = true;
+  }
+
+  int rc = uv_process_kill(&wt->process, SIGTERM);
+  if (rc != 0) {
+    jsval_t p = js_deref(js, wt->terminate_root);
+    js_reject_promise(js, p, js_mkerr(js, "terminate failed: %s", uv_strerror(rc)));
+    js_root_update(js, wt->terminate_root, js_mkundef());
+    wt->has_terminate_root = false;
+    return p;
+  }
+
+  return js_deref(js, wt->terminate_root);
+}
+
+static jsval_t worker_threads_worker_post_message(ant_t *js, jsval_t *args, int nargs) {
+  return js_mkerr(js, "Worker.postMessage is not implemented yet");
+}
+
+static jsval_t worker_threads_message_port_post_message(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (!wt_is_message_port(js, this_obj)) return js_mkerr(js, "invalid MessagePort receiver");
+  if (wt_port_is_closed(js, this_obj)) return js_mkundef();
+
+  jsval_t peer = js_get_slot(js, this_obj, SLOT_WT_PORT_PEER);
+  if (!wt_is_message_port(js, peer) || wt_port_is_closed(js, peer)) return js_mkundef();
+
+  jsval_t value = (nargs > 0) ? args[0] : js_mkundef();
+  wt_port_queue_push(js, peer, value);
+  wt_port_drain(js, peer);
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_message_port_on(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2 || vtype(args[0]) != T_STR || !wt_is_callable(args[1])) {
+    return js_mkerr(js, "MessagePort.on(event, listener) requires (string, function)");
+  }
+  jsval_t this_obj = js_getthis(js);
+  if (!wt_is_message_port(js, this_obj)) return js_mkerr(js, "invalid MessagePort receiver");
+
+  size_t len = 0;
+  const char *event = js_getstr(js, args[0], &len);
+  if (!event) return js_mkerr(js, "invalid event name");
+  if (len == 7 && memcmp(event, "message", 7) == 0) {
+    js_set_slot(js, this_obj, SLOT_WT_PORT_ON_MESSAGE, args[1]);
+    js_set_slot(js, this_obj, SLOT_WT_PORT_STARTED, js_true);
+    wt_port_drain(js, this_obj);
+  }
+  return this_obj;
+}
+
+static jsval_t worker_threads_message_port_once(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2 || vtype(args[0]) != T_STR || !wt_is_callable(args[1])) {
+    return js_mkerr(js, "MessagePort.once(event, listener) requires (string, function)");
+  }
+  jsval_t this_obj = js_getthis(js);
+  if (!wt_is_message_port(js, this_obj)) return js_mkerr(js, "invalid MessagePort receiver");
+
+  size_t len = 0;
+  const char *event = js_getstr(js, args[0], &len);
+  if (!event) return js_mkerr(js, "invalid event name");
+  if (len == 7 && memcmp(event, "message", 7) == 0) {
+    js_set_slot(js, this_obj, SLOT_WT_PORT_ONCE_MESSAGE, args[1]);
+    js_set_slot(js, this_obj, SLOT_WT_PORT_STARTED, js_true);
+    wt_port_drain(js, this_obj);
+  }
+  return this_obj;
+}
+
+static jsval_t worker_threads_message_port_start(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (!wt_is_message_port(js, this_obj)) return js_mkerr(js, "invalid MessagePort receiver");
+  js_set_slot(js, this_obj, SLOT_WT_PORT_STARTED, js_true);
+  wt_port_drain(js, this_obj);
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_message_port_close(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t this_obj = js_getthis(js);
+  if (!wt_is_message_port(js, this_obj)) return js_mkerr(js, "invalid MessagePort receiver");
+  wt_port_set_closed(js, this_obj, true);
+
+  jsval_t peer = js_get_slot(js, this_obj, SLOT_WT_PORT_PEER);
+  js_set_slot(js, this_obj, SLOT_WT_PORT_PEER, js_mknull());
+  if (wt_is_message_port(js, peer)) js_set_slot(js, peer, SLOT_WT_PORT_PEER, js_mknull());
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_message_port_ref(ant_t *js, jsval_t *args, int nargs) {
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_message_port_unref(ant_t *js, jsval_t *args, int nargs) {
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_message_port_ctor(ant_t *js, jsval_t *args, int nargs) {
+  return js_mkerr(js, "MessagePort constructor is not public");
+}
+
+static jsval_t worker_threads_message_channel_ctor(ant_t *js, jsval_t *args, int nargs) {
+  if (vtype(js->new_target) == T_UNDEF) {
+    return js_mkerr(js, "MessageChannel constructor requires 'new'");
+  }
+
+  jsval_t this_obj = js_getthis(js);
+  jsval_t port1 = wt_make_message_port(js);
+  jsval_t port2 = wt_make_message_port(js);
+  js_set_slot(js, port1, SLOT_WT_PORT_PEER, port2);
+  js_set_slot(js, port2, SLOT_WT_PORT_PEER, port1);
+  js_set(js, this_obj, "port1", port1);
+  js_set(js, this_obj, "port2", port2);
+  return this_obj;
+}
+
+static jsval_t worker_threads_worker_ctor(ant_t *js, jsval_t *args, int nargs) {
+  if (vtype(js->new_target) == T_UNDEF) {
+    return js_mkerr(js, "Worker constructor requires 'new'");
+  }
+  if (nargs < 1) return js_mkerr(js, "Worker() requires a filename or URL");
+
+  char *script_path = wt_path_from_specifier(js, args[0]);
+  if (!script_path) return js_mkerr(js, "Invalid Worker filename/URL");
+
+  const char *worker_data_json = NULL;
+  const char *env_store_json = NULL;
+  char *worker_data_heap = NULL;
+  char *env_store_heap = NULL;
+  if (nargs >= 2 && is_object_type(args[1])) {
+    jsval_t worker_data = js_get(js, args[1], "workerData");
+    if (!is_undefined(worker_data)) {
+      jsval_t stringify_args[1] = {worker_data};
+      jsval_t json = js_json_stringify(js, stringify_args, 1);
+      if (vtype(json) != T_STR) {
+        free(script_path);
+        return js_mkerr(js, "Worker options.workerData must be JSON-serializable");
+      }
+      size_t len = 0;
+      const char *raw = js_getstr(js, json, &len);
+      if (!raw) {
+        free(script_path);
+        return js_mkerr(js, "Failed to stringify workerData");
+      }
+      worker_data_heap = strndup(raw, len);
+      if (!worker_data_heap) {
+        free(script_path);
+        return js_mkerr(js, "Out of memory");
+      }
+      worker_data_json = worker_data_heap;
+    }
+  }
+
+  jsval_t env_store = wt_get_or_create_env_store(js);
+  jsval_t env_stringify_args[1] = {env_store};
+  jsval_t env_json = js_json_stringify(js, env_stringify_args, 1);
+  if (vtype(env_json) != T_STR) {
+    free(script_path);
+    free(worker_data_heap);
+    return js_mkerr(js, "setEnvironmentData values must be JSON-serializable");
+  }
+  size_t env_len = 0;
+  const char *env_raw = js_getstr(js, env_json, &env_len);
+  if (!env_raw) {
+    free(script_path);
+    free(worker_data_heap);
+    return js_mkerr(js, "Failed to snapshot environment data");
+  }
+  env_store_heap = strndup(env_raw, env_len);
+  if (!env_store_heap) {
+    free(script_path);
+    free(worker_data_heap);
+    return js_mkerr(js, "Out of memory");
+  }
+  env_store_json = env_store_heap;
+
+  jsval_t this_obj = js_getthis(js);
+  ant_worker_thread_t *wt = (ant_worker_thread_t *)calloc(1, sizeof(*wt));
+  if (!wt) {
+    free(script_path);
+    free(worker_data_heap);
+    free(env_store_heap);
+    return js_mkerr(js, "Out of memory");
+  }
+
+  wt->js = js;
+  wt->self_root = js_root(js, this_obj);
+  js_set_slot(js, this_obj, SLOT_DATA, ANT_PTR(wt));
+
+  int rc = wt_spawn_worker(wt, script_path, worker_data_json, env_store_json);
+  free(script_path);
+  free(worker_data_heap);
+  free(env_store_heap);
+
+  if (rc != 0) {
+    js_set_slot(js, this_obj, SLOT_DATA, js_mkundef());
+    wt_cleanup(wt);
+    return js_mkerr(js, "Failed to spawn Worker: %s", uv_strerror(rc));
+  }
+
+  return this_obj;
+}
+
+static jsval_t worker_threads_parent_post_message(ant_t *js, jsval_t *args, int nargs) {
+  jsval_t value = (nargs > 0) ? args[0] : js_mkundef();
+  jsval_t stringify_args[1] = {value};
+  jsval_t json = js_json_stringify(js, stringify_args, 1);
+  if (vtype(json) != T_STR) return js_mkerr(js, "parentPort.postMessage payload must be JSON-serializable");
+
+  size_t json_len = 0;
+  const char *json_str = js_getstr(js, json, &json_len);
+  if (!json_str) return js_mkerr(js, "Failed to serialize message");
+
+  size_t prefix_len = strlen(WT_MSG_PREFIX);
+  size_t line_len = prefix_len + json_len + 1;
+  char *line = (char *)malloc(line_len + 1);
+  if (!line) return js_mkerr(js, "Out of memory");
+
+  memcpy(line, WT_MSG_PREFIX, prefix_len);
+  memcpy(line + prefix_len, json_str, json_len);
+  line[prefix_len + json_len] = '\n';
+  line[prefix_len + json_len + 1] = '\0';
+
+  ssize_t wrote = WT_WRITE(WT_STDOUT_FD, line, (unsigned int)line_len);
+  free(line);
+  if (wrote < 0) return js_mkerr(js, "parentPort.postMessage failed");
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_parent_unref(ant_t *js, jsval_t *args, int nargs) {
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_mark_as_untransferable(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkundef();
+  return args[0];
+}
+
+static jsval_t worker_threads_receive_message_on_port(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || !wt_is_message_port(js, args[0])) {
+    return js_mkerr(js, "receiveMessageOnPort(port) requires a MessagePort");
+  }
+  jsval_t msg = js_mkundef();
+  if (!wt_port_queue_dequeue(js, args[0], &msg)) return js_mkundef();
+
+  jsval_t out = js_mkobj(js);
+  js_set(js, out, "message", msg);
+  return out;
+}
+
+static jsval_t worker_threads_set_environment_data(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 2) return js_mkerr(js, "setEnvironmentData(key, value) requires 2 arguments");
+
+  jsval_t key_stringify_args[1] = {args[0]};
+  jsval_t key_json = js_json_stringify(js, key_stringify_args, 1);
+  if (vtype(key_json) != T_STR) return js_mkerr(js, "setEnvironmentData key must be JSON-serializable");
+
+  jsval_t value_stringify_args[1] = {args[1]};
+  jsval_t value_json = js_json_stringify(js, value_stringify_args, 1);
+  if (vtype(value_json) != T_STR) return js_mkerr(js, "setEnvironmentData value must be JSON-serializable");
+
+  jsval_t parse_args[1] = {value_json};
+  jsval_t cloned = js_json_parse(js, parse_args, 1);
+  if (is_err(cloned)) return js_mkerr(js, "setEnvironmentData value must be JSON-serializable");
+
+  size_t key_len = 0;
+  const char *key_ptr = js_getstr(js, key_json, &key_len);
+  if (!key_ptr) return js_mkerr(js, "Failed to serialize environment data key");
+
+  char *key = strndup(key_ptr, key_len);
+  if (!key) return js_mkerr(js, "Out of memory");
+  js_set(js, wt_get_or_create_env_store(js), key, cloned);
+  free(key);
+  return js_mkundef();
+}
+
+static jsval_t worker_threads_get_environment_data(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1) return js_mkundef();
+
+  jsval_t key_stringify_args[1] = {args[0]};
+  jsval_t key_json = js_json_stringify(js, key_stringify_args, 1);
+  if (vtype(key_json) != T_STR) return js_mkundef();
+
+  size_t key_len = 0;
+  const char *key_ptr = js_getstr(js, key_json, &key_len);
+  if (!key_ptr) return js_mkundef();
+
+  char *key = strndup(key_ptr, key_len);
+  if (!key) return js_mkerr(js, "Out of memory");
+
+  jsval_t store = wt_get_or_create_env_store(js);
+  jsoff_t off = lkp(js, store, key, key_len);
+  if (off == 0) {
+    free(key);
+    return js_mkundef();
+  }
+
+  jsval_t value = js_get(js, store, key);
+  free(key);
+  return value;
+}
+
+static jsval_t worker_threads_move_message_port_to_context(ant_t *js, jsval_t *args, int nargs) {
+  if (nargs < 1 || !wt_is_message_port(js, args[0])) {
+    return js_mkerr(js, "moveMessagePortToContext(port, context) requires a MessagePort");
+  }
+  return args[0];
+}
+
+jsval_t worker_threads_library(ant_t *js) {
+  jsval_t lib = js_mkobj(js);
+  bool is_worker = wt_is_worker_mode();
+
+  wt_init_env_store(js, is_worker);
+
+  js_set(js, lib, "isMainThread", js_bool(!is_worker));
+  js_set(js, lib, "threadId", js_mknum((double)(is_worker ? rt->pid : 0)));
+  js_set(js, lib, "SHARE_ENV", js_mksym(js, "SHARE_ENV"));
+
+  jsval_t message_port_ctor_obj = js_mkobj(js);
+  jsval_t message_port_proto = js_mkobj(js);
+  js_set(js, message_port_proto, "postMessage", js_mkfun(worker_threads_message_port_post_message));
+  js_set(js, message_port_proto, "on", js_mkfun(worker_threads_message_port_on));
+  js_set(js, message_port_proto, "once", js_mkfun(worker_threads_message_port_once));
+  js_set(js, message_port_proto, "start", js_mkfun(worker_threads_message_port_start));
+  js_set(js, message_port_proto, "close", js_mkfun(worker_threads_message_port_close));
+  js_set(js, message_port_proto, "ref", js_mkfun(worker_threads_message_port_ref));
+  js_set(js, message_port_proto, "unref", js_mkfun(worker_threads_message_port_unref));
+  js_set_sym(js, message_port_proto, get_toStringTag_sym(), js_mkstr(js, "MessagePort", 11));
+
+  js_set_slot(js, message_port_ctor_obj, SLOT_CFUNC, js_mkfun(worker_threads_message_port_ctor));
+  js_mkprop_fast(js, message_port_ctor_obj, "prototype", 9, message_port_proto);
+  js_mkprop_fast(js, message_port_ctor_obj, "name", 4, js_mkstr(js, "MessagePort", 11));
+  js_set_descriptor(js, message_port_ctor_obj, "name", 4, 0);
+  js_set(js, lib, "MessagePort", js_obj_to_func(message_port_ctor_obj));
+  js_set_slot(js, js->global, SLOT_WT_PORT_PROTO, message_port_proto);
+
+  jsval_t message_channel_ctor_obj = js_mkobj(js);
+  jsval_t message_channel_proto = js_mkobj(js);
+  js_set_sym(js, message_channel_proto, get_toStringTag_sym(), js_mkstr(js, "MessageChannel", 14));
+  js_set_slot(js, message_channel_ctor_obj, SLOT_CFUNC, js_mkfun(worker_threads_message_channel_ctor));
+  js_mkprop_fast(js, message_channel_ctor_obj, "prototype", 9, message_channel_proto);
+  js_mkprop_fast(js, message_channel_ctor_obj, "name", 4, js_mkstr(js, "MessageChannel", 14));
+  js_set_descriptor(js, message_channel_ctor_obj, "name", 4, 0);
+  js_set(js, lib, "MessageChannel", js_obj_to_func(message_channel_ctor_obj));
+
+  if (is_worker) {
+    jsval_t parent_port = js_mkobj(js);
+    js_set(js, parent_port, "postMessage", js_mkfun(worker_threads_parent_post_message));
+    js_set(js, parent_port, "unref", js_mkfun(worker_threads_parent_unref));
+    js_set(js, parent_port, "ref", js_mkfun(worker_threads_parent_unref));
+    js_set(js, lib, "parentPort", parent_port);
+
+    const char *worker_data_json = getenv(WT_ENV_DATA_JSON);
+    if (worker_data_json && worker_data_json[0]) {
+      jsval_t raw = js_mkstr(js, worker_data_json, strlen(worker_data_json));
+      jsval_t parse_args[1] = {raw};
+      jsval_t parsed = js_json_parse(js, parse_args, 1);
+      js_set(js, lib, "workerData", is_err(parsed) ? js_mkundef() : parsed);
+    } else js_set(js, lib, "workerData", js_mkundef());
+  } else {
+    js_set(js, lib, "parentPort", js_mknull());
+    js_set(js, lib, "workerData", js_mkundef());
+  }
+
+  jsval_t worker_ctor_obj = js_mkobj(js);
+  jsval_t worker_proto = js_mkobj(js);
+
+  js_set(js, worker_proto, "on", js_mkfun(worker_threads_worker_on));
+  js_set(js, worker_proto, "once", js_mkfun(worker_threads_worker_once));
+  js_set(js, worker_proto, "terminate", js_mkfun(worker_threads_worker_terminate));
+  js_set(js, worker_proto, "unref", js_mkfun(worker_threads_worker_unref));
+  js_set(js, worker_proto, "ref", js_mkfun(worker_threads_worker_ref));
+  js_set(js, worker_proto, "postMessage", js_mkfun(worker_threads_worker_post_message));
+  js_set_sym(js, worker_proto, get_toStringTag_sym(), js_mkstr(js, "Worker", 6));
+
+  js_set_slot(js, worker_ctor_obj, SLOT_CFUNC, js_mkfun(worker_threads_worker_ctor));
+  js_mkprop_fast(js, worker_ctor_obj, "prototype", 9, worker_proto);
+  js_mkprop_fast(js, worker_ctor_obj, "name", 4, js_mkstr(js, "Worker", 6));
+  js_set_descriptor(js, worker_ctor_obj, "name", 4, 0);
+  js_set(js, lib, "Worker", js_obj_to_func(worker_ctor_obj));
+
+  js_set(js, lib, "markAsUntransferable", js_mkfun(worker_threads_mark_as_untransferable));
+  js_set(js, lib, "receiveMessageOnPort", js_mkfun(worker_threads_receive_message_on_port));
+  js_set(js, lib, "setEnvironmentData", js_mkfun(worker_threads_set_environment_data));
+  js_set(js, lib, "getEnvironmentData", js_mkfun(worker_threads_get_environment_data));
+  js_set(js, lib, "moveMessagePortToContext", js_mkfun(worker_threads_move_message_port_to_context));
+
+  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "worker_threads", 14));
+  return lib;
+}
diff --git a/src/pkg/fetcher.zig b/src/pkg/fetcher.zig
index d14fe0c..91fc178 100644
--- a/src/pkg/fetcher.zig
+++ b/src/pkg/fetcher.zig
@@ -88,6 +88,7 @@ const Http2Client = struct {
   requests: [MAX_PENDING_REQUESTS]RequestState,
   request_count: usize,
   requests_done: usize,
+  last_response_status_code: u16,
 
   const RequestState = struct {
     stream_id: i32,
@@ -134,6 +135,7 @@ const Http2Client = struct {
       .requests = undefined,
       .request_count = 0,
       .requests_done = 0,
+      .last_response_status_code = 0,
     };
 
     for (&client.requests) |*req| {
@@ -532,6 +534,7 @@ const Http2Client = struct {
       try self.flush();
     }
     
+    self.last_response_status_code = req.status_code;
     if (req.has_error or req.status_code != 200) return error.ResponseError;
     return try allocator.dupe(u8, req.response_body.items);
   }
@@ -667,6 +670,13 @@ pub const Fetcher = struct {
   tarball_contexts: std.ArrayListUnmanaged(*TarballCtx),
   tarball_round_robin: usize,
   tarball_stats: std.ArrayListUnmanaged(TarballStats),
+  last_http_error_url: ?[]u8,
+  last_http_error_status: u16,
+
+  pub const HttpErrorInfo = struct {
+    url: []const u8,
+    status: u16,
+  };
 
   pub fn init(allocator: std.mem.Allocator, registry_host: []const u8) !*Fetcher {
     const f = try allocator.create(Fetcher);
@@ -681,11 +691,14 @@ pub const Fetcher = struct {
       .tarball_contexts = .{},
       .tarball_round_robin = 0,
       .tarball_stats = .{},
+      .last_http_error_url = null,
+      .last_http_error_status = 0,
     };
     return f;
   }
 
   pub fn deinit(self: *Fetcher) void {
+    if (self.last_http_error_url) |url| self.allocator.free(url);
     for (&self.meta_clients) |*maybe_client| {
       if (maybe_client.*) |c| { c.deinit();  maybe_client.* = null; }
     }
@@ -705,6 +718,23 @@ pub const Fetcher = struct {
     self.allocator.destroy(self);
   }
 
+  fn clearLastHttpError(self: *Fetcher) void {
+    if (self.last_http_error_url) |url| self.allocator.free(url);
+    self.last_http_error_url = null;
+    self.last_http_error_status = 0;
+  }
+
+  fn setLastHttpError(self: *Fetcher, url: []const u8, status: u16) void {
+    self.clearLastHttpError();
+    self.last_http_error_url = self.allocator.dupe(u8, url) catch null;
+    self.last_http_error_status = status;
+  }
+
+  pub fn getLastHttpError(self: *const Fetcher) ?HttpErrorInfo {
+    const url = self.last_http_error_url orelse return null;
+    return .{ .url = url, .status = self.last_http_error_status };
+  }
+
   fn ensureMetaClients(self: *Fetcher) !void {
     if (self.meta_clients_initialized) return;
 
@@ -731,6 +761,7 @@ pub const Fetcher = struct {
   }
 
   pub fn resetMetaClients(self: *Fetcher) void {
+    self.clearLastHttpError();
     for (&self.meta_clients) |*slot| {
       if (slot.*) |client| { client.deinit(); slot.* = null; }
     }
@@ -1132,14 +1163,86 @@ pub const Fetcher = struct {
     return self.fetchMetadataFull(package_name, false, allocator);
   }
 
+  const DecodedMetadata = struct {
+    data: []u8,
+    compressed: bool,
+  };
+
+  fn metaClientCanQueue(c: *const Http2Client) bool {
+    return c.h2_session != null and c.connected == 1 and c.request_count < MAX_PENDING_REQUESTS - 1;
+  }
+
+  fn nextMetaClient(self: *Fetcher, conn_idx: *usize) ?*Http2Client {
+    var attempts: usize = 0;
+    while (attempts < NUM_META_CONNECTIONS) : (attempts += 1) {
+      if (self.meta_clients[conn_idx.*]) |c| {
+        if (metaClientCanQueue(c)) return c;
+      }
+      conn_idx.* = (conn_idx.* + 1) % NUM_META_CONNECTIONS;
+    }
+    return null;
+  }
+
+  fn flushMetaClients(self: *Fetcher) void {
+    for (self.meta_clients) |maybe_client| {
+      if (maybe_client) |c| c.flush() catch {};
+    }
+  }
+
+  fn metaRequestsComplete(self: *Fetcher) bool {
+    for (self.meta_clients) |maybe_client| {
+      if (maybe_client) |c| {
+        for (c.requests[0..c.request_count]) |*req| {
+          if (!req.done and !req.has_error) return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  fn decodeMetadataOwned(
+    req: *Http2Client.RequestState,
+    allocator: std.mem.Allocator,
+    decompress_buf: *std.ArrayListUnmanaged(u8),
+  ) ?DecodedMetadata {
+    if (req.has_error or req.status_code != 200) return null;
+
+    if (req.content_encoding != .gzip) {
+      const data = allocator.dupe(u8, req.response_body.items) catch return null;
+      return .{ .data = data, .compressed = false };
+    }
+
+    decompress_buf.clearRetainingCapacity();
+    const decomp = extractor.GzipDecompressor.init(allocator) catch return null;
+    defer decomp.deinit();
+
+    _ = decomp.decompress(req.response_body.items, struct {
+      fn onChunk(data: []const u8, ctx: ?*anyopaque) anyerror!void {
+        const buf: *std.ArrayListUnmanaged(u8) = @ptrCast(@alignCast(ctx));
+        try buf.appendSlice(c_allocator, data);
+      }
+    }.onChunk, decompress_buf) catch return null;
+
+    const data = allocator.dupe(u8, decompress_buf.items) catch return null;
+    return .{ .data = data, .compressed = true };
+  }
+
   pub fn fetchMetadataFull(self: *Fetcher, package_name: []const u8, full: bool, allocator: std.mem.Allocator) ![]u8 {
     try self.ensureMetaClients();
+    self.clearLastHttpError();
     for (self.meta_clients) |maybe_client| {
       if (maybe_client) |client| {
         var path_buf: [512]u8 = undefined;
         const path_slice = std.fmt.bufPrint(&path_buf, "/{s}", .{package_name}) catch return error.OutOfMemory;
         const accept: [:0]const u8 = if (full) "application/json" else "application/vnd.npm.install-v1+json";
-        return client.getWithAccept(path_slice, accept, allocator);
+        return client.getWithAccept(path_slice, accept, allocator) catch |err| {
+          if (err == error.ResponseError) {
+            var url_buf: [1024]u8 = undefined;
+            const url = std.fmt.bufPrint(&url_buf, "https://{s}/{s}", .{ self.registry_host, package_name }) catch "";
+            self.setLastHttpError(url, client.last_response_status_code);
+          }
+          return err;
+        };
       }
     }
     return error.ConnectionFailed;
@@ -1152,6 +1255,21 @@ pub const Fetcher = struct {
     has_error: bool,
   };
 
+  fn storeMetadataBatchResult(
+    req: *Http2Client.RequestState,
+    result: *MetadataResult,
+    allocator: std.mem.Allocator,
+    decompress_buf: *std.ArrayListUnmanaged(u8),
+  ) bool {
+    const decoded = decodeMetadataOwned(req, allocator, decompress_buf) orelse {
+      result.has_error = true;
+      return false;
+    };
+    result.data = decoded.data;
+    result.compressed = decoded.compressed;
+    return true;
+  }
+
   pub fn fetchMetadataBatch(self: *Fetcher, names: []const []const u8, allocator: std.mem.Allocator) ![]MetadataResult {
     if (names.len == 0) return &[_]MetadataResult{};
 
@@ -1189,22 +1307,10 @@ pub const Fetcher = struct {
         const result = &results[i];
         const name = names[i];
 
-        var client: ?*Http2Client = null;
-        var attempts: usize = 0;
-        while (attempts < NUM_META_CONNECTIONS) : (attempts += 1) {
-          if (self.meta_clients[conn_idx]) |c| {
-            if (c.h2_session != null and c.connected == 1 and c.request_count < MAX_PENDING_REQUESTS - 1) {
-              client = c; break;
-            }
-          }
-          conn_idx = (conn_idx + 1) % NUM_META_CONNECTIONS;
-        }
-
-        if (client == null) {
+        const c = self.nextMetaClient(&conn_idx) orelse {
           result.has_error = true; continue;
-        }
-
-        const c = client.?;
+        };
+        
         const session = c.h2_session orelse {
           result.has_error = true; continue;
         };
@@ -1257,11 +1363,9 @@ pub const Fetcher = struct {
         queued += 1;
         conn_idx = (conn_idx + 1) % NUM_META_CONNECTIONS;
       }
+      
       batch_start = debug.timer("  meta: queue requests", batch_start);
-
-      for (self.meta_clients) |maybe_client| {
-        if (maybe_client) |c| c.flush() catch {};
-      }
+      self.flushMetaClients();
 
       const loop = uv.uv_default_loop();
       var all_done = false;
@@ -1271,15 +1375,7 @@ pub const Fetcher = struct {
       while (!all_done) {
         _ = uv.uv_run(loop, uv.RUN_ONCE);
         loops += 1;
-
-        all_done = true;
-        for (self.meta_clients) |maybe_client| {
-          if (maybe_client) |c| {
-            for (c.requests[0..c.request_count]) |*req| {
-              if (!req.done and !req.has_error) { all_done = false; break; }
-            } if (!all_done) break;
-          }
-        }
+        all_done = self.metaRequestsComplete();
       }
 
       const elapsed_ns: u64 = @intCast(@as(i128, @intCast(std.time.nanoTimestamp())) - @as(i128, run_start));
@@ -1320,32 +1416,7 @@ pub const Fetcher = struct {
         if (maybe_client) |c| {
           for (c.requests[0..c.request_count]) |*req| {
             const result: *MetadataResult = @ptrCast(@alignCast(req.userdata));
-            if (req.has_error or req.status_code != 200) {
-              result.has_error = true;
-            } else {
-              if (req.content_encoding == .gzip) {
-                decompress_buf.clearRetainingCapacity();
-                const decomp = extractor.GzipDecompressor.init(allocator) catch {
-                  result.has_error = true;
-                  continue;
-                };
-                defer decomp.deinit();
-                _ = decomp.decompress(req.response_body.items, struct {
-                  fn onChunk(data: []const u8, ctx: ?*anyopaque) anyerror!void {
-                    const buf: *std.ArrayListUnmanaged(u8) = @ptrCast(@alignCast(ctx));
-                    try buf.appendSlice(c_allocator, data);
-                  }
-                }.onChunk, &decompress_buf) catch {
-                  result.has_error = true;
-                  continue;
-                };
-                result.data = allocator.dupe(u8, decompress_buf.items) catch null;
-                result.compressed = true;
-              } else {
-                result.data = allocator.dupe(u8, req.response_body.items) catch null;
-              }
-              if (result.data == null) result.has_error = true else success += 1;
-            }
+            if (storeMetadataBatchResult(req, result, allocator, &decompress_buf)) success += 1;
           }
           c.resetRequests();
         }
@@ -1367,6 +1438,71 @@ pub const Fetcher = struct {
     userdata: ?*anyopaque
   ) void;
 
+  const MetadataStreamTracker = struct {
+    name: []const u8,
+    index: usize,
+  };
+
+  fn emitMetadataStreamingResult(
+    req: *Http2Client.RequestState,
+    name: []const u8,
+    allocator: std.mem.Allocator,
+    decompress_buf: *std.ArrayListUnmanaged(u8),
+    callback: MetadataCallback,
+    userdata: ?*anyopaque,
+  ) void {
+    if (req.has_error or req.status_code != 200) {
+      callback(name, null, true, userdata);
+      return;
+    }
+
+    if (req.content_encoding != .gzip) {
+      callback(name, req.response_body.items, false, userdata);
+      return;
+    }
+
+    decompress_buf.clearRetainingCapacity();
+    const decomp = extractor.GzipDecompressor.init(allocator) catch {
+      callback(name, null, true, userdata);
+      return;
+    };
+    defer decomp.deinit();
+
+    _ = decomp.decompress(req.response_body.items, struct {
+      fn onChunk(data: []const u8, ctx: ?*anyopaque) anyerror!void {
+        const buf: *std.ArrayListUnmanaged(u8) = @ptrCast(@alignCast(ctx));
+        try buf.appendSlice(c_allocator, data);
+      }
+    }.onChunk, decompress_buf) catch {
+      callback(name, null, true, userdata);
+      return;
+    };
+
+    callback(name, decompress_buf.items, false, userdata);
+  }
+
+  fn emitCompletedStreamingMetadataCallbacks(
+    self: *Fetcher,
+    processed: []bool,
+    allocator: std.mem.Allocator,
+    decompress_buf: *std.ArrayListUnmanaged(u8),
+    callback: MetadataCallback,
+    userdata: ?*anyopaque,
+  ) void {
+    for (self.meta_clients) |maybe_client| {
+      const c = maybe_client orelse continue;
+      for (c.requests[0..c.request_count]) |*req| {
+        if (!req.done and !req.has_error) continue;
+
+        const tracker: *MetadataStreamTracker = @ptrCast(@alignCast(req.userdata));
+        if (processed[tracker.index]) continue;
+
+        processed[tracker.index] = true;
+        emitMetadataStreamingResult(req, tracker.name, allocator, decompress_buf, callback, userdata);
+      }
+    }
+  }
+
   pub fn fetchMetadataStreaming(
     self: *Fetcher,
     names: []const []const u8,
@@ -1388,16 +1524,11 @@ pub const Fetcher = struct {
     if (active_connections == 0) return error.ConnectionFailed;
     debug.log("  meta: streaming {d} packages across {d} connections", .{ names.len, active_connections });
 
-    var processed = try allocator.alloc(bool, names.len);
+    const processed = try allocator.alloc(bool, names.len);
     defer allocator.free(processed);
     @memset(processed, false);
 
-    const ResultTracker = struct {
-      name: []const u8,
-      index: usize,
-    };
-    
-    var trackers = try allocator.alloc(ResultTracker, names.len);
+    var trackers = try allocator.alloc(MetadataStreamTracker, names.len);
     defer allocator.free(trackers);
     for (names, 0..) |name, i| {
       trackers[i] = .{ .name = name, .index = i };
@@ -1422,19 +1553,7 @@ pub const Fetcher = struct {
         const tracker = &trackers[i];
         const name = names[i];
 
-        var client: ?*Http2Client = null;
-        var attempts: usize = 0;
-        while (attempts < NUM_META_CONNECTIONS) : (attempts += 1) {
-          if (self.meta_clients[conn_idx]) |c| {
-            if (c.h2_session != null and c.connected == 1 and c.request_count < MAX_PENDING_REQUESTS - 1) {
-              client = c; break;
-            }
-          }
-          conn_idx = (conn_idx + 1) % NUM_META_CONNECTIONS;
-        }
-        if (client == null) continue;
-
-        const c = client.?;
+        const c = self.nextMetaClient(&conn_idx) orelse continue;
         const session = c.h2_session orelse continue;
         
         var path_buf: [512]u8 = undefined;
@@ -1480,11 +1599,9 @@ pub const Fetcher = struct {
         queued += 1;
         conn_idx = (conn_idx + 1) % NUM_META_CONNECTIONS;
       }
+      
       batch_start = debug.timer("  meta: queue requests", batch_start);
-
-      for (self.meta_clients) |maybe_client| {
-        if (maybe_client) |c| c.flush() catch {};
-      }
+      self.flushMetaClients();
 
       const loop = uv.uv_default_loop();
       var all_done = false;
@@ -1494,54 +1611,9 @@ pub const Fetcher = struct {
       while (!all_done) {
         _ = uv.uv_run(loop, uv.RUN_ONCE);
         loops += 1;
+        self.emitCompletedStreamingMetadataCallbacks(processed, allocator, &decompress_buf, callback, userdata);
 
-        for (self.meta_clients) |maybe_client| {
-          if (maybe_client) |c| {
-            for (c.requests[0..c.request_count]) |*req| {
-              if (req.done or req.has_error) {
-                const tracker: *ResultTracker = @ptrCast(@alignCast(req.userdata));
-                if (!processed[tracker.index]) {
-                  processed[tracker.index] = true;
-                  if (req.has_error or req.status_code != 200) {
-                    callback(tracker.name, null, true, userdata);
-                  } else if (req.content_encoding == .gzip) {
-                    decompress_buf.clearRetainingCapacity();
-                    const decomp = extractor.GzipDecompressor.init(allocator) catch {
-                      callback(tracker.name, null, true, userdata);
-                      continue;
-                    };
-                    defer decomp.deinit();
-                    _ = decomp.decompress(req.response_body.items, struct {
-                      fn onChunk(data: []const u8, ctx: ?*anyopaque) anyerror!void {
-                        const buf: *std.ArrayListUnmanaged(u8) = @ptrCast(@alignCast(ctx));
-                        try buf.appendSlice(c_allocator, data);
-                      }
-                    }.onChunk, &decompress_buf) catch {
-                      callback(tracker.name, null, true, userdata);
-                      continue;
-                    };
-                    callback(tracker.name, decompress_buf.items, false, userdata);
-                  } else {
-                    callback(tracker.name, req.response_body.items, false, userdata);
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        all_done = true;
-        for (self.meta_clients) |maybe_client| {
-          if (maybe_client) |c| {
-            for (c.requests[0..c.request_count]) |*req| {
-              if (!req.done and !req.has_error) {
-                all_done = false;
-                break;
-              }
-            }
-            if (!all_done) break;
-          }
-        }
+        all_done = self.metaRequestsComplete();
       }
 
       const elapsed_ns: u64 = @intCast(@as(i128, @intCast(std.time.nanoTimestamp())) - @as(i128, run_start));
@@ -1554,7 +1626,7 @@ pub const Fetcher = struct {
       for (self.meta_clients) |maybe_client| {
         if (maybe_client) |c| {
           for (c.requests[0..c.request_count]) |*req| {
-            const tracker: *ResultTracker = @ptrCast(@alignCast(req.userdata));
+            const tracker: *MetadataStreamTracker = @ptrCast(@alignCast(req.userdata));
             const end_ns = if (req.end_ns != 0) req.end_ns else @as(u64, @intCast(std.time.nanoTimestamp()));
             const duration_ms: u64 = @intCast((end_ns - req.start_ns) / 1_000_000);
             total_bytes += req.response_body.items.len;
diff --git a/src/pkg/linker.zig b/src/pkg/linker.zig
index 2878c4a..d2550a4 100644
--- a/src/pkg/linker.zig
+++ b/src/pkg/linker.zig
@@ -190,6 +190,7 @@ pub const Linker = struct {
 
     var should_skip = false;
     var has_existing_install = false;
+    var has_existing_package = false;
     
     {
       const existing = node_modules.openDir(install_path, .{}) catch null;
@@ -200,6 +201,7 @@ pub const Linker = struct {
 
         const installed_version = readPackageVersion(self.allocator, installed_dir);
         defer if (installed_version) |v| self.allocator.free(v);
+        has_existing_package = installed_version != null;
         should_skip = packageVersionsMatch(source_version, installed_version);
       }
     }
@@ -209,7 +211,7 @@ pub const Linker = struct {
       return;
     }
 
-    if (has_existing_install) {
+    if (has_existing_install and has_existing_package) {
       node_modules.deleteTree(install_path) catch return error.IoError;
     }
 
diff --git a/src/pkg/resolver.zig b/src/pkg/resolver.zig
index 702d78b..6ae8256 100644
--- a/src/pkg/resolver.zig
+++ b/src/pkg/resolver.zig
@@ -410,16 +410,22 @@ pub const PackageMetadata = struct {
   allocator: std.mem.Allocator,
   name: []const u8,
   versions: std.ArrayListUnmanaged(VersionInfo),
+  dist_tag_latest: ?Version = null,
 
   pub fn init(allocator: std.mem.Allocator, name: []const u8) !PackageMetadata {
     return .{
       .allocator = allocator,
       .name = try allocator.dupe(u8, name),
       .versions = .{},
+      .dist_tag_latest = null,
     };
   }
 
   pub fn deinit(self: *PackageMetadata) void {
+    if (self.dist_tag_latest) |*dtl| {
+      if (dtl.prerelease) |pre| self.allocator.free(pre);
+      if (dtl.build) |bld| self.allocator.free(bld);
+    }
     for (self.versions.items) |*v| {
       v.deinit();
     }
@@ -443,6 +449,17 @@ pub const PackageMetadata = struct {
     var metadata = try PackageMetadata.init(allocator, name);
     errdefer metadata.deinit();
 
+    metadata.dist_tag_latest = blk: {
+      const dt = root.object.get("dist-tags") orelse break :blk null;
+      if (dt != .object) break :blk null;
+      const latest_val = dt.object.get("latest") orelse break :blk null;
+      if (latest_val != .string) break :blk null;
+      var pl = Version.parse(latest_val.string) catch break :blk null;
+      if (pl.prerelease) |pre| pl.prerelease = allocator.dupe(u8, pre) catch null;
+      if (pl.build) |bld| pl.build = allocator.dupe(u8, bld) catch null;
+      break :blk pl;
+    };
+
     const versions_obj = root.object.get("versions") orelse return metadata;
     if (versions_obj != .object) return metadata;
 
@@ -1648,6 +1665,11 @@ pub const Resolver = struct {
   }
 
   fn selectBestVersion(_: *Resolver, metadata: *const PackageMetadata, constraint: Constraint) ?*const VersionInfo {
+    if (constraint.kind == .any) for (metadata.versions.items) |*v| {
+      const dtl = metadata.dist_tag_latest orelse break;
+      if (v.version.order(dtl) == .eq) return v;
+    };
+
     var best: ?*const VersionInfo = null;
     const want_prerelease = constraint.version.prerelease != null;
 
@@ -1678,6 +1700,11 @@ pub const Resolver = struct {
       if (c.kind != .any) all_any = false;
     }
 
+    if (all_any) for (metadata.versions.items) |*v| {
+      const dtl = metadata.dist_tag_latest orelse break;
+      if (v.version.order(dtl) == .eq) return v;
+    };
+
     for (metadata.versions.items) |*v| {
       if (v.version.prerelease != null and !want_prerelease) continue;
 
diff --git a/src/pkg/root.zig b/src/pkg/root.zig
index b3fae91..9881222 100644
--- a/src/pkg/root.zig
+++ b/src/pkg/root.zig
@@ -352,6 +352,8 @@ pub const PkgContext = struct {
     }
     debug.log("  cache hits: {d}, misses: {d}", .{ cache_hits.items.len, misses.items.len });
 
+    std.sort.heap(cache.CacheDB.BatchHit, cache_hits.items, &lf, batchHitLessThanParentFirst);
+
     var pkg_linker = linker.Linker.init(self.allocator);
     defer pkg_linker.deinit();
     try pkg_linker.setNodeModulesPath(node_modules_path);
@@ -375,11 +377,7 @@ pub const PkgContext = struct {
       });
 
       if (pkg.flags.direct) {
-        const version_str = std.fmt.allocPrint(arena_alloc, "{d}.{d}.{d}", .{
-          pkg.version_major,
-          pkg.version_minor,
-          pkg.version_patch,
-        }) catch continue;
+        const version_str = pkg.versionString(arena_alloc, lf.string_table) catch continue;
         self.addPackageToResults(pkg_name, version_str, true) catch {};
       }
     }
@@ -473,6 +471,20 @@ pub const PkgContext = struct {
 
       var success_count: usize = 0;
       var error_count: usize = 0;
+      std.sort.heap(PkgExtractCtx, extract_contexts[0..valid_count], {}, struct {
+        fn lessThan(_: void, a: PkgExtractCtx, b: PkgExtractCtx) bool {
+          const depth_a = linkPathDepth(a.parent_path);
+          const depth_b = linkPathDepth(b.parent_path);
+          if (depth_a != depth_b) return depth_a < depth_b;
+
+          const parent_a = a.parent_path orelse "";
+          const parent_b = b.parent_path orelse "";
+          const parent_order = std.mem.order(u8, parent_a, parent_b);
+          if (parent_order != .eq) return parent_order == .lt;
+          return std.mem.order(u8, a.pkg_name, b.pkg_name) == .lt;
+        }
+      }.lessThan);
+
       for (extract_contexts[0..valid_count], 0..) |*ctx, i| {
         defer ctx.ext.deinit();
 
@@ -531,6 +543,66 @@ pub const PkgContext = struct {
   }
 };
 
+fn trySetHttpResolveError(c: *PkgContext, err: anyerror) bool {
+  if (err != error.ResponseError) return false;
+
+  const http = c.http orelse return false;
+  const info = http.getLastHttpError() orelse return false;
+
+  c.setErrorFmt("error: GET {s} - {d}", .{ info.url, info.status });
+  return true;
+}
+
+fn setResolveError(c: *PkgContext, target: ?[]const u8, err: anyerror) void {
+  if (trySetHttpResolveError(c, err)) return;
+
+  if (target) |name| c.setErrorFmt("Failed to resolve {s}: {}", .{ name, err })
+  else c.setErrorFmt("Failed to resolve dependencies: {}", .{ err });
+}
+
+fn linkPathDepth(parent_path: ?[]const u8) u32 {
+  const parent = parent_path orelse return 0;
+  if (parent.len == 0) return 0;
+
+  var depth: u32 = 1;
+  var it: usize = 0;
+  while (std.mem.indexOfPos(u8, parent, it, "/node_modules/")) |idx| {
+    depth += 1;
+    it = idx + "/node_modules/".len;
+  }
+  return depth;
+}
+
+fn packageLinkLessThanParentFirst(_: void, a: linker.PackageLink, b: linker.PackageLink) bool {
+  const a_depth = linkPathDepth(a.parent_path);
+  const b_depth = linkPathDepth(b.parent_path);
+  if (a_depth != b_depth) return a_depth < b_depth;
+
+  const a_parent = a.parent_path orelse "";
+  const b_parent = b.parent_path orelse "";
+  const parent_order = std.mem.order(u8, a_parent, b_parent);
+  if (parent_order != .eq) return parent_order == .lt;
+
+  return std.mem.order(u8, a.name, b.name) == .lt;
+}
+
+fn batchHitLessThanParentFirst(lf: *const lockfile.Lockfile, a: cache.CacheDB.BatchHit, b: cache.CacheDB.BatchHit) bool {
+  const pkg_a = &lf.packages[a.index];
+  const pkg_b = &lf.packages[b.index];
+
+  const parent_a = pkg_a.parent_path.slice(lf.string_table);
+  const parent_b = pkg_b.parent_path.slice(lf.string_table);
+  const depth_a = linkPathDepth(if (parent_a.len > 0) parent_a else null);
+  const depth_b = linkPathDepth(if (parent_b.len > 0) parent_b else null);
+  if (depth_a != depth_b) return depth_a < depth_b;
+
+  const name_a = pkg_a.name.slice(lf.string_table);
+  const name_b = pkg_b.name.slice(lf.string_table);
+  const parent_order = std.mem.order(u8, parent_a, parent_b);
+  if (parent_order != .eq) return parent_order == .lt;
+  return std.mem.order(u8, name_a, name_b) == .lt;
+}
+
 export fn pkg_init(options: *const PkgOptions) ?*PkgContext {
   return PkgContext.init(global_allocator, options.*) catch null;
 }
@@ -590,6 +662,44 @@ export fn pkg_get_added_package(ctx: ?*const PkgContext, index: u32, out: *Added
   return .ok;
 }
 
+export fn pkg_get_latest_available_version(
+  ctx: ?*PkgContext,
+  package_name: [*:0]const u8,
+  installed_version: [*:0]const u8,
+  out_version: [*]u8,
+  out_version_len: usize,
+) c_int {
+  const c = ctx orelse return 0;
+  if (out_version_len == 0) return 0;
+  out_version[0] = 0;
+
+  const name = std.mem.span(package_name);
+  const installed_str = std.mem.span(installed_version);
+  const installed = resolver.Version.parse(installed_str) catch return 0;
+  const meta = c.metadata_cache.get(name) orelse return 0;
+
+  var best: ?*const resolver.VersionInfo = null;
+  for (meta.versions.items) |*v| {
+    if (v.version.prerelease != null) continue;
+    if (!v.matchesPlatform()) continue;
+    if (best == null or v.version.order(best.?.version) == .gt) best = v;
+  }
+  if (best == null) {
+    for (meta.versions.items) |*v| {
+      if (!v.matchesPlatform()) continue;
+      if (best == null or v.version.order(best.?.version) == .gt) best = v;
+    }
+  }
+
+  const latest = best orelse return 0;
+  if (latest.version.order(installed) != .gt) return 0;
+
+  if (latest.version_str.len + 1 > out_version_len) return 0;
+  @memcpy(out_version[0..latest.version_str.len], latest.version_str);
+  out_version[latest.version_str.len] = 0;
+  return 1;
+}
+
 export fn pkg_count_installed(node_modules_path: [*:0]const u8) u32 {
   const nm_path = std.mem.span(node_modules_path);
   if (!std.mem.endsWith(u8, nm_path, "node_modules")) return 0;
@@ -874,9 +984,7 @@ const InterleavedContext = struct {
     } self.tarballs_queued += 1;
 
     const cache_path = self.db.getPackagePath(&pkg.integrity, self.arena_alloc) catch return;
-    const version_str = std.fmt.allocPrint(self.arena_alloc, "{d}.{d}.{d}", .{
-      pkg.version.major, pkg.version.minor, pkg.version.patch,
-    }) catch return;
+    const version_str = pkg.version.format(self.arena_alloc) catch return;
 
     const ext = extractor.Extractor.init(self.allocator, cache_path) catch return;
     const ctx = self.arena_alloc.create(InterleavedExtractCtx) catch {
@@ -990,7 +1098,7 @@ export fn pkg_resolve_and_install(
 
   res.setOnPackageResolved(InterleavedContext.onPackageResolved, &interleaved);
   res.resolveFromPackageJson(std.mem.span(package_json_path)) catch |err| {
-    c.setErrorFmt("Failed to resolve dependencies: {}", .{err});
+    setResolveError(c, null, err);
     return .resolve_error;
   };
   
@@ -1007,11 +1115,7 @@ export fn pkg_resolve_and_install(
   while (direct_iter.next()) |pkg_ptr| {
     const pkg = pkg_ptr.*;
     if (pkg.direct) {
-      const version_str = std.fmt.allocPrint(arena_alloc, "{d}.{d}.{d}", .{
-        pkg.version.major,
-        pkg.version.minor,
-        pkg.version.patch,
-      }) catch continue;
+      const version_str = pkg.version.format(arena_alloc) catch continue;
       c.addPackageToResults(pkg.name.slice(), version_str, true) catch {};
     }
   }
@@ -1061,6 +1165,8 @@ export fn pkg_resolve_and_install(
     };
   }
 
+  std.sort.heap(linker.PackageLink, cache_hit_jobs.items, {}, packageLinkLessThanParentFirst);
+
   var linked_count: usize = 0;
   for (cache_hit_jobs.items, 0..) |job, i| {
     const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{job.name}, 0) catch continue;
@@ -1138,45 +1244,47 @@ export fn pkg_resolve_and_install(
 
   const total_jobs: u32 = @intCast(link_jobs.items.len);
   var link_counter = std.atomic.Value(u32).init(0);
-  const LARGE_LINK_BYTES: u64 = 2 * 1024 * 1024;
-
   std.sort.heap(LinkJobWithSize, link_jobs.items, {}, struct {
     fn lessThan(_: void, a: LinkJobWithSize, b: LinkJobWithSize) bool {
-      return a.size > b.size;
+      const depth_a = linkPathDepth(a.job.parent_path);
+      const depth_b = linkPathDepth(b.job.parent_path);
+      if (depth_a != depth_b) return depth_a < depth_b;
+      if (a.size != b.size) return a.size > b.size;
+
+      const parent_a = a.job.parent_path orelse "";
+      const parent_b = b.job.parent_path orelse "";
+      const parent_order = std.mem.order(u8, parent_a, parent_b);
+      if (parent_order != .eq) return parent_order == .lt;
+      return std.mem.order(u8, a.job.name, b.job.name) == .lt;
     }
   }.lessThan);
 
-  var split_idx: usize = link_jobs.items.len;
-  for (link_jobs.items, 0..) |job, i| {
-    if (job.size < LARGE_LINK_BYTES) {
-      split_idx = i;
-      break;
-    }
-  }
-
-  const large_jobs = link_jobs.items[0..split_idx];
-  const small_jobs = link_jobs.items[split_idx..];
-  const phases = [_][]const LinkJobWithSize{ large_jobs, small_jobs };
-
   var slow_link_count = std.atomic.Value(u32).init(0);
   var max_link_ms = std.atomic.Value(u64).init(0);
   var slow_link_names = std.ArrayListUnmanaged([]const u8){};
   defer slow_link_names.deinit(c.allocator);
   var slow_link_lock = std.Thread.Mutex{};
 
-  for (phases) |phase_jobs| {
-    if (phase_jobs.len == 0) continue;
-    const num_threads = @min(8, phase_jobs.len);
-    if (c.options.verbose and phase_jobs.len == large_jobs.len) {
-      debug.log("  linking large packages first ({d} items)", .{phase_jobs.len});
+  var depth_start: usize = 0;
+  while (depth_start < link_jobs.items.len) {
+    const depth = linkPathDepth(link_jobs.items[depth_start].job.parent_path);
+    var depth_end = depth_start + 1;
+    while (depth_end < link_jobs.items.len and
+      linkPathDepth(link_jobs.items[depth_end].job.parent_path) == depth) : (depth_end += 1) {}
+
+    const depth_jobs = link_jobs.items[depth_start..depth_end];
+    const num_threads = @min(8, depth_jobs.len);
+    if (c.options.verbose and depth_jobs.len > 1) {
+      debug.log("  linking depth {d} ({d} items)", .{ depth, depth_jobs.len });
     }
-    if (num_threads > 1 and phase_jobs.len > 4) {
+
+    if (num_threads > 1 and depth_jobs.len > 4) {
       var threads: [8]?std.Thread = .{null} ** 8;
-      const jobs_per_thread = (phase_jobs.len + num_threads - 1) / num_threads;
+      const jobs_per_thread = (depth_jobs.len + num_threads - 1) / num_threads;
 
       for (0..num_threads) |t| {
         const start_idx = t * jobs_per_thread;
-        const end_idx = @min(start_idx + jobs_per_thread, phase_jobs.len);
+        const end_idx = @min(start_idx + jobs_per_thread, depth_jobs.len);
         if (start_idx >= end_idx) break;
 
         threads[t] = std.Thread.spawn(.{}, struct {
@@ -1207,14 +1315,14 @@ export fn pkg_resolve_and_install(
               }
             }
           }
-        }.work, .{ &pkg_linker, phase_jobs[start_idx..end_idx], c, total_jobs, &link_counter, &slow_link_count, &max_link_ms, &slow_link_names, &slow_link_lock, c.allocator }) catch null;
+        }.work, .{ &pkg_linker, depth_jobs[start_idx..end_idx], c, total_jobs, &link_counter, &slow_link_count, &max_link_ms, &slow_link_names, &slow_link_lock, c.allocator }) catch null;
       }
 
       for (&threads) |*t| {
         if (t.*) |thread| thread.join();
       }
     } else {
-      for (phase_jobs) |job_with_size| {
+      for (depth_jobs) |job_with_size| {
         const job = job_with_size.job;
         const current = link_counter.fetchAdd(1, .monotonic) + 1;
         const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{job.name}, 0) catch continue;
@@ -1227,6 +1335,8 @@ export fn pkg_resolve_and_install(
         }
       }
     }
+
+    depth_start = depth_end;
   }
 
   if (c.options.verbose) {
@@ -1482,7 +1592,7 @@ export fn pkg_add(
   ); defer res.deinit();
 
   const resolved_pkg = res.resolve(pkg_name, version_constraint, 0) catch |err| {
-    c.setErrorFmt("Failed to resolve {s}: {}", .{ pkg_name, err });
+    setResolveError(c, pkg_name, err);
     return .resolve_error;
   };
 
@@ -1618,7 +1728,7 @@ export fn pkg_add_many(
     }
 
     const resolved_pkg = res.resolve(pkg_name, version_constraint, 0) catch |err| {
-      c.setErrorFmt("Failed to resolve {s}: {}", .{ pkg_name, err });
+      setResolveError(c, pkg_name, err);
       return .resolve_error;
     };
 
@@ -2600,7 +2710,7 @@ export fn pkg_exec_temp(
 
   res.setOnPackageResolved(InterleavedContext.onPackageResolved, &interleaved);
   res.resolveFromPackageJson(temp_pkg_json) catch |err| {
-    c.setErrorFmt("Failed to resolve {s}: {}", .{ pkg_name, err });
+    setResolveError(c, pkg_name, err);
     return .resolve_error;
   };
 
diff --git a/src/reactor.c b/src/reactor.c
index 0725d77..ca8fc98 100644
--- a/src/reactor.c
+++ b/src/reactor.c
@@ -13,36 +13,6 @@
 static reactor_poll_hook_t g_poll_hook = NULL;
 static void *g_poll_hook_data = NULL;
 
-void js_reactor_set_poll_hook(reactor_poll_hook_t hook, void *data) {
-  g_poll_hook = hook;
-  g_poll_hook_data = data;
-}
-
-void js_poll_events(ant_t *js) {
-  coros_this_tick = 0;
-  
-  process_immediates(js);
-  process_microtasks(js);
-  
-  for (coroutine_t *temp = pending_coroutines.head, *next; temp; temp = next) {
-    next = temp->next;
-    if (!temp->is_ready || !temp->mco || mco_status(temp->mco) != MCO_SUSPENDED) continue;
-    remove_coroutine(temp);
-    
-    coro_saved_state_t saved = coro_enter(temp->js, temp);
-    mco_result res = mco_resume(temp->mco);
-    coro_leave(temp->js, temp, saved);
-    
-    if (res == MCO_SUCCESS && mco_status(temp->mco) != MCO_DEAD) {
-      temp->is_ready = false;
-      enqueue_coroutine(temp);
-    } else free_coroutine(temp);
-  }
-  
-  if (js->needs_gc) js_gc_safepoint(js);  
-  if (g_poll_hook) g_poll_hook(g_poll_hook_data);
-}
-
 static inline work_flags_t get_pending_work(void) {
   work_flags_t flags = 0;
   if (has_pending_microtasks())         flags |= WORK_MICROTASKS;
@@ -58,29 +28,62 @@ static inline work_flags_t get_pending_work(void) {
   return flags;
 }
 
-static void process_before_exit(ant_t *js) {
-  jsval_t code = js_mknum(0);
-  emit_process_event("beforeExit", &code, 1);
-  if ((get_pending_work() & WORK_PENDING) || UV_CHECK_ALIVE) js_run_event_loop(js);
+static inline bool event_loop_alive(void) {
+  work_flags_t w = get_pending_work();
+  if (w & (WORK_PENDING & ~WORK_COROUTINES)) return true;
+  if ((w & WORK_COROUTINES) && (w & WORK_COROUTINES_READY)) return true;
+  return UV_CHECK_ALIVE;
 }
 
-void js_run_event_loop(ant_t *js) {
-  work_flags_t work;
-  int uv_alive = UV_CHECK_ALIVE;
+void js_reactor_set_poll_hook(reactor_poll_hook_t hook, void *data) {
+  g_poll_hook = hook;
+  g_poll_hook_data = data;
+}
+
+void js_poll_events(ant_t *js) {
+  coros_this_tick = 0;
   
-  while (((work = get_pending_work()) & WORK_PENDING) || uv_alive) {
-    js_poll_events(js);
+  process_immediates(js);
+  process_microtasks(js);
+  
+  for (;;) {
+    coroutine_t *temp = NULL;
+    for (coroutine_t *c = pending_coroutines.head; c; c = c->next) {
+      if (c->is_ready && c->mco && mco_status(c->mco) == MCO_SUSPENDED) { temp = c; break; }
+    }
     
-    work = get_pending_work();
-    uv_alive = UV_CHECK_ALIVE;
+    if (!temp) break;
+    temp->is_ready = false;
+
+    mco_result res;
+    MCO_RESUME_SAVE(js, temp->mco, res);
+
+    if (res != MCO_SUCCESS || mco_status(temp->mco) == MCO_DEAD) {
+      remove_coroutine(temp);
+      free_coroutine(temp);
+    }
+  }
   
+  if (js->needs_gc) js_gc_maybe(js);  
+  if (g_poll_hook) g_poll_hook(g_poll_hook_data);
+}
+
+void js_run_event_loop(ant_t *js) {
+drain:
+  while (event_loop_alive()) {
+    js_poll_events(js);
+    work_flags_t work = get_pending_work();
+    
     if (work & WORK_BLOCKING) uv_run(uv_default_loop(), UV_RUN_NOWAIT);
-    else if ((work & WORK_ASYNC) || uv_alive) {
-      js_gc_safepoint(js);
+    else if ((work & WORK_ASYNC) || UV_CHECK_ALIVE) {
+      js_gc_maybe(js);
       uv_run(uv_default_loop(), UV_RUN_ONCE);
-    } else if (work & WORK_COROUTINES) break;
-  }
+    } else break;
+  } 
   
   js_poll_events(js);
-  process_before_exit(js);
+  jsval_t code = js_mknum(0);
+  emit_process_event("beforeExit", &code, 1);
+  
+  if (event_loop_alive()) goto drain;
 }
diff --git a/src/repl.c b/src/repl.c
index c61d44d..bbadcc6 100644
--- a/src/repl.c
+++ b/src/repl.c
@@ -23,6 +23,8 @@
 #include "reactor.h"
 #include "runtime.h"
 #include "internal.h"
+#include "silver/ast.h"
+#include "silver/engine.h"
 #include "modules/io.h"
 
 #define MAX_HISTORY 512
@@ -49,32 +51,298 @@ typedef struct {
   const char *name;
   const char *description;
   bool has_arg;
-  cmd_result_t (*handler)(struct js *js, history_t *history, const char *arg);
+  cmd_result_t (*handler)(ant_t *js, history_t *history, const char *arg);
 } repl_command_t;
 
-static void sigint_handler(int sig) {
-  (void)sig;
-  ctrl_c_pressed++;
+typedef struct {
+  char *name;
+  size_t len;
+} repl_decl_name_t;
+
+typedef struct {
+  repl_decl_name_t *items;
+  size_t count;
+  size_t cap;
+} repl_decl_registry_t;
+
+typedef struct {
+  const char **names;
+  uint32_t *lens;
+  size_t count;
+  size_t cap;
+} repl_decl_pending_t;
+
+static repl_decl_registry_t *g_repl_decl_registry = NULL;
+static void sigint_handler(int sig) { ctrl_c_pressed++; }
+
+static inline void repl_clear_exception_state(ant_t *js) {
+  js->thrown_exists = false;
+  js->thrown_value = js_mkundef();
+}
+
+static void repl_decl_registry_free(repl_decl_registry_t *reg) {
+  if (!reg) return;
+  for (size_t i = 0; i < reg->count; i++) 
+    free(reg->items[i].name);
+  free(reg->items);
+  reg->items = NULL;
+  reg->count = 0;
+  reg->cap = 0;
+}
+
+static bool repl_decl_registry_contains(
+  const repl_decl_registry_t *reg,
+  const char *name, uint32_t len
+) {
+  if (!reg || !name) return false;
+  for (size_t i = 0; i < reg->count; i++) {
+    if (
+      reg->items[i].len == (size_t)len 
+      && memcmp(reg->items[i].name, name, (size_t)len) == 0
+    ) return true;
+  }
+  return false;
 }
 
-static cmd_result_t cmd_help(struct js *js, history_t *history, const char *arg);
-static cmd_result_t cmd_exit(struct js *js, history_t *history, const char *arg);
-static cmd_result_t cmd_load(struct js *js, history_t *history, const char *arg);
-static cmd_result_t cmd_save(struct js *js, history_t *history, const char *arg);
-static cmd_result_t cmd_gc(struct js *js, history_t *history, const char *arg);
-static cmd_result_t cmd_stats(struct js *js, history_t *history, const char *arg);
+static bool repl_decl_registry_add(
+  ant_t *js, repl_decl_registry_t *reg,
+  const char *name, uint32_t len
+) {
+  if (!reg || !name) return true;
+  if (repl_decl_registry_contains(reg, name, len)) return true;
+  
+  if (reg->count >= reg->cap) {
+    size_t new_cap = reg->cap ? reg->cap * 2 : 32;
+    repl_decl_name_t *ni = realloc(reg->items, new_cap * sizeof(*ni));
+    if (!ni) {
+      js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "out of memory");
+      return false;
+    }
+    reg->items = ni;
+    reg->cap = new_cap;
+  }
+  
+  char *copy = malloc((size_t)len + 1);
+  if (!copy) {
+    js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "out of memory");
+    return false;
+  }
+  
+  memcpy(copy, name, (size_t)len);
+  copy[len] = '\0';
+  reg->items[reg->count++] = (repl_decl_name_t){ .name = copy, .len = (size_t)len };
+  
+  return true;
+}
+
+static void repl_decl_pending_free(repl_decl_pending_t *p) {
+  if (!p) return;
+  free(p->names);
+  free(p->lens);
+  p->names = NULL;
+  p->lens = NULL;
+  p->count = 0;
+  p->cap = 0;
+}
+
+static bool repl_decl_pending_contains(
+  const repl_decl_pending_t *p,
+  const char *name, uint32_t len
+) {
+  if (!p || !name) return false;
+  for (size_t i = 0; i < p->count; i++) 
+    if (p->lens[i] == len && memcmp(p->names[i], name, (size_t)len) == 0) return true;
+  return false;
+}
+
+static bool repl_decl_pending_push(
+  ant_t *js, repl_decl_pending_t *p,
+  const char *name, uint32_t len
+) {
+  if (!p || !name || len == 0) return true;
+  if (repl_decl_pending_contains(p, name, len)) return true;
+  if (p->count >= p->cap) {
+    size_t new_cap = p->cap ? p->cap * 2 : 16;
+    const char **nn = realloc(p->names, new_cap * sizeof(*nn));
+    if (!nn) {
+      js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "out of memory");
+      return false;
+    }
+    uint32_t *nl = realloc(p->lens, new_cap * sizeof(*nl));
+    if (!nl) {
+      p->names = nn;
+      js_mkerr_typed(js, JS_ERR_INTERNAL | JS_ERR_NO_STACK, "out of memory");
+      return false;
+    }
+    p->names = nn;
+    p->lens = nl;
+    p->cap = new_cap;
+  }
+  p->names[p->count] = name;
+  p->lens[p->count] = len;
+  p->count++;
+  return true;
+}
+
+static bool repl_collect_pattern_names(ant_t *js, sv_ast_t *pat, repl_decl_pending_t *p) {
+  if (!pat) return true;
+  switch (pat->type) {
+    case N_IDENT:
+      return repl_decl_pending_push(js, p, pat->str, pat->len);
+    case N_ASSIGN_PAT:
+    case N_ASSIGN:
+      return repl_collect_pattern_names(js, pat->left, p);
+    case N_REST:
+    case N_SPREAD:
+      return repl_collect_pattern_names(js, pat->right, p);
+    case N_ARRAY:
+    case N_ARRAY_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        if (!repl_collect_pattern_names(js, pat->args.items[i], p)) return false;
+      }
+      return true;
+    case N_OBJECT:
+    case N_OBJECT_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        sv_ast_t *prop = pat->args.items[i];
+        if (!prop) continue;
+        if (prop->type == N_PROPERTY) {
+          if (!repl_collect_pattern_names(js, prop->right, p)) return false;
+        } else if (prop->type == N_REST || prop->type == N_SPREAD) {
+          if (!repl_collect_pattern_names(js, prop->right, p)) return false;
+        }
+      }
+      return true;
+    default: return true;
+  }
+}
+
+static bool repl_collect_top_level_decls(ant_t *js, sv_ast_t *stmt, repl_decl_pending_t *p) {
+  if (!stmt) return true;
+  sv_ast_t *node = (stmt->type == N_EXPORT) ? stmt->left : stmt;
+  if (!node) return true;
+
+  if (node->type == N_VAR && node->var_kind != VAR_VAR) {
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *decl = node->args.items[i];
+      if (!decl || decl->type != N_VARDECL || !decl->left) continue;
+      if (!repl_collect_pattern_names(js, decl->left, p)) return false;
+    }
+    return true;
+  }
+
+  if (node->type == N_CLASS && node->str && node->len > 0)
+    return repl_decl_pending_push(js, p, node->str, node->len);
+
+  if (node->type == N_IMPORT_DECL) {
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *spec = node->args.items[i];
+      if (!spec || spec->type != N_IMPORT_SPEC || !spec->right) continue;
+      if (spec->right->type != N_IDENT) continue;
+      if (!repl_decl_pending_push(js, p, spec->right->str, spec->right->len)) return false;
+    }
+  }
+
+  return true;
+}
+
+static bool repl_precheck_and_commit_lexicals(
+  ant_t *js, repl_decl_registry_t *reg,
+  const char *code, size_t len
+) {
+  if (!js || !reg || !code || len == 0) return true;
+
+  code_arena_mark_t mark = code_arena_mark();
+  repl_decl_pending_t pending = {0};
+  bool ok = true;
+
+  repl_clear_exception_state(js);
+  sv_ast_t *program = sv_parse(js, code, (jsoff_t)len, false);
+  
+  if (!program || js->thrown_exists) {
+    ok = true;
+    goto done;
+  }
+
+  for (int i = 0; i < program->args.count; i++) {
+    if (
+      !repl_collect_top_level_decls(
+      js, program->args.items[i], &pending)
+    ) { ok = false; goto done; }
+  }
+
+  for (size_t i = 0; i < pending.count; i++) {
+    if (repl_decl_registry_contains(reg, pending.names[i], pending.lens[i])) {
+      js_mkerr_typed(
+        js, JS_ERR_SYNTAX, "Identifier '%.*s' has already been declared",
+        (int)pending.lens[i], pending.names[i]
+      );
+      ok = false; goto done;
+    }
+  }
+
+  for (size_t i = 0; i < pending.count; i++) {
+    if (
+      !repl_decl_registry_add(
+      js, reg, pending.names[i], pending.lens[i])
+    ) { ok = false; goto done; }
+  }
+
+done:
+  code_arena_rewind(mark);
+  repl_decl_pending_free(&pending);
+
+  if (ok && js->thrown_exists)
+    repl_clear_exception_state(js);
+
+  return ok;
+}
+
+typedef enum {
+  REPL_PRINT_INTERACTIVE,
+  REPL_PRINT_LOAD,
+} repl_print_mode_t;
+
+static void repl_eval_chunk(
+  ant_t *js, repl_decl_registry_t *decl_registry,
+  const char *code, size_t len,
+  repl_print_mode_t print_mode
+) {
+  if (!repl_precheck_and_commit_lexicals(js, decl_registry, code, len)) {
+    print_uncaught_throw(js);
+    return;
+  }
+
+  repl_clear_exception_state(js);
+  jsval_t result = js_eval_bytecode_repl(js, code, len);
+  js_run_event_loop(js);
+
+  if (print_uncaught_throw(js)) return;
+  if (print_mode == REPL_PRINT_INTERACTIVE) {
+    print_repl_value(js, result, stdout);
+    return;
+  }
+
+  if (vtype(result) == T_ERR) fprintf(stderr, "%s\n", js_str(js, result));
+  else if (vtype(result) != T_UNDEF) printf("%s\n", js_str(js, result));
+}
+
+static cmd_result_t cmd_help(ant_t *js, history_t *history, const char *arg);
+static cmd_result_t cmd_exit(ant_t *js, history_t *history, const char *arg);
+static cmd_result_t cmd_load(ant_t *js, history_t *history, const char *arg);
+static cmd_result_t cmd_save(ant_t *js, history_t *history, const char *arg);
+static cmd_result_t cmd_stats(ant_t *js, history_t *history, const char *arg);
 
 static const repl_command_t commands[] = {
   { "help",  "Show this help message", false, cmd_help },
   { "exit",  "Exit the REPL", false, cmd_exit },
   { "load",  "Load JS from a file into the REPL session", true, cmd_load },
   { "save",  "Save all evaluated commands in this REPL session to a file", true, cmd_save },
-  { "gc",    "Run garbage collector", false, cmd_gc },
   { "stats", "Show memory statistics", false, cmd_stats },
   { NULL, NULL, false, NULL }
 };
 
-static cmd_result_t cmd_help(struct js *js, history_t *history, const char *arg) {
+static cmd_result_t cmd_help(ant_t *js, history_t *history, const char *arg) {
   for (const repl_command_t *cmd = commands; cmd->name; cmd++) {
     printf("  .%-7s - %s\n", cmd->name, cmd->description);
   }
@@ -82,11 +350,11 @@ static cmd_result_t cmd_help(struct js *js, history_t *history, const char *arg)
   return CMD_OK;
 }
 
-static cmd_result_t cmd_exit(struct js *js, history_t *history, const char *arg) {
+static cmd_result_t cmd_exit(ant_t *js, history_t *history, const char *arg) {
   return CMD_EXIT;
 }
 
-static cmd_result_t cmd_load(struct js *js, history_t *history, const char *arg) {
+static cmd_result_t cmd_load(ant_t *js, history_t *history, const char *arg) {
   (void)history;
   if (!arg || *arg == '\0') {
     fprintf(stderr, "Usage: .load <filename>\n");
@@ -107,22 +375,17 @@ static cmd_result_t cmd_load(struct js *js, history_t *history, const char *arg)
   if (file_buffer) {
     size_t len = fread(file_buffer, 1, file_size, fp);
     file_buffer[len] = '\0';
-    
-    jsval_t result = js_eval(js, file_buffer, len);
-    js_run_event_loop(js);
-    if (vtype(result) == T_ERR) {
-      fprintf(stderr, "%s\n", js_str(js, result));
-    } else if (vtype(result) != T_UNDEF) {
-      printf("%s\n", js_str(js, result));
-    }
-    
+    repl_eval_chunk(
+      js, g_repl_decl_registry, 
+      file_buffer, len, REPL_PRINT_LOAD
+    );
     free(file_buffer);
   }
   fclose(fp);
   return CMD_OK;
 }
 
-static cmd_result_t cmd_save(struct js *js, history_t *history, const char *arg) {
+static cmd_result_t cmd_save(ant_t *js, history_t *history, const char *arg) {
   (void)js;
   if (!arg || *arg == '\0') {
     fprintf(stderr, "Usage: .save <filename>\n");
@@ -143,21 +406,14 @@ static cmd_result_t cmd_save(struct js *js, history_t *history, const char *arg)
   return CMD_OK;
 }
 
-static cmd_result_t cmd_gc(struct js *js, history_t *history, const char *arg) {
-  jsval_t gc_fn = js_get(js, rt->ant_obj, "gc");
-  jsval_t result = js_call(js, gc_fn, NULL, 0);
-  console_print(js, &result, 1, NULL, stdout);
-  return CMD_OK;
-}
-
-static cmd_result_t cmd_stats(struct js *js, history_t *history, const char *arg) {
+static cmd_result_t cmd_stats(ant_t *js, history_t *history, const char *arg) {
   jsval_t stats_fn = js_get(js, rt->ant_obj, "stats");
-  jsval_t result = js_call(js, stats_fn, NULL, 0);
+  jsval_t result = sv_vm_call(js->vm, js, stats_fn, js_mkundef(), NULL, 0, NULL, false);
   console_print(js, &result, 1, NULL, stdout);
   return CMD_OK;
 }
 
-static cmd_result_t execute_command(struct js *js, history_t *history, const char *line) {
+static cmd_result_t execute_command(ant_t *js, history_t *history, const char *line) {
   const char *cmd_start = line + 1;
   
   for (const repl_command_t *cmd = commands; cmd->name; cmd++) {
@@ -379,7 +635,7 @@ static key_handler_t handlers[] = {
   [KEY_BACKSPACE] = handle_backspace, [KEY_CHAR] = handle_char,
 };
 
-static char* read_line_with_history(history_t *hist, struct js *js, const char *prompt) {
+static char* read_line_with_history(history_t *hist, ant_t *js, const char *prompt) {
   char *line = malloc(MAX_LINE_LENGTH);
   int pos = 0, len = 0; line[0] = '\0';
   
@@ -466,11 +722,10 @@ static bool is_incomplete_input(const char *code, size_t len) {
 }
 
 void ant_repl_run() {
-  struct js *js = rt->js;
+  ant_t *js = rt->js;
   
   js_set_filename(js, "[repl]");
   js_setup_import_meta(js, "[repl]");
-  js_mkscope(js);
   
   printf("Welcome to Ant JavaScript v%s\n", ANT_VERSION);
   printf("Type \".help\" for more information.\n");
@@ -489,6 +744,9 @@ void ant_repl_run() {
   history_init(&history);
   history_load(&history);
   
+  repl_decl_registry_t decl_registry = {0};
+  g_repl_decl_registry = &decl_registry;
+  
   js_set(js, js_glob(js), "__dirname", js_mkstr(js, ".", 1));
   js_set(js, js_glob(js), "__filename", js_mkstr(js, "[repl]", 6));
 
@@ -581,14 +839,15 @@ void ant_repl_run() {
     memcpy(multiline_buf + multiline_len, line, line_len);
     multiline_len += line_len;
     multiline_buf[multiline_len] = '\0';
-    
     free(line);
     
     if (is_incomplete_input(multiline_buf, multiline_len)) continue;
     history_add(&history, multiline_buf);
     
-    jsval_t eval_result = js_eval(js, multiline_buf, multiline_len);
-    js_run_event_loop(js); print_repl_value(js, eval_result, stdout);
+    repl_eval_chunk(
+      js, &decl_registry, multiline_buf, 
+      multiline_len, REPL_PRINT_INTERACTIVE
+    );
     
     free(multiline_buf);
     multiline_buf = NULL;
@@ -597,6 +856,9 @@ void ant_repl_run() {
   }
   
   if (multiline_buf) free(multiline_buf);
+  repl_decl_registry_free(&decl_registry);
+  g_repl_decl_registry = NULL;
+  
   history_save(&history);
   history_free(&history);
 }
diff --git a/src/roots.c b/src/roots.c
index a7b0267..7a851fd 100644
--- a/src/roots.c
+++ b/src/roots.c
@@ -1,9 +1,9 @@
 #include "ant.h"
 #include "gc.h"
 #include "arena.h"
-#include "internal.h"
+#include "internal.h" // IWYU pragma: keep
 
-jshdl_t js_root(struct js *js, jsval_t val) {
+jshdl_t js_root(ant_t *js, jsval_t val) {
   if (js->gc_roots_len >= js->gc_roots_cap) {
     jshdl_t new_cap = js->gc_roots_cap ? js->gc_roots_cap * 2 : GC_ROOTS_INITIAL_CAP;
     jsval_t *new_roots = ant_realloc(js->gc_roots, new_cap * sizeof(jsval_t));
@@ -19,15 +19,15 @@ jshdl_t js_root(struct js *js, jsval_t val) {
   return idx;
 }
 
-jsval_t js_deref(struct js *js, jshdl_t h) {
+jsval_t js_deref(ant_t *js, jshdl_t h) {
   if (h < 0 || h >= js->gc_roots_len) return js_mkundef();
   return js->gc_roots[h];
 }
 
-void js_unroot(struct js *js, jshdl_t h) {
+void js_unroot(ant_t *js, jshdl_t h) {
   if (h >= 0 && h == js->gc_roots_len - 1) js->gc_roots_len--;
 }
 
-void js_root_update(struct js *js, jshdl_t h, jsval_t val) {
+void js_root_update(ant_t *js, jshdl_t h, jsval_t val) {
   if (h >= 0 && h < js->gc_roots_len) js->gc_roots[h] = val;
 }
\ No newline at end of file
diff --git a/src/runtime.c b/src/runtime.c
index 4affd53..07ffa93 100644
--- a/src/runtime.c
+++ b/src/runtime.c
@@ -8,6 +8,14 @@
 #include <uthash.h>
 #include <argtable3.h>
 
+#ifdef _WIN32
+#include <process.h>
+#define ant_getpid _getpid
+#else
+#include <unistd.h>
+#define ant_getpid getpid
+#endif
+
 typedef struct {
   const char *ptr;
   size_t len;
@@ -74,6 +82,20 @@ const char *code_arena_alloc(const char *code, size_t len) {
   return dest;
 }
 
+void *code_arena_bump(size_t size) {
+  size = (size + 7) & ~(size_t)7;
+  if (!code_arena_current || code_arena_current->used + size > code_arena_current->capacity) {
+    code_block_t *new_block = code_arena_new_block(size);
+    if (!new_block) return NULL;
+    if (!code_arena_head) code_arena_head = new_block;
+    else if (code_arena_current) code_arena_current->next = new_block;
+    code_arena_current = new_block;
+  }
+  void *ptr = &code_arena_current->data[code_arena_current->used];
+  code_arena_current->used += size;
+  return ptr;
+}
+
 size_t code_arena_get_memory(void) {
   size_t total = 0;
   for (code_block_t *b = code_arena_head; b; b = b->next)
@@ -81,6 +103,42 @@ size_t code_arena_get_memory(void) {
   return total;
 }
 
+code_arena_mark_t code_arena_mark(void) {
+  code_arena_mark_t mark = {0};
+  mark.block = code_arena_current;
+  mark.used = code_arena_current ? code_arena_current->used : 0;
+  return mark;
+}
+
+void code_arena_rewind(code_arena_mark_t mark) {
+  code_block_t *target = (code_block_t *)mark.block;
+
+  if (!target) {
+    code_block_t *block = code_arena_head;
+    
+    while (block) {
+      code_block_t *next = block->next;
+      free(block); block = next;
+    }
+    
+    code_arena_head = NULL;
+    code_arena_current = NULL;
+    
+    return;
+  }
+
+  if (mark.used <= target->capacity) target->used = mark.used;
+  code_block_t *b = target->next;
+  
+  while (b) {
+    code_block_t *next = b->next;
+    free(b); b = next;
+  }
+  
+  target->next = NULL;
+  code_arena_current = target;
+}
+
 void code_arena_reset(void) {
   intern_entry_t *entry, *tmp;
   HASH_ITER(hh, code_interns, entry, tmp) {
@@ -100,7 +158,7 @@ void code_arena_reset(void) {
   code_arena_current = NULL;
 }
 
-void destroy_runtime(struct js *js) {
+void destroy_runtime(ant_t *js) {
   if (rt->js == js) memset(&runtime, 0, sizeof(runtime));
 }
 
@@ -109,6 +167,7 @@ struct ant_runtime *ant_runtime_init(ant_t *js, int argc, char **argv, struct ar
     .js = js,
     .ant_obj = js_newobj(js),
     .flags = 0, .argc = argc, .argv = argv,
+    .pid = (int)ant_getpid(),
     .ls_fp = (ls_p && ls_p->count > 0) ? ls_p->filename[0] : NULL,
   };
 
@@ -119,4 +178,4 @@ struct ant_runtime *ant_runtime_init(ant_t *js, int argc, char **argv, struct ar
   js_set(js, global, "Ant", runtime.ant_obj);
 
   return &runtime;
-}
\ No newline at end of file
+}
diff --git a/src/silver/ast.c b/src/silver/ast.c
new file mode 100644
index 0000000..92b6060
--- /dev/null
+++ b/src/silver/ast.c
@@ -0,0 +1,2061 @@
+#include "silver/ast.h"
+#include "silver/lexer.h"
+#include "silver/directives.h"
+
+#include "escape.h"
+#include "errors.h"
+#include "internal.h"
+#include "tokens.h"
+
+#include <runtime.h>
+#include <stdlib.h>
+#include <string.h>
+
+sv_ast_t *sv_ast_new(sv_node_type_t type) {
+  sv_ast_t *n = code_arena_bump(sizeof(sv_ast_t));
+  if (!n) return NULL;
+  memset(n, 0, sizeof(sv_ast_t));
+  n->type = type;
+  return n;
+}
+
+void sv_ast_list_push(sv_ast_list_t *list, sv_ast_t *node) {
+  if (list->count >= list->cap) {
+    int new_cap = list->cap ? list->cap * 2 : 4;
+    sv_ast_t **new_items = code_arena_bump((size_t)new_cap * sizeof(sv_ast_t *));
+    if (!new_items) return;
+    if (list->items)
+      memcpy(new_items, list->items, (size_t)list->count * sizeof(sv_ast_t *));
+    list->items = new_items;
+    list->cap = new_cap;
+  }
+  list->items[list->count++] = node;
+}
+
+bool sv_ast_can_be_expression_statement(const sv_ast_t *node) {
+  if (!node) return false;
+
+  static const uint8_t expr_stmt_nodes[N__COUNT] = {
+    [N_NUMBER] = 1, [N_STRING] = 1, [N_BIGINT] = 1, [N_BOOL] = 1,
+    [N_NULL] = 1, [N_UNDEF] = 1, [N_THIS] = 1, [N_GLOBAL_THIS] = 1,
+    [N_TEMPLATE] = 1, [N_REGEXP] = 1, [N_IDENT] = 1, [N_BINARY] = 1,
+    [N_UNARY] = 1, [N_UPDATE] = 1, [N_ASSIGN] = 1, [N_TERNARY] = 1,
+    [N_CALL] = 1, [N_NEW] = 1, [N_MEMBER] = 1, [N_OPTIONAL] = 1,
+    [N_ARRAY] = 1, [N_OBJECT] = 1, [N_PROPERTY] = 1, [N_SPREAD] = 1,
+    [N_SEQUENCE] = 1, [N_ARROW] = 1, [N_YIELD] = 1, [N_AWAIT] = 1,
+    [N_TYPEOF] = 1, [N_DELETE] = 1, [N_VOID] = 1, [N_TAGGED_TEMPLATE] = 1,
+    [N_IMPORT] = 1,
+  };
+
+  if (node->type == N_FUNC)
+    return !(node->str && !(node->flags & FN_ARROW));
+  if ((unsigned)node->type >= N__COUNT) return false;
+  return expr_stmt_nodes[node->type] != 0;
+}
+
+typedef struct {
+  ant_t *js;
+  sv_lexer_t lx;
+  bool no_in;
+} sv_parser_t;
+
+#define P            sv_parser_t *p
+#define JS           p->js
+#define TOK          p->lx.st.tok
+#define TOFF         p->lx.st.toff
+#define TLEN         p->lx.st.tlen
+#define TVAL         p->lx.st.tval
+#define POS          p->lx.st.pos
+#define CONSUMED     p->lx.st.consumed
+#define HAD_NEWLINE  p->lx.st.had_newline
+#define CODE         p->lx.code
+#define CLEN         p->lx.clen
+#define CONSUME()    ((void)(CONSUMED = 1))
+#define NEXT()       sv_lexer_next(&p->lx)
+#define LA()         sv_lexer_lookahead(&p->lx)
+
+static sv_ast_t *parse_stmt(P);
+static sv_ast_t *parse_expr(P);
+static sv_ast_t *parse_assign(P);
+static sv_ast_t *parse_ternary(P);
+static sv_ast_t *parse_binary(P, int min_prec);
+static sv_ast_t *parse_unary(P);
+static sv_ast_t *parse_postfix(P);
+static sv_ast_t *parse_call(P);
+static sv_ast_t *parse_primary(P);
+static sv_ast_t *parse_block(P, bool directive_ctx);
+static sv_ast_t *parse_func(P);
+static sv_ast_t *parse_class(P);
+static sv_ast_t *parse_object(P);
+static sv_ast_t *parse_array(P);
+static sv_ast_t *parse_import_stmt(P);
+static sv_ast_t *parse_export_stmt(P);
+static sv_ast_t *parse_arrow_body(P);
+static sv_ast_t *parse_binding_pattern(P);
+
+#define SV_SYNC_ERR() ((void)sv_lexer_set_error_site(&p->lx))
+#define SV_MKERR(...) (SV_SYNC_ERR(), js_mkerr(__VA_ARGS__))
+#define SV_MKERR_TYPED(...) (SV_SYNC_ERR(), js_mkerr_typed(__VA_ARGS__))
+
+static inline const char *tok_str(P) { 
+  return &CODE[TOFF]; 
+}
+
+static inline bool eat(P, uint8_t tok) {
+  NEXT();
+  if (TOK == tok) { CONSUME(); return true; }
+  return false;
+}
+
+static inline void expect(P, uint8_t tok) {
+  NEXT();
+  if (TOK == tok) CONSUME();
+}
+
+static inline sv_ast_t *mk_plain(sv_node_type_t type) {
+  return sv_ast_new(type);
+}
+
+#define mk(type) ({ \
+  sv_ast_t *_n = mk_plain(type); \
+  _n->src_off = (uint32_t)TOFF; _n; \
+})
+
+static inline sv_ast_t *mk_num(double val) {
+  sv_ast_t *n = mk_plain(N_NUMBER);
+  n->num = val;
+  return n;
+}
+
+static inline sv_ast_t *mk_ident(const char *s, uint32_t len) {
+  sv_ast_t *n = mk_plain(N_IDENT);
+  n->str = s;
+  n->len = len;
+  return n;
+}
+
+static inline void sv_ast_set_string(sv_ast_t *n, sv_lex_string_t s) {
+  if (!n || !s.ok) return;
+  n->str = s.str;
+  n->len = s.len;
+}
+
+typedef struct {
+  const char *str;
+  uint32_t len;
+  bool ok;
+  bool valid_cooked;
+} sv_tpl_cooked_t;
+
+static inline const char *decode_ident_into_arena(const char *src, uint32_t len, uint32_t *out_len) {
+  if (!src || len == 0 || !memchr(src, '\\', len)) {
+    if (out_len) *out_len = len;
+    return src;
+  }
+
+  char *dst = code_arena_bump((size_t)len + 1);
+  if (!dst) {
+    if (out_len) *out_len = len;
+    return src;
+  }
+
+  size_t di = 0; size_t i = 0;
+  const uint8_t *in = (const uint8_t *)src;
+  uint8_t *out = (uint8_t *)dst;
+  
+  while (i < len) {
+    if (in[i] == '\\' && i + 1 < len && in[i + 1] == 'u') {
+      size_t adv = decode_escape(in, i, len, out, &di, 0);
+      if (adv > 0) { i += 2 + adv; continue; }
+    }
+    out[di++] = in[i++];
+  }
+  
+  out[di] = '\0';
+  if (out_len) *out_len = (uint32_t)di;
+  return dst;
+}
+
+static inline bool is_contextual_ident_tok(uint8_t tok) {
+  return 
+    tok == TOK_AS
+    || tok == TOK_FROM
+    || tok == TOK_OF
+    || tok == TOK_ASYNC;
+}
+
+static inline const char *tok_ident_str(P, uint32_t *out_len) {
+  return decode_ident_into_arena(tok_str(p), (uint32_t)TLEN, out_len);
+}
+
+static inline bool is_ident_like_tok(uint8_t tok) {
+  return tok == TOK_IDENTIFIER || tok == TOK_DEFAULT || is_contextual_ident_tok(tok);
+}
+
+static inline bool sv_strict_forbidden_binding_ident(const char *s, uint32_t len) {
+  return is_eval_or_arguments_name(s, len) || is_strict_reserved_name(s, len);
+}
+
+static inline bool sv_is_strict_restricted_assign_target(P, sv_ast_t *n) {
+  return p->lx.strict && n && n->type == N_IDENT && is_eval_or_arguments_name(n->str, n->len);
+}
+
+static inline sv_ast_t *mk_ident_from_tok(P) {
+  uint32_t len = 0;
+  const char *name = tok_ident_str(p, &len);
+  sv_ast_t *n = mk_ident(name, len);
+  n->src_off = (uint32_t)TOFF;
+  n->src_end = (uint32_t)(TOFF + TLEN);
+  return n;
+}
+
+static inline sv_ast_t *mk_private_ident_from_tok(P) {
+  sv_ast_t *n = mk(N_IDENT);
+  n->str = &CODE[TOFF - 1];
+  n->len = (uint32_t)(TLEN + 1);
+  n->src_off = (uint32_t)(TOFF > 0 ? TOFF - 1 : TOFF);
+  n->src_end = (uint32_t)(TOFF + TLEN);
+  return n;
+}
+
+static inline void sv_strict_check_binding_ident(P, const char *s, uint32_t len) {
+  if (!p->lx.strict || !s || len == 0) return;
+  if (sv_strict_forbidden_binding_ident(s, len)) SV_MKERR_TYPED(
+    JS, JS_ERR_SYNTAX, "Invalid binding identifier '%.*s' in strict mode", 
+    (int)len, s
+  );
+}
+
+static inline void sv_parse_unexpected_token(P) {
+  size_t tok_len = 0;
+
+  if (TOFF < CLEN && TLEN > 0) {
+    jsoff_t rem = CLEN - TOFF;
+    tok_len = (size_t)TLEN;
+    if ((jsoff_t)tok_len > rem) tok_len = (size_t)rem;
+  }
+
+  if (tok_len == 0) {
+    SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Unexpected token 'EOF'");
+    return;
+  }
+
+  SV_MKERR_TYPED(
+    JS, JS_ERR_SYNTAX,
+    "Unexpected token '%.*s'",
+    (int)tok_len, &CODE[TOFF]
+  );
+}
+
+static sv_ast_t *parse_arrow_body(P) {
+  if (NEXT() == TOK_LBRACE) return parse_block(p, true);
+  return parse_assign(p);
+}
+
+static void sv_parse_stmt_list(P, sv_ast_list_t *out, bool stop_at_rbrace, bool directive_ctx) {
+  bool strict_mode = p->lx.strict;
+  bool saved_lexer_strict = p->lx.strict;
+  bool in_directive_prologue = directive_ctx;
+  p->lx.strict = strict_mode;
+
+  for (;;) {
+    NEXT();
+    if (TOK == TOK_EOF) break;
+    if (stop_at_rbrace && TOK == TOK_RBRACE) break;
+
+    if (TOK == TOK_ERR) {
+      sv_parse_unexpected_token(p);
+      break;
+    }
+
+    sv_ast_t *stmt = parse_stmt(p);
+    if (stmt) sv_ast_list_push(out, stmt);
+    if (JS->thrown_exists) break;
+    if (!in_directive_prologue) continue;
+    if (!stmt || stmt->type == N_EMPTY) continue;
+    
+    if (!sv_ast_can_be_expression_statement(stmt)) {
+      in_directive_prologue = false;
+      continue;
+    }
+    
+    if (sv_ast_is_use_strict(JS, stmt)) {
+      strict_mode = true;
+      p->lx.strict = true;
+      continue;
+    }
+    in_directive_prologue = false;
+  }
+  p->lx.strict = saved_lexer_strict;
+}
+
+static sv_ast_t *parse_binding_pattern(P) {
+  NEXT();
+  if (TOK == TOK_LBRACKET) return parse_array(p);
+  if (TOK == TOK_LBRACE) return parse_object(p);
+  if (is_ident_like_tok(TOK)) {
+    sv_ast_t *id = mk_ident_from_tok(p);
+    sv_strict_check_binding_ident(p, id->str, id->len);
+    CONSUME();
+    return id;
+  }
+  CONSUME();
+  return mk(N_EMPTY);
+}
+
+static void push_arrow_params_from_expr(sv_ast_t *fn, sv_ast_t *expr) {
+  if (!fn || !expr) return;
+  if (expr->type == N_SEQUENCE) {
+    push_arrow_params_from_expr(fn, expr->left);
+    push_arrow_params_from_expr(fn, expr->right);
+    return;
+  }
+  if (expr->type == N_ASSIGN && expr->op == TOK_ASSIGN) {
+    sv_ast_t *def = mk_plain(N_ASSIGN_PAT);
+    def->left = expr->left;
+    def->right = expr->right;
+    def->src_off = expr->src_off;
+    sv_ast_list_push(&fn->args, def);
+    return;
+  }
+  if (expr->type == N_SPREAD) {
+    sv_ast_t *rest = mk_plain(N_REST);
+    rest->right = expr->right;
+    rest->src_off = expr->src_off;
+    sv_ast_list_push(&fn->args, rest);
+    return;
+  }
+  sv_ast_list_push(&fn->args, expr);
+}
+
+static sv_tpl_cooked_t decode_template_segment(P, const uint8_t *in, size_t start, size_t end) {
+  sv_tpl_cooked_t outv = { .str = NULL, .len = 0, .ok = true, .valid_cooked = true };
+  size_t raw_len = (end > start) ? (end - start) : 0;
+  if (raw_len == 0) {
+    outv.str = "";
+    return outv;
+  }
+
+  uint8_t *out = code_arena_bump(raw_len);
+  if (!out) {
+    (void)SV_MKERR(JS, "oom");
+    outv.ok = false;
+    return outv;
+  }
+
+  size_t out_len = 0;
+  for (size_t i = start; i < end; i++) {
+    if (in[i] == '\r') {
+      out[out_len++] = '\n';
+      if (i + 1 < end && in[i + 1] == '\n') i++;
+      continue;
+    }
+    if (in[i] != '\\' || i + 1 >= end) {
+      out[out_len++] = in[i];
+      continue;
+    }
+    uint8_t c = in[i + 1];
+    if (c >= '1' && c <= '9') { outv.valid_cooked = false; return outv; }
+    if (c == '0' && i + 2 < end && in[i + 2] >= '0' && in[i + 2] <= '9') {
+      outv.valid_cooked = false; return outv;
+    }
+    if (c == 'x' && !(i + 3 < end && is_xdigit(in[i + 2]) && is_xdigit(in[i + 3]))) {
+      outv.valid_cooked = false; return outv;
+    }
+    if (c == 'u') {
+      if (i + 2 < end && in[i + 2] == '{') {
+        uint32_t cp = 0; size_t j = i + 3;
+        while (j < end && is_xdigit(in[j])) { cp = (cp << 4) | unhex(in[j]); j++; }
+        if (!(j < end && in[j] == '}' && j > i + 3 && cp <= 0x10FFFF)) {
+          outv.valid_cooked = false; return outv;
+        }
+      } else if (
+        !(i + 5 < end && is_xdigit(in[i + 2]) 
+        && is_xdigit(in[i + 3]) 
+        && is_xdigit(in[i + 4]) 
+        && is_xdigit(in[i + 5]))) { outv.valid_cooked = false; return outv; }
+    }
+    i += 1 + decode_escape(in, i, end, out, &out_len, '`');
+  }
+
+  outv.str = (const char *)out;
+  outv.len = (uint32_t)out_len;
+  return outv;
+}
+
+static sv_ast_t *try_parse_async_arrow(P) {
+  uint8_t la = LA();
+  uint32_t async_off = (uint32_t)TOFF;
+
+  if (la == TOK_LPAREN) {
+    sv_lexer_state_t saved;
+    sv_lexer_save_state(&p->lx, &saved);
+    NEXT(); CONSUME();
+    if (NEXT() == TOK_RPAREN) {
+      CONSUME();
+      if (LA() == TOK_ARROW) {
+        NEXT(); CONSUME();
+        sv_ast_t *fn = mk(N_FUNC);
+        fn->flags = FN_ARROW | FN_ASYNC;
+        fn->body = parse_arrow_body(p);
+        fn->src_off = async_off;
+        fn->src_end = (uint32_t)(TOFF + TLEN);
+        return fn;
+      }
+    }
+    sv_lexer_restore_state(&p->lx, &saved);
+    NEXT(); CONSUME();
+    sv_ast_t *expr = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    if (LA() == TOK_ARROW) {
+      NEXT(); CONSUME();
+      sv_ast_t *fn = mk(N_FUNC);
+      fn->flags = FN_ARROW | FN_ASYNC;
+      push_arrow_params_from_expr(fn, expr);
+      fn->body = parse_arrow_body(p);
+      fn->src_off = async_off;
+      fn->src_end = (uint32_t)(TOFF + TLEN);
+      return fn;
+    }
+    sv_lexer_restore_state(&p->lx, &saved);
+    return NULL;
+  }
+
+  if (la == TOK_IDENTIFIER) {
+    sv_lexer_state_t saved;
+    sv_lexer_save_state(&p->lx, &saved);
+    NEXT(); CONSUME();
+    sv_ast_t *id = mk_ident_from_tok(p);
+    if (LA() == TOK_ARROW) {
+      NEXT(); CONSUME();
+      sv_ast_t *fn = mk(N_FUNC);
+      fn->flags = FN_ARROW | FN_ASYNC;
+      sv_ast_list_push(&fn->args, id);
+      fn->body = parse_arrow_body(p);
+      fn->src_off = async_off;
+      fn->src_end = (uint32_t)(TOFF + TLEN);
+      return fn;
+    }
+    sv_lexer_restore_state(&p->lx, &saved);
+    return NULL;
+  }
+
+  return NULL;
+}
+
+static sv_ast_t *parse_primary(P) {
+  NEXT();
+
+  static const void *dispatch[TOK_MAX] = {
+    [TOK_NUMBER]     = &&l_number,
+    [TOK_STRING]     = &&l_string,
+    [TOK_BIGINT]     = &&l_bigint,
+    [TOK_TRUE]       = &&l_true,
+    [TOK_FALSE]      = &&l_false,
+    [TOK_NULL]       = &&l_null,
+    [TOK_UNDEF]      = &&l_undef,
+    [TOK_THIS]       = &&l_this,
+    [TOK_IDENTIFIER] = &&l_ident,
+    [TOK_AS]         = &&l_ident,
+    [TOK_FROM]       = &&l_ident,
+    [TOK_OF]         = &&l_ident,
+    [TOK_LPAREN]     = &&l_paren,
+    [TOK_LBRACKET]   = &&l_array,
+    [TOK_LBRACE]     = &&l_object,
+    [TOK_FUNC]       = &&l_func,
+    [TOK_CLASS]      = &&l_class,
+    [TOK_ASYNC]      = &&l_async,
+    [TOK_TEMPLATE]   = &&l_template,
+    [TOK_NEW]        = &&l_new,
+    [TOK_TYPEOF]     = &&l_typeof,
+    [TOK_VOID]       = &&l_void,
+    [TOK_DELETE]     = &&l_delete,
+    [TOK_YIELD]      = &&l_yield,
+    [TOK_AWAIT]      = &&l_await,
+    [TOK_SUPER]      = &&l_super,
+    [TOK_REST]       = &&l_spread,
+    [TOK_IMPORT]     = &&l_import_expr,
+    [TOK_DIV]        = &&l_regex,
+    [TOK_DIV_ASSIGN] = &&l_regex,
+    [TOK_GLOBAL_THIS] = &&l_globalthis,
+    [TOK_WINDOW]      = &&l_globalthis,
+    [TOK_HASH]        = &&l_private_name,
+  };
+
+  if (TOK < TOK_MAX && dispatch[TOK])
+    goto *dispatch[TOK];
+
+  sv_parse_unexpected_token(p);
+  return mk(N_EMPTY);
+
+  l_number: {
+    CONSUME();
+    return mk_num(tod(TVAL));
+  }
+
+  l_string: {
+    sv_ast_t *n = mk(N_STRING);
+    sv_ast_set_string(n, sv_lexer_str_literal(&p->lx));
+    CONSUME();
+    return n;
+  }
+
+  l_bigint: {
+    CONSUME();
+    sv_ast_t *n = mk(N_BIGINT);
+    n->str = tok_str(p);
+    n->len = (uint32_t)TLEN;
+    return n;
+  }
+
+  l_true:  { CONSUME(); sv_ast_t *n = mk(N_BOOL); n->num = 1; return n; }
+  l_false: { CONSUME(); sv_ast_t *n = mk(N_BOOL); n->num = 0; return n; }
+  l_null:  { CONSUME(); return mk(N_NULL); }
+  l_undef: { CONSUME(); return mk(N_UNDEF); }
+  l_this:  { CONSUME(); return mk(N_THIS); }
+  l_globalthis: { CONSUME(); return mk(N_GLOBAL_THIS); }
+
+  l_ident: {
+    uint32_t ident_off = (uint32_t)TOFF;
+    CONSUME();
+    sv_ast_t *id = mk_ident_from_tok(p);
+    if (LA() == TOK_ARROW) {
+      NEXT(); CONSUME();
+      sv_ast_t *fn = mk(N_FUNC);
+      fn->flags = FN_ARROW;
+      fn->src_off = ident_off;
+      sv_ast_list_push(&fn->args, id);
+      fn->body = parse_arrow_body(p);
+      fn->src_end = (uint32_t)(TOFF + TLEN);
+      return fn;
+    }
+    return id;
+  }
+
+  l_paren: {
+    uint32_t paren_off = (uint32_t)TOFF;
+    CONSUME();
+    if (NEXT() == TOK_RPAREN) {
+      CONSUME();
+      if (LA() == TOK_ARROW) {
+        NEXT(); CONSUME();
+        sv_ast_t *fn = mk(N_FUNC);
+        fn->flags = FN_ARROW;
+        fn->src_off = paren_off;
+        fn->body = parse_arrow_body(p);
+        fn->src_end = (uint32_t)(TOFF + TLEN);
+        return fn;
+      }
+      return mk(N_UNDEF);
+    }
+    sv_ast_t *expr = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    if (LA() == TOK_ARROW) {
+      NEXT(); CONSUME();
+      sv_ast_t *fn = mk(N_FUNC);
+      fn->flags = FN_ARROW;
+      fn->src_off = paren_off;
+      push_arrow_params_from_expr(fn, expr);
+      fn->body = parse_arrow_body(p);
+      fn->src_end = (uint32_t)(TOFF + TLEN);
+      return fn;
+    }
+    expr->flags |= FN_PAREN;
+    return expr;
+  }
+
+  l_array:  return parse_array(p);
+  l_object: return parse_object(p);
+  l_func:   { CONSUME(); return parse_func(p); }
+
+  l_class: {
+    CONSUME();
+    return parse_class(p);
+  }
+
+  l_async: {
+    uint32_t async_off = (uint32_t)TOFF;
+    CONSUME();
+    if (LA() == TOK_FUNC) {
+      NEXT(); CONSUME();
+      sv_ast_t *fn = parse_func(p);
+      fn->flags |= FN_ASYNC;
+      fn->src_off = async_off;
+      return fn;
+    }
+    sv_ast_t *arrow = try_parse_async_arrow(p);
+    if (arrow) return arrow;
+    return mk_ident_from_tok(p);
+  }
+
+  l_template: {
+    CONSUME();
+    sv_ast_t *n = mk(N_TEMPLATE);
+    const uint8_t *in = (const uint8_t *)&CODE[TOFF];
+    size_t tpl_len = TLEN;
+    size_t i = 1;
+
+    for (;;) {
+      size_t seg_start = i;
+      while (i < tpl_len - 1) {
+        if (in[i] == '\\' && i + 1 < tpl_len - 1) { i += 2; continue; }
+        if (in[i] == '$' && i + 1 < tpl_len - 1 && in[i + 1] == '{') break;
+        i++;
+      }
+      sv_ast_t *s = mk(N_STRING);
+      s->aux = (const char *)&in[seg_start];
+      s->aux_len = (uint32_t)(i - seg_start);
+      sv_tpl_cooked_t cooked = decode_template_segment(p, in, seg_start, i);
+      if (cooked.ok && cooked.valid_cooked) {
+        s->str = cooked.str;
+        s->len = cooked.len;
+      } else if (cooked.ok) s->flags |= FN_INVALID_COOKED;
+      
+      sv_ast_list_push(&n->args, s);
+      if (i >= tpl_len - 1 || in[i] != '$') break;
+
+      i += 2;
+      size_t expr_start = i;
+      size_t expr_max_len = (
+        tpl_len > 0 && expr_start < tpl_len - 1)
+        ? (tpl_len - 1 - expr_start) : 0;
+
+      sv_lexer_checkpoint_t cp;
+      sv_lexer_push_source(&p->lx, &cp, (const char *)&in[expr_start], (jsoff_t)expr_max_len);
+
+      sv_ast_t *expr = parse_expr(p);
+      sv_ast_list_push(&n->args, expr);
+
+      if (NEXT() != TOK_RBRACE) {
+        SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Unterminated template expression");
+        sv_lexer_pop_source(&p->lx, &cp);
+        return n;
+      }
+      CONSUME();
+
+      size_t consumed_expr = (size_t)POS;
+      sv_lexer_pop_source(&p->lx, &cp);
+
+      if (consumed_expr == 0) {
+        SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Unterminated template expression");
+        return n;
+      } i = expr_start + consumed_expr;
+    }
+    return n;
+  }
+
+  l_new: {
+    CONSUME();
+
+    if (NEXT() == TOK_DOT) {
+      CONSUME();
+      if (NEXT() == TOK_IDENTIFIER && TLEN == 6 && memcmp(tok_str(p), "target", 6) == 0) {
+        CONSUME();
+        return mk(N_NEW_TARGET);
+      }
+      sv_parse_unexpected_token(p);
+      return mk(N_EMPTY);
+    }
+
+    sv_ast_t *n = mk(N_NEW);
+    sv_ast_t *callee = parse_primary(p);
+    
+    for (;;) {
+      uint8_t la = NEXT();
+      if (la == TOK_DOT) {
+        CONSUME();
+        NEXT();
+        sv_ast_t *mem = mk(N_MEMBER);
+        mem->left = callee;
+        mem->right = mk_ident_from_tok(p);
+        CONSUME();
+        callee = mem;
+      } else if (la == TOK_LBRACKET) {
+        CONSUME();
+        sv_ast_t *mem = mk(N_MEMBER);
+        mem->left = callee;
+        mem->right = parse_expr(p);
+        mem->flags = 1;
+        expect(p, TOK_RBRACKET);
+        callee = mem;
+      } else break;
+    }
+    n->left = callee;
+
+    if (NEXT() == TOK_LPAREN) {
+      CONSUME();
+      while (NEXT() != TOK_RPAREN && TOK != TOK_EOF) {
+        if (TOK == TOK_REST) {
+          CONSUME();
+          sv_ast_t *spread = mk(N_SPREAD);
+          spread->right = parse_assign(p);
+          sv_ast_list_push(&n->args, spread);
+        } else sv_ast_list_push(&n->args, parse_assign(p));
+        if (NEXT() == TOK_COMMA) CONSUME();
+        else break;
+      } expect(p, TOK_RPAREN);
+    }
+    return n;
+  }
+
+  l_typeof: {
+    CONSUME();
+    sv_ast_t *n = mk(N_TYPEOF);
+    n->right = parse_unary(p);
+    return n;
+  }
+
+  l_void: {
+    CONSUME();
+    sv_ast_t *n = mk(N_VOID);
+    n->right = parse_unary(p);
+    return n;
+  }
+
+  l_delete: {
+    CONSUME();
+    sv_ast_t *n = mk(N_DELETE);
+    n->right = parse_unary(p);
+    if (p->lx.strict && n->right && n->right->type == N_IDENT) {
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "cannot delete bindings in strict mode");
+      return mk(N_EMPTY);
+    }
+    return n;
+  }
+
+  l_yield: {
+    CONSUME();
+    sv_ast_t *n = mk(N_YIELD);
+    if (NEXT() == TOK_MUL) {
+      CONSUME();
+      n->flags = 1;
+    }
+    if (TOK != TOK_SEMICOLON && TOK != TOK_RBRACE &&
+        TOK != TOK_RPAREN && TOK != TOK_RBRACKET &&
+        TOK != TOK_EOF && TOK != TOK_COMMA)
+      n->right = parse_assign(p);
+    return n;
+  }
+
+  l_await: {
+    CONSUME();
+    sv_ast_t *n = mk(N_AWAIT);
+    n->right = parse_unary(p);
+    return n;
+  }
+
+  l_super: {
+    CONSUME();
+    return mk_ident("super", 5);
+  }
+
+  l_spread: {
+    CONSUME();
+    sv_ast_t *n = mk(N_SPREAD);
+    n->right = parse_assign(p);
+    return n;
+  }
+
+  l_import_expr: {
+    CONSUME();
+    if (NEXT() != TOK_LPAREN) return mk_ident("import", 6);
+    CONSUME();
+    sv_ast_t *n = mk(N_IMPORT);
+    n->right = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    return n;
+  }
+
+  l_regex: {
+    CONSUME();
+    jsoff_t pattern_start = (TOK == TOK_DIV_ASSIGN) ? (TOFF + 1) : POS;
+    if (TOK == TOK_DIV_ASSIGN) POS = pattern_start;
+    bool in_class = false;
+
+    while (POS < CLEN) {
+      char c = CODE[POS];
+      if (c == '\\' && POS + 1 < CLEN) {
+        POS += 2;
+        continue;
+      }
+      if (c == '[') in_class = true;
+      else if (c == ']') in_class = false;
+      else if (c == '/' && !in_class) break;
+      POS++;
+    }
+
+    jsoff_t pattern_end = POS;
+    if (POS < CLEN) POS++;
+
+    jsoff_t flags_start = POS;
+    while (POS < CLEN) {
+      char c = CODE[POS];
+      if (c == 'g' || c == 'i' || c == 'm' || c == 's' || c == 'u' || c == 'y')
+        POS++;
+      else break;
+    }
+    
+    jsoff_t flags_end = POS;
+    sv_ast_t *n = mk(N_REGEXP);
+    
+    n->str = &CODE[pattern_start];
+    n->len = (uint32_t)(pattern_end - pattern_start);
+    n->aux = &CODE[flags_start];
+    n->aux_len = (uint32_t)(flags_end - flags_start);
+    CONSUMED = 1;
+    return n;
+  }
+
+  l_private_name: {
+    CONSUME();
+    NEXT();
+    if (!is_ident_like_tok(TOK)) {
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "private field name expected");
+      return mk(N_EMPTY);
+    }
+    sv_ast_t *n = mk_private_ident_from_tok(p);
+    CONSUME();
+    return n;
+  }
+}
+
+static sv_ast_t *parse_array(P) {
+  CONSUME();
+  sv_ast_t *n = mk(N_ARRAY);
+  while (NEXT() != TOK_RBRACKET && TOK != TOK_EOF) {
+    if (TOK == TOK_COMMA) {
+      CONSUME();
+      sv_ast_list_push(&n->args, mk(N_EMPTY));
+      continue;
+    }
+    if (TOK == TOK_REST) {
+      CONSUME();
+      sv_ast_t *spread = mk(N_SPREAD);
+      spread->right = parse_assign(p);
+      sv_ast_list_push(&n->args, spread);
+    } else {
+      sv_ast_list_push(&n->args, parse_assign(p));
+    }
+    if (NEXT() == TOK_COMMA) CONSUME();
+    else break;
+  }
+  expect(p, TOK_RBRACKET);
+  return n;
+}
+
+static sv_ast_t *parse_object(P) {
+  CONSUME();
+  sv_ast_t *n = mk(N_OBJECT);
+  bool proto_set = false;
+  while (NEXT() != TOK_RBRACE && TOK != TOK_EOF) {
+    sv_ast_t *prop = mk(N_PROPERTY);
+
+    if (TOK == TOK_REST) {
+      CONSUME();
+      sv_ast_t *spread = mk(N_SPREAD);
+      spread->right = parse_assign(p);
+      sv_ast_list_push(&n->args, spread);
+      if (NEXT() == TOK_COMMA) CONSUME();
+      continue;
+    }
+
+    if (TOK == TOK_LBRACKET) {
+      CONSUME();
+      prop->left = parse_assign(p);
+      expect(p, TOK_RBRACKET);
+      prop->flags |= FN_COMPUTED;
+    }
+    else if (
+      (TLEN == 3 && memcmp(tok_str(p), "get", 3) == 0) ||
+      (TLEN == 3 && memcmp(tok_str(p), "set", 3) == 0)) {
+      uint8_t gs = tok_str(p)[0];
+      uint8_t la = LA();
+      if (la != TOK_COLON && la != TOK_LPAREN && la != TOK_COMMA &&
+          la != TOK_RBRACE) {
+        CONSUME();
+        prop->flags |= (gs == 'g') ? FN_GETTER : FN_SETTER;
+        NEXT();
+
+        if (TOK == TOK_LBRACKET) {
+          CONSUME();
+          prop->left = parse_assign(p);
+          expect(p, TOK_RBRACKET);
+          prop->flags |= FN_COMPUTED;
+        } else if (TOK == TOK_NUMBER) {
+          CONSUME();
+          prop->left = mk_num(tod(TVAL));
+        } else if (TOK == TOK_STRING) {
+          prop->left = mk(N_STRING);
+          sv_ast_set_string(prop->left, sv_lexer_str_literal(&p->lx));
+          CONSUME();
+        } else {
+          prop->left = mk_ident_from_tok(p);
+          CONSUME();
+        }
+
+        prop->right = parse_func(p);
+        sv_ast_list_push(&n->args, prop);
+        if (NEXT() == TOK_COMMA) CONSUME();
+        continue;
+      }
+      prop->left = mk_ident_from_tok(p);
+      CONSUME();
+    }
+    else if (TOK == TOK_ASYNC) {
+      uint8_t la = LA();
+      if (la != TOK_COLON && la != TOK_LPAREN && la != TOK_COMMA && la != TOK_RBRACE) {
+        CONSUME();
+        prop->flags |= FN_ASYNC;
+        NEXT();
+
+        if (TOK == TOK_MUL) {
+          prop->flags |= FN_GENERATOR;
+          CONSUME();
+          NEXT();
+        }
+
+        if (TOK == TOK_LBRACKET) {
+          CONSUME();
+          prop->left = parse_assign(p);
+          expect(p, TOK_RBRACKET);
+          prop->flags |= FN_COMPUTED;
+        } else if (TOK == TOK_NUMBER) {
+          CONSUME();
+          prop->left = mk_num(tod(TVAL));
+        } else if (TOK == TOK_STRING) {
+          prop->left = mk(N_STRING);
+          sv_ast_set_string(prop->left, sv_lexer_str_literal(&p->lx));
+          CONSUME();
+        } else {
+          prop->left = mk_ident_from_tok(p);
+          CONSUME();
+        }
+
+        prop->right = parse_func(p);
+        prop->right->flags |= FN_ASYNC;
+        if (prop->flags & FN_GENERATOR)
+          prop->right->flags |= FN_GENERATOR;
+        sv_ast_list_push(&n->args, prop);
+        if (NEXT() == TOK_COMMA) CONSUME();
+        continue;
+      }
+      prop->left = mk_ident_from_tok(p);
+      CONSUME();
+    }
+    else if (TOK == TOK_NUMBER) {
+      CONSUME();
+      prop->left = mk_num(tod(TVAL));
+    }
+    else if (TOK == TOK_STRING) {
+      prop->left = mk(N_STRING);
+      sv_ast_set_string(prop->left, sv_lexer_str_literal(&p->lx));
+      CONSUME();
+    }
+    else {
+      prop->left = mk_ident_from_tok(p);
+      CONSUME();
+    }
+
+    if (NEXT() == TOK_COLON) {
+      CONSUME();
+      prop->flags |= FN_COLON;
+      if (prop->left && prop->left->type == N_IDENT &&
+          prop->left->len == 9 && memcmp(prop->left->str, "__proto__", 9) == 0) {
+        if (proto_set) { SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Duplicate __proto__ fields are not allowed in object literals"); return n; }
+        proto_set = true;
+      }
+      prop->right = parse_assign(p);
+    } else if (TOK == TOK_LPAREN) {
+      prop->right = parse_func(p);
+    } else {
+      prop->right = mk_ident(prop->left->str, prop->left->len);
+      if (NEXT() == TOK_ASSIGN) {
+        CONSUME();
+        sv_ast_t *def = mk(N_ASSIGN);
+        def->op = TOK_ASSIGN;
+        def->left = prop->right;
+        def->right = parse_assign(p);
+        prop->right = def;
+      }
+    }
+
+    sv_ast_list_push(&n->args, prop);
+    if (NEXT() == TOK_COMMA) CONSUME();
+    else break;
+  }
+  expect(p, TOK_RBRACE);
+  return n;
+}
+
+static sv_ast_t *parse_call(P) {
+  sv_ast_t *n = parse_primary(p);
+
+  for (;;) {
+    uint8_t la = NEXT();
+    if (la == TOK_LPAREN) {
+      CONSUME();
+      sv_ast_t *call = mk(N_CALL);
+      call->left = n;
+      while (NEXT() != TOK_RPAREN && TOK != TOK_EOF) {
+        if (TOK == TOK_REST) {
+          CONSUME();
+          sv_ast_t *spread = mk(N_SPREAD);
+          spread->right = parse_assign(p);
+          sv_ast_list_push(&call->args, spread);
+        } else {
+          sv_ast_list_push(&call->args, parse_assign(p));
+        }
+        if (NEXT() == TOK_COMMA) CONSUME();
+        else break;
+      }
+      expect(p, TOK_RPAREN);
+      n = call;
+    } else if (la == TOK_DOT) {
+      CONSUME();
+      NEXT();
+      sv_ast_t *mem = mk(N_MEMBER);
+      mem->left = n;
+      if (TOK == TOK_HASH) {
+        CONSUME();
+        NEXT();
+        if (!is_ident_like_tok(TOK)) {
+          SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "private field name expected");
+          return mk(N_EMPTY);
+        }
+        mem->right = mk_private_ident_from_tok(p);
+        CONSUME();
+      } else {
+        mem->right = mk_ident_from_tok(p);
+        CONSUME();
+      }
+      n = mem;
+    } else if (la == TOK_LBRACKET) {
+      CONSUME();
+      sv_ast_t *mem = mk(N_MEMBER);
+      mem->left = n;
+      mem->right = parse_expr(p);
+      mem->flags = 1;
+      expect(p, TOK_RBRACKET);
+      n = mem;
+    } else if (la == TOK_OPTIONAL_CHAIN) {
+      CONSUME();
+      sv_ast_t *opt = mk(N_OPTIONAL);
+      opt->left = n;
+      if (NEXT() == TOK_LBRACKET) {
+        CONSUME();
+        opt->right = parse_expr(p);
+        opt->flags = 1;
+        expect(p, TOK_RBRACKET);
+      } else if (TOK == TOK_LPAREN) {
+        sv_ast_t *call = mk(N_CALL);
+        call->left = opt;
+        CONSUME();
+        while (NEXT() != TOK_RPAREN && TOK != TOK_EOF) {
+          sv_ast_list_push(&call->args, parse_assign(p));
+          if (NEXT() == TOK_COMMA) CONSUME();
+          else break;
+        }
+        expect(p, TOK_RPAREN);
+        n = call;
+        continue;
+      } else if (TOK == TOK_HASH) {
+        CONSUME();
+        NEXT();
+        if (!is_ident_like_tok(TOK)) {
+          SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "private field name expected");
+          return mk(N_EMPTY);
+        }
+        opt->right = mk_private_ident_from_tok(p);
+        CONSUME();
+      } else {
+        opt->right = mk_ident_from_tok(p);
+        CONSUME();
+      }
+      n = opt;
+    } else if (la == TOK_TEMPLATE) {
+      sv_ast_t *tagged = mk(N_TAGGED_TEMPLATE);
+      tagged->left = n;
+      tagged->right = parse_primary(p);
+      n = tagged;
+    } else break;
+  }
+  return n;
+}
+
+static sv_ast_t *parse_postfix(P) {
+  sv_ast_t *n = parse_call(p);
+  uint8_t la = NEXT();
+  if ((la == TOK_POSTINC || la == TOK_POSTDEC) && !HAD_NEWLINE) {
+    if (sv_is_strict_restricted_assign_target(p, n)) {
+      SV_MKERR_TYPED(
+        JS, JS_ERR_SYNTAX,
+        "cannot modify eval or arguments in strict mode");
+      return mk(N_EMPTY);
+    }
+    CONSUME();
+    sv_ast_t *u = mk(N_UPDATE);
+    u->op = la;
+    u->right = n;
+    return u;
+  }
+  return n;
+}
+
+static sv_ast_t *parse_unary(P) {
+  uint8_t la = NEXT();
+  if (la == TOK_NOT || la == TOK_TILDA ||
+      la == TOK_UPLUS || la == TOK_UMINUS ||
+      la == TOK_PLUS || la == TOK_MINUS) {
+    CONSUME();
+    sv_ast_t *n = mk(N_UNARY);
+    n->op = (la == TOK_PLUS) ? TOK_UPLUS :
+            (la == TOK_MINUS) ? TOK_UMINUS : la;
+    n->right = parse_unary(p);
+    if (NEXT() == TOK_EXP) {
+      SV_MKERR_TYPED(
+        JS, JS_ERR_SYNTAX,
+       "Unary operator used immediately before exponentiation expression. "
+       "Parenthesis must be used to disambiguate operator precedence");
+      return mk(N_EMPTY);
+    }
+    return n;
+  }
+  if (la == TOK_POSTINC || la == TOK_POSTDEC) {
+    CONSUME();
+    sv_ast_t *target = parse_unary(p);
+    if (sv_is_strict_restricted_assign_target(p, target)) {
+      SV_MKERR_TYPED(
+        JS, JS_ERR_SYNTAX,
+        "cannot modify eval or arguments in strict mode");
+      return mk(N_EMPTY);
+    }
+    sv_ast_t *n = mk(N_UPDATE);
+    n->op = la;
+    n->right = target;
+    n->flags = 1;
+    return n;
+  }
+  return parse_postfix(p);
+}
+
+static sv_ast_t *parse_binary(P, int min_prec) {
+  sv_ast_t *left = parse_unary(p);
+
+  for (;;) {
+    uint8_t op = NEXT();
+    if (op >= TOK_MAX) break;
+    if (op == TOK_IN && p->no_in) break;
+    int prec = prec_table[op];
+    if (prec == 0 || prec < min_prec) break;
+    CONSUME();
+    int next_prec = (op == TOK_EXP) ? prec : prec + 1;
+    sv_ast_t *right = parse_binary(p, next_prec);
+    sv_ast_t *bin = mk(N_BINARY);
+    bin->op = op;
+    bin->left = left;
+    bin->right = right;
+    left = bin;
+  }
+  return left;
+}
+
+static sv_ast_t *parse_ternary(P) {
+  sv_ast_t *cond = parse_binary(p, 1);
+  if (NEXT() == TOK_Q) {
+    CONSUME();
+    sv_ast_t *n = mk(N_TERNARY);
+    n->cond = cond;
+    n->left = parse_assign(p);
+    expect(p, TOK_COLON);
+    n->right = parse_assign(p);
+    return n;
+  }
+  return cond;
+}
+
+static bool is_assign_op(uint8_t tok) {
+  return tok >= TOK_ASSIGN && tok <= TOK_NULLISH_ASSIGN;
+}
+
+static sv_ast_t *parse_assign(P) {
+  sv_ast_t *left = parse_ternary(p);
+  uint8_t op = NEXT();
+  if (is_assign_op(op)) {
+    if (left->type == N_NEW_TARGET) {
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Invalid left-hand side in assignment");
+      return mk(N_EMPTY);
+    }
+    if ((left->flags & FN_PAREN) && op == TOK_ASSIGN &&
+        (left->type == N_OBJECT || left->type == N_OBJECT_PAT ||
+         left->type == N_ARRAY || left->type == N_ARRAY_PAT)) {
+      SV_MKERR_TYPED(
+        JS, JS_ERR_SYNTAX,
+        "Invalid destructuring assignment target");
+      return mk(N_EMPTY);
+    }
+    if (sv_is_strict_restricted_assign_target(p, left)) {
+      SV_MKERR_TYPED(
+        JS, JS_ERR_SYNTAX,
+        "cannot modify eval or arguments in strict mode");
+      return mk(N_EMPTY);
+    }
+    CONSUME();
+    sv_ast_t *n = mk(N_ASSIGN);
+    n->op = op;
+    n->left = left;
+    n->right = parse_assign(p);
+    return n;
+  }
+  return left;
+}
+
+static sv_ast_t *parse_expr(P) {
+  sv_ast_t *left = parse_assign(p);
+  while (NEXT() == TOK_COMMA) {
+    CONSUME();
+    sv_ast_t *n = mk(N_SEQUENCE);
+    n->left = left;
+    n->right = parse_assign(p);
+    left = n;
+  }
+  return left;
+}
+
+bool ast_references_arguments(const sv_ast_t *node) {
+  if (!node) return false;
+  if (node->type == N_IDENT && node->len == 9 && memcmp(node->str, "arguments", 9) == 0)
+    return true;
+    
+  if (node->type == N_FUNC && !(node->flags & FN_ARROW)) {
+    for (int i = 0; i < node->args.count; i++)
+      if (ast_references_arguments(node->args.items[i])) return true;
+    return false;
+  }
+  
+  if (ast_references_arguments(node->left))            return true;
+  if (ast_references_arguments(node->right))           return true;
+  if (ast_references_arguments(node->body))            return true;
+  if (ast_references_arguments(node->catch_body))      return true;
+  if (ast_references_arguments(node->finally_body))    return true;
+  for (int i = 0; i < node->args.count; i++)
+    if (ast_references_arguments(node->args.items[i])) return true;
+    
+  return false;
+}
+
+static sv_ast_t *parse_func(P) {
+  sv_ast_t *fn = mk(N_FUNC);
+
+  if (NEXT() == TOK_MUL) {
+    CONSUME();
+    fn->flags |= FN_GENERATOR;
+  }
+
+  if (NEXT() == TOK_IDENTIFIER) {
+    fn->str = tok_ident_str(p, &fn->len);
+    sv_strict_check_binding_ident(p, fn->str, fn->len);
+    CONSUME();
+  }
+
+  expect(p, TOK_LPAREN);
+  while (NEXT() != TOK_RPAREN && TOK != TOK_EOF) {
+    if (TOK == TOK_REST) {
+      CONSUME();
+      sv_ast_t *rest = mk(N_REST);
+      rest->right = parse_binding_pattern(p);
+      sv_ast_list_push(&fn->args, rest);
+      break;
+    }
+    sv_ast_t *param = parse_binding_pattern(p);
+    if (NEXT() == TOK_ASSIGN) {
+      CONSUME();
+      sv_ast_t *def = mk(N_ASSIGN_PAT);
+      def->left = param;
+      def->right = parse_assign(p);
+      param = def;
+    }
+    sv_ast_list_push(&fn->args, param);
+    if (NEXT() == TOK_COMMA) {
+      CONSUME();
+      if (NEXT() == TOK_RPAREN) break;
+    } else break;
+  }
+  expect(p, TOK_RPAREN);
+
+  fn->body = parse_block(p, true);
+  fn->src_end = (uint32_t)(TOFF + TLEN);
+  if (!(fn->flags & FN_ARROW) && ast_references_arguments(fn->body))
+    fn->flags |= FN_USES_ARGS;
+  return fn;
+}
+
+static sv_ast_t *parse_class(P) {
+  sv_ast_t *cls = mk(N_CLASS);
+
+  if (NEXT() == TOK_IDENTIFIER &&
+      !(TLEN == 7 && memcmp(tok_str(p), "extends", 7) == 0)) {
+    cls->str = tok_ident_str(p, &cls->len);
+    CONSUME();
+  }
+
+  if (NEXT() == TOK_IDENTIFIER && TLEN == 7 && memcmp(tok_str(p), "extends", 7) == 0) {
+    CONSUME();
+    cls->left = parse_assign(p);
+  }
+
+  expect(p, TOK_LBRACE);
+  while (NEXT() != TOK_RBRACE && TOK != TOK_EOF) {
+    if (TOK == TOK_SEMICOLON) { CONSUME(); continue; }
+
+    uint8_t flags = 0;
+
+    if (TOK == TOK_STATIC) {
+      flags |= FN_STATIC;
+      CONSUME();
+      NEXT();
+
+      if (TOK == TOK_LBRACE) {
+        sv_ast_t *block = parse_block(p, false);
+        block->type = N_STATIC_BLOCK;
+        block->flags = FN_STATIC;
+        sv_ast_list_push(&cls->args, block);
+        continue;
+      }
+    }
+
+    sv_ast_t *method = mk(N_METHOD);
+    uint32_t method_src_off = (uint32_t)TOFF;
+
+    if (TOK == TOK_ASYNC && LA() != TOK_LPAREN) {
+      flags |= FN_ASYNC;
+      CONSUME();
+      NEXT();
+    }
+
+    if (TOK == TOK_MUL) {
+      flags |= FN_GENERATOR;
+      CONSUME();
+      NEXT();
+    }
+
+    if ((TLEN == 3 && memcmp(tok_str(p), "get", 3) == 0) ||
+        (TLEN == 3 && memcmp(tok_str(p), "set", 3) == 0)) {
+      uint8_t la = LA();
+      if (la != TOK_LPAREN) {
+        flags |= (tok_str(p)[0] == 'g') ? FN_GETTER : FN_SETTER;
+        CONSUME();
+        NEXT();
+      }
+    }
+
+    if (TOK == TOK_LBRACKET) {
+      CONSUME();
+      method->left = parse_assign(p);
+      expect(p, TOK_RBRACKET);
+      flags |= FN_COMPUTED;
+    } else if (TOK == TOK_HASH) {
+      CONSUME();
+      NEXT();
+      if (!is_ident_like_tok(TOK)) {
+        SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "private field name expected");
+        return mk(N_EMPTY);
+      }
+      method->left = mk_private_ident_from_tok(p);
+      CONSUME();
+    } else {
+      method->left = mk_ident_from_tok(p);
+      CONSUME();
+    }
+
+    method->flags = flags;
+
+    if (NEXT() == TOK_LPAREN) {
+      method->right = parse_func(p);
+      method->right->flags |= (flags & (FN_ASYNC | FN_GENERATOR)) | FN_METHOD;
+      method->right->src_off = method_src_off;
+    } else if (TOK == TOK_ASSIGN) {
+      CONSUME();
+      method->right = parse_assign(p);
+      if (NEXT() == TOK_SEMICOLON) CONSUME();
+    } else {
+      method->right = mk(N_UNDEF);
+      if (TOK == TOK_SEMICOLON) CONSUME();
+    }
+
+    sv_ast_list_push(&cls->args, method);
+  }
+  expect(p, TOK_RBRACE);
+  return cls;
+}
+
+static sv_ast_t *parse_block(P, bool directive_ctx) {
+  expect(p, TOK_LBRACE);
+  sv_ast_t *block = mk(N_BLOCK);
+  sv_parse_stmt_list(p, &block->args, true, directive_ctx);
+  if (JS->thrown_exists) return block;
+  expect(p, TOK_RBRACE);
+  return block;
+}
+
+static sv_ast_t *parse_var_decl(P, sv_var_kind_t kind, bool allow_uninit_const) {
+  sv_ast_t *var = mk(N_VAR);
+  var->var_kind = kind;
+
+  do {
+    NEXT();
+    sv_ast_t *decl = mk(N_VARDECL);
+
+    if (TOK == TOK_LBRACKET) {
+      decl->left = parse_array(p);
+    } else if (TOK == TOK_LBRACE) {
+      decl->left = parse_object(p);
+    } else if (TOK == TOK_ERR) {
+      sv_parse_unexpected_token(p);
+      return var;
+    } else {
+      decl->left = mk_ident_from_tok(p);
+      sv_strict_check_binding_ident(p, decl->left->str, decl->left->len);
+      CONSUME();
+    }
+
+    if (NEXT() == TOK_ASSIGN) {
+      CONSUME();
+      decl->right = parse_assign(p);
+    } else if (kind == VAR_CONST && !allow_uninit_const) {
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Missing initializer in const declaration");
+    }
+    sv_ast_list_push(&var->args, decl);
+  } while (NEXT() == TOK_COMMA && (CONSUME(), 1));
+
+  return var;
+}
+
+static sv_ast_t *skip_import_stmt(P) {
+  while (NEXT() != TOK_SEMICOLON && TOK != TOK_EOF) CONSUME();
+  if (TOK == TOK_SEMICOLON) CONSUME();
+  return mk(N_EMPTY);
+}
+
+enum {
+  IMPORT_BIND_DEFAULT   = 1 << 0,
+  IMPORT_BIND_NAMESPACE = 1 << 1,
+};
+
+static inline void import_decl_add_binding(
+  sv_ast_t *decl,
+  const char *import_name, uint32_t import_len,
+  const char *local_name, uint32_t local_len,
+  uint8_t flags
+) {
+  sv_ast_t *spec = mk_plain(N_IMPORT_SPEC);
+  spec->flags = flags;
+  if (import_name)
+    spec->left = mk_ident(import_name, import_len);
+  spec->right = mk_ident(local_name, local_len);
+  sv_ast_list_push(&decl->args, spec);
+}
+
+static sv_ast_t *parse_import_stmt(P) {
+  static const char default_name[] = "default";
+  sv_ast_t *decl = mk(N_IMPORT_DECL);
+
+  if (NEXT() == TOK_STRING) {
+    sv_ast_t *spec = mk(N_STRING);
+    sv_ast_set_string(spec, sv_lexer_str_literal(&p->lx));
+    CONSUME();
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    decl->right = spec;
+    return decl;
+  }
+
+  bool saw_clause = false;
+
+  if (is_ident_like_tok(NEXT())) {
+    saw_clause = true;
+    uint32_t local_len = 0;
+    const char *local_name = tok_ident_str(p, &local_len);
+    import_decl_add_binding(
+      decl,
+      default_name, (uint32_t)(sizeof(default_name) - 1),
+      local_name, local_len,
+      IMPORT_BIND_DEFAULT
+    );
+    CONSUME();
+    if (NEXT() == TOK_COMMA) CONSUME();
+    else goto parse_from;
+  }
+
+  if (NEXT() == TOK_MUL) {
+    saw_clause = true;
+    CONSUME();
+    expect(p, TOK_AS);
+    NEXT();
+    if (!is_ident_like_tok(TOK)) return skip_import_stmt(p);
+    uint32_t ns_len = 0;
+    const char *ns_name = tok_ident_str(p, &ns_len);
+    import_decl_add_binding(
+      decl,
+      NULL, 0,
+      ns_name, ns_len,
+      IMPORT_BIND_NAMESPACE
+    );
+    CONSUME();
+  } else if (NEXT() == TOK_LBRACE) {
+    saw_clause = true;
+    CONSUME();
+    while (NEXT() != TOK_RBRACE && TOK != TOK_EOF) {
+      const char *import_name;
+      uint32_t import_len;
+
+      if (TOK == TOK_STRING) {
+        sv_lex_string_t s = sv_lexer_str_literal(&p->lx);
+        import_name = s.str;
+        import_len = s.len;
+        CONSUME();
+      } else if (!(TOK >= TOK_IDENTIFIER && TOK < TOK_IDENT_LIKE_END)) {
+        CONSUME();
+        continue;
+      } else {
+        import_name = tok_ident_str(p, &import_len);
+        CONSUME();
+      }
+
+      const char *local_name = import_name;
+      uint32_t local_len = import_len;
+
+      if (NEXT() == TOK_AS) {
+        CONSUME();
+        NEXT();
+        if (!is_ident_like_tok(TOK)) return skip_import_stmt(p);
+        local_name = tok_ident_str(p, &local_len);
+        CONSUME();
+      }
+
+      import_decl_add_binding(decl, import_name, import_len, local_name, local_len, 0);
+
+      if (NEXT() == TOK_COMMA) {
+        CONSUME();
+        if (NEXT() == TOK_RBRACE) break;
+      }
+    }
+    expect(p, TOK_RBRACE);
+  }
+
+parse_from:
+  if (!saw_clause) return skip_import_stmt(p);
+  expect(p, TOK_FROM);
+  if (NEXT() != TOK_STRING) return skip_import_stmt(p);
+
+  sv_ast_t *spec = mk(N_STRING);
+  sv_ast_set_string(spec, sv_lexer_str_literal(&p->lx));
+  CONSUME();
+  decl->right = spec;
+
+  if (NEXT() == TOK_SEMICOLON) CONSUME();
+  return decl;
+}
+
+static sv_ast_t *parse_export_name(P) {
+  NEXT();
+  if (TOK == TOK_STRING) {
+    sv_lex_string_t s = sv_lexer_str_literal(&p->lx);
+    sv_ast_t *name = mk(N_IDENT);
+    name->str = s.str;
+    name->len = s.len;
+    CONSUME();
+    return name;
+  }
+
+  if (!(TOK >= TOK_IDENTIFIER && TOK < TOK_IDENT_LIKE_END)) {
+    sv_parse_unexpected_token(p);
+    return NULL;
+  }
+  sv_ast_t *name = mk_ident_from_tok(p);
+  CONSUME();
+  return name;
+}
+
+static sv_ast_t *parse_export_stmt(P) {
+  sv_ast_t *decl = mk(N_EXPORT);
+  NEXT();
+
+  if (TOK == TOK_DEFAULT) {
+    CONSUME();
+    decl->flags |= EX_DEFAULT;
+
+    if (NEXT() == TOK_ASYNC && LA() == TOK_FUNC) {
+      uint32_t async_off = (uint32_t)TOFF;
+      CONSUME();
+      NEXT(); CONSUME();
+      decl->left = parse_func(p);
+      decl->left->flags |= FN_ASYNC;
+      decl->left->src_off = async_off;
+      if (NEXT() == TOK_SEMICOLON) CONSUME();
+      return decl;
+    }
+    if (TOK == TOK_FUNC) {
+      CONSUME();
+      decl->left = parse_func(p);
+      if (NEXT() == TOK_SEMICOLON) CONSUME();
+      return decl;
+    }
+    if (TOK == TOK_CLASS) {
+      CONSUME();
+      decl->left = parse_class(p);
+      if (NEXT() == TOK_SEMICOLON) CONSUME();
+      return decl;
+    }
+
+    decl->left = parse_assign(p);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return decl;
+  }
+
+  if (TOK == TOK_ASYNC && LA() == TOK_FUNC) {
+    decl->flags |= EX_DECL;
+    uint32_t async_off = (uint32_t)TOFF;
+    CONSUME();
+    NEXT(); CONSUME();
+    decl->left = parse_func(p);
+    decl->left->flags |= FN_ASYNC;
+    decl->left->src_off = async_off;
+    if (!decl->left->str || decl->left->len == 0)
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "exported function declarations require a name");
+    return decl;
+  }
+
+  if (TOK == TOK_FUNC) {
+    decl->flags |= EX_DECL;
+    CONSUME();
+    decl->left = parse_func(p);
+    if (!decl->left->str || decl->left->len == 0)
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "exported function declarations require a name");
+    return decl;
+  }
+  if (TOK == TOK_CLASS) {
+    decl->flags |= EX_DECL;
+    CONSUME();
+    decl->left = parse_class(p);
+    if (!decl->left->str || decl->left->len == 0)
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "exported class declarations require a name");
+    return decl;
+  }
+
+  if (TOK == TOK_VAR || TOK == TOK_LET || TOK == TOK_CONST) {
+    decl->flags |= EX_DECL;
+    sv_var_kind_t kind = (
+      TOK == TOK_VAR) ? VAR_VAR :
+      (TOK == TOK_LET) ? VAR_LET : VAR_CONST;
+    CONSUME();
+    decl->left = parse_var_decl(p, kind, false);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return decl;
+  }
+
+  if (TOK == TOK_LBRACE) {
+    decl->flags |= EX_NAMED;
+    CONSUME();
+    while (NEXT() != TOK_RBRACE && TOK != TOK_EOF) {
+      sv_ast_t *local_name = parse_export_name(p);
+      if (!local_name) return decl;
+
+      sv_ast_t *export_name = local_name;
+      if (NEXT() == TOK_AS) {
+        CONSUME();
+        export_name = parse_export_name(p);
+        if (!export_name) return decl;
+      }
+
+      sv_ast_t *spec = mk(N_IMPORT_SPEC);
+      spec->left = local_name;
+      spec->right = export_name;
+      sv_ast_list_push(&decl->args, spec);
+
+      if (NEXT() == TOK_COMMA) {
+        CONSUME();
+        if (NEXT() == TOK_RBRACE) break;
+      } else {
+        break;
+      }
+    }
+    expect(p, TOK_RBRACE);
+
+    if (NEXT() == TOK_FROM) {
+      CONSUME();
+      if (NEXT() != TOK_STRING) {
+        sv_parse_unexpected_token(p);
+        return decl;
+      }
+      sv_ast_t *spec = mk(N_STRING);
+      sv_ast_set_string(spec, sv_lexer_str_literal(&p->lx));
+      decl->right = spec;
+      decl->flags |= EX_FROM;
+      CONSUME();
+    }
+
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return decl;
+  }
+
+  if (TOK == TOK_MUL) {
+    decl->flags |= EX_STAR;
+    CONSUME();
+
+    if (NEXT() == TOK_AS) {
+      decl->flags |= EX_NAMESPACE;
+      CONSUME();
+
+      sv_ast_t *name = parse_export_name(p);
+      if (!name) return decl;
+
+      sv_ast_t *spec = mk(N_IMPORT_SPEC);
+      spec->right = name;
+      sv_ast_list_push(&decl->args, spec);
+    }
+
+    expect(p, TOK_FROM);
+    if (NEXT() != TOK_STRING) {
+      sv_parse_unexpected_token(p);
+      return decl;
+    }
+    sv_ast_t *spec = mk(N_STRING);
+    sv_ast_set_string(spec, sv_lexer_str_literal(&p->lx));
+    decl->right = spec;
+    decl->flags |= EX_FROM;
+    CONSUME();
+
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return decl;
+  }
+
+  sv_parse_unexpected_token(p);
+  return decl;
+}
+
+static sv_ast_t *parse_stmt(P) {
+  NEXT();
+
+  static const void *dispatch[TOK_MAX] = {
+    [TOK_SEMICOLON] = &&l_semi,
+    [TOK_LBRACE]    = &&l_block,
+    [TOK_VAR]       = &&l_var,
+    [TOK_LET]       = &&l_let,
+    [TOK_CONST]     = &&l_const,
+    [TOK_IF]        = &&l_if,
+    [TOK_WHILE]     = &&l_while,
+    [TOK_DO]        = &&l_do,
+    [TOK_FOR]       = &&l_for,
+    [TOK_RETURN]    = &&l_return,
+    [TOK_THROW]     = &&l_throw,
+    [TOK_BREAK]     = &&l_break,
+    [TOK_CONTINUE]  = &&l_continue,
+    [TOK_TRY]       = &&l_try,
+    [TOK_SWITCH]    = &&l_switch,
+    [TOK_DEBUGGER]  = &&l_debugger,
+    [TOK_WITH]      = &&l_with,
+    [TOK_FUNC]      = &&l_func,
+    [TOK_CLASS]     = &&l_class,
+    [TOK_ASYNC]     = &&l_async,
+    [TOK_EXPORT]    = &&l_export,
+    [TOK_IMPORT]    = &&l_import,
+  };
+
+  if (TOK < TOK_MAX && dispatch[TOK])
+    goto *dispatch[TOK];
+  goto l_expr_stmt;
+
+  l_semi:  { CONSUME(); return mk(N_EMPTY); }
+  l_block: return parse_block(p, false);
+
+  l_var: {
+    CONSUME();
+    sv_ast_t *n = parse_var_decl(p, VAR_VAR, false);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+  l_let: {
+    CONSUME();
+    sv_ast_t *n = parse_var_decl(p, VAR_LET, false);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+  l_const: {
+    CONSUME();
+    sv_ast_t *n = parse_var_decl(p, VAR_CONST, false);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+
+  l_if: {
+    CONSUME();
+    sv_ast_t *n = mk(N_IF);
+    expect(p, TOK_LPAREN);
+    n->cond = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    n->left = parse_stmt(p);
+    if (NEXT() == TOK_ELSE) {
+      CONSUME();
+      n->right = parse_stmt(p);
+    }
+    return n;
+  }
+
+  l_while: {
+    CONSUME();
+    sv_ast_t *n = mk(N_WHILE);
+    expect(p, TOK_LPAREN);
+    n->cond = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    n->body = parse_stmt(p);
+    return n;
+  }
+
+  l_do: {
+    CONSUME();
+    sv_ast_t *n = mk(N_DO_WHILE);
+    n->body = parse_stmt(p);
+    expect(p, TOK_WHILE);
+    expect(p, TOK_LPAREN);
+    n->cond = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+
+  l_for: {
+    CONSUME();
+    bool is_for_await = false;
+    if (NEXT() == TOK_AWAIT) {
+      CONSUME();
+      is_for_await = true;
+    }
+    expect(p, TOK_LPAREN);
+    sv_ast_t *init_node = NULL;
+
+    NEXT();
+    if (TOK == TOK_VAR || TOK == TOK_LET || TOK == TOK_CONST) {
+      sv_var_kind_t kind = (
+        TOK == TOK_VAR) ? VAR_VAR :
+        (TOK == TOK_LET) ? VAR_LET : VAR_CONST;
+      CONSUME();
+      p->no_in = true;
+      init_node = parse_var_decl(p, kind, true);
+      p->no_in = false;
+    } else if (TOK != TOK_SEMICOLON) {
+      p->no_in = true;
+      init_node = parse_expr(p);
+      p->no_in = false;
+    }
+
+    uint8_t la = NEXT();
+    if (la == TOK_IN) {
+      CONSUME();
+      sv_ast_t *n = mk(N_FOR_IN);
+      n->left = init_node;
+      n->right = parse_expr(p);
+      expect(p, TOK_RPAREN);
+      n->body = parse_stmt(p);
+      return n;
+    }
+    if (la == TOK_OF || (la == TOK_IDENTIFIER && TLEN == 2 &&
+        memcmp(tok_str(p), "of", 2) == 0)) {
+      CONSUME();
+      sv_ast_t *n = mk(is_for_await ? N_FOR_AWAIT_OF : N_FOR_OF);
+      n->left = init_node;
+      n->right = parse_assign(p);
+      expect(p, TOK_RPAREN);
+      n->body = parse_stmt(p);
+      return n;
+    }
+
+    if (init_node && init_node->type == N_VAR && init_node->var_kind == VAR_CONST) {
+      for (int i = 0; i < init_node->args.count; i++) {
+        sv_ast_t *decl = init_node->args.items[i];
+        if (decl && decl->type == N_VARDECL && !decl->right) {
+          SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "Missing initializer in const declaration");
+          return mk(N_EMPTY);
+        }
+      }
+    }
+
+    sv_ast_t *n = mk(N_FOR);
+    n->init = init_node;
+    expect(p, TOK_SEMICOLON);
+    if (NEXT() != TOK_SEMICOLON)
+      n->cond = parse_expr(p);
+    expect(p, TOK_SEMICOLON);
+    if (NEXT() != TOK_RPAREN)
+      n->update = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    n->body = parse_stmt(p);
+    return n;
+  }
+
+  l_return: {
+    CONSUME();
+    sv_ast_t *n = mk(N_RETURN);
+    if (NEXT() != TOK_SEMICOLON && TOK != TOK_RBRACE && TOK != TOK_EOF &&
+        !HAD_NEWLINE)
+      n->right = parse_expr(p);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+
+  l_throw: {
+    CONSUME();
+    sv_ast_t *n = mk(N_THROW);
+    n->right = parse_expr(p);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+
+  l_break: {
+    CONSUME();
+    sv_ast_t *n = mk(N_BREAK);
+    if (NEXT() == TOK_IDENTIFIER && !HAD_NEWLINE) {
+      n->str = tok_ident_str(p, &n->len);
+      CONSUME();
+    }
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+
+  l_continue: {
+    CONSUME();
+    sv_ast_t *n = mk(N_CONTINUE);
+    if (NEXT() == TOK_IDENTIFIER && !HAD_NEWLINE) {
+      n->str = tok_ident_str(p, &n->len);
+      CONSUME();
+    }
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return n;
+  }
+
+  l_try: {
+    CONSUME();
+    sv_ast_t *n = mk(N_TRY);
+    n->body = parse_block(p, false);
+    if (NEXT() == TOK_CATCH) {
+      CONSUME();
+      if (NEXT() == TOK_LPAREN) {
+        CONSUME();
+        n->catch_param = parse_binding_pattern(p);
+        if (n->catch_param->type == N_IDENT)
+          sv_strict_check_binding_ident(p, n->catch_param->str, n->catch_param->len);
+        expect(p, TOK_RPAREN);
+      }
+      n->catch_body = parse_block(p, false);
+    }
+    if (NEXT() == TOK_FINALLY) {
+      CONSUME();
+      n->finally_body = parse_block(p, false);
+    }
+    return n;
+  }
+
+  l_switch: {
+    CONSUME();
+    sv_ast_t *n = mk(N_SWITCH);
+    expect(p, TOK_LPAREN);
+    n->cond = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    expect(p, TOK_LBRACE);
+    while (NEXT() != TOK_RBRACE && TOK != TOK_EOF) {
+      sv_ast_t *c = mk(N_CASE);
+      if (TOK == TOK_CASE) {
+        CONSUME();
+        c->left = parse_expr(p);
+      } else if (TOK == TOK_DEFAULT) {
+        CONSUME();
+      }
+      expect(p, TOK_COLON);
+      while (NEXT() != TOK_CASE && TOK != TOK_DEFAULT &&
+             TOK != TOK_RBRACE && TOK != TOK_EOF)
+        sv_ast_list_push(&c->args, parse_stmt(p));
+      sv_ast_list_push(&n->args, c);
+    }
+    expect(p, TOK_RBRACE);
+    return n;
+  }
+
+  l_debugger: { CONSUME(); if (NEXT() == TOK_SEMICOLON) CONSUME(); return mk(N_DEBUGGER); }
+
+  l_with: {
+    if (p->lx.strict) {
+      SV_MKERR_TYPED(JS, JS_ERR_SYNTAX, "with statement not allowed in strict mode");
+      return mk(N_EMPTY);
+    }
+    CONSUME();
+    sv_ast_t *n = mk(N_WITH);
+    expect(p, TOK_LPAREN);
+    n->left = parse_expr(p);
+    expect(p, TOK_RPAREN);
+    n->body = parse_stmt(p);
+    return n;
+  }
+
+  l_func: {
+    CONSUME();
+    return parse_func(p);
+  }
+
+  l_class: {
+    CONSUME();
+    return parse_class(p);
+  }
+
+  l_async: {
+    uint8_t la = LA();
+    uint32_t async_off = (uint32_t)TOFF;
+    if (la == TOK_FUNC) {
+      CONSUME();
+      NEXT(); CONSUME();
+      sv_ast_t *fn = parse_func(p);
+      fn->flags |= FN_ASYNC;
+      fn->src_off = async_off;
+      return fn;
+    }
+    goto l_expr_stmt;
+  }
+
+  l_import: {
+    CONSUME();
+    return parse_import_stmt(p);
+  }
+
+  l_export: {
+    CONSUME();
+    return parse_export_stmt(p);
+  }
+
+  l_expr_stmt: {
+    if (TOK == TOK_IDENTIFIER) {
+      uint8_t la = LA();
+      if (la == TOK_COLON) {
+        sv_ast_t *label = mk(N_LABEL);
+        label->str = tok_ident_str(p, &label->len);
+        CONSUME();
+        NEXT(); CONSUME();
+        label->body = parse_stmt(p);
+        return label;
+      }
+    }
+
+    sv_ast_t *expr = parse_expr(p);
+    if (NEXT() == TOK_SEMICOLON) CONSUME();
+    return expr;
+  }
+}
+
+sv_ast_t *sv_parse(ant_t *js, const char *code, jsoff_t clen, bool strict){
+  sv_parser_t parser = { .js = js };
+  sv_parser_t *p = &parser;
+  sv_lexer_init(&p->lx, js, code, clen, strict);
+
+  sv_ast_t *program = mk(N_PROGRAM);
+  sv_parse_stmt_list(p, &program->args, false, true);
+  if (js->thrown_exists) return NULL;
+  if (p->lx.strict) program->flags |= FN_PARSE_STRICT;
+
+  return program;
+}
diff --git a/src/silver/compiler.c b/src/silver/compiler.c
new file mode 100644
index 0000000..f5a2270
--- /dev/null
+++ b/src/silver/compiler.c
@@ -0,0 +1,4219 @@
+#include "silver/ast.h"
+#include "silver/engine.h"
+#include "silver/compiler.h"
+#include "silver/directives.h"
+
+#include "internal.h"
+#include "tokens.h"
+#include "runtime.h"
+#include "ops/coercion.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+  const char *name;
+  uint32_t name_len;
+  int  depth;
+  bool is_const;
+  bool captured;
+  bool is_tdz;
+} sv_local_t;
+
+typedef struct {
+  int *offsets;
+  int  count;
+  int  cap;
+} sv_patch_list_t;
+
+typedef struct {
+  int loop_start;
+  sv_patch_list_t breaks;
+  sv_patch_list_t continues;
+  int scope_depth;
+  const char *label;
+  uint32_t label_len;
+} sv_loop_t;
+
+typedef struct {
+  const char *name;
+  uint32_t len;
+} sv_deferred_export_t;
+
+typedef struct sv_compiler {
+  ant_t *js;
+  const char *source;
+  jsoff_t source_len;
+
+  uint8_t *code;
+  int code_len;
+  int code_cap;
+
+  jsval_t *constants;
+  int const_count;
+  int const_cap;
+
+  sv_atom_t *atoms;
+  int atom_count;
+  int atom_cap;
+
+  sv_local_t *locals;
+  int local_count;
+  int local_cap;
+  int max_local_count;
+  int scope_depth;
+  int param_locals;
+
+  sv_upval_desc_t *upval_descs;
+  int upvalue_count;
+  int upvalue_cap;
+
+  sv_loop_t *loops;
+  int loop_count;
+  int loop_cap;
+
+  struct sv_compiler *enclosing;
+  sv_ast_t **field_inits;
+  
+  int field_init_count;
+  int *computed_key_locals;
+  int param_count;
+  
+  bool is_arrow;
+  bool is_strict;
+  sv_compile_mode_t mode;
+  
+  bool is_tla;
+  int try_depth;
+  int with_depth;
+  int strict_args_local;
+  int new_target_local;
+  int super_local;
+
+  const char *pending_label;
+  uint32_t pending_label_len;
+
+  const char *inferred_name;
+  uint32_t inferred_name_len;
+
+  sv_srcpos_t *srcpos;
+  int srcpos_count;
+  int srcpos_cap;
+  uint32_t last_srcpos_off;
+  uint32_t last_srcpos_end;
+
+  sv_deferred_export_t *deferred_exports;
+  int deferred_export_count;
+  int deferred_export_cap;
+} sv_compiler_t;
+
+static sv_func_t *compile_function_body(
+  sv_compiler_t *enclosing,
+  sv_ast_t *node, sv_compile_mode_t mode
+);
+
+static void compile_expr(sv_compiler_t *c, sv_ast_t *node);
+static void compile_stmt(sv_compiler_t *c, sv_ast_t *node);
+static void compile_stmts(sv_compiler_t *c, sv_ast_list_t *list);
+static void compile_binary(sv_compiler_t *c, sv_ast_t *node);
+static void compile_unary(sv_compiler_t *c, sv_ast_t *node);
+static void compile_update(sv_compiler_t *c, sv_ast_t *node);
+static void compile_assign(sv_compiler_t *c, sv_ast_t *node);
+static void compile_lhs_set(sv_compiler_t *c, sv_ast_t *target, bool keep);
+static void compile_ternary(sv_compiler_t *c, sv_ast_t *node);
+static void compile_tail_return_expr(sv_compiler_t *c, sv_ast_t *expr);
+static void compile_typeof(sv_compiler_t *c, sv_ast_t *node);
+static void compile_delete(sv_compiler_t *c, sv_ast_t *node);
+static void compile_template(sv_compiler_t *c, sv_ast_t *node);
+static void compile_call(sv_compiler_t *c, sv_ast_t *node);
+static void compile_new(sv_compiler_t *c, sv_ast_t *node);
+static void compile_member(sv_compiler_t *c, sv_ast_t *node);
+static void compile_optional(sv_compiler_t *c, sv_ast_t *node);
+static void compile_optional_get(sv_compiler_t *c, sv_ast_t *node);
+static void compile_array(sv_compiler_t *c, sv_ast_t *node);
+static void compile_object(sv_compiler_t *c, sv_ast_t *node);
+static void compile_func_expr(sv_compiler_t *c, sv_ast_t *node);
+static void compile_array_destructure(sv_compiler_t *c, sv_ast_t *pat, bool keep);
+static void compile_object_destructure(sv_compiler_t *c, sv_ast_t *pat, bool keep);
+static void compile_var_decl(sv_compiler_t *c, sv_ast_t *node);
+static void compile_import_decl(sv_compiler_t *c, sv_ast_t *node);
+static void compile_export_decl(sv_compiler_t *c, sv_ast_t *node);
+static void compile_destructure_binding(sv_compiler_t *c, sv_ast_t *pat, sv_var_kind_t kind);
+static void compile_if(sv_compiler_t *c, sv_ast_t *node);
+static void compile_while(sv_compiler_t *c, sv_ast_t *node);
+static void compile_do_while(sv_compiler_t *c, sv_ast_t *node);
+static void compile_for(sv_compiler_t *c, sv_ast_t *node);
+static void compile_for_in(sv_compiler_t *c, sv_ast_t *node);
+static void compile_for_of(sv_compiler_t *c, sv_ast_t *node);
+static void compile_break(sv_compiler_t *c, sv_ast_t *node);
+static void compile_continue(sv_compiler_t *c, sv_ast_t *node);
+static void compile_try(sv_compiler_t *c, sv_ast_t *node);
+static void compile_switch(sv_compiler_t *c, sv_ast_t *node);
+static void compile_label(sv_compiler_t *c, sv_ast_t *node);
+static void compile_class(sv_compiler_t *c, sv_ast_t *node);
+
+static const char *pin_source_text(const char *source, jsoff_t source_len) {
+  if (!source || source_len <= 0) return source;
+  const char *pinned = code_arena_alloc(source, (size_t)source_len);
+  return pinned ? pinned : source;
+}
+
+static void emit(sv_compiler_t *c, uint8_t byte) {
+  if (c->code_len >= c->code_cap) {
+    c->code_cap = c->code_cap ? c->code_cap * 2 : 256;
+    c->code = realloc(c->code, (size_t)c->code_cap);
+  }
+  c->code[c->code_len++] = byte;
+}
+
+static void emit_u16(sv_compiler_t *c, uint16_t val) {
+  emit(c, (uint8_t)(val & 0xFF));
+  emit(c, (uint8_t)(val >> 8));
+}
+
+static void emit_u32(sv_compiler_t *c, uint32_t val) {
+  emit(c, (uint8_t)(val & 0xFF));
+  emit(c, (uint8_t)((val >> 8) & 0xFF));
+  emit(c, (uint8_t)((val >> 16) & 0xFF));
+  emit(c, (uint8_t)((val >> 24) & 0xFF));
+}
+
+static void emit_i32(sv_compiler_t *c, int32_t val) {
+  uint32_t u;
+  memcpy(&u, &val, 4);
+  emit_u32(c, u);
+}
+
+static void emit_op(sv_compiler_t *c, sv_op_t op) {
+  emit(c, (uint8_t)op);
+}
+
+static void emit_srcpos(sv_compiler_t *c, sv_ast_t *node) {
+  if (!node) return;
+  const char *code = c->source;
+  jsoff_t clen = c->source_len;
+  if (!code || clen <= 0) return;
+
+  uint32_t off = node->src_off;
+  if (off > clen) off = (uint32_t)clen;
+  uint32_t end = node->src_end;
+  if (end > clen) end = (uint32_t)clen;
+  if (end < off) end = off;
+  if (end == off && off < (uint32_t)clen) end = off + 1;
+  if (end == off) return;
+
+  uint32_t line = 1, col = 1;
+  for (uint32_t i = 0; i < off; i++) {
+    if (code[i] == '\n') { line++; col = 1; }
+    else col++;
+  }
+  if (c->srcpos_count > 0 && c->last_srcpos_off == off && c->last_srcpos_end == end) return;
+  if (c->srcpos_count >= c->srcpos_cap) {
+    c->srcpos_cap = c->srcpos_cap ? c->srcpos_cap * 2 : 32;
+    c->srcpos = realloc(c->srcpos, (size_t)c->srcpos_cap * sizeof(sv_srcpos_t));
+  }
+  c->srcpos[c->srcpos_count++] = (sv_srcpos_t){
+    .bc_offset = (uint32_t)c->code_len,
+    .line = line,
+    .col = col,
+    .src_off = off,
+    .src_end = end,
+  };
+  c->last_srcpos_off = off;
+  c->last_srcpos_end = end;
+}
+
+static void patch_u32(sv_compiler_t *c, int offset, uint32_t val) {
+  c->code[offset]     = (uint8_t)(val & 0xFF);
+  c->code[offset + 1] = (uint8_t)((val >> 8) & 0xFF);
+  c->code[offset + 2] = (uint8_t)((val >> 16) & 0xFF);
+  c->code[offset + 3] = (uint8_t)((val >> 24) & 0xFF);
+}
+
+static int add_constant(sv_compiler_t *c, jsval_t val) {
+  if (c->const_count >= c->const_cap) {
+    c->const_cap = c->const_cap ? c->const_cap * 2 : 16;
+    c->constants = realloc(c->constants, (size_t)c->const_cap * sizeof(jsval_t));
+  }
+  c->constants[c->const_count] = val;
+  return c->const_count++;
+}
+
+static void emit_constant(sv_compiler_t *c, jsval_t val) {
+  int idx = add_constant(c, val);
+  if (idx <= 255) {
+    emit_op(c, OP_CONST8);
+    emit(c, (uint8_t)idx);
+  } else {
+    emit_op(c, OP_CONST);
+    emit_u32(c, (uint32_t)idx);
+  }
+}
+
+static void emit_number(sv_compiler_t *c, double num) {
+  if (num >= -128 && num <= 127 && num == (int)num && num != -0.0) {
+    emit_op(c, OP_CONST_I8);
+    emit(c, (uint8_t)(int8_t)num);
+  } else emit_constant(c, tov(num));
+}
+
+
+static inline bool is_quoted_ident_key(const sv_ast_t *node) {
+  if (!node || node->type != N_IDENT || !node->str || node->len < 2) return false;
+  char open = node->str[0];
+  char close = node->str[node->len - 1];
+  return ((open == '\'' && close == '\'') || (open == '"' && close == '"'));
+}
+
+static inline bool is_invalid_cooked_string(const sv_ast_t *node) {
+  return node && (node->flags & FN_INVALID_COOKED);
+}
+
+static inline jsval_t ast_string_const(sv_compiler_t *c, const sv_ast_t *node) {
+  if (!node || !node->str) return js_mkstr(c->js, "", 0);
+  return js_mkstr(c->js, node->str, node->len);
+}
+
+static inline void compile_static_property_key(sv_compiler_t *c, sv_ast_t *key) {
+  if (!key) {
+    emit_op(c, OP_UNDEF);
+    return;
+  }
+
+  if (key->type == N_STRING) {
+    emit_constant(c, ast_string_const(c, key));
+    return;
+  }
+
+  if (key->type == N_NUMBER) {
+    char buf[32];
+    int n = snprintf(buf, sizeof(buf), "%g", key->num);
+    emit_constant(c, js_mkstr(c->js, buf, (size_t)n));
+    return;
+  }
+
+  if (key->type == N_IDENT) {
+    if (is_quoted_ident_key(key))
+      emit_constant(c, js_mkstr(c->js, key->str + 1, key->len - 2));
+    else
+      emit_constant(c, js_mkstr(c->js, key->str, key->len));
+    return;
+  }
+
+  compile_expr(c, key);
+}
+
+static int add_atom(sv_compiler_t *c, const char *str, uint32_t len) {
+  for (int i = 0; i < c->atom_count; i++) {
+    if (c->atoms[i].len == len && memcmp(c->atoms[i].str, str, len) == 0)
+      return i;
+  }
+  if (c->atom_count >= c->atom_cap) {
+    c->atom_cap = c->atom_cap ? c->atom_cap * 2 : 16;
+    c->atoms = realloc(c->atoms, (size_t)c->atom_cap * sizeof(sv_atom_t));
+  }
+  char *copy = code_arena_bump(len);
+  memcpy(copy, str, len);
+  c->atoms[c->atom_count] = (sv_atom_t){ .str = copy, .len = len };
+  return c->atom_count++;
+}
+
+static void emit_atom_op(sv_compiler_t *c, sv_op_t op, const char *str, uint32_t len) {
+  int idx = add_atom(c, str, len);
+  emit_op(c, op);
+  emit_u32(c, (uint32_t)idx);
+}
+
+static inline void emit_set_function_name(
+  sv_compiler_t *c,
+  const char *name, uint32_t len
+) {
+  if (!name) { name = ""; len = 0; }
+  emit_atom_op(c, OP_SET_NAME, name, len);
+}
+
+static void emit_const_assign_error(sv_compiler_t *c, const char *name, uint32_t len) {
+  static const char prefix[] = "Assignment to constant variable '";
+  static const char suffix[] = "'";
+  
+  uint32_t mlen = (uint32_t)(sizeof(prefix) - 1 + len + sizeof(suffix) - 1);
+  char *buf = code_arena_bump(mlen);
+  
+  memcpy(buf, prefix, sizeof(prefix) - 1);
+  memcpy(buf + sizeof(prefix) - 1, name, len);
+  memcpy(buf + sizeof(prefix) - 1 + len, suffix, sizeof(suffix) - 1);
+  
+  int atom = add_atom(c, buf, mlen);
+  emit_op(c, OP_THROW_ERROR);
+  emit_u32(c, (uint32_t)atom);
+  emit(c, (uint8_t)JS_ERR_TYPE);
+}
+
+static inline bool is_ident_str(
+  const char *name, uint32_t len,
+  const char *lit, uint32_t lit_len
+) {
+  return len == lit_len && memcmp(name, lit, lit_len) == 0;
+}
+
+static inline bool is_strict_restricted_ident(const char *name, uint32_t len) {
+  return 
+    is_ident_str(name, len, "eval", 4) ||
+    is_ident_str(name, len, "arguments", 9);
+}
+
+static inline bool is_repl_top_level(const sv_compiler_t *c) {
+  return 
+    c->mode == SV_COMPILE_REPL && c->scope_depth == 0 &&
+    c->enclosing && !c->enclosing->enclosing &&
+    !c->is_strict;
+}
+
+static inline bool has_completion_value(const sv_compiler_t *c) {
+  return c && (c->mode == SV_COMPILE_EVAL || c->mode == SV_COMPILE_REPL);
+}
+
+static inline bool has_implicit_arguments_obj(const sv_compiler_t *c) {
+  return c && !c->is_arrow && c->enclosing;
+}
+
+static int resolve_local(sv_compiler_t *c, const char *name, uint32_t len) {
+  for (int i = c->local_count - 1; i >= 0; i--) {
+    sv_local_t *loc = &c->locals[i];
+    if (loc->name_len == len && memcmp(loc->name, name, len) == 0)
+      return i;
+  }
+  return -1;
+}
+
+static int add_local(
+  sv_compiler_t *c, const char *name, uint32_t len,
+  bool is_const, int depth
+) {
+  if (c->local_count >= c->local_cap) {
+    c->local_cap = c->local_cap ? c->local_cap * 2 : 16;
+    c->locals = realloc(c->locals, (size_t)c->local_cap * sizeof(sv_local_t));
+  }
+  int idx = c->local_count++;
+  if (c->local_count > c->max_local_count)
+    c->max_local_count = c->local_count;
+  c->locals[idx] = (sv_local_t){
+    .name = name, .name_len = len,
+    .depth = depth, .is_const = is_const, .captured = false,
+  };
+  return idx;
+}
+
+static int ensure_local_at_depth(
+  sv_compiler_t *c, const char *name, uint32_t len,
+  bool is_const, int depth
+) {
+  int local = resolve_local(c, name, len);
+  if (local != -1 && c->locals[local].depth == depth)
+    return local;
+  return add_local(c, name, len, is_const, depth);
+}
+
+static int local_to_frame_slot(sv_compiler_t *c, int local_idx) {
+  if (c->locals[local_idx].depth == -1) return local_idx;
+  return c->param_count + (local_idx - c->param_locals);
+}
+
+static int resolve_local_slot(sv_compiler_t *c, const char *name, uint32_t len) {
+  int local = resolve_local(c, name, len);
+  if (local == -1 || c->locals[local].depth == -1) return -1;
+  int slot = local - c->param_locals;
+  return (slot >= 0 && slot <= 255) ? slot : -1;
+}
+
+static int add_upvalue(sv_compiler_t *c, uint16_t index, bool is_local, bool is_const) {
+  for (int i = 0; i < c->upvalue_count; i++) {
+    if (c->upval_descs[i].index == index &&
+        c->upval_descs[i].is_local == is_local)
+      return i;
+  }
+  if (c->upvalue_count >= c->upvalue_cap) {
+    c->upvalue_cap = c->upvalue_cap ? c->upvalue_cap * 2 : 8;
+    c->upval_descs = realloc(
+      c->upval_descs,
+      (size_t)c->upvalue_cap * sizeof(sv_upval_desc_t));
+  }
+  int idx = c->upvalue_count++;
+  c->upval_descs[idx] = (sv_upval_desc_t){
+    .index = index, .is_local = is_local, .is_const = is_const,
+  };
+  return idx;
+}
+
+static int resolve_super_upvalue(sv_compiler_t *c) {
+  if (!c->enclosing) return -1;
+  sv_compiler_t *enc = c->enclosing;
+
+  if (!enc->is_arrow) {
+    if (enc->super_local < 0) return -1;
+    enc->locals[enc->super_local].captured = true;
+    uint16_t slot = (uint16_t)local_to_frame_slot(enc, enc->super_local);
+    return add_upvalue(c, slot, true, false);
+  }
+
+  int upvalue = resolve_super_upvalue(enc);
+  if (upvalue == -1) return -1;
+  return add_upvalue(c, (uint16_t)upvalue, false, false);
+}
+
+static int resolve_arguments_upvalue(sv_compiler_t *c) {
+  if (!c->enclosing) return -1;
+  sv_compiler_t *enc = c->enclosing;
+
+  if (!enc->is_arrow) {
+    if (enc->strict_args_local < 0) return -1;
+    enc->locals[enc->strict_args_local].captured = true;
+    uint16_t slot = (uint16_t)local_to_frame_slot(enc, enc->strict_args_local);
+    return add_upvalue(c, slot, true, false);
+  }
+
+  int upvalue = resolve_arguments_upvalue(enc);
+  if (upvalue == -1) return -1;
+  
+  return add_upvalue(c, (uint16_t)upvalue, false, false);
+}
+
+static int resolve_upvalue(sv_compiler_t *c, const char *name, uint32_t len) {
+  if (!c->enclosing) return -1;
+
+  int local = resolve_local(c->enclosing, name, len);
+  if (local != -1) {
+    c->enclosing->locals[local].captured = true;
+    uint16_t slot = (uint16_t)local_to_frame_slot(c->enclosing, local);
+    return add_upvalue(c, slot, true, c->enclosing->locals[local].is_const);
+  }
+
+  int upvalue = resolve_upvalue(c->enclosing, name, len);
+  if (upvalue != -1) {
+    bool uv_const = c->enclosing->upval_descs[upvalue].is_const;
+    return add_upvalue(c, (uint16_t)upvalue, false, uv_const);
+  }
+
+  return -1;
+}
+
+static int emit_jump(sv_compiler_t *c, sv_op_t op) {
+  emit_op(c, op);
+  int offset = c->code_len;
+  emit_i32(c, 0);
+  return offset;
+}
+
+static void patch_jump(sv_compiler_t *c, int offset) {
+  int32_t delta = (int32_t)(c->code_len - offset - 4);
+  patch_u32(c, offset, (uint32_t)delta);
+}
+
+static void emit_loop(sv_compiler_t *c, int loop_start) {
+  emit_op(c, OP_JMP);
+  int32_t delta = (int32_t)(loop_start - c->code_len - 4);
+  emit_i32(c, delta);
+}
+
+static void patch_list_add(sv_patch_list_t *pl, int offset) {
+  if (pl->count >= pl->cap) {
+    pl->cap = pl->cap ? pl->cap * 2 : 4;
+    pl->offsets = realloc(pl->offsets, (size_t)pl->cap * sizeof(int));
+  }
+  pl->offsets[pl->count++] = offset;
+}
+
+static void patch_list_resolve(sv_compiler_t *c, sv_patch_list_t *pl) {
+  for (int i = 0; i < pl->count; i++)
+    patch_jump(c, pl->offsets[i]);
+  free(pl->offsets);
+  *pl = (sv_patch_list_t){0};
+}
+
+static void push_loop(
+  sv_compiler_t *c, int loop_start,
+  const char *label, uint32_t label_len
+) {
+  if (c->loop_count >= c->loop_cap) {
+    c->loop_cap = c->loop_cap ? c->loop_cap * 2 : 4;
+    c->loops = realloc(c->loops, (size_t)c->loop_cap * sizeof(sv_loop_t));
+  }
+  if (!label && c->pending_label) {
+    label = c->pending_label;
+    label_len = c->pending_label_len;
+    c->pending_label = NULL;
+    c->pending_label_len = 0;
+  }
+  c->loops[c->loop_count++] = (sv_loop_t){
+    .loop_start = loop_start,
+    .scope_depth = c->scope_depth,
+    .label = label, .label_len = label_len,
+  };
+}
+
+static void pop_loop(sv_compiler_t *c) {
+  sv_loop_t *loop = &c->loops[--c->loop_count];
+  patch_list_resolve(c, &loop->breaks);
+  free(loop->continues.offsets);
+}
+
+static void begin_scope(sv_compiler_t *c) {
+  c->scope_depth++;
+}
+
+static void end_scope(sv_compiler_t *c) {
+  while (
+    c->local_count > 0 &&
+    c->locals[c->local_count - 1].depth >= c->scope_depth
+  ) {
+    sv_local_t *loc = &c->locals[c->local_count - 1];
+    if (loc->captured) {
+      int frame_slot = local_to_frame_slot(c, c->local_count - 1);
+      emit_op(c, OP_CLOSE_UPVAL);
+      emit_u16(c, (uint16_t)frame_slot);
+    }
+    c->local_count--;
+  }
+  c->scope_depth--;
+}
+
+static void emit_close_upvals(sv_compiler_t *c) {
+  for (int i = 0; i < c->local_count; i++) {
+  if (c->locals[i].captured) {
+    int frame_slot = local_to_frame_slot(c, i);
+    emit_op(c, OP_CLOSE_UPVAL);
+    emit_u16(c, (uint16_t)frame_slot);
+    return;
+  }}
+}
+
+static void emit_with_get(
+  sv_compiler_t *c, const char *name, uint32_t len,
+  uint8_t fb_kind, uint16_t fb_idx
+) {
+  int atom = add_atom(c, name, len);
+  emit_op(c, OP_WITH_GET_VAR);
+  emit_u32(c, (uint32_t)atom);
+  emit(c, fb_kind);
+  emit_u16(c, fb_idx);
+}
+
+static void emit_with_put(
+  sv_compiler_t *c, const char *name, uint32_t len,
+  uint8_t fb_kind, uint16_t fb_idx
+) {
+  int atom = add_atom(c, name, len);
+  emit_op(c, OP_WITH_PUT_VAR);
+  emit_u32(c, (uint32_t)atom);
+  emit(c, fb_kind);
+  emit_u16(c, fb_idx);
+}
+
+static void emit_get_local(sv_compiler_t *c, int local_idx);
+static void emit_put_local(sv_compiler_t *c, int local_idx);
+
+static void emit_get_var(sv_compiler_t *c, const char *name, uint32_t len) {
+  int local = resolve_local(c, name, len);
+  if (local != -1) {
+    if (c->with_depth > 0) {
+      uint8_t kind = c->locals[local].depth == -1 ? WITH_FB_ARG : WITH_FB_LOCAL;
+      uint16_t idx = kind == WITH_FB_ARG 
+        ? (uint16_t)local
+        : (uint16_t)(local - c->param_locals);
+      emit_with_get(c, name, len, kind, idx);
+      return;
+    }
+    if (c->locals[local].depth == -1) {
+      emit_op(c, OP_GET_ARG);
+      emit_u16(c, (uint16_t)local);
+    } else {
+      int slot = local - c->param_locals;
+      if (c->locals[local].is_tdz) {
+        int ai = add_atom(c, name, len);
+        emit_op(c, OP_GET_LOCAL_CHK);
+        emit_u16(c, (uint16_t)slot);
+        emit_u32(c, (uint32_t)ai);
+      } else if (slot <= 255) {
+        emit_op(c, OP_GET_LOCAL8);
+        emit(c, (uint8_t)slot);
+      } else {
+        emit_op(c, OP_GET_LOCAL);
+        emit_u16(c, (uint16_t)slot);
+      }
+    }
+    return;
+  }
+  int upval = resolve_upvalue(c, name, len);
+  if (upval != -1) {
+    if (c->with_depth > 0) {
+      emit_with_get(c, name, len, WITH_FB_UPVAL, (uint16_t)upval);
+      return;
+    }
+    emit_op(c, OP_GET_UPVAL);
+    emit_u16(c, (uint16_t)upval);
+    return;
+  }
+  if (is_ident_str(name, len, "arguments", 9)) {
+    if (has_implicit_arguments_obj(c)) {
+      if (c->strict_args_local >= 0) {
+        emit_get_local(c, c->strict_args_local);
+      } else {
+        emit_op(c, OP_SPECIAL_OBJ);
+        emit(c, 0);
+      }
+      return;
+    }
+    if (c->is_arrow) {
+      int args_upval = resolve_arguments_upvalue(c);
+      if (args_upval != -1) {
+        emit_op(c, OP_GET_UPVAL);
+        emit_u16(c, (uint16_t)args_upval);
+        return;
+      }
+    }
+  }
+  if (c->is_arrow && is_ident_str(name, len, "super", 5)) {
+    int super_upval = resolve_super_upvalue(c);
+    if (super_upval != -1) {
+      emit_op(c, OP_GET_UPVAL);
+      emit_u16(c, (uint16_t)super_upval);
+      return;
+    }
+  }
+  if (c->with_depth > 0)
+    emit_with_get(c, name, len, WITH_FB_GLOBAL, 0);
+  else
+    emit_atom_op(c, OP_GET_GLOBAL, name, len);
+}
+
+static void emit_set_var(sv_compiler_t *c, const char *name, uint32_t len, bool keep) {
+  int local = resolve_local(c, name, len);
+  if (local != -1) {
+    if (c->locals[local].is_const) {
+      emit_const_assign_error(c, name, len);
+      return;
+    }
+
+    if (c->with_depth > 0) {
+      uint8_t kind = c->locals[local].depth == -1 ? WITH_FB_ARG : WITH_FB_LOCAL;
+      uint16_t idx = kind == WITH_FB_ARG 
+        ? (uint16_t)local
+        : (uint16_t)(local - c->param_locals);
+      if (keep) emit_op(c, OP_DUP);
+      emit_with_put(c, name, len, kind, idx);
+      return;
+    }
+    if (c->locals[local].depth == -1) {
+      emit_op(c, keep ? OP_SET_ARG : OP_PUT_ARG);
+      emit_u16(c, (uint16_t)local);
+    } else {
+      int slot = local - c->param_locals;
+      sv_op_t op = keep 
+        ? (slot <= 255 ? OP_SET_LOCAL8 : OP_SET_LOCAL)
+        : (slot <= 255 ? OP_PUT_LOCAL8 : OP_PUT_LOCAL);
+      emit_op(c, op);
+      if (slot <= 255) emit(c, (uint8_t)slot);
+      else emit_u16(c, (uint16_t)slot);
+    }
+    return;
+  }
+  int upval = resolve_upvalue(c, name, len);
+  if (upval != -1) {
+    if (c->upval_descs[upval].is_const) {
+      emit_const_assign_error(c, name, len);
+      return;
+    }
+    if (c->with_depth > 0) {
+      if (keep) emit_op(c, OP_DUP);
+      emit_with_put(c, name, len, WITH_FB_UPVAL, (uint16_t)upval);
+      return;
+    }
+    emit_op(c, keep ? OP_SET_UPVAL : OP_PUT_UPVAL);
+    emit_u16(c, (uint16_t)upval);
+    return;
+  }
+  if (c->with_depth > 0) {
+    if (keep) emit_op(c, OP_DUP);
+    emit_with_put(c, name, len, WITH_FB_GLOBAL, 0);
+  } else {
+    if (keep) {
+      emit_op(c, OP_DUP);
+      emit_atom_op(c, OP_PUT_GLOBAL, name, len);
+    } else emit_atom_op(c, OP_PUT_GLOBAL, name, len);
+  }
+}
+
+static void emit_put_local(sv_compiler_t *c, int local_idx) {
+  int slot = local_idx - c->param_locals;
+  if (slot <= 255) { emit_op(c, OP_PUT_LOCAL8); emit(c, (uint8_t)slot); }
+  else { emit_op(c, OP_PUT_LOCAL); emit_u16(c, (uint16_t)slot); }
+}
+
+static void emit_get_local(sv_compiler_t *c, int local_idx) {
+  int slot = local_idx - c->param_locals;
+  if (slot <= 255) { emit_op(c, OP_GET_LOCAL8); emit(c, (uint8_t)slot); }
+  else { emit_op(c, OP_GET_LOCAL); emit_u16(c, (uint16_t)slot); }
+}
+
+
+static inline bool is_ident_name(sv_ast_t *node, const char *name) {
+  size_t n = strlen(name);
+  return node 
+    && node->type == N_IDENT && node->len == (uint32_t)n 
+    && memcmp(node->str, name, n) == 0;
+}
+
+static void hoist_var_pattern(sv_compiler_t *c, sv_ast_t *pat) {
+  if (!pat) return;
+  switch (pat->type) {
+    case N_IDENT:
+      if (resolve_local(c, pat->str, pat->len) == -1)
+        add_local(c, pat->str, pat->len, false, 0);
+      break;
+    case N_ARRAY: case N_ARRAY_PAT:
+      for (int i = 0; i < pat->args.count; i++)
+        hoist_var_pattern(c, pat->args.items[i]);
+      break;
+    case N_OBJECT: case N_OBJECT_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        sv_ast_t *prop = pat->args.items[i];
+        if (!prop) continue;
+        if (prop->type == N_PROPERTY)
+          hoist_var_pattern(c, prop->right);
+        else if (prop->type == N_REST || prop->type == N_SPREAD)
+          hoist_var_pattern(c, prop->right);
+      }
+      break;
+    case N_ASSIGN_PAT:
+      hoist_var_pattern(c, pat->left);
+      break;
+    case N_ASSIGN:
+      hoist_var_pattern(c, pat->left);
+      break;
+    case N_REST: case N_SPREAD:
+      hoist_var_pattern(c, pat->right);
+      break;
+    default:
+      break;
+  }
+}
+
+static void hoist_var_decls(sv_compiler_t *c, sv_ast_t *node) {
+  if (!node) return;
+  switch (node->type) {
+    case N_VAR:
+      if (node->var_kind == VAR_VAR) {
+        for (int i = 0; i < node->args.count; i++) {
+          sv_ast_t *decl = node->args.items[i];
+          if (decl->type == N_VARDECL && decl->left)
+            hoist_var_pattern(c, decl->left);
+        }
+      }
+      break;
+    case N_BLOCK:
+      for (int i = 0; i < node->args.count; i++)
+        hoist_var_decls(c, node->args.items[i]);
+      break;
+    case N_IF:
+      hoist_var_decls(c, node->left);
+      hoist_var_decls(c, node->right);
+      break;
+    case N_WHILE: case N_DO_WHILE: case N_LABEL:
+      hoist_var_decls(c, node->body);
+      break;
+    case N_FOR:
+      hoist_var_decls(c, node->init);
+      hoist_var_decls(c, node->body);
+      break;
+    case N_FOR_IN: case N_FOR_OF: case N_FOR_AWAIT_OF:
+      hoist_var_decls(c, node->left);
+      hoist_var_decls(c, node->body);
+      break;
+    case N_SWITCH:
+      for (int i = 0; i < node->args.count; i++) {
+        sv_ast_t *cas = node->args.items[i];
+        for (int j = 0; j < cas->args.count; j++)
+          hoist_var_decls(c, cas->args.items[j]);
+      }
+      break;
+    case N_TRY:
+      hoist_var_decls(c, node->body);
+      hoist_var_decls(c, node->catch_body);
+      hoist_var_decls(c, node->finally_body);
+      break;
+    case N_EXPORT:
+      hoist_var_decls(c, node->left);
+      break;
+    default: break;
+  }
+}
+
+static void hoist_lexical_pattern(sv_compiler_t *c, sv_ast_t *pat,
+                                  bool is_const) {
+  if (!pat) return;
+
+  switch (pat->type) {
+    case N_IDENT:
+      ensure_local_at_depth(c, pat->str, pat->len, is_const, c->scope_depth);
+      break;
+    case N_ASSIGN_PAT:
+      hoist_lexical_pattern(c, pat->left, is_const);
+      break;
+    case N_REST:
+    case N_SPREAD:
+      hoist_lexical_pattern(c, pat->right, is_const);
+      break;
+    case N_ARRAY:
+    case N_ARRAY_PAT:
+      for (int i = 0; i < pat->args.count; i++)
+        hoist_lexical_pattern(c, pat->args.items[i], is_const);
+      break;
+    case N_OBJECT:
+    case N_OBJECT_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        sv_ast_t *prop = pat->args.items[i];
+        if (!prop) continue;
+        if (prop->type == N_PROPERTY)
+          hoist_lexical_pattern(c, prop->right, is_const);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+static void annex_b_collect_funcs(sv_ast_t *node, sv_ast_list_t *out) {
+  if (!node) return;
+  if (node->type == N_FUNC && node->str && !(node->flags & FN_ARROW)) {
+    sv_ast_list_push(out, node);
+    return;
+  }
+  if (node->type == N_IF) {
+    annex_b_collect_funcs(node->left, out);
+    annex_b_collect_funcs(node->right, out);
+  } else if (node->type == N_LABEL) annex_b_collect_funcs(node->body, out);
+}
+
+static void hoist_lexical_decls(sv_compiler_t *c, sv_ast_list_t *stmts) {
+  for (int i = 0; i < stmts->count; i++) {
+    sv_ast_t *node = stmts->items[i];
+    if (!node) continue;
+    sv_ast_t *decl_node = (node->type == N_EXPORT) ? node->left : node;
+    if (!decl_node) continue;
+
+    if (decl_node->type == N_VAR && decl_node->var_kind != VAR_VAR) {
+      bool is_const = (decl_node->var_kind == VAR_CONST);
+      int lb = c->local_count;
+      for (int j = 0; j < decl_node->args.count; j++) {
+        sv_ast_t *decl = decl_node->args.items[j];
+        if (!decl || decl->type != N_VARDECL || !decl->left) continue;
+        hoist_lexical_pattern(c, decl->left, is_const);
+      }
+      for (int j = lb; j < c->local_count; j++) {
+        c->locals[j].is_tdz = true;
+        int slot = j - c->param_locals;
+        emit_op(c, OP_SET_LOCAL_UNDEF);
+        emit_u16(c, (uint16_t)slot);
+      }
+    } else if (decl_node->type == N_IMPORT_DECL) {
+      for (int j = 0; j < decl_node->args.count; j++) {
+        sv_ast_t *spec = decl_node->args.items[j];
+        if (!spec || spec->type != N_IMPORT_SPEC ||
+            !spec->right || spec->right->type != N_IDENT)
+          continue;
+        ensure_local_at_depth(c, spec->right->str, spec->right->len, true, c->scope_depth);
+      }
+    } else if (decl_node->type == N_CLASS && decl_node->str) {
+      int lb = c->local_count;
+      ensure_local_at_depth(c, decl_node->str, decl_node->len, false, c->scope_depth);
+      if (c->local_count > lb) {
+        c->locals[c->local_count - 1].is_tdz = true;
+        int slot = (c->local_count - 1) - c->param_locals;
+        emit_op(c, OP_SET_LOCAL_UNDEF);
+        emit_u16(c, (uint16_t)slot);
+      }
+    } else if (decl_node->type == N_FUNC && decl_node->str && !(decl_node->flags & FN_ARROW)) {
+      ensure_local_at_depth(c, decl_node->str, decl_node->len, false, c->scope_depth);
+    }
+    if (!c->is_strict && (decl_node->type == N_IF || decl_node->type == N_LABEL)) {
+      sv_ast_list_t funcs = {0};
+      annex_b_collect_funcs(decl_node, &funcs);
+      for (int j = 0; j < funcs.count; j++) {
+        sv_ast_t *fn = funcs.items[j];
+        if (resolve_local(c, fn->str, fn->len) == -1)
+          add_local(c, fn->str, fn->len, false, c->scope_depth);
+      }
+    }
+  }
+}
+
+static void hoist_one_func(sv_compiler_t *c, sv_ast_t *node) {
+  sv_func_t *fn = compile_function_body(c, node, SV_COMPILE_SCRIPT);
+  if (!fn) return;
+  int idx = add_constant(c, mkval(T_CFUNC, (uintptr_t)fn));
+  emit_op(c, OP_CLOSURE);
+  emit_u32(c, (uint32_t)idx);
+  emit_set_function_name(c, node->str, node->len);
+  if (is_repl_top_level(c)) {
+    emit_atom_op(c, OP_PUT_GLOBAL, node->str, node->len);
+  } else {
+    int local = resolve_local(c, node->str, node->len);
+    emit_put_local(c, local);
+  }
+}
+
+static void hoist_func_decls(sv_compiler_t *c, sv_ast_list_t *stmts) {
+  for (int i = 0; i < stmts->count; i++) {
+    sv_ast_t *node = stmts->items[i];
+    if (node && node->type == N_EXPORT && node->left)
+      node = node->left;
+    if (!node) continue;
+    if (node->type == N_FUNC && node->str && !(node->flags & FN_ARROW)) {
+      hoist_one_func(c, node);
+    }
+    if (!c->is_strict && (node->type == N_IF || node->type == N_LABEL)) {
+      sv_ast_list_t funcs = {0};
+      annex_b_collect_funcs(node, &funcs);
+      for (int j = 0; j < funcs.count; j++)
+        hoist_one_func(c, funcs.items[j]);
+    }
+  }
+}
+
+static void compile_expr(sv_compiler_t *c, sv_ast_t *node) {
+  if (!node) { emit_op(c, OP_UNDEF); return; }
+  emit_srcpos(c, node);
+
+  switch (node->type) {
+    case N_NUMBER:
+      emit_number(c, node->num);
+      break;
+
+    case N_STRING: {
+      emit_constant(c, ast_string_const(c, node));
+      break;
+    }
+
+    case N_BIGINT: {
+      bool neg = false;
+      const char *digits = node->str;
+      uint32_t dlen = node->len;
+      if (dlen > 0 && digits[0] == '-') {
+        neg = true; digits++; dlen--;
+      }
+      if (dlen > 0 && digits[dlen - 1] == 'n') dlen--;
+      jsval_t bi = js_mkbigint(c->js, digits, dlen, neg);
+      emit_constant(c, bi);
+      break;
+    }
+
+    case N_BOOL:
+      emit_op(c, node->num != 0.0 ? OP_TRUE : OP_FALSE);
+      break;
+
+    case N_NULL:
+      emit_op(c, OP_NULL);
+      break;
+
+    case N_UNDEF:
+      emit_op(c, OP_UNDEF);
+      break;
+
+    case N_THIS:
+      emit_op(c, OP_THIS);
+      break;
+
+    case N_GLOBAL_THIS:
+      emit_op(c, OP_GLOBAL);
+      break;
+
+    case N_NEW_TARGET: {
+      static const char nt_name[] = "\x01new.target";
+      int local = resolve_local(c, nt_name, sizeof(nt_name) - 1);
+      if (local >= 0) {
+        emit_get_local(c, local);
+      } else {
+        int upval = resolve_upvalue(c, nt_name, sizeof(nt_name) - 1);
+        if (upval >= 0) {
+          emit_op(c, OP_GET_UPVAL);
+          emit_u16(c, (uint16_t)upval);
+        } else {
+          emit_op(c, OP_UNDEF);
+        }
+      }
+      break;
+    }
+
+    case N_IDENT:
+      emit_get_var(c, node->str, node->len);
+      break;
+
+    case N_BINARY:
+      compile_binary(c, node);
+      break;
+
+    case N_UNARY:
+      compile_unary(c, node);
+      break;
+
+    case N_UPDATE:
+      compile_update(c, node);
+      break;
+
+    case N_ASSIGN:
+      compile_assign(c, node);
+      break;
+
+    case N_TERNARY:
+      compile_ternary(c, node);
+      break;
+
+    case N_CALL:
+      compile_call(c, node);
+      break;
+
+    case N_NEW:
+      compile_new(c, node);
+      break;
+
+    case N_MEMBER:
+      compile_member(c, node);
+      break;
+
+    case N_OPTIONAL:
+      compile_optional(c, node);
+      break;
+
+    case N_ARRAY:
+      compile_array(c, node);
+      break;
+
+    case N_OBJECT:
+      compile_object(c, node);
+      break;
+
+    case N_FUNC:
+      compile_func_expr(c, node);
+      break;
+
+    case N_CLASS:
+      compile_class(c, node);
+      break;
+
+    case N_SEQUENCE:
+      compile_expr(c, node->left);
+      emit_op(c, OP_POP);
+      compile_expr(c, node->right);
+      break;
+
+    case N_TYPEOF:
+      compile_typeof(c, node);
+      break;
+
+    case N_VOID:
+      compile_expr(c, node->right);
+      emit_op(c, OP_VOID);
+      break;
+
+    case N_DELETE:
+      compile_delete(c, node);
+      break;
+
+    case N_SPREAD:
+      compile_expr(c, node->right);
+      break;
+
+    case N_TEMPLATE:
+      compile_template(c, node);
+      break;
+
+    case N_AWAIT:
+      compile_expr(c, node->right);
+      emit_op(c, OP_AWAIT);
+      if (c->enclosing && !c->enclosing->enclosing)
+        c->is_tla = true;
+      break;
+
+    case N_YIELD:
+      if (node->right) compile_expr(c, node->right);
+      else emit_op(c, OP_UNDEF);
+      emit_op(c, node->flags ? OP_YIELD_STAR : OP_YIELD);
+      break;
+
+    case N_TAGGED_TEMPLATE: {
+      compile_expr(c, node->left);
+      sv_ast_t *tpl = node->right;
+      int n = tpl->args.count;
+      int n_strings = 0, n_exprs = 0;
+      for (int i = 0; i < n; i++) {
+        if (tpl->args.items[i]->type == N_STRING) n_strings++;
+        else n_exprs++;
+      }
+      int cache_idx = add_constant(c, js_mkundef());
+      emit_op(c, OP_CONST);
+      emit_u32(c, (uint32_t)cache_idx);
+      int skip_jump = emit_jump(c, OP_JMP_TRUE_PEEK);
+      emit_op(c, OP_POP);
+      for (int i = 0; i < n; i++) {
+        sv_ast_t *item = tpl->args.items[i];
+        if (item->type != N_STRING) continue;
+        if (is_invalid_cooked_string(item))
+          emit_op(c, OP_UNDEF);
+        else emit_constant(c, ast_string_const(c, item));
+      }
+      emit_op(c, OP_ARRAY);
+      emit_u16(c, (uint16_t)n_strings);
+      for (int i = 0; i < n; i++) {
+        sv_ast_t *item = tpl->args.items[i];
+        if (item->type != N_STRING) continue;
+        const char *raw = item->aux ? item->aux : item->str;
+        uint32_t raw_len = item->aux ? item->aux_len : item->len;
+        emit_constant(c, js_mkstr(c->js, raw ? raw : "", raw_len));
+      }
+      emit_op(c, OP_ARRAY);
+      emit_u16(c, (uint16_t)n_strings);
+      emit_atom_op(c, OP_GET_GLOBAL, "Object", 6);
+      emit_atom_op(c, OP_GET_FIELD2, "freeze", 6);
+      emit_op(c, OP_ROT3L);
+      emit_op(c, OP_CALL_METHOD);
+      emit_u16(c, 1);
+      emit_atom_op(c, OP_DEFINE_FIELD, "raw", 3);
+      emit_atom_op(c, OP_GET_GLOBAL, "Object", 6);
+      emit_atom_op(c, OP_GET_FIELD2, "freeze", 6);
+      emit_op(c, OP_ROT3L);
+      emit_op(c, OP_CALL_METHOD);
+      emit_u16(c, 1);
+      emit_op(c, OP_DUP);
+      emit_op(c, OP_PUT_CONST);
+      emit_u32(c, (uint32_t)cache_idx);
+      patch_jump(c, skip_jump);
+      for (int i = 0; i < n; i++) {
+        sv_ast_t *item = tpl->args.items[i];
+        if (item->type == N_STRING) continue;
+        compile_expr(c, item);
+      }
+      emit_op(c, OP_CALL);
+      emit_u16(c, (uint16_t)(1 + n_exprs));
+      break;
+    }
+
+    case N_IMPORT:
+      compile_expr(c, node->right);
+      emit_op(c, OP_IMPORT);
+      break;
+
+    case N_REGEXP:
+      emit_constant(c, js_mkstr(c->js, node->str ? node->str : "", node->len));
+      emit_constant(c, js_mkstr(c->js, node->aux ? node->aux : "", node->aux_len));
+      emit_op(c, OP_REGEXP);
+      break;
+
+    default:
+      emit_op(c, OP_UNDEF);
+      break;
+  }
+}
+
+static void compile_binary(sv_compiler_t *c, sv_ast_t *node) {
+  uint8_t op = node->op;
+
+  if (op == TOK_LAND) {
+    compile_expr(c, node->left);
+    int jump = emit_jump(c, OP_JMP_FALSE_PEEK);
+    emit_op(c, OP_POP);
+    compile_expr(c, node->right);
+    patch_jump(c, jump);
+    return;
+  }
+  
+  if (op == TOK_LOR) {
+    compile_expr(c, node->left);
+    int jump = emit_jump(c, OP_JMP_TRUE_PEEK);
+    emit_op(c, OP_POP);
+    compile_expr(c, node->right);
+    patch_jump(c, jump);
+    return;
+  }
+  
+  if (op == TOK_NULLISH) {
+    compile_expr(c, node->left);
+    int jump = emit_jump(c, OP_JMP_NOT_NULLISH);
+    emit_op(c, OP_POP);
+    compile_expr(c, node->right);
+    patch_jump(c, jump);
+    return;
+  }
+
+  if (op == TOK_IN && node->left->type == N_IDENT &&
+      node->left->len > 0 && node->left->str[0] == '#') {
+    emit_constant(c, js_mkstr(c->js, node->left->str, node->left->len));
+    compile_expr(c, node->right);
+    emit_op(c, OP_IN);
+    return;
+  }
+
+  compile_expr(c, node->left);
+  compile_expr(c, node->right);
+
+  switch (op) {
+    case TOK_PLUS:       emit_op(c, OP_ADD); break;
+    case TOK_MINUS:      emit_op(c, OP_SUB); break;
+    case TOK_MUL:        emit_op(c, OP_MUL); break;
+    case TOK_DIV:        emit_op(c, OP_DIV); break;
+    case TOK_REM:        emit_op(c, OP_MOD); break;
+    case TOK_EXP:        emit_op(c, OP_EXP); break;
+    case TOK_LT:         emit_op(c, OP_LT);  break;
+    case TOK_LE:         emit_op(c, OP_LE);  break;
+    case TOK_GT:         emit_op(c, OP_GT);  break;
+    case TOK_GE:         emit_op(c, OP_GE);  break;
+    case TOK_EQ:         emit_op(c, OP_EQ);  break;
+    case TOK_NE:         emit_op(c, OP_NE);  break;
+    case TOK_SEQ:        emit_op(c, OP_SEQ); break;
+    case TOK_SNE:        emit_op(c, OP_SNE); break;
+    case TOK_AND:        emit_op(c, OP_BAND); break;
+    case TOK_OR:         emit_op(c, OP_BOR);  break;
+    case TOK_XOR:        emit_op(c, OP_BXOR); break;
+    case TOK_SHL:        emit_op(c, OP_SHL);  break;
+    case TOK_SHR:        emit_op(c, OP_SHR);  break;
+    case TOK_ZSHR:       emit_op(c, OP_USHR); break;
+    case TOK_INSTANCEOF: emit_op(c, OP_INSTANCEOF); break;
+    case TOK_IN:         emit_op(c, OP_IN);  break;
+    default:             emit_op(c, OP_UNDEF); break;
+  }
+}
+
+static void compile_unary(sv_compiler_t *c, sv_ast_t *node) {
+  compile_expr(c, node->right);
+  switch (node->op) {
+    case TOK_NOT:    emit_op(c, OP_NOT);   break;
+    case TOK_TILDA:  emit_op(c, OP_BNOT);  break;
+    case TOK_UPLUS:  emit_op(c, OP_UPLUS); break;
+    case TOK_UMINUS: emit_op(c, OP_NEG);   break;
+    default: break;
+  }
+}
+
+
+static void compile_update(sv_compiler_t *c, sv_ast_t *node) {
+  bool prefix = (node->flags & 1);
+  bool is_inc = (node->op == TOK_POSTINC);
+  sv_ast_t *target = node->right;
+
+  if (target->type == N_IDENT) {
+    if (prefix) {
+      emit_get_var(c, target->str, target->len);
+      emit_op(c, is_inc ? OP_INC : OP_DEC);
+      emit_set_var(c, target->str, target->len, true);
+    } else {
+      emit_get_var(c, target->str, target->len);
+      emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
+      emit_set_var(c, target->str, target->len, false);
+    }
+  } else if (target->type == N_MEMBER && !(target->flags & 1)) {
+    compile_expr(c, target->left);
+    emit_op(c, OP_DUP);
+    int atom = add_atom(c, target->right->str, target->right->len);
+    emit_op(c, OP_GET_FIELD);
+    emit_u32(c, (uint32_t)atom);
+    if (prefix) {
+      emit_op(c, is_inc ? OP_INC : OP_DEC);
+      emit_op(c, OP_INSERT2);
+      emit_op(c, OP_PUT_FIELD);
+      emit_u32(c, (uint32_t)atom);
+    } else {
+      emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
+      emit_op(c, OP_SWAP_UNDER);
+      emit_op(c, OP_PUT_FIELD);
+      emit_u32(c, (uint32_t)atom);
+    }
+  } else if (target->type == N_MEMBER && (target->flags & 1)) {
+    compile_expr(c, target->left);
+    compile_expr(c, target->right);
+    emit_op(c, OP_DUP2);
+    emit_op(c, OP_GET_ELEM);
+    if (prefix) {
+      emit_op(c, is_inc ? OP_INC : OP_DEC);
+      emit_op(c, OP_INSERT3);
+      emit_op(c, OP_PUT_ELEM);
+    } else {
+      emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
+      emit_op(c, OP_ROT4_UNDER);
+      emit_op(c, OP_PUT_ELEM);
+    }
+  } else {
+    emit_op(c, OP_UNDEF);
+  }
+}
+
+static void compile_assign(sv_compiler_t *c, sv_ast_t *node) {
+  sv_ast_t *target = node->left;
+  uint8_t op = node->op;
+
+  if (op == TOK_ASSIGN) {
+    if (target->type == N_MEMBER && !(target->flags & 1)) {
+      int atom = add_atom(c, target->right->str, target->right->len);
+      compile_expr(c, target->left);
+      compile_expr(c, node->right);
+      emit_op(c, OP_INSERT2);
+      emit_op(c, OP_PUT_FIELD);
+      emit_u32(c, (uint32_t)atom);
+      return;
+    }
+
+    if (target->type == N_MEMBER && (target->flags & 1)) {
+      compile_expr(c, target->left);
+      compile_expr(c, target->right);
+      compile_expr(c, node->right);
+      emit_op(c, OP_INSERT3);
+      emit_op(c, OP_PUT_ELEM);
+      return;
+    }
+
+    compile_expr(c, node->right);
+    compile_lhs_set(c, target, true);
+    return;
+  }
+
+  if (target->type == N_IDENT) {
+    if (op == TOK_PLUS_ASSIGN) {
+      int slot = resolve_local_slot(c, target->str, target->len);
+      if (slot >= 0 && !c->locals[slot + c->param_locals].is_const) {
+        sv_ast_t *rhs = node->right;
+        bool rhs_pure = rhs && (
+          rhs->type == N_NUMBER || rhs->type == N_STRING ||
+          rhs->type == N_BOOL || rhs->type == N_NULL ||
+          rhs->type == N_UNDEF || rhs->type == N_IDENT
+        );
+        if (rhs_pure) {
+          compile_expr(c, rhs);
+          emit_op(c, OP_ADD_LOCAL);
+          emit(c, (uint8_t)slot);
+          emit_get_local(c, c->param_locals + slot);
+          return;
+        }
+      }
+    }
+
+    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
+        op == TOK_NULLISH_ASSIGN) {
+      emit_get_var(c, target->str, target->len);
+      int skip = emit_jump(c,
+        op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
+        op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
+      emit_op(c, OP_POP);
+      compile_expr(c, node->right);
+      emit_set_var(c, target->str, target->len, true);
+      patch_jump(c, skip);
+      return;
+    }
+
+    emit_get_var(c, target->str, target->len);
+    compile_expr(c, node->right);
+    switch (op) {
+      case TOK_PLUS_ASSIGN:    emit_op(c, OP_ADD); break;
+      case TOK_MINUS_ASSIGN:   emit_op(c, OP_SUB); break;
+      case TOK_MUL_ASSIGN:     emit_op(c, OP_MUL); break;
+      case TOK_DIV_ASSIGN:     emit_op(c, OP_DIV); break;
+      case TOK_REM_ASSIGN:     emit_op(c, OP_MOD); break;
+      case TOK_SHL_ASSIGN:     emit_op(c, OP_SHL); break;
+      case TOK_SHR_ASSIGN:     emit_op(c, OP_SHR); break;
+      case TOK_ZSHR_ASSIGN:    emit_op(c, OP_USHR); break;
+      case TOK_AND_ASSIGN:     emit_op(c, OP_BAND); break;
+      case TOK_XOR_ASSIGN:     emit_op(c, OP_BXOR); break;
+      case TOK_OR_ASSIGN:      emit_op(c, OP_BOR); break;
+      case TOK_EXP_ASSIGN:    emit_op(c, OP_EXP); break;
+      default: break;
+    }
+    emit_set_var(c, target->str, target->len, true);
+  } else if (target->type == N_MEMBER && !(target->flags & 1)) {
+    int atom = add_atom(c, target->right->str, target->right->len);
+
+    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
+        op == TOK_NULLISH_ASSIGN) {
+      compile_expr(c, target->left);
+      emit_op(c, OP_DUP);
+      emit_op(c, OP_GET_FIELD);
+      emit_u32(c, (uint32_t)atom);
+      int skip = emit_jump(c,
+        op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
+        op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
+      emit_op(c, OP_POP);
+      compile_expr(c, node->right);
+      emit_op(c, OP_INSERT2);
+      emit_op(c, OP_PUT_FIELD);
+      emit_u32(c, (uint32_t)atom);
+      int end = emit_jump(c, OP_JMP);
+      patch_jump(c, skip);
+      emit_op(c, OP_NIP);
+      patch_jump(c, end);
+      return;
+    }
+
+    compile_expr(c, target->left);
+    emit_op(c, OP_DUP);
+    emit_op(c, OP_GET_FIELD);
+    emit_u32(c, (uint32_t)atom);
+    compile_expr(c, node->right);
+    switch (op) {
+      case TOK_PLUS_ASSIGN:  emit_op(c, OP_ADD); break;
+      case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
+      case TOK_MUL_ASSIGN:   emit_op(c, OP_MUL); break;
+      case TOK_DIV_ASSIGN:   emit_op(c, OP_DIV); break;
+      case TOK_REM_ASSIGN:   emit_op(c, OP_MOD); break;
+      case TOK_SHL_ASSIGN:   emit_op(c, OP_SHL); break;
+      case TOK_SHR_ASSIGN:   emit_op(c, OP_SHR); break;
+      case TOK_ZSHR_ASSIGN:  emit_op(c, OP_USHR); break;
+      case TOK_AND_ASSIGN:   emit_op(c, OP_BAND); break;
+      case TOK_XOR_ASSIGN:   emit_op(c, OP_BXOR); break;
+      case TOK_OR_ASSIGN:    emit_op(c, OP_BOR); break;
+      case TOK_EXP_ASSIGN:  emit_op(c, OP_EXP); break;
+      default: break;
+    }
+    emit_op(c, OP_INSERT2);
+    emit_op(c, OP_PUT_FIELD);
+    emit_u32(c, (uint32_t)atom);
+  } else if (target->type == N_MEMBER && (target->flags & 1)) {
+
+    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
+        op == TOK_NULLISH_ASSIGN) {
+      compile_expr(c, target->left);
+      compile_expr(c, target->right);
+      emit_op(c, OP_DUP2);
+      emit_op(c, OP_GET_ELEM);
+      int skip = emit_jump(c,
+        op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
+        op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
+      emit_op(c, OP_POP);
+      compile_expr(c, node->right);
+      emit_op(c, OP_INSERT3);
+      emit_op(c, OP_PUT_ELEM);
+      int end = emit_jump(c, OP_JMP);
+      patch_jump(c, skip);
+      emit_op(c, OP_NIP2);
+      patch_jump(c, end);
+      return;
+    }
+
+    compile_expr(c, target->left);
+    compile_expr(c, target->right);
+    emit_op(c, OP_DUP2);
+    emit_op(c, OP_GET_ELEM);
+    compile_expr(c, node->right);
+    switch (op) {
+      case TOK_PLUS_ASSIGN:  emit_op(c, OP_ADD); break;
+      case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
+      case TOK_MUL_ASSIGN:   emit_op(c, OP_MUL); break;
+      case TOK_DIV_ASSIGN:   emit_op(c, OP_DIV); break;
+      case TOK_REM_ASSIGN:   emit_op(c, OP_MOD); break;
+      case TOK_SHL_ASSIGN:   emit_op(c, OP_SHL); break;
+      case TOK_SHR_ASSIGN:   emit_op(c, OP_SHR); break;
+      case TOK_ZSHR_ASSIGN:  emit_op(c, OP_USHR); break;
+      case TOK_AND_ASSIGN:   emit_op(c, OP_BAND); break;
+      case TOK_XOR_ASSIGN:   emit_op(c, OP_BXOR); break;
+      case TOK_OR_ASSIGN:    emit_op(c, OP_BOR); break;
+      case TOK_EXP_ASSIGN:  emit_op(c, OP_EXP); break;
+      default: break;
+    }
+    emit_op(c, OP_INSERT3);
+    emit_op(c, OP_PUT_ELEM);
+  } else {
+    compile_expr(c, node->right);
+  }
+}
+
+static void compile_lhs_set(sv_compiler_t *c, sv_ast_t *target, bool keep) {
+  if (target->type == N_IDENT) {
+    emit_set_var(c, target->str, target->len, keep);
+  } else if (target->type == N_MEMBER && !(target->flags & 1)) {
+    if (keep) emit_op(c, OP_DUP);
+    compile_expr(c, target->left);
+    emit_op(c, OP_SWAP);
+    emit_atom_op(c, OP_PUT_FIELD, target->right->str, target->right->len);
+  } else if (target->type == N_MEMBER && (target->flags & 1)) {
+    if (keep) emit_op(c, OP_DUP);
+    compile_expr(c, target->left);
+    compile_expr(c, target->right);
+    emit_op(c, OP_ROT3L);
+    emit_op(c, OP_PUT_ELEM);
+  } else if (target->type == N_ARRAY_PAT || target->type == N_ARRAY) {
+    compile_array_destructure(c, target, keep);
+  } else if (target->type == N_OBJECT_PAT || target->type == N_OBJECT) {
+    compile_object_destructure(c, target, keep);
+  }
+}
+
+static void compile_ternary(sv_compiler_t *c, sv_ast_t *node) {
+  compile_expr(c, node->cond);
+  int else_jump = emit_jump(c, OP_JMP_FALSE);
+  compile_expr(c, node->left);
+  int end_jump = emit_jump(c, OP_JMP);
+  patch_jump(c, else_jump);
+  compile_expr(c, node->right);
+  patch_jump(c, end_jump);
+}
+
+static void compile_typeof(sv_compiler_t *c, sv_ast_t *node) {
+  sv_ast_t *arg = node->right;
+  if (arg->type == N_IDENT) {
+    int local = resolve_local(c, arg->str, arg->len);
+    if (local != -1) {
+      emit_get_var(c, arg->str, arg->len);
+    } else {
+      int upval = resolve_upvalue(c, arg->str, arg->len);
+      if (upval != -1) {
+        emit_op(c, OP_GET_UPVAL);
+        emit_u16(c, (uint16_t)upval);
+      } else if (
+          has_implicit_arguments_obj(c) &&
+          is_ident_str(arg->str, arg->len, "arguments", 9)
+        ) {
+        if (c->strict_args_local >= 0) {
+          emit_get_local(c, c->strict_args_local);
+        } else {
+          emit_op(c, OP_SPECIAL_OBJ);
+          emit(c, 0);
+        }
+      } else emit_atom_op(c, OP_GET_GLOBAL_UNDEF, arg->str, arg->len);
+    }
+  } else compile_expr(c, arg);
+  emit_op(c, OP_TYPEOF);
+}
+
+static void compile_delete(sv_compiler_t *c, sv_ast_t *node) {
+  sv_ast_t *arg = node->right;
+  if (arg->type == N_MEMBER && !(arg->flags & 1)) {
+    compile_expr(c, arg->left);
+    jsval_t key = js_mkstr(c->js, arg->right->str, arg->right->len);
+    emit_constant(c, key);
+    emit_op(c, OP_DELETE);
+  } else if (arg->type == N_MEMBER && (arg->flags & 1)) {
+    compile_expr(c, arg->left);
+    compile_expr(c, arg->right);
+    emit_op(c, OP_DELETE);
+  } else if (arg->type == N_IDENT) {
+    emit_atom_op(c, OP_DELETE_VAR, arg->str, arg->len);
+  } else {
+    compile_expr(c, arg);
+    emit_op(c, OP_POP);
+    emit_op(c, OP_TRUE);
+  }
+}
+
+static void compile_template(sv_compiler_t *c, sv_ast_t *node) {
+  int n = node->args.count;
+  if (n == 0) {
+    emit_constant(c, js_mkstr(c->js, "", 0));
+    return;
+  }
+  for (int i = 0; i < n; i++) {
+    sv_ast_t *item = node->args.items[i];
+    if (item->type == N_STRING && is_invalid_cooked_string(item)) {
+      static const char msg[] = "Invalid or unexpected token";
+      int atom = add_atom(c, msg, sizeof(msg) - 1);
+      emit_op(c, OP_THROW_ERROR);
+      emit_u32(c, (uint32_t)atom);
+      emit(c, (uint8_t)JS_ERR_SYNTAX);
+      return;
+    }
+  }
+  compile_expr(c, node->args.items[0]);
+  if (node->args.items[0]->type != N_STRING)
+    emit_op(c, OP_TO_PROPKEY);
+  for (int i = 1; i < n; i++) {
+    compile_expr(c, node->args.items[i]);
+    if (node->args.items[i]->type != N_STRING)
+      emit_op(c, OP_TO_PROPKEY);
+    emit_op(c, OP_ADD);
+  }
+}
+
+static bool call_has_spread_arg(const sv_ast_t *node) {
+  if (!node) return false;
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *arg = node->args.items[i];
+    if (arg && arg->type == N_SPREAD) return true;
+  }
+  return false;
+}
+
+static void compile_push_arg_to_array(sv_compiler_t *c, sv_ast_t *arg) {
+  emit_op(c, OP_DUP);
+  emit_op(c, OP_DUP);
+  emit_atom_op(c, OP_GET_FIELD, "push", 4);
+  compile_expr(c, arg);
+  emit_op(c, OP_CALL_METHOD);
+  emit_u16(c, 1);
+  emit_op(c, OP_POP);
+}
+
+static void compile_concat_spread_to_array(sv_compiler_t *c, sv_ast_t *spread_arg) {
+  compile_expr(c, spread_arg->right);
+  emit_op(c, OP_SPREAD);
+}
+
+static void compile_call_args_array(sv_compiler_t *c, sv_ast_t *call_node) {
+  emit_op(c, OP_ARRAY);
+  emit_u16(c, 0);
+  for (int i = 0; i < call_node->args.count; i++) {
+    sv_ast_t *arg = call_node->args.items[i];
+    if (arg && arg->type == N_SPREAD) compile_concat_spread_to_array(c, arg);
+    else compile_push_arg_to_array(c, arg);
+  }
+}
+
+typedef enum {
+  SV_CALL_DIRECT = 0,
+  SV_CALL_METHOD = 1,
+} sv_call_kind_t;
+
+static void compile_receiver_property_get(sv_compiler_t *c, sv_ast_t *node) {
+  emit_op(c, OP_DUP);
+  if (node->flags & 1) {
+    compile_expr(c, node->right);
+    emit_op(c, OP_GET_ELEM);
+  } else {
+    emit_srcpos(c, node->right);
+    emit_atom_op(c, OP_GET_FIELD, node->right->str, node->right->len);
+  }
+}
+
+static void compile_call_emit_invoke(
+  sv_compiler_t *c, sv_ast_t *node,
+  sv_call_kind_t kind, bool has_spread
+) {
+  int argc = node->args.count;
+  if (has_spread) {
+    if (kind == SV_CALL_METHOD) emit_op(c, OP_SWAP);
+    else emit_op(c, OP_GLOBAL);
+    compile_call_args_array(c, node);
+    emit_op(c, OP_APPLY);
+    emit_u16(c, 1);
+    return;
+  }
+
+  for (int i = 0; i < argc; i++)
+    compile_expr(c, node->args.items[i]);
+  emit_op(c, kind == SV_CALL_METHOD ? OP_CALL_METHOD : OP_CALL);
+  emit_u16(c, (uint16_t)argc);
+}
+
+static sv_call_kind_t compile_call_setup_non_optional(sv_compiler_t *c, sv_ast_t *callee) {
+  if (is_ident_name(callee, "super")) {
+    emit_op(c, OP_THIS);
+    emit_get_var(c, "super", 5);
+    return SV_CALL_METHOD;
+  }
+
+  if (callee->type == N_MEMBER && is_ident_name(callee->left, "super")) {
+    emit_op(c, OP_THIS);
+    emit_op(c, OP_THIS);
+    emit_get_var(c, "super", 5);
+    if (callee->flags & 1)
+      compile_expr(c, callee->right);
+    else
+      emit_constant(c, js_mkstr(c->js, callee->right->str, callee->right->len));
+    emit_op(c, OP_GET_SUPER_VAL);
+    return SV_CALL_METHOD;
+  }
+
+  if (callee->type == N_MEMBER) {
+    compile_expr(c, callee->left);
+    compile_receiver_property_get(c, callee);
+    return SV_CALL_METHOD;
+  }
+
+  compile_expr(c, callee);
+  return SV_CALL_DIRECT;
+}
+
+static void compile_optional_call_after_setup(
+  sv_compiler_t *c, sv_ast_t *call_node,
+  sv_call_kind_t kind, bool has_spread
+) {
+  emit_op(c, OP_DUP);
+  emit_op(c, OP_IS_UNDEF_OR_NULL);
+  int j_do_call = emit_jump(c, OP_JMP_FALSE);
+  emit_op(c, OP_POP);
+  if (kind == SV_CALL_METHOD)
+    emit_op(c, OP_POP);
+  emit_op(c, OP_UNDEF);
+  int j_end = emit_jump(c, OP_JMP);
+  patch_jump(c, j_do_call);
+  compile_call_emit_invoke(c, call_node, kind, has_spread);
+  patch_jump(c, j_end);
+}
+
+static void compile_call_optional(
+  sv_compiler_t *c, sv_ast_t *node,
+  sv_ast_t *opt_callee, bool has_spread
+) {
+  if (opt_callee->right) {
+    compile_expr(c, opt_callee->left);
+    emit_op(c, OP_DUP);
+    emit_op(c, OP_IS_UNDEF_OR_NULL);
+    int j_have_obj = emit_jump(c, OP_JMP_FALSE);
+    emit_op(c, OP_POP);
+    emit_op(c, OP_UNDEF);
+    int j_end = emit_jump(c, OP_JMP);
+    patch_jump(c, j_have_obj);
+
+    compile_receiver_property_get(c, opt_callee);
+    compile_call_emit_invoke(c, node, SV_CALL_METHOD, has_spread);
+    patch_jump(c, j_end);
+    
+    return;
+  }
+
+  sv_ast_t *target = opt_callee->left;
+  if (target && target->type == N_OPTIONAL && target->right) {
+    compile_expr(c, target->left);
+    emit_op(c, OP_DUP);
+    emit_op(c, OP_IS_UNDEF_OR_NULL);
+    int j_have_obj = emit_jump(c, OP_JMP_FALSE);
+    emit_op(c, OP_POP);
+    emit_op(c, OP_UNDEF);
+    int j_end = emit_jump(c, OP_JMP);
+    patch_jump(c, j_have_obj);
+
+    compile_receiver_property_get(c, target);
+    compile_optional_call_after_setup(c, node, SV_CALL_METHOD, has_spread);
+    patch_jump(c, j_end);
+    return;
+  }
+
+  sv_call_kind_t kind = compile_call_setup_non_optional(c, target);
+  compile_optional_call_after_setup(c, node, kind, has_spread);
+}
+
+static void compile_call(sv_compiler_t *c, sv_ast_t *node) {
+  sv_ast_t *callee = node->left;
+  bool has_spread = call_has_spread_arg(node);
+
+  if (callee->type == N_OPTIONAL) {
+    compile_call_optional(c, node, callee, has_spread);
+    return;
+  }
+
+  if (!has_spread && is_ident_name(callee, "eval")) {
+    if (node->args.count > 0)
+      compile_expr(c, node->args.items[0]);
+    else
+      emit_op(c, OP_UNDEF);
+    for (int i = 1; i < node->args.count; i++) {
+      compile_expr(c, node->args.items[i]);
+      emit_op(c, OP_POP);
+    }
+    
+    emit_op(c, OP_EVAL);
+    emit_u32(c, 0);
+    
+    return;
+  }
+
+  sv_call_kind_t kind = compile_call_setup_non_optional(c, callee);
+  compile_call_emit_invoke(c, node, kind, has_spread);
+}
+
+static void compile_new(sv_compiler_t *c, sv_ast_t *node) {
+  compile_expr(c, node->left);
+  emit_op(c, OP_DUP);
+  int argc = node->args.count;
+  for (int i = 0; i < argc; i++)
+    compile_expr(c, node->args.items[i]);
+  emit_op(c, OP_NEW);
+  emit_u16(c, (uint16_t)argc);
+}
+
+static bool sv_node_has_optional_base(sv_ast_t *n) {
+  while (n) {
+    if (n->type == N_OPTIONAL) return true;
+    if (n->type == N_MEMBER || n->type == N_CALL) n = n->left;
+    else break;
+  }
+  return false;
+}
+
+static void compile_member(sv_compiler_t *c, sv_ast_t *node) {
+  if (is_ident_name(node->left, "super")) {
+    emit_op(c, OP_THIS);
+    emit_get_var(c, "super", 5);
+    if (node->flags & 1)
+      compile_expr(c, node->right);
+    else
+      emit_constant(c, js_mkstr(c->js, node->right->str, node->right->len));
+    emit_op(c, OP_GET_SUPER_VAL);
+    return;
+  }
+
+  compile_expr(c, node->left);
+
+  int ok_jump = -1, end_jump = -1;
+  if (sv_node_has_optional_base(node->left)) {
+    ok_jump  = emit_jump(c, OP_JMP_NOT_NULLISH);
+    end_jump = emit_jump(c, OP_JMP);
+    patch_jump(c, ok_jump);
+  }
+
+  if (node->flags & 1) {
+    compile_expr(c, node->right);
+    emit_op(c, OP_GET_ELEM);
+  } else {
+    if (node->right->len == 6 && memcmp(node->right->str, "length", 6) == 0)
+      emit_op(c, OP_GET_LENGTH);
+    else {
+      emit_srcpos(c, node->right);
+      emit_atom_op(c, OP_GET_FIELD, node->right->str, node->right->len);
+    }
+  }
+
+  if (end_jump >= 0) patch_jump(c, end_jump);
+}
+
+static void compile_optional_get(sv_compiler_t *c, sv_ast_t *node) {
+  if (node->flags & 1) {
+    compile_expr(c, node->right);
+    emit_op(c, OP_GET_ELEM_OPT);
+  } else {
+    emit_srcpos(c, node->right);
+    emit_atom_op(c, OP_GET_FIELD_OPT, node->right->str, node->right->len);
+  }
+}
+
+static void compile_optional(sv_compiler_t *c, sv_ast_t *node) {
+  compile_expr(c, node->left);
+  compile_optional_get(c, node);
+}
+
+static void compile_array(sv_compiler_t *c, sv_ast_t *node) {
+  int count = node->args.count;
+  bool has_spread = false;
+  for (int i = 0; i < count; i++) {
+    sv_ast_t *elem = node->args.items[i];
+    if (elem && elem->type == N_SPREAD) {
+      has_spread = true;
+      break;
+    }
+  }
+
+  if (!has_spread) {
+    for (int i = 0; i < count; i++) {
+      sv_ast_t *elem = node->args.items[i];
+      if (elem && elem->type == N_EMPTY)
+        emit_op(c, OP_EMPTY);
+      else
+        compile_expr(c, elem);
+    }
+    emit_op(c, OP_ARRAY);
+    emit_u16(c, (uint16_t)count);
+    return;
+  }
+
+  emit_op(c, OP_ARRAY);
+  emit_u16(c, 0);
+  for (int i = 0; i < count; i++) {
+    sv_ast_t *elem = node->args.items[i];
+    if (elem && elem->type == N_SPREAD) compile_concat_spread_to_array(c, elem);
+    else compile_push_arg_to_array(c, elem);
+  }
+}
+
+static void compile_object(sv_compiler_t *c, sv_ast_t *node) {
+  emit_op(c, OP_OBJECT);
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *prop = node->args.items[i];
+    if (prop->type == N_SPREAD) {
+      compile_expr(c, prop->right);
+      emit_op(c, OP_COPY_DATA_PROPS);
+      emit(c, 0);
+      emit_op(c, OP_POP);
+      continue;
+    }
+    
+    if (prop->type != N_PROPERTY) continue;
+    if (prop->flags & FN_GETTER || prop->flags & FN_SETTER) {
+      compile_expr(c, prop->right);
+      uint8_t flags = 0;
+      if (prop->flags & FN_GETTER) flags |= 1;
+      if (prop->flags & FN_SETTER) flags |= 2;
+      if (prop->flags & FN_COMPUTED) compile_expr(c, prop->left);
+      else compile_static_property_key(c, prop->left);
+      emit_op(c, OP_SWAP);
+      emit_op(c, OP_DEFINE_METHOD_COMP);
+      emit(c, flags);
+    } else if (prop->flags & FN_COMPUTED) {
+      compile_expr(c, prop->left);
+      compile_expr(c, prop->right);
+      emit_op(c, OP_DEFINE_METHOD_COMP);
+      emit(c, 0);
+    } else {
+      if (prop->right && (prop->right->type == N_FUNC || prop->right->type == N_CLASS) &&
+          (!prop->right->str || prop->right->len == 0) &&
+          prop->left && prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left)) {
+        c->inferred_name = prop->left->str;
+        c->inferred_name_len = prop->left->len;
+      }
+      compile_expr(c, prop->right);
+      if ((prop->flags & FN_COLON) &&
+          prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left) &&
+          is_ident_str(prop->left->str, prop->left->len, "__proto__", 9)) {
+        emit_op(c, OP_SET_PROTO);
+        continue;
+      }
+      if (prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left)) {
+        emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str, prop->left->len);
+      } else if (is_quoted_ident_key(prop->left)) {
+        emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str + 1, prop->left->len - 2);
+      } else if (prop->left->type == N_STRING) {
+        emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str ? prop->left->str : "", prop->left->len);
+      } else if (prop->left->type == N_NUMBER) {
+        char buf[32];
+        int n = snprintf(buf, sizeof(buf), "%g", prop->left->num);
+        emit_atom_op(c, OP_DEFINE_FIELD, buf, (uint32_t)n);
+      } else emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str, prop->left->len);
+    }
+  }
+}
+
+static void compile_func_expr(sv_compiler_t *c, sv_ast_t *node) {
+  bool has_name = node->str && node->len > 0 && !(node->flags & FN_ARROW);
+  int name_local = -1;
+
+  if (has_name) {
+    begin_scope(c);
+    name_local = add_local(c, node->str, node->len, true, c->scope_depth);
+    emit_op(c, OP_UNDEF);
+    emit_put_local(c, name_local);
+  }
+
+  sv_func_t *fn = compile_function_body(c, node, SV_COMPILE_SCRIPT);
+  if (!fn) {
+    emit_op(c, OP_UNDEF);
+    if (has_name) end_scope(c);
+    return;
+  }
+  int idx = add_constant(c, mkval(T_CFUNC, (uintptr_t)fn));
+  emit_op(c, OP_CLOSURE);
+  emit_u32(c, (uint32_t)idx);
+
+  if (node->str && node->len > 0) {
+    emit_set_function_name(c, node->str, node->len);
+  } else if (c->inferred_name) {
+    emit_set_function_name(c, c->inferred_name, c->inferred_name_len);
+    c->inferred_name = NULL;
+    c->inferred_name_len = 0;
+  } else {
+    emit_set_function_name(c, NULL, 0);
+  }
+
+  if (has_name) {
+    emit_op(c, OP_DUP);
+    emit_put_local(c, name_local);
+    end_scope(c);
+  }
+}
+
+typedef enum {
+  DESTRUCTURE_ASSIGN = 0,
+  DESTRUCTURE_BIND   = 1,
+} sv_destructure_mode_t;
+
+static void emit_build_object_rest(sv_compiler_t *c) {
+  emit_op(c, OP_DUP);
+  emit_op(c, OP_OBJECT);
+  emit_op(c, OP_SWAP);
+  emit_op(c, OP_COPY_DATA_PROPS);
+  emit(c, 0);
+  emit_op(c, OP_POP);
+}
+
+static void emit_delete_rest_key(sv_compiler_t *c, sv_ast_t *key) {
+  emit_op(c, OP_DUP);
+  if (key->type == N_IDENT) {
+    emit_constant(c, js_mkstr(c->js, key->str, key->len));
+  } else if (key->type == N_STRING) {
+    emit_constant(c, ast_string_const(c, key));
+  } else if (key->type == N_NUMBER) {
+    emit_number(c, key->num);
+  } else {
+    compile_expr(c, key);
+  }
+  emit_op(c, OP_DELETE);
+  emit_op(c, OP_POP);
+}
+
+static bool is_destructure_pattern_node(sv_ast_t *node) {
+  return node && (node->type == N_ARRAY_PAT || node->type == N_ARRAY ||
+                  node->type == N_OBJECT_PAT || node->type == N_OBJECT);
+}
+
+static void compile_destructure_pattern(sv_compiler_t *c, sv_ast_t *pat,
+                                        bool keep, bool consume_source,
+                                        sv_destructure_mode_t mode,
+                                        sv_var_kind_t kind);
+
+static void compile_destructure_store(sv_compiler_t *c, sv_ast_t *target,
+                                      sv_destructure_mode_t mode,
+                                      sv_var_kind_t kind) {
+  if (!target) return;
+
+  if (mode == DESTRUCTURE_ASSIGN) {
+    compile_lhs_set(c, target, false);
+    return;
+  }
+
+  if (target->type == N_IDENT) {
+    bool is_const = (kind == VAR_CONST);
+    int idx = ensure_local_at_depth(c, target->str, target->len,
+                                    is_const, c->scope_depth);
+    emit_put_local(c, idx);
+    return;
+  }
+
+  if (is_destructure_pattern_node(target)) {
+    compile_destructure_pattern(c, target, false, true, mode, kind);
+    return;
+  }
+
+  compile_lhs_set(c, target, false);
+}
+
+static void compile_destructure_pattern(sv_compiler_t *c, sv_ast_t *pat,
+                                        bool keep, bool consume_source,
+                                        sv_destructure_mode_t mode,
+                                        sv_var_kind_t kind) {
+  if (!pat) return;
+  if (keep) emit_op(c, OP_DUP);
+
+  if (pat->type == N_ARRAY_PAT || pat->type == N_ARRAY) {
+    for (int i = 0; i < pat->args.count; i++) {
+      sv_ast_t *elem = pat->args.items[i];
+      if (!elem || elem->type == N_EMPTY) continue;
+
+      if (elem->type == N_REST || elem->type == N_SPREAD) {
+        emit_op(c, OP_DUP);
+        emit_op(c, OP_DUP);
+        emit_atom_op(c, OP_GET_FIELD, "slice", 5);
+        emit_number(c, (double)i);
+        emit_op(c, OP_CALL_METHOD);
+        emit_u16(c, 1);
+        compile_destructure_store(c, elem->right, mode, kind);
+        continue;
+      }
+
+      sv_ast_t *target = elem;
+      sv_ast_t *default_val = NULL;
+      if (elem->type == N_ASSIGN_PAT ||
+          (elem->type == N_ASSIGN && elem->op == TOK_ASSIGN)) {
+        target = elem->left;
+        default_val = elem->right;
+      }
+
+      emit_op(c, OP_DUP);
+      emit_number(c, (double)i);
+      emit_op(c, OP_GET_ELEM);
+
+      if (default_val) {
+        emit_op(c, OP_DUP);
+        emit_op(c, OP_IS_UNDEF);
+        int skip = emit_jump(c, OP_JMP_FALSE);
+        emit_op(c, OP_POP);
+        compile_expr(c, default_val);
+        patch_jump(c, skip);
+      }
+
+      compile_destructure_store(c, target, mode, kind);
+    }
+  } else if (pat->type == N_OBJECT_PAT || pat->type == N_OBJECT) {
+    for (int i = 0; i < pat->args.count; i++) {
+      sv_ast_t *prop = pat->args.items[i];
+      if (!prop) continue;
+
+      if (prop->type == N_REST || prop->type == N_SPREAD) {
+        emit_build_object_rest(c);
+        for (int j = 0; j < i; j++) {
+          sv_ast_t *prev = pat->args.items[j];
+          if (!prev || prev->type != N_PROPERTY || !prev->left) continue;
+          emit_delete_rest_key(c, prev->left);
+        }
+        compile_destructure_store(c, prop->right, mode, kind);
+        continue;
+      }
+      if (prop->type != N_PROPERTY) continue;
+
+      sv_ast_t *key = prop->left;
+      sv_ast_t *value = prop->right;
+      sv_ast_t *default_val = NULL;
+      if (value && (value->type == N_ASSIGN_PAT ||
+                    (value->type == N_ASSIGN && value->op == TOK_ASSIGN))) {
+        default_val = value->right;
+        value = value->left;
+      }
+
+      emit_op(c, OP_DUP);
+      if ((prop->flags & FN_COMPUTED)) {
+        compile_expr(c, key);
+        emit_op(c, OP_GET_ELEM);
+      } else if (key->type == N_IDENT) {
+        emit_atom_op(c, OP_GET_FIELD, key->str, key->len);
+      } else {
+        compile_expr(c, key);
+        emit_op(c, OP_GET_ELEM);
+      }
+
+      if (default_val) {
+        emit_op(c, OP_DUP);
+        emit_op(c, OP_IS_UNDEF);
+        int skip = emit_jump(c, OP_JMP_FALSE);
+        emit_op(c, OP_POP);
+        compile_expr(c, default_val);
+        patch_jump(c, skip);
+      }
+
+      compile_destructure_store(c, value, mode, kind);
+    }
+  }
+
+  if (consume_source) emit_op(c, OP_POP);
+}
+
+static void compile_array_destructure(sv_compiler_t *c, sv_ast_t *pat,
+                                      bool keep) {
+  compile_destructure_pattern(c, pat, keep, true, DESTRUCTURE_ASSIGN, VAR_LET);
+}
+
+static void compile_object_destructure(sv_compiler_t *c, sv_ast_t *pat,
+                                       bool keep) {
+  compile_destructure_pattern(c, pat, keep, true, DESTRUCTURE_ASSIGN, VAR_LET);
+}
+
+static bool is_tail_callable(sv_compiler_t *c, sv_ast_t *node) {
+  if (c->try_depth > 0) return false;
+  if (node->type != N_CALL) return false;
+  if (call_has_spread_arg(node)) return false;
+  sv_ast_t *callee = node->left;
+  if (callee->type == N_IDENT && callee->len == 5 && memcmp(callee->str, "super", 5) == 0) return false;
+  return true;
+}
+
+static void compile_tail_call(sv_compiler_t *c, sv_ast_t *node) {
+  sv_ast_t *callee = node->left;
+
+  if (callee->type == N_OPTIONAL) {
+    compile_call(c, node);
+    emit_close_upvals(c);
+    emit_op(c, OP_RETURN);
+    return;
+  }
+
+  sv_call_kind_t kind = compile_call_setup_non_optional(c, callee);
+  int argc = node->args.count;
+  for (int i = 0; i < argc; i++)
+    compile_expr(c, node->args.items[i]);
+
+  emit_close_upvals(c);
+  emit_op(c, kind == SV_CALL_METHOD ? OP_TAIL_CALL_METHOD : OP_TAIL_CALL);
+  emit_u16(c, (uint16_t)argc);
+}
+
+static void compile_tail_return_expr(sv_compiler_t *c, sv_ast_t *expr) {
+  if (expr->type == N_TERNARY) {
+    compile_expr(c, expr->cond);
+    int else_jump = emit_jump(c, OP_JMP_FALSE);
+    compile_tail_return_expr(c, expr->left);
+    patch_jump(c, else_jump);
+    compile_tail_return_expr(c, expr->right);
+    return;
+  }
+
+  if (is_tail_callable(c, expr)) {
+    compile_tail_call(c, expr);
+    return;
+  }
+
+  compile_expr(c, expr);
+  emit_close_upvals(c);
+  emit_op(c, OP_RETURN);
+}
+
+static void compile_stmts(sv_compiler_t *c, sv_ast_list_t *list) {
+  for (int i = 0; i < list->count; i++)
+    compile_stmt(c, list->items[i]);
+}
+
+static void compile_stmt(sv_compiler_t *c, sv_ast_t *node) {
+  if (!node) return;
+  emit_srcpos(c, node);
+
+  switch (node->type) {
+    case N_EMPTY:
+    case N_DEBUGGER:
+      break;
+
+    case N_BLOCK:
+      begin_scope(c);
+      hoist_lexical_decls(c, &node->args);
+      hoist_func_decls(c, &node->args);
+      compile_stmts(c, &node->args);
+      end_scope(c);
+      break;
+
+    case N_VAR:
+      compile_var_decl(c, node);
+      break;
+
+    case N_IMPORT_DECL:
+      compile_import_decl(c, node);
+      break;
+
+    case N_EXPORT:
+      compile_export_decl(c, node);
+      break;
+
+    case N_IF:
+      compile_if(c, node);
+      break;
+
+    case N_WHILE:
+      compile_while(c, node);
+      break;
+
+    case N_DO_WHILE:
+      compile_do_while(c, node);
+      break;
+
+    case N_FOR:
+      compile_for(c, node);
+      break;
+
+    case N_FOR_IN:
+      compile_for_in(c, node);
+      break;
+
+    case N_FOR_OF:
+    case N_FOR_AWAIT_OF:
+      compile_for_of(c, node);
+      break;
+
+    case N_RETURN:
+      if (node->right) {
+        compile_tail_return_expr(c, node->right);
+      } else {
+        emit_close_upvals(c);
+        emit_op(c, OP_RETURN_UNDEF);
+      }
+      break;
+
+    case N_THROW:
+      compile_expr(c, node->right);
+      emit_op(c, OP_THROW);
+      break;
+
+    case N_BREAK:
+      compile_break(c, node);
+      break;
+
+    case N_CONTINUE:
+      compile_continue(c, node);
+      break;
+
+    case N_TRY:
+      compile_try(c, node);
+      break;
+
+    case N_SWITCH:
+      compile_switch(c, node);
+      break;
+
+    case N_LABEL:
+      compile_label(c, node);
+      break;
+
+    case N_FUNC:
+      if (node->str && !(node->flags & FN_ARROW)) break;
+      compile_expr(c, node);
+      emit_op(c, OP_POP);
+      break;
+
+    case N_CLASS:
+      compile_class(c, node);
+      emit_op(c, OP_POP);
+      break;
+
+    case N_WITH:
+      compile_expr(c, node->left);
+      emit_op(c, OP_ENTER_WITH);
+      c->with_depth++;
+      compile_stmt(c, node->body);
+      c->with_depth--;
+      emit_op(c, OP_EXIT_WITH);
+      break;
+
+    default:
+      compile_expr(c, node);
+      emit_op(c, OP_POP);
+      break;
+  }
+}
+
+enum {
+  IMPORT_BIND_DEFAULT   = 1 << 0,
+  IMPORT_BIND_NAMESPACE = 1 << 1,
+};
+
+static void compile_import_decl(sv_compiler_t *c, sv_ast_t *node) {
+  if (!node->right) return;
+  bool repl_top = is_repl_top_level(c);
+
+  compile_expr(c, node->right);
+  emit_op(c, OP_IMPORT_SYNC);
+
+  if (node->args.count == 0) {
+    emit_op(c, OP_POP);
+    return;
+  }
+
+  int ns_local = add_local(c, "", 0, false, c->scope_depth);
+  emit_put_local(c, ns_local);
+
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *spec = node->args.items[i];
+    if (!spec || spec->type != N_IMPORT_SPEC ||
+        !spec->right || spec->right->type != N_IDENT)
+      continue;
+
+    emit_get_local(c, ns_local);
+
+    if (!(spec->flags & IMPORT_BIND_NAMESPACE)) {
+      if ((spec->flags & IMPORT_BIND_DEFAULT) ||
+          !spec->left || spec->left->type != N_IDENT) {
+        emit_op(c, OP_IMPORT_DEFAULT);
+      } else {
+        emit_atom_op(c, OP_GET_FIELD, spec->left->str, spec->left->len);
+      }
+    }
+
+    if (repl_top) {
+      emit_atom_op(c, OP_PUT_GLOBAL, spec->right->str, spec->right->len);
+    } else {
+      int idx = ensure_local_at_depth(c, spec->right->str, spec->right->len,
+                                      true, c->scope_depth);
+      emit_put_local(c, idx);
+    }
+  }
+}
+
+static void compile_export_emit(sv_compiler_t *c, const char *name, uint32_t len) {
+  emit_get_var(c, name, len);
+  emit_atom_op(c, OP_EXPORT, name, len);
+}
+
+static void defer_export(sv_compiler_t *c, const char *name, uint32_t len) {
+  if (c->deferred_export_count >= c->deferred_export_cap) {
+    int cap = c->deferred_export_cap ? c->deferred_export_cap * 2 : 8;
+    c->deferred_exports = realloc(c->deferred_exports, cap * sizeof(sv_deferred_export_t));
+    c->deferred_export_cap = cap;
+  }
+  c->deferred_exports[c->deferred_export_count++] =
+    (sv_deferred_export_t){ .name = name, .len = len };
+}
+
+static void defer_export_pattern(sv_compiler_t *c, sv_ast_t *pat) {
+  if (!pat) return;
+  switch (pat->type) {
+    case N_IDENT:
+      defer_export(c, pat->str, pat->len);
+      break;
+    case N_ASSIGN_PAT:
+      defer_export_pattern(c, pat->left);
+      break;
+    case N_REST:
+    case N_SPREAD:
+      defer_export_pattern(c, pat->right);
+      break;
+    case N_ARRAY:
+    case N_ARRAY_PAT:
+      for (int i = 0; i < pat->args.count; i++)
+        defer_export_pattern(c, pat->args.items[i]);
+      break;
+    case N_OBJECT:
+    case N_OBJECT_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        sv_ast_t *prop = pat->args.items[i];
+        if (!prop) continue;
+        if (prop->type == N_PROPERTY) defer_export_pattern(c, prop->right);
+        else defer_export_pattern(c, prop);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+static void compile_export_pattern(sv_compiler_t *c, sv_ast_t *pat) {
+  if (!pat) return;
+  switch (pat->type) {
+    case N_IDENT:
+      compile_export_emit(c, pat->str, pat->len);
+      break;
+    case N_ASSIGN_PAT:
+      compile_export_pattern(c, pat->left);
+      break;
+    case N_REST:
+    case N_SPREAD:
+      compile_export_pattern(c, pat->right);
+      break;
+    case N_ARRAY:
+    case N_ARRAY_PAT:
+      for (int i = 0; i < pat->args.count; i++)
+        compile_export_pattern(c, pat->args.items[i]);
+      break;
+    case N_OBJECT:
+    case N_OBJECT_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        sv_ast_t *prop = pat->args.items[i];
+        if (!prop) continue;
+        if (prop->type == N_PROPERTY) compile_export_pattern(c, prop->right);
+        else compile_export_pattern(c, prop);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+static void compile_export_decl(sv_compiler_t *c, sv_ast_t *node) {
+  if (!node) return;
+
+  if (node->flags & EX_DEFAULT) {
+    if (node->left) compile_expr(c, node->left);
+    else emit_op(c, OP_UNDEF);
+    emit_atom_op(c, OP_EXPORT, "default", 7);
+    return;
+  }
+
+  if ((node->flags & EX_DECL) && node->left) {
+    sv_ast_t *decl = node->left;
+    if (decl->type == N_VAR) {
+      compile_var_decl(c, decl);
+      bool is_var = decl->var_kind == VAR_VAR;
+      for (int i = 0; i < decl->args.count; i++) {
+        sv_ast_t *var = decl->args.items[i];
+        if (!var || var->type != N_VARDECL) continue;
+        if (is_var && c->mode == SV_COMPILE_MODULE)
+          defer_export_pattern(c, var->left);
+        else
+          compile_export_pattern(c, var->left);
+      }
+      return;
+    }
+
+    compile_stmt(c, decl);
+    if ((decl->type == N_FUNC || decl->type == N_CLASS) &&
+        decl->str && decl->len > 0) {
+      compile_export_emit(c, decl->str, decl->len);
+    }
+    return;
+  }
+
+  if ((node->flags & EX_STAR) && (node->flags & EX_FROM) && node->right) {
+    compile_expr(c, node->right);
+    emit_op(c, OP_IMPORT_SYNC);
+
+    if (node->flags & EX_NAMESPACE) {
+      if (node->args.count > 0) {
+        sv_ast_t *spec = node->args.items[0];
+        if (spec && spec->type == N_IMPORT_SPEC &&
+            spec->right && spec->right->type == N_IDENT) {
+          emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
+          return;
+        }
+      }
+      emit_op(c, OP_POP);
+      return;
+    }
+
+    emit_op(c, OP_EXPORT_ALL);
+    return;
+  }
+
+  if (!(node->flags & EX_NAMED) || node->args.count == 0) return;
+
+  int ns_local = -1;
+  if (node->flags & EX_FROM) {
+    if (!node->right) return;
+    compile_expr(c, node->right);
+    emit_op(c, OP_IMPORT_SYNC);
+    ns_local = add_local(c, "", 0, false, c->scope_depth);
+    emit_put_local(c, ns_local);
+  }
+
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *spec = node->args.items[i];
+    if (!spec || spec->type != N_IMPORT_SPEC || !spec->left || !spec->right ||
+        spec->left->type != N_IDENT || spec->right->type != N_IDENT)
+      continue;
+
+    if (node->flags & EX_FROM) {
+      emit_get_local(c, ns_local);
+      if (spec->left->len == 7 && memcmp(spec->left->str, "default", 7) == 0)
+        emit_op(c, OP_IMPORT_DEFAULT);
+      else
+        emit_atom_op(c, OP_GET_FIELD, spec->left->str, spec->left->len);
+      emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
+    } else {
+      emit_get_var(c, spec->left->str, spec->left->len);
+      emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
+    }
+  }
+}
+
+static void compile_var_decl(sv_compiler_t *c, sv_ast_t *node) {
+  sv_var_kind_t kind = node->var_kind;
+  bool is_const = (kind == VAR_CONST);
+  bool repl_top = is_repl_top_level(c);
+
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *decl = node->args.items[i];
+    if (decl->type != N_VARDECL) continue;
+    sv_ast_t *target = decl->left;
+
+    if (repl_top) {
+      if (!decl->right && kind == VAR_VAR) continue;
+      if (decl->right) {
+        compile_expr(c, decl->right);
+      } else {
+        emit_op(c, OP_UNDEF);
+      }
+      if (target->type == N_IDENT) {
+        emit_atom_op(c, OP_PUT_GLOBAL, target->str, target->len);
+      } else {
+        compile_destructure_pattern(c, target, false, true,
+                                    DESTRUCTURE_ASSIGN, kind);
+      }
+    } else if (kind == VAR_VAR) {
+      if (decl->right) {
+        compile_expr(c, decl->right);
+        compile_lhs_set(c, target, false);
+      }
+    } else {
+      if (target->type == N_IDENT) {
+        int idx = ensure_local_at_depth(c, target->str, target->len,
+                                        is_const, c->scope_depth);
+        if (decl->right) {
+          compile_expr(c, decl->right);
+        } else if (!is_const) {
+          emit_op(c, OP_UNDEF);
+        }
+        if (decl->right || !is_const) {
+          emit_put_local(c, idx);
+          c->locals[idx].is_tdz = false;
+        }
+      } else {
+        if (decl->right) {
+          compile_expr(c, decl->right);
+          compile_destructure_binding(c, target, kind);
+          emit_op(c, OP_POP);
+        }
+      }
+    }
+  }
+}
+
+static void compile_destructure_binding(sv_compiler_t *c, sv_ast_t *pat,
+                                         sv_var_kind_t kind) {
+  compile_destructure_pattern(c, pat, false, false, DESTRUCTURE_BIND, kind);
+}
+
+
+static void compile_if(sv_compiler_t *c, sv_ast_t *node) {
+  compile_expr(c, node->cond);
+  int else_jump = emit_jump(c, OP_JMP_FALSE);
+  compile_stmt(c, node->left);
+  if (node->right) {
+    int end_jump = emit_jump(c, OP_JMP);
+    patch_jump(c, else_jump);
+    compile_stmt(c, node->right);
+    patch_jump(c, end_jump);
+  } else {
+    patch_jump(c, else_jump);
+  }
+}
+
+
+static void compile_while(sv_compiler_t *c, sv_ast_t *node) {
+  int loop_start = c->code_len;
+  push_loop(c, loop_start, NULL, 0);
+
+  compile_expr(c, node->cond);
+  int exit_jump = emit_jump(c, OP_JMP_FALSE);
+  compile_stmt(c, node->body);
+
+  sv_loop_t *loop = &c->loops[c->loop_count - 1];
+  for (int i = 0; i < loop->continues.count; i++)
+    patch_jump(c, loop->continues.offsets[i]);
+
+  emit_loop(c, loop_start);
+  patch_jump(c, exit_jump);
+  pop_loop(c);
+}
+
+
+static void compile_do_while(sv_compiler_t *c, sv_ast_t *node) {
+  int loop_start = c->code_len;
+  push_loop(c, loop_start, NULL, 0);
+
+  compile_stmt(c, node->body);
+
+  sv_loop_t *loop = &c->loops[c->loop_count - 1];
+  int cond_start = c->code_len;
+  for (int i = 0; i < loop->continues.count; i++)
+    patch_jump(c, loop->continues.offsets[i]);
+
+  compile_expr(c, node->cond);
+  int exit_jump = emit_jump(c, OP_JMP_FALSE);
+  emit_loop(c, loop_start);
+  patch_jump(c, exit_jump);
+  pop_loop(c);
+  (void)cond_start;
+}
+
+
+static void for_add_slot_unique(int **slots, int *count, int *cap, int slot) {
+  if (slot < 0) return;
+  for (int i = 0; i < *count; i++) {
+    if ((*slots)[i] == slot) return;
+  }
+  if (*count >= *cap) {
+    int new_cap = (*cap > 0) ? (*cap * 2) : 8;
+    int *new_slots = realloc(*slots, (size_t)new_cap * sizeof(int));
+    if (!new_slots) return;
+    *slots = new_slots;
+    *cap = new_cap;
+  }
+  (*slots)[(*count)++] = slot;
+}
+
+static void for_collect_pattern_slots(sv_compiler_t *c, sv_ast_t *pat,
+                                      int **slots, int *count, int *cap) {
+  if (!pat) return;
+  switch (pat->type) {
+    case N_IDENT: {
+      int slot = resolve_local(c, pat->str, pat->len);
+      for_add_slot_unique(slots, count, cap, slot);
+      break;
+    }
+    case N_ASSIGN_PAT:
+      for_collect_pattern_slots(c, pat->left, slots, count, cap);
+      break;
+    case N_REST:
+    case N_SPREAD:
+      for_collect_pattern_slots(c, pat->right, slots, count, cap);
+      break;
+    case N_ARRAY:
+    case N_ARRAY_PAT:
+      for (int i = 0; i < pat->args.count; i++)
+        for_collect_pattern_slots(c, pat->args.items[i], slots, count, cap);
+      break;
+    case N_OBJECT:
+    case N_OBJECT_PAT:
+      for (int i = 0; i < pat->args.count; i++) {
+        sv_ast_t *prop = pat->args.items[i];
+        if (!prop) continue;
+        if (prop->type == N_PROPERTY)
+          for_collect_pattern_slots(c, prop->right, slots, count, cap);
+        else
+          for_collect_pattern_slots(c, prop, slots, count, cap);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+static void for_collect_var_decl_slots(sv_compiler_t *c, sv_ast_t *init_var,
+                                       int **slots, int *count, int *cap) {
+  if (!init_var || init_var->type != N_VAR) return;
+  for (int i = 0; i < init_var->args.count; i++) {
+    sv_ast_t *decl = init_var->args.items[i];
+    if (!decl || decl->type != N_VARDECL || !decl->left) continue;
+    for_collect_pattern_slots(c, decl->left, slots, count, cap);
+  }
+}
+
+static void compile_for(sv_compiler_t *c, sv_ast_t *node) {
+  begin_scope(c);
+
+  int *iter_slots = NULL;
+  int iter_count = 0;
+  int iter_cap = 0;
+
+  if (node->init) {
+    if (node->init->type == N_VAR) {
+      sv_var_kind_t kind = node->init->var_kind;
+      compile_var_decl(c, node->init);
+      if (kind == VAR_LET || kind == VAR_CONST)
+        for_collect_var_decl_slots(c, node->init, &iter_slots, &iter_count, &iter_cap);
+    } else {
+      compile_expr(c, node->init);
+      emit_op(c, OP_POP);
+    }
+  }
+
+  int loop_start = c->code_len;
+  push_loop(c, loop_start, NULL, 0);
+
+  int exit_jump = -1;
+  if (node->cond) {
+    compile_expr(c, node->cond);
+    exit_jump = emit_jump(c, OP_JMP_FALSE);
+  }
+
+  int iter_inner_start = -1;
+  if (iter_count > 0) {
+    begin_scope(c);
+    iter_inner_start = c->local_count;
+    for (int i = 0; i < iter_count; i++) {
+      int outer_idx = iter_slots[i];
+      sv_local_t outer = c->locals[outer_idx];
+      emit_get_local(c, outer_idx);
+      int inner_idx = add_local(c, outer.name, outer.name_len,
+                                outer.is_const, c->scope_depth);
+      emit_put_local(c, inner_idx);
+    }
+  }
+
+  compile_stmt(c, node->body);
+
+  sv_loop_t *loop = &c->loops[c->loop_count - 1];
+  for (int i = 0; i < loop->continues.count; i++)
+    patch_jump(c, loop->continues.offsets[i]);
+
+  int break_close_slot = -1;
+  if (iter_count > 0) {
+    for (int i = 0; i < iter_count; i++) {
+      int inner_idx = iter_inner_start + i;
+      if (!c->locals[inner_idx].captured) continue;
+      int slot = local_to_frame_slot(c, inner_idx);
+      if (break_close_slot < 0 || slot < break_close_slot)
+        break_close_slot = slot;
+    }
+
+    for (int i = 0; i < iter_count; i++) {
+      emit_get_local(c, iter_inner_start + i);
+      emit_put_local(c, iter_slots[i]);
+    }
+    end_scope(c);
+  }
+
+  if (node->update) {
+    sv_ast_t *upd = node->update;
+    int slot;
+    if (upd->type == N_UPDATE && upd->right && upd->right->type == N_IDENT &&
+        (slot = resolve_local_slot(c, upd->right->str, upd->right->len)) >= 0) {
+      emit_op(c, upd->op == TOK_POSTINC ? OP_INC_LOCAL : OP_DEC_LOCAL);
+      emit(c, (uint8_t)slot);
+    } else {
+      compile_expr(c, upd);
+      emit_op(c, OP_POP);
+    }
+  }
+
+  emit_loop(c, loop_start);
+  if (exit_jump >= 0) patch_jump(c, exit_jump);
+
+  int skip_break_cleanup = -1;
+  if (break_close_slot >= 0)
+    skip_break_cleanup = emit_jump(c, OP_JMP);
+
+  pop_loop(c);
+
+  if (break_close_slot >= 0) {
+    emit_op(c, OP_CLOSE_UPVAL);
+    emit_u16(c, (uint16_t)break_close_slot);
+    patch_jump(c, skip_break_cleanup);
+  }
+
+  free(iter_slots);
+  end_scope(c);
+}
+
+
+static void compile_for_each(sv_compiler_t *c, sv_ast_t *node, bool is_for_of);
+
+static void compile_for_in(sv_compiler_t *c, sv_ast_t *node) {
+  compile_for_each(c, node, false);
+}
+
+
+static void compile_for_of(sv_compiler_t *c, sv_ast_t *node) {
+  compile_for_each(c, node, true);
+}
+
+static void compile_for_each_assign_target(sv_compiler_t *c, sv_ast_t *lhs) {
+  if (!lhs) return;
+  if (lhs->type == N_VAR && lhs->args.count > 0) {
+    sv_ast_t *decl = lhs->args.items[0];
+    sv_ast_t *target = decl->left ? decl->left : decl;
+    if (target->type == N_IDENT) {
+      int loc = resolve_local(c, target->str, target->len);
+      if (loc == -1) {
+        bool is_const = (lhs->var_kind == VAR_CONST);
+        loc = add_local(c, target->str, target->len, is_const, c->scope_depth);
+      }
+      emit_put_local(c, loc);
+    } else {
+      if (lhs->var_kind == VAR_VAR) {
+        compile_lhs_set(c, target, false);
+      } else {
+        compile_destructure_binding(c, target, lhs->var_kind);
+        emit_op(c, OP_POP);
+      }
+    }
+    return;
+  }
+  if (lhs->type == N_IDENT) {
+    emit_set_var(c, lhs->str, lhs->len, false);
+    return;
+  }
+  compile_lhs_set(c, lhs, false);
+}
+
+static void compile_for_each(sv_compiler_t *c, sv_ast_t *node, bool is_for_of) {
+  begin_scope(c);
+
+  int *iter_slots = NULL;
+  int iter_count = 0;
+  int iter_cap = 0;
+
+  if (node->left && node->left->type == N_VAR &&
+      node->left->var_kind != VAR_VAR) {
+    bool is_const = (node->left->var_kind == VAR_CONST);
+    int lb = c->local_count;
+    for (int i = 0; i < node->left->args.count; i++) {
+      sv_ast_t *decl = node->left->args.items[i];
+      if (!decl || decl->type != N_VARDECL || !decl->left) continue;
+      hoist_lexical_pattern(c, decl->left, is_const);
+    }
+    for (int i = lb; i < c->local_count; i++) {
+      c->locals[i].is_tdz = true;
+      int slot = i - c->param_locals;
+      emit_op(c, OP_SET_LOCAL_UNDEF);
+      emit_u16(c, (uint16_t)slot);
+    }
+    for_collect_var_decl_slots(c, node->left, &iter_slots, &iter_count, &iter_cap);
+  }
+
+  if (!is_for_of && node->left && node->left->type == N_VAR &&
+      node->left->var_kind == VAR_VAR && node->left->args.count > 0) {
+    sv_ast_t *decl = node->left->args.items[0];
+    if (decl && decl->right) {
+      compile_expr(c, decl->right);
+      sv_ast_t *target = decl->left ? decl->left : decl;
+      if (target->type == N_IDENT) {
+        int loc = resolve_local(c, target->str, target->len);
+        if (loc == -1)
+          loc = add_local(c, target->str, target->len, false, c->scope_depth);
+        emit_put_local(c, loc);
+      } else {
+        compile_lhs_set(c, target, false);
+      }
+    }
+  }
+
+  int iter_local = -1;
+  int idx_local = -1;
+  int exit_jump = -1;
+  int try_jump_for_of = -1;
+  int iter_err_local = -1;
+  int break_close_slot = -1;
+  int iter_inner_start = -1;
+
+  bool is_for_await = (node->type == N_FOR_AWAIT_OF);
+  compile_expr(c, node->right);
+  if (is_for_of) {
+    emit_op(c, is_for_await ? OP_FOR_AWAIT_OF : OP_FOR_OF);
+    iter_err_local = add_local(c, "", 0, false, c->scope_depth);
+    try_jump_for_of = emit_jump(c, OP_TRY_PUSH);
+    c->try_depth++;
+  } else {
+    emit_op(c, OP_FOR_IN);  
+    iter_local = add_local(c, "", 0, false, c->scope_depth);
+    emit_put_local(c, iter_local);
+
+    emit_number(c, 0);
+    idx_local = add_local(c, "", 0, false, c->scope_depth);
+    emit_put_local(c, idx_local);
+  }
+
+  int loop_start = c->code_len;
+  push_loop(c, loop_start, NULL, 0);
+
+  if (is_for_of) {
+    emit_op(c, is_for_await ? OP_AWAIT_ITER_NEXT : OP_ITER_NEXT);
+    exit_jump = emit_jump(c, OP_JMP_TRUE);  
+  } else {
+    emit_get_local(c, idx_local);
+    emit_get_local(c, iter_local);
+    emit_op(c, OP_GET_LENGTH);
+    emit_op(c, OP_LT);
+    exit_jump = emit_jump(c, OP_JMP_FALSE);
+
+    emit_get_local(c, iter_local);
+    emit_get_local(c, idx_local);
+    emit_op(c, OP_GET_ELEM);
+  }
+
+  compile_for_each_assign_target(c, node->left);
+
+  if (iter_count > 0) {
+    begin_scope(c);
+    iter_inner_start = c->local_count;
+    for (int i = 0; i < iter_count; i++) {
+      int outer_idx = iter_slots[i];
+      sv_local_t outer = c->locals[outer_idx];
+      emit_get_local(c, outer_idx);
+      int inner_idx = add_local(c, outer.name, outer.name_len,
+                                outer.is_const, c->scope_depth);
+      emit_put_local(c, inner_idx);
+    }
+  }
+
+  compile_stmt(c, node->body);
+
+  sv_loop_t *loop = &c->loops[c->loop_count - 1];
+  for (int i = 0; i < loop->continues.count; i++)
+    patch_jump(c, loop->continues.offsets[i]);
+
+  if (iter_count > 0) {
+    for (int i = 0; i < iter_count; i++) {
+      int inner_idx = iter_inner_start + i;
+      if (!c->locals[inner_idx].captured) continue;
+      int slot = local_to_frame_slot(c, inner_idx);
+      if (break_close_slot < 0 || slot < break_close_slot)
+        break_close_slot = slot;
+    }
+    end_scope(c);
+  }
+
+  if (!is_for_of) {
+    emit_get_local(c, idx_local);
+    emit_op(c, OP_INC);
+    emit_put_local(c, idx_local);
+  }
+
+  emit_loop(c, loop_start);
+  patch_jump(c, exit_jump);
+
+  int skip_break_cleanup = -1;
+  if (break_close_slot >= 0)
+    skip_break_cleanup = emit_jump(c, OP_JMP);
+
+  if (is_for_of) {
+    emit_op(c, OP_POP);
+    emit_op(c, OP_TRY_POP);
+
+    pop_loop(c);
+    if (break_close_slot >= 0) {
+      emit_op(c, OP_CLOSE_UPVAL);
+      emit_u16(c, (uint16_t)break_close_slot);
+      patch_jump(c, skip_break_cleanup);
+    }
+    emit_op(c, OP_TRY_POP);   
+    emit_op(c, OP_ITER_CLOSE);
+    int end_jump = emit_jump(c, OP_JMP);
+
+    patch_jump(c, try_jump_for_of);
+    int catch_tag = emit_jump(c, OP_CATCH);
+    emit_put_local(c, iter_err_local);  
+    emit_op(c, OP_ITER_CLOSE);          
+    emit_get_local(c, iter_err_local);  
+    emit_op(c, OP_THROW);              
+    patch_jump(c, catch_tag);
+
+    patch_jump(c, end_jump);
+    c->try_depth--;
+  } else {
+    pop_loop(c);
+    if (break_close_slot >= 0) {
+      emit_op(c, OP_CLOSE_UPVAL);
+      emit_u16(c, (uint16_t)break_close_slot);
+      patch_jump(c, skip_break_cleanup);
+    }
+  }
+
+  free(iter_slots);
+  end_scope(c);
+}
+
+
+static void compile_break(sv_compiler_t *c, sv_ast_t *node) {
+  if (c->loop_count == 0) return;
+
+  int target = c->loop_count - 1;
+  if (node->str) {
+    for (int i = c->loop_count - 1; i >= 0; i--) {
+      if (c->loops[i].label &&
+          c->loops[i].label_len == node->len &&
+          memcmp(c->loops[i].label, node->str, node->len) == 0) {
+        target = i;
+        break;
+      }
+    }
+  }
+
+  int offset = emit_jump(c, OP_JMP);
+  patch_list_add(&c->loops[target].breaks, offset);
+}
+
+
+static void compile_continue(sv_compiler_t *c, sv_ast_t *node) {
+  if (c->loop_count == 0) return;
+
+  int target = c->loop_count - 1;
+  if (node->str) {
+    for (int i = c->loop_count - 1; i >= 0; i--) {
+      if (c->loops[i].label &&
+          c->loops[i].label_len == node->len &&
+          memcmp(c->loops[i].label, node->str, node->len) == 0) {
+        target = i;
+        break;
+      }
+    }
+  }
+
+  int offset = emit_jump(c, OP_JMP);
+  patch_list_add(&c->loops[target].continues, offset);
+}
+
+static void compile_finally_block(sv_compiler_t *c, sv_ast_t *finally_body) {
+  int finally_jump = emit_jump(c, OP_FINALLY);
+  compile_stmt(c, finally_body);
+  emit_op(c, OP_FINALLY_RET);
+  patch_jump(c, finally_jump);
+}
+
+static void compile_catch_body(sv_compiler_t *c, sv_ast_t *node) {
+  begin_scope(c);
+  if (node->catch_param && node->catch_param->type == N_IDENT) {
+    int loc = add_local(c, node->catch_param->str,
+                        node->catch_param->len, false, c->scope_depth);
+    emit_put_local(c, loc);
+  } else if (node->catch_param && is_destructure_pattern_node(node->catch_param)) {
+    compile_destructure_binding(c, node->catch_param, VAR_LET);
+    emit_op(c, OP_POP);
+  } else {
+    emit_op(c, OP_POP);  
+  }
+  compile_stmt(c, node->catch_body);
+  end_scope(c);
+}
+
+static void compile_try(sv_compiler_t *c, sv_ast_t *node) {
+  c->try_depth++;
+  int try_jump = emit_jump(c, OP_TRY_PUSH);
+
+  compile_stmt(c, node->body);
+  emit_op(c, OP_TRY_POP);
+
+  bool has_catch = (node->catch_body != NULL);
+  bool has_finally = (node->finally_body != NULL);
+
+  if (!has_finally) {
+    int end_jump = emit_jump(c, OP_JMP);
+    patch_jump(c, try_jump);
+    int catch_tag = emit_jump(c, OP_CATCH);
+    if (has_catch)
+      compile_catch_body(c, node);
+    else
+      emit_op(c, OP_POP);
+    patch_jump(c, catch_tag);
+    patch_jump(c, end_jump);
+    c->try_depth--;
+    return;
+  }
+
+  int to_finally_from_try = emit_jump(c, OP_JMP);
+  int to_finally_from_catch = -1;
+  int to_finally_from_throw = -1;
+
+  patch_jump(c, try_jump);
+
+  if (has_catch) {
+    int catch_tag = emit_jump(c, OP_CATCH);
+    int catch_throw_jump = emit_jump(c, OP_TRY_PUSH);
+
+    compile_catch_body(c, node);
+    emit_op(c, OP_TRY_POP);
+    to_finally_from_catch = emit_jump(c, OP_JMP);
+
+    patch_jump(c, catch_throw_jump);
+    emit_op(c, OP_POP);  
+    to_finally_from_throw = emit_jump(c, OP_JMP);
+
+    patch_jump(c, catch_tag);
+  } else {
+    emit_op(c, OP_POP);  
+    to_finally_from_throw = emit_jump(c, OP_JMP);
+  }
+
+  patch_jump(c, to_finally_from_try);
+  if (to_finally_from_catch >= 0) patch_jump(c, to_finally_from_catch);
+  if (to_finally_from_throw >= 0) patch_jump(c, to_finally_from_throw);
+
+  compile_finally_block(c, node->finally_body);
+
+  c->try_depth--;
+}
+
+
+static void compile_switch(sv_compiler_t *c, sv_ast_t *node) {
+  int case_count = node->args.count;
+  int default_case = -1;
+  int *match_to_stub = NULL;
+  int *stub_to_body = NULL;
+
+  if (case_count > 0) {
+    match_to_stub = calloc((size_t)case_count, sizeof(int));
+    stub_to_body = calloc((size_t)case_count, sizeof(int));
+    for (int i = 0; i < case_count; i++) {
+      match_to_stub[i] = -1;
+      stub_to_body[i] = -1;
+    }
+  }
+
+  compile_expr(c, node->cond);  
+  begin_scope(c);
+  push_loop(c, c->code_len, NULL, 0);  
+
+  for (int i = 0; i < case_count; i++) {
+    sv_ast_t *cas = node->args.items[i];
+    if (!cas->left) {
+      default_case = i;
+      continue;
+    }
+    emit_op(c, OP_DUP);
+    compile_expr(c, cas->left);
+    emit_op(c, OP_SEQ);
+    match_to_stub[i] = emit_jump(c, OP_JMP_TRUE);
+  }
+
+  int miss_jump = emit_jump(c, OP_JMP);
+  int default_to_body = -1;
+  int miss_to_end = -1;
+
+  for (int i = 0; i < case_count; i++) {
+    if (match_to_stub[i] < 0) continue;
+    patch_jump(c, match_to_stub[i]);
+    emit_op(c, OP_POP);
+    stub_to_body[i] = emit_jump(c, OP_JMP);
+  }
+
+  patch_jump(c, miss_jump);
+  emit_op(c, OP_POP);
+  if (default_case >= 0)
+    default_to_body = emit_jump(c, OP_JMP);
+  else
+    miss_to_end = emit_jump(c, OP_JMP);
+
+  for (int i = 0; i < case_count; i++) {
+    if (i == default_case && default_to_body >= 0)
+      patch_jump(c, default_to_body);
+    if (stub_to_body[i] >= 0)
+      patch_jump(c, stub_to_body[i]);
+
+    sv_ast_t *cas = node->args.items[i];
+    compile_stmts(c, &cas->args);
+  }
+
+  if (miss_to_end >= 0)
+    patch_jump(c, miss_to_end);
+
+  free(match_to_stub);
+  free(stub_to_body);
+  pop_loop(c);
+  end_scope(c);
+}
+
+
+static inline bool is_loop_node(sv_ast_t *n) {
+  return n && (n->type == N_WHILE || n->type == N_DO_WHILE ||
+               n->type == N_FOR   || n->type == N_FOR_IN  ||
+               n->type == N_FOR_OF || n->type == N_FOR_AWAIT_OF);
+}
+
+static void compile_label(sv_compiler_t *c, sv_ast_t *node) {
+  if (is_loop_node(node->body)) {
+    c->pending_label = node->str;
+    c->pending_label_len = node->len;
+    compile_stmt(c, node->body);
+    c->pending_label = NULL;
+    c->pending_label_len = 0;
+  } else {
+    push_loop(c, c->code_len, node->str, node->len);
+    compile_stmt(c, node->body);
+    pop_loop(c);
+  }
+}
+
+
+static void emit_field_inits(sv_compiler_t *c, sv_ast_t **fields, int count) {
+  sv_compiler_t *enc = c->enclosing;
+  for (int i = 0; i < count; i++) {
+    sv_ast_t *m = fields[i];
+    emit_op(c, OP_THIS);
+    if (m->right) compile_expr(c, m->right);
+    else emit_op(c, OP_UNDEF);
+    if (m->flags & FN_COMPUTED) {
+      int key_local = enc->computed_key_locals[i];
+      enc->locals[key_local].captured = true;
+      uint16_t slot = (uint16_t)local_to_frame_slot(enc, key_local);
+      int uv = add_upvalue(c, slot, true, false);
+      emit_op(c, OP_GET_UPVAL);
+      emit_u16(c, (uint16_t)uv);
+    } else {
+      compile_static_property_key(c, m->left);
+    }
+    emit_op(c, OP_SWAP);
+    emit_op(c, OP_DEFINE_METHOD_COMP);
+    emit(c, 0);
+    emit_op(c, OP_POP);
+  }
+}
+
+
+static sv_ast_t *find_class_constructor(sv_ast_t *node) {
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *m = node->args.items[i];
+    if (m->type == N_METHOD && m->left && m->left->type == N_IDENT &&
+        m->left->len == 11 &&
+        memcmp(m->left->str, "constructor", 11) == 0) {
+      return m;
+    }
+  }
+  return NULL;
+}
+
+static void compile_class_method(sv_compiler_t *c, sv_ast_t *m,
+                                 int ctor_local, int proto_local,
+                                 int preeval_key) {
+  bool is_static = !!(m->flags & FN_STATIC);
+  int home_local = is_static ? ctor_local : proto_local;
+  bool is_fn = (m->right && m->right->type == N_FUNC);
+
+  if (is_fn) {
+    compile_func_expr(c, m->right);   
+    emit_get_local(c, home_local);    
+    emit_op(c, OP_SET_HOME_OBJ);      
+    emit_op(c, OP_SWAP);              
+  } else {
+    emit_get_local(c, home_local);    
+    if (m->right) compile_expr(c, m->right);
+    else emit_op(c, OP_UNDEF);        
+  }
+
+  uint8_t method_flags = 0;
+  if (m->flags & FN_GETTER) method_flags |= 1;
+  if (m->flags & FN_SETTER) method_flags |= 2;
+
+  if (m->flags & FN_COMPUTED) {
+    if (preeval_key >= 0) emit_get_local(c, preeval_key);
+    else compile_expr(c, m->left);
+  } else compile_static_property_key(c, m->left); 
+  emit_op(c, OP_SWAP);                          
+  emit_op(c, OP_DEFINE_METHOD_COMP);
+  emit(c, method_flags);                        
+  emit_op(c, OP_POP);
+}
+
+static void compile_class(sv_compiler_t *c, sv_ast_t *node) {
+  int outer_name_local = -1;
+  bool class_repl_top = is_repl_top_level(c);
+  if (node->str)
+    outer_name_local = resolve_local(c, node->str, node->len);
+
+  if (node->left)
+    compile_expr(c, node->left);
+  else
+    emit_op(c, OP_UNDEF);
+
+  sv_ast_t *ctor_method = find_class_constructor(node);
+
+  int field_count = 0;
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *m = node->args.items[i];
+    if (m->type != N_METHOD) continue;
+    if (m == ctor_method) continue;
+    if (m->flags & FN_STATIC) continue;
+    bool is_fn = (m->right && m->right->type == N_FUNC);
+    if (!is_fn) field_count++;
+  }
+
+  sv_ast_t **field_inits = NULL;
+  int *computed_key_locals = NULL;
+  if (field_count > 0) {
+    field_inits = malloc(sizeof(sv_ast_t *) * field_count);
+    computed_key_locals = malloc(sizeof(int) * field_count);
+    int fi = 0;
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *m = node->args.items[i];
+      if (m->type != N_METHOD) continue;
+      if (m == ctor_method) continue;
+      if (m->flags & FN_STATIC) continue;
+      bool is_fn = (m->right && m->right->type == N_FUNC);
+      if (!is_fn) {
+        field_inits[fi] = m;
+        if (m->flags & FN_COMPUTED) {
+          compile_expr(c, m->left);
+          int loc = add_local(c, "", 0, false, c->scope_depth);
+          emit_put_local(c, loc);
+          computed_key_locals[fi] = loc;
+        } else {
+          computed_key_locals[fi] = -1;
+        }
+        fi++;
+      }
+    }
+  }
+
+  int *method_comp_keys = NULL;
+  if (node->str) {
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *m = node->args.items[i];
+      if (m->type != N_METHOD || !(m->flags & FN_COMPUTED)) continue;
+      if (m == ctor_method) continue;
+      bool is_fn = (m->right && m->right->type == N_FUNC);
+      if (!is_fn && !(m->flags & FN_STATIC)) continue;
+      if (!method_comp_keys) {
+        method_comp_keys = malloc(sizeof(int) * node->args.count);
+        for (int j = 0; j < node->args.count; j++) method_comp_keys[j] = -1;
+      }
+      compile_expr(c, m->left);
+      int loc = add_local(c, "", 0, false, c->scope_depth);
+      emit_put_local(c, loc);
+      method_comp_keys[i] = loc;
+    }
+  }
+
+  int inner_name_local = -1;
+  if (node->str) {
+    begin_scope(c);
+    inner_name_local = add_local(c, node->str, node->len, true, c->scope_depth);
+  }
+
+  if (ctor_method && ctor_method->right) {
+    c->field_inits = field_inits;
+    c->field_init_count = field_count;
+    c->computed_key_locals = computed_key_locals;
+    compile_func_expr(c, ctor_method->right);
+    c->field_inits = NULL;
+    c->field_init_count = 0;
+    c->computed_key_locals = NULL;
+  } else if (field_count > 0) {
+    c->computed_key_locals = computed_key_locals;
+    sv_compiler_t comp = {0};
+    comp.js = c->js;
+    comp.source = c->source;
+    comp.source_len = c->source_len;
+    comp.enclosing = c;
+    comp.scope_depth = 0;
+    comp.is_strict = c->is_strict;
+    comp.param_count = 0;
+
+    emit_field_inits(&comp, field_inits, field_count);
+    emit_op(&comp, OP_RETURN_UNDEF);
+
+    sv_func_t *fn = code_arena_bump(sizeof(sv_func_t));
+    memset(fn, 0, sizeof(sv_func_t));
+    fn->code = code_arena_bump((size_t)comp.code_len);
+    memcpy(fn->code, comp.code, (size_t)comp.code_len);
+    fn->code_len = comp.code_len;
+    if (comp.const_count > 0) {
+      fn->constants = code_arena_bump((size_t)comp.const_count * sizeof(jsval_t));
+      memcpy(fn->constants, comp.constants, (size_t)comp.const_count * sizeof(jsval_t));
+      fn->const_count = comp.const_count;
+    }
+    if (comp.atom_count > 0) {
+      fn->atoms = code_arena_bump((size_t)comp.atom_count * sizeof(sv_atom_t));
+      memcpy(fn->atoms, comp.atoms, (size_t)comp.atom_count * sizeof(sv_atom_t));
+      fn->atom_count = comp.atom_count;
+    }
+    if (comp.upvalue_count > 0) {
+      fn->upval_descs = code_arena_bump(
+        (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
+      memcpy(fn->upval_descs, comp.upval_descs,
+             (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
+      fn->upvalue_count = comp.upvalue_count;
+    }
+    fn->max_locals = comp.max_local_count;
+    fn->max_stack = fn->max_locals + 64;
+    fn->param_count = comp.param_count;
+    fn->is_strict = comp.is_strict;
+    fn->filename = c->js->filename;
+    fn->source_line = (int)node->line;
+    if (node->str && node->len > 0) {
+      char *name = code_arena_bump(node->len + 1);
+      memcpy(name, node->str, node->len);
+      name[node->len] = '\0';
+      fn->name = name;
+    }
+    free(comp.code); free(comp.constants); free(comp.atoms);
+    free(comp.locals); free(comp.upval_descs); free(comp.loops);
+
+    int idx = add_constant(c, mkval(T_CFUNC, (uintptr_t)fn));
+    emit_op(c, OP_CLOSURE);
+    emit_u32(c, (uint32_t)idx);
+  } else emit_op(c, OP_UNDEF);
+  
+  free(field_inits);
+  free(computed_key_locals);
+  c->computed_key_locals = NULL;
+
+  bool has_static_name = false;
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *m = node->args.items[i];
+    if (m->type != N_METHOD) continue;
+    if (!(m->flags & FN_STATIC)) continue;
+    if (m->flags & FN_COMPUTED) continue;
+    if (m->left && m->left->str && m->left->len == 4 &&
+        memcmp(m->left->str, "name", 4) == 0) {
+      has_static_name = true;
+      break;
+    }
+  }
+
+  if (node->str && !has_static_name) {
+    int atom = add_atom(c, node->str, node->len);
+    emit_op(c, OP_DEFINE_CLASS);
+    emit_u32(c, (uint32_t)atom);
+    emit(c, 1);
+  } else {
+    emit_op(c, OP_DEFINE_CLASS);
+    emit_u32(c, 0);
+    emit(c, 0);
+  }
+
+  int proto_local = add_local(c, "", 0, false, c->scope_depth);
+  int ctor_local = add_local(c, "", 0, false, c->scope_depth);
+  emit_put_local(c, proto_local);
+  emit_put_local(c, ctor_local);
+
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *m = node->args.items[i];
+    if (m->type == N_STATIC_BLOCK) {
+      begin_scope(c);
+      compile_stmts(c, &m->args);
+      end_scope(c);
+      continue;
+    }
+    if (m->type != N_METHOD) continue;
+    if (m == ctor_method) continue;
+    bool is_fn = (m->right && m->right->type == N_FUNC);
+    if (!is_fn && !(m->flags & FN_STATIC)) continue;
+    compile_class_method(c, m, ctor_local, proto_local,
+                         method_comp_keys ? method_comp_keys[i] : -1);
+  }
+
+  free(method_comp_keys);
+  emit_get_local(c, ctor_local);
+
+  if (inner_name_local >= 0) {
+    emit_op(c, OP_DUP);
+    emit_put_local(c, inner_name_local);
+  }
+
+  if (class_repl_top && node->str) {
+    emit_op(c, OP_DUP);
+    emit_atom_op(c, OP_PUT_GLOBAL, node->str, node->len);
+  } else if (outer_name_local >= 0) {
+    emit_op(c, OP_DUP);
+    emit_put_local(c, outer_name_local);
+    c->locals[outer_name_local].is_tdz = false;
+  }
+
+  if (node->str)
+    end_scope(c);
+}
+
+static sv_func_t *compile_function_body(
+  sv_compiler_t *enclosing,
+  sv_ast_t *node,
+  sv_compile_mode_t mode
+) {
+  sv_compiler_t comp = {0};
+  comp.js = enclosing->js;
+  comp.source = enclosing->source;
+  comp.source_len = enclosing->source_len;
+  comp.enclosing = enclosing;
+  comp.scope_depth = 0;
+  comp.is_arrow = !!(node->flags & FN_ARROW);
+  comp.is_strict = enclosing->is_strict;
+  comp.mode = mode;
+  comp.strict_args_local = -1;
+  comp.new_target_local = -1;
+  comp.super_local = -1;
+  comp.param_count = node->args.count;
+
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *p = node->args.items[i];
+    if (p->type == N_IDENT) {
+      add_local(&comp, p->str, p->len, false, -1);  
+    } else if (p->type == N_REST && p->right && p->right->type == N_IDENT) {
+      add_local(&comp, p->right->str, p->right->len, false, -1);
+    } else if (p->type == N_ASSIGN_PAT && p->left && p->left->type == N_IDENT) {
+      add_local(&comp, p->left->str, p->left->len, false, -1);
+    } else add_local(&comp, "", 0, false, -1);
+  }
+
+  comp.param_locals = comp.local_count;
+
+  if (!comp.is_strict && node->body && node->body->type == N_BLOCK) {
+    for (int i = 0; i < node->body->args.count; i++) {
+      sv_ast_t *stmt = node->body->args.items[i];
+      if (!stmt || stmt->type == N_EMPTY) continue;
+      if (stmt->type != N_STRING) break;
+      if (sv_ast_is_use_strict(comp.js, stmt)) comp.is_strict = true;
+    }
+  }
+
+  if (comp.is_strict) {
+    const char *param_names[256];
+    uint32_t param_lens[256];
+    int param_name_count = 0;
+
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *p = node->args.items[i];
+      const char *pname = NULL;
+      uint32_t plen = 0;
+
+      if (p && p->type == N_IDENT) {
+        pname = p->str; plen = p->len;
+      } else if (p && p->type == N_REST && p->right && p->right->type == N_IDENT) {
+        pname = p->right->str; plen = p->right->len;
+      } else if (p && p->type == N_ASSIGN_PAT && p->left && p->left->type == N_IDENT) {
+        pname = p->left->str; plen = p->left->len;
+      }
+
+      if (!pname || plen == 0) continue;
+
+      if (is_strict_restricted_ident(pname, plen)) {
+        js_mkerr_typed(
+          comp.js, JS_ERR_SYNTAX,
+          "strict mode forbids '%.*s' as a parameter name",
+          (int)plen, pname);
+        return NULL;
+      }
+
+      for (int j = 0; j < param_name_count; j++) {
+        if (param_lens[j] == plen &&
+            memcmp(param_names[j], pname, plen) == 0) {
+          js_mkerr_typed(
+            comp.js, JS_ERR_SYNTAX,
+            "duplicate parameter name '%.*s' in strict mode",
+            (int)plen, pname);
+          return NULL;
+        }
+      }
+
+      if (param_name_count < (int)(sizeof(param_names) / sizeof(param_names[0]))) {
+        param_names[param_name_count] = pname;
+        param_lens[param_name_count] = plen;
+        param_name_count++;
+      }
+    }
+  }
+
+  bool has_non_simple_params = false;
+  for (int i = 0; i < node->args.count; i++) {
+    sv_ast_t *p = node->args.items[i];
+    if (p->type != N_IDENT) { has_non_simple_params = true; break; }
+  }
+  
+  bool repl_top = is_repl_top_level(&comp);
+  if (!has_non_simple_params && node->body) {
+    if (node->body->type == N_BLOCK) {
+      if (!repl_top) {
+        for (int i = 0; i < node->body->args.count; i++)
+          hoist_var_decls(&comp, node->body->args.items[i]);
+        hoist_lexical_decls(&comp, &node->body->args);
+      }
+      hoist_func_decls(&comp, &node->body->args);
+    } else if (!repl_top) hoist_var_decls(&comp, node->body);
+  }
+
+  if (!has_non_simple_params) {
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *p = node->args.items[i];
+      if (p->type == N_ASSIGN_PAT) {
+        emit_op(&comp, OP_GET_ARG);
+        emit_u16(&comp, (uint16_t)i);
+        emit_op(&comp, OP_DUP);
+        emit_op(&comp, OP_IS_UNDEF);
+        int skip = emit_jump(&comp, OP_JMP_FALSE);
+        emit_op(&comp, OP_POP);
+        compile_expr(&comp, p->right);
+        patch_jump(&comp, skip);
+        if (p->left && p->left->type == N_IDENT) {
+          emit_op(&comp, OP_PUT_ARG);
+          emit_u16(&comp, (uint16_t)i);
+        } else if (p->left) {
+          compile_destructure_binding(&comp, p->left, VAR_LET);
+          emit_op(&comp, OP_POP);
+        } else emit_op(&comp, OP_POP);
+      } else if (
+        p->type == N_ARRAY_PAT || p->type == N_ARRAY ||
+        p->type == N_OBJECT_PAT || p->type == N_OBJECT) {
+        emit_op(&comp, OP_GET_ARG);
+        emit_u16(&comp, (uint16_t)i);
+        compile_destructure_binding(&comp, p, VAR_LET);
+        emit_op(&comp, OP_POP);
+      } else if (p->type == N_REST && p->right && p->right->type == N_IDENT) {
+        emit_op(&comp, OP_REST);
+        emit_u16(&comp, (uint16_t)i);
+        int loc = resolve_local(&comp, p->right->str, p->right->len);
+        if (loc >= 0) {
+          emit_op(&comp, OP_PUT_ARG);
+          emit_u16(&comp, (uint16_t)loc);
+        }
+      } else if (p->type == N_REST && p->right) {
+        emit_op(&comp, OP_REST);
+        emit_u16(&comp, (uint16_t)i);
+        compile_destructure_binding(&comp, p->right, VAR_LET);
+        emit_op(&comp, OP_POP);
+      }
+    }
+  } else {
+    int *param_bind_locals = NULL;
+    int  param_bind_count  = 0;
+    int  param_bind_cap    = 0;
+
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *p = node->args.items[i];
+      const char *pname = NULL;
+      uint32_t    plen  = 0;
+      if (p->type == N_IDENT) {
+        pname = p->str; plen = p->len;
+      } else if ((
+        p->type == N_ASSIGN_PAT) && p->left &&
+        p->left->type == N_IDENT) {
+        pname = p->left->str; plen = p->left->len;
+      } else if (
+        p->type == N_REST && p->right &&
+        p->right->type == N_IDENT) {
+        pname = p->right->str; plen = p->right->len;
+      }
+
+      int lb = comp.local_count;
+      if (pname && plen) {
+        int loc = add_local(&comp, pname, plen, false, 0);
+        comp.locals[loc].is_tdz = true;
+        int slot = loc - comp.param_locals;
+        emit_op(&comp, OP_SET_LOCAL_UNDEF);
+        emit_u16(&comp, (uint16_t)slot);
+      }
+
+      if (param_bind_count >= param_bind_cap) {
+        param_bind_cap = param_bind_cap ? param_bind_cap * 2 : 8;
+        param_bind_locals = realloc(
+          param_bind_locals,
+          (size_t)param_bind_cap * sizeof(int));
+      }
+      param_bind_locals[param_bind_count++] = lb;
+    }
+
+    for (int i = 0; i < node->args.count; i++) {
+      sv_ast_t *p = node->args.items[i];
+      int bind_lb = param_bind_locals[i];
+
+      if (p->type == N_IDENT) {
+        if (bind_lb < comp.local_count) {
+          emit_op(&comp, OP_GET_ARG);
+          emit_u16(&comp, (uint16_t)i);
+          int slot = bind_lb - comp.param_locals;
+          comp.locals[bind_lb].is_tdz = false;
+          if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
+          else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
+        }
+      } else if (p->type == N_ASSIGN_PAT) {
+        emit_op(&comp, OP_GET_ARG);
+        emit_u16(&comp, (uint16_t)i);
+        emit_op(&comp, OP_DUP);
+        emit_op(&comp, OP_IS_UNDEF);
+        int skip = emit_jump(&comp, OP_JMP_FALSE);
+        emit_op(&comp, OP_POP);
+        compile_expr(&comp, p->right);
+        patch_jump(&comp, skip);
+        if (p->left && p->left->type == N_IDENT && bind_lb < comp.local_count) {
+          int slot = bind_lb - comp.param_locals;
+          comp.locals[bind_lb].is_tdz = false;
+          if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
+          else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
+        } else if (p->left) {
+          compile_destructure_binding(&comp, p->left, VAR_LET);
+          emit_op(&comp, OP_POP);
+        } else {
+          emit_op(&comp, OP_POP);
+        }
+      } else if (
+        p->type == N_ARRAY_PAT || p->type == N_ARRAY ||
+        p->type == N_OBJECT_PAT || p->type == N_OBJECT) {
+        emit_op(&comp, OP_GET_ARG);
+        emit_u16(&comp, (uint16_t)i);
+        compile_destructure_binding(&comp, p, VAR_LET);
+        emit_op(&comp, OP_POP);
+      } else if (
+        p->type == N_REST && p->right && p->right->type == N_IDENT &&
+        bind_lb < comp.local_count) {
+        emit_op(&comp, OP_REST);
+        emit_u16(&comp, (uint16_t)i);
+        int slot = bind_lb - comp.param_locals;
+        comp.locals[bind_lb].is_tdz = false;
+        if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
+        else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
+      } else if (p->type == N_REST && p->right) {
+        emit_op(&comp, OP_REST);
+        emit_u16(&comp, (uint16_t)i);
+        compile_destructure_binding(&comp, p->right, VAR_LET);
+        emit_op(&comp, OP_POP);
+      }
+    }
+
+    free(param_bind_locals);
+    if (node->body) {
+      if (node->body->type == N_BLOCK) {
+        if (!repl_top) {
+          for (int i = 0; i < node->body->args.count; i++)
+            hoist_var_decls(&comp, node->body->args.items[i]);
+          hoist_lexical_decls(&comp, &node->body->args);
+        }
+        hoist_func_decls(&comp, &node->body->args);
+      } else if (!repl_top) {
+        hoist_var_decls(&comp, node->body);
+      }
+    }
+  }
+
+  if (!comp.is_arrow && has_implicit_arguments_obj(&comp) &&
+      (node->flags & FN_USES_ARGS)) {
+    comp.strict_args_local = add_local(&comp, "", 0, false, comp.scope_depth);
+    emit_op(&comp, OP_SPECIAL_OBJ);
+    emit(&comp, 0);
+    emit_put_local(&comp, comp.strict_args_local);
+  }
+
+  if (!comp.is_arrow && comp.enclosing) {
+    static const char nt_name[] = "\x01new.target";
+    comp.new_target_local = add_local(&comp, nt_name, sizeof(nt_name) - 1, false, comp.scope_depth);
+    emit_op(&comp, OP_SPECIAL_OBJ);
+    emit(&comp, 1);
+    emit_put_local(&comp, comp.new_target_local);
+  }
+
+  if (!comp.is_arrow && comp.enclosing && (node->flags & (FN_METHOD | FN_GETTER | FN_SETTER | FN_STATIC))) {
+    static const char sv_name[] = "\x01super";
+    comp.super_local = add_local(&comp, sv_name, sizeof(sv_name) - 1, false, comp.scope_depth);
+    emit_op(&comp, OP_SPECIAL_OBJ);
+    emit(&comp, 2);
+    emit_put_local(&comp, comp.super_local);
+  }
+
+  if (enclosing->field_init_count > 0) {
+    emit_field_inits(&comp, enclosing->field_inits, enclosing->field_init_count);
+  }
+
+  if (node->body) {
+    if (node->body->type == N_BLOCK) {
+      int last_expr_idx = -1;
+      if (has_completion_value(&comp) && node->body->args.count > 0) {
+        sv_ast_t *last = node->body->args.items[node->body->args.count - 1];
+        if (sv_ast_can_be_expression_statement(last))
+          last_expr_idx = node->body->args.count - 1;
+      }
+
+      for (int i = 0; i < node->body->args.count; i++) {
+        sv_ast_t *stmt = node->body->args.items[i];
+        if (i == last_expr_idx) {
+          compile_expr(&comp, stmt);
+          emit_close_upvals(&comp);
+          emit_op(&comp, OP_RETURN);
+        } else {
+          compile_stmt(&comp, stmt);
+        }
+      }
+    } else compile_tail_return_expr(&comp, node->body);
+  }
+
+  for (int i = 0; i < comp.deferred_export_count; i++) {
+    sv_deferred_export_t *e = &comp.deferred_exports[i];
+    compile_export_emit(&comp, e->name, e->len);
+  }
+  
+  free(comp.deferred_exports);
+  emit_close_upvals(&comp);
+  emit_op(&comp, OP_RETURN_UNDEF);
+
+  int max_locals = comp.max_local_count - comp.param_locals;
+  sv_func_t *func = code_arena_bump(sizeof(sv_func_t));
+  memset(func, 0, sizeof(sv_func_t));
+
+  func->code = code_arena_bump((size_t)comp.code_len);
+  memcpy(func->code, comp.code, (size_t)comp.code_len);
+  func->code_len = comp.code_len;
+
+  if (comp.const_count > 0) {
+    func->constants = code_arena_bump((size_t)comp.const_count * sizeof(jsval_t));
+    memcpy(func->constants, comp.constants, (size_t)comp.const_count * sizeof(jsval_t));
+    func->const_count = comp.const_count;
+  }
+
+  if (comp.atom_count > 0) {
+    func->atoms = code_arena_bump((size_t)comp.atom_count * sizeof(sv_atom_t));
+    memcpy(func->atoms, comp.atoms, (size_t)comp.atom_count * sizeof(sv_atom_t));
+    func->atom_count = comp.atom_count;
+  }
+
+  if (comp.upvalue_count > 0) {
+    func->upval_descs = code_arena_bump(
+      (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
+    memcpy(func->upval_descs, comp.upval_descs,
+      (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
+    func->upvalue_count = comp.upvalue_count;
+  }
+
+  if (comp.srcpos_count > 0) {
+    func->srcpos = code_arena_bump((size_t)comp.srcpos_count * sizeof(sv_srcpos_t));
+    memcpy(func->srcpos, comp.srcpos, (size_t)comp.srcpos_count * sizeof(sv_srcpos_t));
+    func->srcpos_count = comp.srcpos_count;
+  }
+
+  if (enclosing->source && enclosing->source_len > 0) {
+    func->source = enclosing->source;
+    func->source_len = (int)enclosing->source_len;
+    func->source_start = (int)node->src_off;
+    func->source_end   = (node->src_end > node->src_off)
+      ? (int)node->src_end : func->source_len;
+  }
+
+  func->max_locals = max_locals;
+  func->max_stack = max_locals + 64;
+  func->param_count = comp.param_count;
+  func->is_strict = comp.is_strict;
+  func->is_arrow = comp.is_arrow;
+  
+  func->is_async = !!(node->flags & FN_ASYNC);
+  func->is_generator = !!(node->flags & FN_GENERATOR);
+  func->is_method = !!(node->flags & FN_METHOD);
+  func->is_tla = comp.is_tla;
+  func->filename = enclosing->js->filename;
+  func->source_line = (int)node->line;
+  if (node->str && node->len > 0) {
+    char *name = code_arena_bump(node->len + 1);
+    memcpy(name, node->str, node->len);
+    name[node->len] = '\0';
+    func->name = name;
+  } else if (enclosing->inferred_name && enclosing->inferred_name_len > 0) {
+    char *name = code_arena_bump(enclosing->inferred_name_len + 1);
+    memcpy(name, enclosing->inferred_name, enclosing->inferred_name_len);
+    name[enclosing->inferred_name_len] = '\0';
+    func->name = name;
+  }
+
+  free(comp.code);
+  free(comp.constants);
+  free(comp.atoms);
+  free(comp.locals);
+  free(comp.upval_descs);
+  free(comp.loops);
+  free(comp.srcpos);
+
+  return func;
+}
+
+static const char *sv_op_names[OP__COUNT] = {
+#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = #name,
+#include "silver/opcode.h"
+};
+
+enum {
+  SVF_none, SVF_u8, SVF_i8, SVF_u16, SVF_i16, SVF_u32, SVF_i32,
+  SVF_atom, SVF_atom_u8, SVF_label, SVF_label8, SVF_loc, SVF_loc8,
+  SVF_loc_atom, SVF_arg, SVF_const, SVF_const8, SVF_npop, SVF_var_ref,
+};
+
+static const uint8_t sv_op_fmts[OP__COUNT] = {
+#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = SVF_##f,
+#include "silver/opcode.h"
+};
+
+void sv_disasm(ant_t *js, sv_func_t *func, const char *label) {
+  const char *fname = func->name ? func->name : "";
+
+  fprintf(stderr, "[generated bytecode for function: %s (%p <SharedFunctionInfo %s>)]\n",
+    fname, (void *)func, fname);
+  fprintf(stderr, "Bytecode length: %d\n", func->code_len);
+  fprintf(stderr, "Parameter count %d\n", func->param_count);
+  fprintf(stderr, "Register count %d\n", func->max_locals);
+  fprintf(stderr, "Frame size %d\n", func->max_locals * (int)sizeof(jsval_t));
+
+  int pc = 0;
+  while (pc < func->code_len) {
+    uint8_t op = func->code[pc];
+    const char *name = (op < OP__COUNT) ? sv_op_names[op] : "???";
+    uint8_t size = (op < OP__COUNT) ? sv_op_size[op] : 1;
+    uint8_t fmt = (op < OP__COUNT) ? sv_op_fmts[op] : SVF_none;
+
+    uint32_t line, col;
+    if (sv_lookup_srcpos(func, pc, &line, &col))
+      fprintf(stderr, "%5u S> ", line);
+    else
+      fprintf(stderr, "         ");
+
+    fprintf(stderr, "%p @ %4d : ", (void *)(func->code + pc), pc);
+
+    char hex[32];
+    int hlen = 0;
+    for (int i = 0; i < size && i < 8; i++)
+      hlen += snprintf(hex + hlen, sizeof(hex) - hlen, "%02x ", func->code[pc + i]);
+      
+    fprintf(stderr, "%-18s", hex);
+    fprintf(stderr, "%s", name ? name : "???");
+
+    switch (fmt) {
+    case SVF_u8:
+      fprintf(stderr, " [%d]", func->code[pc + 1]);
+      break;
+    case SVF_i8:
+      fprintf(stderr, " [%d]", (int8_t)func->code[pc + 1]);
+      break;
+    case SVF_u16:
+      fprintf(stderr, " [%d]", sv_get_u16(func->code + pc + 1));
+      break;
+    case SVF_i16:
+      fprintf(stderr, " [%d]", (int16_t)sv_get_u16(func->code + pc + 1));
+      break;
+    case SVF_u32:
+      fprintf(stderr, " [%d]", (int)sv_get_u32(func->code + pc + 1));
+      break;
+    case SVF_i32:
+      fprintf(stderr, " [%d]", (int32_t)sv_get_u32(func->code + pc + 1));
+      break;
+    case SVF_atom: {
+      uint32_t idx = sv_get_u32(func->code + pc + 1);
+      if (idx < (uint32_t)func->atom_count)
+        fprintf(stderr, " [%.*s]", (int)func->atoms[idx].len, func->atoms[idx].str);
+      else
+        fprintf(stderr, " a%u", idx);
+      break;
+    }
+    case SVF_atom_u8: {
+      uint32_t idx = sv_get_u32(func->code + pc + 1);
+      uint8_t extra = func->code[pc + 5];
+      if (idx < (uint32_t)func->atom_count)
+        fprintf(stderr, " [%.*s], [%d]", (int)func->atoms[idx].len, func->atoms[idx].str, extra);
+      else
+        fprintf(stderr, " a%u, [%d]", idx, extra);
+      break;
+    }
+    case SVF_label: {
+      int32_t off = (int32_t)sv_get_u32(func->code + pc + 1);
+      fprintf(stderr, " [%d] (%d)", off, pc + size + off);
+      break;
+    }
+    case SVF_label8: {
+      int8_t off = (int8_t)func->code[pc + 1];
+      fprintf(stderr, " [%d] (%d)", off, pc + size + off);
+      break;
+    }
+    case SVF_loc:
+      fprintf(stderr, " r%d", sv_get_u16(func->code + pc + 1));
+      break;
+    case SVF_loc8:
+      fprintf(stderr, " r%d", func->code[pc + 1]);
+      break;
+    case SVF_loc_atom: {
+      uint16_t slot = sv_get_u16(func->code + pc + 1);
+      uint32_t aidx = sv_get_u32(func->code + pc + 3);
+      fprintf(stderr, " r%d", slot);
+      if (aidx < (uint32_t)func->atom_count)
+        fprintf(stderr, ", [%.*s]", (int)func->atoms[aidx].len, func->atoms[aidx].str);
+      else
+        fprintf(stderr, ", a%u", aidx);
+      break;
+    }
+    case SVF_arg:
+      fprintf(stderr, " a%d", sv_get_u16(func->code + pc + 1));
+      break;
+    case SVF_const: {
+      uint32_t idx = sv_get_u32(func->code + pc + 1);
+      fprintf(stderr, " [%u]", idx);
+      break;
+    }
+    case SVF_const8:
+      fprintf(stderr, " [%d]", func->code[pc + 1]);
+      break;
+    case SVF_npop:
+      fprintf(stderr, " %d", sv_get_u16(func->code + pc + 1));
+      break;
+    case SVF_var_ref:
+      fprintf(stderr, " [%d]", sv_get_u16(func->code + pc + 1));
+      break;
+    default:
+      break;
+    }
+
+    fprintf(stderr, "\n");
+    pc += size;
+  }
+
+  fprintf(stderr, "Constant pool (size = %d)\n", func->const_count);
+  for (int i = 0; i < func->const_count; i++) {
+    jsval_t v = func->constants[i];
+    uint8_t t = vtype(v);
+    if (t == T_STR) {
+      jsoff_t slen;
+      jsoff_t soff = vstr(js, v, &slen);
+      fprintf(stderr, "           %d: <String[%d]: #%.*s>\n", i, (int)slen, (int)slen, &js->mem[soff]);
+    } else if (t == T_NUM) {
+      fprintf(stderr, "           %d: <Number [%g]>\n", i, tod(v));
+    } else if (t == T_CFUNC) {
+      sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(v);
+      const char *cname = child->name ? child->name : "";
+      fprintf(stderr, "           %d: <SharedFunctionInfo %s>\n", i, cname);
+    } else fprintf(stderr, "           %d: <Unknown type=%d>\n", i, t);
+  }
+
+  if (func->atom_count > 0) {
+    fprintf(stderr, "Atom table (size = %d)\n", func->atom_count);
+    for (int i = 0; i < func->atom_count; i++)
+      fprintf(stderr, "           %d: <String[%d]: #%.*s>\n",
+        i, (int)func->atoms[i].len, (int)func->atoms[i].len, func->atoms[i].str);
+  }
+
+  fprintf(stderr, "Handler Table (size = 0)\n");
+  fprintf(stderr, "Source Position Table (size = %d)\n", func->srcpos_count);
+  fprintf(stderr, "\n");
+
+  for (int i = 0; i < func->const_count; i++) {
+    if (vtype(func->constants[i]) == T_CFUNC) {
+      sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(func->constants[i]);
+      char child_label[256];
+      snprintf(child_label, sizeof(child_label), "%s/closure[%d]", label, i);
+      sv_disasm(js, child, child_label);
+    }
+  }
+}
+
+sv_func_t *sv_compile(ant_t *js, sv_ast_t *program, sv_compile_mode_t mode, const char *source, jsoff_t source_len) {
+  if (!program || program->type != N_PROGRAM) return NULL;
+  
+  static const char *k_top_name_script = "<script>";
+  static const char *k_top_name_module = "<module>";
+  static const char *k_top_name_eval   = "<eval>";
+  static const char *k_top_name_repl   = "<repl>";
+  const        char *top_name          = k_top_name_script;
+  
+  switch (mode) {
+    case SV_COMPILE_MODULE: top_name = k_top_name_module; break;
+    case SV_COMPILE_EVAL:   top_name = k_top_name_eval; break;
+    case SV_COMPILE_REPL:   top_name = k_top_name_repl; break;
+    case SV_COMPILE_SCRIPT:
+    default:                top_name = k_top_name_script; break;
+  }
+
+  sv_ast_t top_fn;
+  memset(&top_fn, 0, sizeof(top_fn));
+  
+  top_fn.type = N_FUNC;
+  top_fn.line = 1;
+  top_fn.str = top_name;
+  top_fn.len = (uint32_t)strlen(top_name);
+  top_fn.src_off = 0;
+  top_fn.src_end = (source_len > 0) ? (uint32_t)source_len : 0;
+  top_fn.body = sv_ast_new(N_BLOCK);
+  top_fn.body->args = program->args;
+
+  sv_compiler_t root = {0};
+  root.js = js;
+  root.source = pin_source_text(source, source_len);
+  root.source_len = source_len;
+  root.mode = mode;
+  root.is_strict = ((program->flags & FN_PARSE_STRICT) != 0);
+
+  sv_func_t *func = compile_function_body(&root, &top_fn, mode);
+  if (js->thrown_exists || !func) return NULL;
+  return func;
+}
+
+sv_func_t *sv_compile_function(ant_t *js, const char *source, size_t len, bool is_async) {
+  const char *prefix = is_async ? "(async function" : "(function";
+  size_t prefix_len = strlen(prefix);
+  size_t wrapped_len = prefix_len + len + 1;
+
+  char *wrapped = malloc(wrapped_len + 1);
+  if (!wrapped) return NULL;
+
+  memcpy(wrapped, prefix, prefix_len);
+  memcpy(wrapped + prefix_len, source, len);
+  wrapped[prefix_len + len] = ')';
+  wrapped[wrapped_len] = '\0';
+  
+  bool parse_strict = sv_vm_is_strict(js->vm);
+  sv_ast_t *program = sv_parse(js, wrapped, (jsoff_t)wrapped_len, parse_strict);
+  if (!program) { free(wrapped); return NULL; }
+
+  sv_ast_t *func_node = NULL;
+  if (program->args.count > 0) {
+    sv_ast_t *stmt = program->args.items[0];
+    if (stmt && stmt->type == N_FUNC)
+      func_node = stmt;
+    else if (stmt && stmt->left && stmt->left->type == N_FUNC)
+      func_node = stmt->left;
+  }
+
+  if (!func_node) { free(wrapped); return NULL; }
+
+  sv_compiler_t root = {0};
+  root.js = js;
+  root.source = pin_source_text(wrapped, (jsoff_t)wrapped_len);
+  root.source_len = (jsoff_t)wrapped_len;
+  root.mode = SV_COMPILE_SCRIPT;
+  root.is_strict = (program->flags & FN_PARSE_STRICT) != 0;
+
+  sv_func_t *func = compile_function_body(&root, func_node, SV_COMPILE_SCRIPT);
+  free(wrapped);
+
+  if (js->thrown_exists || !func) return NULL;
+  return func;
+}
+
+sv_func_t *sv_compile_function_parts(
+  ant_t *js,
+  const char *params,
+  size_t params_len,
+  const char *body,
+  size_t body_len,
+  bool is_async
+) {
+  size_t source_len = params_len + body_len + 3;
+  char *source = malloc(source_len + 1);
+  if (!source) return NULL;
+
+  size_t pos = 0;
+  source[pos++] = '(';
+  if (params_len > 0 && params) {
+    memcpy(source + pos, params, params_len);
+    pos += params_len;
+  }
+  source[pos++] = ')';
+  source[pos++] = '{';
+  if (body_len > 0 && body) {
+    memcpy(source + pos, body, body_len);
+    pos += body_len;
+  }
+  source[pos++] = '}';
+  source[pos] = '\0';
+
+  sv_func_t *func = sv_compile_function(js, source, pos, is_async);
+  free(source);
+  return func;
+}
diff --git a/src/silver/directives.c b/src/silver/directives.c
new file mode 100644
index 0000000..fa8088a
--- /dev/null
+++ b/src/silver/directives.c
@@ -0,0 +1,24 @@
+#include <string.h>
+#include "silver/ast.h"
+
+bool sv_ast_is_directive(
+  ant_t *js, const sv_ast_t *node,
+  const char *directive, size_t directive_len
+) {
+  if (!node || node->type != N_STRING) return false;
+
+  if (node->str && node->len == directive_len + 2 
+    && ((node->str[0] == '\'' && node->str[node->len - 1] == '\'') 
+    || (node->str[0] == '"' && node->str[node->len - 1] == '"')) 
+    && memcmp(node->str + 1, directive, directive_len) == 0
+  ) return true;
+
+  return (
+    node->str && node->len == directive_len 
+    && memcmp(node->str, directive, directive_len) == 0
+  );
+}
+
+bool sv_ast_is_use_strict(ant_t *js, const sv_ast_t *node) {
+  return sv_ast_is_directive(js, node, "use strict", 10);
+}
diff --git a/src/silver/engine.c b/src/silver/engine.c
new file mode 100644
index 0000000..3bf82e1
--- /dev/null
+++ b/src/silver/engine.c
@@ -0,0 +1,1349 @@
+#include "silver/engine.h"
+#include "silver/swarm.h"
+
+#include <stdlib.h>
+#include "gc.h"
+#include "errors.h"
+
+#include "ops/literals.h"
+#include "ops/stack.h"
+#include "ops/locals.h"
+#include "ops/upvalues.h"
+#include "ops/globals.h"
+#include "ops/property.h"
+#include "ops/optional.h"
+#include "ops/private.h"
+#include "ops/super.h"
+#include "ops/arithmetic.h"
+#include "ops/comparison.h"
+#include "ops/bitwise.h"
+#include "ops/unary.h"
+#include "ops/control.h"
+#include "ops/calls.h"
+#include "ops/returns.h"
+#include "ops/exceptions.h"
+#include "ops/async.h"
+#include "ops/iteration.h"
+#include "ops/objects.h"
+#include "ops/coercion.h"
+
+sv_vm_t *sv_vm_create(ant_t *js, sv_vm_kind_t kind) {
+  int stack_size, max_frames;
+  sv_vm_limits(kind, &stack_size, &max_frames);
+
+  sv_vm_t *vm = calloc(1, sizeof(*vm));
+  if (!vm) return NULL;
+  
+  vm->js = js;
+  vm->stack_size = stack_size;
+  vm->stack = calloc((size_t)stack_size, sizeof(jsval_t));
+  vm->max_frames = max_frames;
+  vm->frames = calloc((size_t)max_frames, sizeof(sv_frame_t));
+  if (!vm->stack || !vm->frames) { sv_vm_destroy(vm); return NULL; }
+  
+  return vm;
+}
+
+void sv_vm_destroy(sv_vm_t *vm) {
+  if (!vm) return;
+  free(vm->stack);
+  free(vm->frames);
+  free(vm);
+}
+
+static bool sv_vm_grow_frames(sv_vm_t *vm) {
+  int new_max = vm->max_frames * 2;
+  if (new_max > SV_FRAMES_HARD_MAX) new_max = SV_FRAMES_HARD_MAX;
+  if (new_max <= vm->max_frames) return false;
+  
+  sv_frame_t *nf = realloc(vm->frames, (size_t)new_max * sizeof(sv_frame_t));
+  if (!nf) return false;
+  vm->frames = nf;
+  vm->max_frames = new_max;
+  
+  return true;
+}
+
+static bool sv_vm_grow_stack(sv_vm_t *vm) {
+  int new_size = vm->stack_size * 2;
+  if (new_size > SV_STACK_HARD_MAX) new_size = SV_STACK_HARD_MAX;
+  if (new_size <= vm->stack_size) return false;
+  
+  jsval_t *old = vm->stack;
+  jsval_t *ns = realloc(vm->stack, (size_t)new_size * sizeof(jsval_t));
+  if (!ns) return false;
+  
+  ptrdiff_t delta = ns - old;
+  vm->stack = ns;
+  vm->stack_size = new_size;
+  
+  if (delta != 0) {
+    for (int i = 0; i <= vm->fp; i++) {
+      if (vm->frames[i].bp) vm->frames[i].bp += delta;
+      if (vm->frames[i].lp) vm->frames[i].lp += delta;
+    }
+    for (sv_upvalue_t *uv = vm->open_upvalues; uv; uv = uv->next) {
+      if (uv->location != &uv->closed)
+        uv->location += delta;
+    }
+  }
+  
+  return true;
+}
+
+bool sv_lookup_srcpos(sv_func_t *func, int bc_offset, uint32_t *line, uint32_t *col) {
+  if (!func || !func->srcpos || func->srcpos_count <= 0) return false;
+  int best = -1;
+  for (int i = 0; i < func->srcpos_count; i++) {
+    if ((int)func->srcpos[i].bc_offset <= bc_offset) best = i;
+    else break;
+  }
+  if (best < 0) return false;
+  if (line) *line = func->srcpos[best].line;
+  if (col) *col = func->srcpos[best].col;
+  return true;
+}
+
+bool sv_lookup_srcspan(sv_func_t *func, int bc_offset, uint32_t *src_off, uint32_t *src_end) {
+  if (!func || !func->srcpos || func->srcpos_count <= 0) return false;
+  int best = -1;
+  for (int i = 0; i < func->srcpos_count; i++) {
+    if ((int)func->srcpos[i].bc_offset <= bc_offset) best = i;
+    else break;
+  }
+  
+  if (best < 0) return false;
+  uint32_t off = func->srcpos[best].src_off;
+  uint32_t end = func->srcpos[best].src_end;
+  
+  if (end < off) end = off;
+  if (src_off) *src_off = off;
+  if (src_end) *src_end = end;
+  
+  return true;
+}
+
+static jsoff_t sv_srcpos_to_offset_local(const char *code, jsoff_t clen, uint32_t line, uint32_t col) {
+  jsoff_t off = 0;
+  uint32_t cur = 1;
+  
+  while (off < clen && cur < line) {
+    if (code[off] == '\n') cur++;
+    off++;
+  }
+  
+  if (col > 0) off += col - 1;
+  if (off > clen) off = clen;
+  return off;
+}
+
+void js_set_error_site_from_bc(ant_t *js, sv_func_t *func, int bc_offset, const char *filename) {
+  if (!js || !func || !func->source || func->source_len <= 0) return;
+
+  uint32_t src_off = 0, src_end = 0;
+  if (sv_lookup_srcspan(func, bc_offset, &src_off, &src_end)) {
+    jsoff_t off = (jsoff_t)src_off;
+    jsoff_t span_len = (jsoff_t)(src_end > src_off ? (src_end - src_off) : 0);
+    if (span_len <= 0 && off < (jsoff_t)func->source_len) span_len = 1;
+    
+    js_set_error_site(
+      js, func->source, (jsoff_t)func->source_len,
+      filename ? filename : func->filename, off, span_len
+    );
+    return;
+  }
+
+  uint32_t line = 0, col = 0;
+  if (sv_lookup_srcpos(func, bc_offset, &line, &col)) {
+    jsoff_t off = sv_srcpos_to_offset_local(func->source, (jsoff_t)func->source_len, line, col);
+    js_set_error_site(
+      js, func->source, (jsoff_t)func->source_len,
+      filename ? filename : func->filename, off, 0
+    );
+  }
+}
+
+void js_set_error_site_from_vm_top(ant_t *js) {
+  if (!js || !js->vm || js->vm->fp < 0) return;
+  sv_frame_t *frame = &js->vm->frames[js->vm->fp];
+  sv_func_t *func = frame->func;
+  if (!func) return;
+  
+  int bc_off = 0;
+  if (frame->ip && func->code) bc_off = (int)(frame->ip - func->code);
+  js_set_error_site_from_bc(js, func, bc_off, func->filename);
+}
+
+void sv_vm_gc_roots(sv_vm_t *vm, void (*op_val)(void *, jsval_t *), void *ctx) {
+  if (!vm) return;
+
+  for (int i = 0; i < vm->sp; i++)
+    op_val(ctx, &vm->stack[i]);
+
+  for (int i = 0; i <= vm->fp; i++) {
+    op_val(ctx, &vm->frames[i].this);
+    op_val(ctx, &vm->frames[i].callee);
+    op_val(ctx, &vm->frames[i].new_target);
+    op_val(ctx, &vm->frames[i].super_val);
+    op_val(ctx, &vm->frames[i].with_obj);
+  }
+  
+  for (sv_upvalue_t *uv = vm->open_upvalues; uv; uv = uv->next) {
+    if (uv->location != &uv->closed) continue;
+    if (uv->gc_epoch == gc_epoch_counter) continue;
+    op_val(ctx, &uv->closed);
+  }
+
+  for (int i = 0; i <= vm->fp; i++) {
+    sv_frame_t *frame = &vm->frames[i];
+    for (int j = 0; j < frame->upvalue_count; j++) {
+      sv_upvalue_t *uv = frame->upvalues ? frame->upvalues[j] : NULL;
+      if (!uv) continue;
+      if (uv->location != &uv->closed) continue;
+      if (uv->gc_epoch == gc_epoch_counter) continue;
+      op_val(ctx, &uv->closed);
+    }
+  }
+
+  for (int i = 0; i <= vm->fp; i++) {
+    if (vm->frames[i].completion.kind != SV_COMPLETION_NONE)
+      op_val(ctx, &vm->frames[i].completion.value);
+  }
+}
+
+void sv_vm_visit_frame_funcs(sv_vm_t *vm, void (*visitor)(void *, sv_func_t *), void *ctx) {
+  if (!vm) return;
+  for (int i = 0; i <= vm->fp; i++) if (vm->frames[i].func) visitor(ctx, vm->frames[i].func);
+}
+
+jsval_t sv_call_async_closure_dispatch(
+  sv_vm_t *vm, ant_t *js, sv_closure_t *closure,
+  jsval_t callee_func, jsval_t super_val,
+  jsval_t this_val, jsval_t *args, int argc
+) {
+  return sv_start_async_closure(vm, js, closure, callee_func, super_val, this_val, args, argc);
+}
+
+jsval_t sv_execute_entry_tla(ant_t *js, sv_func_t *func, jsval_t this_val) {
+  return sv_start_tla(js, func, this_val);
+}
+
+void sv_vm_gc_roots_pending(void (*op_val)(void *, jsval_t *), void *ctx) {
+  sv_vm_gc_roots_async(op_val, ctx);
+}
+
+static inline jsval_t sv_stage_frame_args(
+  sv_vm_t *vm, ant_t *js, sv_func_t *func, jsval_t *args, int argc,
+  jsval_t **out_bp, jsval_t **out_lp
+) {
+  int arg_slots = (argc > func->param_count) ? argc : func->param_count;
+  int need = arg_slots + func->max_locals;
+  if (vm->sp + need > vm->stack_size) {
+    int args_idx = (
+      args && args >= vm->stack && args < vm->stack + vm->stack_size)
+      ? (int)(args - vm->stack) : -1;
+    while (vm->sp + need > vm->stack_size) {
+      if (!sv_vm_grow_stack(vm)) return js_mkerr(js, "stack overflow");
+    }
+    if (args_idx >= 0) args = &vm->stack[args_idx];
+  }
+
+  jsval_t *base = &vm->stack[vm->sp];
+  *out_bp = base;
+  *out_lp = base + arg_slots;
+
+  if (argc > 0 && args)
+    memmove(base, args, (size_t)argc * sizeof(jsval_t));
+  for (int i = argc; i < arg_slots; i++)
+    base[i] = js_mkundef();
+  if (func->max_locals > 0)
+    for (int i = 0; i < func->max_locals; i++)
+      (*out_lp)[i] = js_mkundef();
+  vm->sp += need;
+  return js_mkundef();
+}
+
+static inline jsval_t sv_execute_entry_common(
+  sv_vm_t *vm, sv_func_t *func, sv_upvalue_t **upvalues, int upvalue_count,
+  jsval_t callee_func, jsval_t super_val,
+  jsval_t this_val, jsval_t *args, int argc, jsval_t *out_this
+) {
+  if (!vm || !vm->js || !func) return mkval(T_ERR, 0);
+  ant_t *js = vm->js;
+  if (vm->fp + 1 >= vm->max_frames && !sv_vm_grow_frames(vm))
+    return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum AOT call stack size exceeded");
+
+  int saved_fp = vm->fp;
+  vm->fp = saved_fp + 1;
+  vm->frames[vm->fp].upvalues = upvalues;
+  vm->frames[vm->fp].upvalue_count = upvalue_count;
+  vm->frames[vm->fp].callee = callee_func;
+
+  jsval_t result = sv_execute_frame(vm, func, this_val, super_val, args, argc);
+  if (out_this) *out_this = vm->frames[vm->fp].this;
+
+  vm->fp = saved_fp;
+
+  return result;
+}
+
+jsval_t sv_execute_entry(
+  sv_vm_t *vm, sv_func_t *func, jsval_t this_val, jsval_t *args, int argc
+) {
+  return sv_execute_entry_common(vm, func, NULL, 0, js_mkundef(), js_mkundef(), this_val, args, argc, NULL);
+}
+
+jsval_t sv_execute_closure_entry(
+  sv_vm_t *vm, sv_closure_t *closure, jsval_t callee_func, jsval_t super_val,
+  jsval_t this_val, jsval_t *args, int argc, jsval_t *out_this
+) {
+  if (!closure || !closure->func) return mkval(T_ERR, 0);
+  return sv_execute_entry_common(
+    vm, closure->func, closure->upvalues, closure->func->upvalue_count, callee_func,
+    super_val, this_val, args, argc, out_this
+  );
+}
+
+jsval_t sv_execute_frame(sv_vm_t *vm, sv_func_t *func, jsval_t this, jsval_t super_val, jsval_t *args, int argc) {
+  ant_t *js = vm->js;
+  uint8_t *ip = func->code;
+  int entry_fp = vm->fp;
+  jsval_t vm_result = js_mkundef();
+
+  // TODO: shorthand?
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  frame->ip = ip;
+  frame->func = func;
+  frame->this = sv_normalize_this_for_frame(js, func, this);
+  frame->new_target = js->new_target;
+  frame->super_val = super_val;
+  frame->prev_sp = vm->sp;
+  frame->handler_base = vm->handler_depth;
+  frame->handler_top = vm->handler_depth;
+  frame->argc = argc;
+  frame->completion.kind = SV_COMPLETION_NONE;
+  frame->completion.value = js_mkundef();
+  frame->with_obj = js_mkundef();
+  
+  jsval_t *entry_bp = NULL;
+  jsval_t *entry_lp = NULL;
+  jsval_t stage_err = sv_stage_frame_args(vm, js, func, args, argc, &entry_bp, &entry_lp);
+  if (is_err(stage_err)) {
+    vm_result = stage_err;
+    goto sv_leave;
+  }
+  #ifdef ANT_JIT
+  if (vm->jit_resume.active) {
+    ip = func->code + vm->jit_resume.ip_offset;
+    frame->ip = ip;
+    int64_t rl = 
+      vm->jit_resume.n_locals < func->max_locals
+      ? vm->jit_resume.n_locals : func->max_locals;
+    for (int64_t i = 0; i < rl; i++)
+      entry_lp[i] = vm->jit_resume.locals[i];
+  }
+  #endif
+  frame->bp = entry_bp;
+  frame->lp = entry_lp;
+
+  jsval_t *bp = frame->bp;
+  jsval_t *lp = frame->lp;
+
+  #ifdef ANT_JIT
+  if (vm->jit_resume.active) {
+    for (int64_t i = 0; i < vm->jit_resume.vstack_sp; i++)
+      vm->stack[vm->sp++] = vm->jit_resume.vstack[i];
+
+    int resume_off = (int)vm->jit_resume.ip_offset;
+    uint8_t *scan = func->code;
+    uint8_t *scan_end = func->code + resume_off;
+    typedef struct { uint8_t *catch_ip; int saved_sp; } pending_h;
+    
+    pending_h h_stack[SV_TRY_MAX];
+    int enclosing_count = 0;
+    int total_depth = 0;
+    bool is_enclosing[SV_TRY_MAX];
+    
+    while (scan < scan_end) {
+      sv_op_t scan_op = (sv_op_t)*scan;
+      int scan_sz = sv_op_size[scan_op];
+      if (scan_sz == 0) break;
+      if (scan_op == OP_TRY_PUSH && total_depth < SV_TRY_MAX) {
+        int32_t off = sv_get_i32(scan + 1);
+        int catch_off = (int)(scan - func->code) + scan_sz + off;
+        is_enclosing[total_depth] = (catch_off > resume_off);
+        if (is_enclosing[total_depth]) {
+          h_stack[enclosing_count].catch_ip = func->code + catch_off;
+          h_stack[enclosing_count].saved_sp = vm->sp;
+          enclosing_count++;
+        }
+        total_depth++;
+      } else if (scan_op == OP_TRY_POP && total_depth > 0) {
+        total_depth--;
+        if (is_enclosing[total_depth]) enclosing_count--;
+      }
+      scan += scan_sz;
+    }
+    
+    for (int i = 0; i < enclosing_count; i++) {
+      if (vm->handler_depth < SV_HANDLER_MAX) {
+        sv_handler_t *h = &vm->handler_stack[vm->handler_depth++];
+        h->kind = SV_HANDLER_TRY;
+        h->ip = h_stack[i].catch_ip;
+        h->saved_sp = h_stack[i].saved_sp;
+        frame->handler_top = vm->handler_depth;
+      }
+    }
+
+    vm->jit_resume.active = false;
+  }
+  #endif
+
+  // TODO: generate with X-macro
+  #define OP(name) [OP_##name] = &&L_##name
+  static const void *dispatch[OP__COUNT] = {
+    OP(INVALID),
+
+    OP(CONST), OP(CONST_I8), OP(CONST8),
+    OP(UNDEF), OP(NULL), OP(TRUE), OP(FALSE),
+    OP(THIS), OP(GLOBAL), OP(OBJECT), OP(ARRAY), OP(REGEXP), OP(CLOSURE),
+
+    OP(POP), OP(DUP), OP(DUP2), OP(SWAP),
+    OP(ROT3L), OP(ROT3R), OP(NIP), OP(NIP2), OP(INSERT2), OP(INSERT3),
+    OP(SWAP_UNDER), OP(ROT4_UNDER),
+
+    OP(GET_LOCAL), OP(PUT_LOCAL), OP(SET_LOCAL),
+    OP(GET_LOCAL8), OP(PUT_LOCAL8), OP(SET_LOCAL8),
+    OP(SET_LOCAL_UNDEF), OP(GET_LOCAL_CHK), OP(PUT_LOCAL_CHK),
+
+    OP(GET_ARG), OP(PUT_ARG), OP(SET_ARG), OP(REST),
+    OP(GET_UPVAL), OP(PUT_UPVAL), OP(SET_UPVAL), OP(CLOSE_UPVAL),
+    OP(GET_GLOBAL), OP(GET_GLOBAL_UNDEF), OP(PUT_GLOBAL),
+
+    OP(GET_FIELD), OP(GET_FIELD2), OP(PUT_FIELD),
+    OP(GET_ELEM), OP(GET_ELEM2), OP(PUT_ELEM),
+    OP(DEFINE_FIELD), OP(GET_LENGTH),
+
+    OP(GET_FIELD_OPT), OP(GET_ELEM_OPT),
+    OP(GET_PRIVATE), OP(PUT_PRIVATE), OP(DEF_PRIVATE),
+    OP(GET_SUPER), OP(GET_SUPER_VAL), OP(PUT_SUPER_VAL),
+
+    OP(ADD), OP(SUB), OP(MUL), OP(DIV), OP(MOD), OP(EXP),
+    OP(NEG), OP(UPLUS),
+    OP(INC), OP(DEC), OP(POST_INC), OP(POST_DEC),
+    OP(INC_LOCAL), OP(DEC_LOCAL), OP(ADD_LOCAL),
+
+    OP(EQ), OP(NE), OP(SEQ), OP(SNE),
+    OP(LT), OP(LE), OP(GT), OP(GE),
+    OP(INSTANCEOF), OP(IN),
+    OP(IS_NULLISH), OP(IS_UNDEF_OR_NULL),
+
+    OP(BAND), OP(BOR), OP(BXOR), OP(BNOT),
+    OP(SHL), OP(SHR), OP(USHR),
+    OP(NOT), OP(TYPEOF), OP(VOID), OP(DELETE), OP(DELETE_VAR),
+
+    OP(JMP), OP(JMP_FALSE), OP(JMP_TRUE),
+    OP(JMP_FALSE_PEEK), OP(JMP_TRUE_PEEK), OP(JMP_NOT_NULLISH),
+    OP(JMP8), OP(JMP_FALSE8), OP(JMP_TRUE8),
+
+    OP(CALL), OP(CALL_METHOD),
+    OP(TAIL_CALL), OP(TAIL_CALL_METHOD),
+    OP(NEW), OP(APPLY), OP(EVAL),
+    OP(RETURN), OP(RETURN_UNDEF), OP(RETURN_ASYNC),
+    OP(CHECK_CTOR), OP(CHECK_CTOR_RET), OP(HALT),
+
+    OP(THROW), OP(THROW_ERROR),
+    OP(TRY_PUSH), OP(TRY_POP),
+    OP(CATCH), OP(FINALLY), OP(FINALLY_RET), OP(NIP_CATCH),
+
+    OP(FOR_IN), OP(FOR_OF), OP(FOR_AWAIT_OF),
+    OP(ITER_NEXT), OP(ITER_GET_VALUE),
+    OP(ITER_CLOSE), OP(ITER_CALL), OP(AWAIT_ITER_NEXT),
+
+    OP(AWAIT), OP(YIELD), OP(YIELD_STAR), OP(INITIAL_YIELD),
+    OP(SPREAD),
+
+    OP(DEFINE_METHOD), OP(DEFINE_METHOD_COMP),
+    OP(SET_NAME), OP(SET_NAME_COMP),
+    OP(SET_PROTO), OP(SET_HOME_OBJ),
+    OP(APPEND), OP(COPY_DATA_PROPS),
+
+    OP(DEFINE_CLASS), OP(DEFINE_CLASS_COMP), OP(ADD_BRAND),
+    OP(TO_OBJECT), OP(TO_PROPKEY), OP(IS_UNDEF), OP(IS_NULL),
+
+    OP(IMPORT), OP(IMPORT_SYNC), OP(IMPORT_DEFAULT), OP(EXPORT), OP(EXPORT_ALL),
+    OP(ENTER_WITH), OP(EXIT_WITH),
+
+    OP(WITH_GET_VAR), OP(WITH_PUT_VAR), OP(WITH_DEL_VAR),
+    OP(SPECIAL_OBJ), OP(EMPTY), OP(DEBUGGER), OP(NOP), OP(PUT_CONST),
+    OP(LABEL), OP(LINE_NUM), OP(COL_NUM),
+  };
+  #undef OP
+  
+  jsval_t sv_err;
+  #define VM_CHECK(expr) do {             \
+    frame->ip = ip;                     \
+    sv_err = (expr);                    \
+    if (is_err(sv_err)) goto sv_throw;  \
+  } while (0)
+  jsval_t  tc_this = js_mkundef();
+
+  #define DISPATCH()  goto *dispatch[*ip]
+  #define NEXT(n)     do { ip += (n); DISPATCH(); } while (0)
+
+  #ifdef ANT_JIT
+  #define JIT_OSR_BACK_EDGE() do {                                            \
+    if (!func->jit_compile_failed) {                                        \
+      if (!func->type_feedback) sv_tfb_ensure(func);                        \
+      if (++func->back_edge_count >= SV_JIT_OSR_THRESHOLD) {                \
+      jsval_t osr_r = sv_jit_try_osr(                                       \
+        vm, js, frame, func,                                                \
+         (int)(ip - func->code));                                           \
+      if (osr_r != SV_JIT_RETRY_INTERP) {                                   \
+        if (is_err(osr_r)) { sv_err = osr_r; goto sv_throw; }               \
+        vm->sp = frame->prev_sp;                                            \
+        if (vm->fp <= entry_fp) {                                           \
+          vm_result = osr_r;                                                \
+          goto sv_leave;                                                    \
+        }                                                                   \
+        vm->fp--;                                                           \
+        frame = &vm->frames[vm->fp];                                        \
+        func = frame->func;                                                 \
+        bp = frame->bp;                                                     \
+        lp = frame->lp;                                                     \
+        ip = frame->ip;                                                     \
+        vm->stack[vm->sp++] = osr_r;                                        \
+        DISPATCH();                                                         \
+      }                                                                     \
+      }                                                                     \
+    }                                                                       \
+  } while (0)
+  #else
+  #define JIT_OSR_BACK_EDGE() ((void)0)
+  #endif
+  DISPATCH();
+
+  L_CONST:     { sv_op_const(vm, func, ip);   NEXT(5); }
+  L_CONST_I8:  { sv_op_const_i8(vm, ip);      NEXT(2); }
+  L_CONST8:    { sv_op_const8(vm, func, ip);  NEXT(2); }
+  L_UNDEF:     { sv_op_undef(vm);             NEXT(1); }
+  L_NULL:      { sv_op_null(vm);              NEXT(1); }
+  L_TRUE:      { sv_op_true(vm);              NEXT(1); }
+  L_FALSE:     { sv_op_false(vm);             NEXT(1); }
+  L_THIS:      { sv_op_this(vm, frame);       NEXT(1); }
+  L_GLOBAL:    { sv_op_global(vm, js);        NEXT(1); }
+  L_OBJECT:    { sv_op_object(vm, js);        NEXT(1); }
+  L_ARRAY:     { sv_op_array(vm, js, ip);     NEXT(3); }
+  
+  L_REGEXP:   { sv_op_regexp(vm, js);                    NEXT(1); }
+  L_CLOSURE:  { sv_op_closure(vm, js, frame, func, ip);  NEXT(5); }
+
+  L_POP:      { sv_op_pop(vm);      NEXT(1); }
+  L_DUP:      { sv_op_dup(vm);      NEXT(1); }
+  L_DUP2:     { sv_op_dup2(vm);     NEXT(1); }
+  L_SWAP:     { sv_op_swap(vm);     NEXT(1); }
+  L_ROT3L:    { sv_op_rot3l(vm);    NEXT(1); }
+  L_ROT3R:    { sv_op_rot3r(vm);    NEXT(1); }
+  L_NIP:      { sv_op_nip(vm);      NEXT(1); }
+  L_NIP2:     { sv_op_nip2(vm);     NEXT(1); }
+  L_INSERT2:  { sv_op_insert2(vm);  NEXT(1); }
+  L_INSERT3:  { sv_op_insert3(vm);  NEXT(1); }
+  
+  L_SWAP_UNDER:  { sv_op_swap_under(vm);   NEXT(1); }
+  L_ROT4_UNDER:  { sv_op_rot4_under(vm);   NEXT(1); }
+
+  L_GET_LOCAL:        { sv_op_get_local(vm, lp, ip);    NEXT(3); }
+  L_PUT_LOCAL:        { sv_op_put_local(vm, lp, ip);    NEXT(3); }
+  L_SET_LOCAL:        { sv_op_set_local(vm, lp, ip);    NEXT(3); }
+  L_GET_LOCAL8:       { sv_op_get_local8(vm, lp, ip);   NEXT(2); }
+  L_PUT_LOCAL8:       { sv_op_put_local8(vm, lp, ip);   NEXT(2); }
+  L_SET_LOCAL8:       { sv_op_set_local8(vm, lp, ip);   NEXT(2); }
+  L_SET_LOCAL_UNDEF:  { sv_op_set_local_undef(lp, ip);  NEXT(3); }
+  
+  L_GET_LOCAL_CHK:  { VM_CHECK(sv_op_get_local_chk(vm, lp, js, func, ip));  NEXT(7); }
+  L_PUT_LOCAL_CHK:  { VM_CHECK(sv_op_put_local_chk(vm, lp, js, func, ip));  NEXT(7); }
+
+  L_GET_ARG:  { sv_op_get_arg(vm, frame, ip);   NEXT(3); }
+  L_PUT_ARG:  { sv_op_put_arg(vm, frame, ip);   NEXT(3); }
+  L_SET_ARG:  { sv_op_set_arg(vm, frame, ip);   NEXT(3); }
+  L_REST:     { sv_op_rest(vm, frame, js, ip);  NEXT(3); }
+
+  L_GET_UPVAL:    { VM_CHECK(sv_op_get_upval(vm, frame, js, ip));  NEXT(3); }
+  L_PUT_UPVAL:    { sv_op_put_upval(vm, frame, ip);                NEXT(3); }
+  L_SET_UPVAL:    { sv_op_set_upval(vm, frame, ip);                NEXT(3); }
+  L_CLOSE_UPVAL:  { sv_op_close_upval(vm, frame, ip);              NEXT(3); }
+
+  L_GET_GLOBAL:        { VM_CHECK(sv_op_get_global(vm, js, func, ip));         NEXT(5); }
+  L_GET_GLOBAL_UNDEF:  { sv_op_get_global_undef(vm, js, func, ip);             NEXT(5); }
+  L_PUT_GLOBAL:        { VM_CHECK(sv_op_put_global(vm, js, frame, func, ip));  NEXT(5); }
+
+  L_GET_FIELD:     { VM_CHECK(sv_op_get_field(vm, js, func, ip));   NEXT(5); }
+  L_GET_FIELD2:    { VM_CHECK(sv_op_get_field2(vm, js, func, ip));  NEXT(5); }
+  L_PUT_FIELD:     { VM_CHECK(sv_op_put_field(vm, js, func, ip));   NEXT(5); }
+  L_GET_ELEM:      { VM_CHECK(sv_op_get_elem(vm, js, func, ip));    NEXT(1); }
+  L_GET_ELEM2:     { VM_CHECK(sv_op_get_elem2(vm, js, func, ip));   NEXT(1); }
+  L_PUT_ELEM:      { VM_CHECK(sv_op_put_elem(vm, js));              NEXT(1); }
+  L_DEFINE_FIELD:  { sv_op_define_field(vm, js, func, ip);          NEXT(5); }
+  L_GET_LENGTH:    { VM_CHECK(sv_op_get_length(vm, js));            NEXT(1); }
+
+  L_GET_FIELD_OPT:  { VM_CHECK(sv_op_get_field_opt(vm, js, func, ip));  NEXT(5); }
+  L_GET_ELEM_OPT:   { VM_CHECK(sv_op_get_elem_opt(vm, js, func, ip));   NEXT(1); }
+
+  L_GET_PRIVATE:  { sv_op_get_private(vm, js);  NEXT(1); }
+  L_PUT_PRIVATE:  { sv_op_put_private(vm, js);  NEXT(1); }
+  L_DEF_PRIVATE:  { sv_op_def_private(vm, js);  NEXT(1); }
+
+  L_GET_SUPER:      { sv_op_get_super(vm, js);      NEXT(1); }
+  L_GET_SUPER_VAL:  { sv_op_get_super_val(vm, js);  NEXT(1); }
+  L_PUT_SUPER_VAL:  { sv_op_put_super_val(vm, js);  NEXT(1); }
+
+  L_ADD: {
+    jsval_t r = vm->stack[vm->sp - 1], l = vm->stack[vm->sp - 2];
+    sv_tfb_record2(func, ip, l, r);
+    if (__builtin_expect(vtype(l) == T_NUM && vtype(r) == T_NUM, 1)) {
+      vm->sp--; vm->stack[vm->sp - 1] = tov(tod(l) + tod(r)); NEXT(1);
+    }
+    VM_CHECK(sv_op_add(vm, js)); NEXT(1);
+  }
+  
+  L_SUB: {
+    jsval_t r = vm->stack[vm->sp - 1], l = vm->stack[vm->sp - 2];
+    sv_tfb_record2(func, ip, l, r);
+    if (__builtin_expect(vtype(l) == T_NUM && vtype(r) == T_NUM, 1)) {
+      vm->sp--; vm->stack[vm->sp - 1] = tov(tod(l) - tod(r)); NEXT(1);
+    }
+    VM_CHECK(sv_op_sub(vm, js)); NEXT(1);
+  }
+  
+  L_MUL:        { sv_tfb_record2(func, ip, vm->stack[vm->sp-2], vm->stack[vm->sp-1]); VM_CHECK(sv_op_mul(vm, js));                NEXT(1); }
+  L_DIV:        { sv_tfb_record2(func, ip, vm->stack[vm->sp-2], vm->stack[vm->sp-1]); VM_CHECK(sv_op_div(vm, js));                NEXT(1); }
+  L_MOD:        { sv_tfb_record2(func, ip, vm->stack[vm->sp-2], vm->stack[vm->sp-1]); VM_CHECK(sv_op_mod(vm, js));                NEXT(1); }
+  L_NEG:        { sv_tfb_record1(func, ip, vm->stack[vm->sp-1]); VM_CHECK(sv_op_neg(vm, js));                                     NEXT(1); }
+  L_ADD_LOCAL:  { sv_tfb_record2(func, ip, lp[sv_get_u8(ip+1)], vm->stack[vm->sp-1]); VM_CHECK(sv_op_add_local(vm, lp, js, ip));  NEXT(2); }
+
+  L_EXP:        { VM_CHECK(sv_op_exp(vm, js));    NEXT(1); }
+  L_UPLUS:      { VM_CHECK(sv_op_uplus(vm, js));  NEXT(1); }
+  L_INC:        { sv_op_inc(vm);                  NEXT(1); }
+  L_DEC:        { sv_op_dec(vm);                  NEXT(1); }
+  L_POST_INC:   { sv_op_post_inc(vm);             NEXT(1); }
+  L_POST_DEC:   { sv_op_post_dec(vm);             NEXT(1); }
+  L_INC_LOCAL:  { sv_op_inc_local(vm, lp, ip);    NEXT(2); }
+  L_DEC_LOCAL:  { sv_op_dec_local(vm, lp, ip);    NEXT(2); }
+
+  L_EQ:   { sv_op_eq(vm, js);   NEXT(1); }
+  L_NE:   { sv_op_ne(vm, js);   NEXT(1); }
+  L_SEQ:  { sv_op_seq(vm, js);  NEXT(1); }
+  L_SNE:  { sv_op_sne(vm, js);  NEXT(1); }
+  
+  L_LT: {
+    jsval_t r = vm->stack[vm->sp - 1], l = vm->stack[vm->sp - 2];
+    sv_tfb_record2(func, ip, l, r);
+    if (__builtin_expect(vtype(l) == T_NUM && vtype(r) == T_NUM, 1)) {
+      vm->sp--; vm->stack[vm->sp - 1] = mkval(T_BOOL, tod(l) < tod(r)); NEXT(1);
+    }
+    VM_CHECK(sv_op_lt(vm, js)); NEXT(1);
+  }
+  
+  L_LE:  { sv_tfb_record2(func, ip, vm->stack[vm->sp-2], vm->stack[vm->sp-1]); VM_CHECK(sv_op_le(vm, js));  NEXT(1); }
+  L_GT:  { sv_tfb_record2(func, ip, vm->stack[vm->sp-2], vm->stack[vm->sp-1]); VM_CHECK(sv_op_gt(vm, js));  NEXT(1); }
+  L_GE:  { sv_tfb_record2(func, ip, vm->stack[vm->sp-2], vm->stack[vm->sp-1]); VM_CHECK(sv_op_ge(vm, js));  NEXT(1); }
+  
+  L_INSTANCEOF:        { VM_CHECK(sv_op_instanceof(vm, js));  NEXT(1); }
+  L_IN:                { VM_CHECK(sv_op_in(vm, js));          NEXT(1); }
+  L_IS_NULLISH:        { sv_op_is_nullish(vm);                NEXT(1); }
+  L_IS_UNDEF_OR_NULL:  { sv_op_is_undef_or_null(vm);          NEXT(1); }
+
+  L_BAND:  { VM_CHECK(sv_op_band(vm, js));  NEXT(1); }
+  L_BOR:   { VM_CHECK(sv_op_bor(vm, js));   NEXT(1); }
+  L_BXOR:  { VM_CHECK(sv_op_bxor(vm, js));  NEXT(1); }
+  L_BNOT:  { sv_op_bnot(vm, js);            NEXT(1); }
+  L_SHL:   { VM_CHECK(sv_op_shl(vm, js));   NEXT(1); }
+  L_SHR:   { VM_CHECK(sv_op_shr(vm, js));   NEXT(1); }
+  L_USHR:  { VM_CHECK(sv_op_ushr(vm, js));  NEXT(1); }
+
+  L_NOT:         { sv_op_not(vm, js);                   NEXT(1); }
+  L_TYPEOF:      { sv_op_typeof(vm, js);                NEXT(1); }
+  L_VOID:        { sv_op_void(vm);                      NEXT(1); }
+  L_DELETE:      { VM_CHECK(sv_op_delete(vm, js));      NEXT(1); }
+  L_DELETE_VAR:  { sv_op_delete_var(vm, js, func, ip);  NEXT(5); }
+
+  L_JMP: { 
+    uint8_t *prev = ip; ip = sv_op_jmp(ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH(); 
+  }
+  
+  L_JMP_FALSE: {
+    uint8_t *prev = ip;
+    jsval_t v = vm->stack[--vm->sp];
+    if (__builtin_expect(vtype(v) == T_BOOL, 1)) {
+      ip = vdata(v) 
+        ? ip + sv_op_size[OP_JMP_FALSE]
+        : ip + sv_op_size[OP_JMP_FALSE] + sv_get_i32(ip + 1);
+    } else {
+      ip = js_truthy(js, v) 
+        ? ip + sv_op_size[OP_JMP_FALSE]
+        : ip + sv_op_size[OP_JMP_FALSE] + sv_get_i32(ip + 1);
+    }
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+  
+  L_JMP_TRUE: {
+    uint8_t *prev = ip;
+    jsval_t v = vm->stack[--vm->sp];
+    if (__builtin_expect(vtype(v) == T_BOOL, 1)) {
+      ip = vdata(v) 
+        ? ip + sv_op_size[OP_JMP_TRUE] + sv_get_i32(ip + 1)
+        : ip + sv_op_size[OP_JMP_TRUE];
+    } else {
+      ip = js_truthy(js, v) 
+        ? ip + sv_op_size[OP_JMP_TRUE] + sv_get_i32(ip + 1)
+        : ip + sv_op_size[OP_JMP_TRUE];
+    }
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+  
+  L_JMP_FALSE_PEEK: { 
+    uint8_t *prev = ip; ip = sv_op_jmp_false_peek(vm, js, ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+  
+  L_JMP_TRUE_PEEK: { 
+    uint8_t *prev = ip; ip = sv_op_jmp_true_peek(vm, js, ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+  
+  L_JMP_NOT_NULLISH: { 
+    uint8_t *prev = ip; ip = sv_op_jmp_not_nullish(vm, ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+   
+  L_JMP8: {
+    uint8_t *prev = ip; ip = sv_op_jmp8(ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+  
+  L_JMP_FALSE8: { 
+    uint8_t *prev = ip; ip = sv_op_jmp_false8(vm, js, ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+  
+  L_JMP_TRUE8:  { 
+    uint8_t *prev = ip; ip = sv_op_jmp_true8(vm, js, ip);
+    if (ip <= prev) {
+      if (js->needs_gc) js_gc_maybe(js);
+      JIT_OSR_BACK_EDGE();
+    }
+    DISPATCH();
+  }
+
+  // TODO: make the methods below DRY
+  L_CALL: {
+    uint16_t call_argc = sv_get_u16(ip + 1);
+    jsval_t *call_args = &vm->stack[vm->sp - call_argc];
+    jsval_t call_func = vm->stack[vm->sp - call_argc - 1];
+    
+    bool is_super_call =
+      (vtype(frame->super_val) != T_UNDEF && call_func == frame->super_val);
+    jsval_t call_this = is_super_call ? frame->this : js_mkundef();
+
+    if (!is_super_call && vtype(frame->new_target) == T_UNDEF && vtype(call_func) == T_FUNC) {
+      sv_closure_t *closure = js_func_closure(call_func);
+      if (closure->func != NULL) {
+        if (closure->call_flags & (SV_CALL_HAS_BOUND_ARGS | SV_CALL_HAS_SUPER))
+          goto call_fallback;
+        if (closure->func->is_async) goto call_fallback;
+        #ifdef ANT_JIT
+        {
+          sv_func_t *callee = closure->func;
+          if (callee->jit_code) {
+            jsval_t jit_this = (
+              callee->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+              ? closure->bound_this : js_mkundef();
+            frame->ip = ip + 3;
+            jsval_t jit_result = ((sv_jit_func_t)callee->jit_code)(
+              vm, jit_this, call_args, (int)call_argc, closure);
+            if (sv_is_jit_bailout(jit_result)) {
+              sv_jit_on_bailout(callee);
+              goto call_fallback;
+            }
+            vm->sp -= call_argc + 1;
+            if (is_err(jit_result)) { sv_err = jit_result; goto sv_throw; }
+            vm->stack[vm->sp++] = jit_result;
+            ip = frame->ip;
+            DISPATCH();
+          }
+          if (!callee->is_generator) {
+            uint32_t cc = ++callee->call_count;
+            if (__builtin_expect(cc == SV_TFB_ALLOC_THRESHOLD, 0))
+              sv_tfb_ensure(callee);
+            if (cc > SV_JIT_THRESHOLD) {
+            sv_jit_func_t jit_fn = sv_jit_compile(js, callee, closure);
+            if (jit_fn) {
+              callee->jit_code = (void *)jit_fn;
+              jsval_t jit_this = (
+                callee->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+                 ? closure->bound_this : js_mkundef();
+              frame->ip = ip + 3;
+              jsval_t jit_result = jit_fn(vm, jit_this, call_args, (int)call_argc, closure);
+              if (sv_is_jit_bailout(jit_result)) {
+                sv_jit_on_bailout(callee);
+                goto call_fallback;
+              }
+              vm->sp -= call_argc + 1;
+              if (is_err(jit_result)) { sv_err = jit_result; goto sv_throw; }
+              vm->stack[vm->sp++] = jit_result;
+              ip = frame->ip;
+              DISPATCH();
+            } else {
+              callee->call_count = 0;
+              callee->back_edge_count = 0;
+            }}
+          }
+        }
+        #endif
+        if (vm->fp + 1 >= vm->max_frames && !sv_vm_grow_frames(vm)) {
+          sv_err = js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum AOT call stack size exceeded");
+          goto sv_throw;
+        }
+        if (closure->func->is_arrow || vtype(closure->bound_this) != T_UNDEF) call_this = closure->bound_this;
+        frame = &vm->frames[vm->fp];
+        frame->ip = ip + 3;
+        vm->sp -= call_argc + 1;
+        vm->fp++;
+        frame = &vm->frames[vm->fp];
+        func = closure->func;
+        frame->func = func;
+        frame->callee = call_func;
+        frame->this = sv_normalize_this_for_frame(js, func, call_this);
+        frame->new_target = js_mkundef();
+        frame->super_val = js_mkundef();
+        frame->prev_sp = vm->sp;
+        frame->handler_base = vm->handler_depth;
+        frame->handler_top = vm->handler_depth;
+        frame->argc = call_argc;
+        jsval_t *call_bp = NULL;
+        jsval_t *call_lp = NULL;
+        jsval_t call_stage_err = sv_stage_frame_args(
+          vm, js, func, call_args, (int)call_argc, &call_bp, &call_lp
+        );
+        if (is_err(call_stage_err)) {
+          vm->fp--;
+          vm->sp += call_argc + 1;
+          sv_err = call_stage_err;
+          goto sv_throw;
+        }
+        frame->bp = call_bp;
+        frame->lp = call_lp;
+        frame->upvalues = closure->upvalues;
+        frame->upvalue_count = closure->func->upvalue_count;
+        bp = frame->bp;
+        lp = frame->lp;
+        
+        ip = func->code;
+        DISPATCH();
+      }
+    }
+    call_fallback:;
+    frame->ip = ip;
+    jsval_t call_result = sv_vm_call(
+      vm, js, call_func, call_this, call_args, call_argc, NULL, false);
+    vm->sp -= call_argc + 1;
+    if (is_err(call_result)) { sv_err = call_result; goto sv_throw; }
+    if (is_super_call && is_object_type(call_result))
+      frame->this = call_result;
+    vm->stack[vm->sp++] = call_result;
+    NEXT(3);
+  }
+
+  L_CALL_METHOD: {
+    uint16_t call_argc = sv_get_u16(ip + 1);
+    jsval_t *call_args = &vm->stack[vm->sp - call_argc];
+    jsval_t call_func = vm->stack[vm->sp - call_argc - 1];
+    jsval_t call_this = vm->stack[vm->sp - call_argc - 2];
+    
+    bool is_super_call =
+      (vtype(frame->super_val) != T_UNDEF && call_func == frame->super_val);
+
+    if (!is_super_call && vtype(frame->new_target) == T_UNDEF &&
+        vtype(call_func) == T_FUNC) {
+      sv_closure_t *closure = js_func_closure(call_func);
+      if (closure->func != NULL) {
+        if (closure->call_flags & (SV_CALL_HAS_BOUND_ARGS | SV_CALL_HAS_SUPER))
+          goto call_method_fallback;
+        if (closure->func->is_async) goto call_method_fallback;
+        #ifdef ANT_JIT
+        {
+          sv_func_t *callee = closure->func;
+          if (callee->jit_code) {
+            jsval_t jit_this = (
+              callee->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+              ? closure->bound_this : call_this;
+            frame->ip = ip + 3;
+            jsval_t jit_result = ((sv_jit_func_t)callee->jit_code)(
+              vm, jit_this, call_args, (int)call_argc, closure);
+            if (sv_is_jit_bailout(jit_result)) {
+              sv_jit_on_bailout(callee);
+              goto call_method_fallback;
+            }
+            vm->sp -= call_argc + 2;
+            if (is_err(jit_result)) { sv_err = jit_result; goto sv_throw; }
+            vm->stack[vm->sp++] = jit_result;
+            ip = frame->ip;
+            DISPATCH();
+          }
+          if (!callee->is_generator) {
+            uint32_t cc = ++callee->call_count;
+            if (__builtin_expect(cc == SV_TFB_ALLOC_THRESHOLD, 0))
+              sv_tfb_ensure(callee);
+            if (cc > SV_JIT_THRESHOLD) {
+            sv_jit_func_t jit_fn = sv_jit_compile(js, callee, closure);
+            if (jit_fn) {
+              callee->jit_code = (void *)jit_fn;
+              jsval_t jit_this = (
+                callee->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+                ? closure->bound_this : call_this;
+              frame->ip = ip + 3;
+              jsval_t jit_result = jit_fn(vm, jit_this, call_args, (int)call_argc, closure);
+              if (sv_is_jit_bailout(jit_result)) {
+                sv_jit_on_bailout(callee);
+                goto call_method_fallback;
+              }
+              vm->sp -= call_argc + 2;
+              if (is_err(jit_result)) { sv_err = jit_result; goto sv_throw; }
+              vm->stack[vm->sp++] = jit_result;
+              ip = frame->ip;
+              DISPATCH();
+            } else {
+              callee->call_count = 0;
+              callee->back_edge_count = 0;
+            }}
+          }
+        }
+        #endif
+        if (vm->fp + 1 >= vm->max_frames && !sv_vm_grow_frames(vm)) {
+          sv_err = js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum AOT call stack size exceeded");
+          goto sv_throw;
+        }
+        if (closure->func->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+          call_this = closure->bound_this;
+        frame = &vm->frames[vm->fp];
+        frame->ip = ip + 3;
+        vm->sp -= call_argc + 2;
+        vm->fp++;
+        frame = &vm->frames[vm->fp];
+        func = closure->func;
+        frame->func = func;
+        frame->callee = call_func;
+        frame->this = sv_normalize_this_for_frame(js, func, call_this);
+        frame->new_target = js_mkundef();
+        frame->super_val = js_mkundef();
+        frame->prev_sp = vm->sp;
+        frame->handler_base = vm->handler_depth;
+        frame->handler_top = vm->handler_depth;
+        frame->argc = call_argc;
+        jsval_t *call_bp = NULL;
+        jsval_t *call_lp = NULL;
+        jsval_t call_stage_err = sv_stage_frame_args(
+          vm, js, func, call_args, (int)call_argc, &call_bp, &call_lp
+        );
+        if (is_err(call_stage_err)) {
+          vm->fp--;
+          vm->sp += call_argc + 2;
+          sv_err = call_stage_err;
+          goto sv_throw;
+        }
+        frame->bp = call_bp;
+        frame->lp = call_lp;
+        frame->upvalues = closure->upvalues;
+        frame->upvalue_count = closure->func->upvalue_count;
+        bp = frame->bp;
+        lp = frame->lp;
+        ip = func->code;
+        DISPATCH();
+      }
+    }
+    call_method_fallback:;
+    frame->ip = ip;
+    if (is_super_call) js->new_target = frame->new_target;
+    jsval_t call_result = sv_vm_call(
+      vm, js, call_func, call_this, call_args, call_argc, NULL, is_super_call);
+    vm->sp -= call_argc + 2;
+    if (is_err(call_result)) { sv_err = call_result; goto sv_throw; }
+    if (is_super_call && is_object_type(call_result))
+      frame->this = call_result;
+    vm->stack[vm->sp++] = call_result;
+    NEXT(3);
+  }
+
+  L_TAIL_CALL: {
+    uint16_t call_argc = sv_get_u16(ip + 1);
+    jsval_t call_func = vm->stack[vm->sp - call_argc - 1];
+    tc_this = js_mkundef();
+
+    if (vm->handler_depth == frame->handler_base &&
+        vtype(frame->new_target) == T_UNDEF &&
+        vtype(call_func) == T_FUNC) {
+      sv_closure_t *closure = js_func_closure(call_func);
+      if (closure->func != NULL) {
+        if (!closure->func->is_async &&
+            !(closure->call_flags & (SV_CALL_HAS_BOUND_ARGS | SV_CALL_HAS_SUPER))) {
+          if (closure->func->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+            tc_this = closure->bound_this;
+          goto tail_call_inline;
+        }
+      }
+    }
+    jsval_t *call_args = &vm->stack[vm->sp - call_argc];
+    frame->ip = ip;
+    jsval_t call_result = sv_vm_call(
+      vm, js, call_func, tc_this, call_args, call_argc, NULL, false);
+    vm->sp -= call_argc + 1;
+    if (is_err(call_result)) { sv_err = call_result; goto sv_throw; }
+    vm->stack[vm->sp++] = call_result;
+    goto L_RETURN;
+  }
+
+  L_TAIL_CALL_METHOD: {
+    uint16_t call_argc = sv_get_u16(ip + 1);
+    jsval_t call_func = vm->stack[vm->sp - call_argc - 1];
+    tc_this = vm->stack[vm->sp - call_argc - 2];
+
+    if (vm->handler_depth == frame->handler_base &&
+        vtype(frame->new_target) == T_UNDEF &&
+        vtype(call_func) == T_FUNC) {
+      sv_closure_t *closure = js_func_closure(call_func);
+      if (closure->func != NULL) {
+        if (!closure->func->is_async &&
+            !(closure->call_flags & (SV_CALL_HAS_BOUND_ARGS | SV_CALL_HAS_SUPER))) {
+          if (closure->func->is_arrow || vtype(closure->bound_this) != T_UNDEF)
+            tc_this = closure->bound_this;
+          goto tail_call_inline;
+        }
+      }
+    }
+    jsval_t *call_args = &vm->stack[vm->sp - call_argc];
+    jsval_t call_result = sv_vm_call(
+      vm, js, call_func, tc_this, call_args, call_argc, NULL, false);
+    vm->sp -= call_argc + 2;
+    if (is_err(call_result)) { sv_err = call_result; goto sv_throw; }
+    vm->stack[vm->sp++] = call_result;
+    goto L_RETURN;
+  }
+
+  tail_call_inline: {
+    uint16_t call_argc = sv_get_u16(ip + 1);
+    jsval_t *call_args = &vm->stack[vm->sp - call_argc];
+    jsval_t call_func = vm->stack[vm->sp - call_argc - 1];
+    sv_closure_t *closure = js_func_closure(call_func);
+    if (frame->bp) sv_close_upvalues_from_slot(vm, frame->bp);
+    vm->sp = frame->prev_sp;
+    int arg_slots = (
+      (int)call_argc > closure->func->param_count)
+      ? (int)call_argc : closure->func->param_count;
+    int need = arg_slots + closure->func->max_locals;
+    jsval_t *base = &vm->stack[vm->sp];
+    memmove(base, call_args, (size_t)call_argc * sizeof(jsval_t));
+    for (int i = (int)call_argc; i < arg_slots; i++) base[i] = js_mkundef();
+    jsval_t *new_lp = base + arg_slots;
+    for (int i = 0; i < closure->func->max_locals; i++) new_lp[i] = js_mkundef();
+    vm->sp = frame->prev_sp + need;
+    func = closure->func;
+    frame->func = func;
+    frame->callee = call_func;
+    frame->this = sv_normalize_this_for_frame(js, func, tc_this);
+    frame->new_target = js_mkundef();
+    frame->super_val = js_mkundef();
+    frame->argc = call_argc;
+    frame->handler_base = vm->handler_depth;
+    frame->handler_top = vm->handler_depth;
+    frame->bp = base;
+    frame->lp = new_lp;
+    frame->upvalues = closure->upvalues;
+    frame->upvalue_count = closure->func->upvalue_count;
+    bp = frame->bp;
+    lp = frame->lp;
+    ip = func->code;
+    DISPATCH();
+  }
+  
+  L_NEW:    { VM_CHECK(sv_op_new(vm, js, ip));          NEXT(3); }
+  L_APPLY:  { VM_CHECK(sv_op_apply(vm, js, ip));        NEXT(3); }
+  L_EVAL:   { VM_CHECK(sv_op_eval(vm, js, frame, ip));  NEXT(5); }
+
+  // TODO: make the methods below DRY
+  L_RETURN: {
+    jsval_t r = vm->stack[--vm->sp];
+    if (__builtin_expect(vm->handler_depth != frame->handler_base, 0)) {
+      uint8_t *finally_ip = sv_vm_unwind_for_return(vm, r);
+      if (finally_ip) {
+        frame = &vm->frames[vm->fp];
+        func = frame->func;
+        bp = frame->bp;
+        lp = frame->lp;
+        ip = finally_ip;
+        DISPATCH();
+      }
+      vm->handler_depth = frame->handler_base;
+      frame->handler_top = frame->handler_base;
+    }
+    vm->sp = frame->prev_sp;
+    if (vm->fp <= entry_fp) {
+      vm_result = r;
+      goto sv_leave;
+    }
+    vm->fp--;
+    frame = &vm->frames[vm->fp];
+    func = frame->func;
+    bp = frame->bp;
+    lp = frame->lp;
+    ip = frame->ip;
+    vm->stack[vm->sp++] = r;
+    DISPATCH();
+  }
+
+  L_RETURN_UNDEF: {
+    jsval_t r = js_mkundef();
+    if (__builtin_expect(vm->handler_depth != frame->handler_base, 0)) {
+      uint8_t *finally_ip = sv_vm_unwind_for_return(vm, r);
+      if (finally_ip) {
+        frame = &vm->frames[vm->fp];
+        func = frame->func;
+        bp = frame->bp;
+        lp = frame->lp;
+        ip = finally_ip;
+        DISPATCH();
+      }
+      vm->handler_depth = frame->handler_base;
+      frame->handler_top = frame->handler_base;
+    }
+    vm->sp = frame->prev_sp;
+    if (vm->fp <= entry_fp) {
+      vm_result = r;
+      goto sv_leave;
+    }
+    vm->fp--;
+    frame = &vm->frames[vm->fp];
+    func = frame->func;
+    bp = frame->bp;
+    lp = frame->lp;
+    ip = frame->ip;
+    vm->stack[vm->sp++] = r;
+    DISPATCH();
+  }
+
+  L_RETURN_ASYNC: {
+    jsval_t r = vm->stack[--vm->sp];
+    if (__builtin_expect(vm->handler_depth != frame->handler_base, 0)) {
+      uint8_t *finally_ip = sv_vm_unwind_for_return(vm, r);
+      if (finally_ip) {
+        frame = &vm->frames[vm->fp];
+        func = frame->func;
+        bp = frame->bp;
+        lp = frame->lp;
+        ip = finally_ip;
+        DISPATCH();
+      }
+      vm->handler_depth = frame->handler_base;
+      frame->handler_top = frame->handler_base;
+    }
+    vm->sp = frame->prev_sp;
+    if (vm->fp <= entry_fp) {
+      vm_result = r;
+      goto sv_leave;
+    }
+    vm->fp--;
+    frame = &vm->frames[vm->fp];
+    func = frame->func;
+    bp = frame->bp;
+    lp = frame->lp;
+    ip = frame->ip;
+    vm->stack[vm->sp++] = r;
+    DISPATCH();
+  }
+
+  L_CHECK_CTOR:      { VM_CHECK(sv_op_check_ctor(vm, js));  NEXT(1); }
+  L_CHECK_CTOR_RET:  { sv_op_check_ctor_ret(vm, frame);     NEXT(1); }
+  
+  L_HALT: {
+    vm_result = sv_op_halt(vm, frame);
+    goto sv_leave;
+  }
+
+  L_THROW:       { sv_err = sv_op_throw(vm);                      goto sv_throw; }
+  L_THROW_ERROR: { sv_err = sv_op_throw_error(vm, js, func, ip);  goto sv_throw; }
+  
+  L_TRY_PUSH:    { sv_op_try_push(vm, ip);               NEXT(5); }
+  L_TRY_POP:     { sv_op_try_pop(vm);                    NEXT(1); }
+  L_CATCH:       { sv_op_catch(vm, sv_err, ip);          NEXT(5); }
+  L_FINALLY:     { VM_CHECK(sv_op_finally(vm, js, ip));  NEXT(5); }
+  
+  L_FINALLY_RET: {
+    uint8_t *resume_ip = NULL;
+    jsval_t completion = js_mkundef();
+    sv_finally_ret_t action = sv_op_finally_ret(vm, js, &resume_ip, &completion);
+    if (action == SV_FINALLY_RET_ERROR || action == SV_FINALLY_RET_THROW) {
+      sv_err = completion;
+      goto sv_throw;
+    }
+    if (action == SV_FINALLY_RET_RETURN) {
+      vm->handler_depth = frame->handler_base;
+      frame->handler_top = frame->handler_base;
+      vm->sp = frame->prev_sp;
+      if (vm->fp <= entry_fp) {
+        vm_result = completion;
+        goto sv_leave;
+      }
+      vm->fp--;
+      frame = &vm->frames[vm->fp];
+      func = frame->func;
+      bp = frame->bp;
+      lp = frame->lp;
+      
+      ip = frame->ip;
+      vm->stack[vm->sp++] = completion;
+      DISPATCH();
+    }
+    ip = resume_ip;
+    DISPATCH();
+  }
+  
+  L_NIP_CATCH:        { sv_op_nip_catch(vm);                      NEXT(1); }
+  L_FOR_IN:           { VM_CHECK(sv_op_for_in(vm, js));           NEXT(1); }
+  L_FOR_OF:           { VM_CHECK(sv_op_for_of(vm, js));           NEXT(1); }
+  L_FOR_AWAIT_OF:     { VM_CHECK(sv_op_for_await_of(vm, js));     NEXT(1); }
+  L_ITER_NEXT:        { VM_CHECK(sv_op_iter_next(vm, js));        NEXT(1); }
+  L_ITER_GET_VALUE:   { sv_op_iter_get_value(vm, js);             NEXT(1); }
+  L_ITER_CLOSE:       { sv_op_iter_close(vm, js);                 NEXT(1); }
+  L_ITER_CALL:        { VM_CHECK(sv_op_iter_call(vm, js, ip));    NEXT(2); }
+  L_AWAIT_ITER_NEXT:  { VM_CHECK(sv_op_await_iter_next(vm, js));  NEXT(1); }
+
+  L_AWAIT: {
+    jsval_t await_val = vm->stack[--vm->sp];
+    jsval_t result = sv_await_value(js, await_val);
+    if (is_err(result)) { sv_err = result; goto sv_throw; }
+    vm->stack[vm->sp++] = result;
+    NEXT(1);
+  }
+  
+  // TODO: implement
+  L_YIELD:          { NEXT(1); }
+  L_YIELD_STAR:     { NEXT(1); }
+  L_INITIAL_YIELD:  { NEXT(1); }
+
+  L_SPREAD:              { VM_CHECK(sv_op_spread(vm, js));         NEXT(1); }
+  L_DEFINE_METHOD:       { sv_op_define_method(vm, js, func, ip);  NEXT(6); }
+  L_DEFINE_METHOD_COMP:  { sv_op_define_method_comp(vm, js, ip);   NEXT(2); }
+  L_SET_NAME:            { sv_op_set_name(vm, js, func, ip);       NEXT(5); }
+  L_SET_NAME_COMP:       { sv_op_set_name_comp(vm, js);            NEXT(1); }
+  L_SET_PROTO:           { sv_op_set_proto(vm, js);                NEXT(1); }
+  L_SET_HOME_OBJ:        { sv_op_set_home_obj(vm, js);             NEXT(1); }
+  L_APPEND:              { sv_op_append(vm, js);                   NEXT(1); }
+  L_COPY_DATA_PROPS:     { sv_op_copy_data_props(vm, js, ip);      NEXT(2); }
+
+  L_DEFINE_CLASS:       { sv_op_define_class(vm, js, func, ip);       NEXT(6); }
+  L_DEFINE_CLASS_COMP:  { sv_op_define_class_comp(vm, js, func, ip);  NEXT(6); }
+  L_ADD_BRAND:          { sv_op_add_brand(vm);                        NEXT(1); }
+
+  L_TO_OBJECT:   { VM_CHECK(sv_op_to_object(vm, js));  NEXT(1); }
+  L_TO_PROPKEY:  { sv_op_to_propkey(vm, js);           NEXT(1); }
+  L_IS_UNDEF:    { sv_op_is_undef(vm);                 NEXT(1); }
+  L_IS_NULL:     { sv_op_is_null(vm);                  NEXT(1); }
+
+  L_IMPORT:          { VM_CHECK(sv_op_import(vm, js));            NEXT(1); }
+  L_IMPORT_SYNC:     { VM_CHECK(sv_op_import_sync(vm, js));       NEXT(1); }
+  L_IMPORT_DEFAULT:  { sv_op_import_default(vm, js);              NEXT(1); }
+  L_EXPORT:          { VM_CHECK(sv_op_export(vm, js, func, ip));  NEXT(5); }
+  L_EXPORT_ALL:      { VM_CHECK(sv_op_export_all(vm, js));        NEXT(1); }
+
+  L_ENTER_WITH:   { VM_CHECK(sv_op_enter_with(vm, js, frame));  NEXT(1); }
+  L_EXIT_WITH:    { sv_op_exit_with(vm, frame);                 NEXT(1); }
+
+  L_WITH_GET_VAR:  { VM_CHECK(sv_op_with_get_var(vm, js, frame, func, ip));  NEXT(8); }
+  L_WITH_PUT_VAR:  { sv_op_with_put_var(vm, js, frame, func, ip);            NEXT(8); }
+  L_WITH_DEL_VAR:  { sv_op_with_del_var(vm, js, frame, func, ip);            NEXT(5); }
+
+  L_SPECIAL_OBJ:  { sv_op_special_obj(vm, js, frame, ip);                       NEXT(2); }
+  L_EMPTY:        { vm->stack[vm->sp++] = T_EMPTY;                              NEXT(1); }
+  L_PUT_CONST:    { func->constants[sv_get_u32(ip + 1)] = vm->stack[--vm->sp];  NEXT(5); }
+  
+  L_DEBUGGER:  { NEXT(1); }
+  L_NOP:       { NEXT(1); }
+
+  L_LABEL:
+  L_LINE_NUM:
+  L_COL_NUM:
+  L_INVALID:
+    sv_err = js_mkerr(js, "invalid opcode %d", (int)*ip);
+    goto sv_throw;
+
+  sv_throw: {
+    uint8_t *catch_ip = sv_vm_throw(vm, sv_err, entry_fp);
+    if (catch_ip) {
+      frame = &vm->frames[vm->fp];
+      func = frame->func;
+      bp = frame->bp;
+      lp = frame->lp;
+      
+      ip = catch_ip;
+      DISPATCH();
+    }
+    if (!is_err(sv_err)) {
+      vm_result = js_throw(js, sv_err);
+      goto sv_leave;
+    }
+    vm_result = sv_err;
+    goto sv_leave;
+  }
+
+  sv_leave:
+  for (int f = vm->fp; f >= entry_fp; f--) {
+    jsval_t *drop_bp = vm->frames[f].bp;
+    if (drop_bp) sv_close_upvalues_from_slot(vm, drop_bp);
+  }
+  vm->fp = entry_fp;
+  vm->sp = vm->frames[entry_fp].prev_sp;
+  vm->handler_depth = vm->frames[entry_fp].handler_base;
+
+  return vm_result;
+
+  #undef DISPATCH
+  #undef NEXT
+  #undef VM_CHECK
+
+  // TODO: use entry_bp/frame->bp
+  //       and sv_op_size values
+  (void)bp;
+  (void)sv_op_size;
+}
diff --git a/src/silver/glue.c b/src/silver/glue.c
new file mode 100644
index 0000000..24c8e11
--- /dev/null
+++ b/src/silver/glue.c
@@ -0,0 +1,489 @@
+#ifdef ANT_JIT
+
+#include <math.h>
+#include "silver/glue.h"
+
+#include "utf8.h"
+#include "internal.h"
+#include "errors.h"
+
+#include "ops/globals.h"
+#include "ops/property.h"
+#include "ops/upvalues.h"
+#include "ops/comparison.h"
+
+bool jit_helper_stack_overflow(ant_t *js) {
+  volatile char marker;
+  uintptr_t curr = (uintptr_t)&marker;
+  if (js->cstk.limit == 0 || js->cstk.base == NULL) return false;
+  uintptr_t base = (uintptr_t)js->cstk.base;
+  size_t used = (base > curr) ? (base - curr) : (curr - base);
+  return used > js->cstk.limit;
+}
+
+jsval_t jit_helper_stack_overflow_error(sv_vm_t *vm, ant_t *js) {
+  return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum JIT call stack size exceeded");
+}
+
+jsval_t jit_helper_add(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) + tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_sub(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) - tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_mul(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) * tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_div(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) / tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_mod(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(fmod(tod(l), tod(r)));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_lt(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return js_bool(tod(l) < tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_le(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return js_bool(tod(l) <= tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_call(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t func, jsval_t this_val,
+  jsval_t *args, int argc
+) {
+  return sv_vm_call(vm, js, func, this_val, args, argc, NULL, false);
+}
+
+jsval_t jit_helper_get_global(ant_t *js, const char *str, uint32_t len) {
+  return sv_global_get(js, str, len);
+}
+
+jsval_t jit_helper_seq(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  return mkval(T_BOOL, strict_eq_values(js, l, r));
+}
+
+jsval_t jit_helper_in(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  return do_in(js, l, r);
+}
+
+jsval_t jit_helper_eq(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  return sv_abstract_eq(js, l, r);
+}
+
+jsval_t jit_helper_throw(sv_vm_t *vm, ant_t *js, jsval_t val) {
+  return js_throw(js, val);
+}
+
+jsval_t jit_helper_ne(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  jsval_t eq = sv_abstract_eq(js, l, r);
+  return mkval(T_BOOL, !vdata(eq));
+}
+
+jsval_t jit_helper_sne(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  return mkval(T_BOOL, !strict_eq_values(js, l, r));
+}
+
+jsval_t jit_helper_not(sv_vm_t *vm, ant_t *js, jsval_t v) {
+  return mkval(T_BOOL, !js_truthy(js, v));
+}
+
+jsval_t jit_helper_instanceof(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  return do_instanceof(js, l, r);
+}
+
+// TODO: dont bail out
+jsval_t jit_helper_typeof(sv_vm_t *vm, ant_t *js, jsval_t v) {
+  return SV_JIT_BAILOUT;
+}
+
+int64_t jit_helper_is_truthy(ant_t *js, jsval_t v) {
+  return (int64_t)js_truthy(js, v);
+}
+
+sv_closure_t *jit_helper_get_closure(jsval_t v) {
+  if (vtype(v) != T_FUNC) return NULL;
+  return js_func_closure(v);
+}
+
+static inline void jit_set_error_site_from_func(ant_t *js, sv_func_t *func, int32_t bc_off) {
+  if (!func) return;
+  js_set_error_site_from_bc(js, func, (int)bc_off, func->filename);
+}
+
+jsval_t jit_helper_get_field(
+  sv_vm_t *vm, ant_t *js, jsval_t obj, 
+  const char *str, uint32_t len, sv_func_t *func, int32_t bc_off
+) {
+  if (vtype(obj) == T_NULL || vtype(obj) == T_UNDEF)
+    jit_set_error_site_from_func(js, func, bc_off);
+  return sv_prop_get(js, obj, str, len);
+}
+
+jsval_t jit_helper_to_propkey(sv_vm_t *vm, ant_t *js, jsval_t v) {
+  if (vtype(v) == T_STR || vtype(v) == T_SYMBOL) return v;
+  return coerce_to_str(js, v);
+}
+
+uint64_t jit_helper_vtype(jsval_t v) { return vtype(v); }
+double   jit_helper_tod(jsval_t v)   { return tod(v); }
+jsval_t  jit_helper_tov(double d)    { return tov(d); }
+jsval_t  jit_helper_mkbool(int b)    { return js_bool(b); }
+
+jsval_t jit_helper_closure(
+  sv_vm_t *vm, ant_t *js,
+  sv_closure_t *parent_closure, jsval_t this_val,
+  jsval_t *args, int argc,
+  uint32_t const_idx, jsval_t *locals, int n_locals
+) {
+  sv_func_t *parent_func = parent_closure->func;
+  sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(parent_func->constants[const_idx]);
+
+  sv_closure_t *closure = calloc(1, sizeof(sv_closure_t));
+  if (!closure) return mkval(T_ERR, 0);
+  
+  closure->func = child;
+  closure->bound_this = child->is_arrow ? this_val : js_mkundef();
+  closure->call_flags = 0;
+
+  // TODO: reduce nesting
+  if (child->upvalue_count > 0) {
+    closure->upvalues = calloc((size_t)child->upvalue_count, sizeof(sv_upvalue_t *));
+    for (int i = 0; i < child->upvalue_count; i++) {
+      sv_upval_desc_t *desc = &child->upval_descs[i];
+      if (desc->is_local) {
+        int idx = (int)desc->index;
+        if (idx < parent_func->param_count) {
+          sv_upvalue_t *uv = calloc(1, sizeof(sv_upvalue_t));
+          uv->closed = (idx < argc && args) ? args[idx] : js_mkundef();
+          uv->location = &uv->closed;
+          closure->upvalues[i] = uv;
+        } else {
+          int li = idx - parent_func->param_count;
+          if (li >= 0 && li < n_locals && locals) {
+            closure->upvalues[i] = sv_capture_upvalue(vm, &locals[li]);
+          } else {
+            sv_upvalue_t *uv = calloc(1, sizeof(sv_upvalue_t));
+            uv->closed = js_mkundef();
+            uv->location = &uv->closed;
+            closure->upvalues[i] = uv;
+          }
+        }
+      } else closure->upvalues[i] = parent_closure->upvalues[desc->index];
+    }
+  }
+
+  jsval_t func_obj = mkobj(js, 0);
+  closure->func_obj = func_obj;
+  js_setprop(js, func_obj, js->length_str, tov((double)child->param_count));
+  js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
+
+  jsval_t func_val = mkval(T_FUNC, (uintptr_t)closure);
+  if (!child->is_arrow && !child->is_method)
+    sv_setup_function_prototype(js, func_obj, func_val);
+
+  if (child->is_strict)
+    js_set_slot(js, func_obj, SLOT_STRICT, js_true);
+  if (child->is_arrow) {
+    js_set_slot(js, func_obj, SLOT_ARROW, js_true);
+    js_set_slot(js, func_obj, SLOT_BOUND_THIS, this_val);
+  }
+  if (child->is_async) {
+    js_set_slot(js, func_obj, SLOT_ASYNC, js_true);
+    jsval_t async_proto = js_get_slot(js, js->global, SLOT_ASYNC_PROTO);
+    if (vtype(async_proto) == T_FUNC)
+      js_set_proto(js, func_obj, async_proto);
+  } else {
+    jsval_t func_proto = js_get_slot(js, js->global, SLOT_FUNC_PROTO);
+    if (vtype(func_proto) == T_FUNC)
+      js_set_proto(js, func_obj, func_proto);
+  }
+
+  return func_val;
+}
+
+void jit_helper_close_upval(sv_vm_t *vm, uint16_t slot_idx, jsval_t *locals, int n_locals) {
+  (void)slot_idx; // TODO: use value
+  if (!locals || n_locals <= 0) return;
+
+  jsval_t *lo = locals;
+  jsval_t *hi = locals + n_locals;
+  sv_upvalue_t **pp = &vm->open_upvalues;
+  
+  while (*pp) {
+    sv_upvalue_t *uv = *pp;
+    if (uv->location >= lo && uv->location < hi) {
+      uv->closed = *uv->location;
+      uv->location = &uv->closed;
+      *pp = uv->next;
+    } else pp = &uv->next;
+  }
+}
+
+jsval_t jit_helper_bailout_resume(
+  sv_vm_t *vm, sv_closure_t *closure,
+  jsval_t this_val, jsval_t *args, int argc,
+  jsval_t *vstack, int64_t vstack_sp,
+  jsval_t *locals, int64_t n_locals,
+  int64_t bc_offset
+) {
+  if (!closure || !closure->func) return mkval(T_ERR, 0);
+  sv_func_t *fn = closure->func;
+  sv_jit_on_bailout(fn);
+
+  vm->jit_resume.active     = true;
+  vm->jit_resume.ip_offset  = (int)bc_offset;
+  vm->jit_resume.locals     = locals;
+  vm->jit_resume.n_locals   = n_locals;
+  vm->jit_resume.vstack     = vstack;
+  vm->jit_resume.vstack_sp  = vstack_sp;
+
+  return sv_execute_closure_entry(
+    vm, closure, closure->func_obj, js_mkundef(),
+    this_val, args, argc, NULL
+  );
+}
+
+void jit_helper_define_field(
+  sv_vm_t *vm, ant_t *js, jsval_t obj,
+  jsval_t val, const char *str, uint32_t len
+) { js_define_own_prop(js, obj, str, len, val); }
+
+
+void jit_helper_set_name(
+  sv_vm_t *vm, ant_t *js, jsval_t fn,
+  const char *str, uint32_t len
+) {
+  jsval_t name = js_mkstr(js, str, len);
+  setprop_cstr(js, fn, "name", 4, name);
+}
+
+jsval_t jit_helper_get_length(sv_vm_t *vm, ant_t *js, jsval_t obj) {
+  if (vtype(obj) == T_ARR)
+    return tov((double)(uint32_t)js_arr_len(js, obj));
+  if (vtype(obj) == T_STR) {
+    jsoff_t byte_len = 0;
+    jsoff_t off = vstr(js, obj, &byte_len);
+    const char *str_data = (const char *)&js->mem[off];
+    return tov((double)(uint32_t)utf16_strlen(str_data, byte_len));
+  }
+  return js_getprop_fallback(js, obj, "length");
+}
+
+jsval_t jit_helper_put_field(
+  sv_vm_t *vm, ant_t *js, jsval_t obj,
+  jsval_t val, const char *str, uint32_t len
+) {
+  jsval_t key = js_mkstr(js, str, len);
+  return js_setprop(js, obj, key, val);
+}
+
+jsval_t jit_helper_get_elem(
+  sv_vm_t *vm, ant_t *js, jsval_t obj, 
+  jsval_t key, sv_func_t *func, int32_t bc_off
+) {
+  uint8_t ot = vtype(obj);
+  if (ot == T_NULL || ot == T_UNDEF) {
+    jit_set_error_site_from_func(js, func, bc_off);
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "Cannot read properties of %s", ot == T_NULL ? "null" : "undefined");
+  }
+  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
+    double d = tod(key);
+    if (d >= 0 && d == (uint32_t)d)
+      return js_arr_get(js, obj, (uint32_t)d);
+  }
+  jsval_t str_elem = js_mkundef();
+  if (sv_try_string_index_get(js, obj, key, &str_elem))
+    return str_elem;
+  return sv_getprop_by_key(js, obj, key);
+}
+
+jsval_t jit_helper_put_elem(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t obj, jsval_t key, jsval_t val
+) {
+  if (vtype(key) == T_SYMBOL) return js_setprop(js, obj, key, val);
+  jsval_t key_jv = sv_key_to_propstr(js, key);
+  return js_setprop(js, obj, key_jv, val);
+}
+
+jsval_t jit_helper_put_global(
+  sv_vm_t *vm, ant_t *js, jsval_t val,
+  const char *str, uint32_t len, int is_strict
+) {
+  if (is_strict && lkp(js, js->global, str, len) == 0)
+    return js_mkerr_typed(js, JS_ERR_REFERENCE, "'%.*s' is not defined", (int)len, str);
+  jsval_t key = js_mkstr(js, str, len);
+  return js_setprop(js, js->global, key, val);
+}
+
+jsval_t jit_helper_object(sv_vm_t *vm, ant_t *js) {
+  jsval_t obj = mkobj(js, 0);
+  jsval_t proto = js_get_ctor_proto(js, "Object", 6);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto);
+  return obj;
+}
+
+jsval_t jit_helper_array(sv_vm_t *vm, ant_t *js, jsval_t *elements, int count) {
+  jsval_t arr = js_mkarr(js);
+  jshdl_t h = js_root(js, arr);
+  for (int i = 0; i < count; i++)
+    js_arr_push(js, js_deref(js, h), elements[i]);
+  arr = js_deref(js, h);
+  js_unroot(js, h);
+  return arr;
+}
+
+jsval_t jit_helper_catch_value(sv_vm_t *vm, ant_t *js, jsval_t err) {
+  if (vtype(err) == T_ERR && js->thrown_exists &&
+      vtype(js->thrown_value) != T_UNDEF) {
+    jsval_t caught = js->thrown_value;
+    js->thrown_value = js_mkundef();
+    js->thrown_exists = false;
+    return caught;
+  }
+  return err;
+}
+
+jsval_t jit_helper_throw_error(
+  sv_vm_t *vm, ant_t *js,
+  const char *str, uint32_t len, int err_type
+) { return js_mkerr_typed(js, (js_err_type_t)err_type, "%.*s", (int)len, str); }
+
+jsval_t jit_helper_get_elem2(sv_vm_t *vm, ant_t *js, jsval_t obj, jsval_t key) {
+  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
+    double d = tod(key);
+    if (d >= 0 && d == (uint32_t)d)
+      return js_arr_get(js, obj, (uint32_t)d);
+  }
+  jsval_t str_elem = js_mkundef();
+  if (sv_try_string_index_get(js, obj, key, &str_elem))
+    return str_elem;
+  return sv_getprop_by_key(js, obj, key);
+}
+
+jsval_t jit_helper_set_proto(sv_vm_t *vm, ant_t *js, jsval_t obj, jsval_t proto) {
+  uint8_t pt = vtype(proto);
+  if (pt == T_OBJ || pt == T_NULL || pt == T_FUNC || pt == T_ARR)
+    js_set_proto(js, obj, proto);
+  return js_mkundef();
+}
+
+jsval_t jit_helper_band(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
+  int32_t ai = js_to_int32(tod(l));
+  int32_t bi = js_to_int32(tod(r));
+  return tov((double)(ai & bi));
+}
+
+jsval_t jit_helper_bor(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
+  int32_t ai = js_to_int32(tod(l));
+  int32_t bi = js_to_int32(tod(r));
+  return tov((double)(ai | bi));
+}
+
+jsval_t jit_helper_bxor(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
+  int32_t ai = js_to_int32(tod(l));
+  int32_t bi = js_to_int32(tod(r));
+  return tov((double)(ai ^ bi));
+}
+
+jsval_t jit_helper_bnot(sv_vm_t *vm, ant_t *js, jsval_t v) {
+  if (vtype(v) != T_NUM) return SV_JIT_BAILOUT;
+  return tov((double)(~js_to_int32(tod(v))));
+}
+
+jsval_t jit_helper_shl(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
+  int32_t ai = js_to_int32(tod(l));
+  uint32_t bi = js_to_uint32(tod(r));
+  return tov((double)(ai << (bi & 0x1f)));
+}
+
+jsval_t jit_helper_shr(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
+  int32_t ai = js_to_int32(tod(l));
+  uint32_t bi = js_to_uint32(tod(r));
+  return tov((double)(ai >> (bi & 0x1f)));
+}
+
+jsval_t jit_helper_ushr(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
+  uint32_t ai = js_to_uint32(tod(l));
+  uint32_t bi = js_to_uint32(tod(r));
+  return tov((double)(ai >> (bi & 0x1f)));
+}
+
+jsval_t jit_helper_gt(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM)
+    return js_bool(tod(l) > tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_ge(sv_vm_t *vm, ant_t *js, jsval_t l, jsval_t r) {
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM)
+    return js_bool(tod(l) >= tod(r));
+  return SV_JIT_BAILOUT;
+}
+
+jsval_t jit_helper_delete(sv_vm_t *vm, ant_t *js, jsval_t obj, jsval_t key) {
+  jsval_t key_str = js_mkundef();
+
+  if (vtype(key) == T_SYMBOL) 
+    return js_delete_sym_prop(js, obj, key);
+  else key_str = coerce_to_str(js, key);
+
+  if (!is_err(key_str) && vtype(key_str) == T_STR) {
+    jsoff_t klen = 0;
+    jsoff_t koff = vstr(js, key_str, &klen);
+    const char *kptr = (const char *)&js->mem[koff];
+    return js_delete_prop(js, obj, kptr, klen);
+  }
+  return mkval(T_BOOL, 0);
+}
+
+jsval_t jit_helper_new(
+  sv_vm_t *vm, ant_t *js,
+  jsval_t func, jsval_t new_target,
+  jsval_t *args, int argc
+) {
+  js->new_target = new_target;
+
+  if (vtype(func) == T_OBJ && is_proxy(js, func))
+    return js_proxy_construct(js, func, args, argc, new_target);
+
+  jsval_t obj = mkobj(js, 0);
+
+  if (vtype(func) == T_FUNC) {
+    jsval_t proto_source = func;
+    jsval_t func_obj = js_func_obj(func);
+    jsval_t target_func = js_get_slot(js, func_obj, SLOT_TARGET_FUNC);
+    if (vtype(target_func) == T_FUNC) proto_source = target_func;
+    jsval_t proto = js_getprop_fallback(js, proto_source, "prototype");
+    if (is_object_type(proto)) js_set_proto(js, obj, proto);
+  }
+
+  jsval_t ctor_this = obj;
+  jsval_t result = sv_vm_call(vm, js, func, obj, args, argc, &ctor_this, true);
+  
+  if (is_err(result)) return result;
+  return is_object_type(result) ? result : (is_object_type(ctor_this) ? ctor_this : obj);
+}
+
+#endif
diff --git a/src/silver/lexer.c b/src/silver/lexer.c
new file mode 100644
index 0000000..d4077d3
--- /dev/null
+++ b/src/silver/lexer.c
@@ -0,0 +1,1160 @@
+#include "silver/lexer.h"
+
+#include "escape.h"
+#include "internal.h"
+#include "tokens.h"
+#include "utf8.h"
+#include "errors.h"
+
+#include <runtime.h>
+#include <math.h>
+#include <string.h>
+
+void sv_lexer_init(sv_lexer_t *lx, ant_t *js, const char *code, jsoff_t clen, bool strict) {
+  lx->js = js;
+  lx->code = code;
+  lx->clen = clen;
+  lx->strict = strict;
+  lx->st.pos = 0;
+  lx->st.toff = 0;
+  lx->st.tlen = 0;
+  lx->st.tval = js_mkundef();
+  lx->st.tok = TOK_ERR;
+  lx->st.consumed = 1;
+  lx->st.had_newline = false;
+}
+
+void sv_lexer_set_error_site(sv_lexer_t *lx) {
+  ant_t *js = lx->js;
+  jsoff_t off = lx->st.toff > 0 ? lx->st.toff : lx->st.pos;
+  js_set_error_site(js, lx->code, lx->clen, js->filename, off, lx->st.tlen);
+}
+
+void sv_lexer_save_state(const sv_lexer_t *lx, sv_lexer_state_t *st) {
+  *st = lx->st;
+}
+
+void sv_lexer_restore_state(sv_lexer_t *lx, const sv_lexer_state_t *st) {
+  lx->st = *st;
+}
+
+void sv_lexer_push_source(sv_lexer_t *lx, sv_lexer_checkpoint_t *cp, const char *code, jsoff_t clen) {
+  cp->code = lx->code;
+  cp->clen = lx->clen;
+  cp->strict = lx->strict;
+  cp->st = lx->st;
+
+  lx->code = code;
+  lx->clen = clen;
+  lx->st.pos = 0;
+  lx->st.toff = 0;
+  lx->st.tlen = 0;
+  lx->st.tval = js_mkundef();
+  lx->st.tok = TOK_ERR;
+  lx->st.consumed = 1;
+  lx->st.had_newline = false;
+}
+
+void sv_lexer_pop_source(sv_lexer_t *lx, const sv_lexer_checkpoint_t *cp) {
+  lx->code = cp->code;
+  lx->clen = cp->clen;
+  lx->strict = cp->strict;
+  lx->st = cp->st;
+}
+
+sv_lex_string_t sv_lexer_str_literal(sv_lexer_t *lx) {
+  ant_t *js = lx->js;
+  sv_lex_string_t outv = { .str = NULL, .len = 0, .ok = false };
+  uint8_t *in = (uint8_t *)&lx->code[lx->st.toff];
+  size_t n1 = 0, n2 = 0;
+  size_t cap = (size_t)lx->st.tlen;
+  if (cap == 0) {
+    outv.str = "";
+    outv.ok = true;
+    return outv;
+  }
+  uint8_t *out = code_arena_bump(cap);
+  if (!out) {
+    (void)js_mkerr(js, "oom");
+    return outv;
+  }
+  while (n2++ + 2 < (size_t)lx->st.tlen) {
+    if (in[n2] == '\\') {
+      if (lx->strict && is_octal_escape(in, n2)) {
+        sv_lexer_set_error_site(lx);
+        (void)js_mkerr_typed(js, JS_ERR_SYNTAX,
+          "Octal escape sequences are not allowed in strict mode.");
+        return outv;
+      }
+      size_t extra = decode_escape(in, n2, (size_t)lx->st.tlen, out, &n1, in[0]);
+      n2 += extra + 1;
+    } else {
+      out[n1++] = ((uint8_t *)lx->code)[lx->st.toff + n2];
+    }
+  }
+  outv.str = (const char *)out;
+  outv.len = (uint32_t)n1;
+  outv.ok = true;
+  return outv;
+}
+
+static int is_unicode_space(const unsigned char *p, jsoff_t remaining, bool *is_line_term) {
+  if (is_line_term) *is_line_term = false;
+  if (p[0] < 0x80) return 0;
+
+  utf8proc_int32_t cp;
+  utf8proc_ssize_t n = utf8_next(p, (utf8proc_ssize_t)remaining, &cp);
+  
+  if (cp < 0) return 0;
+  if (cp == 0xFEFF) return (int)n;
+
+  utf8proc_category_t cat = utf8proc_category(cp);
+  if (cat == UTF8PROC_CATEGORY_ZS) return (int)n;
+  
+  if (cat == UTF8PROC_CATEGORY_ZL || cat == UTF8PROC_CATEGORY_ZP) {
+    if (is_line_term) *is_line_term = true;
+    return (int)n;
+  }
+
+  return 0;
+}
+
+enum { C_0 = 0, C_SPC, C_NL, C_SL, C_HI };
+
+static const uint8_t cc[128] = {
+  0,0,0,0,0,0,0,0,0,C_SPC,C_NL,C_SPC,C_SPC,C_SPC,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  C_SPC,0,0,0,0,0,0,0,0,0,0,0,0,0,0,C_SL,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+};
+
+static jsoff_t sv_skiptonext(const char *code, jsoff_t len, jsoff_t n, bool *nl) {
+  static const void *D[] = { &&L0, &&LS, &&LN, &&LSL, &&LH };
+  bool saw_nl = false;
+  unsigned char c;
+
+  const char *p = code + n;
+  const char *end = code + len;
+
+  if (__builtin_expect(p == code && end - p >= 2 && p[0] == '#' && p[1] == '!', 0)) {
+    for (p += 2; p < end && *p != '\n'; p++);
+    if (p < end) { saw_nl = true; p++; }
+  }
+
+  if (__builtin_expect(p >= end, 0)) goto L0;
+  c = (unsigned char)*p;
+  goto *D[c & 0x80 ? C_HI : cc[c]];
+
+LS:
+  p++;
+  if (__builtin_expect(p >= end, 0)) goto L0;
+  c = (unsigned char)*p;
+  goto *D[c & 0x80 ? C_HI : cc[c]];
+
+LN:
+  saw_nl = true;
+  p++;
+  if (__builtin_expect(p >= end, 0)) goto L0;
+  c = (unsigned char)*p;
+  goto *D[c & 0x80 ? C_HI : cc[c]];
+
+LSL:
+  if (p + 1 >= end) goto L0;
+  if (p[1] == '/') {
+    for (p += 2; p < end && *p != '\n'; p++);
+    if (p < end) { saw_nl = true; p++; }
+    if (__builtin_expect(p >= end, 0)) goto L0;
+    c = (unsigned char)*p;
+    goto *D[c & 0x80 ? C_HI : cc[c]];
+  }
+  if (p[1] == '*') {
+    for (p += 2; p + 1 < end; p++) {
+      if (*p == '*' && p[1] == '/') { p += 2; break; }
+      if (*p == '\n') saw_nl = true;
+    }
+    if (__builtin_expect(p >= end, 0)) goto L0;
+    c = (unsigned char)*p;
+    goto *D[c & 0x80 ? C_HI : cc[c]];
+  }
+  goto L0;
+
+LH: {
+  bool lt;
+  int u = is_unicode_space((const unsigned char *)p, (jsoff_t)(end - p), &lt);
+  if (u > 0) {
+    if (lt) saw_nl = true;
+    p += u;
+    if (__builtin_expect(p >= end, 0)) goto L0;
+    c = (unsigned char)*p;
+    goto *D[c & 0x80 ? C_HI : cc[c]];
+  }
+}
+
+L0:
+  if (nl) *nl = saw_nl;
+  return (jsoff_t)(p - code);
+}
+
+#define K(s, t) if (len == sizeof(s)-1 && !memcmp(buf, s, sizeof(s)-1)) return t
+#define M(s) (len == sizeof(s)-1 && !memcmp(buf, s, sizeof(s)-1))
+
+bool is_eval_or_arguments_name(const char *buf, size_t len) {
+  switch (buf[0]) {
+    case 'a': if M("arguments") return true; break;
+    case 'e': if M("eval") return true; break;
+  }
+  return false;
+}
+
+bool is_strict_reserved_name(const char *buf, size_t len) {
+  switch (buf[0]) {
+    case 'i':
+      if M("interface") return true;
+      if M("implements") return true;
+      break;
+    case 'l':
+      if M("let") return true;
+      break;
+    case 'p':
+      if M("private") return true;
+      if M("package") return true;
+      if M("public") return true;
+      if M("protected") return true;
+      break;
+    case 's':
+      if M("static") return true;
+      break;
+    case 'y':
+      if M("yield") return true;
+      break;
+  }
+  return false;
+}
+
+static uint8_t parsekeyword(const char *buf, size_t len) {
+  switch (buf[0]) {
+    case 'a':
+      K("as", TOK_AS);
+      K("async", TOK_ASYNC);
+      K("await", TOK_AWAIT);
+      break;
+    case 'b':
+      K("break", TOK_BREAK);
+      break;
+    case 'c':
+      K("case", TOK_CASE);
+      K("catch", TOK_CATCH);
+      K("class", TOK_CLASS);
+      K("const", TOK_CONST);
+      K("continue", TOK_CONTINUE);
+      break;
+    case 'd':
+      K("do", TOK_DO);
+      K("default", TOK_DEFAULT);
+      K("delete", TOK_DELETE);
+      K("debugger", TOK_DEBUGGER);
+      break;
+    case 'e':
+      K("else", TOK_ELSE);
+      K("export", TOK_EXPORT);
+      break;
+    case 'f':
+      K("for", TOK_FOR);
+      K("from", TOK_FROM);
+      K("false", TOK_FALSE);
+      K("finally", TOK_FINALLY);
+      K("function", TOK_FUNC);
+      break;
+    case 'g':
+      K("globalThis", TOK_GLOBAL_THIS);
+      break;
+    case 'i':
+      K("if", TOK_IF);
+      K("in", TOK_IN);
+      K("import", TOK_IMPORT);
+      K("instanceof", TOK_INSTANCEOF);
+      break;
+    case 'l':
+      K("let", TOK_LET);
+      break;
+    case 'n':
+      K("new", TOK_NEW);
+      K("null", TOK_NULL);
+      break;
+    case 'o':
+      K("of", TOK_OF);
+      break;
+    case 'r':
+      K("return", TOK_RETURN);
+      break;
+    case 's':
+      K("super", TOK_SUPER);
+      K("static", TOK_STATIC);
+      K("switch", TOK_SWITCH);
+      break;
+    case 't':
+      K("try", TOK_TRY);
+      K("this", TOK_THIS);
+      K("true", TOK_TRUE);
+      K("throw", TOK_THROW);
+      K("typeof", TOK_TYPEOF);
+      break;
+    case 'u':
+      K("undefined", TOK_UNDEF);
+      break;
+    case 'v':
+      K("var", TOK_VAR);
+      K("void", TOK_VOID);
+      break;
+    case 'w':
+      K("while", TOK_WHILE);
+      K("with", TOK_WITH);
+      K("window", TOK_WINDOW);
+      break;
+    case 'y':
+      K("yield", TOK_YIELD);
+      break;
+  }
+  return TOK_IDENTIFIER;
+}
+
+#undef K
+#undef M
+
+#define CHAR_DIGIT  0x01
+#define CHAR_XDIGIT 0x02
+#define CHAR_ALPHA  0x04
+#define CHAR_IDENT  0x08
+#define CHAR_IDENT1 0x10
+#define CHAR_WS     0x20
+#define CHAR_OCTAL  0x40
+
+static const uint8_t char_type[256] = {
+  ['\t'] = CHAR_WS, ['\n'] = CHAR_WS, ['\r'] = CHAR_WS, [' '] = CHAR_WS,
+  ['0'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['1'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['2'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['3'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['4'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['5'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['6'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['7'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT | CHAR_OCTAL,
+  ['8'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT,
+  ['9'] = CHAR_DIGIT | CHAR_XDIGIT | CHAR_IDENT,
+  ['A'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['B'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['C'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['D'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['E'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['F'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['a'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['b'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['c'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['d'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['e'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['f'] = CHAR_XDIGIT | CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['G'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['H'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['I'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['J'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['K'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['L'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['M'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['N'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['O'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['P'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['Q'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['R'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['S'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['T'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['U'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['V'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['W'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['X'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['Y'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['Z'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['g'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['h'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['i'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['j'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['k'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['l'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['m'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['n'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['o'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['p'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['q'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['r'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['s'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['t'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['u'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['v'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['w'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['x'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['y'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1, ['z'] = CHAR_ALPHA | CHAR_IDENT | CHAR_IDENT1,
+  ['_'] = CHAR_IDENT | CHAR_IDENT1,
+  ['$'] = CHAR_IDENT | CHAR_IDENT1,
+};
+
+#define IS_DIGIT(c)  (char_type[(uint8_t)(c)] & CHAR_DIGIT)
+#define IS_XDIGIT(c) (char_type[(uint8_t)(c)] & CHAR_XDIGIT)
+#define IS_IDENT(c)  (char_type[(uint8_t)(c)] & CHAR_IDENT)
+#define IS_IDENT1(c) (char_type[(uint8_t)(c)] & CHAR_IDENT1)
+#define IS_OCTAL(c)  (char_type[(uint8_t)(c)] & CHAR_OCTAL)
+
+#define likely(x)   __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+
+static const uint8_t single_char_tok[128] = {
+  ['('] = TOK_LPAREN,
+  [')'] = TOK_RPAREN,
+  ['{'] = TOK_LBRACE,
+  ['}'] = TOK_RBRACE,
+  ['['] = TOK_LBRACKET,
+  [']'] = TOK_RBRACKET,
+  [';'] = TOK_SEMICOLON,
+  [','] = TOK_COMMA,
+  [':'] = TOK_COLON,
+  ['~'] = TOK_TILDA,
+  ['#'] = TOK_HASH,
+};
+
+bool is_space(int c) { 
+  if (c < 0 || c >= 256) return false;
+  return (char_type[(uint8_t)c] & CHAR_WS) != 0;
+}
+
+bool is_digit(int c) { 
+  if (c < 0 || c >= 256) return false;
+  return (char_type[(uint8_t)c] & CHAR_DIGIT) != 0;
+}
+
+static bool is_ident_begin(int c) { 
+  if (c < 0) return false;
+  if (c < 128) return (char_type[(uint8_t)c] & CHAR_IDENT1) != 0;
+  return (c & 0x80) != 0;
+}
+
+static bool is_ident_continue(int c) { 
+  if (c < 0) return false;
+  if (c < 128) return (char_type[(uint8_t)c] & (CHAR_IDENT | CHAR_IDENT1)) != 0;
+  return (c & 0x80) != 0;
+}
+
+static int parse_unicode_escape(const char *buf, jsoff_t len, jsoff_t pos, uint32_t *codepoint) {
+  if (pos + 3 >= len) return 0;
+  if (buf[pos] != '\\' || buf[pos + 1] != 'u') return 0;
+
+  if (buf[pos + 2] == '{') {
+    jsoff_t i = pos + 3;
+    uint32_t cp = 0;
+    int ndigits = 0;
+    while (i < len && is_xdigit((unsigned char)buf[i])) {
+      cp = (cp << 4) | ((unsigned char)buf[i] <= '9' ? buf[i] - '0' : ((unsigned char)buf[i] | 0x20) - 'a' + 10);
+      i++;
+      ndigits++;
+    }
+    if (ndigits == 0 || i >= len || buf[i] != '}' || cp > 0x10FFFF) return 0;
+    *codepoint = cp;
+    return (int)(i - pos + 1);
+  }
+
+  if (pos + 5 >= len) return 0;
+  uint32_t cp = 0;
+  for (int i = 0; i < 4; i++) {
+    int c = (unsigned char)buf[pos + 2 + i];
+    if (!is_xdigit(c)) return 0;
+    cp <<= 4;
+    cp |= (c <= '9') ? (c - '0') : ((c | 0x20) - 'a' + 10);
+  }
+  *codepoint = cp;
+  return 6;
+}
+
+static bool is_unicode_id_start(utf8proc_int32_t cp) {
+  utf8proc_category_t cat = utf8proc_category(cp);
+  return 
+    cat == UTF8PROC_CATEGORY_LU || cat == UTF8PROC_CATEGORY_LL ||
+    cat == UTF8PROC_CATEGORY_LT || cat == UTF8PROC_CATEGORY_LM ||
+    cat == UTF8PROC_CATEGORY_LO || cat == UTF8PROC_CATEGORY_NL;
+}
+
+static bool is_unicode_id_continue(utf8proc_int32_t cp) {
+  if (is_unicode_id_start(cp)) return true;
+  utf8proc_category_t cat = utf8proc_category(cp);
+  return 
+    cat == UTF8PROC_CATEGORY_MN || cat == UTF8PROC_CATEGORY_MC ||
+    cat == UTF8PROC_CATEGORY_ND || cat == UTF8PROC_CATEGORY_PC ||
+    cp == 0x200C || cp == 0x200D;
+}
+
+static bool is_unicode_ident_begin(uint32_t cp) {
+  if (cp < 128) return (char_type[(uint8_t)cp] & CHAR_IDENT1) != 0;
+  return is_unicode_id_start((utf8proc_int32_t)cp);
+}
+
+static bool is_unicode_ident_continue(uint32_t cp) {
+  if (cp < 128) return (char_type[(uint8_t)cp] & (CHAR_IDENT | CHAR_IDENT1)) != 0;
+  return is_unicode_id_continue((utf8proc_int32_t)cp);
+}
+
+static size_t decode_ident_escapes(const char *src, size_t srclen, char *dst, size_t dstlen) {
+  size_t si = 0, di = 0;
+  while (si < srclen && di + 4 < dstlen) {
+    uint32_t cp;
+    int el = parse_unicode_escape(src, (jsoff_t)srclen, (jsoff_t)si, &cp);
+    if (el > 0) {
+      di += utf8_encode(cp, dst + di);
+      si += el;
+    } else dst[di++] = src[si++];
+  }
+  dst[di] = '\0';
+  return di;
+}
+
+static uint8_t parseident(const char *buf, jsoff_t len, jsoff_t *tlen) {
+  if (len == 0) return TOK_ERR;
+  
+  unsigned char c = (unsigned char)buf[0];
+  jsoff_t i = 0;
+  
+  if (c < 128 && c != '\\' && is_ident_begin(c)) {
+    i = 1;
+    while (i < len) {
+      c = (unsigned char)buf[i];
+      if (c >= 128 || c == '\\') goto slow_path_continue;
+      if (!is_ident_continue(c)) break;
+      i++;
+    }
+    *tlen = i;
+    return parsekeyword(buf, i);
+  }
+  
+  if (c == '\\') {
+    uint32_t first_cp;
+    int esc_len = parse_unicode_escape(buf, len, 0, &first_cp);
+    if (esc_len <= 0 || !is_unicode_ident_begin(first_cp)) return TOK_ERR;
+    *tlen = esc_len;
+    goto slow_path_loop;
+  }
+  
+  if (c >= 128) {
+    utf8proc_int32_t cp;
+    utf8proc_ssize_t n = utf8_next((const utf8proc_uint8_t *)buf, (utf8proc_ssize_t)len, &cp);
+    if (cp < 0 || !is_unicode_id_start(cp)) return TOK_ERR;
+    i = (jsoff_t)n;
+    *tlen = i;
+    goto slow_path_loop;
+  }
+  
+  return TOK_ERR;
+
+slow_path_continue:
+  *tlen = i;
+  
+slow_path_loop:;
+  int has_escapes = (buf[0] == '\\');
+  
+  while (*tlen < len) {
+    c = (unsigned char)buf[*tlen];
+    
+    if (c == '\\') {
+      uint32_t cp;
+      int el = parse_unicode_escape(buf, len, *tlen, &cp);
+      if (el <= 0 || !is_unicode_ident_continue(cp)) break;
+      *tlen += el;
+      has_escapes = 1;
+    } else if (c < 128) {
+      if (!is_ident_continue(c)) break;
+      (*tlen)++;
+    } else {
+      utf8proc_int32_t cp;
+      utf8proc_ssize_t n = utf8_next(
+        (const utf8proc_uint8_t *)&buf[*tlen],
+        (utf8proc_ssize_t)(len - *tlen), &cp
+      );
+      if (cp < 0 || !is_unicode_id_continue(cp)) break;
+      *tlen += (jsoff_t)n;
+    }
+  }
+  
+  if (has_escapes) {
+    char decoded[256];
+    size_t decoded_len = decode_ident_escapes(buf, *tlen, decoded, sizeof(decoded));
+    uint8_t kw = parsekeyword(decoded, decoded_len);
+    if (kw != TOK_IDENTIFIER) return TOK_ERR;
+    return TOK_IDENTIFIER;
+  }
+  
+  return parsekeyword(buf, *tlen);
+}
+
+static inline jsoff_t parse_decimal(const char *buf, jsoff_t maxlen, double *out) {
+  uint64_t int_part = 0, frac_part = 0;
+  int frac_digits = 0;
+  jsoff_t i = 0;
+
+  while (i < maxlen && (IS_DIGIT(buf[i]) || buf[i] == '_')) {
+    if (buf[i] != '_') int_part = int_part * 10 + (buf[i] - '0');
+    i++;
+  }
+
+  if (i < maxlen && buf[i] == '.') {
+    i++;
+    while (i < maxlen && (IS_DIGIT(buf[i]) || buf[i] == '_')) {
+      if (buf[i] != '_') { frac_part = frac_part * 10 + (buf[i] - '0'); frac_digits++; }
+      i++;
+    }
+  }
+
+  static const double neg_pow10[] = {
+    1e0,1e-1,1e-2,1e-3,1e-4,1e-5,1e-6,1e-7,1e-8,1e-9,1e-10,
+    1e-11,1e-12,1e-13,1e-14,1e-15,1e-16,1e-17,1e-18,1e-19,1e-20
+  };
+  
+  static const double pos_pow10[] = {
+    1e0,1e1,1e2,1e3,1e4,1e5,1e6,1e7,1e8,1e9,1e10,
+    1e11,1e12,1e13,1e14,1e15,1e16,1e17,1e18,1e19,1e20
+  };
+
+  double val = (double)int_part;
+  if (frac_digits > 0) {
+    val += (frac_digits <= 20) 
+      ? (double)frac_part * neg_pow10[frac_digits] 
+      : (double)frac_part * pow(10.0, -frac_digits);
+  }
+
+  if (i < maxlen && (buf[i] == 'e' || buf[i] == 'E')) {
+    i++;
+    int exp_sign = 1, exp_val = 0;
+    if (i < maxlen && (buf[i] == '+' || buf[i] == '-')) {
+      exp_sign = (buf[i] == '-') ? -1 : 1;
+      i++;
+    }
+    while (i < maxlen && (IS_DIGIT(buf[i]) || buf[i] == '_')) {
+      if (buf[i] != '_') exp_val = exp_val * 10 + (buf[i] - '0');
+      i++;
+    }
+    if (exp_val <= 20) {
+      val = (exp_sign > 0) ? val * pos_pow10[exp_val] : val * neg_pow10[exp_val];
+    } else val *= pow(10.0, exp_sign * exp_val);
+  }
+
+  *out = val;
+  return i;
+}
+
+static inline jsoff_t parse_binary(const char *buf, jsoff_t maxlen, double *out) {
+  double val = 0;
+  jsoff_t i = 2;
+  while (i < maxlen && (buf[i] == '0' || buf[i] == '1' || buf[i] == '_')) {
+    if (buf[i] != '_') val = val * 2 + (buf[i] - '0');
+    i++;
+  }
+  *out = val;
+  return i;
+}
+
+static inline jsoff_t parse_octal(const char *buf, jsoff_t maxlen, double *out) {
+  double val = 0;
+  jsoff_t i = 2;
+  while (i < maxlen && (IS_OCTAL(buf[i]) || buf[i] == '_')) {
+    if (buf[i] != '_') val = val * 8 + (buf[i] - '0');
+    i++;
+  }
+  *out = val;
+  return i;
+}
+
+static inline jsoff_t parse_legacy_octal(const char *buf, jsoff_t maxlen, double *out) {
+  double val = 0;
+  jsoff_t i = 1;
+  while (i < maxlen && IS_OCTAL(buf[i])) {
+      val = val * 8 + (buf[i] - '0');
+      i++;
+  }
+  *out = val;
+  return i;
+}
+
+static inline jsoff_t parse_hex(const char *buf, jsoff_t maxlen, double *out) {
+  double val = 0;
+  jsoff_t i = 2;
+  while (i < maxlen && (IS_XDIGIT(buf[i]) || buf[i] == '_')) {
+    if (buf[i] != '_') {
+      int d = 
+        (buf[i] >= 'a') ? (buf[i] - 'a' + 10) :
+        (buf[i] >= 'A') ? (buf[i] - 'A' + 10) : (buf[i] - '0');
+      val = val * 16 + d;
+    } i++;
+  }
+  *out = val;
+  return i;
+}
+
+static inline uint8_t parse_number(sv_lexer_t *lx, const char *buf, jsoff_t remaining) {
+  double value = 0;
+  jsoff_t numlen = 0;
+  
+  if (buf[0] == '0' && remaining > 1) {
+    char c1 = buf[1] | 0x20; 
+    if (c1 == 'b') {
+      numlen = parse_binary(buf, remaining, &value);
+    } else if (c1 == 'o') {
+      numlen = parse_octal(buf, remaining, &value);
+    } else if (c1 == 'x') {
+      numlen = parse_hex(buf, remaining, &value);
+    } else if (IS_OCTAL(buf[1])) {
+        if (lx->strict) {
+          lx->st.tok = TOK_ERR;
+          lx->st.tlen = 1;
+          return TOK_ERR;
+        }
+        numlen = parse_legacy_octal(buf, remaining, &value);
+    } else if (is_digit(buf[1]) && lx->strict) {
+        lx->st.tok = TOK_ERR;
+        lx->st.tlen = 1;
+        return TOK_ERR;
+    } else numlen = parse_decimal(buf, remaining, &value);
+  } else numlen = parse_decimal(buf, remaining, &value);
+  
+  lx->st.tval = tov(value);
+  if (numlen < remaining && buf[numlen] == 'n') {
+    lx->st.tok = TOK_BIGINT;
+    lx->st.tlen = numlen + 1;
+  } else {
+    lx->st.tok = TOK_NUMBER;
+    lx->st.tlen = numlen;
+  }
+  
+  return lx->st.tok;
+}
+
+static inline uint8_t scan_string(sv_lexer_t *lx, const char *buf, jsoff_t rem, char quote) {
+  jsoff_t i = 1;
+
+  while (i < rem) {
+    const char *p = buf + i;
+    jsoff_t search_len = rem - i;
+
+    const char *q = memchr(p, quote, search_len);
+    const char *b = memchr(p, '\\', search_len);
+
+    if (q == NULL) {
+      lx->st.tok = TOK_ERR;
+      lx->st.tlen = rem;
+      return TOK_ERR;
+    }
+
+    if (b == NULL || q < b) {
+      i = (jsoff_t)((q - buf) + 1);
+      lx->st.tok = TOK_STRING;
+      lx->st.tlen = i;
+      return TOK_STRING;
+    }
+
+    jsoff_t esc_pos = (jsoff_t)(b - buf);
+    if (esc_pos + 1 >= rem) {
+      lx->st.tok = TOK_ERR;
+      lx->st.tlen = rem;
+      return TOK_ERR;
+    }
+
+    char esc_char = buf[esc_pos + 1];
+    jsoff_t skip = 2;
+
+    if (esc_char == 'x') { skip = 4; } else if (esc_char == 'u') {
+      skip = (esc_pos + 2 < rem && buf[esc_pos + 2] == '{') ? 0 : 6;
+      if (skip == 0) {
+        jsoff_t j = esc_pos + 3;
+        while (j < rem && buf[j] != '}') j++;
+        skip = (j < rem) ? (j - esc_pos + 1) : (rem - esc_pos);
+      }
+    }
+
+    if (esc_pos + skip > rem) {
+      lx->st.tok = TOK_ERR;
+      lx->st.tlen = rem;
+      return TOK_ERR;
+    }
+
+    i = esc_pos + skip;
+  }
+
+  lx->st.tok = TOK_ERR;
+  lx->st.tlen = rem;
+  return TOK_ERR;
+}
+
+static inline jsoff_t skip_string_literal(const char *buf, jsoff_t rem, jsoff_t start, char quote) {
+  jsoff_t i = start + 1;
+  while (i < rem) {
+    if (buf[i] == '\\') { i += 2; continue; }
+    if (buf[i] == quote) { return i + 1; } i++;
+  }
+  return rem;
+}
+
+static inline jsoff_t skip_line_comment(const char *buf, jsoff_t rem, jsoff_t start) {
+  jsoff_t i = start + 2;
+  while (i < rem && buf[i] != '\n') i++;
+  return i;
+}
+
+static inline jsoff_t skip_block_comment(const char *buf, jsoff_t rem, jsoff_t start) {
+  jsoff_t i = start + 2;
+  while (i + 1 < rem && !(buf[i] == '*' && buf[i + 1] == '/')) i++;
+  return (i + 1 < rem) ? (i + 2) : rem;
+}
+
+static inline bool is_expr_ws(char c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v';
+}
+
+static inline bool is_ident_ascii_start(char c) {
+  return 
+    (c == '_' || c == '$' ||
+    (c >= 'a' && c <= 'z') ||
+    (c >= 'A' && c <= 'Z'));
+}
+
+static inline bool is_ident_ascii_continue(char c) {
+  return is_ident_ascii_start(c) || (c >= '0' && c <= '9');
+}
+
+static inline jsoff_t skip_regex_literal(const char *buf, jsoff_t rem, jsoff_t start) {
+  jsoff_t i = start + 1;
+  bool in_class = false;
+
+  while (i < rem) {
+    char c = buf[i];
+    if (c == '\\' && i + 1 < rem) { i += 2; continue; }
+    if (c == '[') in_class = true;
+    else if (c == ']' && in_class) in_class = false;
+    else if (c == '/' && !in_class) { i++; break; }
+    i++;
+  }
+
+  while (i < rem && is_ident_ascii_start(buf[i])) i++;
+  return i;
+}
+
+// todo: modularize
+static inline bool regex_allowed_after_ident(const char *buf, jsoff_t start, jsoff_t end) {
+  size_t n = (size_t)(end - start);
+  if (n == 2 && !memcmp(buf + start, "if", 2)) return true;
+  if (n == 2 && !memcmp(buf + start, "in", 2)) return true;
+  if (n == 2 && !memcmp(buf + start, "do", 2)) return true;
+  if (n == 2 && !memcmp(buf + start, "of", 2)) return true;
+  if (n == 3 && !memcmp(buf + start, "for", 3)) return true;
+  if (n == 4 && !memcmp(buf + start, "else", 4)) return true;
+  if (n == 4 && !memcmp(buf + start, "case", 4)) return true;
+  if (n == 5 && !memcmp(buf + start, "throw", 5)) return true;
+  if (n == 6 && !memcmp(buf + start, "return", 6)) return true;
+  if (n == 6 && !memcmp(buf + start, "typeof", 6)) return true;
+  if (n == 6 && !memcmp(buf + start, "delete", 6)) return true;
+  if (n == 4 && !memcmp(buf + start, "void", 4)) return true;
+  if (n == 3 && !memcmp(buf + start, "new", 3)) return true;
+  if (n == 10 && !memcmp(buf + start, "instanceof", 10)) return true;
+  return false;
+}
+
+static jsoff_t skip_template_literal(const char *buf, jsoff_t rem, jsoff_t start) {
+  jsoff_t i = start + 1;
+  int expr_depth = 0;
+  bool can_start_regex = true;
+
+  while (i < rem) {
+    char c = buf[i];
+
+    if (c == '\\') {
+      i += 2;
+      continue;
+    }
+
+    if (expr_depth == 0) {
+      if (c == '`') return i + 1;
+      if (c == '$' && i + 1 < rem && buf[i + 1] == '{') {
+        expr_depth = 1;
+        can_start_regex = true;
+        i += 2;
+        continue;
+      } i++; continue;
+    }
+
+    if (c == '\'' || c == '"') {
+      i = skip_string_literal(buf, rem, i, c);
+      continue;
+    }
+
+    if (c == '`') {
+      jsoff_t next = skip_template_literal(buf, rem, i);
+      if (next <= i) return rem;
+      i = next;
+      can_start_regex = false;
+      continue;
+    }
+
+    if (c == '/' && i + 1 < rem) {
+      if (buf[i + 1] == '/') { i = skip_line_comment(buf, rem, i); continue; }
+      if (buf[i + 1] == '*') { i = skip_block_comment(buf, rem, i); continue; }
+      if (can_start_regex) {
+        i = skip_regex_literal(buf, rem, i);
+        can_start_regex = false;
+        continue;
+      }
+      i++;
+      can_start_regex = true;
+      continue;
+    }
+
+    if (is_expr_ws(c)) { i++; continue; }
+
+    if (is_ident_ascii_start(c)) {
+      jsoff_t id_start = i;
+      i++;
+      while (i < rem && is_ident_ascii_continue(buf[i])) i++;
+      can_start_regex = regex_allowed_after_ident(buf, id_start, i);
+      continue;
+    }
+
+    if ((c >= '0' && c <= '9') || (c == '.' && i + 1 < rem && (buf[i + 1] >= '0' && buf[i + 1] <= '9'))) {
+      i++;
+      while (i < rem) {
+        char d = buf[i];
+        if ((d >= '0' && d <= '9') || d == '_' || d == '.') i++;
+        else break;
+      }
+      can_start_regex = false;
+      continue;
+    }
+
+    if (c == '{') { expr_depth++; i++; can_start_regex = true; continue; }
+    if (c == '}') { expr_depth--; i++; can_start_regex = false; continue; }
+
+    if (c == '(' || c == '[' || c == ',' || c == ';' || c == ':' || c == '?' ||
+        c == '!' || c == '~' || c == '+' || c == '-' || c == '*' || c == '%' ||
+        c == '&' || c == '|' || c == '^' || c == '=' || c == '<' || c == '>') {
+      i++;
+      can_start_regex = true;
+      continue;
+    }
+
+    if (c == ')' || c == ']') {
+      i++;
+      can_start_regex = false;
+      continue;
+    }
+
+    i++;
+    can_start_regex = false;
+  }
+
+  return rem;
+}
+
+static inline uint8_t scan_template(sv_lexer_t *lx, const char *buf, jsoff_t rem) {
+  jsoff_t end = skip_template_literal(buf, rem, 0);
+  if (end <= 1 || end > rem) {
+    lx->st.tok = TOK_ERR;
+    lx->st.tlen = rem;
+    return TOK_ERR;
+  }
+
+  lx->st.tok = TOK_TEMPLATE;
+  lx->st.tlen = end;
+  return TOK_TEMPLATE;
+}
+
+static inline uint8_t parse_operator(sv_lexer_t *lx, const char *buf, jsoff_t rem) {
+  #define MATCH2(c1,c2)       (rem >= 2 && buf[1] == (c2))
+  #define MATCH3(c1,c2,c3)    (rem >= 3 && buf[1] == (c2) && buf[2] == (c3))
+  #define MATCH4(c1,c2,c3,c4) (rem >= 4 && buf[1]==(c2) && buf[2]==(c3) && buf[3]==(c4))
+
+  switch (buf[0]) {
+  case '?':
+    if (MATCH3('?','?','=')) { lx->st.tok = TOK_NULLISH_ASSIGN; lx->st.tlen = 3; }
+    else if (MATCH2('?','?')) { lx->st.tok = TOK_NULLISH; lx->st.tlen = 2; }
+    else if (MATCH2('?','.')) { lx->st.tok = TOK_OPTIONAL_CHAIN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_Q; lx->st.tlen = 1; }
+    break;
+
+  case '!':
+    if (MATCH3('!','=','=')) { lx->st.tok = TOK_SNE; lx->st.tlen = 3; }
+    else if (MATCH2('!','=')) { lx->st.tok = TOK_NE; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_NOT; lx->st.tlen = 1; }
+    break;
+
+  case '=':
+    if (MATCH3('=','=','=')) { lx->st.tok = TOK_SEQ; lx->st.tlen = 3; }
+    else if (MATCH2('=','=')) { lx->st.tok = TOK_EQ; lx->st.tlen = 2; }
+    else if (MATCH2('=','>')) { lx->st.tok = TOK_ARROW; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_ASSIGN; lx->st.tlen = 1; }
+    break;
+
+  case '<':
+    if (MATCH3('<','<','=')) { lx->st.tok = TOK_SHL_ASSIGN; lx->st.tlen = 3; }
+    else if (MATCH2('<','<')) { lx->st.tok = TOK_SHL; lx->st.tlen = 2; }
+    else if (MATCH2('<','=')) { lx->st.tok = TOK_LE; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_LT; lx->st.tlen = 1; }
+    break;
+
+  case '>':
+    if (MATCH4('>','>','>','=')) { lx->st.tok = TOK_ZSHR_ASSIGN; lx->st.tlen = 4; }
+    else if (MATCH3('>','>','>')) { lx->st.tok = TOK_ZSHR; lx->st.tlen = 3; }
+    else if (MATCH3('>','>','=')) { lx->st.tok = TOK_SHR_ASSIGN; lx->st.tlen = 3; }
+    else if (MATCH2('>','>')) { lx->st.tok = TOK_SHR; lx->st.tlen = 2; }
+    else if (MATCH2('>','=')) { lx->st.tok = TOK_GE; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_GT; lx->st.tlen = 1; }
+    break;
+
+  case '&':
+    if (MATCH3('&','&','=')) { lx->st.tok = TOK_LAND_ASSIGN; lx->st.tlen = 3; }
+    else if (MATCH2('&','&')) { lx->st.tok = TOK_LAND; lx->st.tlen = 2; }
+    else if (MATCH2('&','=')) { lx->st.tok = TOK_AND_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_AND; lx->st.tlen = 1; }
+    break;
+
+  case '|':
+    if (MATCH3('|','|','=')) { lx->st.tok = TOK_LOR_ASSIGN; lx->st.tlen = 3; }
+    else if (MATCH2('|','|')) { lx->st.tok = TOK_LOR; lx->st.tlen = 2; }
+    else if (MATCH2('|','=')) { lx->st.tok = TOK_OR_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_OR; lx->st.tlen = 1; }
+    break;
+
+  case '+':
+    if (MATCH2('+','+')) { lx->st.tok = TOK_POSTINC; lx->st.tlen = 2; }
+    else if (MATCH2('+','=')) { lx->st.tok = TOK_PLUS_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_PLUS; lx->st.tlen = 1; }
+    break;
+
+  case '-':
+    if (MATCH2('-','-')) { lx->st.tok = TOK_POSTDEC; lx->st.tlen = 2; }
+    else if (MATCH2('-','=')) { lx->st.tok = TOK_MINUS_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_MINUS; lx->st.tlen = 1; }
+    break;
+
+  case '*':
+    if (MATCH3('*','*','=')) { lx->st.tok = TOK_EXP_ASSIGN; lx->st.tlen = 3; }
+    else if (MATCH2('*','*')) { lx->st.tok = TOK_EXP; lx->st.tlen = 2; }
+    else if (MATCH2('*','=')) { lx->st.tok = TOK_MUL_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_MUL; lx->st.tlen = 1; }
+    break;
+
+  case '/':
+    if (MATCH2('/','=')) { lx->st.tok = TOK_DIV_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_DIV; lx->st.tlen = 1; }
+    break;
+
+  case '%':
+    if (MATCH2('%','=')) { lx->st.tok = TOK_REM_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_REM; lx->st.tlen = 1; }
+    break;
+
+  case '^':
+    if (MATCH2('^','=')) { lx->st.tok = TOK_XOR_ASSIGN; lx->st.tlen = 2; }
+    else { lx->st.tok = TOK_XOR; lx->st.tlen = 1; }
+    break;
+
+  case '.':
+    if (MATCH3('.','.', '.')) { lx->st.tok = TOK_REST; lx->st.tlen = 3; }
+    else if (rem > 1 && IS_DIGIT(buf[1])) {
+      double val;
+      lx->st.tlen = parse_decimal(buf, rem, &val);
+      lx->st.tval = tov(val);
+      lx->st.tok = TOK_NUMBER;
+    }
+    else { lx->st.tok = TOK_DOT; lx->st.tlen = 1; }
+    break;
+
+  default:
+    return 0;
+  }
+
+  #undef MATCH2
+  #undef MATCH3
+  #undef MATCH4
+
+  return lx->st.tok;
+}
+
+static uint8_t sv_next_raw(sv_lexer_t *lx) {
+  if (likely(lx->st.consumed == 0)) return lx->st.tok;
+
+  lx->st.consumed = 0;
+  lx->st.tok = TOK_ERR;
+  lx->st.toff = lx->st.pos = sv_skiptonext(lx->code, lx->clen, lx->st.pos, &lx->st.had_newline);
+  lx->st.tlen = 0;
+
+  if (unlikely(lx->st.toff >= lx->clen)) {
+    lx->st.tok = TOK_EOF;
+    return TOK_EOF;
+  }
+
+  const char *buf = lx->code + lx->st.toff;
+  jsoff_t rem = lx->clen - lx->st.toff;
+  uint8_t c = (uint8_t)buf[0];
+
+  if (likely(c < 128)) {
+    uint8_t simple_tok = single_char_tok[c];
+    if (simple_tok != 0) {
+      lx->st.tok = simple_tok;
+      lx->st.tlen = 1;
+      lx->st.pos = lx->st.toff + 1;
+      return simple_tok;
+    }
+  }
+
+  if (likely(IS_IDENT1(c))) {
+    lx->st.tok = parseident(buf, rem, &lx->st.tlen);
+    lx->st.pos = lx->st.toff + lx->st.tlen;
+    return lx->st.tok;
+  }
+
+  if (IS_DIGIT(c)) {
+    parse_number(lx, buf, rem);
+    if (lx->st.tlen == 0) lx->st.tlen = 1;
+    lx->st.pos = lx->st.toff + lx->st.tlen;
+    return lx->st.tok;
+  }
+
+  if (c == '"' || c == '\'') {
+    scan_string(lx, buf, rem, c);
+    if (lx->st.tlen == 0) lx->st.tlen = 1;
+    lx->st.pos = lx->st.toff + lx->st.tlen;
+    return lx->st.tok;
+  }
+
+  if (c == '`') {
+    scan_template(lx, buf, rem);
+    if (lx->st.tlen == 0) lx->st.tlen = 1;
+    lx->st.pos = lx->st.toff + lx->st.tlen;
+    return lx->st.tok;
+  }
+
+  if (parse_operator(lx, buf, rem)) {
+    if (lx->st.tlen == 0) lx->st.tlen = 1;
+    lx->st.pos = lx->st.toff + lx->st.tlen;
+    return lx->st.tok;
+  }
+
+  lx->st.tok = parseident(buf, rem, &lx->st.tlen);
+  if (lx->st.tlen == 0) lx->st.tlen = 1;
+  lx->st.pos = lx->st.toff + lx->st.tlen;
+  
+  return lx->st.tok;
+}
+
+uint8_t sv_lexer_next(sv_lexer_t *lx) {
+  if (likely(lx->st.consumed == 0)) return lx->st.tok;
+  return sv_next_raw(lx);
+}
+
+uint8_t sv_lexer_lookahead(sv_lexer_t *lx) {
+  uint8_t old = lx->st.tok, tok = 0;
+  uint8_t old_consumed = lx->st.consumed;
+  
+  jsoff_t pos = lx->st.pos;
+  jsoff_t toff = lx->st.toff;
+  jsoff_t tlen = lx->st.tlen;
+  
+  bool had_newline = lx->st.had_newline;
+
+  lx->st.consumed = 1;
+  tok = sv_lexer_next(lx);
+  
+  lx->st.pos = pos;
+  lx->st.tok = old;
+  lx->st.toff = toff;
+  lx->st.tlen = tlen;
+  
+  lx->st.had_newline = had_newline;
+  lx->st.consumed = old_consumed;
+  
+  return tok;
+}
diff --git a/src/silver/limits.c b/src/silver/limits.c
new file mode 100644
index 0000000..3900b71
--- /dev/null
+++ b/src/silver/limits.c
@@ -0,0 +1,56 @@
+#include "silver/vm.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/resource.h>
+#include <pthread.h>
+#endif
+
+#define SV_DEFAULT_STACK_KB  984
+#define SV_ASYNC_STACK_KB    64
+#define SV_BYTES_PER_SLOT    ((int)sizeof(uint64_t))
+
+int sv_user_stack_size_kb = 0;
+
+static size_t os_thread_stack_size(void) {
+#ifdef _WIN32
+  return 1024 * 1024;
+#else
+  struct rlimit rl;
+  if (getrlimit(RLIMIT_STACK, &rl) == 0 && rl.rlim_cur != RLIM_INFINITY)
+    return (size_t)rl.rlim_cur;
+
+  pthread_attr_t attr;
+  size_t sz = 0;
+  if (pthread_attr_init(&attr) == 0) {
+    pthread_attr_getstacksize(&attr, &sz);
+    pthread_attr_destroy(&attr);
+    if (sz > 0) return sz;
+  }
+
+  return 8 * 1024 * 1024;
+#endif
+}
+
+void sv_vm_limits(sv_vm_kind_t kind, int *out_stack_size, int *out_max_frames) {
+  if (kind == SV_VM_ASYNC) {
+    *out_stack_size = (SV_ASYNC_STACK_KB * 1024) / SV_BYTES_PER_SLOT;
+    *out_max_frames = 256;
+    return;
+  }
+
+  int stack_kb = (sv_user_stack_size_kb > 0)
+    ? sv_user_stack_size_kb
+    : SV_DEFAULT_STACK_KB;
+
+  int slots = (stack_kb * 1024) / SV_BYTES_PER_SLOT;
+  int frames = stack_kb * 10;
+  if (frames > slots) frames = slots;
+
+  *out_stack_size = slots;
+  *out_max_frames = frames;
+}
diff --git a/src/silver/ops/arithmetic.h b/src/silver/ops/arithmetic.h
new file mode 100644
index 0000000..196b7bf
--- /dev/null
+++ b/src/silver/ops/arithmetic.h
@@ -0,0 +1,210 @@
+#ifndef SV_ARITHMETIC_H
+#define SV_ARITHMETIC_H
+
+#include <math.h>
+#include "tokens.h"
+#include "errors.h"
+#include "silver/engine.h"
+
+static inline jsval_t sv_op_add(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
+    vm->stack[vm->sp++] = tov(tod(l) + tod(r));
+    return tov(0);
+  }
+  jsval_t lu = unwrap_primitive(js, l);
+  jsval_t ru = unwrap_primitive(js, r);
+  if (vtype(lu) == T_BIGINT && vtype(ru) == T_BIGINT) {
+    jsval_t res = bigint_add(js, lu, ru);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (vtype(lu) == T_BIGINT || vtype(ru) == T_BIGINT) {
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  }
+  if (is_non_numeric(lu) || is_non_numeric(ru) ||
+      (vtype(lu) == T_STR && vtype(ru) == T_STR)) {
+    jsval_t l_str = coerce_to_str_concat(js, l);
+    if (is_err(l_str)) return l_str;
+    jshdl_t lh = js_root(js, l_str);
+    jsval_t r_str = coerce_to_str_concat(js, r);
+    l_str = js_deref(js, lh); js_unroot(js, lh);
+    if (is_err(r_str)) return r_str;
+    jsval_t res = do_string_op(js, TOK_PLUS, l_str, r_str);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  vm->stack[vm->sp++] = tov(js_to_number(js, l) + js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_sub(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
+    vm->stack[vm->sp++] = tov(tod(l) - tod(r));
+    return tov(0);
+  }
+  if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
+    jsval_t res = bigint_sub(js, l, r);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  vm->stack[vm->sp++] = tov(js_to_number(js, l) - js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_mul(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
+    vm->stack[vm->sp++] = tov(tod(l) * tod(r));
+    return tov(0);
+  }
+  if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
+    jsval_t res = bigint_mul(js, l, r);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  vm->stack[vm->sp++] = tov(js_to_number(js, l) * js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_div(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
+    vm->stack[vm->sp++] = tov(tod(l) / tod(r));
+    return tov(0);
+  }
+  if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
+    jsval_t res = bigint_div(js, l, r);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  vm->stack[vm->sp++] = tov(js_to_number(js, l) / js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_mod(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
+    vm->stack[vm->sp++] = tov(fmod(tod(l), tod(r)));
+    return tov(0);
+  }
+  if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
+    jsval_t res = bigint_mod(js, l, r);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  vm->stack[vm->sp++] = tov(fmod(js_to_number(js, l), js_to_number(js, r)));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_exp(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  if (vtype(l) == T_NUM && vtype(r) == T_NUM) {
+    vm->stack[vm->sp++] = tov(pow(tod(l), tod(r)));
+    return tov(0);
+  }
+  if (vtype(l) == T_BIGINT && vtype(r) == T_BIGINT) {
+    jsval_t res = bigint_exp(js, l, r);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (vtype(l) == T_BIGINT || vtype(r) == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  vm->stack[vm->sp++] = tov(pow(js_to_number(js, l), js_to_number(js, r)));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_neg(sv_vm_t *vm, ant_t *js) {
+  jsval_t a = vm->stack[--vm->sp];
+  if (vtype(a) == T_BIGINT) {
+    jsval_t res = bigint_neg(js, a);
+    vm->stack[vm->sp++] = res;
+    return res;
+  }
+  if (is_object_type(a)) {
+    jsval_t prim = js_to_primitive(js, a, 2);
+    if (is_err(prim)) return prim;
+    vm->stack[vm->sp++] = tov(-js_to_number(js, prim));
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = tov(-js_to_number(js, a));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_uplus(sv_vm_t *vm, ant_t *js) {
+  jsval_t a = vm->stack[--vm->sp];
+  if (vtype(a) == T_BIGINT)
+    return js_mkerr(js, "Cannot convert a BigInt value to a number");
+  if (is_object_type(a)) {
+    jsval_t prim = js_to_primitive(js, a, 2);
+    if (is_err(prim)) return prim;
+    vm->stack[vm->sp++] = tov(js_to_number(js, prim));
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = tov(js_to_number(js, a));
+  return tov(0);
+}
+
+static inline void sv_op_inc(sv_vm_t *vm) {
+  vm->stack[vm->sp - 1] = tov(tod(vm->stack[vm->sp - 1]) + 1.0);
+}
+
+static inline void sv_op_dec(sv_vm_t *vm) {
+  vm->stack[vm->sp - 1] = tov(tod(vm->stack[vm->sp - 1]) - 1.0);
+}
+
+static inline void sv_op_post_inc(sv_vm_t *vm) {
+  jsval_t old = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp++] = tov(tod(old) + 1.0);
+}
+
+static inline void sv_op_post_dec(sv_vm_t *vm) {
+  jsval_t old = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp++] = tov(tod(old) - 1.0);
+}
+
+static inline void sv_op_inc_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  jsval_t *slot = &lp[idx];
+  *slot = tov(tod(*slot) + 1.0);
+}
+
+static inline void sv_op_dec_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  jsval_t *slot = &lp[idx];
+  *slot = tov(tod(*slot) - 1.0);
+  (void)vm;
+}
+
+static inline jsval_t sv_op_add_local(sv_vm_t *vm, jsval_t *lp, ant_t *js, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  jsval_t *slot = &lp[idx];
+  jsval_t val = vm->stack[--vm->sp];
+  if (vtype(*slot) == T_NUM && vtype(val) == T_NUM) {
+    *slot = tov(tod(*slot) + tod(val));
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = *slot;
+  vm->stack[vm->sp++] = val;
+  jsval_t err = sv_op_add(vm, js);
+  if (is_err(err)) return err;
+  *slot = vm->stack[--vm->sp];
+  return tov(0);
+}
+
+#endif
diff --git a/src/silver/ops/async.h b/src/silver/ops/async.h
new file mode 100644
index 0000000..ef28aa1
--- /dev/null
+++ b/src/silver/ops/async.h
@@ -0,0 +1,337 @@
+#ifndef SV_ASYNC_H
+#define SV_ASYNC_H
+
+#include "ant.h"
+#include "sugar.h"
+#include "silver/engine.h"
+
+#include <minicoro.h>
+
+typedef struct {
+  ant_t *js;
+  coroutine_t *coro;
+} sv_coro_header_t;
+
+typedef struct {
+  ant_t *js;
+  
+  coroutine_t *coro;
+  sv_closure_t *closure;
+  
+  jsval_t callee_func;
+  jsval_t super_val;
+  jsval_t this_val;
+  jsval_t *args;
+  
+  int argc;
+  sv_vm_t *vm;
+} sv_async_ctx_t;
+
+static void sv_mco_async_entry(mco_coro *mco) {
+  sv_async_ctx_t *ctx = (sv_async_ctx_t *)mco_get_user_data(mco);
+  ant_t *js = ctx->js;
+  MCO_CORO_STACK_ENTER(js, mco);
+
+  jsval_t super_val = ctx->super_val;
+  if (ctx->coro) {
+    super_val = ctx->coro->super_val;
+    js->new_target = ctx->coro->new_target;
+  }
+
+  sv_vm_t *vm = ctx->vm;
+  jsval_t result = sv_execute_closure_entry(
+    vm, ctx->closure, ctx->callee_func, 
+    super_val, ctx->this_val, ctx->args, ctx->argc, NULL
+  );
+
+  jsval_t promise = ctx->coro->async_promise;
+
+  if (is_err(result)) {
+    jsval_t reject_value = js->thrown_value;
+    if (vtype(reject_value) == T_UNDEF) reject_value = result;
+    js->thrown_exists = false;
+    js->thrown_value = js_mkundef();
+    js_reject_promise(js, promise, reject_value);
+  } else js_resolve_promise(js, promise, result);
+}
+
+typedef struct {
+  ant_t *js;
+  coroutine_t *coro;
+  sv_func_t   *func;
+  jsval_t this_val;
+  sv_vm_t *vm;
+} sv_tla_ctx_t;
+
+static void sv_mco_tla_entry(mco_coro *mco) {
+  sv_tla_ctx_t *ctx = (sv_tla_ctx_t *)mco_get_user_data(mco);
+  ant_t *js = ctx->js;
+  sv_vm_t *vm = ctx->vm;
+  MCO_CORO_STACK_ENTER(js, mco);
+
+  jsval_t result = sv_execute_entry(vm, ctx->func, ctx->this_val, NULL, 0);
+  jsval_t promise = ctx->coro->async_promise;
+
+  if (is_err(result)) {
+    jsval_t reject_value = js->thrown_value;
+    if (vtype(reject_value) == T_UNDEF) reject_value = result;
+    js->thrown_exists = false;
+    js->thrown_value = js_mkundef();
+    js_reject_promise(js, promise, reject_value);
+  } else js_resolve_promise(js, promise, result);
+}
+
+static inline jsval_t sv_start_tla(ant_t *js, sv_func_t *func, jsval_t this_val) {
+  if (++coros_this_tick > CORO_PER_TICK_LIMIT) {
+    js->fatal_error = true;
+    return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK,
+      "Maximum async operations per tick exceeded");
+  }
+
+  jsval_t promise = js_mkpromise(js);
+  sv_tla_ctx_t *ctx = (sv_tla_ctx_t *)CORO_MALLOC(sizeof(sv_tla_ctx_t));
+  if (!ctx) return js_mkerr(js, "out of memory for TLA context");
+
+  sv_vm_t *async_vm = sv_vm_create(js, SV_VM_ASYNC);
+  if (!async_vm) { CORO_FREE(ctx); return js_mkerr(js, "out of memory for TLA VM"); }
+
+  ctx->js = js;
+  ctx->func = func;
+  ctx->this_val = this_val;
+  ctx->coro = NULL;
+  ctx->vm = async_vm;
+
+  size_t stack_size = 0;
+  const char *env_stack = getenv("ANT_CORO_STACK_SIZE");
+  if (env_stack) {
+    size_t sz = (size_t)atoi(env_stack) * 1024;
+    if (sz >= 32 * 1024 && sz <= 8 * 1024 * 1024) stack_size = sz;
+  }
+
+  mco_desc desc = mco_desc_init(sv_mco_tla_entry, stack_size);
+  desc.user_data = ctx;
+
+  mco_coro *mco = NULL;
+  mco_result res = mco_create(&mco, &desc);
+  if (res != MCO_SUCCESS) {
+    sv_vm_destroy(async_vm); CORO_FREE(ctx);
+    return js_mkerr(js, "failed to create TLA coroutine");
+  }
+
+  coroutine_t *coro = (coroutine_t *)CORO_MALLOC(sizeof(coroutine_t));
+  if (!coro) {
+    mco_destroy(mco);
+    sv_vm_destroy(async_vm); CORO_FREE(ctx);
+    return js_mkerr(js, "out of memory for TLA coroutine");
+  }
+
+  *coro = (coroutine_t){
+    .js = js,
+    .type = CORO_ASYNC_AWAIT,
+    .this_val = this_val,
+    .super_val = js_mkundef(),
+    .new_target = js_mkundef(),
+    .awaited_promise = js_mkundef(),
+    .result = js_mkundef(),
+    .async_func = js_mkundef(),
+    .args = NULL,
+    .nargs = 0,
+    .is_settled = false,
+    .is_error = false,
+    .is_done = false,
+    .resume_point = 0,
+    .yield_value = js_mkundef(),
+    .async_promise = promise,
+    .next = NULL,
+    .mco = mco,
+    .mco_started = false,
+    .is_ready = true,
+    .sv_vm = async_vm,
+  };
+
+  ctx->coro = coro;
+  enqueue_coroutine(coro);
+  MCO_RESUME_SAVE(js, mco, res);
+
+  if (res != MCO_SUCCESS && mco_status(mco) != MCO_DEAD) {
+    remove_coroutine(coro);
+    free_coroutine(coro);
+    return js_mkerr(js, "failed to start TLA coroutine");
+  }
+
+  coro->mco_started = true;
+  if (mco_status(mco) == MCO_DEAD) {
+    remove_coroutine(coro);
+    free_coroutine(coro);
+    js->needs_gc = true;
+  }
+
+  return promise;
+}
+
+static inline jsval_t sv_start_async_closure(
+  sv_vm_t *caller_vm, ant_t *js,
+  sv_closure_t *closure, jsval_t callee_func, jsval_t super_val,
+  jsval_t this_val, jsval_t *args, int argc
+) {
+  if (++coros_this_tick > CORO_PER_TICK_LIMIT) {
+    js->fatal_error = true;
+    return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK,
+      "Maximum async operations per tick exceeded");
+  }
+
+  jsval_t promise = js_mkpromise(js);
+  sv_async_ctx_t *ctx = (sv_async_ctx_t *)CORO_MALLOC(sizeof(sv_async_ctx_t));
+  if (!ctx) return js_mkerr(js, "out of memory for async context");
+
+  sv_vm_t *async_vm = sv_vm_create(js, SV_VM_ASYNC);
+  if (!async_vm) { CORO_FREE(ctx); return js_mkerr(js, "out of memory for async VM"); }
+
+  ctx->js = js;
+  ctx->closure = closure;
+  ctx->callee_func = callee_func;
+  ctx->super_val = super_val;
+  ctx->this_val = this_val;
+  ctx->args = NULL;
+  ctx->argc = argc;
+  ctx->coro = NULL;
+  ctx->vm = async_vm;
+
+  if (argc > 0 && args) {
+    ctx->args = (jsval_t *)CORO_MALLOC(sizeof(jsval_t) * (size_t)argc);
+    if (!ctx->args) {
+      sv_vm_destroy(async_vm); CORO_FREE(ctx);
+      return js_mkerr(js, "out of memory for async args");
+    }
+    memcpy(ctx->args, args, sizeof(jsval_t) * (size_t)argc);
+  }
+
+  size_t stack_size = 0;
+  const char *env_stack = getenv("ANT_CORO_STACK_SIZE");
+  if (env_stack) {
+    size_t sz = (size_t)atoi(env_stack) * 1024;
+    if (sz >= 32 * 1024 && sz <= 8 * 1024 * 1024) stack_size = sz;
+  }
+
+  mco_desc desc = mco_desc_init(sv_mco_async_entry, stack_size);
+  desc.user_data = ctx;
+
+  mco_coro *mco = NULL;
+  mco_result res = mco_create(&mco, &desc);
+  if (res != MCO_SUCCESS) {
+    if (ctx->args) CORO_FREE(ctx->args);
+    sv_vm_destroy(async_vm); CORO_FREE(ctx);
+    return js_mkerr(js, "failed to create async coroutine");
+  }
+
+  coroutine_t *coro = (coroutine_t *)CORO_MALLOC(sizeof(coroutine_t));
+  if (!coro) {
+    mco_destroy(mco);
+    if (ctx->args) CORO_FREE(ctx->args);
+    sv_vm_destroy(async_vm); CORO_FREE(ctx);
+    return js_mkerr(js, "out of memory for coroutine");
+  }
+
+  *coro = (coroutine_t){
+    .js = js,
+    .type = CORO_ASYNC_AWAIT,
+    .this_val = this_val,
+    .super_val = super_val,
+    .new_target = js->new_target,
+    .awaited_promise = js_mkundef(),
+    .result = js_mkundef(),
+    .async_func = callee_func,
+    .args = ctx->args,
+    .nargs = argc,
+    .is_settled = false,
+    .is_error = false,
+    .is_done = false,
+    .resume_point = 0,
+    .yield_value = js_mkundef(),
+    .async_promise = promise,
+    .next = NULL,
+    .mco = mco,
+    .mco_started = false,
+    .is_ready = true,
+    .sv_vm = async_vm,
+  };
+
+  ctx->coro = coro;
+  enqueue_coroutine(coro);
+  MCO_RESUME_SAVE(js, mco, res);
+
+  if (res != MCO_SUCCESS && mco_status(mco) != MCO_DEAD) {
+    remove_coroutine(coro);
+    free_coroutine(coro);
+    return js_mkerr(js, "failed to start async coroutine");
+  }
+
+  coro->mco_started = true;
+  if (mco_status(mco) == MCO_DEAD) {
+    remove_coroutine(coro);
+    free_coroutine(coro);
+    js->needs_gc = true;
+  }
+
+  return promise;
+}
+
+static inline jsval_t sv_await_value(ant_t *js, jsval_t value) {
+  if (vtype(value) != T_PROMISE) return value;
+
+  mco_coro *current_mco = mco_running();
+  if (!current_mco)
+    return js_mkerr(js, "await can only be used inside async functions");
+
+  coroutine_t *coro = NULL;
+  sv_coro_header_t *hdr = (sv_coro_header_t *)mco_get_user_data(current_mco);
+  if (hdr) coro = hdr->coro;
+
+  if (!coro)
+    return js_mkerr(js, "invalid async context");
+
+  coro->awaited_promise = value;
+  coro->is_settled = false;
+  coro->is_ready = false;
+
+  jsval_t resume_obj = mkobj(js, 0);
+  js_set_slot(js, resume_obj, SLOT_CORO, tov((double)(uintptr_t)coro));
+  js_set_slot(js, resume_obj, SLOT_CFUNC, js_mkfun(resume_coroutine_wrapper));
+
+  jsval_t reject_obj = mkobj(js, 0);
+  js_set_slot(js, reject_obj, SLOT_CORO, tov((double)(uintptr_t)coro));
+  js_set_slot(js, reject_obj, SLOT_CFUNC, js_mkfun(reject_coroutine_wrapper));
+
+  jsval_t then_fn = js_getprop_fallback(js, value, "then");
+  if (vtype(then_fn) == T_FUNC || vtype(then_fn) == T_CFUNC) {
+    jsval_t then_args[] = {
+      js_obj_to_func(resume_obj),
+      js_obj_to_func(reject_obj)
+    };
+    sv_vm_call(
+      js->vm, js, then_fn, value, 
+      then_args, 2, NULL, false
+    );
+  }
+
+  mco_result mco_res = mco_yield(current_mco);
+  if (mco_res != MCO_SUCCESS)
+    return js_mkerr(js, "failed to yield coroutine");
+
+  MCO_CORO_STACK_ENTER(js, current_mco);
+  jsval_t result = coro->result;
+  bool is_error = coro->is_error;
+  
+  coro->is_settled = false;
+  coro->awaited_promise = js_mkundef();
+  if (is_error) return js_throw(js, result);
+
+  return result;
+}
+
+static inline void sv_vm_gc_roots_async(void (*op_val)(void *, jsval_t *), void *ctx) {
+  for (coroutine_t *c = pending_coroutines.head; c; c = c->next) 
+    if (c->sv_vm) sv_vm_gc_roots(c->sv_vm, op_val, ctx);
+}
+
+#endif
diff --git a/src/silver/ops/bitwise.h b/src/silver/ops/bitwise.h
new file mode 100644
index 0000000..130f9d0
--- /dev/null
+++ b/src/silver/ops/bitwise.h
@@ -0,0 +1,120 @@
+#ifndef SV_BITWISE_H
+#define SV_BITWISE_H
+
+#include "errors.h"
+#include "silver/engine.h"
+
+static inline jsval_t sv_op_band(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_BIGINT || rt == T_BIGINT) {
+    if (lt != T_BIGINT || rt != T_BIGINT)
+      return js_mkerr(js, "Cannot mix BigInt value and other types");
+    return js_mkerr_typed(js, JS_ERR_TYPE, "BigInt does not support bitwise ops");
+  }
+  int32_t ai = (lt == T_NUM) ? js_to_int32(tod(l)) : js_to_int32(js_to_number(js, l));
+  int32_t bi = (rt == T_NUM) ? js_to_int32(tod(r)) : js_to_int32(js_to_number(js, r));
+  vm->stack[vm->sp++] = tov((double)(ai & bi));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_bor(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_BIGINT || rt == T_BIGINT) {
+    if (lt != T_BIGINT || rt != T_BIGINT)
+      return js_mkerr(js, "Cannot mix BigInt value and other types");
+    return js_mkerr_typed(js, JS_ERR_TYPE, "BigInt does not support bitwise ops");
+  }
+  int32_t ai = (lt == T_NUM) ? js_to_int32(tod(l)) : js_to_int32(js_to_number(js, l));
+  int32_t bi = (rt == T_NUM) ? js_to_int32(tod(r)) : js_to_int32(js_to_number(js, r));
+  vm->stack[vm->sp++] = tov((double)(ai | bi));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_bxor(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_BIGINT || rt == T_BIGINT) {
+    if (lt != T_BIGINT || rt != T_BIGINT)
+      return js_mkerr(js, "Cannot mix BigInt value and other types");
+    return js_mkerr_typed(js, JS_ERR_TYPE, "BigInt does not support bitwise ops");
+  }
+  int32_t ai = (lt == T_NUM) ? js_to_int32(tod(l)) : js_to_int32(js_to_number(js, l));
+  int32_t bi = (rt == T_NUM) ? js_to_int32(tod(r)) : js_to_int32(js_to_number(js, r));
+  vm->stack[vm->sp++] = tov((double)(ai ^ bi));
+  return tov(0);
+}
+
+static inline void sv_op_bnot(sv_vm_t *vm, ant_t *js) {
+  jsval_t a = vm->stack[--vm->sp];
+  vm->stack[vm->sp++] = tov((double)(~js_to_int32(js_to_number(js, a))));
+}
+
+static inline jsval_t sv_op_shl(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_BIGINT || rt == T_BIGINT) {
+    if (lt != T_BIGINT || rt != T_BIGINT)
+      return js_mkerr(js, "Cannot mix BigInt value and other types");
+    uint64_t shift = 0;
+    jsval_t err = bigint_asint_bits(js, r, &shift);
+    if (is_err(err)) return err;
+    jsval_t res = bigint_shift_left(js, l, shift);
+    if (is_err(res)) return res;
+    vm->stack[vm->sp++] = res;
+    return tov(0);
+  }
+  int32_t ai = (lt == T_NUM) ? js_to_int32(tod(l)) : js_to_int32(js_to_number(js, l));
+  uint32_t bi = (rt == T_NUM) ? js_to_uint32(tod(r)) : js_to_uint32(js_to_number(js, r));
+  vm->stack[vm->sp++] = tov((double)(ai << (bi & 0x1f)));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_shr(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_BIGINT || rt == T_BIGINT) {
+    if (lt != T_BIGINT || rt != T_BIGINT)
+      return js_mkerr(js, "Cannot mix BigInt value and other types");
+    uint64_t shift = 0;
+    jsval_t err = bigint_asint_bits(js, r, &shift);
+    if (is_err(err)) return err;
+    jsval_t res = bigint_shift_right(js, l, shift);
+    if (is_err(res)) return res;
+    vm->stack[vm->sp++] = res;
+    return tov(0);
+  }
+  int32_t ai = (lt == T_NUM) ? js_to_int32(tod(l)) : js_to_int32(js_to_number(js, l));
+  uint32_t bi = (rt == T_NUM) ? js_to_uint32(tod(r)) : js_to_uint32(js_to_number(js, r));
+  vm->stack[vm->sp++] = tov((double)(ai >> (bi & 0x1f)));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_ushr(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_BIGINT || rt == T_BIGINT) {
+    if (lt != T_BIGINT || rt != T_BIGINT)
+      return js_mkerr(js, "Cannot mix BigInt value and other types");
+    uint64_t shift = 0;
+    jsval_t err = bigint_asint_bits(js, r, &shift);
+    if (is_err(err)) return err;
+    jsval_t res = bigint_shift_right_logical(js, l, shift);
+    if (is_err(res)) return res;
+    vm->stack[vm->sp++] = res;
+    return tov(0);
+  }
+  uint32_t ai = (lt == T_NUM) ? js_to_uint32(tod(l)) : js_to_uint32(js_to_number(js, l));
+  uint32_t bi = (rt == T_NUM) ? js_to_uint32(tod(r)) : js_to_uint32(js_to_number(js, r));
+  vm->stack[vm->sp++] = tov((double)(ai >> (bi & 0x1f)));
+  return tov(0);
+}
+
+#endif
diff --git a/src/silver/ops/calls.h b/src/silver/ops/calls.h
new file mode 100644
index 0000000..eb7436b
--- /dev/null
+++ b/src/silver/ops/calls.h
@@ -0,0 +1,142 @@
+#ifndef SV_CALLS_H
+#define SV_CALLS_H
+
+#include <limits.h>
+#include "silver/engine.h"
+
+typedef struct {
+  jsval_t *args;
+  int      argc;
+  jsval_t *alloc;
+} sv_call_args_t;
+
+static inline void sv_call_args_reset(sv_call_args_t *a, jsval_t *args, int argc) {
+  a->args = args;
+  a->argc = argc;
+  a->alloc = NULL;
+}
+
+static inline void sv_call_args_release(sv_call_args_t *a) {
+  if (a->alloc) free(a->alloc);
+  a->alloc = NULL;
+}
+
+static inline jsval_t sv_apply_normalize_args(ant_t *js, sv_call_args_t *a) {
+  if (a->argc != 1) return js_mkundef();
+
+  jsval_t arg_array = a->args[0];
+  uint8_t t = vtype(arg_array);
+  if (t == T_UNDEF || t == T_NULL) {
+    a->args = NULL;
+    a->argc = 0;
+    return js_mkundef();
+  }
+  if (t != T_ARR) {
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "apply arguments must be an array or null/undefined");
+  }
+
+  jsoff_t len = js_arr_len(js, arg_array);
+  if (len <= 0) {
+    a->args = NULL;
+    a->argc = 0;
+    return js_mkundef();
+  }
+
+  if (len > INT_MAX)
+    return js_mkerr(js, "too many arguments");
+
+  a->alloc = malloc((size_t)len * sizeof(jsval_t));
+  if (!a->alloc) return js_mkerr(js, "out of memory");
+  for (jsoff_t i = 0; i < len; i++)
+    a->alloc[i] = js_arr_get(js, arg_array, i);
+  a->args = a->alloc;
+  a->argc = (int)len;
+  return js_mkundef();
+}
+
+static inline jsval_t sv_op_new(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  uint16_t argc = sv_get_u16(ip + 1);
+  jsval_t *args = &vm->stack[vm->sp - argc];
+  jsval_t new_target = vm->stack[vm->sp - argc - 1];
+  jsval_t func = vm->stack[vm->sp - argc - 2];
+  js->new_target = new_target;
+
+  if (vtype(func) == T_OBJ && is_proxy(js, func)) {
+    jsval_t result = js_proxy_construct(js, func, args, argc, new_target);
+    vm->sp -= argc + 2;
+    if (is_err(result)) return result;
+    vm->stack[vm->sp++] = result;
+    return result;
+  }
+
+  jsval_t obj = mkobj(js, 0);
+
+  if (vtype(func) == T_FUNC) {
+    jsval_t proto_source = func;
+    jsval_t func_obj = js_func_obj(func);
+    jsval_t target_func = js_get_slot(js, func_obj, SLOT_TARGET_FUNC);
+    if (vtype(target_func) == T_FUNC)
+      proto_source = target_func;
+    jsval_t proto = js_getprop_fallback(js, proto_source, "prototype");
+    if (is_object_type(proto)) js_set_proto(js, obj, proto);
+  }
+
+  jsval_t ctor_this = obj;
+  jsval_t result = sv_vm_call(vm, js, func, obj, args, argc, &ctor_this, true);
+  vm->sp -= argc + 2;
+  if (is_err(result)) return result;
+  vm->stack[vm->sp++] = 
+    is_object_type(result) ? result
+    : (is_object_type(ctor_this) ? ctor_this : obj);
+  return result;
+}
+
+static inline jsval_t sv_op_apply(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  uint16_t argc = sv_get_u16(ip + 1);
+  jsval_t *args = &vm->stack[vm->sp - argc];
+  jsval_t this = vm->stack[vm->sp - argc - 1];
+  jsval_t func = vm->stack[vm->sp - argc - 2];
+  sv_call_args_t call;
+  
+  sv_call_args_reset(&call, args, (int)argc);
+  jsval_t norm = sv_apply_normalize_args(js, &call);
+  if (is_err(norm)) return norm;
+
+  jsval_t result = sv_vm_call(vm, js, func, this, call.args, call.argc, NULL, false);
+  sv_call_args_release(&call);
+  vm->sp -= argc + 2;
+  if (!is_err(result)) vm->stack[vm->sp++] = result;
+  return result;
+}
+
+static inline jsval_t sv_op_eval(sv_vm_t *vm, ant_t *js, sv_frame_t *frame, uint8_t *ip) {
+  jsval_t code = vm->stack[--vm->sp];
+  if (vtype(code) != T_STR) {
+    vm->stack[vm->sp++] = code;
+    return code;
+  }
+  jsoff_t len;
+  jsoff_t off = vstr(js, code, &len);
+  const char *str = (const char *)&js->mem[off];
+  jsval_t result = js_eval_bytecode_eval_with_strict(
+    js, str, len, sv_frame_is_strict(frame));
+  if (!is_err(result)) vm->stack[vm->sp++] = result;
+  return result;
+}
+
+static inline jsval_t sv_op_check_ctor(sv_vm_t *vm, ant_t *js) {
+  if (vtype(sv_vm_get_new_target(vm, js)) == T_UNDEF)
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "Class constructor cannot be invoked without 'new'");
+  return tov(0);
+}
+
+static inline void sv_op_check_ctor_ret(sv_vm_t *vm, sv_frame_t *frame) {
+  jsval_t val = vm->stack[vm->sp - 1];
+  if (is_object_type(val)) {
+    vm->stack[vm->sp++] = val;
+  } else vm->stack[vm->sp++] = frame->this;
+}
+
+#endif
diff --git a/src/silver/ops/coercion.h b/src/silver/ops/coercion.h
new file mode 100644
index 0000000..604c830
--- /dev/null
+++ b/src/silver/ops/coercion.h
@@ -0,0 +1,294 @@
+#ifndef SV_COERCION_H
+#define SV_COERCION_H
+
+#include "silver/engine.h"
+#include "modules/symbol.h"
+
+#include "esm/loader.h"
+#include <string.h>
+
+#include "globals.h"
+#include "property.h"
+
+static inline jsval_t sv_module_export_cstr(
+  ant_t *js,
+  const char *name, size_t len,
+  jsval_t value
+) {
+  if (vtype(js->module_ns) != T_OBJ)
+    return js_mkerr_typed(js, JS_ERR_SYNTAX, "export used outside module");
+
+  jsval_t set_res = setprop_cstr(js, js->module_ns, name, len, value);
+  if (is_err(set_res)) return set_res;
+
+  if (len == 7 && memcmp(name, "default", 7) == 0)
+    js_set_slot(js, js->module_ns, SLOT_DEFAULT, value);
+
+  return tov(0);
+}
+
+static inline jsval_t sv_op_to_object(sv_vm_t *vm, ant_t *js) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  uint8_t t = vtype(v);
+  if (t == T_OBJ || t == T_ARR || t == T_FUNC) return tov(0);
+  if (t == T_NULL || t == T_UNDEF)
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "Cannot convert undefined or null to object");
+  jsval_t obj = mkobj(js, 0);
+  jsval_t obj_as_obj = js_as_obj(obj);
+  js_set_slot(js, obj_as_obj, SLOT_PRIMITIVE, v);
+  vm->stack[vm->sp - 1] = obj;
+  return tov(0);
+}
+
+static inline void sv_op_to_propkey(sv_vm_t *vm, ant_t *js) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  if (vtype(v) != T_STR && vtype(v) != T_SYMBOL)
+    vm->stack[vm->sp - 1] = coerce_to_str(js, v);
+}
+
+static inline void sv_op_is_undef(sv_vm_t *vm) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 1] = mkval(T_BOOL, vtype(v) == T_UNDEF);
+}
+
+static inline void sv_op_is_null(sv_vm_t *vm) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 1] = mkval(T_BOOL, vtype(v) == T_NULL);
+}
+
+static inline jsval_t sv_op_import(sv_vm_t *vm, ant_t *js) {
+  jsval_t specifier = vm->stack[--vm->sp];
+  jsval_t import_fn = js_getprop_fallback(js, js->global, "import");
+  if (vtype(import_fn) == T_FUNC || vtype(import_fn) == T_CFUNC) {
+    jsval_t result = sv_vm_call(vm, js, import_fn, js->global, &specifier, 1, NULL, false);
+    if (!is_err(result)) vm->stack[vm->sp++] = result;
+    return result;
+  }
+  vm->stack[vm->sp++] = mkval(T_UNDEF, 0);
+  return tov(0);
+}
+
+static inline jsval_t sv_op_import_sync(sv_vm_t *vm, ant_t *js) {
+  jsval_t specifier = vm->stack[--vm->sp];
+  jsval_t result = js_esm_import_sync(js, specifier);
+  if (!is_err(result)) vm->stack[vm->sp++] = result;
+  return result;
+}
+
+static inline void sv_op_import_default(sv_vm_t *vm, ant_t *js) {
+  jsval_t ns = vm->stack[vm->sp - 1];
+  if (vtype(ns) == T_OBJ) {
+    jsval_t slot_val = js_get_slot(js, ns, SLOT_DEFAULT);
+    if (vtype(slot_val) != T_UNDEF) { vm->stack[vm->sp - 1] = slot_val; return;  }
+  }
+}
+
+static inline jsval_t sv_op_export(sv_vm_t *vm, ant_t *js, sv_func_t *func, uint8_t *ip) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  if (atom_idx >= (uint32_t)func->atom_count)
+    return js_mkerr(js, "invalid export atom index");
+
+  jsval_t value = vm->stack[--vm->sp];
+  sv_atom_t *a = &func->atoms[atom_idx];
+  return sv_module_export_cstr(js, a->str, a->len, value);
+}
+
+static inline jsval_t sv_op_export_all(sv_vm_t *vm, ant_t *js) {
+  jsval_t ns = vm->stack[--vm->sp];
+  if (vtype(ns) != T_OBJ)
+    return js_mkerr_typed(js, JS_ERR_SYNTAX, "Cannot re-export from non-object module");
+
+  ant_iter_t iter = js_prop_iter_begin(js, ns);
+  const char *key = NULL;
+  size_t key_len = 0;
+  jsval_t value = js_mkundef();
+
+  while (js_prop_iter_next(&iter, &key, &key_len, &value)) {
+    jsval_t export_res = sv_module_export_cstr(js, key, key_len, value);
+    if (is_err(export_res)) { js_prop_iter_end(&iter); return export_res; }
+  }
+  
+  js_prop_iter_end(&iter);
+  return tov(0);
+}
+
+static inline jsval_t sv_op_enter_with(sv_vm_t *vm, ant_t *js, sv_frame_t *frame) {
+  if (sv_frame_is_strict(frame))
+    return js_mkerr_typed(js, JS_ERR_SYNTAX, "with statement not allowed in strict mode");
+  frame->with_obj = vm->stack[--vm->sp];
+  return js_mkundef();
+}
+
+static inline void sv_op_exit_with(sv_vm_t *vm, sv_frame_t *frame) {
+  frame->with_obj = js_mkundef();
+}
+
+enum { 
+  WITH_FB_GLOBAL = 0,
+  WITH_FB_LOCAL  = 1,
+  WITH_FB_ARG    = 2,
+  WITH_FB_UPVAL  = 3 
+};
+
+static inline jsval_t sv_with_fallback_get(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame,
+  uint8_t kind, uint16_t idx
+) {
+switch (kind) {
+  case WITH_FB_LOCAL: return frame->lp ? frame->lp[idx] : js_mkundef();
+  case WITH_FB_ARG:   return sv_frame_get_arg_value(frame, idx);
+  case WITH_FB_UPVAL: {
+    if (!frame->upvalues || (int)idx >= frame->upvalue_count) return js_mkundef();
+    sv_upvalue_t *uv = frame->upvalues[idx];
+    return uv ? *uv->location : js_mkundef();
+  }
+  default: return sv_global_get(js, NULL, 0);
+}}
+
+static inline void sv_with_fallback_put(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame,
+  uint8_t kind, uint16_t idx,
+  jsval_t val
+) {
+  switch (kind) {
+    case WITH_FB_LOCAL:
+      if (frame->lp) frame->lp[idx] = val;
+      break;
+    case WITH_FB_ARG:
+      sv_frame_set_arg_value(frame, idx, val);
+      break;
+    case WITH_FB_UPVAL:
+      if (frame->upvalues && (int)idx < frame->upvalue_count) {
+        sv_upvalue_t *uv = frame->upvalues[idx];
+        if (uv) *uv->location = val;
+      }
+      break;
+    default: break;
+  }
+}
+
+static inline jsval_t sv_op_with_get_var(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  uint8_t  fb_kind  = sv_get_u8(ip + 5);
+  uint16_t fb_idx   = sv_get_u16(ip + 6);
+  sv_atom_t *a = &func->atoms[atom_idx];
+
+  if (vtype(frame->with_obj) != T_UNDEF) {
+    if (lkp(js, frame->with_obj, a->str, a->len) != 0) {
+      jsval_t val = sv_getprop_fallback_len(
+        js, frame->with_obj, a->str, (jsoff_t)a->len);
+      if (is_err(val)) return val;
+      vm->stack[vm->sp++] = val;
+      return js_mkundef();
+    }
+  }
+
+  if (fb_kind == WITH_FB_GLOBAL) {
+    jsval_t val = sv_global_get(js, a->str, a->len);
+    if (is_undefined(val))
+      return js_mkerr_typed(
+        js, JS_ERR_REFERENCE, "'%.*s' is not defined",
+        (int)a->len, a->str);
+    vm->stack[vm->sp++] = val;
+  } else vm->stack[vm->sp++] = sv_with_fallback_get(vm, js, frame, fb_kind, fb_idx);
+  return js_mkundef();
+}
+
+static inline void sv_op_with_put_var(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  uint8_t  fb_kind  = sv_get_u8(ip + 5);
+  uint16_t fb_idx   = sv_get_u16(ip + 6);
+  
+  sv_atom_t *a = &func->atoms[atom_idx];
+  jsval_t val = vm->stack[--vm->sp];
+
+  if (vtype(frame->with_obj) != T_UNDEF) {
+    if (lkp(js, frame->with_obj, a->str, a->len) != 0) {
+      jsval_t key = js_mkstr(js, a->str, a->len);
+      js_setprop(js, frame->with_obj, key, val);
+      return;
+    }
+  }
+
+  if (fb_kind == WITH_FB_GLOBAL) {
+    setprop_interned(js, js->global, a->str, a->len, val);
+  } else sv_with_fallback_put(vm, js, frame, fb_kind, fb_idx, val);
+}
+
+static inline void sv_op_with_del_var(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[atom_idx];
+  
+  if (vtype(frame->with_obj) != T_UNDEF) {
+    if (lkp(js, frame->with_obj, a->str, a->len) != 0) {
+      jsval_t result = js_delete_prop(js, frame->with_obj, a->str, a->len);
+      vm->stack[vm->sp++] = result;
+      return;
+    }
+  }
+  
+  char tmp[256];
+  bool ok = js_del(js, js->global, sv_atom_cstr(a, tmp, sizeof(tmp)));
+  vm->stack[vm->sp++] = mkval(T_BOOL, ok);
+}
+
+static inline void sv_op_special_obj(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame, uint8_t *ip
+) {
+  uint8_t which = sv_get_u8(ip + 1);
+  if (which == 1) {
+    vm->stack[vm->sp++] = frame ? frame->new_target : js_mkundef();
+    return;
+  }
+  if (which == 2) {
+    vm->stack[vm->sp++] = frame ? frame->super_val : js_mkundef();
+    return;
+  }
+  if (which != 0 || !frame) {
+    vm->stack[vm->sp++] = js_mkundef();
+    return;
+  }
+
+  jsval_t arr = js_mkarr(js);
+  jshdl_t h = js_root(js, arr);
+  
+  if (frame->bp && frame->argc > 0) {
+    for (int i = 0; i < frame->argc; i++)
+      js_arr_push(js, js_deref(js, h), frame->bp[i]);
+  }
+
+  if (sv_frame_is_strict(frame))
+    js_set_slot(js, js_deref(js, h), SLOT_STRICT_ARGS, tov(1));
+  else if (vtype(frame->callee) == T_FUNC)
+    setprop_cstr(js, js_deref(js, h), "callee", 6, frame->callee);
+
+  js_set_sym(js, js_deref(js, h), get_toStringTag_sym(), js_mkstr(js, "Arguments", 9));
+  jsval_t array_proto = js_get_ctor_proto(js, "Array", 5);
+  
+  if (is_object_type(array_proto)) {
+    jsval_t iter_fn = js_get_sym(js, array_proto, get_iterator_sym());
+    if (vtype(iter_fn) == T_FUNC || vtype(iter_fn) == T_CFUNC)
+      js_set_sym(js, js_deref(js, h), get_iterator_sym(), iter_fn);
+  }
+
+  vm->stack[vm->sp++] = js_deref(js, h);
+  js_unroot(js, h);
+}
+
+#endif
diff --git a/src/silver/ops/comparison.h b/src/silver/ops/comparison.h
new file mode 100644
index 0000000..a145336
--- /dev/null
+++ b/src/silver/ops/comparison.h
@@ -0,0 +1,216 @@
+#ifndef SV_COMPARISON_H
+#define SV_COMPARISON_H
+
+#include "silver/engine.h"
+
+static inline void sv_op_seq(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  vm->stack[vm->sp++] = mkval(T_BOOL, strict_eq_values(js, l, r));
+}
+
+static inline void sv_op_sne(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  vm->stack[vm->sp++] = mkval(T_BOOL, !strict_eq_values(js, l, r));
+}
+
+static inline jsval_t sv_abstract_eq(ant_t *js, jsval_t l, jsval_t r) {
+  uint8_t lt = vtype(l), rt = vtype(r);
+
+  if ((lt == T_NULL && rt == T_NULL) || (lt == T_UNDEF && rt == T_UNDEF) ||
+      (lt == T_UNDEF && rt == T_NULL) || (lt == T_NULL && rt == T_UNDEF))
+    return mkval(T_BOOL, 1);
+
+  if (lt == T_NULL || rt == T_NULL || lt == T_UNDEF || rt == T_UNDEF)
+    return mkval(T_BOOL, 0);
+
+  if (lt == rt)
+    return mkval(T_BOOL, strict_eq_values(js, l, r));
+
+  if ((lt == T_BIGINT && rt == T_NUM) || (lt == T_NUM && rt == T_BIGINT)) {
+    double num_val = lt == T_NUM ? tod(l) : tod(r);
+    jsval_t bigint_val = lt == T_BIGINT ? l : r;
+    if (isfinite(num_val) && num_val == trunc(num_val)) {
+      bool neg = num_val < 0;
+      if (neg) num_val = -num_val;
+      char buf[64];
+      snprintf(buf, sizeof(buf), "%.0f", num_val);
+      return mkval(
+        T_BOOL, bigint_compare(js, bigint_val,
+        js_mkbigint(js, buf, strlen(buf), neg)) == 0);
+    }
+    return mkval(T_BOOL, 0);
+  }
+
+  if (lt == T_BOOL) return sv_abstract_eq(js, tov(vdata(l) ? 1.0 : 0.0), r);
+  if (rt == T_BOOL) return sv_abstract_eq(js, l, tov(vdata(r) ? 1.0 : 0.0));
+
+  if ((lt == T_NUM && rt == T_STR) || (lt == T_STR && rt == T_NUM))
+    return mkval(T_BOOL, js_to_number(js, l) == js_to_number(js, r));
+
+  if (is_object_type(l)) {
+    jsval_t lp = js_to_primitive(js, l, 0);
+    if (!is_err(lp)) return sv_abstract_eq(js, lp, r);
+  }
+  if (is_object_type(r)) {
+    jsval_t rp = js_to_primitive(js, r, 0);
+    if (!is_err(rp)) return sv_abstract_eq(js, l, rp);
+  }
+  return mkval(T_BOOL, 0);
+}
+
+static inline void sv_op_eq(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  vm->stack[vm->sp++] = sv_abstract_eq(js, l, r);
+}
+
+static inline void sv_op_ne(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  jsval_t eq = sv_abstract_eq(js, l, r);
+  vm->stack[vm->sp++] = mkval(T_BOOL, !vdata(eq));
+}
+
+static inline int sv_strcmp(ant_t *js, jsval_t l, jsval_t r) {
+  jsoff_t n1, off1 = vstr(js, l, &n1);
+  jsoff_t n2, off2 = vstr(js, r, &n2);
+  jsoff_t min_len = n1 < n2 ? n1 : n2;
+  int cmp = memcmp(&js->mem[off1], &js->mem[off2], min_len);
+  if (cmp == 0) return (n1 < n2) ? -1 : (n1 > n2) ? 1 : 0;
+  return cmp < 0 ? -1 : 1;
+}
+
+static inline void sv_coerce_relational(ant_t *js, jsval_t *l, jsval_t *r) {
+  if (is_object_type(*l)) {
+    jsval_t prim = js_to_primitive(js, *l, 2);
+    if (!is_err(prim)) *l = prim;
+  }
+  if (is_object_type(*r)) {
+    jsval_t prim = js_to_primitive(js, *r, 2);
+    if (!is_err(prim)) *r = prim;
+  }
+}
+
+static inline jsval_t sv_op_lt(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  sv_coerce_relational(js, &l, &r);
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_NUM && rt == T_NUM) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) < tod(r));
+    return tov(0);
+  }
+  if (lt == T_BIGINT && rt == T_BIGINT) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) < 0);
+    return tov(0);
+  }
+  if (lt == T_BIGINT || rt == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  if (lt == T_STR && rt == T_STR) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) < 0);
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) < js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_le(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  sv_coerce_relational(js, &l, &r);
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_NUM && rt == T_NUM) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) <= tod(r));
+    return tov(0);
+  }
+  if (lt == T_BIGINT && rt == T_BIGINT) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) <= 0);
+    return tov(0);
+  }
+  if (lt == T_BIGINT || rt == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  if (lt == T_STR && rt == T_STR) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) <= 0);
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) <= js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_gt(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  sv_coerce_relational(js, &l, &r);
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_NUM && rt == T_NUM) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) > tod(r));
+    return tov(0);
+  }
+  if (lt == T_BIGINT && rt == T_BIGINT) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) > 0);
+    return tov(0);
+  }
+  if (lt == T_BIGINT || rt == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  if (lt == T_STR && rt == T_STR) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) > 0);
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) > js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_ge(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  sv_coerce_relational(js, &l, &r);
+  uint8_t lt = vtype(l), rt = vtype(r);
+  if (lt == T_NUM && rt == T_NUM) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, tod(l) >= tod(r));
+    return tov(0);
+  }
+  if (lt == T_BIGINT && rt == T_BIGINT) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, bigint_compare(js, l, r) >= 0);
+    return tov(0);
+  }
+  if (lt == T_BIGINT || rt == T_BIGINT)
+    return js_mkerr(js, "Cannot mix BigInt value and other types");
+  if (lt == T_STR && rt == T_STR) {
+    vm->stack[vm->sp++] = mkval(T_BOOL, sv_strcmp(js, l, r) >= 0);
+    return tov(0);
+  }
+  vm->stack[vm->sp++] = mkval(T_BOOL, js_to_number(js, l) >= js_to_number(js, r));
+  return tov(0);
+}
+
+static inline jsval_t sv_op_instanceof(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  jsval_t res = do_instanceof(js, l, r);
+  if (!is_err(res)) vm->stack[vm->sp++] = res;
+  return res;
+}
+
+static inline jsval_t sv_op_in(sv_vm_t *vm, ant_t *js) {
+  jsval_t r = vm->stack[--vm->sp];
+  jsval_t l = vm->stack[--vm->sp];
+  jsval_t res = do_in(js, l, r);
+  if (!is_err(res)) vm->stack[vm->sp++] = res;
+  return res;
+}
+
+static inline void sv_op_is_nullish(sv_vm_t *vm) {
+  jsval_t v = vm->stack[--vm->sp];
+  uint8_t t = vtype(v);
+  vm->stack[vm->sp++] = mkval(T_BOOL, t == T_NULL || t == T_UNDEF);
+}
+
+static inline void sv_op_is_undef_or_null(sv_vm_t *vm) {
+  jsval_t v = vm->stack[--vm->sp];
+  uint8_t t = vtype(v);
+  vm->stack[vm->sp++] = mkval(T_BOOL, t == T_NULL || t == T_UNDEF);
+}
+
+#endif
diff --git a/src/silver/ops/control.h b/src/silver/ops/control.h
new file mode 100644
index 0000000..2b2a673
--- /dev/null
+++ b/src/silver/ops/control.h
@@ -0,0 +1,80 @@
+#ifndef SV_CONTROL_H
+#define SV_CONTROL_H
+
+#include "silver/engine.h"
+
+static inline uint8_t *sv_op_jmp(uint8_t *ip) {
+  int32_t off = sv_get_i32(ip + 1);
+  return ip + sv_op_size[OP_JMP] + off;
+}
+
+static inline uint8_t *sv_op_jmp_false(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t v = vm->stack[--vm->sp];
+  if (!js_truthy(js, v)) {
+    int32_t off = sv_get_i32(ip + 1);
+    return ip + sv_op_size[OP_JMP_FALSE] + off;
+  }
+  return ip + sv_op_size[OP_JMP_FALSE];
+}
+
+static inline uint8_t *sv_op_jmp_true(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t v = vm->stack[--vm->sp];
+  if (js_truthy(js, v)) {
+    int32_t off = sv_get_i32(ip + 1);
+    return ip + sv_op_size[OP_JMP_TRUE] + off;
+  }
+  return ip + sv_op_size[OP_JMP_TRUE];
+}
+
+static inline uint8_t *sv_op_jmp_false_peek(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  if (!js_truthy(js, v)) {
+    int32_t off = sv_get_i32(ip + 1);
+    return ip + sv_op_size[OP_JMP_FALSE_PEEK] + off;
+  }
+  return ip + sv_op_size[OP_JMP_FALSE_PEEK];
+}
+
+static inline uint8_t *sv_op_jmp_true_peek(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  if (js_truthy(js, v)) {
+    int32_t off = sv_get_i32(ip + 1);
+    return ip + sv_op_size[OP_JMP_TRUE_PEEK] + off;
+  }
+  return ip + sv_op_size[OP_JMP_TRUE_PEEK];
+}
+
+static inline uint8_t *sv_op_jmp_not_nullish(sv_vm_t *vm, uint8_t *ip) {
+  jsval_t v = vm->stack[vm->sp - 1];
+  uint8_t t = vtype(v);
+  if (t != T_NULL && t != T_UNDEF) {
+    int32_t off = sv_get_i32(ip + 1);
+    return ip + sv_op_size[OP_JMP_NOT_NULLISH] + off;
+  }
+  return ip + sv_op_size[OP_JMP_NOT_NULLISH];
+}
+
+static inline uint8_t *sv_op_jmp8(uint8_t *ip) {
+  int8_t off = sv_get_i8(ip + 1);
+  return ip + sv_op_size[OP_JMP8] + off;
+}
+
+static inline uint8_t *sv_op_jmp_false8(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t v = vm->stack[--vm->sp];
+  if (!js_truthy(js, v)) {
+    int8_t off = sv_get_i8(ip + 1);
+    return ip + sv_op_size[OP_JMP_FALSE8] + off;
+  }
+  return ip + sv_op_size[OP_JMP_FALSE8];
+}
+
+static inline uint8_t *sv_op_jmp_true8(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t v = vm->stack[--vm->sp];
+  if (js_truthy(js, v)) {
+    int8_t off = sv_get_i8(ip + 1);
+    return ip + sv_op_size[OP_JMP_TRUE8] + off;
+  }
+  return ip + sv_op_size[OP_JMP_TRUE8];
+}
+
+#endif
diff --git a/src/silver/ops/exceptions.h b/src/silver/ops/exceptions.h
new file mode 100644
index 0000000..cae2936
--- /dev/null
+++ b/src/silver/ops/exceptions.h
@@ -0,0 +1,197 @@
+#ifndef SV_EXCEPTIONS_H
+#define SV_EXCEPTIONS_H
+
+#include "silver/engine.h"
+#include "errors.h"
+
+typedef enum {
+  SV_FINALLY_RET_JUMP = 0,
+  SV_FINALLY_RET_THROW = 1,
+  SV_FINALLY_RET_RETURN = 2,
+  SV_FINALLY_RET_ERROR = 3,
+} sv_finally_ret_t;
+
+static inline bool sv_is_catch_only_handler(uint8_t *ip) {
+  return ip && *ip == OP_CATCH;
+}
+
+static inline void sv_clear_completion(sv_vm_t *vm) {
+  if (vm->fp < 0) return;
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  frame->completion.kind = SV_COMPLETION_NONE;
+  frame->completion.value = js_mkundef();
+}
+
+static inline void sv_close_upvalues_from_slot(sv_vm_t *vm, jsval_t *slot) {
+  sv_upvalue_t **pp = &vm->open_upvalues;
+  while (*pp) {
+  sv_upvalue_t *uv = *pp;
+  if (uv->location >= slot) {
+    uv->closed = *uv->location;
+    uv->location = &uv->closed;
+    *pp = uv->next;
+  } else pp = &uv->next;}
+}
+
+static inline jsval_t sv_op_throw(sv_vm_t *vm) {
+  return vm->stack[--vm->sp];
+}
+
+static inline jsval_t sv_op_throw_error(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  uint8_t err_type = sv_get_u8(ip + 5);
+  sv_atom_t *a = &func->atoms[atom_idx];
+  return js_mkerr_typed(js, (js_err_type_t)err_type, "%.*s", (int)a->len, a->str);
+}
+
+static inline void sv_op_try_push(sv_vm_t *vm, uint8_t *ip) {
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  if (vm->handler_depth < SV_HANDLER_MAX) {
+    int32_t off = sv_get_i32(ip + 1);
+    sv_handler_t *h = &vm->handler_stack[vm->handler_depth++];
+    h->kind = SV_HANDLER_TRY;
+    h->ip = ip + sv_op_size[OP_TRY_PUSH] + off;
+    h->saved_sp = vm->sp;
+    frame->handler_top = vm->handler_depth;
+  }
+}
+
+static inline void sv_op_try_pop(sv_vm_t *vm) {
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  for (int i = vm->handler_depth - 1; i >= frame->handler_base; i--) {
+    if (vm->handler_stack[i].kind != SV_HANDLER_TRY) continue;
+    if (i + 1 < vm->handler_depth) {
+      memmove(
+        &vm->handler_stack[i],
+        &vm->handler_stack[i + 1],
+        (size_t)(vm->handler_depth - i - 1) * sizeof(vm->handler_stack[0]));
+    }
+    vm->handler_depth--;
+    frame->handler_top = vm->handler_depth;
+    return;
+  }
+}
+
+static inline void sv_op_catch(sv_vm_t *vm, jsval_t caught, uint8_t *ip) {
+  if (vm->sp == 0) vm->stack[vm->sp++] = caught;
+  sv_clear_completion(vm);
+}
+
+static inline jsval_t sv_op_finally(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  if (vm->handler_depth >= SV_HANDLER_MAX)
+    return js_mkerr(js, "handler stack overflow");
+
+  int32_t off = sv_get_i32(ip + 1);
+  sv_handler_t *h = &vm->handler_stack[vm->handler_depth++];
+  h->kind = SV_HANDLER_FINALLY;
+  h->ip = ip + sv_op_size[OP_FINALLY] + off;
+  h->saved_sp = 0;
+  frame->handler_top = vm->handler_depth;
+  
+  return js_mkundef();
+}
+
+static inline sv_finally_ret_t sv_op_finally_ret(
+  sv_vm_t *vm, ant_t *js,
+  uint8_t **resume_ip,
+  jsval_t *completion_val
+) {
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  if (vm->handler_depth <= frame->handler_base ||
+      vm->handler_stack[vm->handler_depth - 1].kind != SV_HANDLER_FINALLY) {
+    *completion_val = js_mkerr(js, "finally handler underflow");
+    return SV_FINALLY_RET_ERROR;
+  }
+
+  sv_handler_t h = vm->handler_stack[--vm->handler_depth];
+  frame->handler_top = vm->handler_depth;
+
+  if (frame->completion.kind == SV_COMPLETION_THROW) {
+    *completion_val = frame->completion.value;
+    sv_clear_completion(vm);
+    return SV_FINALLY_RET_THROW;
+  }
+
+  if (frame->completion.kind == SV_COMPLETION_RETURN) {
+    *completion_val = frame->completion.value;
+    sv_clear_completion(vm);
+    return SV_FINALLY_RET_RETURN;
+  }
+
+  *resume_ip = h.ip;
+  return SV_FINALLY_RET_JUMP;
+}
+
+static inline void sv_op_nip_catch(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 2] = a;
+  vm->sp--;
+}
+
+static inline uint8_t *sv_vm_throw(sv_vm_t *vm, jsval_t err, int min_fp) {
+  ant_t *js = vm->js;
+  if (min_fp < 0) min_fp = 0;
+
+  for (int f = vm->fp; f >= min_fp; f--) {
+    sv_frame_t *frame = &vm->frames[f];
+    int base = frame->handler_base;
+    int top = (f == vm->fp) ? vm->handler_depth : frame->handler_top;
+    for (int i = top - 1; i >= base; i--) {
+      sv_handler_t *h = &vm->handler_stack[i];
+      if (h->kind != SV_HANDLER_TRY) continue;
+
+      for (int drop = vm->fp; drop > f; drop--) {
+        jsval_t *bp = vm->frames[drop].bp;
+        if (bp) sv_close_upvalues_from_slot(vm, bp);
+      }
+
+      jsval_t caught = err;
+      if (vtype(err) == T_ERR && js->thrown_exists &&
+          vtype(js->thrown_value) != T_UNDEF) {
+        caught = js->thrown_value;
+        js->thrown_value = js_mkundef();
+        js->thrown_exists = false;
+      }
+
+      vm->sp = h->saved_sp;
+      vm->fp = f;
+      vm->frames[f].completion.kind = SV_COMPLETION_THROW;
+      vm->frames[f].completion.value = caught;
+      vm->stack[vm->sp++] = caught;
+      vm->handler_depth = i;
+      vm->frames[f].handler_top = i;
+      return h->ip;
+    }
+
+    frame->handler_top = base;
+    if (f == vm->fp) vm->handler_depth = base;
+  }
+  
+  sv_clear_completion(vm);
+  return NULL;
+}
+
+static inline uint8_t *sv_vm_unwind_for_return(sv_vm_t *vm, jsval_t ret) {
+  sv_frame_t *frame = &vm->frames[vm->fp];
+  for (int i = vm->handler_depth - 1; i >= frame->handler_base; i--) {
+    sv_handler_t *h = &vm->handler_stack[i];
+    if (h->kind != SV_HANDLER_TRY) continue;
+    if (sv_is_catch_only_handler(h->ip)) continue;
+
+    vm->handler_depth = i;
+    frame->handler_top = i;
+    vm->sp = h->saved_sp;
+    frame->completion.kind = SV_COMPLETION_RETURN;
+    frame->completion.value = ret;
+    vm->stack[vm->sp++] = ret;
+    return h->ip;
+  }
+  
+  return NULL;
+}
+
+#endif
diff --git a/src/silver/ops/globals.h b/src/silver/ops/globals.h
new file mode 100644
index 0000000..d22572d
--- /dev/null
+++ b/src/silver/ops/globals.h
@@ -0,0 +1,55 @@
+#ifndef SV_GLOBALS_H
+#define SV_GLOBALS_H
+
+#include "silver/engine.h"
+#include "errors.h"
+
+static inline jsval_t sv_global_get(ant_t *js, const char *str, uint32_t len) {
+  jsoff_t off = lkp(js, js->global, str, len);
+  if (off == 0) return js_mkundef();
+  return resolveprop(js, mkval(T_PROP, off));
+}
+
+static inline jsval_t sv_op_get_global(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  sv_atom_t *a = &func->atoms[sv_get_u32(ip + 1)];
+  jsval_t super_val = sv_vm_get_super_val(vm);
+  if (a->len == 5 && memcmp(a->str, "super", 5) == 0 &&
+      vtype(super_val) != T_UNDEF) {
+    jsval_t sv = super_val;
+    vm->stack[vm->sp++] = sv;
+    return sv;
+  }
+  jsval_t val = sv_global_get(js, a->str, a->len);
+  if (is_undefined(val))
+    return js_mkerr_typed(
+      js, JS_ERR_REFERENCE, "'%.*s' is not defined",
+      (int)a->len, a->str);
+  vm->stack[vm->sp++] = val;
+  return val;
+}
+
+static inline void sv_op_get_global_undef(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  sv_atom_t *a = &func->atoms[sv_get_u32(ip + 1)];
+  vm->stack[vm->sp++] = sv_global_get(js, a->str, a->len);
+}
+
+static inline jsval_t sv_op_put_global(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame, sv_func_t *func, uint8_t *ip
+) {
+  sv_atom_t *a = &func->atoms[sv_get_u32(ip + 1)];
+  if (sv_frame_is_strict(frame) && lkp(js, js->global, a->str, a->len) == 0)
+    return js_mkerr_typed(
+      js, JS_ERR_REFERENCE, "'%.*s' is not defined",
+      (int)a->len, a->str);
+  jsval_t key = js_mkstr(js, a->str, a->len);
+  return js_setprop(js, js->global, key, vm->stack[--vm->sp]);
+}
+
+#endif
diff --git a/src/silver/ops/iteration.h b/src/silver/ops/iteration.h
new file mode 100644
index 0000000..af00dbd
--- /dev/null
+++ b/src/silver/ops/iteration.h
@@ -0,0 +1,305 @@
+#ifndef SV_ITERATION_H
+#define SV_ITERATION_H
+
+#include "ant.h"
+#include "async.h"
+#include "utf8.h"
+#include "silver/engine.h"
+#include "modules/symbol.h"
+#include "modules/collections.h"
+
+#define SV_ITER_GENERIC  0
+#define SV_ITER_ARRAY    1
+#define SV_ITER_MAP      2
+#define SV_ITER_SET      3
+#define SV_ITER_STRING   4
+
+static inline jsval_t sv_op_for_in(sv_vm_t *vm, ant_t *js) {
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t keys = js_for_in_keys(js, obj);
+  if (is_err(keys)) return keys;
+  vm->stack[vm->sp++] = keys;
+  return tov(0);
+}
+
+static inline bool sv_is_map_iter(
+  ant_t *js, jsval_t obj,
+  map_iterator_state_t **out_state,
+  iter_type_t *out_type
+) {
+  if (vtype(obj) != T_OBJ) return false;
+  jsval_t state_val = js_get_slot(js, obj, SLOT_ITER_STATE);
+  if (vtype(state_val) == T_UNDEF) return false;
+  
+  map_iterator_state_t *st = (map_iterator_state_t *)(uintptr_t)js_getnum(state_val);
+  if (!st) return false;
+  if (st->type > ITER_TYPE_MAP_ENTRIES) return false;
+  
+  *out_state = st;
+  *out_type = st->type;
+  
+  return true;
+}
+
+static inline bool sv_is_set_iter(
+  ant_t *js, jsval_t obj,
+  set_iterator_state_t **out_state,
+  iter_type_t *out_type
+) {
+  if (vtype(obj) != T_OBJ) return false;
+  jsval_t state_val = js_get_slot(js, obj, SLOT_ITER_STATE);
+  if (vtype(state_val) == T_UNDEF) return false;
+  
+  set_iterator_state_t *st = (set_iterator_state_t *)(uintptr_t)js_getnum(state_val);
+  if (!st) return false;
+  
+  if (st->type != ITER_TYPE_SET_VALUES && st->type != ITER_TYPE_SET_ENTRIES)
+    return false;
+    
+  *out_state = st;
+  *out_type = st->type;
+  
+  return true;
+}
+
+static inline jsval_t sv_op_for_of(sv_vm_t *vm, ant_t *js) {
+  jsval_t iterable = vm->stack[--vm->sp];
+
+  if (vtype(iterable) == T_ARR) {
+    vm->stack[vm->sp++] = iterable;
+    vm->stack[vm->sp++] = tov(0);
+    vm->stack[vm->sp++] = tov(SV_ITER_ARRAY);
+    return tov(0);
+  }
+
+  if (vtype(iterable) == T_STR) {
+    if (is_rope(js, iterable)) {
+      iterable = rope_flatten(js, iterable);
+      if (is_err(iterable)) return iterable;
+    }
+    vm->stack[vm->sp++] = iterable;
+    vm->stack[vm->sp++] = tov(0);
+    vm->stack[vm->sp++] = tov(SV_ITER_STRING);
+    return tov(0);
+  }
+
+  jsval_t iter_fn = js_get_sym(js, iterable, get_iterator_sym());
+  uint8_t ft = vtype(iter_fn);
+  if (ft != T_FUNC && ft != T_CFUNC) return js_mkerr(js, "not iterable");
+  jsval_t iterator = sv_vm_call(vm, js, iter_fn, iterable, NULL, 0, NULL, false);
+  if (is_err(iterator)) return iterator;
+
+  map_iterator_state_t *map_st;
+  iter_type_t map_type;
+  if (sv_is_map_iter(js, iterator, &map_st, &map_type)) {
+    vm->stack[vm->sp++] = ANT_PTR(map_st);
+    vm->stack[vm->sp++] = tov((double)map_type);
+    vm->stack[vm->sp++] = tov(SV_ITER_MAP);
+    return tov(0);
+  }
+
+  set_iterator_state_t *set_st;
+  iter_type_t set_type;
+  if (sv_is_set_iter(js, iterator, &set_st, &set_type)) {
+    vm->stack[vm->sp++] = ANT_PTR(set_st);
+    vm->stack[vm->sp++] = tov((double)set_type);
+    vm->stack[vm->sp++] = tov(SV_ITER_SET);
+    return tov(0);
+  }
+
+  jsval_t next_method = js_getprop_fallback(js, iterator, "next");
+  vm->stack[vm->sp++] = iterator;
+  vm->stack[vm->sp++] = next_method;
+  vm->stack[vm->sp++] = tov(SV_ITER_GENERIC);
+  return tov(0);
+}
+
+static inline jsval_t sv_op_for_await_of(sv_vm_t *vm, ant_t *js) {
+  jsval_t iterable = vm->stack[--vm->sp];
+  jsval_t iter_fn = js_get_sym(js, iterable, get_asyncIterator_sym());
+
+  uint8_t ft = vtype(iter_fn);
+  if (ft != T_FUNC && ft != T_CFUNC) {
+    iter_fn = js_get_sym(js, iterable, get_iterator_sym());
+    ft = vtype(iter_fn);
+    if (ft != T_FUNC && ft != T_CFUNC) return js_mkerr(js, "not iterable");
+  }
+
+  jsval_t iterator = sv_vm_call(vm, js, iter_fn, iterable, NULL, 0, NULL, false);
+  if (is_err(iterator)) return iterator;
+  jsval_t next_method = js_getprop_fallback(js, iterator, "next");
+  vm->stack[vm->sp++] = iterator;
+  vm->stack[vm->sp++] = next_method;
+  vm->stack[vm->sp++] = tov(SV_ITER_GENERIC);
+  return tov(0);
+}
+
+static inline jsval_t sv_op_iter_next(sv_vm_t *vm, ant_t *js) {
+  int tag = (int)js_getnum(vm->stack[vm->sp - 1]);
+  switch (tag) {
+  case SV_ITER_ARRAY: {
+    jsval_t arr = vm->stack[vm->sp - 3];
+    int idx = (int)js_getnum(vm->stack[vm->sp - 2]);
+    jsoff_t len = js_arr_len(js, arr);
+    if (idx >= (int)len) {
+      vm->stack[vm->sp++] = js_mkundef();
+      vm->stack[vm->sp++] = js_true;
+    } else {
+      vm->stack[vm->sp++] = js_arr_get(js, arr, (jsoff_t)idx);
+      vm->stack[vm->sp++] = js_false;
+      vm->stack[vm->sp - 4] = tov(idx + 1);
+    }
+    return tov(0);
+  }
+
+  case SV_ITER_MAP: {
+    map_iterator_state_t *st =
+      (map_iterator_state_t *)(uintptr_t)js_getnum(vm->stack[vm->sp - 3]);
+    if (!st->current) {
+      vm->stack[vm->sp++] = js_mkundef();
+      vm->stack[vm->sp++] = js_true;
+    } else {
+      map_entry_t *entry = st->current;
+      jsval_t value;
+      switch (st->type) {
+      case ITER_TYPE_MAP_VALUES:
+        value = entry->value;
+        break;
+      case ITER_TYPE_MAP_KEYS:
+        value = js_mkstr(js, entry->key, strlen(entry->key));
+        break;
+      case ITER_TYPE_MAP_ENTRIES: {
+        jsval_t pair = js_mkarr(js);
+        js_arr_push(js, pair, js_mkstr(js, entry->key, strlen(entry->key)));
+        js_arr_push(js, pair, entry->value);
+        value = pair;
+        break;
+      }
+      default:
+        value = js_mkundef();
+      }
+      st->current = entry->hh.next;
+      vm->stack[vm->sp++] = value;
+      vm->stack[vm->sp++] = js_false;
+    }
+    return tov(0);
+  }
+
+  case SV_ITER_SET: {
+    set_iterator_state_t *st =
+      (set_iterator_state_t *)(uintptr_t)js_getnum(vm->stack[vm->sp - 3]);
+    if (!st->current) {
+      vm->stack[vm->sp++] = js_mkundef();
+      vm->stack[vm->sp++] = js_true;
+    } else {
+      set_entry_t *entry = st->current;
+      jsval_t value;
+      if (st->type == ITER_TYPE_SET_ENTRIES) {
+        jsval_t pair = js_mkarr(js);
+        js_arr_push(js, pair, entry->value);
+        js_arr_push(js, pair, entry->value);
+        value = pair;
+      } else {
+        value = entry->value;
+      }
+      st->current = entry->hh.next;
+      vm->stack[vm->sp++] = value;
+      vm->stack[vm->sp++] = js_false;
+    }
+    return tov(0);
+  }
+
+  case SV_ITER_STRING: {
+    jsval_t str = vm->stack[vm->sp - 3];
+    int idx = (int)js_getnum(vm->stack[vm->sp - 2]);
+    jsoff_t slen = str_len_fast(js, str);
+    if (idx >= (int)slen) {
+      vm->stack[vm->sp++] = js_mkundef();
+      vm->stack[vm->sp++] = js_true;
+    } else {
+      jsoff_t off = vstr(js, str, NULL);
+      utf8proc_int32_t cp;
+      jsoff_t cb_len = (jsoff_t)utf8_next((const utf8proc_uint8_t *)&js->mem[off + idx], (utf8proc_ssize_t)(slen - idx), &cp);
+      vm->stack[vm->sp++] = js_mkstr(js, (char *)&js->mem[off + idx], cb_len);
+      vm->stack[vm->sp++] = js_false;
+      vm->stack[vm->sp - 4] = tov(idx + (int)cb_len);
+    }
+    return tov(0);
+  }
+
+  default: {
+    jsval_t next_method = vm->stack[vm->sp - 2];
+    jsval_t iterator = vm->stack[vm->sp - 3];
+    uint8_t ft = vtype(next_method);
+    if (ft != T_FUNC && ft != T_CFUNC)
+      return js_mkerr(js, "iterator.next is not a function");
+    jsval_t result = sv_vm_call(vm, js, next_method, iterator, NULL, 0, NULL, false);
+    if (is_err(result)) return result;
+    if (!is_object_type(result))
+      return js_mkerr_typed(js, JS_ERR_TYPE, "Iterator result is not an object");
+    jsval_t done = js_getprop_fallback(js, result, "done");
+    jsval_t value = js_getprop_fallback(js, result, "value");
+    vm->stack[vm->sp++] = value;
+    vm->stack[vm->sp++] = mkval(T_BOOL, js_truthy(js, done));
+    return tov(0);
+  }}
+}
+
+static inline void sv_op_iter_get_value(sv_vm_t *vm, ant_t *js) {
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t done = js_getprop_fallback(js, obj, "done");
+  jsval_t value = js_getprop_fallback(js, obj, "value");
+  vm->stack[vm->sp++] = value;
+  vm->stack[vm->sp++] = mkval(T_BOOL, js_truthy(js, done));
+}
+
+static inline void sv_op_iter_close(sv_vm_t *vm, ant_t *js) {
+  int tag = (int)js_getnum(vm->stack[vm->sp - 1]);
+  if (tag == SV_ITER_GENERIC) {
+    jsval_t iterator = vm->stack[vm->sp - 3];
+    jsval_t return_fn = js_getprop_fallback(js, iterator, "return");
+    uint8_t ft = vtype(return_fn);
+    if (ft == T_FUNC || ft == T_CFUNC)
+      sv_vm_call(vm, js, return_fn, iterator, NULL, 0, NULL, false);
+  }
+  vm->sp -= 3;
+}
+
+static inline jsval_t sv_op_iter_call(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  jsval_t method = vm->stack[vm->sp - 1];
+  jsval_t iterator = vm->stack[vm->sp - 4];
+  uint8_t ft = vtype(method);
+  if (ft != T_FUNC && ft != T_CFUNC)
+    return js_mkerr(js, "iterator method is not callable");
+  jsval_t result = sv_vm_call(vm, js, method, iterator, NULL, 0, NULL, false);
+  if (is_err(result)) return result;
+  vm->stack[vm->sp++] = result;
+  return tov(0);
+}
+
+static inline jsval_t sv_op_await_iter_next(sv_vm_t *vm, ant_t *js) {
+  jsval_t next_method = vm->stack[vm->sp - 2];
+  jsval_t iterator = vm->stack[vm->sp - 3];
+  uint8_t ft = vtype(next_method);
+  if (ft != T_FUNC && ft != T_CFUNC)
+    return js_mkerr(js, "iterator.next is not a function");
+  jsval_t result = sv_vm_call(vm, js, next_method, iterator, NULL, 0, NULL, false);
+  if (is_err(result)) return result;
+  if (vtype(result) == T_PROMISE) {
+    jsval_t awaited = sv_await_value(js, result);
+    if (is_err(awaited)) return awaited;
+    result = awaited;
+  }
+  jsval_t done = js_getprop_fallback(js, result, "done");
+  jsval_t value = js_getprop_fallback(js, result, "value");
+  if (vtype(value) == T_PROMISE) {
+    jsval_t awaited_val = sv_await_value(js, value);
+    if (is_err(awaited_val)) return awaited_val;
+    value = awaited_val;
+  }
+  vm->stack[vm->sp++] = value;
+  vm->stack[vm->sp++] = mkval(T_BOOL, js_truthy(js, done));
+  return tov(0);
+}
+
+#endif
diff --git a/src/silver/ops/literals.h b/src/silver/ops/literals.h
new file mode 100644
index 0000000..4477552
--- /dev/null
+++ b/src/silver/ops/literals.h
@@ -0,0 +1,116 @@
+#ifndef SV_LITERALS_H
+#define SV_LITERALS_H
+
+#include "ant.h"
+#include "silver/engine.h"
+
+static inline void sv_op_const(sv_vm_t *vm, sv_func_t *func, uint8_t *ip) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  vm->stack[vm->sp++] = func->constants[idx];
+}
+
+static inline void sv_op_const_i8(sv_vm_t *vm, uint8_t *ip) {
+  int8_t val = sv_get_i8(ip + 1);
+  vm->stack[vm->sp++] = tov((double)val);
+}
+
+static inline void sv_op_const8(sv_vm_t *vm, sv_func_t *func, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  vm->stack[vm->sp++] = func->constants[idx];
+}
+
+static inline void sv_op_undef(sv_vm_t *vm) {
+  vm->stack[vm->sp++] = mkval(T_UNDEF, 0);
+}
+
+static inline void sv_op_null(sv_vm_t *vm) {
+  vm->stack[vm->sp++] = mkval(T_NULL, 0);
+}
+
+static inline void sv_op_true(sv_vm_t *vm) {
+  vm->stack[vm->sp++] = js_true;
+}
+
+static inline void sv_op_false(sv_vm_t *vm) {
+  vm->stack[vm->sp++] = js_false;
+}
+
+static inline void sv_op_this(sv_vm_t *vm, sv_frame_t *frame) {
+  vm->stack[vm->sp++] = frame->this;
+}
+
+static inline void sv_op_global(sv_vm_t *vm, ant_t *js) {
+  vm->stack[vm->sp++] = js->global;
+}
+
+static inline void sv_op_object(sv_vm_t *vm, ant_t *js) {
+  jsval_t obj = mkobj(js, 0);
+  jsval_t proto = js_get_ctor_proto(js, "Object", 6);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto);
+  vm->stack[vm->sp++] = obj;
+}
+
+static inline void sv_op_array(sv_vm_t *vm, ant_t *js, uint8_t *ip) {
+  uint16_t n = sv_get_u16(ip + 1);
+  jsval_t arr = js_mkarr(js);
+  jshdl_t h = js_root(js, arr);
+  for (uint16_t i = 0; i < n; i++) {
+    jsval_t val = vm->stack[vm->sp - n + i];
+    js_arr_push(js, js_deref(js, h), val);
+  }
+  vm->sp -= n;
+  vm->stack[vm->sp++] = js_deref(js, h);
+  js_unroot(js, h);
+}
+
+static inline void sv_op_regexp(sv_vm_t *vm, ant_t *js) {
+  jsval_t pattern = vm->stack[vm->sp - 2];
+  jsval_t flags   = vm->stack[vm->sp - 1];
+  vm->sp -= 2;
+
+  jsval_t regexp_obj = mkobj(js, 0);
+  jshdl_t h = js_root(js, regexp_obj);
+
+  jsval_t regexp_proto = js_get_ctor_proto(js, "RegExp", 6);
+  if (vtype(regexp_proto) == T_OBJ) js_set_proto(js, js_deref(js, h), regexp_proto);
+
+  js_mkprop_fast(js, js_deref(js, h), "source", 6, pattern);
+
+  jsoff_t flen = 0;
+  const char *fstr = "";
+  if (vtype(flags) == T_STR) {
+    jsoff_t foff;
+    foff = vstr(js, flags, &flen);
+    fstr = (const char *)&js->mem[foff];
+  }
+
+  bool g = false, i = false, m = false, s = false, y = false;
+  for (jsoff_t k = 0; k < flen; k++) {
+    if (fstr[k] == 'g') g = true;
+    if (fstr[k] == 'i') i = true;
+    if (fstr[k] == 'm') m = true;
+    if (fstr[k] == 's') s = true;
+    if (fstr[k] == 'y') y = true;
+  }
+
+  char sorted[8]; int si = 0;
+  if (g) sorted[si++] = 'g';
+  if (i) sorted[si++] = 'i';
+  if (m) sorted[si++] = 'm';
+  if (s) sorted[si++] = 's';
+  if (y) sorted[si++] = 'y';
+
+  jsval_t obj = js_deref(js, h);
+  js_mkprop_fast(js, obj, "flags", 5, js_mkstr(js, sorted, si));
+  js_mkprop_fast(js, obj, "global", 6, mkval(T_BOOL, g ? 1 : 0));
+  js_mkprop_fast(js, obj, "ignoreCase", 10, mkval(T_BOOL, i ? 1 : 0));
+  js_mkprop_fast(js, obj, "multiline", 9, mkval(T_BOOL, m ? 1 : 0));
+  js_mkprop_fast(js, obj, "dotAll", 6, mkval(T_BOOL, s ? 1 : 0));
+  js_mkprop_fast(js, obj, "sticky", 6, mkval(T_BOOL, y ? 1 : 0));
+  js_mkprop_fast(js, obj, "lastIndex", 9, tov(0));
+
+  vm->stack[vm->sp++] = js_deref(js, h);
+  js_unroot(js, h);
+}
+
+#endif
diff --git a/src/silver/ops/locals.h b/src/silver/ops/locals.h
new file mode 100644
index 0000000..4859dcc
--- /dev/null
+++ b/src/silver/ops/locals.h
@@ -0,0 +1,116 @@
+#ifndef SV_LOCALS_H
+#define SV_LOCALS_H
+
+#include "silver/engine.h"
+#include "errors.h"
+
+static inline void sv_op_get_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  vm->stack[vm->sp++] = lp[idx];
+}
+
+static inline void sv_op_put_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  lp[idx] = vm->stack[--vm->sp];
+}
+
+static inline void sv_op_set_local(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  lp[idx] = vm->stack[vm->sp - 1];
+}
+
+static inline void sv_op_get_local8(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  vm->stack[vm->sp++] = lp[idx];
+}
+
+static inline void sv_op_put_local8(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  lp[idx] = vm->stack[--vm->sp];
+}
+
+static inline void sv_op_set_local8(sv_vm_t *vm, jsval_t *lp, uint8_t *ip) {
+  uint8_t idx = sv_get_u8(ip + 1);
+  lp[idx] = vm->stack[vm->sp - 1];
+}
+
+static inline void sv_op_set_local_undef(jsval_t *lp, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  lp[idx] = SV_TDZ;
+}
+
+static inline jsval_t sv_op_get_local_chk(
+  sv_vm_t *vm, jsval_t *lp,
+  ant_t *js, sv_func_t *func, uint8_t *ip
+) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  jsval_t val = lp[idx];
+  if (val == SV_TDZ) {
+    uint32_t ai = sv_get_u32(ip + 3);
+    if (ai < (uint32_t)func->atom_count) {
+      sv_atom_t *a = &func->atoms[ai];
+      return js_mkerr_typed(
+        js, JS_ERR_REFERENCE,
+        "Cannot access '%.*s' before initialization", (int)a->len, a->str);
+    }
+    return js_mkerr_typed(
+      js, JS_ERR_REFERENCE,
+      "Cannot access variable before initialization");
+  }
+  vm->stack[vm->sp++] = val;
+  return val;
+}
+
+static inline jsval_t sv_op_put_local_chk(
+  sv_vm_t *vm, jsval_t *lp,
+  ant_t *js, sv_func_t *func, uint8_t *ip
+) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  jsval_t *slot = &lp[idx];
+  if (*slot == SV_TDZ) {
+    uint32_t ai = sv_get_u32(ip + 3);
+    if (ai < (uint32_t)func->atom_count) {
+      sv_atom_t *a = &func->atoms[ai];
+      return js_mkerr_typed(
+        js, JS_ERR_REFERENCE,
+        "Cannot access '%.*s' before initialization", (int)a->len, a->str);
+    }
+    return js_mkerr_typed(
+      js, JS_ERR_REFERENCE,
+      "Cannot access variable before initialization");
+  }
+  *slot = vm->stack[--vm->sp];
+  return *slot;
+}
+
+static inline void sv_op_get_arg(sv_vm_t *vm, sv_frame_t *frame, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  vm->stack[vm->sp++] = sv_frame_get_arg_value(frame, idx);
+}
+
+static inline void sv_op_put_arg(sv_vm_t *vm, sv_frame_t *frame, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  sv_frame_set_arg_value(frame, idx, vm->stack[--vm->sp]);
+}
+
+static inline void sv_op_set_arg(sv_vm_t *vm, sv_frame_t *frame, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  sv_frame_set_arg_value(frame, idx, vm->stack[vm->sp - 1]);
+}
+
+static inline void sv_op_rest(
+  sv_vm_t *vm, sv_frame_t *frame,
+  ant_t *js, uint8_t *ip
+) {
+  uint16_t start = sv_get_u16(ip + 1);
+  jsval_t arr = js_mkarr(js);
+  jshdl_t h = js_root(js, arr);
+  if (frame->bp) {
+    for (int i = (int)start; i < frame->argc; i++)
+      js_arr_push(js, js_deref(js, h), frame->bp[i]);
+  }
+  vm->stack[vm->sp++] = js_deref(js, h);
+  js_unroot(js, h);
+}
+
+#endif
diff --git a/src/silver/ops/objects.h b/src/silver/ops/objects.h
new file mode 100644
index 0000000..41c3f6e
--- /dev/null
+++ b/src/silver/ops/objects.h
@@ -0,0 +1,286 @@
+#ifndef SV_OBJECTS_H
+#define SV_OBJECTS_H
+
+#include "utf8.h"
+#include "property.h"
+#include "descriptors.h"
+
+#include "silver/engine.h"
+#include "modules/symbol.h"
+
+static inline void sv_op_define_method(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  uint8_t flags = sv_get_u8(ip + 5);
+  sv_atom_t *a = &func->atoms[atom_idx];
+  jsval_t fn = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[vm->sp - 1];
+  bool is_getter = (flags & 1) != 0;
+  bool is_setter = (flags & 2) != 0;
+  if (is_getter) {
+    js_set_getter_desc(js, obj, a->str, a->len, fn, JS_DESC_C);
+    return;
+  }
+  if (is_setter) {
+    js_set_setter_desc(js, obj, a->str, a->len, fn, JS_DESC_C);
+    return;
+  }
+  jsval_t key = js_mkstr(js, a->str, a->len);
+  mkprop(js, obj, key, fn, 0);
+}
+
+static inline void sv_op_define_method_comp(
+  sv_vm_t *vm, ant_t *js,
+  uint8_t *ip
+) {
+  uint8_t flags = sv_get_u8(ip + 1);
+  jsval_t fn = vm->stack[--vm->sp];
+  jsval_t key = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[vm->sp - 1];
+  bool is_getter = (flags & 1) != 0;
+  bool is_setter = (flags & 2) != 0;
+  if (vtype(key) == T_SYMBOL && !is_getter && !is_setter) {
+    js_set_sym(js, obj, key, fn);
+    return;
+  }
+  jsval_t key_str = sv_key_to_propstr(js, key);
+  if ((is_getter || is_setter) && vtype(key_str) == T_STR) {
+    jsoff_t klen = 0;
+    jsoff_t koff = vstr(js, key_str, &klen);
+    const char *kptr = (const char *)&js->mem[koff];
+    if (is_getter) js_set_getter_desc(js, obj, kptr, klen, fn, JS_DESC_C);
+    else js_set_setter_desc(js, obj, kptr, klen, fn, JS_DESC_C);
+    return;
+  }
+  if (vtype(key_str) == T_STR) {
+    jsoff_t klen = 0;
+    jsoff_t koff = vstr(js, key_str, &klen);
+    const char *kptr = (const char *)&js->mem[koff];
+    js_define_own_prop(js, obj, kptr, (size_t)klen, fn);
+  } else mkprop(js, obj, key_str, fn, 0);
+}
+
+static inline void sv_op_set_name(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[atom_idx];
+  jsval_t fn = vm->stack[vm->sp - 1];
+  jsval_t name = js_mkstr(js, a->str, a->len);
+  setprop_cstr(js, fn, "name", 4, name);
+}
+
+static inline void sv_op_set_name_comp(sv_vm_t *vm, ant_t *js) {
+  jsval_t key = vm->stack[vm->sp - 1];
+  jsval_t fn = vm->stack[vm->sp - 2];
+  jsval_t name = coerce_to_str(js, key);
+  setprop_cstr(js, fn, "name", 4, name);
+}
+
+static inline void sv_op_set_proto(sv_vm_t *vm, ant_t *js) {
+  jsval_t proto = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[vm->sp - 1];
+  uint8_t pt = vtype(proto);
+  if (pt == T_OBJ || pt == T_NULL || pt == T_FUNC || pt == T_ARR)
+    js_set_proto(js, obj, proto);
+}
+
+static inline void sv_op_set_home_obj(sv_vm_t *vm, ant_t *js) {
+  jsval_t home = vm->stack[vm->sp - 1];
+  jsval_t fn = vm->stack[vm->sp - 2];
+  jsval_t fn_obj = js_func_obj(fn);
+  js_set_slot(js, fn_obj, SLOT_SUPER, home);
+  sv_closure_t *c = js_func_closure(fn);
+  if (c->func != NULL)
+    c->call_flags |= SV_CALL_HAS_SUPER;
+}
+
+static inline void sv_op_append(sv_vm_t *vm, ant_t *js) {
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t arr = vm->stack[vm->sp - 2];
+  js_arr_push(js, arr, val);
+}
+
+static inline void sv_op_copy_data_props(
+  sv_vm_t *vm, ant_t *js,
+  uint8_t *ip
+) {
+  if (vm->sp < 2) return;
+  jsval_t src = vm->stack[vm->sp - 1];
+  jsval_t dst = vm->stack[vm->sp - 2];
+  if (!is_object_type(src) || !is_object_type(dst)) return;
+  
+  const char *key = NULL;
+  size_t key_len = 0;
+  jsval_t val = js_mkundef();
+  ant_iter_t iter = js_prop_iter_begin(js, src);
+  
+  while (js_prop_iter_next(&iter, &key, &key_len, &val)) {
+    jsval_t prop_key = js_mkstr(js, key, key_len);
+    js_setprop(js, dst, prop_key, val);
+  }
+  
+  js_prop_iter_end(&iter);
+}
+
+static inline jsval_t sv_op_spread(sv_vm_t *vm, ant_t *js) {
+  if (vm->sp < 2)
+    return js_mkerr(js, "invalid spread state");
+
+  jsval_t iterable = vm->stack[--vm->sp];
+  jsval_t arr = vm->stack[vm->sp - 1];
+  if (vtype(arr) != T_ARR)
+    return js_mkerr(js, "spread target is not an array");
+
+  if (vtype(iterable) == T_ARR) {
+    jsoff_t len = js_arr_len(js, iterable);
+    for (jsoff_t i = 0; i < len; i++)
+      js_arr_push(js, arr, js_arr_get(js, iterable, i));
+    return tov(0);
+  }
+
+  if (vtype(iterable) == T_STR) {
+    if (is_rope(js, iterable)) {
+      iterable = rope_flatten(js, iterable);
+      if (is_err(iterable)) return iterable;
+    }
+    jsoff_t slen = str_len_fast(js, iterable);
+    for (jsoff_t i = 0; i < slen; ) {
+      jsoff_t off = vstr(js, iterable, NULL);
+      utf8proc_int32_t cp;
+      jsoff_t cb_len = (jsoff_t)utf8_next(
+        (const utf8proc_uint8_t *)&js->mem[off + i],
+        (utf8proc_ssize_t)(slen - i), &cp
+      );
+      js_arr_push(js, arr, js_mkstr(js, (char *)&js->mem[off + i], cb_len));
+      i += cb_len;
+    }
+    return tov(0);
+  }
+
+  jsval_t iter_fn = js_get_sym(js, iterable, get_iterator_sym());
+  uint8_t ft = vtype(iter_fn);
+  if (ft != T_FUNC && ft != T_CFUNC)
+    return js_mkerr(js, "not iterable");
+
+  jsval_t iterator = sv_vm_call(vm, js, iter_fn, iterable, NULL, 0, NULL, false);
+  if (is_err(iterator)) return iterator;
+  if (!is_object_type(iterator))
+    return js_mkerr(js, "not iterable");
+
+  jshdl_t hiter = js_root(js, iterator);
+  jsval_t status = tov(0);
+
+  for (;;) {
+    jsval_t cur_iter = js_deref(js, hiter);
+    jsval_t next_method = js_getprop_fallback(js, cur_iter, "next");
+    ft = vtype(next_method);
+    if (ft != T_FUNC && ft != T_CFUNC) {
+      status = js_mkerr(js, "iterator.next is not a function");
+      break;
+    }
+
+    jsval_t result = sv_vm_call(vm, js, next_method, cur_iter, NULL, 0, NULL, false);
+    if (is_err(result)) {
+      status = result;
+      break;
+    }
+    if (!is_object_type(result)) {
+      status = js_mkerr_typed(js, JS_ERR_TYPE, "Iterator result is not an object");
+      break;
+    }
+
+    jsval_t done = js_getprop_fallback(js, result, "done");
+    if (js_truthy(js, done))
+      break;
+
+    jsval_t value = js_getprop_fallback(js, result, "value");
+    js_arr_push(js, arr, value);
+  }
+
+  js_unroot(js, hiter);
+  return status;
+}
+
+static inline void sv_op_define_class(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t atom_idx = sv_get_u32(ip + 1);
+  uint8_t cls_flags = sv_get_u8(ip + 5);
+  
+  bool has_name = (cls_flags & 1) && (int)atom_idx < func->atom_count;
+  sv_atom_t *a = has_name ? &func->atoms[atom_idx] : NULL;
+  jsval_t ctor = vm->stack[vm->sp - 1];
+  jsval_t parent = vm->stack[vm->sp - 2];
+  
+  uint8_t pt = vtype(parent);
+  bool parent_is_object = is_object_type(parent);
+  bool parent_is_callable = (pt == T_FUNC || pt == T_CFUNC);
+
+  if (vtype(ctor) == T_UNDEF) {
+    jsval_t ctor_obj = mkobj(js, 0);
+    ctor = js_obj_to_func(ctor_obj);
+    js_set_slot(js, ctor_obj, SLOT_DEFAULT_CTOR, js_true);
+    jsval_t func_proto = js_get_slot(js, js->global, SLOT_FUNC_PROTO);
+    if (vtype(func_proto) == T_FUNC)
+      js_set_proto(js, ctor_obj, func_proto);
+  }
+
+  jsval_t proto = mkobj(js, 0);
+  jshdl_t hp = js_root(js, proto);
+  jshdl_t hc = js_root(js, ctor);
+
+  if (pt == T_NULL) {
+    js_set_proto(js, js_deref(js, hp), js_mknull());
+    jsval_t func_proto = js_get_slot(js, js->global, SLOT_FUNC_PROTO);
+    if (vtype(func_proto) == T_FUNC)
+      js_set_proto(js, js_deref(js, hc), func_proto);
+  } else if (parent_is_object) {
+    jsval_t parent_proto = js_getprop_fallback(js, parent, "prototype");
+    if (is_object_type(parent_proto))
+      js_set_proto(js, js_deref(js, hp), parent_proto);
+    js_set_proto(js, js_deref(js, hc), parent);
+  } else {
+    jsval_t object_ctor = js_getprop_fallback(js, js->global, "Object");
+    if (vtype(object_ctor) == T_FUNC) {
+      jsval_t object_proto = js_getprop_fallback(js, object_ctor, "prototype");
+      if (is_object_type(object_proto))
+        js_set_proto(js, js_deref(js, hp), object_proto);
+    }
+  }
+  if (parent_is_callable)
+    js_set_slot(js, js_deref(js, hc), SLOT_SUPER, parent);
+
+  ctor = js_deref(js, hc);
+  proto = js_deref(js, hp);
+  setprop_interned(js, proto, "constructor", 11, ctor);
+  setprop_interned(js, ctor, "prototype", 9, proto);
+  if (a && a->len > 0)
+    setprop_cstr(js, ctor, "name", 4, js_mkstr(js, a->str, a->len));
+
+  js_unroot(js, hc);
+  js_unroot(js, hp);
+
+  vm->stack[vm->sp - 2] = ctor;
+  vm->stack[vm->sp - 1] = proto;
+}
+
+static inline void sv_op_define_class_comp(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  jsval_t name = vm->stack[vm->sp - 1];
+  vm->sp--;
+  sv_op_define_class(vm, js, func, ip);
+  vm->stack[vm->sp++] = name;
+}
+
+static inline void sv_op_add_brand(sv_vm_t *vm) {
+  vm->sp -= 2;
+}
+
+#endif
diff --git a/src/silver/ops/optional.h b/src/silver/ops/optional.h
new file mode 100644
index 0000000..cbe2a23
--- /dev/null
+++ b/src/silver/ops/optional.h
@@ -0,0 +1,36 @@
+#ifndef SV_OPTIONAL_H
+#define SV_OPTIONAL_H
+
+#include "silver/engine.h"
+#include "property.h"
+
+static inline jsval_t sv_op_get_field_opt(sv_vm_t *vm, ant_t *js, sv_func_t *func, uint8_t *ip) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[idx];
+  jsval_t obj = vm->stack[--vm->sp];
+  uint8_t t = vtype(obj);
+  if (t == T_NULL || t == T_UNDEF) {
+    vm->stack[vm->sp++] = js_mkundef();
+    return js_mkundef();
+  } else {
+    jsval_t res = sv_prop_get_at(js, obj, a->str, a->len, func, ip);
+    if (is_err(res)) return res;
+    vm->stack[vm->sp++] = res;
+    return js_mkundef();
+  }
+}
+
+static inline jsval_t sv_op_get_elem_opt(sv_vm_t *vm, ant_t *js, sv_func_t *func, uint8_t *ip) {
+  jsval_t key = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  uint8_t t = vtype(obj);
+  if (t == T_NULL || t == T_UNDEF) {
+    vm->stack[vm->sp++] = js_mkundef();
+    return js_mkundef();
+  }
+  vm->stack[vm->sp++] = obj;
+  vm->stack[vm->sp++] = key;
+  return sv_op_get_elem(vm, js, func, ip);
+}
+
+#endif
diff --git a/src/silver/ops/private.h b/src/silver/ops/private.h
new file mode 100644
index 0000000..b893f38
--- /dev/null
+++ b/src/silver/ops/private.h
@@ -0,0 +1,32 @@
+#ifndef SV_PRIVATE_H
+#define SV_PRIVATE_H
+
+#include "silver/engine.h"
+
+static inline void sv_op_get_private(sv_vm_t *vm, ant_t *js) {
+  jsval_t prop = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t key_str = coerce_to_str(js, prop);
+  jsoff_t klen;
+  jsoff_t koff = vstr(js, key_str, &klen);
+  const char *kptr = (const char *)&js->mem[koff];
+  vm->stack[vm->sp++] = js_getprop_fallback(js, obj, kptr);
+}
+
+static inline void sv_op_put_private(sv_vm_t *vm, ant_t *js) {
+  jsval_t prop = vm->stack[--vm->sp];
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t key_str = coerce_to_str(js, prop);
+  js_setprop(js, obj, key_str, val);
+}
+
+static inline void sv_op_def_private(sv_vm_t *vm, ant_t *js) {
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t prop = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[vm->sp - 1];
+  jsval_t key_str = coerce_to_str(js, prop);
+  js_setprop(js, obj, key_str, val);
+}
+
+#endif
diff --git a/src/silver/ops/property.h b/src/silver/ops/property.h
new file mode 100644
index 0000000..1fc8e25
--- /dev/null
+++ b/src/silver/ops/property.h
@@ -0,0 +1,295 @@
+#ifndef SV_PROPERTY_H
+#define SV_PROPERTY_H
+
+#include "silver/engine.h"
+#include "utf8.h"
+#include <math.h>
+#include <stdlib.h>
+
+static inline jsval_t sv_getprop_fallback_len(
+  ant_t *js, jsval_t obj,
+  const char *key, jsoff_t key_len
+) {
+  char small[64];
+  char *tmp = small;
+
+  if (key_len + 1 > (jsoff_t)sizeof(small)) {
+    tmp = malloc((size_t)key_len + 1);
+    if (!tmp) return js_mkerr(js, "out of memory");
+  }
+
+  memcpy(tmp, key, (size_t)key_len);
+  tmp[key_len] = '\0';
+  jsval_t out = js_getprop_fallback(js, obj, tmp);
+
+  if (tmp != small) free(tmp);
+  return out;
+}
+
+static inline jsval_t sv_key_to_propstr(ant_t *js, jsval_t key) {
+  return coerce_to_str(js, key);
+}
+
+static inline jsval_t sv_getprop_by_key(ant_t *js, jsval_t obj, jsval_t key) {
+  if (vtype(key) == T_SYMBOL) return js_get_sym(js, obj, key);
+  jsval_t key_str = sv_key_to_propstr(js, key);
+  if (is_err(key_str) || vtype(key_str) != T_STR) return js_mkundef();
+
+  jsoff_t klen = 0;
+  jsoff_t koff = vstr(js, key_str, &klen);
+  const char *kptr = (const char *)&js->mem[koff];
+  return sv_getprop_fallback_len(js, obj, kptr, klen);
+}
+
+static inline jsval_t sv_prop_get_at(
+  ant_t *js, jsval_t obj, const char *str, uint32_t len,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint8_t t = vtype(obj);
+
+  if (t == T_NULL || t == T_UNDEF) {
+    if (func && ip) js_set_error_site_from_bc(js, func, (int)(ip - func->code), func->filename);
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "Cannot read properties of %s (reading '%.*s')",
+      t == T_NULL ? "null" : "undefined", (int)len, str);
+  }
+
+  jsval_t str_prim = js_mkundef();
+  jsval_t sym_prim = js_mkundef();
+
+  if (t == T_STR) {
+    str_prim = obj;
+  } else if (t == T_SYMBOL) {
+    sym_prim = obj;
+  } else if (t == T_OBJ) {
+    jsval_t prim = js_get_slot(js, obj, SLOT_PRIMITIVE);
+    if (vtype(prim) == T_STR) str_prim = prim;
+    else if (vtype(prim) == T_SYMBOL) sym_prim = prim;
+  }
+
+  if (vtype(str_prim) == T_STR && len == 6 && memcmp(str, "length", 6) == 0) {
+    jsoff_t byte_len = 0;
+    jsoff_t str_off = vstr(js, str_prim, &byte_len);
+    const char *str_data = (const char *)&js->mem[str_off];
+    return tov((double)utf16_strlen(str_data, byte_len));
+  }
+
+  if (vtype(sym_prim) == T_SYMBOL && len == 11 &&
+      memcmp(str, "description", 11) == 0) {
+    const char *desc = js_sym_desc(js, sym_prim);
+    if (desc) return js_mkstr(js, desc, strlen(desc));
+    return js_mkundef();
+  }
+  
+  return sv_getprop_fallback_len(js, obj, str, (jsoff_t)len);
+}
+
+static inline jsval_t sv_prop_get(ant_t *js, jsval_t obj, const char *str, uint32_t len) {
+  return sv_prop_get_at(js, obj, str, len, NULL, NULL);
+}
+
+static inline bool sv_parse_string_index_key(ant_t *js, jsval_t key, size_t *out_idx) {
+  if (vtype(key) == T_NUM) {
+    double d = tod(key);
+    if (!isfinite(d) || d < 0.0) return false;
+    double di = floor(d);
+    if (di != d || di > (double)SIZE_MAX) return false;
+    *out_idx = (size_t)di;
+    return true;
+  }
+
+  if (vtype(key) != T_STR) return false;
+
+  jsoff_t klen = 0;
+  jsoff_t koff = vstr(js, key, &klen);
+  const char *k = (const char *)&js->mem[koff];
+  if (klen == 0) return false;
+  if (klen > 1 && k[0] == '0') return false;
+
+  size_t idx = 0;
+  for (jsoff_t i = 0; i < klen; i++) {
+    if (k[i] < '0' || k[i] > '9') return false;
+    size_t digit = (size_t)(k[i] - '0');
+    if (idx > (SIZE_MAX - digit) / 10) return false;
+    idx = idx * 10 + digit;
+  }
+
+  *out_idx = idx;
+  return true;
+}
+
+static inline bool sv_try_string_index_get(ant_t *js, jsval_t obj, jsval_t key, jsval_t *out) {
+  jsval_t str = obj;
+  if (vtype(obj) == T_OBJ) {
+    jsval_t prim = js_get_slot(js, obj, SLOT_PRIMITIVE);
+    if (vtype(prim) == T_STR) str = prim;
+  }
+  if (vtype(str) != T_STR) return false;
+
+  size_t idx = 0;
+  if (!sv_parse_string_index_key(js, key, &idx)) return false;
+
+  jsoff_t byte_len = 0;
+  jsoff_t str_off = vstr(js, str, &byte_len);
+  const char *str_data = (const char *)&js->mem[str_off];
+  size_t char_bytes = 0;
+  int byte_offset = utf16_index_to_byte_offset(str_data, byte_len, idx, &char_bytes);
+  if (byte_offset < 0 || char_bytes == 0) {
+    *out = js_mkundef();
+    return true;
+  }
+
+  *out = js_mkstr(js, str_data + byte_offset, char_bytes);
+  return true;
+}
+
+static inline jsval_t sv_op_get_field(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[idx];
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t res = sv_prop_get_at(js, obj, a->str, a->len, func, ip);
+  if (is_err(res)) return res;
+  vm->stack[vm->sp++] = res;
+  return js_mkundef();
+}
+
+static inline jsval_t sv_op_get_field2(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[idx];
+  jsval_t obj = vm->stack[vm->sp - 1];
+  jsval_t res = sv_prop_get_at(js, obj, a->str, a->len, func, ip);
+  if (is_err(res)) return res;
+  vm->stack[vm->sp++] = res;
+  return js_mkundef();
+}
+
+static inline jsval_t sv_op_put_field(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[idx];
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t key = js_mkstr(js, a->str, a->len);
+  return js_setprop(js, obj, key, val);
+}
+
+static inline jsval_t sv_op_get_elem(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  jsval_t key = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  uint8_t ot = vtype(obj);
+
+  if (ot == T_NULL || ot == T_UNDEF) {
+    if (func && ip) js_set_error_site_from_bc(js, func, (int)(ip - func->code), func->filename);
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "Cannot read properties of %s", ot == T_NULL ? "null" : "undefined");
+  }
+
+  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
+    double d = tod(key);
+    if (d >= 0 && d == (uint32_t)d) {
+      vm->stack[vm->sp++] = js_arr_get(js, obj, (uint32_t)d);
+      return js_mkundef();
+    }
+  }
+
+  jsval_t str_elem = js_mkundef();
+  if (sv_try_string_index_get(js, obj, key, &str_elem)) {
+    vm->stack[vm->sp++] = str_elem;
+    return js_mkundef();
+  }
+
+  jsval_t res = sv_getprop_by_key(js, obj, key);
+  if (is_err(res)) return res;
+  vm->stack[vm->sp++] = res;
+  return js_mkundef();
+}
+
+static inline jsval_t sv_op_get_elem2(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  jsval_t key = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[vm->sp - 1];
+
+  uint8_t ot = vtype(obj);
+  if (ot == T_NULL || ot == T_UNDEF) {
+    if (func && ip) js_set_error_site_from_bc(js, func, (int)(ip - func->code), func->filename);
+    return js_mkerr_typed(js, JS_ERR_TYPE,
+      "Cannot read properties of %s", ot == T_NULL ? "null" : "undefined");
+  }
+
+  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
+    double d = tod(key);
+    if (d >= 0 && d == (uint32_t)d) {
+      vm->stack[vm->sp++] = js_arr_get(js, obj, (uint32_t)d);
+      return js_mkundef();
+    }
+  }
+
+  jsval_t str_elem = js_mkundef();
+  if (sv_try_string_index_get(js, obj, key, &str_elem)) {
+    vm->stack[vm->sp++] = str_elem;
+    return js_mkundef();
+  }
+
+  jsval_t res = sv_getprop_by_key(js, obj, key);
+  if (is_err(res)) return res;
+  vm->stack[vm->sp++] = res;
+  return js_mkundef();
+}
+
+static inline jsval_t sv_op_put_elem(sv_vm_t *vm, ant_t *js) {
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t key = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  if (vtype(key) == T_SYMBOL) return js_setprop(js, obj, key, val);
+  jsval_t key_jv = sv_key_to_propstr(js, key);
+  return js_setprop(js, obj, key_jv, val);
+}
+
+static inline void sv_op_define_field(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  sv_atom_t *a = &func->atoms[idx];
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[vm->sp - 1];
+  js_define_own_prop(js, obj, a->str, a->len, val);
+}
+
+static inline jsval_t sv_op_get_length(sv_vm_t *vm, ant_t *js) {
+  jsval_t obj = vm->stack[--vm->sp];
+
+  if (vtype(obj) == T_ARR) {
+    vm->stack[vm->sp++] = tov((double)(uint32_t)js_arr_len(js, obj));
+    return js_mkundef();
+  }
+  
+  if (vtype(obj) == T_STR) {
+    jsoff_t byte_len = 0;
+    jsoff_t off = vstr(js, obj, &byte_len);
+    const char *str_data = (const char *)&js->mem[off];
+    vm->stack[vm->sp++] = tov((double)(uint32_t)utf16_strlen(str_data, byte_len));
+    return js_mkundef();
+  }
+
+  jsval_t res = js_getprop_fallback(js, obj, "length");
+  if (is_err(res)) return res;
+  
+  vm->stack[vm->sp++] = res;
+  return js_mkundef();
+}
+
+#endif
diff --git a/src/silver/ops/returns.h b/src/silver/ops/returns.h
new file mode 100644
index 0000000..ee1c70e
--- /dev/null
+++ b/src/silver/ops/returns.h
@@ -0,0 +1,12 @@
+#ifndef SV_RETURNS_H
+#define SV_RETURNS_H
+
+#include "silver/engine.h"
+
+static inline jsval_t sv_op_halt(sv_vm_t *vm, sv_frame_t *frame) {
+  jsval_t r = vm->sp > 0 ? vm->stack[--vm->sp] : js_mkundef();
+  vm->sp = frame->prev_sp;
+  return r;
+}
+
+#endif
diff --git a/src/silver/ops/stack.h b/src/silver/ops/stack.h
new file mode 100644
index 0000000..1474dc5
--- /dev/null
+++ b/src/silver/ops/stack.h
@@ -0,0 +1,85 @@
+#ifndef SV_STACK_H
+#define SV_STACK_H
+
+#include "silver/engine.h"
+
+static inline void sv_op_pop(sv_vm_t *vm) {
+  vm->sp--;
+}
+
+static inline void sv_op_dup(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp++] = a;
+}
+
+static inline void sv_op_dup2(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 2];
+  jsval_t b = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp++] = a;
+  vm->stack[vm->sp++] = b;
+}
+
+static inline void sv_op_swap(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 2];
+  vm->stack[vm->sp - 2] = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 1] = a;
+}
+
+static inline void sv_op_rot3l(sv_vm_t *vm) {
+  jsval_t x = vm->stack[vm->sp - 3];
+  vm->stack[vm->sp - 3] = vm->stack[vm->sp - 2];
+  vm->stack[vm->sp - 2] = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 1] = x;
+}
+
+static inline void sv_op_rot3r(sv_vm_t *vm) {
+  jsval_t x = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 1] = vm->stack[vm->sp - 2];
+  vm->stack[vm->sp - 2] = vm->stack[vm->sp - 3];
+  vm->stack[vm->sp - 3] = x;
+}
+
+static inline void sv_op_nip(sv_vm_t *vm) {
+  vm->stack[vm->sp - 2] = vm->stack[vm->sp - 1];
+  vm->sp--;
+}
+
+static inline void sv_op_nip2(sv_vm_t *vm) {
+  vm->stack[vm->sp - 3] = vm->stack[vm->sp - 1];
+  vm->sp -= 2;
+}
+
+static inline void sv_op_insert2(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 1];
+  jsval_t obj = vm->stack[vm->sp - 2];
+  vm->stack[vm->sp - 2] = a;
+  vm->stack[vm->sp - 1] = obj;
+  vm->stack[vm->sp++] = a;
+}
+
+static inline void sv_op_insert3(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 1];
+  jsval_t prop = vm->stack[vm->sp - 2];
+  jsval_t obj = vm->stack[vm->sp - 3];
+  vm->stack[vm->sp - 3] = a;
+  vm->stack[vm->sp - 2] = obj;
+  vm->stack[vm->sp - 1] = prop;
+  vm->stack[vm->sp++] = a;
+}
+
+static inline void sv_op_swap_under(sv_vm_t *vm) {
+  jsval_t tmp = vm->stack[vm->sp - 3];
+  vm->stack[vm->sp - 3] = vm->stack[vm->sp - 2];
+  vm->stack[vm->sp - 2] = tmp;
+}
+
+static inline void sv_op_rot4_under(sv_vm_t *vm) {
+  jsval_t a = vm->stack[vm->sp - 4];
+  jsval_t b = vm->stack[vm->sp - 3];
+  jsval_t c = vm->stack[vm->sp - 2];
+  vm->stack[vm->sp - 4] = c;
+  vm->stack[vm->sp - 3] = a;
+  vm->stack[vm->sp - 2] = b;
+}
+
+#endif
diff --git a/src/silver/ops/super.h b/src/silver/ops/super.h
new file mode 100644
index 0000000..d278d6f
--- /dev/null
+++ b/src/silver/ops/super.h
@@ -0,0 +1,32 @@
+#ifndef SV_SUPER_H
+#define SV_SUPER_H
+
+#include "silver/engine.h"
+
+static inline void sv_op_get_super(sv_vm_t *vm, ant_t *js) {
+  jsval_t obj = vm->stack[vm->sp - 1];
+  vm->stack[vm->sp - 1] = js_get_proto(js, obj);
+}
+
+static inline void sv_op_get_super_val(sv_vm_t *vm, ant_t *js) {
+  jsval_t prop = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t receiver = vm->stack[--vm->sp];
+  jsval_t proto = js_get_proto(js, obj);
+  jsval_t key_str = coerce_to_str(js, prop);
+  jsoff_t klen;
+  jsoff_t koff = vstr(js, key_str, &klen);
+  const char *kptr = (const char *)&js->mem[koff];
+  vm->stack[vm->sp++] = js_getprop_super(js, proto, receiver, kptr);
+}
+
+static inline void sv_op_put_super_val(sv_vm_t *vm, ant_t *js) {
+  jsval_t val = vm->stack[--vm->sp];
+  jsval_t prop = vm->stack[--vm->sp];
+  vm->sp--;
+  jsval_t this = vm->stack[--vm->sp];
+  jsval_t key_str = coerce_to_str(js, prop);
+  js_setprop(js, this, key_str, val);
+}
+
+#endif
diff --git a/src/silver/ops/unary.h b/src/silver/ops/unary.h
new file mode 100644
index 0000000..8b89711
--- /dev/null
+++ b/src/silver/ops/unary.h
@@ -0,0 +1,57 @@
+#ifndef SV_UNARY_H
+#define SV_UNARY_H
+
+#include "silver/engine.h"
+#include <stdlib.h>
+#include <string.h>
+
+static inline void sv_op_not(sv_vm_t *vm, ant_t *js) {
+  jsval_t a = vm->stack[--vm->sp];
+  vm->stack[vm->sp++] = mkval(T_BOOL, !js_truthy(js, a));
+}
+
+static inline void sv_op_typeof(sv_vm_t *vm, ant_t *js) {
+  jsval_t a = vm->stack[--vm->sp];
+  const char *ts = typestr(vtype(a));
+  vm->stack[vm->sp++] = js_mkstr(js, ts, strlen(ts));
+}
+
+static inline void sv_op_void(sv_vm_t *vm) {
+  vm->sp--;
+  vm->stack[vm->sp++] = mkval(T_UNDEF, 0);
+}
+
+static inline jsval_t sv_op_delete(sv_vm_t *vm, ant_t *js) {
+  jsval_t key = vm->stack[--vm->sp];
+  jsval_t obj = vm->stack[--vm->sp];
+  jsval_t key_str = js_mkundef();
+
+  if (vtype(key) == T_SYMBOL) {
+    jsval_t result = js_delete_sym_prop(js, obj, key);
+    if (is_err(result)) return result;
+    vm->stack[vm->sp++] = result;
+    return js_mkundef();
+  } else key_str = coerce_to_str(js, key);
+
+  if (!is_err(key_str) && vtype(key_str) == T_STR) {
+    jsoff_t klen = 0;
+    jsoff_t koff = vstr(js, key_str, &klen);
+    const char *kptr = (const char *)&js->mem[koff];
+    jsval_t result = js_delete_prop(js, obj, kptr, klen);
+    if (is_err(result)) return result;
+    vm->stack[vm->sp++] = result;
+  } else vm->stack[vm->sp++] = mkval(T_BOOL, 0);
+
+  return js_mkundef();
+}
+
+static inline void sv_op_delete_var(
+  sv_vm_t *vm, ant_t *js,
+  sv_func_t *func, uint8_t *ip
+) {
+  sv_atom_t *a = &func->atoms[sv_get_u32(ip + 1)];
+  jsval_t result = js_delete_prop(js, js->global, a->str, a->len);
+  vm->stack[vm->sp++] = result;
+}
+
+#endif
diff --git a/src/silver/ops/upvalues.h b/src/silver/ops/upvalues.h
new file mode 100644
index 0000000..ce943a6
--- /dev/null
+++ b/src/silver/ops/upvalues.h
@@ -0,0 +1,158 @@
+#ifndef SV_UPVALUES_H
+#define SV_UPVALUES_H
+
+#include "silver/engine.h"
+#include "descriptors.h"
+
+static inline jsval_t sv_setup_function_prototype(
+  ant_t *js, jsval_t func_obj, 
+  jsval_t func_val
+) {
+  jsval_t proto_obj = mkobj(js, 0);
+  if (is_err(proto_obj)) return proto_obj;
+
+  jshdl_t hproto = js_root(js, proto_obj);
+  jsval_t object_proto = js_get_ctor_proto(js, "Object", 6);
+  if (vtype(object_proto) == T_OBJ)
+    js_set_proto(js, js_deref(js, hproto), object_proto);
+
+  jsval_t ctor_key = js_mkstr(js, "constructor", 11);
+  if (is_err(ctor_key)) {
+    js_unroot(js, hproto);
+    return ctor_key;
+  }
+  jsval_t set_ctor = js_setprop(js, js_deref(js, hproto), ctor_key, func_val);
+  if (is_err(set_ctor)) {
+    js_unroot(js, hproto);
+    return set_ctor;
+  }
+  js_set_descriptor(js, js_deref(js, hproto), "constructor", 11, JS_DESC_W | JS_DESC_C);
+
+  jsval_t proto_key = js_mkstr(js, "prototype", 9);
+  if (is_err(proto_key)) {
+    js_unroot(js, hproto);
+    return proto_key;
+  }
+  jsval_t set_proto = js_setprop(js, func_obj, proto_key, js_deref(js, hproto));
+  if (is_err(set_proto)) {
+    js_unroot(js, hproto);
+    return set_proto;
+  }
+  js_set_descriptor(js, func_obj, "prototype", 9, JS_DESC_W);
+
+  js_unroot(js, hproto);
+  return js_mkundef();
+}
+
+static inline jsval_t sv_op_get_upval(
+  sv_vm_t *vm, sv_frame_t *frame,
+  ant_t *js, uint8_t *ip
+) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  sv_upvalue_t *uv = frame->upvalues[idx];
+  jsval_t val = *uv->location;
+  if (val == SV_TDZ)
+    return js_mkerr_typed(js, JS_ERR_REFERENCE,
+      "Cannot access variable before initialization");
+  vm->stack[vm->sp++] = val;
+  return js_mkundef();
+}
+
+static inline void sv_op_put_upval(sv_vm_t *vm, sv_frame_t *frame, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  sv_upvalue_t *uv = frame->upvalues[idx];
+  *uv->location = vm->stack[--vm->sp];
+}
+
+static inline void sv_op_set_upval(sv_vm_t *vm, sv_frame_t *frame, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  sv_upvalue_t *uv = frame->upvalues[idx];
+  *uv->location = vm->stack[vm->sp - 1];
+}
+
+static inline void sv_op_close_upval(sv_vm_t *vm, sv_frame_t *frame, uint8_t *ip) {
+  uint16_t idx = sv_get_u16(ip + 1);
+  jsval_t *slot = sv_frame_slot_ptr(frame, idx);
+  if (!slot) return;
+
+  sv_upvalue_t **pp = &vm->open_upvalues;
+  while (*pp) {
+    sv_upvalue_t *uv = *pp;
+    if (uv->location >= slot) {
+      uv->closed = *uv->location;
+      uv->location = &uv->closed;
+      *pp = uv->next;
+    } else pp = &uv->next;
+  }
+}
+
+static inline sv_upvalue_t *sv_capture_upvalue(sv_vm_t *vm, jsval_t *slot) {
+  sv_upvalue_t **pp = &vm->open_upvalues;
+  while (*pp && (*pp)->location > slot)
+    pp = &(*pp)->next;
+
+  if (*pp && (*pp)->location == slot)
+    return *pp;
+
+  sv_upvalue_t *uv = calloc(1, sizeof(sv_upvalue_t));
+  uv->location = slot;
+  uv->next = *pp;
+  *pp = uv;
+  return uv;
+}
+
+static inline void sv_op_closure(
+  sv_vm_t *vm, ant_t *js, sv_frame_t *frame,
+  sv_func_t *func, uint8_t *ip
+) {
+  uint32_t idx = sv_get_u32(ip + 1);
+  sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(func->constants[idx]);
+
+  sv_closure_t *closure = calloc(1, sizeof(sv_closure_t));
+  closure->func = child;
+  closure->bound_this = child->is_arrow ? frame->this : js_mkundef();
+  closure->call_flags = 0;
+
+  if (child->upvalue_count > 0) {
+    closure->upvalues = calloc((size_t)child->upvalue_count, sizeof(sv_upvalue_t *));
+    for (int i = 0; i < child->upvalue_count; i++) {
+      sv_upval_desc_t *desc = &child->upval_descs[i];
+      if (desc->is_local) {
+        jsval_t *slot = sv_frame_slot_ptr(frame, desc->index);
+        if (!slot) slot = frame->bp;
+        closure->upvalues[i] = sv_capture_upvalue(vm, slot);
+      } else closure->upvalues[i] = frame->upvalues[desc->index];
+    }
+  }
+
+  jsval_t func_obj = mkobj(js, 0);
+  closure->func_obj = func_obj;
+  js_setprop(js, func_obj, js->length_str, tov((double)child->param_count));
+  js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
+
+  jsval_t func_val = mkval(T_FUNC, (uintptr_t)closure);
+  if (!child->is_arrow && !child->is_method) {
+    (void)sv_setup_function_prototype(js, func_obj, func_val);
+  }
+
+  if (child->is_strict)
+    js_set_slot(js, func_obj, SLOT_STRICT, js_true);
+  if (child->is_arrow) {
+    js_set_slot(js, func_obj, SLOT_ARROW, js_true);
+    js_set_slot(js, func_obj, SLOT_BOUND_THIS, frame->this);
+  }
+  if (child->is_async) {
+    js_set_slot(js, func_obj, SLOT_ASYNC, js_true);
+    jsval_t async_proto = js_get_slot(js, js->global, SLOT_ASYNC_PROTO);
+    if (vtype(async_proto) == T_FUNC)
+      js_set_proto(js, func_obj, async_proto);
+  } else {
+    jsval_t func_proto = js_get_slot(js, js->global, SLOT_FUNC_PROTO);
+    if (vtype(func_proto) == T_FUNC)
+      js_set_proto(js, func_obj, func_proto);
+  }
+
+  vm->stack[vm->sp++] = func_val;
+}
+
+#endif
diff --git a/src/silver/swarm.c b/src/silver/swarm.c
new file mode 100644
index 0000000..ba2a462
--- /dev/null
+++ b/src/silver/swarm.c
@@ -0,0 +1,5351 @@
+#ifdef ANT_JIT
+
+#include "silver/swarm.h"
+#include "silver/glue.h"
+#include "silver/engine.h"
+#include "silver/opcode.h"
+
+#include "internal.h"
+#include "debug.h"
+
+#include <mir.h>
+#include <mir-gen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stddef.h>
+
+static const char *sv_op_name[] = {
+#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = #name,
+#include "silver/opcode.h"
+};
+
+typedef struct {
+  MIR_context_t ctx;
+} sv_jit_ctx_t;
+
+static sv_jit_ctx_t *jit_ctx_get(ant_t *js) {
+  return (sv_jit_ctx_t *)js->jit_ctx;
+}
+
+static void jit_ctx_set(ant_t *js, sv_jit_ctx_t *ctx) {
+  js->jit_ctx = ctx;
+}
+
+static void jit_ctx_remove(ant_t *js) {
+  js->jit_ctx = NULL;
+}
+
+void sv_jit_init(ant_t *js) {
+  if (jit_ctx_get(js)) return;
+  sv_jit_ctx_t *jc = calloc(1, sizeof(*jc));
+  if (!jc) return;
+  jc->ctx = MIR_init();
+  MIR_gen_init(jc->ctx);
+  MIR_gen_set_optimize_level(jc->ctx, 2);
+  jit_ctx_set(js, jc);
+}
+
+void sv_jit_destroy(ant_t *js) {
+  sv_jit_ctx_t *jc = jit_ctx_get(js);
+  if (!jc) return;
+  MIR_gen_finish(jc->ctx);
+  MIR_finish(jc->ctx);
+  free(jc);
+  jit_ctx_remove(js);
+}
+
+
+typedef struct {
+  MIR_reg_t   *regs;        
+  MIR_reg_t   *d_regs;      
+  sv_func_t  **known_func;  
+  uint8_t     *slot_type;    
+  int          sp;           
+  int          max;
+} jit_vstack_t;
+
+static MIR_reg_t vstack_push(jit_vstack_t *vs) {
+  if (vs->known_func) vs->known_func[vs->sp] = NULL;
+  if (vs->slot_type) vs->slot_type[vs->sp] = 0; 
+  return vs->regs[vs->sp++];
+}
+
+static MIR_reg_t vstack_pop(jit_vstack_t *vs) {
+  return vs->regs[--vs->sp];
+}
+
+static MIR_reg_t vstack_top(jit_vstack_t *vs) {
+  return vs->regs[vs->sp - 1];
+}
+
+
+#define MAX_LABELS 1024
+
+typedef struct {
+  int          bc_off;
+  MIR_label_t  label;
+  int          sp;     
+} jit_label_t;
+
+typedef struct {
+  jit_label_t entries[MAX_LABELS];
+  int         count;
+} jit_label_map_t;
+
+static MIR_label_t label_for_offset(MIR_context_t ctx, jit_label_map_t *lm,
+                                    int bc_off) {
+  for (int i = 0; i < lm->count; i++)
+    if (lm->entries[i].bc_off == bc_off) return lm->entries[i].label;
+  if (lm->count >= MAX_LABELS) return NULL;
+  MIR_label_t lbl = MIR_new_label(ctx);
+  lm->entries[lm->count].bc_off = bc_off;
+  lm->entries[lm->count].label  = lbl;
+  lm->entries[lm->count].sp     = -1;
+  lm->count++;
+  return lbl;
+}
+
+static void label_record_sp(jit_label_map_t *lm, int bc_off, int sp) {
+  for (int i = 0; i < lm->count; i++)
+    if (lm->entries[i].bc_off != bc_off) continue;
+    else { if (lm->entries[i].sp < 0) lm->entries[i].sp = sp; return; }
+}
+
+static MIR_label_t label_for_branch(MIR_context_t ctx, jit_label_map_t *lm,
+                                    int bc_off, int sp) {
+  MIR_label_t lbl = label_for_offset(ctx, lm, bc_off);
+  label_record_sp(lm, bc_off, sp);
+  return lbl;
+}
+
+
+#define MIR_JSVAL MIR_T_I64
+
+#define JIT_ERR_TAG ((NANBOX_PREFIX >> NANBOX_TYPE_SHIFT) | T_ERR)
+
+
+static void mir_i64_to_d(MIR_context_t ctx, MIR_item_t fn,
+                         MIR_reg_t dst_d, MIR_reg_t src_i64,
+                         MIR_reg_t slot) {
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_mem_op(ctx, MIR_T_I64, 0, slot, 0, 1),
+      MIR_new_reg_op(ctx, src_i64)));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_DMOV,
+      MIR_new_reg_op(ctx, dst_d),
+      MIR_new_mem_op(ctx, MIR_T_D, 0, slot, 0, 1)));
+}
+
+static void mir_d_to_i64(MIR_context_t ctx, MIR_item_t fn,
+                         MIR_reg_t dst_i64, MIR_reg_t src_d,
+                         MIR_reg_t slot) {
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_DMOV,
+      MIR_new_mem_op(ctx, MIR_T_D, 0, slot, 0, 1),
+      MIR_new_reg_op(ctx, src_d)));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_reg_op(ctx, dst_i64),
+      MIR_new_mem_op(ctx, MIR_T_I64, 0, slot, 0, 1)));
+}
+
+
+#define SLOT_BOXED 0
+#define SLOT_NUM   1
+
+static void vstack_ensure_boxed(jit_vstack_t *vs, int idx,
+                                MIR_context_t ctx, MIR_item_t fn,
+                                MIR_reg_t d_slot) {
+  if (!vs->slot_type || vs->slot_type[idx] != SLOT_NUM) return;
+  mir_d_to_i64(ctx, fn, vs->regs[idx], vs->d_regs[idx], d_slot);
+  vs->slot_type[idx] = SLOT_BOXED;
+}
+
+static void vstack_ensure_num(jit_vstack_t *vs, int idx,
+                              MIR_context_t ctx, MIR_item_t fn,
+                              MIR_reg_t d_slot) {
+  if (!vs->slot_type || vs->slot_type[idx] == SLOT_NUM) return;
+  mir_i64_to_d(ctx, fn, vs->d_regs[idx], vs->regs[idx], d_slot);
+  vs->slot_type[idx] = SLOT_NUM;
+}
+
+static void vstack_flush_to_boxed(jit_vstack_t *vs,
+                                  MIR_context_t ctx, MIR_item_t fn,
+                                  MIR_reg_t d_slot) {
+  if (!vs->slot_type) return;
+  for (int i = 0; i < vs->sp; i++)
+    vstack_ensure_boxed(vs, i, ctx, fn, d_slot);
+}
+
+static void mir_emit_bailout_check(MIR_context_t ctx, MIR_item_t fn,
+                                   MIR_reg_t res,
+                                   MIR_reg_t restore_val,
+                                   MIR_reg_t r_bailout_off, int bc_off,
+                                   MIR_reg_t r_bailout_sp,  int pre_op_sp,
+                                   MIR_label_t bailout_tramp,
+                                   MIR_reg_t r_args_buf,
+                                   jit_vstack_t *vs,
+                                   MIR_reg_t *local_regs, int n_locals,
+                                   MIR_reg_t r_lbuf,
+                                   MIR_reg_t r_d_slot) {
+  MIR_label_t no_bail = MIR_new_label(ctx);
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_BNE,
+      MIR_new_label_op(ctx, no_bail),
+      MIR_new_reg_op(ctx, res),
+      MIR_new_uint_op(ctx, (uint64_t)SV_JIT_BAILOUT)));
+  if (restore_val)
+    MIR_append_insn(ctx, fn,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_reg_op(ctx, res),
+        MIR_new_reg_op(ctx, restore_val)));
+  for (int i = 0; i < pre_op_sp; i++) {
+    if (vs->slot_type && vs->slot_type[i] == SLOT_NUM)
+      mir_d_to_i64(ctx, fn, vs->regs[i], vs->d_regs[i], r_d_slot);
+    MIR_append_insn(ctx, fn,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_mem_op(ctx, MIR_T_I64,
+          (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+        MIR_new_reg_op(ctx, vs->regs[i])));
+  }
+  for (int i = 0; i < n_locals; i++)
+    MIR_append_insn(ctx, fn,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_mem_op(ctx, MIR_T_I64,
+          (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+        MIR_new_reg_op(ctx, local_regs[i])));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_reg_op(ctx, r_bailout_off),
+      MIR_new_int_op(ctx, bc_off)));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_reg_op(ctx, r_bailout_sp),
+      MIR_new_int_op(ctx, pre_op_sp)));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_JMP,
+      MIR_new_label_op(ctx, bailout_tramp)));
+  MIR_append_insn(ctx, fn, no_bail);
+}
+
+
+static void mir_load_imm(MIR_context_t ctx, MIR_item_t fn,
+                         MIR_reg_t dst, uint64_t imm) {
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_reg_op(ctx, dst),
+      MIR_new_uint_op(ctx, imm)));
+}
+
+
+static inline bool jit_const_is_heap(jsval_t cv) {
+  uint8_t t = vtype(cv);
+  return ((1u << t) & GC_HEAP_TYPE_MASK) != 0;
+}
+
+
+static void mir_load_const_slot(MIR_context_t ctx, MIR_item_t fn,
+                                MIR_reg_t dst, jsval_t *slot) {
+  mir_load_imm(ctx, fn, dst, (uint64_t)(uintptr_t)slot);
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_reg_op(ctx, dst),
+      MIR_new_mem_op(ctx, MIR_T_I64, 0, dst, 0, 1)));
+}
+
+
+static void mir_call_helper2(MIR_context_t ctx, MIR_item_t fn,
+                             MIR_reg_t dst,
+                             MIR_item_t proto, MIR_item_t func_item,
+                             MIR_reg_t vm_reg, MIR_reg_t js_reg,
+                             MIR_reg_t arg0,  MIR_reg_t arg1) {
+  MIR_append_insn(ctx, fn,
+    MIR_new_call_insn(ctx, 7,
+      MIR_new_ref_op(ctx, proto),
+      MIR_new_ref_op(ctx, func_item),
+      MIR_new_reg_op(ctx, dst),
+      MIR_new_reg_op(ctx, vm_reg),
+      MIR_new_reg_op(ctx, js_reg),
+      MIR_new_reg_op(ctx, arg0),
+      MIR_new_reg_op(ctx, arg1)));
+}
+
+static void mir_emit_is_num_guard(MIR_context_t ctx, MIR_item_t fn,
+                                   MIR_reg_t r_bool, MIR_reg_t v,
+                                   MIR_label_t slow) {
+  (void)r_bool;
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_UBGT,
+      MIR_new_label_op(ctx, slow),
+      MIR_new_reg_op(ctx, v),
+      MIR_new_uint_op(ctx, NANBOX_PREFIX)));
+}
+
+#define NANBOX_TFUNC_TAG  ((NANBOX_PREFIX >> NANBOX_TYPE_SHIFT) | (uint64_t)T_FUNC)
+
+static void mir_emit_get_closure(MIR_context_t ctx, MIR_item_t fn,
+                                 MIR_reg_t dst, MIR_reg_t v,
+                                 MIR_reg_t r_tag, MIR_label_t fallback) {
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_URSH,
+      MIR_new_reg_op(ctx, r_tag),
+      MIR_new_reg_op(ctx, v),
+      MIR_new_uint_op(ctx, NANBOX_TYPE_SHIFT)));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_BNE,
+      MIR_new_label_op(ctx, fallback),
+      MIR_new_reg_op(ctx, r_tag),
+      MIR_new_uint_op(ctx, NANBOX_TFUNC_TAG)));
+  MIR_append_insn(ctx, fn,
+    MIR_new_insn(ctx, MIR_AND,
+      MIR_new_reg_op(ctx, dst),
+      MIR_new_reg_op(ctx, v),
+      MIR_new_uint_op(ctx, NANBOX_DATA_MASK)));
+}
+
+
+#define MAX_OSR_ENTRIES 64
+
+typedef struct {
+  int offsets[MAX_OSR_ENTRIES];
+  int count;
+} osr_entry_map_t;
+
+static void scan_osr_entries(sv_func_t *func, osr_entry_map_t *osr) {
+  osr->count = 0;
+  uint8_t *ip  = func->code;
+  uint8_t *end = func->code + func->code_len;
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) break;
+    int src = (int)(ip - func->code);
+    int target = -1;
+    switch (op) {
+      case OP_JMP:
+      case OP_JMP_FALSE:
+      case OP_JMP_TRUE:
+      case OP_JMP_FALSE_PEEK:
+      case OP_JMP_TRUE_PEEK:
+      case OP_JMP_NOT_NULLISH:
+        target = src + sz + sv_get_i32(ip + 1);
+        break;
+      case OP_JMP8:
+      case OP_JMP_FALSE8:
+      case OP_JMP_TRUE8:
+        target = src + sz + (int8_t)sv_get_i8(ip + 1);
+        break;
+      default: break;
+    }
+    if (target >= 0 && target < src) {
+      bool found = false;
+      for (int i = 0; i < osr->count; i++)
+        if (osr->offsets[i] == target) { found = true; break; }
+      if (!found && osr->count < MAX_OSR_ENTRIES)
+        osr->offsets[osr->count++] = target;
+    }
+    ip += sz;
+  }
+}
+
+static bool *scan_captured_locals(sv_func_t *func, int n_locals) {
+  if (n_locals <= 0) return NULL;
+  bool *captured = calloc((size_t)n_locals, sizeof(bool));
+  if (!captured) return NULL;
+  uint8_t *ip  = func->code;
+  uint8_t *end = func->code + func->code_len;
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) break;
+    if (op == OP_CLOSURE) {
+      uint32_t idx = sv_get_u32(ip + 1);
+      if (idx < (uint32_t)func->const_count) {
+        sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(func->constants[idx]);
+        for (int i = 0; i < child->upvalue_count; i++) {
+          sv_upval_desc_t *desc = &child->upval_descs[i];
+          if (desc->is_local) {
+            int li = (int)desc->index - func->param_count;
+            if (li >= 0 && li < n_locals)
+              captured[li] = true;
+          }
+        }
+      }
+    }
+    ip += sz;
+  }
+  return captured;
+}
+
+
+#define JIT_INLINE_MAX_BYTECODE 64
+
+static bool jit_inlineable(sv_func_t *f) {
+  if (!f) return false;
+  if (f->upvalue_count != 0) return false;
+  if (f->is_async || f->is_generator) return false;
+  if (f->code_len > JIT_INLINE_MAX_BYTECODE) return false;
+
+  uint8_t *ip  = f->code;
+  uint8_t *end = f->code + f->code_len;
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) return false;
+    switch (op) {
+      case OP_GET_ARG:
+      case OP_CONST_I8: case OP_CONST: case OP_CONST8:
+      case OP_UNDEF: case OP_NULL: case OP_TRUE: case OP_FALSE:
+      case OP_GET_LOCAL: case OP_GET_LOCAL8:
+      case OP_PUT_LOCAL: case OP_PUT_LOCAL8:
+      case OP_SET_LOCAL: case OP_SET_LOCAL8:
+      case OP_POP: case OP_DUP:
+      case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD:
+      case OP_LT:  case OP_LE:
+      case OP_RETURN: case OP_RETURN_UNDEF:
+      case OP_NOP: case OP_LINE_NUM: case OP_COL_NUM: case OP_LABEL:
+        break;
+      default:
+        return false;
+    }
+    ip += sz;
+  }
+  return true;
+}
+
+static bool jit_emit_inline_body(
+  MIR_context_t ctx, MIR_item_t jit_func,
+  sv_func_t *callee,
+  MIR_reg_t *arg_regs, int caller_argc,
+  MIR_reg_t result, MIR_label_t slow, MIR_label_t join,
+  MIR_reg_t r_bool, MIR_reg_t *p_d_slot, int id
+) {
+  int inl_max_stack = callee->max_stack > 0 ? callee->max_stack : 4;
+  MIR_reg_t inl_vs[inl_max_stack];
+  for (int i = 0; i < inl_max_stack; i++) {
+    char rn[32]; snprintf(rn, sizeof(rn), "inl%d_s%d", id, i);
+    inl_vs[i] = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, rn);
+  }
+  int isp = 0;
+
+  int inl_n_locals = callee->max_locals;
+  MIR_reg_t inl_locals[inl_n_locals > 0 ? inl_n_locals : 1];
+  for (int i = 0; i < inl_n_locals; i++) {
+    char rn[32]; snprintf(rn, sizeof(rn), "inl%d_l%d", id, i);
+    inl_locals[i] = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, rn);
+    mir_load_imm(ctx, jit_func, inl_locals[i], mkval(T_UNDEF, 0));
+  }
+
+  int inl_arith = 0;
+
+  uint8_t *ip  = callee->code;
+  uint8_t *end = callee->code + callee->code_len;
+
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+
+    switch (op) {
+      case OP_GET_ARG: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        MIR_reg_t dst = inl_vs[isp++];
+        if ((int)idx < caller_argc)
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, dst),
+              MIR_new_reg_op(ctx, arg_regs[idx])));
+        else
+          mir_load_imm(ctx, jit_func, dst, mkval(T_UNDEF, 0));
+        break;
+      }
+
+      case OP_CONST_I8: {
+        double d = (double)(int8_t)sv_get_i8(ip + 1);
+        union { double d; uint64_t u; } u = {d};
+        mir_load_imm(ctx, jit_func, inl_vs[isp++], u.u);
+        break;
+      }
+      case OP_CONST: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)callee->const_count) return false;
+        jsval_t cv = callee->constants[idx];
+        MIR_reg_t dst = inl_vs[isp++];
+        if (jit_const_is_heap(cv))
+          mir_load_const_slot(ctx, jit_func, dst, &callee->constants[idx]);
+        else
+          mir_load_imm(ctx, jit_func, dst, cv);
+        break;
+      }
+      case OP_CONST8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)callee->const_count) return false;
+        jsval_t cv = callee->constants[idx];
+        MIR_reg_t dst = inl_vs[isp++];
+        if (jit_const_is_heap(cv))
+          mir_load_const_slot(ctx, jit_func, dst, &callee->constants[idx]);
+        else
+          mir_load_imm(ctx, jit_func, dst, cv);
+        break;
+      }
+      case OP_UNDEF: mir_load_imm(ctx, jit_func, inl_vs[isp++], mkval(T_UNDEF, 0)); break;
+      case OP_NULL:  mir_load_imm(ctx, jit_func, inl_vs[isp++], mkval(T_NULL, 0));  break;
+      case OP_TRUE:  mir_load_imm(ctx, jit_func, inl_vs[isp++], js_true);  break;
+      case OP_FALSE: mir_load_imm(ctx, jit_func, inl_vs[isp++], js_false); break;
+
+      case OP_GET_LOCAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (idx >= (uint16_t)inl_n_locals) return false;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_vs[isp++]),
+            MIR_new_reg_op(ctx, inl_locals[idx])));
+        break;
+      }
+      case OP_GET_LOCAL8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)inl_n_locals) return false;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_vs[isp++]),
+            MIR_new_reg_op(ctx, inl_locals[idx])));
+        break;
+      }
+      case OP_PUT_LOCAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (idx >= (uint16_t)inl_n_locals) return false;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_locals[idx]),
+            MIR_new_reg_op(ctx, inl_vs[--isp])));
+        break;
+      }
+      case OP_PUT_LOCAL8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)inl_n_locals) return false;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_locals[idx]),
+            MIR_new_reg_op(ctx, inl_vs[--isp])));
+        break;
+      }
+      case OP_SET_LOCAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (idx >= (uint16_t)inl_n_locals) return false;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_locals[idx]),
+            MIR_new_reg_op(ctx, inl_vs[isp - 1])));
+        break;
+      }
+      case OP_SET_LOCAL8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)inl_n_locals) return false;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_locals[idx]),
+            MIR_new_reg_op(ctx, inl_vs[isp - 1])));
+        break;
+      }
+
+      case OP_POP: isp--; break;
+      case OP_DUP: {
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, inl_vs[isp]),
+            MIR_new_reg_op(ctx, inl_vs[isp - 1])));
+        isp++;
+        break;
+      }
+
+      case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: {
+        MIR_reg_t rr = inl_vs[--isp];
+        MIR_reg_t rl = inl_vs[--isp];
+        MIR_reg_t rd = inl_vs[isp++];
+
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+
+        if (!*p_d_slot) {
+          *p_d_slot = MIR_new_func_reg(ctx, jit_func->u.func,
+                                       MIR_T_I64, "d_slot_inl");
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_ALLOCA,
+              MIR_new_reg_op(ctx, *p_d_slot),
+              MIR_new_uint_op(ctx, 8)));
+        }
+
+        int an = inl_arith++;
+        char d1[32], d2[32], d3[32];
+        snprintf(d1, sizeof(d1), "inl%d_fd1_%d", id, an);
+        snprintf(d2, sizeof(d2), "inl%d_fd2_%d", id, an);
+        snprintf(d3, sizeof(d3), "inl%d_fd3_%d", id, an);
+        MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+        MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+        MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+
+        mir_i64_to_d(ctx, jit_func, fd1, rl, *p_d_slot);
+        mir_i64_to_d(ctx, jit_func, fd2, rr, *p_d_slot);
+
+        MIR_insn_code_t mir_op;
+        switch (op) {
+          case OP_ADD: mir_op = MIR_DADD; break;
+          case OP_SUB: mir_op = MIR_DSUB; break;
+          case OP_MUL: mir_op = MIR_DMUL; break;
+          default:     mir_op = MIR_DDIV; break;
+        }
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, mir_op,
+            MIR_new_reg_op(ctx, fd3),
+            MIR_new_reg_op(ctx, fd1),
+            MIR_new_reg_op(ctx, fd2)));
+        mir_d_to_i64(ctx, jit_func, rd, fd3, *p_d_slot);
+        break;
+      }
+
+      case OP_LT: case OP_LE: {
+        MIR_reg_t rr = inl_vs[--isp];
+        MIR_reg_t rl = inl_vs[--isp];
+        MIR_reg_t rd = inl_vs[isp++];
+
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+
+        if (!*p_d_slot) {
+          *p_d_slot = MIR_new_func_reg(ctx, jit_func->u.func,
+                                       MIR_T_I64, "d_slot_inl");
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_ALLOCA,
+              MIR_new_reg_op(ctx, *p_d_slot),
+              MIR_new_uint_op(ctx, 8)));
+        }
+
+        int cn = inl_arith++;
+        char cd1[32], cd2[32];
+        snprintf(cd1, sizeof(cd1), "inl%d_cd1_%d", id, cn);
+        snprintf(cd2, sizeof(cd2), "inl%d_cd2_%d", id, cn);
+        MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, cd1);
+        MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, cd2);
+        mir_i64_to_d(ctx, jit_func, fd1, rl, *p_d_slot);
+        mir_i64_to_d(ctx, jit_func, fd2, rr, *p_d_slot);
+
+        char cmp_rn[32];
+        snprintf(cmp_rn, sizeof(cmp_rn), "inl%d_%s_%d", id,
+                 op == OP_LT ? "lt" : "le", cn);
+        MIR_reg_t r_tmp = MIR_new_func_reg(ctx, jit_func->u.func,
+                                            MIR_T_I64, cmp_rn);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, op == OP_LT ? MIR_DLT : MIR_DLE,
+            MIR_new_reg_op(ctx, r_tmp),
+            MIR_new_reg_op(ctx, fd1),
+            MIR_new_reg_op(ctx, fd2)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_OR,
+            MIR_new_reg_op(ctx, rd),
+            MIR_new_uint_op(ctx, js_false),
+            MIR_new_reg_op(ctx, r_tmp)));
+        break;
+      }
+
+      case OP_RETURN: {
+        MIR_reg_t ret = inl_vs[--isp];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, result),
+            MIR_new_reg_op(ctx, ret)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, join)));
+        break;
+      }
+      case OP_RETURN_UNDEF:
+        mir_load_imm(ctx, jit_func, result, mkval(T_UNDEF, 0));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, join)));
+        break;
+
+      case OP_NOP: case OP_LINE_NUM: case OP_COL_NUM: case OP_LABEL:
+        break;
+
+      default:
+        return false;
+    }
+    ip += sz;
+  }
+  return true;
+}
+
+static void scan_branch_targets(sv_func_t *func, jit_label_map_t *lm,
+                                MIR_context_t ctx) {
+  uint8_t *ip   = func->code;
+  uint8_t *end  = func->code + func->code_len;
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) break;
+    switch (op) {
+      case OP_JMP:
+      case OP_JMP_FALSE:
+      case OP_JMP_TRUE:
+      case OP_JMP_FALSE_PEEK:
+      case OP_JMP_TRUE_PEEK:
+      case OP_JMP_NOT_NULLISH:
+      case OP_TRY_PUSH:
+      case OP_CATCH:
+      case OP_FINALLY: {
+        int off = (int)(ip - func->code) + sv_get_i32(ip + 1) + sz;
+        label_for_offset(ctx, lm, off);
+        break;
+      }
+      case OP_JMP8:
+      case OP_JMP_FALSE8:
+      case OP_JMP_TRUE8: {
+        int off = (int)(ip - func->code) + (int8_t)sv_get_i8(ip + 1) + sz;
+        label_for_offset(ctx, lm, off);
+        break;
+      }
+      default: break;
+    }
+    ip += sz;
+  }
+}
+
+
+typedef struct {
+  bool needs_bailout;      
+  bool needs_inc_local;    
+  bool needs_args_buf;     
+  bool needs_close_upval;  
+  bool needs_args_norm;    
+} jit_features_t;
+
+static jit_features_t jit_prescan_features(sv_func_t *func) {
+  jit_features_t f = {false, false, false, false, false};
+  uint8_t *ip  = func->code;
+  uint8_t *end = func->code + func->code_len;
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) break;
+    switch (op) {
+      case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD:
+      case OP_NEG:
+      case OP_LT:  case OP_LE:  case OP_GT:  case OP_GE:
+      case OP_BAND: case OP_BOR: case OP_BXOR: case OP_BNOT:
+      case OP_SHL:  case OP_SHR: case OP_USHR:
+      case OP_TYPEOF:
+      case OP_ADD_LOCAL:
+        f.needs_bailout = true;
+        break;
+      case OP_INC_LOCAL: case OP_DEC_LOCAL:
+        f.needs_inc_local = true; 
+        break;
+      case OP_CALL: case OP_CALL_METHOD:
+      case OP_TAIL_CALL: case OP_TAIL_CALL_METHOD:
+      case OP_ARRAY: case OP_NEW:
+        f.needs_args_buf = true;
+        break;
+      case OP_CLOSE_UPVAL: case OP_CLOSURE:
+        f.needs_close_upval = true;
+        break;
+      case OP_GET_ARG:
+      case OP_SET_ARG:
+        f.needs_args_norm = true;
+        break;
+      default: break;
+    }
+    ip += sz;
+  }
+  if (f.needs_bailout) f.needs_args_buf = true;
+  return f;
+}
+
+static bool jit_is_eligible(sv_func_t *func) {
+  if (func->is_async || func->is_generator) return false;
+
+  bool eligible = true;
+  uint8_t *ip  = func->code;
+  uint8_t *end = func->code + func->code_len;
+  while (ip < end) {
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) return false;
+    switch (op) {
+      case OP_CONST_I8: case OP_CONST: case OP_CONST8:
+      case OP_UNDEF: case OP_NULL: case OP_TRUE: case OP_FALSE:
+      case OP_THIS:
+      case OP_GET_ARG: case OP_SET_ARG:
+      case OP_GET_LOCAL:  case OP_PUT_LOCAL:  case OP_SET_LOCAL:
+      case OP_GET_LOCAL8: case OP_PUT_LOCAL8: case OP_SET_LOCAL8:
+      case OP_SET_LOCAL_UNDEF:                  
+      case OP_GET_UPVAL: case OP_PUT_UPVAL: case OP_SET_UPVAL:
+      case OP_CLOSE_UPVAL:
+      case OP_POP: case OP_DUP: case OP_DUP2:
+      case OP_INSERT2: case OP_INSERT3:
+      case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD:
+      case OP_NEG: case OP_IS_UNDEF: case OP_IS_NULL:
+      case OP_LT:  case OP_LE:  case OP_GT:  case OP_GE:
+      case OP_NE:  case OP_SNE:
+      case OP_BAND: case OP_BOR: case OP_BXOR: case OP_BNOT:
+      case OP_SHL:  case OP_SHR: case OP_USHR:
+      case OP_NOT: case OP_TYPEOF: case OP_VOID:
+      case OP_DELETE:
+      case OP_INSTANCEOF:
+      case OP_NEW:
+      case OP_JMP: case OP_JMP8:
+      case OP_JMP_FALSE:  case OP_JMP_FALSE8:
+      case OP_JMP_TRUE:   case OP_JMP_TRUE8:
+      case OP_CALL: case OP_CALL_METHOD:
+      case OP_TAIL_CALL: case OP_TAIL_CALL_METHOD:
+      case OP_GET_GLOBAL: case OP_GET_GLOBAL_UNDEF:
+      case OP_PUT_GLOBAL:
+      case OP_GET_FIELD: case OP_GET_FIELD2: case OP_PUT_FIELD:
+      case OP_GET_ELEM: case OP_GET_ELEM2: case OP_PUT_ELEM:
+      case OP_OBJECT: case OP_ARRAY: case OP_SET_PROTO:
+      case OP_SWAP: case OP_ROT3L:
+      case OP_IN: case OP_GET_LENGTH:
+      case OP_DEFINE_FIELD: case OP_SEQ: case OP_EQ:
+      case OP_INC_LOCAL: case OP_DEC_LOCAL: case OP_ADD_LOCAL:
+      case OP_TO_PROPKEY:
+      case OP_RETURN: case OP_RETURN_UNDEF:
+      case OP_CLOSURE: case OP_SET_NAME:
+      case OP_TRY_PUSH: case OP_TRY_POP:
+      case OP_THROW: case OP_THROW_ERROR:
+      case OP_CATCH: case OP_NIP_CATCH:
+      case OP_NOP: case OP_HALT:
+      case OP_LINE_NUM: case OP_COL_NUM: case OP_LABEL:
+        break;
+      case OP_SPECIAL_OBJ:
+        if (sv_get_u8(ip + 1) != 1) {
+          if (sv_jit_warn_unlikely)
+            fprintf(stderr, "jit: ineligible op SPECIAL_OBJ(%d) in %s\n",
+                    sv_get_u8(ip + 1),
+                    func->name ? func->name : "<anonymous>");
+          eligible = false;
+        }
+        break;
+      default:
+        if (sv_jit_warn_unlikely)
+          fprintf(stderr, "jit: ineligible op %s in %s\n",
+                  (op < OP__COUNT && sv_op_name[op]) ? sv_op_name[op] : "???",
+                  func->name ? func->name : "<anonymous>");
+        eligible = false;
+        break;
+    }
+    ip += sz;
+  }
+  return eligible;
+}
+
+sv_jit_func_t sv_jit_compile(ant_t *js, sv_func_t *func, sv_closure_t *hint_closure) {
+  if (func->jit_compile_failed) return NULL;
+  if (func->jit_code == NULL && func->jit_compiled_tfb_ver != 0 &&
+      func->tfb_version == func->jit_compiled_tfb_ver) {
+    func->jit_compile_failed = true;
+    return NULL;
+  }
+  if (!jit_is_eligible(func)) { func->jit_compile_failed = true; return NULL; }
+
+  sv_jit_ctx_t *jc = jit_ctx_get(js);
+  if (!jc) { sv_jit_init(js); jc = jit_ctx_get(js); }
+  if (!jc) return NULL;
+
+  MIR_context_t ctx = jc->ctx;
+
+  char fname[128];
+  snprintf(fname, sizeof(fname), "jit_%s_%p",
+           func->name ? func->name : "anon", (void *)func);
+
+  MIR_module_t mod = MIR_new_module(ctx, fname);
+
+  MIR_type_t ret_type = MIR_JSVAL;
+
+  MIR_item_t self_proto = MIR_new_proto(ctx, "jit_proto",
+    1, &ret_type,
+    5,
+    MIR_T_I64, "vm",
+    MIR_JSVAL,  "this_val",
+    MIR_T_P,    "args",
+    MIR_T_I32,  "argc",
+    MIR_T_P,    "closure");
+  MIR_type_t h2_ret = MIR_JSVAL;
+  MIR_item_t helper2_proto = MIR_new_proto(ctx, "helper2_proto",
+    1, &h2_ret,
+    4,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "l",
+    MIR_JSVAL,  "r");
+
+  MIR_type_t call_ret = MIR_JSVAL;
+  MIR_item_t call_proto = MIR_new_proto(ctx, "call_proto",
+    1, &call_ret,
+    6,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js_p",
+    MIR_JSVAL,  "func",
+    MIR_JSVAL,  "this_val",
+    MIR_T_P,    "args",
+    MIR_T_I32,  "argc");
+
+  MIR_type_t gg_ret = MIR_JSVAL;
+  MIR_item_t gg_proto = MIR_new_proto(ctx, "gg_proto",
+    1, &gg_ret, 3,
+    MIR_T_I64, "js",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len");
+
+  MIR_type_t gf_ret = MIR_JSVAL;
+  MIR_item_t gf_proto = MIR_new_proto(ctx, "gf_proto",
+    1, &gf_ret, 7,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "obj",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len",
+    MIR_T_P,   "func",
+    MIR_T_I32, "bc_off");
+
+  MIR_type_t ge_ret = MIR_JSVAL;
+  MIR_item_t ge_proto = MIR_new_proto(ctx, "ge_proto",
+    1, &ge_ret, 6,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL, "obj",
+    MIR_JSVAL, "key",
+    MIR_T_P,   "func",
+    MIR_T_I32, "bc_off");
+
+  MIR_type_t h1_ret = MIR_JSVAL;
+  MIR_item_t helper1_proto = MIR_new_proto(ctx, "helper1_proto",
+    1, &h1_ret, 3,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "v");
+
+  MIR_type_t truthy_ret = MIR_T_I64;
+  MIR_item_t truthy_proto = MIR_new_proto(ctx, "truthy_proto",
+    1, &truthy_ret, 2,
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "v");
+
+  MIR_type_t br_ret = MIR_JSVAL;
+  MIR_item_t resume_proto = MIR_new_proto(ctx, "resume_proto",
+    1, &br_ret, 10,
+    MIR_T_I64,  "vm",
+    MIR_T_P,    "closure",
+    MIR_JSVAL,  "this_val",
+    MIR_T_P,    "args",
+    MIR_T_I32,  "argc",
+    MIR_T_P,    "vstack",
+    MIR_T_I64,  "vstack_sp",
+    MIR_T_P,    "locals",
+    MIR_T_I64,  "n_locals",
+    MIR_T_I64,  "bc_offset");
+
+  MIR_type_t cl_ret = MIR_JSVAL;
+  MIR_item_t closure_proto = MIR_new_proto(ctx, "closure_proto",
+    1, &cl_ret, 9,
+    MIR_T_I64,  "vm",
+    MIR_T_I64,  "js",
+    MIR_T_P,    "parent",
+    MIR_JSVAL,  "this_val",
+    MIR_T_P,    "args",
+    MIR_T_I32,  "argc",
+    MIR_T_I32,  "const_idx",
+    MIR_T_P,    "locals",
+    MIR_T_I32,  "n_locals");
+
+  MIR_item_t close_upval_proto = MIR_new_proto(ctx, "close_upval_proto",
+    0, NULL, 4,
+    MIR_T_I64, "vm",
+    MIR_T_I32, "slot_idx",
+    MIR_T_P,   "locals",
+    MIR_T_I32, "n_locals");
+
+  MIR_item_t set_name_proto = MIR_new_proto(ctx, "sn_proto",
+    0, NULL, 5,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "fn",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len");
+
+  MIR_type_t so_ret = MIR_T_I64;
+  MIR_item_t stack_ovf_proto = MIR_new_proto(ctx, "so_proto",
+    1, &so_ret, 1,
+    MIR_T_I64, "js");
+
+  MIR_type_t soe_ret = MIR_JSVAL;
+  MIR_item_t stack_ovf_err_proto = MIR_new_proto(ctx, "soe_proto",
+    1, &soe_ret, 2,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js");
+
+  MIR_item_t define_field_proto = MIR_new_proto(ctx, "df_proto",
+    0, NULL, 6,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "obj",
+    MIR_JSVAL,  "val",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len");
+
+  MIR_type_t pf_ret = MIR_JSVAL;
+  MIR_item_t put_field_proto = MIR_new_proto(ctx, "pf_proto",
+    1, &pf_ret, 6,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "obj",
+    MIR_JSVAL,  "val",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len");
+
+  MIR_type_t pe_ret = MIR_JSVAL;
+  MIR_item_t put_elem_proto = MIR_new_proto(ctx, "pe_proto",
+    1, &pe_ret, 5,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "obj",
+    MIR_JSVAL,  "key",
+    MIR_JSVAL,  "val");
+
+  MIR_type_t pg_ret = MIR_JSVAL;
+  MIR_item_t put_global_proto = MIR_new_proto(ctx, "pg_proto",
+    1, &pg_ret, 6,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "val",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len",
+    MIR_T_I32, "strict");
+
+  MIR_type_t obj_ret = MIR_JSVAL;
+  MIR_item_t object_proto = MIR_new_proto(ctx, "obj_proto",
+    1, &obj_ret, 2,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js");
+
+  MIR_type_t arr_ret = MIR_JSVAL;
+  MIR_item_t array_proto = MIR_new_proto(ctx, "arr_proto",
+    1, &arr_ret, 4,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_T_P,   "elements",
+    MIR_T_I32, "count");
+
+  MIR_type_t te_ret = MIR_JSVAL;
+  MIR_item_t throw_error_proto = MIR_new_proto(ctx, "te_proto",
+    1, &te_ret, 5,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_T_P,   "str",
+    MIR_T_I32, "len",
+    MIR_T_I32, "err_type");
+
+  MIR_type_t nw_ret = MIR_JSVAL;
+  MIR_item_t new_proto = MIR_new_proto(ctx, "new_proto",
+    1, &nw_ret, 6,
+    MIR_T_I64, "vm",
+    MIR_T_I64, "js",
+    MIR_JSVAL,  "func",
+    MIR_JSVAL,  "new_target",
+    MIR_T_P,    "args",
+    MIR_T_I32,  "argc");
+
+  MIR_item_t imp_add   = MIR_new_import(ctx, "jit_helper_add");
+  MIR_item_t imp_sub   = MIR_new_import(ctx, "jit_helper_sub");
+  MIR_item_t imp_mul   = MIR_new_import(ctx, "jit_helper_mul");
+  MIR_item_t imp_div   = MIR_new_import(ctx, "jit_helper_div");
+  MIR_item_t imp_mod   = MIR_new_import(ctx, "jit_helper_mod");
+  MIR_item_t imp_lt    = MIR_new_import(ctx, "jit_helper_lt");
+  MIR_item_t imp_le    = MIR_new_import(ctx, "jit_helper_le");
+  MIR_item_t imp_gt    = MIR_new_import(ctx, "jit_helper_gt");
+  MIR_item_t imp_ge    = MIR_new_import(ctx, "jit_helper_ge");
+  MIR_item_t imp_call  = MIR_new_import(ctx, "jit_helper_call");
+  MIR_item_t imp_tov   = MIR_new_import(ctx, "jit_helper_tov");
+  MIR_item_t imp_gg         = MIR_new_import(ctx, "jit_helper_get_global");
+  MIR_item_t imp_get_field  = MIR_new_import(ctx, "jit_helper_get_field");
+  MIR_item_t imp_to_propkey = MIR_new_import(ctx, "jit_helper_to_propkey");
+  MIR_item_t imp_resume     = MIR_new_import(ctx, "jit_helper_bailout_resume");
+  MIR_item_t imp_close_upval = MIR_new_import(ctx, "jit_helper_close_upval");
+  MIR_item_t imp_closure     = MIR_new_import(ctx, "jit_helper_closure");
+  MIR_item_t imp_in          = MIR_new_import(ctx, "jit_helper_in");
+  MIR_item_t imp_get_length  = MIR_new_import(ctx, "jit_helper_get_length");
+  MIR_item_t imp_define_field = MIR_new_import(ctx, "jit_helper_define_field");
+  MIR_item_t imp_seq         = MIR_new_import(ctx, "jit_helper_seq");
+  MIR_item_t imp_eq          = MIR_new_import(ctx, "jit_helper_eq");
+  MIR_item_t imp_ne          = MIR_new_import(ctx, "jit_helper_ne");
+  MIR_item_t imp_sne         = MIR_new_import(ctx, "jit_helper_sne");
+  MIR_item_t imp_put_field   = MIR_new_import(ctx, "jit_helper_put_field");
+  MIR_item_t imp_get_elem    = MIR_new_import(ctx, "jit_helper_get_elem");
+  MIR_item_t imp_put_elem    = MIR_new_import(ctx, "jit_helper_put_elem");
+  MIR_item_t imp_put_global  = MIR_new_import(ctx, "jit_helper_put_global");
+  MIR_item_t imp_object      = MIR_new_import(ctx, "jit_helper_object");
+  MIR_item_t imp_array       = MIR_new_import(ctx, "jit_helper_array");
+  MIR_item_t imp_catch_value = MIR_new_import(ctx, "jit_helper_catch_value");
+  MIR_item_t imp_throw       = MIR_new_import(ctx, "jit_helper_throw");
+  MIR_item_t imp_throw_error = MIR_new_import(ctx, "jit_helper_throw_error");
+  MIR_item_t imp_set_proto   = MIR_new_import(ctx, "jit_helper_set_proto");
+  MIR_item_t imp_get_elem2   = MIR_new_import(ctx, "jit_helper_get_elem2");
+  MIR_item_t imp_band        = MIR_new_import(ctx, "jit_helper_band");
+  MIR_item_t imp_bor         = MIR_new_import(ctx, "jit_helper_bor");
+  MIR_item_t imp_bxor        = MIR_new_import(ctx, "jit_helper_bxor");
+  MIR_item_t imp_bnot        = MIR_new_import(ctx, "jit_helper_bnot");
+  MIR_item_t imp_shl         = MIR_new_import(ctx, "jit_helper_shl");
+  MIR_item_t imp_shr         = MIR_new_import(ctx, "jit_helper_shr");
+  MIR_item_t imp_ushr        = MIR_new_import(ctx, "jit_helper_ushr");
+  MIR_item_t imp_not         = MIR_new_import(ctx, "jit_helper_not");
+  MIR_item_t imp_is_truthy   = MIR_new_import(ctx, "jit_helper_is_truthy");
+  MIR_item_t imp_typeof      = MIR_new_import(ctx, "jit_helper_typeof");
+  MIR_item_t imp_new         = MIR_new_import(ctx, "jit_helper_new");
+  MIR_item_t imp_instanceof  = MIR_new_import(ctx, "jit_helper_instanceof");
+  MIR_item_t imp_delete      = MIR_new_import(ctx, "jit_helper_delete");
+  MIR_item_t imp_set_name   = MIR_new_import(ctx, "jit_helper_set_name");
+  MIR_item_t imp_stack_ovf      = MIR_new_import(ctx, "jit_helper_stack_overflow");
+  MIR_item_t imp_stack_ovf_err  = MIR_new_import(ctx, "jit_helper_stack_overflow_error");
+  (void)imp_tov;
+
+  MIR_item_t jit_func = MIR_new_func(ctx, fname,
+    1, &ret_type,
+    5,
+    MIR_T_I64, "vm",
+    MIR_JSVAL,  "this_val",
+    MIR_T_P,    "args",
+    MIR_T_I32,  "argc",
+    MIR_T_P,    "closure");
+
+  MIR_reg_t r_vm       = MIR_reg(ctx, "vm",       jit_func->u.func);
+  MIR_reg_t r_this     = MIR_reg(ctx, "this_val", jit_func->u.func);
+  MIR_reg_t r_args     = MIR_reg(ctx, "args",     jit_func->u.func);
+  MIR_reg_t r_argc     = MIR_reg(ctx, "argc",     jit_func->u.func);
+  MIR_reg_t r_closure  = MIR_reg(ctx, "closure",  jit_func->u.func);
+
+  MIR_reg_t r_js = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "js_ptr");
+  MIR_append_insn(ctx, jit_func,
+    MIR_new_insn(ctx, MIR_MOV,
+      MIR_new_reg_op(ctx, r_js),
+      MIR_new_mem_op(ctx, MIR_T_I64, 0, r_vm, 0, 1)));
+
+  {
+    MIR_reg_t r_ovf = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "stk_ovf");
+    MIR_label_t no_overflow = MIR_new_label(ctx);
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_call_insn(ctx, 4,
+        MIR_new_ref_op(ctx, stack_ovf_proto),
+        MIR_new_ref_op(ctx, imp_stack_ovf),
+        MIR_new_reg_op(ctx, r_ovf),
+        MIR_new_reg_op(ctx, r_js)));
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_BEQ,
+        MIR_new_label_op(ctx, no_overflow),
+        MIR_new_reg_op(ctx, r_ovf),
+        MIR_new_int_op(ctx, 0)));
+    MIR_reg_t r_ovf_err = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, "stk_err");
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_call_insn(ctx, 5,
+        MIR_new_ref_op(ctx, stack_ovf_err_proto),
+        MIR_new_ref_op(ctx, imp_stack_ovf_err),
+        MIR_new_reg_op(ctx, r_ovf_err),
+        MIR_new_reg_op(ctx, r_vm),
+        MIR_new_reg_op(ctx, r_js)));
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_ovf_err)));
+    MIR_append_insn(ctx, jit_func, no_overflow);
+  }
+
+  jit_vstack_t vs = {0};
+  vs.max = func->max_stack > 0 ? func->max_stack : 32;
+  vs.regs = calloc((size_t)vs.max, sizeof(MIR_reg_t));
+  vs.known_func = calloc((size_t)vs.max, sizeof(sv_func_t *));
+  vs.d_regs = calloc((size_t)vs.max, sizeof(MIR_reg_t));
+  vs.slot_type = calloc((size_t)vs.max, sizeof(uint8_t));
+  if (!vs.regs || !vs.known_func || !vs.d_regs || !vs.slot_type) {
+    free(vs.regs); free(vs.known_func); free(vs.d_regs); free(vs.slot_type);
+    MIR_finish_func(ctx); MIR_finish_module(ctx); return NULL;
+  }
+
+  for (int i = 0; i < vs.max; i++) {
+    char rname[32];
+    snprintf(rname, sizeof(rname), "s%d", i);
+    vs.regs[i] = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, rname);
+  }
+  for (int i = 0; i < vs.max; i++) {
+    char dname[32];
+    snprintf(dname, sizeof(dname), "sd%d", i);
+    vs.d_regs[i] = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, dname);
+  }
+
+  int n_locals = func->max_locals;
+  MIR_reg_t *local_regs = NULL;
+  sv_func_t **known_func_locals = NULL;
+  if (n_locals > 0) {
+    local_regs = calloc((size_t)n_locals, sizeof(MIR_reg_t));
+    known_func_locals = calloc((size_t)n_locals, sizeof(sv_func_t *));
+    if (!local_regs) { free(vs.regs); free(vs.known_func); free(vs.d_regs); free(vs.slot_type); free(known_func_locals); MIR_finish_func(ctx); MIR_finish_module(ctx); return NULL; }
+    for (int i = 0; i < n_locals; i++) {
+      char rname[32];
+      snprintf(rname, sizeof(rname), "l%d", i);
+      local_regs[i] = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, rname);
+      mir_load_imm(ctx, jit_func, local_regs[i],
+                   mkval(T_UNDEF, 0));
+    }
+  }
+
+  MIR_reg_t r_tmp  = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, "tmp");
+  MIR_reg_t r_tmp2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, "tmp2");
+  MIR_reg_t r_bool = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "bool_tmp");
+  MIR_reg_t r_err_tmp = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, "err_tmp");
+  (void)r_tmp2;
+
+  jit_features_t feat = jit_prescan_features(func);
+
+
+  MIR_reg_t r_d_slot = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "d_slot");
+  MIR_append_insn(ctx, jit_func,
+    MIR_new_insn(ctx, MIR_ALLOCA,
+      MIR_new_reg_op(ctx, r_d_slot),
+      MIR_new_uint_op(ctx, 8)));
+
+  MIR_reg_t r_d_one = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, "d_one");
+  if (feat.needs_inc_local) {
+    union { double d; uint64_t u; } one = {1.0};
+    mir_load_imm(ctx, jit_func, r_bool, one.u);
+    mir_i64_to_d(ctx, jit_func, r_d_one, r_bool, r_d_slot);
+  }
+
+  MIR_reg_t r_args_buf = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "args_buf");
+  if (feat.needs_args_buf) {
+    int scratch_slots = 16;
+    if (vs.max > scratch_slots)  scratch_slots = vs.max;
+    if (n_locals > scratch_slots) scratch_slots = n_locals;
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_ALLOCA,
+        MIR_new_reg_op(ctx, r_args_buf),
+        MIR_new_uint_op(ctx, (uint64_t)scratch_slots * sizeof(jsval_t))));
+  } else {
+    mir_load_imm(ctx, jit_func, r_args_buf, 0);
+  }
+
+  MIR_reg_t r_cond_d = 0, r_cond_nan = 0, r_cond_zd = 0, r_cond_zero = 0;
+
+  bool needs_bailout = feat.needs_bailout;
+
+  MIR_reg_t   r_bailout_val = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, "bail_val");
+  MIR_reg_t   r_bailout_off = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "bail_off");
+  MIR_reg_t   r_bailout_sp  = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "bail_sp");
+  MIR_label_t bailout_tramp = needs_bailout ? MIR_new_label(ctx) : NULL;
+
+  bool needs_lbuf = needs_bailout || feat.needs_close_upval;
+  MIR_reg_t r_lbuf = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "lbuf");
+  if (needs_lbuf && n_locals > 0) {
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_ALLOCA,
+        MIR_new_reg_op(ctx, r_lbuf),
+        MIR_new_uint_op(ctx, (uint64_t)n_locals * sizeof(jsval_t))));
+  } else {
+    mir_load_imm(ctx, jit_func, r_lbuf, 0);
+  }
+
+  bool *captured_locals = scan_captured_locals(func, n_locals);
+  bool has_captures = false;
+  if (captured_locals) {
+    for (int i = 0; i < n_locals; i++)
+      if (captured_locals[i]) { has_captures = true; break; }
+  }
+  if (has_captures) {
+    for (int i = 0; i < n_locals; i++) {
+      if (captured_locals[i])
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_mem_op(ctx, MIR_T_I64,
+              (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+            MIR_new_uint_op(ctx, mkval(T_UNDEF, 0))));
+    }
+  }
+
+  int param_count = func->param_count;
+  if (param_count > 0 && feat.needs_args_norm) {
+    MIR_label_t args_ok = MIR_new_label(ctx);
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_UBGE,
+        MIR_new_label_op(ctx, args_ok),
+        MIR_new_reg_op(ctx, r_argc),
+        MIR_new_int_op(ctx, (int64_t)param_count)));
+    MIR_reg_t r_arg_local = MIR_new_func_reg(ctx, jit_func->u.func,
+                                              MIR_T_I64, "arg_local");
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_ALLOCA,
+        MIR_new_reg_op(ctx, r_arg_local),
+        MIR_new_uint_op(ctx, (uint64_t)param_count * sizeof(jsval_t))));
+    for (int i = 0; i < param_count; i++)
+      MIR_append_insn(ctx, jit_func,
+        MIR_new_insn(ctx, MIR_MOV,
+          MIR_new_mem_op(ctx, MIR_T_I64,
+            (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_arg_local, 0, 1),
+          MIR_new_uint_op(ctx, mkval(T_UNDEF, 0))));
+    for (int i = 0; i < param_count; i++) {
+      MIR_label_t copy_skip = MIR_new_label(ctx);
+      MIR_append_insn(ctx, jit_func,
+        MIR_new_insn(ctx, MIR_UBLE,
+          MIR_new_label_op(ctx, copy_skip),
+          MIR_new_reg_op(ctx, r_argc),
+          MIR_new_int_op(ctx, (int64_t)i)));
+      MIR_append_insn(ctx, jit_func,
+        MIR_new_insn(ctx, MIR_MOV,
+          MIR_new_mem_op(ctx, MIR_T_I64,
+            (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_arg_local, 0, 1),
+          MIR_new_mem_op(ctx, MIR_T_I64,
+            (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args, 0, 1)));
+      MIR_append_insn(ctx, jit_func, copy_skip);
+    }
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_reg_op(ctx, r_args),
+        MIR_new_reg_op(ctx, r_arg_local)));
+    MIR_append_insn(ctx, jit_func, args_ok);
+  }
+
+  jit_label_map_t lm = {0};
+  scan_branch_targets(func, &lm, ctx);
+
+  osr_entry_map_t osr_map = {0};
+  scan_osr_entries(func, &osr_map);
+  if (osr_map.count > 0) {
+    MIR_label_t normal_entry = MIR_new_label(ctx);
+
+    MIR_disp_t osr_base = (MIR_disp_t)offsetof(struct sv_vm, jit_osr);
+
+    MIR_reg_t r_osr_active = MIR_new_func_reg(ctx, jit_func->u.func,
+                                               MIR_T_I64, "osr_active");
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_reg_op(ctx, r_osr_active),
+        MIR_new_mem_op(ctx, MIR_T_U8,
+          osr_base + (MIR_disp_t)offsetof(sv_jit_osr_t, active),
+          r_vm, 0, 1)));
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_BEQ,
+        MIR_new_label_op(ctx, normal_entry),
+        MIR_new_reg_op(ctx, r_osr_active),
+        MIR_new_int_op(ctx, 0)));
+
+    MIR_reg_t r_osr_locals = MIR_new_func_reg(ctx, jit_func->u.func,
+                                               MIR_T_I64, "osr_locals");
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_reg_op(ctx, r_osr_locals),
+        MIR_new_mem_op(ctx, MIR_T_P,
+          osr_base + (MIR_disp_t)offsetof(sv_jit_osr_t, locals),
+          r_vm, 0, 1)));
+
+    for (int i = 0; i < n_locals; i++)
+      MIR_append_insn(ctx, jit_func,
+        MIR_new_insn(ctx, MIR_MOV,
+          MIR_new_reg_op(ctx, local_regs[i]),
+          MIR_new_mem_op(ctx, MIR_JSVAL,
+            (MIR_disp_t)(i * (int)sizeof(jsval_t)),
+            r_osr_locals, 0, 1)));
+
+    if (has_captures) {
+      MIR_append_insn(ctx, jit_func,
+        MIR_new_insn(ctx, MIR_MOV,
+          MIR_new_reg_op(ctx, r_lbuf),
+          MIR_new_mem_op(ctx, MIR_T_P,
+            osr_base + (MIR_disp_t)offsetof(sv_jit_osr_t, lp),
+            r_vm, 0, 1)));
+    }
+
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_mem_op(ctx, MIR_T_U8,
+          osr_base + (MIR_disp_t)offsetof(sv_jit_osr_t, active),
+          r_vm, 0, 1),
+        MIR_new_int_op(ctx, 0)));
+
+    MIR_reg_t r_osr_off = MIR_new_func_reg(ctx, jit_func->u.func,
+                                            MIR_T_I64, "osr_off");
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_insn(ctx, MIR_MOV,
+        MIR_new_reg_op(ctx, r_osr_off),
+        MIR_new_mem_op(ctx, MIR_T_I32,
+          osr_base + (MIR_disp_t)offsetof(sv_jit_osr_t, bc_offset),
+          r_vm, 0, 1)));
+
+    for (int i = 0; i < osr_map.count; i++) {
+      MIR_label_t target_lbl = label_for_offset(ctx, &lm, osr_map.offsets[i]);
+      MIR_append_insn(ctx, jit_func,
+        MIR_new_insn(ctx, MIR_BEQ,
+          MIR_new_label_op(ctx, target_lbl),
+          MIR_new_reg_op(ctx, r_osr_off),
+          MIR_new_int_op(ctx, osr_map.offsets[i])));
+    }
+
+    MIR_append_insn(ctx, jit_func, normal_entry);
+  }
+
+#define JIT_TRY_MAX 16
+  typedef struct {
+    MIR_label_t catch_label;
+    int catch_bc_off;
+    int saved_sp;
+  } jit_try_entry_t;
+
+  jit_try_entry_t jit_try_stack[JIT_TRY_MAX];
+  int jit_try_depth = 0;
+
+  typedef struct { int bc_off; int saved_sp; } jit_catch_sp_t;
+  jit_catch_sp_t catch_sp_map[JIT_TRY_MAX];
+  int catch_sp_count = 0;
+
+  MIR_label_t self_tail_entry = MIR_new_label(ctx);
+  MIR_append_insn(ctx, jit_func, self_tail_entry);
+
+
+  MIR_reg_t r_result = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, "result");
+  mir_load_imm(ctx, jit_func, r_result, mkval(T_UNDEF, 0));
+
+  uint8_t *ip  = func->code;
+  uint8_t *end = func->code + func->code_len;
+
+  bool ok = true; 
+  int  call_n  = 0; 
+  int  upval_n = 0; 
+  int  arith_n = 0; 
+
+  while (ip < end) {
+    int bc_off = (int)(ip - func->code);
+    sv_op_t op = (sv_op_t)*ip;
+    int sz = sv_op_size[op];
+    if (sz == 0) { ok = false; break; }
+
+    for (int i = 0; i < lm.count; i++) {
+      if (lm.entries[i].bc_off == bc_off) {
+        MIR_append_insn(ctx, jit_func, lm.entries[i].label);
+        if (lm.entries[i].sp >= 0)
+          vs.sp = lm.entries[i].sp;
+        if (vs.slot_type)
+          memset(vs.slot_type, SLOT_BOXED, (size_t)vs.max);
+      }
+    }
+
+    switch (op) {
+
+      case OP_CONST_I8: {
+        double d = (double)(int8_t)sv_get_i8(ip + 1);
+        union { double d; uint64_t u; } u = {d};
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_load_imm(ctx, jit_func, dst, u.u);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DMOV,
+            MIR_new_reg_op(ctx, vs.d_regs[vs.sp - 1]),
+            MIR_new_double_op(ctx, d)));
+        vs.slot_type[vs.sp - 1] = SLOT_NUM;
+        break;
+      }
+
+      case OP_CONST: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->const_count) { ok = false; break; }
+        jsval_t cv = func->constants[idx];
+        MIR_reg_t dst = vstack_push(&vs);
+        if (jit_const_is_heap(cv))
+          mir_load_const_slot(ctx, jit_func, dst, &func->constants[idx]);
+        else {
+          mir_load_imm(ctx, jit_func, dst, cv);
+          if (vtype(cv) == T_NUM) {
+            union { uint64_t u; double d; } u = {cv};
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_DMOV,
+                MIR_new_reg_op(ctx, vs.d_regs[vs.sp - 1]),
+                MIR_new_double_op(ctx, u.d)));
+            vs.slot_type[vs.sp - 1] = SLOT_NUM;
+          }
+        }
+        break;
+      }
+
+      case OP_CONST8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)func->const_count) { ok = false; break; }
+        jsval_t cv = func->constants[idx];
+        MIR_reg_t dst = vstack_push(&vs);
+        if (jit_const_is_heap(cv))
+          mir_load_const_slot(ctx, jit_func, dst, &func->constants[idx]);
+        else {
+          mir_load_imm(ctx, jit_func, dst, cv);
+          if (vtype(cv) == T_NUM) {
+            union { uint64_t u; double d; } u = {cv};
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_DMOV,
+                MIR_new_reg_op(ctx, vs.d_regs[vs.sp - 1]),
+                MIR_new_double_op(ctx, u.d)));
+            vs.slot_type[vs.sp - 1] = SLOT_NUM;
+          }
+        }
+        break;
+      }
+
+      case OP_UNDEF:
+        mir_load_imm(ctx, jit_func, vstack_push(&vs), mkval(T_UNDEF, 0));
+        break;
+      case OP_NULL:
+        mir_load_imm(ctx, jit_func, vstack_push(&vs), mkval(T_NULL, 0));
+        break;
+      case OP_TRUE:
+        mir_load_imm(ctx, jit_func, vstack_push(&vs), js_true);
+        break;
+      case OP_FALSE:
+        mir_load_imm(ctx, jit_func, vstack_push(&vs), js_false);
+        break;
+
+      case OP_THIS: {
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_this)));
+        break;
+      }
+
+      case OP_GET_ARG: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_mem_op(ctx, MIR_JSVAL,
+              (MIR_disp_t)(idx * (int)sizeof(jsval_t)),
+              r_args, 0, 1)));
+        break;
+      }
+
+      case OP_SET_ARG: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        MIR_reg_t val = vstack_top(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_mem_op(ctx, MIR_JSVAL,
+              (MIR_disp_t)(idx * (int)sizeof(jsval_t)),
+              r_args, 0, 1),
+            MIR_new_reg_op(ctx, val)));
+        break;
+      }
+
+      case OP_GET_LOCAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (idx >= (uint16_t)n_locals) { ok = false; break; }
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, local_regs[idx]),
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+        MIR_reg_t dst = vstack_push(&vs);
+        if (known_func_locals) vs.known_func[vs.sp - 1] = known_func_locals[idx];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, local_regs[idx])));
+        break;
+      }
+      case OP_GET_LOCAL8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)n_locals) { ok = false; break; }
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, local_regs[idx]),
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+        MIR_reg_t dst = vstack_push(&vs);
+        if (known_func_locals) vs.known_func[vs.sp - 1] = known_func_locals[idx];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, local_regs[idx])));
+        break;
+      }
+
+      case OP_PUT_LOCAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (idx >= (uint16_t)n_locals) { ok = false; break; }
+        sv_func_t *kf = vs.known_func[vs.sp - 1];
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t src = vstack_pop(&vs);
+        if (known_func_locals) known_func_locals[idx] = kf;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, local_regs[idx]),
+            MIR_new_reg_op(ctx, src)));
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, src)));
+        break;
+      }
+      case OP_PUT_LOCAL8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)n_locals) { ok = false; break; }
+        sv_func_t *kf = vs.known_func[vs.sp - 1];
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t src = vstack_pop(&vs);
+        if (known_func_locals) known_func_locals[idx] = kf;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, local_regs[idx]),
+            MIR_new_reg_op(ctx, src)));
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, src)));
+        break;
+      }
+
+      case OP_SET_LOCAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (idx >= (uint16_t)n_locals) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t src = vstack_top(&vs);
+        if (known_func_locals) known_func_locals[idx] = vs.known_func[vs.sp - 1];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, local_regs[idx]),
+            MIR_new_reg_op(ctx, src)));
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, src)));
+        break;
+      }
+      case OP_SET_LOCAL8: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)n_locals) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t src = vstack_top(&vs);
+        if (known_func_locals) known_func_locals[idx] = vs.known_func[vs.sp - 1];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, local_regs[idx]),
+            MIR_new_reg_op(ctx, src)));
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, src)));
+        break;
+      }
+
+      case OP_SET_LOCAL_UNDEF:
+        break;
+
+      case OP_POP:
+        vstack_pop(&vs);
+        break;
+
+      case OP_DUP: {
+        sv_func_t *kf = vs.known_func[vs.sp - 1];
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t top = vstack_top(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        vs.known_func[vs.sp - 1] = kf;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, top)));
+        break;
+      }
+
+      case OP_DUP2: {
+        if (vs.sp < 2) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 2, ctx, jit_func, r_d_slot);
+        MIR_reg_t ra = vs.regs[vs.sp - 2];
+        MIR_reg_t rb = vs.regs[vs.sp - 1];
+        MIR_reg_t da = vstack_push(&vs);
+        MIR_reg_t db = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, da),
+            MIR_new_reg_op(ctx, ra)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, db),
+            MIR_new_reg_op(ctx, rb)));
+        break;
+      }
+
+      case OP_INSERT2: {
+        if (vs.sp < 2) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 2, ctx, jit_func, r_d_slot);
+        MIR_reg_t r_a   = vs.regs[vs.sp - 1];
+        MIR_reg_t r_obj = vs.regs[vs.sp - 2];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_tmp),
+            MIR_new_reg_op(ctx, r_a)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, vs.regs[vs.sp - 1]),
+            MIR_new_reg_op(ctx, r_obj)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, vs.regs[vs.sp - 2]),
+            MIR_new_reg_op(ctx, r_tmp)));
+        MIR_reg_t dup = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dup),
+            MIR_new_reg_op(ctx, r_tmp)));
+        break;
+      }
+
+      case OP_INSERT3: {
+        if (vs.sp < 3) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 2, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 3, ctx, jit_func, r_d_slot);
+        MIR_reg_t r_a    = vs.regs[vs.sp - 1];
+        MIR_reg_t r_prop = vs.regs[vs.sp - 2];
+        MIR_reg_t r_obj  = vs.regs[vs.sp - 3];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_tmp),
+            MIR_new_reg_op(ctx, r_a)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, vs.regs[vs.sp - 1]),
+            MIR_new_reg_op(ctx, r_prop)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, vs.regs[vs.sp - 2]),
+            MIR_new_reg_op(ctx, r_obj)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, vs.regs[vs.sp - 3]),
+            MIR_new_reg_op(ctx, r_tmp)));
+        MIR_reg_t dup = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dup),
+            MIR_new_reg_op(ctx, r_tmp)));
+        break;
+      }
+
+      case OP_ADD: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];     
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1]; 
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DADD,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DADD,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else if (fb_num_only) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, bail_direct);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, bail_direct);
+          int an = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "add_d1_%d", an);
+          snprintf(d2, sizeof(d2), "add_d2_%d", an);
+          snprintf(d3, sizeof(d3), "add_d3_%d", an);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DADD,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int an = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "add_d1_%d", an);
+          snprintf(d2, sizeof(d2), "add_d2_%d", an);
+          snprintf(d3, sizeof(d3), "add_d3_%d", an);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DADD,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_add,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_SUB: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_sub,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DSUB,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DSUB,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else if (fb_num_only) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, bail_direct);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, bail_direct);
+          int sn = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "sub_d1_%d", sn);
+          snprintf(d2, sizeof(d2), "sub_d2_%d", sn);
+          snprintf(d3, sizeof(d3), "sub_d3_%d", sn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DSUB,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int sn = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "sub_d1_%d", sn);
+          snprintf(d2, sizeof(d2), "sub_d2_%d", sn);
+          snprintf(d3, sizeof(d3), "sub_d3_%d", sn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DSUB,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_sub, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_MUL: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_mul,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DMUL,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DMUL,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else if (fb_num_only) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, bail_direct);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, bail_direct);
+          int mn = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "mul_d1_%d", mn);
+          snprintf(d2, sizeof(d2), "mul_d2_%d", mn);
+          snprintf(d3, sizeof(d3), "mul_d3_%d", mn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DMUL,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int mn = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "mul_d1_%d", mn);
+          snprintf(d2, sizeof(d2), "mul_d2_%d", mn);
+          snprintf(d3, sizeof(d3), "mul_d3_%d", mn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DMUL,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_mul, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_DIV: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_div,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DDIV,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_r   = vs.d_regs[vs.sp];
+          MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DDIV,
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_dst),
+              MIR_new_reg_op(ctx, fd_r)));
+          vs.slot_type[vs.sp - 1] = SLOT_NUM;
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else if (fb_num_only) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, bail_direct);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, bail_direct);
+          int dn = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "dv_d1_%d", dn);
+          snprintf(d2, sizeof(d2), "dv_d2_%d", dn);
+          snprintf(d3, sizeof(d3), "dv_d3_%d", dn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DDIV,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int dn = arith_n++;
+          char d1[32], d2[32], d3[32];
+          snprintf(d1, sizeof(d1), "dv_d1_%d", dn);
+          snprintf(d2, sizeof(d2), "dv_d2_%d", dn);
+          snprintf(d3, sizeof(d3), "dv_d3_%d", dn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d3);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DDIV,
+              MIR_new_reg_op(ctx, fd3),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          mir_d_to_i64(ctx, jit_func, rd, fd3, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_div, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_MOD: {
+        vstack_flush_to_boxed(&vs, ctx, jit_func, r_d_slot);
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_val),
+            MIR_new_reg_op(ctx, rl)));
+        mir_call_helper2(ctx, jit_func, rd,
+                         helper2_proto, imp_mod, r_vm, r_js, rl, rr);
+        mir_emit_bailout_check(ctx, jit_func, rd,
+          r_bailout_val, r_bailout_off, bc_off,
+          r_bailout_sp, vs.sp + 1, bailout_tramp,
+          r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        break;
+      }
+
+      case OP_NEG: {
+        MIR_reg_t rs = vstack_top(&vs);  
+        MIR_label_t slow = MIR_new_label(ctx);
+        MIR_label_t done = MIR_new_label(ctx);
+
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, rs, slow);
+
+        int nn = arith_n++;
+        char neg_d1[32], neg_d2[32];
+        snprintf(neg_d1, sizeof(neg_d1), "neg_d1_%d", nn);
+        snprintf(neg_d2, sizeof(neg_d2), "neg_d2_%d", nn);
+        MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, neg_d1);
+        MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, neg_d2);
+        mir_i64_to_d(ctx, jit_func, fd1, rs, r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DNEG,
+            MIR_new_reg_op(ctx, fd2),
+            MIR_new_reg_op(ctx, fd1)));
+        mir_d_to_i64(ctx, jit_func, rs, fd2, r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+
+        MIR_append_insn(ctx, jit_func, slow);
+        for (int i = 0; i < vs.sp; i++) {
+          if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+            mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+              MIR_new_reg_op(ctx, vs.regs[i])));
+        }
+        for (int i = 0; i < n_locals; i++)
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, local_regs[i])));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_off),
+            MIR_new_int_op(ctx, bc_off)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_sp),
+            MIR_new_int_op(ctx, vs.sp)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP,
+            MIR_new_label_op(ctx, bailout_tramp)));
+
+        MIR_append_insn(ctx, jit_func, done);
+        break;
+      }
+
+      case OP_IS_UNDEF:
+      case OP_IS_NULL: {
+        MIR_reg_t rs = vstack_top(&vs);
+        uint64_t cmp_val = (op == OP_IS_UNDEF) ? mkval(T_UNDEF, 0) : mkval(T_NULL, 0);
+        MIR_label_t is_true = MIR_new_label(ctx);
+        MIR_label_t is_done = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, is_true),
+            MIR_new_reg_op(ctx, rs),
+            MIR_new_uint_op(ctx, cmp_val)));
+        mir_load_imm(ctx, jit_func, rs, js_false);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, is_done)));
+        MIR_append_insn(ctx, jit_func, is_true);
+        mir_load_imm(ctx, jit_func, rs, js_true);
+        MIR_append_insn(ctx, jit_func, is_done);
+        break;
+      }
+
+      case OP_LT: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_lt,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else if (fb_num_only) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, bail_direct);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, bail_direct);
+          int ltn = arith_n++;
+          char d1[32], d2[32];
+          snprintf(d1, sizeof(d1), "lt_d1_%d", ltn);
+          snprintf(d2, sizeof(d2), "lt_d2_%d", ltn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int ltn = arith_n++;
+          char d1[32], d2[32];
+          snprintf(d1, sizeof(d1), "lt_d1_%d", ltn);
+          snprintf(d2, sizeof(d2), "lt_d2_%d", ltn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_lt, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_LE: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_le,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else if (fb_num_only) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, bail_direct);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, bail_direct);
+          int len = arith_n++;
+          char d1[32], d2[32];
+          snprintf(d1, sizeof(d1), "le_d1_%d", len);
+          snprintf(d2, sizeof(d2), "le_d2_%d", len);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int len = arith_n++;
+          char d1[32], d2[32];
+          snprintf(d1, sizeof(d1), "le_d1_%d", len);
+          snprintf(d2, sizeof(d2), "le_d2_%d", len);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DLE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_le, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_JMP:
+      case OP_JMP8: {
+        vstack_flush_to_boxed(&vs, ctx, jit_func, r_d_slot);
+        bool short_op = (op == OP_JMP8);
+        int target = bc_off + sz + (short_op ? (int8_t)sv_get_i8(ip + 1)
+                                              : sv_get_i32(ip + 1));
+        MIR_label_t lbl = label_for_branch(ctx, &lm, target, vs.sp);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl)));
+        break;
+      }
+
+      case OP_JMP_FALSE:
+      case OP_JMP_FALSE8:
+      case OP_JMP_TRUE:
+      case OP_JMP_TRUE8: {
+        vstack_flush_to_boxed(&vs, ctx, jit_func, r_d_slot);
+        MIR_reg_t cond = vstack_pop(&vs);
+        bool short_op = (op == OP_JMP_FALSE8 || op == OP_JMP_TRUE8);
+        bool is_false_branch = (op == OP_JMP_FALSE || op == OP_JMP_FALSE8);
+        int target = bc_off + sz + (short_op ? (int8_t)sv_get_i8(ip + 1)
+                                             : sv_get_i32(ip + 1));
+        MIR_label_t lbl = label_for_branch(ctx, &lm, target, vs.sp);
+        MIR_label_t lbl_not_bool = MIR_new_label(ctx);
+        MIR_label_t lbl_not_num  = MIR_new_label(ctx);
+        MIR_label_t lbl_done     = MIR_new_label(ctx);
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, cond),
+            MIR_new_uint_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, lbl_not_bool),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, js_false >> NANBOX_TYPE_SHIFT)));
+        uint64_t cmp_bool = is_false_branch ? js_false : js_true;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl),
+            MIR_new_reg_op(ctx, cond),
+            MIR_new_uint_op(ctx, cmp_bool)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl_done)));
+
+        MIR_append_insn(ctx, jit_func, lbl_not_bool);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_UBGT,
+            MIR_new_label_op(ctx, lbl_not_num),
+            MIR_new_reg_op(ctx, cond),
+            MIR_new_uint_op(ctx, NANBOX_PREFIX)));
+        if (!r_d_slot) {
+          r_d_slot = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "d_slot_cond");
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_ALLOCA,
+              MIR_new_reg_op(ctx, r_d_slot),
+              MIR_new_uint_op(ctx, 8)));
+        }
+        if (!r_cond_d) {
+          r_cond_d    = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D,   "cond_d");
+          r_cond_nan  = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "cond_nan");
+          r_cond_zd   = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D,   "zero_d");
+          r_cond_zero = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, "cond_zero");
+        }
+        mir_i64_to_d(ctx, jit_func, r_cond_d, cond, r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DNE,    
+            MIR_new_reg_op(ctx, r_cond_nan),
+            MIR_new_reg_op(ctx, r_cond_d),
+            MIR_new_reg_op(ctx, r_cond_d)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DMOV,
+            MIR_new_reg_op(ctx, r_cond_zd),
+            MIR_new_double_op(ctx, 0.0)));
+        MIR_reg_t r_is_zero = r_cond_zero;
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DEQ,    
+            MIR_new_reg_op(ctx, r_is_zero),
+            MIR_new_reg_op(ctx, r_cond_d),
+            MIR_new_reg_op(ctx, r_cond_zd)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_OR,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_is_zero),
+            MIR_new_reg_op(ctx, r_cond_nan)));
+        if (is_false_branch) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_BNE,   
+              MIR_new_label_op(ctx, lbl),
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_uint_op(ctx, 0)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_BEQ,   
+              MIR_new_label_op(ctx, lbl),
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_uint_op(ctx, 0)));
+        }
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl_done)));
+
+        MIR_append_insn(ctx, jit_func, lbl_not_num);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 5,
+            MIR_new_ref_op(ctx, truthy_proto),
+            MIR_new_ref_op(ctx, imp_is_truthy),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, cond)));
+        if (is_false_branch) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_BEQ,
+              MIR_new_label_op(ctx, lbl),
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_uint_op(ctx, 0)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_BNE,
+              MIR_new_label_op(ctx, lbl),
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_uint_op(ctx, 0)));
+        }
+        MIR_append_insn(ctx, jit_func, lbl_done);
+        break;
+      }
+
+      case OP_TAIL_CALL:
+      case OP_CALL: {
+        vstack_flush_to_boxed(&vs, ctx, jit_func, r_d_slot);
+        bool is_tail = (op == OP_TAIL_CALL);
+        uint16_t call_argc = sv_get_u16(ip + 1);
+        if (call_argc > 16 || vs.sp < (int)call_argc + 1) { ok = false; break; }
+
+        if (!is_tail) {
+          sv_func_t *inline_callee = vs.known_func[vs.sp - call_argc - 1];
+          if (inline_callee && jit_inlineable(inline_callee)) {
+            int cn = call_n++;
+
+            MIR_reg_t inl_arg_regs[call_argc > 0 ? call_argc : 1];
+            for (int i = (int)call_argc - 1; i >= 0; i--)
+              inl_arg_regs[i] = vstack_pop(&vs);
+            MIR_reg_t r_inl_callee = vstack_pop(&vs); 
+
+            MIR_reg_t r_call_res = vstack_push(&vs);
+
+            MIR_label_t inl_slow = MIR_new_label(ctx);
+            MIR_label_t inl_join = MIR_new_label(ctx);
+
+            bool inlined = jit_emit_inline_body(
+              ctx, jit_func, inline_callee,
+              inl_arg_regs, (int)call_argc,
+              r_call_res, inl_slow, inl_join,
+              r_bool, &r_d_slot, cn);
+
+            if (inlined) {
+              MIR_append_insn(ctx, jit_func, inl_slow);
+              for (int i = 0; i < (int)call_argc; i++)
+                MIR_append_insn(ctx, jit_func,
+                  MIR_new_insn(ctx, MIR_MOV,
+                    MIR_new_mem_op(ctx, MIR_JSVAL,
+                      (MIR_disp_t)(i * (int)sizeof(jsval_t)),
+                      r_args_buf, 0, 1),
+                    MIR_new_reg_op(ctx, inl_arg_regs[i])));
+
+              char rn_sl_this[32];
+              snprintf(rn_sl_this, sizeof(rn_sl_this), "inl%d_slow_t", cn);
+              MIR_reg_t r_slow_this = MIR_new_func_reg(ctx, jit_func->u.func,
+                                                        MIR_JSVAL, rn_sl_this);
+              mir_load_imm(ctx, jit_func, r_slow_this, mkval(T_UNDEF, 0));
+
+              MIR_append_insn(ctx, jit_func,
+                MIR_new_call_insn(ctx, 9,
+                  MIR_new_ref_op(ctx, call_proto),
+                  MIR_new_ref_op(ctx, imp_call),
+                  MIR_new_reg_op(ctx, r_call_res),
+                  MIR_new_reg_op(ctx, r_vm),
+                  MIR_new_reg_op(ctx, r_js),
+                  MIR_new_reg_op(ctx, r_inl_callee),
+                  MIR_new_reg_op(ctx, r_slow_this),
+                  MIR_new_reg_op(ctx, r_args_buf),
+                  MIR_new_int_op(ctx, (int64_t)call_argc)));
+
+              MIR_append_insn(ctx, jit_func, inl_join);
+              break;
+            }
+
+            vs.sp = vs.sp - 1 + call_argc + 1;
+          }
+        }
+
+        int cn = call_n++;
+
+        char rn_arr[32], rn_this[32], rn_ccl[32], rn_cfn[32], rn_jptr[32];
+        snprintf(rn_arr,  sizeof(rn_arr),  "arg_arr%d",       cn);
+        snprintf(rn_this, sizeof(rn_this), "call_this%d",     cn);
+        snprintf(rn_ccl,  sizeof(rn_ccl),  "callee_cl%d",     cn);
+        snprintf(rn_cfn,  sizeof(rn_cfn),  "callee_func%d",   cn);
+        snprintf(rn_jptr, sizeof(rn_jptr), "jit_ptr%d",       cn);
+
+        MIR_reg_t r_arg_arr = r_args_buf;
+
+        for (int i = (int)call_argc - 1; i >= 0; i--) {
+          MIR_reg_t areg = vstack_pop(&vs);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_JSVAL,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)),
+                r_arg_arr, 0, 1),
+              MIR_new_reg_op(ctx, areg)));
+        }
+
+        sv_func_t *call_known = vs.known_func
+          ? vs.known_func[vs.sp - 1] : NULL;
+
+        MIR_reg_t r_call_func = vstack_pop(&vs);
+        MIR_reg_t r_call_this = MIR_new_func_reg(ctx, jit_func->u.func, MIR_JSVAL, rn_this);
+        mir_load_imm(ctx, jit_func, r_call_this, mkval(T_UNDEF, 0));
+
+        MIR_reg_t r_call_res = vstack_push(&vs);
+
+        if (call_known == func) {
+          if (is_tail && jit_try_depth == 0) {
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_reg_op(ctx, r_args),
+                MIR_new_reg_op(ctx, r_arg_arr)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_reg_op(ctx, r_argc),
+                MIR_new_int_op(ctx, (int64_t)call_argc)));
+            for (int i = 0; i < n_locals; i++)
+              mir_load_imm(ctx, jit_func, local_regs[i], mkval(T_UNDEF, 0));
+            if (has_captures) {
+              for (int i = 0; i < n_locals; i++)
+                if (captured_locals[i])
+                  MIR_append_insn(ctx, jit_func,
+                    MIR_new_insn(ctx, MIR_MOV,
+                      MIR_new_mem_op(ctx, MIR_T_I64,
+                        (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                      MIR_new_uint_op(ctx, mkval(T_UNDEF, 0))));
+            }
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_JMP,
+                MIR_new_label_op(ctx, self_tail_entry)));
+            break;
+          }
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_call_insn(ctx, 8,
+              MIR_new_ref_op(ctx, self_proto),
+              MIR_new_ref_op(ctx, jit_func),
+              MIR_new_reg_op(ctx, r_call_res),
+              MIR_new_reg_op(ctx, r_vm),
+              MIR_new_reg_op(ctx, r_call_this),
+              MIR_new_reg_op(ctx, r_arg_arr),
+              MIR_new_int_op(ctx, (int64_t)call_argc),
+              MIR_new_reg_op(ctx, r_closure)));
+          if (has_captures) {
+            for (int i = 0; i < n_locals; i++)
+              if (captured_locals[i])
+                MIR_append_insn(ctx, jit_func,
+                  MIR_new_insn(ctx, MIR_MOV,
+                    MIR_new_reg_op(ctx, local_regs[i]),
+                    MIR_new_mem_op(ctx, MIR_T_I64,
+                      (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+          }
+          if (jit_try_depth > 0) {
+            jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+            MIR_label_t no_err = MIR_new_label(ctx);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_URSH,
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_reg_op(ctx, r_call_res),
+                MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_BNE,
+                MIR_new_label_op(ctx, no_err),
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_reg_op(ctx, r_result),
+                MIR_new_reg_op(ctx, r_call_res)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_JMP,
+                MIR_new_label_op(ctx, h->catch_label)));
+            MIR_append_insn(ctx, jit_func, no_err);
+          } else {
+            MIR_label_t no_err = MIR_new_label(ctx);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_URSH,
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_reg_op(ctx, r_call_res),
+                MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_BNE,
+                MIR_new_label_op(ctx, no_err),
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+            MIR_append_insn(ctx, jit_func, no_err);
+          }
+          break;
+        }
+
+        MIR_label_t lbl_self_call   = MIR_new_label(ctx);
+        MIR_label_t lbl_interp_call = MIR_new_label(ctx);
+        MIR_label_t lbl_call_done   = MIR_new_label(ctx);
+
+        MIR_reg_t r_callee_cl = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_ccl);
+        mir_emit_get_closure(ctx, jit_func, r_callee_cl, r_call_func,
+                             r_bool, lbl_interp_call);
+
+        MIR_reg_t r_callee_fn = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_cfn);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_callee_fn),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_closure_t, func),
+              r_callee_cl, 0, 1)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl_interp_call),
+            MIR_new_reg_op(ctx, r_callee_fn),
+            MIR_new_int_op(ctx, 0)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl_self_call),
+            MIR_new_reg_op(ctx, r_callee_cl),
+            MIR_new_reg_op(ctx, r_closure)));
+
+        MIR_reg_t r_jit_ptr = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_jptr);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_jit_ptr),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_func_t, jit_code),
+              r_callee_fn, 0, 1)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl_interp_call),
+            MIR_new_reg_op(ctx, r_jit_ptr),
+            MIR_new_int_op(ctx, 0)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 8,
+            MIR_new_ref_op(ctx, self_proto),
+            MIR_new_reg_op(ctx, r_jit_ptr),   
+            MIR_new_reg_op(ctx, r_call_res),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_call_this),
+            MIR_new_reg_op(ctx, r_arg_arr),
+            MIR_new_int_op(ctx, (int64_t)call_argc),
+            MIR_new_reg_op(ctx, r_callee_cl)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl_call_done)));
+
+        MIR_append_insn(ctx, jit_func, lbl_self_call);
+        if (is_tail && jit_try_depth == 0) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_args),
+              MIR_new_reg_op(ctx, r_arg_arr)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_argc),
+              MIR_new_int_op(ctx, (int64_t)call_argc)));
+          for (int i = 0; i < n_locals; i++)
+            mir_load_imm(ctx, jit_func, local_regs[i], mkval(T_UNDEF, 0));
+          if (has_captures) {
+            for (int i = 0; i < n_locals; i++)
+              if (captured_locals[i])
+                MIR_append_insn(ctx, jit_func,
+                  MIR_new_insn(ctx, MIR_MOV,
+                    MIR_new_mem_op(ctx, MIR_T_I64,
+                      (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                    MIR_new_uint_op(ctx, mkval(T_UNDEF, 0))));
+          }
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, self_tail_entry)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_call_insn(ctx, 8,
+              MIR_new_ref_op(ctx, self_proto),
+              MIR_new_ref_op(ctx, jit_func),    
+              MIR_new_reg_op(ctx, r_call_res),
+              MIR_new_reg_op(ctx, r_vm),
+              MIR_new_reg_op(ctx, r_call_this),
+              MIR_new_reg_op(ctx, r_arg_arr),
+              MIR_new_int_op(ctx, (int64_t)call_argc),
+              MIR_new_reg_op(ctx, r_closure)));
+        }
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl_call_done)));
+
+        MIR_append_insn(ctx, jit_func, lbl_interp_call);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 9,
+            MIR_new_ref_op(ctx, call_proto),
+            MIR_new_ref_op(ctx, imp_call),
+            MIR_new_reg_op(ctx, r_call_res),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, r_call_func),
+            MIR_new_reg_op(ctx, r_call_this),
+            MIR_new_reg_op(ctx, r_arg_arr),
+            MIR_new_int_op(ctx, (int64_t)call_argc)));
+
+        MIR_append_insn(ctx, jit_func, lbl_call_done);
+        if (is_tail && jit_try_depth == 0) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+        } else {
+          if (has_captures) {
+            for (int i = 0; i < n_locals; i++)
+              if (captured_locals[i])
+                MIR_append_insn(ctx, jit_func,
+                  MIR_new_insn(ctx, MIR_MOV,
+                    MIR_new_reg_op(ctx, local_regs[i]),
+                    MIR_new_mem_op(ctx, MIR_T_I64,
+                      (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+          }
+          if (jit_try_depth > 0) {
+            jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+            MIR_label_t no_err = MIR_new_label(ctx);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_URSH,
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_reg_op(ctx, r_call_res),
+                MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_BNE,
+                MIR_new_label_op(ctx, no_err),
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+                MIR_new_reg_op(ctx, r_call_res)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_JMP,
+                MIR_new_label_op(ctx, h->catch_label)));
+            MIR_append_insn(ctx, jit_func, no_err);
+          } else {
+            MIR_label_t no_err = MIR_new_label(ctx);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_URSH,
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_reg_op(ctx, r_call_res),
+                MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_BNE,
+                MIR_new_label_op(ctx, no_err),
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+            MIR_append_insn(ctx, jit_func, no_err);
+          }
+          if (is_tail) {
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+          }
+        }
+        break;
+      }
+
+      case OP_SPECIAL_OBJ:
+        mir_load_imm(ctx, jit_func, vstack_push(&vs), mkval(T_UNDEF, 0));
+        break;
+
+      case OP_GET_UPVAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+
+        if (vs.known_func && hint_closure &&
+            idx < (uint16_t)func->upvalue_count &&
+            hint_closure->upvalues && hint_closure->upvalues[idx]) {
+          jsval_t uv_val = *hint_closure->upvalues[idx]->location;
+          if (vtype(uv_val) == T_FUNC) {
+            sv_closure_t *ucl = js_func_closure(uv_val);
+            if (ucl && ucl->func == func) {
+              MIR_reg_t dst = vstack_push(&vs);
+              vs.known_func[vs.sp - 1] = func;
+              uint64_t func_tag = NANBOX_PREFIX
+                | ((jsval_t)(T_FUNC & NANBOX_TYPE_MASK) << NANBOX_TYPE_SHIFT);
+              mir_load_imm(ctx, jit_func, r_tmp, func_tag);
+              MIR_append_insn(ctx, jit_func,
+                MIR_new_insn(ctx, MIR_OR,
+                  MIR_new_reg_op(ctx, dst),
+                  MIR_new_reg_op(ctx, r_tmp),
+                  MIR_new_reg_op(ctx, r_closure)));
+              break;
+            }
+          }
+        }
+
+        int un = upval_n++;
+        char rn_uvs[32], rn_uv[32], rn_loc[32];
+        snprintf(rn_uvs, sizeof(rn_uvs), "upvs%d",  un);
+        snprintf(rn_uv,  sizeof(rn_uv),  "upv%d",   un);
+        snprintf(rn_loc, sizeof(rn_loc),  "uvloc%d", un);
+
+        MIR_reg_t r_uvs = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_uvs);
+        MIR_reg_t r_uv  = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_uv);
+        MIR_reg_t r_loc = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_loc);
+        MIR_reg_t dst   = vstack_push(&vs);
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_uvs),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_closure_t, upvalues),
+              r_closure, 0, 1)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_uv),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)((int)idx * (int)sizeof(sv_upvalue_t *)),
+              r_uvs, 0, 1)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_loc),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_upvalue_t, location),
+              r_uv, 0, 1)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_mem_op(ctx, MIR_JSVAL, 0, r_loc, 0, 1)));
+        break;
+      }
+
+      case OP_PUT_UPVAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        int un = upval_n++;
+        char rn_uvs[32], rn_uv[32], rn_loc[32];
+        snprintf(rn_uvs, sizeof(rn_uvs), "upvs%d",  un);
+        snprintf(rn_uv,  sizeof(rn_uv),  "upv%d",   un);
+        snprintf(rn_loc, sizeof(rn_loc),  "uvloc%d", un);
+
+        MIR_reg_t r_uvs = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_uvs);
+        MIR_reg_t r_uv  = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_uv);
+        MIR_reg_t r_loc = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_loc);
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t src   = vstack_pop(&vs);
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_uvs),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_closure_t, upvalues),
+              r_closure, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_uv),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)((int)idx * (int)sizeof(sv_upvalue_t *)),
+              r_uvs, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_loc),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_upvalue_t, location),
+              r_uv, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_mem_op(ctx, MIR_JSVAL, 0, r_loc, 0, 1),
+            MIR_new_reg_op(ctx, src)));
+        break;
+      }
+
+      case OP_SET_UPVAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        int un = upval_n++;
+        char rn_uvs[32], rn_uv[32], rn_loc[32];
+        snprintf(rn_uvs, sizeof(rn_uvs), "upvs%d",  un);
+        snprintf(rn_uv,  sizeof(rn_uv),  "upv%d",   un);
+        snprintf(rn_loc, sizeof(rn_loc),  "uvloc%d", un);
+
+        MIR_reg_t r_uvs = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_uvs);
+        MIR_reg_t r_uv  = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_uv);
+        MIR_reg_t r_loc = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_loc);
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t src   = vstack_top(&vs);
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_uvs),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_closure_t, upvalues),
+              r_closure, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_uv),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)((int)idx * (int)sizeof(sv_upvalue_t *)),
+              r_uvs, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_loc),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_upvalue_t, location),
+              r_uv, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_mem_op(ctx, MIR_JSVAL, 0, r_loc, 0, 1),
+            MIR_new_reg_op(ctx, src)));
+        break;
+      }
+
+      case OP_CLOSE_UPVAL: {
+        uint16_t idx = sv_get_u16(ip + 1);
+        if (n_locals > 0) {
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+        }
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 6,
+            MIR_new_ref_op(ctx, close_upval_proto),
+            MIR_new_ref_op(ctx, imp_close_upval),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_uint_op(ctx, (uint64_t)idx),
+            MIR_new_reg_op(ctx, r_lbuf),
+            MIR_new_int_op(ctx, n_locals)));
+        break;
+      }
+
+      case OP_GET_GLOBAL:
+      case OP_GET_GLOBAL_UNDEF: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[idx];
+        MIR_reg_t dst = vstack_push(&vs);
+
+        if (vs.known_func) {
+          jsval_t gv = jit_helper_get_global(js, atom->str, atom->len);
+          if (vtype(gv) == T_FUNC) {
+            sv_closure_t *gcl = js_func_closure(gv);
+            if (gcl && gcl->func == func) {
+              vs.known_func[vs.sp - 1] = func;
+              uint64_t func_tag = NANBOX_PREFIX
+                | ((jsval_t)(T_FUNC & NANBOX_TYPE_MASK) << NANBOX_TYPE_SHIFT);
+              mir_load_imm(ctx, jit_func, r_tmp, func_tag);
+              MIR_append_insn(ctx, jit_func,
+                MIR_new_insn(ctx, MIR_OR,
+                  MIR_new_reg_op(ctx, dst),
+                  MIR_new_reg_op(ctx, r_tmp),
+                  MIR_new_reg_op(ctx, r_closure)));
+              break;
+            }
+          }
+        }
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 6,
+            MIR_new_ref_op(ctx, gg_proto),
+            MIR_new_ref_op(ctx, imp_gg),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len)));
+        break;
+      }
+
+      case OP_RETURN: {
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        MIR_reg_t ret_val = vstack_pop(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, ret_val)));
+        break;
+      }
+
+      case OP_RETURN_UNDEF: {
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_ret_insn(ctx, 1,
+            MIR_new_uint_op(ctx, mkval(T_UNDEF, 0))));
+        break;
+      }
+
+      case OP_INC_LOCAL: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)n_locals) { ok = false; break; }
+        if (known_func_locals) known_func_locals[idx] = NULL;
+        int in = arith_n++;
+        char il_d1[32], il_d2[32];
+        snprintf(il_d1, sizeof(il_d1), "il_d1_%d", in);
+        snprintf(il_d2, sizeof(il_d2), "il_d2_%d", in);
+        MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, il_d1);
+        MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, il_d2);
+        mir_i64_to_d(ctx, jit_func, fd1, local_regs[idx], r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DADD,
+            MIR_new_reg_op(ctx, fd2),
+            MIR_new_reg_op(ctx, fd1),
+            MIR_new_reg_op(ctx, r_d_one)));
+        mir_d_to_i64(ctx, jit_func, local_regs[idx], fd2, r_d_slot);
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, local_regs[idx])));
+        break;
+      }
+
+      case OP_DEC_LOCAL: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)n_locals) { ok = false; break; }
+        if (known_func_locals) known_func_locals[idx] = NULL;
+        int dn = arith_n++;
+        char dl_d1[32], dl_d2[32];
+        snprintf(dl_d1, sizeof(dl_d1), "dl_d1_%d", dn);
+        snprintf(dl_d2, sizeof(dl_d2), "dl_d2_%d", dn);
+        MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, dl_d1);
+        MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, dl_d2);
+        mir_i64_to_d(ctx, jit_func, fd1, local_regs[idx], r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DSUB,
+            MIR_new_reg_op(ctx, fd2),
+            MIR_new_reg_op(ctx, fd1),
+            MIR_new_reg_op(ctx, r_d_one)));
+        mir_d_to_i64(ctx, jit_func, local_regs[idx], fd2, r_d_slot);
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, local_regs[idx])));
+        break;
+      }
+
+      case OP_ADD_LOCAL: {
+        uint8_t idx = sv_get_u8(ip + 1);
+        if (idx >= (uint8_t)n_locals) { ok = false; break; }
+        if (known_func_locals) known_func_locals[idx] = NULL;
+        MIR_reg_t rr = vstack_pop(&vs);
+
+        MIR_label_t slow = MIR_new_label(ctx);
+        MIR_label_t done = MIR_new_label(ctx);
+
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, local_regs[idx], slow);
+        mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+
+        int an = arith_n++;
+        char al_d1[32], al_d2[32], al_d3[32];
+        snprintf(al_d1, sizeof(al_d1), "al_d1_%d", an);
+        snprintf(al_d2, sizeof(al_d2), "al_d2_%d", an);
+        snprintf(al_d3, sizeof(al_d3), "al_d3_%d", an);
+        MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, al_d1);
+        MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, al_d2);
+        MIR_reg_t fd3 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, al_d3);
+        mir_i64_to_d(ctx, jit_func, fd1, local_regs[idx], r_d_slot);
+        mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_DADD,
+            MIR_new_reg_op(ctx, fd3),
+            MIR_new_reg_op(ctx, fd1),
+            MIR_new_reg_op(ctx, fd2)));
+        mir_d_to_i64(ctx, jit_func, local_regs[idx], fd3, r_d_slot);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+
+        MIR_append_insn(ctx, jit_func, slow);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_val),
+            MIR_new_reg_op(ctx, local_regs[idx])));
+        mir_call_helper2(ctx, jit_func, local_regs[idx],
+                         helper2_proto, imp_add,
+                         r_vm, r_js, local_regs[idx], rr);
+        mir_emit_bailout_check(ctx, jit_func, local_regs[idx],
+          r_bailout_val, r_bailout_off, bc_off,
+          r_bailout_sp, vs.sp, bailout_tramp,
+          r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+
+        MIR_append_insn(ctx, jit_func, done);
+        if (has_captures && captured_locals && captured_locals[idx])
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)((int)idx * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, local_regs[idx])));
+        break;
+      }
+
+      case OP_TO_PROPKEY: {
+        MIR_reg_t src = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_label_t is_key  = MIR_new_label(ctx);
+        MIR_label_t pk_done = MIR_new_label(ctx);
+        MIR_label_t pk_helper = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_UBLE,
+            MIR_new_label_op(ctx, pk_helper),
+            MIR_new_reg_op(ctx, src),
+            MIR_new_uint_op(ctx, NANBOX_PREFIX)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, src),
+            MIR_new_uint_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_AND,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, NANBOX_TYPE_MASK)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, is_key),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_int_op(ctx, T_STR)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, is_key),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_int_op(ctx, T_SYMBOL)));
+        MIR_append_insn(ctx, jit_func, pk_helper);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 6,
+            MIR_new_ref_op(ctx, helper1_proto),
+            MIR_new_ref_op(ctx, imp_to_propkey),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, src)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, pk_done)));
+        MIR_append_insn(ctx, jit_func, is_key);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, src)));
+        MIR_append_insn(ctx, jit_func, pk_done);
+        break;
+      }
+
+      case OP_GET_FIELD: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[idx];
+        MIR_reg_t obj = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 10,
+            MIR_new_ref_op(ctx, gf_proto),
+            MIR_new_ref_op(ctx, imp_get_field),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)func),
+            MIR_new_int_op(ctx, (int64_t)bc_off)));
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_GET_FIELD2: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[idx];
+        MIR_reg_t obj = vstack_top(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 10,
+            MIR_new_ref_op(ctx, gf_proto),
+            MIR_new_ref_op(ctx, imp_get_field),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)func),
+            MIR_new_int_op(ctx, (int64_t)bc_off)));
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_PUT_FIELD: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[idx];
+        MIR_reg_t val = vstack_pop(&vs);
+        MIR_reg_t obj = vstack_pop(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 9,
+            MIR_new_ref_op(ctx, put_field_proto),
+            MIR_new_ref_op(ctx, imp_put_field),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj),
+            MIR_new_reg_op(ctx, val),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len)));
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, r_err_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_err_tmp)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_DEFINE_FIELD: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[idx];
+        MIR_reg_t val = vstack_pop(&vs);
+        MIR_reg_t obj = vstack_top(&vs); 
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 8,
+            MIR_new_ref_op(ctx, define_field_proto),
+            MIR_new_ref_op(ctx, imp_define_field),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj),
+            MIR_new_reg_op(ctx, val),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len)));
+        break;
+      }
+
+      case OP_GET_ELEM: {
+        MIR_reg_t key = vstack_pop(&vs);
+        MIR_reg_t obj = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 9,
+            MIR_new_ref_op(ctx, ge_proto),
+            MIR_new_ref_op(ctx, imp_get_elem),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj),
+            MIR_new_reg_op(ctx, key),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)func),
+            MIR_new_int_op(ctx, (int64_t)bc_off)));
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_GET_ELEM2: {
+        MIR_reg_t key = vstack_pop(&vs);
+        MIR_reg_t obj = vstack_top(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_get_elem2,
+                         r_vm, r_js, obj, key);
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_PUT_ELEM: {
+        MIR_reg_t val = vstack_pop(&vs);
+        MIR_reg_t key = vstack_pop(&vs);
+        MIR_reg_t obj = vstack_pop(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 8,
+            MIR_new_ref_op(ctx, put_elem_proto),
+            MIR_new_ref_op(ctx, imp_put_elem),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj),
+            MIR_new_reg_op(ctx, key),
+            MIR_new_reg_op(ctx, val)));
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, r_err_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_err_tmp)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_PUT_GLOBAL: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[idx];
+        MIR_reg_t val = vstack_pop(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 9,
+            MIR_new_ref_op(ctx, put_global_proto),
+            MIR_new_ref_op(ctx, imp_put_global),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, val),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len),
+            MIR_new_int_op(ctx, func->is_strict ? 1 : 0)));
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, r_err_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_err_tmp)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_OBJECT: {
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 5,
+            MIR_new_ref_op(ctx, object_proto),
+            MIR_new_ref_op(ctx, imp_object),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js)));
+        break;
+      }
+
+      case OP_ARRAY: {
+        uint16_t n = sv_get_u16(ip + 1);
+        if (vs.sp < (int)n) { ok = false; break; }
+        for (int i = (int)n - 1; i >= 0; i--) {
+          MIR_reg_t elem = vstack_pop(&vs);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)),
+                r_args_buf, 0, 1),
+              MIR_new_reg_op(ctx, elem)));
+        }
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 7,
+            MIR_new_ref_op(ctx, array_proto),
+            MIR_new_ref_op(ctx, imp_array),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, r_args_buf),
+            MIR_new_int_op(ctx, (int64_t)n)));
+        break;
+      }
+
+      case OP_SET_PROTO: {
+        MIR_reg_t proto = vstack_pop(&vs);
+        MIR_reg_t obj = vstack_top(&vs);
+        mir_call_helper2(ctx, jit_func, r_err_tmp,
+                         helper2_proto, imp_set_proto,
+                         r_vm, r_js, obj, proto);
+        break;
+      }
+
+      case OP_SWAP: {
+        if (vs.sp < 2) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 2, ctx, jit_func, r_d_slot);
+        MIR_reg_t ra = vs.regs[vs.sp - 2];
+        MIR_reg_t rb = vs.regs[vs.sp - 1];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_tmp),
+            MIR_new_reg_op(ctx, ra)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, ra),
+            MIR_new_reg_op(ctx, rb)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, rb),
+            MIR_new_reg_op(ctx, r_tmp)));
+        break;
+      }
+
+      case OP_ROT3L: {
+        if (vs.sp < 3) { ok = false; break; }
+        vstack_ensure_boxed(&vs, vs.sp - 1, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 2, ctx, jit_func, r_d_slot);
+        vstack_ensure_boxed(&vs, vs.sp - 3, ctx, jit_func, r_d_slot);
+        MIR_reg_t rx = vs.regs[vs.sp - 3];
+        MIR_reg_t ra = vs.regs[vs.sp - 2];
+        MIR_reg_t rb = vs.regs[vs.sp - 1];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_tmp),
+            MIR_new_reg_op(ctx, rx)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, rx),
+            MIR_new_reg_op(ctx, ra)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, ra),
+            MIR_new_reg_op(ctx, rb)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, rb),
+            MIR_new_reg_op(ctx, r_tmp)));
+        break;
+      }
+
+      case OP_IN: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_in,
+                         r_vm, r_js, rl, rr);
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_INSTANCEOF: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_instanceof,
+                         r_vm, r_js, rl, rr);
+        if (has_captures) {
+          for (int i = 0; i < n_locals; i++)
+            if (captured_locals[i])
+              MIR_append_insn(ctx, jit_func,
+                MIR_new_insn(ctx, MIR_MOV,
+                  MIR_new_reg_op(ctx, local_regs[i]),
+                  MIR_new_mem_op(ctx, MIR_T_I64,
+                    (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+        }
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_GET_LENGTH: {
+        MIR_reg_t obj = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 6,
+            MIR_new_ref_op(ctx, helper1_proto),
+            MIR_new_ref_op(ctx, imp_get_length),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, obj)));
+        break;
+      }
+
+      case OP_SEQ: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_seq,
+                         r_vm, r_js, rl, rr);
+        break;
+      }
+
+      case OP_EQ: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_eq,
+                         r_vm, r_js, rl, rr);
+        break;
+      }
+
+      case OP_NE: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_ne,
+                         r_vm, r_js, rl, rr);
+        break;
+      }
+
+      case OP_SNE: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_sne,
+                         r_vm, r_js, rl, rr);
+        break;
+      }
+
+      case OP_GT: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_gt,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DGT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DGT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int gtn = arith_n++;
+          char d1[32], d2[32];
+          snprintf(d1, sizeof(d1), "gt_d1_%d", gtn);
+          snprintf(d2, sizeof(d2), "gt_d2_%d", gtn);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DGT,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_gt, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_GE: {
+        uint8_t fb = func->type_feedback ? func->type_feedback[bc_off] : 0;
+        bool fb_num_only  = fb && !(fb & ~SV_TFB_NUM);
+        bool fb_never_num = fb && !(fb & SV_TFB_NUM);
+
+        bool l_is_num = vs.slot_type && vs.slot_type[vs.sp - 2] == SLOT_NUM;
+        bool r_is_num = vs.slot_type && vs.slot_type[vs.sp - 1] == SLOT_NUM;
+
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+
+        if (fb_never_num) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_ge,
+                           r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        } else if (fb_num_only && l_is_num && r_is_num) {
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DGE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+        } else if (fb_num_only && (l_is_num || r_is_num)) {
+          MIR_label_t bail_direct = MIR_new_label(ctx);
+          MIR_reg_t boxed_reg = l_is_num ? rr : rl;
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, boxed_reg, bail_direct);
+          int boxed_idx = l_is_num ? (int)vs.sp : (int)(vs.sp - 1);
+          mir_i64_to_d(ctx, jit_func, vs.d_regs[boxed_idx],
+                       vs.regs[boxed_idx], r_d_slot);
+          MIR_reg_t fd_l = vs.d_regs[vs.sp - 1];
+          MIR_reg_t fd_r = vs.d_regs[vs.sp];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DGE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd_l),
+              MIR_new_reg_op(ctx, fd_r)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_label_t skip_bail = MIR_new_label(ctx);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail)));
+          MIR_append_insn(ctx, jit_func, bail_direct);
+          int pre_op_sp = vs.sp + 1;
+          for (int i = 0; i < pre_op_sp; i++) {
+            if (vs.slot_type && vs.slot_type[i] == SLOT_NUM)
+              mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+                MIR_new_reg_op(ctx, vs.regs[i])));
+          }
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_off),
+              MIR_new_int_op(ctx, bc_off)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_sp),
+              MIR_new_int_op(ctx, pre_op_sp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, bailout_tramp)));
+          MIR_append_insn(ctx, jit_func, skip_bail);
+        } else {
+          MIR_label_t slow = MIR_new_label(ctx);
+          MIR_label_t done = MIR_new_label(ctx);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rl, slow);
+          mir_emit_is_num_guard(ctx, jit_func, r_bool, rr, slow);
+          int gen = arith_n++;
+          char d1[32], d2[32];
+          snprintf(d1, sizeof(d1), "ge_d1_%d", gen);
+          snprintf(d2, sizeof(d2), "ge_d2_%d", gen);
+          MIR_reg_t fd1 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d1);
+          MIR_reg_t fd2 = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_D, d2);
+          mir_i64_to_d(ctx, jit_func, fd1, rl, r_d_slot);
+          mir_i64_to_d(ctx, jit_func, fd2, rr, r_d_slot);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_DGE,
+              MIR_new_reg_op(ctx, r_bool),
+              MIR_new_reg_op(ctx, fd1),
+              MIR_new_reg_op(ctx, fd2)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_tmp),
+              MIR_new_reg_op(ctx, r_bool)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_OR,
+              MIR_new_reg_op(ctx, rd),
+              MIR_new_uint_op(ctx, js_false),
+              MIR_new_reg_op(ctx, r_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done)));
+          MIR_append_insn(ctx, jit_func, slow);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, r_bailout_val),
+              MIR_new_reg_op(ctx, rl)));
+          mir_call_helper2(ctx, jit_func, rd,
+                           helper2_proto, imp_ge, r_vm, r_js, rl, rr);
+          mir_emit_bailout_check(ctx, jit_func, rd,
+            r_bailout_val, r_bailout_off, bc_off,
+            r_bailout_sp, vs.sp + 1, bailout_tramp,
+            r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+          MIR_append_insn(ctx, jit_func, done);
+        }
+        break;
+      }
+
+      case OP_BAND: case OP_BOR: case OP_BXOR:
+      case OP_SHL:  case OP_SHR: case OP_USHR: {
+        MIR_reg_t rr = vstack_pop(&vs);
+        MIR_reg_t rl = vstack_pop(&vs);
+        MIR_reg_t rd = vstack_push(&vs);
+        MIR_item_t imp;
+        switch (op) {
+          case OP_BAND: imp = imp_band; break;
+          case OP_BOR:  imp = imp_bor;  break;
+          case OP_BXOR: imp = imp_bxor; break;
+          case OP_SHL:  imp = imp_shl;  break;
+          case OP_SHR:  imp = imp_shr;  break;
+          default:      imp = imp_ushr; break;
+        }
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_val),
+            MIR_new_reg_op(ctx, rl)));
+        mir_call_helper2(ctx, jit_func, rd,
+                         helper2_proto, imp, r_vm, r_js, rl, rr);
+        mir_emit_bailout_check(ctx, jit_func, rd,
+          r_bailout_val, r_bailout_off, bc_off,
+          r_bailout_sp, vs.sp + 1, bailout_tramp,
+          r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot);
+        break;
+      }
+
+      case OP_BNOT: {
+        MIR_reg_t rs = vstack_top(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 6,
+            MIR_new_ref_op(ctx, helper1_proto),
+            MIR_new_ref_op(ctx, imp_bnot),
+            MIR_new_reg_op(ctx, rs),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, rs)));
+        MIR_label_t no_bail = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_bail),
+            MIR_new_reg_op(ctx, rs),
+            MIR_new_uint_op(ctx, (uint64_t)SV_JIT_BAILOUT)));
+        for (int i = 0; i < vs.sp; i++)
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+              MIR_new_reg_op(ctx, vs.regs[i])));
+        for (int i = 0; i < n_locals; i++)
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, local_regs[i])));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_off),
+            MIR_new_int_op(ctx, bc_off)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_sp),
+            MIR_new_int_op(ctx, vs.sp)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP,
+            MIR_new_label_op(ctx, bailout_tramp)));
+        MIR_append_insn(ctx, jit_func, no_bail);
+        break;
+      }
+
+      case OP_NOT: {
+        MIR_reg_t rs = vstack_top(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 6,
+            MIR_new_ref_op(ctx, helper1_proto),
+            MIR_new_ref_op(ctx, imp_not),
+            MIR_new_reg_op(ctx, rs),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, rs)));
+        break;
+      }
+
+      case OP_TYPEOF: {
+        MIR_reg_t rs = vstack_top(&vs);
+        for (int i = 0; i < vs.sp; i++)
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_args_buf, 0, 1),
+              MIR_new_reg_op(ctx, vs.regs[i])));
+        for (int i = 0; i < n_locals; i++)
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_T_I64,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+              MIR_new_reg_op(ctx, local_regs[i])));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_off),
+            MIR_new_int_op(ctx, bc_off)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_bailout_sp),
+            MIR_new_int_op(ctx, vs.sp)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP,
+            MIR_new_label_op(ctx, bailout_tramp)));
+        (void)rs; (void)imp_typeof;
+        break;
+      }
+
+      case OP_VOID: {
+        MIR_reg_t rs = vstack_top(&vs);
+        mir_load_imm(ctx, jit_func, rs, mkval(T_UNDEF, 0));
+        break;
+      }
+
+      case OP_DELETE: {
+        MIR_reg_t rk = vstack_pop(&vs);
+        MIR_reg_t ro = vstack_pop(&vs);
+        MIR_reg_t dst = vstack_push(&vs);
+        mir_call_helper2(ctx, jit_func, dst,
+                         helper2_proto, imp_delete,
+                         r_vm, r_js, ro, rk);
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, dst)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, dst)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_NEW: {
+        uint16_t new_argc = sv_get_u16(ip + 1);
+        if (new_argc > 16 || vs.sp < (int)new_argc + 2) { ok = false; break; }
+
+        for (int i = (int)new_argc - 1; i >= 0; i--) {
+          MIR_reg_t areg = vstack_pop(&vs);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_JSVAL,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)),
+                r_args_buf, 0, 1),
+              MIR_new_reg_op(ctx, areg)));
+        }
+
+        MIR_reg_t r_new_target = vstack_pop(&vs);
+        MIR_reg_t r_new_func   = vstack_pop(&vs);
+        MIR_reg_t r_new_res    = vstack_push(&vs);
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 9,
+            MIR_new_ref_op(ctx, new_proto),
+            MIR_new_ref_op(ctx, imp_new),
+            MIR_new_reg_op(ctx, r_new_res),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, r_new_func),
+            MIR_new_reg_op(ctx, r_new_target),
+            MIR_new_reg_op(ctx, r_args_buf),
+            MIR_new_int_op(ctx, (int64_t)new_argc)));
+
+        if (has_captures) {
+          for (int i = 0; i < n_locals; i++)
+            if (captured_locals[i])
+              MIR_append_insn(ctx, jit_func,
+                MIR_new_insn(ctx, MIR_MOV,
+                  MIR_new_reg_op(ctx, local_regs[i]),
+                  MIR_new_mem_op(ctx, MIR_T_I64,
+                    (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+        }
+
+        MIR_label_t no_err = MIR_new_label(ctx);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_URSH,
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_reg_op(ctx, r_new_res),
+            MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BNE,
+            MIR_new_label_op(ctx, no_err),
+            MIR_new_reg_op(ctx, r_bool),
+            MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, r_new_res)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_new_res)));
+        }
+        MIR_append_insn(ctx, jit_func, no_err);
+        break;
+      }
+
+      case OP_TAIL_CALL_METHOD:
+      case OP_CALL_METHOD: {
+        vstack_flush_to_boxed(&vs, ctx, jit_func, r_d_slot);
+        bool is_tail = (op == OP_TAIL_CALL_METHOD);
+        uint16_t call_argc = sv_get_u16(ip + 1);
+        if (call_argc > 16 || vs.sp < (int)call_argc + 2) { ok = false; break; }
+
+        int cn = call_n++;
+
+        char rn_arr[32], rn_ccl[32], rn_cfn[32], rn_jptr[32];
+        snprintf(rn_arr,  sizeof(rn_arr),  "cm_arr%d",  cn);
+        snprintf(rn_ccl,  sizeof(rn_ccl),  "cm_cl%d",   cn);
+        snprintf(rn_cfn,  sizeof(rn_cfn),  "cm_fn%d",   cn);
+        snprintf(rn_jptr, sizeof(rn_jptr), "cm_jptr%d", cn);
+
+        MIR_reg_t r_arg_arr = r_args_buf;
+
+        for (int i = (int)call_argc - 1; i >= 0; i--) {
+          MIR_reg_t areg = vstack_pop(&vs);
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_mem_op(ctx, MIR_JSVAL,
+                (MIR_disp_t)(i * (int)sizeof(jsval_t)),
+                r_arg_arr, 0, 1),
+              MIR_new_reg_op(ctx, areg)));
+        }
+
+        MIR_reg_t r_call_func = vstack_pop(&vs);
+        MIR_reg_t r_call_this = vstack_pop(&vs); 
+        MIR_reg_t r_call_res  = vstack_push(&vs);
+
+        MIR_label_t lbl_cm_self   = MIR_new_label(ctx);
+        MIR_label_t lbl_cm_interp = MIR_new_label(ctx);
+        MIR_label_t lbl_cm_done   = MIR_new_label(ctx);
+
+        MIR_reg_t r_callee_cl = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_ccl);
+        mir_emit_get_closure(ctx, jit_func, r_callee_cl, r_call_func,
+                             r_bool, lbl_cm_interp);
+
+        MIR_reg_t r_callee_fn = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_cfn);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_callee_fn),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_closure_t, func),
+              r_callee_cl, 0, 1)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl_cm_interp),
+            MIR_new_reg_op(ctx, r_callee_fn),
+            MIR_new_int_op(ctx, 0)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl_cm_self),
+            MIR_new_reg_op(ctx, r_callee_cl),
+            MIR_new_reg_op(ctx, r_closure)));
+
+        MIR_reg_t r_jit_ptr = MIR_new_func_reg(ctx, jit_func->u.func, MIR_T_I64, rn_jptr);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, r_jit_ptr),
+            MIR_new_mem_op(ctx, MIR_T_P,
+              (MIR_disp_t)offsetof(sv_func_t, jit_code),
+              r_callee_fn, 0, 1)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_BEQ,
+            MIR_new_label_op(ctx, lbl_cm_interp),
+            MIR_new_reg_op(ctx, r_jit_ptr),
+            MIR_new_int_op(ctx, 0)));
+
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 8,
+            MIR_new_ref_op(ctx, self_proto),
+            MIR_new_reg_op(ctx, r_jit_ptr),
+            MIR_new_reg_op(ctx, r_call_res),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_call_this),
+            MIR_new_reg_op(ctx, r_arg_arr),
+            MIR_new_int_op(ctx, (int64_t)call_argc),
+            MIR_new_reg_op(ctx, r_callee_cl)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl_cm_done)));
+
+        MIR_append_insn(ctx, jit_func, lbl_cm_self);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 8,
+            MIR_new_ref_op(ctx, self_proto),
+            MIR_new_ref_op(ctx, jit_func),
+            MIR_new_reg_op(ctx, r_call_res),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_call_this),
+            MIR_new_reg_op(ctx, r_arg_arr),
+            MIR_new_int_op(ctx, (int64_t)call_argc),
+            MIR_new_reg_op(ctx, r_closure)));
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, lbl_cm_done)));
+
+        MIR_append_insn(ctx, jit_func, lbl_cm_interp);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 9,
+            MIR_new_ref_op(ctx, call_proto),
+            MIR_new_ref_op(ctx, imp_call),
+            MIR_new_reg_op(ctx, r_call_res),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, r_call_func),
+            MIR_new_reg_op(ctx, r_call_this),
+            MIR_new_reg_op(ctx, r_arg_arr),
+            MIR_new_int_op(ctx, (int64_t)call_argc)));
+        MIR_append_insn(ctx, jit_func, lbl_cm_done);
+        if (is_tail && jit_try_depth == 0) {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+        } else {
+          if (has_captures) {
+            for (int i = 0; i < n_locals; i++)
+              if (captured_locals[i])
+                MIR_append_insn(ctx, jit_func,
+                  MIR_new_insn(ctx, MIR_MOV,
+                    MIR_new_reg_op(ctx, local_regs[i]),
+                    MIR_new_mem_op(ctx, MIR_T_I64,
+                      (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1)));
+          }
+          if (jit_try_depth > 0) {
+            jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+            MIR_label_t no_err = MIR_new_label(ctx);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_URSH,
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_reg_op(ctx, r_call_res),
+                MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_BNE,
+                MIR_new_label_op(ctx, no_err),
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+                MIR_new_reg_op(ctx, r_call_res)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_JMP,
+                MIR_new_label_op(ctx, h->catch_label)));
+            MIR_append_insn(ctx, jit_func, no_err);
+          } else {
+            MIR_label_t no_err = MIR_new_label(ctx);
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_URSH,
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_reg_op(ctx, r_call_res),
+                MIR_new_int_op(ctx, NANBOX_TYPE_SHIFT)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_BNE,
+                MIR_new_label_op(ctx, no_err),
+                MIR_new_reg_op(ctx, r_bool),
+                MIR_new_uint_op(ctx, JIT_ERR_TAG)));
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+            MIR_append_insn(ctx, jit_func, no_err);
+          }
+          if (is_tail) {
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_call_res)));
+          }
+        }
+        break;
+      }
+
+      case OP_NOP:
+      case OP_HALT:
+      case OP_LINE_NUM:
+      case OP_COL_NUM:
+      case OP_LABEL:
+        break;
+
+      case OP_SET_NAME: {
+        uint32_t atom_idx = sv_get_u32(ip + 1);
+        if (atom_idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[atom_idx];
+        MIR_reg_t fn_val = vstack_top(&vs);
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 7,
+            MIR_new_ref_op(ctx, set_name_proto),
+            MIR_new_ref_op(ctx, imp_set_name),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, fn_val),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len)));
+        break;
+      }
+
+      case OP_TRY_PUSH: {
+        int32_t off = sv_get_i32(ip + 1);
+        int catch_off = bc_off + sz + off;
+        MIR_label_t catch_lbl = label_for_branch(ctx, &lm, catch_off, vs.sp);
+        if (jit_try_depth < JIT_TRY_MAX) {
+          jit_try_stack[jit_try_depth].catch_label = catch_lbl;
+          jit_try_stack[jit_try_depth].catch_bc_off = catch_off;
+          jit_try_stack[jit_try_depth].saved_sp = vs.sp;
+          jit_try_depth++;
+        }
+        if (catch_sp_count < JIT_TRY_MAX) {
+          catch_sp_map[catch_sp_count].bc_off = catch_off;
+          catch_sp_map[catch_sp_count].saved_sp = vs.sp;
+          catch_sp_count++;
+        }
+        break;
+      }
+
+      case OP_TRY_POP:
+        if (jit_try_depth > 0) jit_try_depth--;
+        break;
+
+      case OP_THROW: {
+        MIR_reg_t thrown = vstack_pop(&vs);
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, thrown)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_call_insn(ctx, 6,
+              MIR_new_ref_op(ctx, helper1_proto),
+              MIR_new_ref_op(ctx, imp_throw),
+              MIR_new_reg_op(ctx, r_err_tmp),
+              MIR_new_reg_op(ctx, r_vm),
+              MIR_new_reg_op(ctx, r_js),
+              MIR_new_reg_op(ctx, thrown)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_err_tmp)));
+        }
+        break;
+      }
+
+      case OP_THROW_ERROR: {
+        uint32_t atom_idx = sv_get_u32(ip + 1);
+        uint8_t err_type = sv_get_u8(ip + 5);
+        if (atom_idx >= (uint32_t)func->atom_count) { ok = false; break; }
+        sv_atom_t *atom = &func->atoms[atom_idx];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 8,
+            MIR_new_ref_op(ctx, throw_error_proto),
+            MIR_new_ref_op(ctx, imp_throw_error),
+            MIR_new_reg_op(ctx, r_err_tmp),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_uint_op(ctx, (uint64_t)(uintptr_t)atom->str),
+            MIR_new_uint_op(ctx, (uint64_t)atom->len),
+            MIR_new_int_op(ctx, (int64_t)err_type)));
+        if (jit_try_depth > 0) {
+          jit_try_entry_t *h = &jit_try_stack[jit_try_depth - 1];
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_MOV,
+              MIR_new_reg_op(ctx, vs.regs[h->saved_sp]),
+              MIR_new_reg_op(ctx, r_err_tmp)));
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_insn(ctx, MIR_JMP,
+              MIR_new_label_op(ctx, h->catch_label)));
+        } else {
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_err_tmp)));
+        }
+        break;
+      }
+
+      case OP_CATCH: {
+        int catch_saved_sp = -1;
+        for (int i = 0; i < catch_sp_count; i++) {
+          if (catch_sp_map[i].bc_off == bc_off) {
+            catch_saved_sp = catch_sp_map[i].saved_sp;
+            break;
+          }
+        }
+        if (catch_saved_sp >= 0) {
+          vs.sp = catch_saved_sp + 1;
+          MIR_append_insn(ctx, jit_func,
+            MIR_new_call_insn(ctx, 6,
+              MIR_new_ref_op(ctx, helper1_proto),
+              MIR_new_ref_op(ctx, imp_catch_value),
+              MIR_new_reg_op(ctx, vs.regs[catch_saved_sp]),
+              MIR_new_reg_op(ctx, r_vm),
+              MIR_new_reg_op(ctx, r_js),
+              MIR_new_reg_op(ctx, vs.regs[catch_saved_sp])));
+        } else {
+          ok = false;
+        }
+        break;
+      }
+
+      case OP_NIP_CATCH: {
+        MIR_reg_t a = vs.regs[vs.sp - 1];
+        MIR_reg_t below = vs.regs[vs.sp - 2];
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_insn(ctx, MIR_MOV,
+            MIR_new_reg_op(ctx, below),
+            MIR_new_reg_op(ctx, a)));
+        vs.sp--;
+        break;
+      }
+
+      case OP_CLOSURE: {
+        uint32_t idx = sv_get_u32(ip + 1);
+        if (idx >= (uint32_t)func->const_count) { ok = false; break; }
+        MIR_reg_t dst = vstack_push(&vs);
+        jsval_t cv = func->constants[idx];
+        vs.known_func[vs.sp - 1] = (sv_func_t *)(uintptr_t)vdata(cv);
+        if (n_locals > 0) {
+          for (int i = 0; i < n_locals; i++)
+            MIR_append_insn(ctx, jit_func,
+              MIR_new_insn(ctx, MIR_MOV,
+                MIR_new_mem_op(ctx, MIR_T_I64,
+                  (MIR_disp_t)(i * (int)sizeof(jsval_t)), r_lbuf, 0, 1),
+                MIR_new_reg_op(ctx, local_regs[i])));
+        }
+        MIR_append_insn(ctx, jit_func,
+          MIR_new_call_insn(ctx, 12,
+            MIR_new_ref_op(ctx, closure_proto),
+            MIR_new_ref_op(ctx, imp_closure),
+            MIR_new_reg_op(ctx, dst),
+            MIR_new_reg_op(ctx, r_vm),
+            MIR_new_reg_op(ctx, r_js),
+            MIR_new_reg_op(ctx, r_closure),
+            MIR_new_reg_op(ctx, r_this),
+            MIR_new_reg_op(ctx, r_args),
+            MIR_new_reg_op(ctx, r_argc),
+            MIR_new_uint_op(ctx, (uint64_t)idx),
+            MIR_new_reg_op(ctx, r_lbuf),
+            MIR_new_int_op(ctx, n_locals)));
+        break;
+      }
+
+      default:
+        ok = false;
+        break;
+    }
+
+    if (!ok) break;
+    ip += sz;
+  }
+
+  if (!ok || vs.sp > 0) {
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_ret_insn(ctx, 1,
+        MIR_new_uint_op(ctx, mkval(T_UNDEF, 0))));
+  }
+
+  if (needs_bailout) {
+    MIR_append_insn(ctx, jit_func, bailout_tramp);
+
+    MIR_reg_t r_resume_res = MIR_new_func_reg(ctx, jit_func->u.func,
+                                               MIR_JSVAL, "resume_res");
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_call_insn(ctx, 13,
+        MIR_new_ref_op(ctx, resume_proto),
+        MIR_new_ref_op(ctx, imp_resume),
+        MIR_new_reg_op(ctx, r_resume_res),
+        MIR_new_reg_op(ctx, r_vm),
+        MIR_new_reg_op(ctx, r_closure),
+        MIR_new_reg_op(ctx, r_this),
+        MIR_new_reg_op(ctx, r_args),
+        MIR_new_reg_op(ctx, r_argc),
+        MIR_new_reg_op(ctx, r_args_buf),
+        MIR_new_reg_op(ctx, r_bailout_sp),
+        MIR_new_reg_op(ctx, r_lbuf),
+        MIR_new_int_op(ctx, n_locals),
+        MIR_new_reg_op(ctx, r_bailout_off)));
+    MIR_append_insn(ctx, jit_func,
+      MIR_new_ret_insn(ctx, 1, MIR_new_reg_op(ctx, r_resume_res)));
+  }
+
+  MIR_finish_func(ctx); MIR_finish_module(ctx);
+  if (sv_dump_jit_unlikely) MIR_output_module(ctx, stderr, mod);
+
+  free(vs.regs);
+  free(vs.d_regs);
+  free(vs.known_func);
+  free(vs.slot_type);
+  free(local_regs);
+  free(known_func_locals);
+  free(captured_locals);
+
+  if (!ok) return NULL;
+
+  MIR_load_module(ctx, mod);
+#define LOAD_EXT(name) MIR_load_external(ctx, #name, name)
+  LOAD_EXT(jit_helper_add);
+  LOAD_EXT(jit_helper_sub);
+  LOAD_EXT(jit_helper_mul);
+  LOAD_EXT(jit_helper_div);
+  LOAD_EXT(jit_helper_mod);
+  LOAD_EXT(jit_helper_lt);
+  LOAD_EXT(jit_helper_le);
+  LOAD_EXT(jit_helper_gt);
+  LOAD_EXT(jit_helper_ge);
+  LOAD_EXT(jit_helper_call);
+  LOAD_EXT(jit_helper_tov);
+  LOAD_EXT(jit_helper_get_global);
+  LOAD_EXT(jit_helper_get_field);
+  LOAD_EXT(jit_helper_to_propkey);
+  LOAD_EXT(jit_helper_bailout_resume);
+  LOAD_EXT(jit_helper_close_upval);
+  LOAD_EXT(jit_helper_closure);
+  LOAD_EXT(jit_helper_in);
+  LOAD_EXT(jit_helper_instanceof);
+  LOAD_EXT(jit_helper_get_length);
+  LOAD_EXT(jit_helper_define_field);
+  LOAD_EXT(jit_helper_seq);
+  LOAD_EXT(jit_helper_eq);
+  LOAD_EXT(jit_helper_ne);
+  LOAD_EXT(jit_helper_sne);
+  LOAD_EXT(jit_helper_put_field);
+  LOAD_EXT(jit_helper_get_elem);
+  LOAD_EXT(jit_helper_get_elem2);
+  LOAD_EXT(jit_helper_put_elem);
+  LOAD_EXT(jit_helper_put_global);
+  LOAD_EXT(jit_helper_object);
+  LOAD_EXT(jit_helper_array);
+  LOAD_EXT(jit_helper_catch_value);
+  LOAD_EXT(jit_helper_throw);
+  LOAD_EXT(jit_helper_throw_error);
+  LOAD_EXT(jit_helper_set_proto);
+  LOAD_EXT(jit_helper_band);
+  LOAD_EXT(jit_helper_bor);
+  LOAD_EXT(jit_helper_bxor);
+  LOAD_EXT(jit_helper_bnot);
+  LOAD_EXT(jit_helper_shl);
+  LOAD_EXT(jit_helper_shr);
+  LOAD_EXT(jit_helper_ushr);
+  LOAD_EXT(jit_helper_not);
+  LOAD_EXT(jit_helper_is_truthy);
+  LOAD_EXT(jit_helper_typeof);
+  LOAD_EXT(jit_helper_new);
+  LOAD_EXT(jit_helper_delete);
+  LOAD_EXT(jit_helper_set_name);
+  LOAD_EXT(jit_helper_stack_overflow);
+  LOAD_EXT(jit_helper_stack_overflow_error);
+#undef LOAD_EXT
+  MIR_link(ctx, MIR_set_gen_interface, NULL);
+
+  func->jit_compiled_tfb_ver = func->tfb_version;
+  return MIR_gen(ctx, jit_func);
+}
+
+
+jsval_t sv_jit_try_compile_and_call(
+  sv_vm_t *vm, ant_t *js,
+  sv_closure_t *closure, jsval_t callee_func,
+  sv_call_ctx_t *ctx, jsval_t *out_this
+) {
+  sv_func_t *fn = closure->func;
+
+  sv_jit_func_t jit = sv_jit_compile(js, fn, closure);
+  if (!jit) {
+    fn->call_count = 0;
+    fn->back_edge_count = 0;
+    return SV_JIT_RETRY_INTERP;
+  }
+
+  fn->jit_code = (void *)jit;
+  jsval_t result = jit(vm, ctx->this_val, ctx->args, ctx->argc, closure);
+  if (sv_is_jit_bailout(result)) {
+    sv_jit_on_bailout(fn);
+    return SV_JIT_RETRY_INTERP;
+  }
+  sv_call_cleanup(js, ctx);
+  if (out_this) *out_this = ctx->this_val;
+  return result;
+}
+
+
+jsval_t sv_jit_try_osr(
+  sv_vm_t *vm, ant_t *js,
+  sv_frame_t *frame, sv_func_t *func,
+  int bc_offset
+) {
+  sv_closure_t osr_closure;
+  sv_closure_t *closure;
+  if (vtype(frame->callee) == T_FUNC) {
+    closure = js_func_closure(frame->callee);
+  } else {
+    memset(&osr_closure, 0, sizeof(osr_closure));
+    osr_closure.func     = func;
+    osr_closure.upvalues = frame->upvalues;
+    closure = &osr_closure;
+  }
+
+  sv_jit_func_t jit;
+  if (func->jit_code) {
+    jit = (sv_jit_func_t)func->jit_code;
+  } else {
+    jit = sv_jit_compile(js, func, closure);
+    if (!jit) return SV_JIT_RETRY_INTERP;
+    func->jit_code = (void *)jit;
+  }
+
+  int nl = func->max_locals;
+  jsval_t osr_locals[nl > 0 ? nl : 1];
+  for (int i = 0; i < nl; i++)
+    osr_locals[i] = frame->lp[i];
+
+  vm->jit_osr.active    = true;
+  vm->jit_osr.bc_offset = bc_offset;
+  vm->jit_osr.locals    = osr_locals;
+  vm->jit_osr.n_locals  = nl;
+  vm->jit_osr.lp        = frame->lp;
+
+  jsval_t result = jit(vm, frame->this, frame->bp, frame->argc, closure);
+
+  if (sv_is_jit_bailout(result)) {
+    sv_jit_on_bailout(func);
+    return SV_JIT_RETRY_INTERP;
+  }
+
+  return result;
+}
+
+#endif 
diff --git a/src/snapshot.c b/src/snapshot.c
index 5ef9094..a485b0c 100644
--- a/src/snapshot.c
+++ b/src/snapshot.c
@@ -7,10 +7,12 @@
 
 jsval_t ant_load_snapshot(ant_t *js) {
   if (!js) return js_mkundef();
-  jsval_t result = js_eval_cached(js, (const char *)ant_snapshot_source, ant_snapshot_source_len);
   
-  if (vtype(result) == T_ERR) return result;
-  return js_true;
+  const char *src = (const char *)ant_snapshot_source;
+  size_t len = ant_snapshot_source_len;
+  
+  jsval_t result = js_eval_bytecode(js, src, len);
+  return vtype(result) == T_ERR ? result : js_true;
 }
 
 const uint8_t *ant_get_snapshot_source(size_t *len) {
diff --git a/src/stack.c b/src/stack.c
deleted file mode 100644
index 32c3018..0000000
--- a/src/stack.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "stack.h"
-#include "arena.h"
-
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-call_stack_t global_call_stack = {NULL, 0, 0};
-
-void pop_call_frame(void) {
-  if (global_call_stack.depth == 0) return;
-  global_call_stack.depth--;
-}
-
-bool push_call_frame(const char *filename, const char *function_name, const char *code, uint32_t pos) {
-  if (global_call_stack.depth >= global_call_stack.capacity) {
-    size_t new_capacity = global_call_stack.capacity == 0 ? 32U : (size_t)global_call_stack.capacity * 2U;
-    if (new_capacity > (size_t)INT_MAX) abort();
-    if (new_capacity > SIZE_MAX / sizeof(call_frame_t)) abort();
-
-    size_t alloc_size = new_capacity * sizeof(call_frame_t);
-    call_frame_t *new_stack = (call_frame_t *)ant_realloc(global_call_stack.frames, alloc_size);
-    if (!new_stack) abort();
-
-    global_call_stack.frames = new_stack;
-    global_call_stack.capacity = (int)new_capacity;
-  }
-
-  call_frame_t *frame = 
-    &global_call_stack.frames[global_call_stack.depth++];
-  
-  *frame = (call_frame_t) {
-    .filename = filename,
-    .function_name = function_name,
-    .code = code,
-    .pos = pos, .line = -1, .col = -1,
-  };
-
-  return true;
-}
diff --git a/src/strip/src/ffi.rs b/src/strip/src/ffi.rs
index 5a66924..91480b7 100644
--- a/src/strip/src/ffi.rs
+++ b/src/strip/src/ffi.rs
@@ -1,3 +1,4 @@
+use std::alloc::{Layout, alloc, dealloc};
 use std::ffi::{CStr, c_char, c_int};
 use std::ptr;
 
@@ -6,38 +7,115 @@ use crate::strip::strip_types_internal;
 
 pub const OXC_ERR_NULL_INPUT: c_int = -1;
 pub const OXC_ERR_INVALID_UTF8: c_int = -2;
+pub const OXC_ERR_PARSE_FAILED: c_int = -3;
 pub const OXC_ERR_TRANSFORM_FAILED: c_int = -4;
 pub const OXC_ERR_OUTPUT_TOO_LARGE: c_int = -5;
 
+fn classify_strip_error(err: &str) -> c_int {
+  match ["Parse errors:", "Semantic errors:"].iter().any(|p| err.starts_with(p)) {
+    true => OXC_ERR_PARSE_FAILED,
+    false => OXC_ERR_TRANSFORM_FAILED,
+  }
+}
+
+unsafe fn write_error(output: *mut c_char, output_len: usize, msg: &str) {
+  if output.is_null() || output_len == 0 {
+    return;
+  }
+
+  let bytes = msg.as_bytes();
+  let copy_len = bytes.len().min(output_len.saturating_sub(1));
+
+  unsafe {
+    ptr::copy_nonoverlapping(bytes.as_ptr(), output as *mut u8, copy_len);
+    *output.add(copy_len) = 0;
+  }
+}
+
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn OXC_strip_types(input: *const c_char, filename: *const c_char, output: *mut c_char, output_len: usize) -> c_int {
-  if input.is_null() || output.is_null() {
-    return OXC_ERR_NULL_INPUT;
+pub unsafe extern "C" fn OXC_strip_types_owned(
+  input: *const c_char, filename: *const c_char, out_len: *mut usize, out_error: *mut c_int, error_output: *mut c_char, error_output_len: usize,
+) -> *mut c_char {
+  if !out_error.is_null() {
+    unsafe { *out_error = OXC_ERR_NULL_INPUT };
+  }
+
+  if !out_len.is_null() {
+    unsafe { *out_len = 0 };
+  }
+
+  if input.is_null() || filename.is_null() || out_len.is_null() {
+    unsafe { write_error(error_output, error_output_len, "null input/output passed") };
+    return ptr::null_mut();
   }
 
   let filename_str = match unsafe { CStr::from_ptr(filename).to_str() } {
     Ok(s) => s,
-    Err(_) => return OXC_ERR_INVALID_UTF8,
+    Err(_) => {
+      unsafe { write_error(error_output, error_output_len, "filename is not valid UTF-8") };
+      if !out_error.is_null() {
+        unsafe { *out_error = OXC_ERR_INVALID_UTF8 };
+      }
+      return ptr::null_mut();
+    }
   };
 
   let input_str = match unsafe { CStr::from_ptr(input).to_str() } {
     Ok(s) => s,
-    Err(_) => return OXC_ERR_INVALID_UTF8,
+    Err(_) => {
+      unsafe { write_error(error_output, error_output_len, "source input is not valid UTF-8") };
+      if !out_error.is_null() {
+        unsafe { *out_error = OXC_ERR_INVALID_UTF8 };
+      }
+      return ptr::null_mut();
+    }
   };
 
   match strip_types_internal(input_str, filename_str) {
     Ok(result) => {
       let bytes = result.as_bytes();
-      if bytes.len() + 1 > output_len {
-        return OXC_ERR_OUTPUT_TOO_LARGE;
+      let alloc_len = bytes.len() + 1;
+      let layout = Layout::from_size_align(alloc_len, 1).unwrap();
+      let out_ptr = unsafe { alloc(layout) as *mut c_char };
+      if out_ptr.is_null() {
+        unsafe { write_error(error_output, error_output_len, "out of memory allocating strip output") };
+        if !out_error.is_null() {
+          unsafe { *out_error = OXC_ERR_OUTPUT_TOO_LARGE };
+        }
+        return ptr::null_mut();
       }
+
       unsafe {
-        ptr::copy_nonoverlapping(bytes.as_ptr(), output as *mut u8, bytes.len());
-        *output.add(bytes.len()) = 0;
+        ptr::copy_nonoverlapping(bytes.as_ptr(), out_ptr as *mut u8, bytes.len());
+        *out_ptr.add(bytes.len()) = 0;
+        *out_len = bytes.len();
       }
-      bytes.len() as c_int
+      if !out_error.is_null() {
+        unsafe { *out_error = 0 };
+      }
+      out_ptr
+    }
+    Err(err) => {
+      unsafe { write_error(error_output, error_output_len, &err) };
+      if !out_error.is_null() {
+        unsafe { *out_error = classify_strip_error(&err) };
+      }
+      ptr::null_mut()
     }
-    Err(_) => OXC_ERR_TRANSFORM_FAILED,
+  }
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn OXC_free_stripped_output(ptr: *mut c_char, len: usize) {
+  if ptr.is_null() {
+    return;
+  }
+
+  let alloc_len = len.saturating_add(1);
+  let layout = Layout::from_size_align(alloc_len, 1).unwrap();
+
+  unsafe {
+    dealloc(ptr as *mut u8, layout);
   }
 }
 
diff --git a/src/sugar.c b/src/sugar.c
index a9e6c13..96aafc9 100644
--- a/src/sugar.c
+++ b/src/sugar.c
@@ -1,7 +1,6 @@
 #include "internal.h"
-#include "gc.h"
-#include "errors.h"
 #include "sugar.h"
+#include "silver/vm.h"
 
 #define MCO_USE_VMEM_ALLOCATOR
 #define MCO_ZERO_MEMORY
@@ -57,51 +56,18 @@ void free_coroutine(coroutine_t *coro) {
   
   if (coro->mco) {
     if (mco_running() == coro->mco) fprintf(stderr, "WARNING: Attempting to free a running coroutine\n");
-    async_exec_context_t *ctx = (async_exec_context_t *)mco_get_user_data(coro->mco);
+    void *ctx = mco_get_user_data(coro->mco);
     if (ctx) CORO_FREE(ctx);
     mco_destroy(coro->mco);
     coro->mco = NULL;
   }
   
   if (coro->args) CORO_FREE(coro->args);
-  if (coro->for_let_stack) free(coro->for_let_stack);
-  if (coro->scope_stack) utarray_free(coro->scope_stack);
+  if (coro->sv_vm) { sv_vm_destroy(coro->sv_vm); coro->sv_vm = NULL; }
   
   CORO_FREE(coro);
 }
 
-static void for_let_swap_with_coro(struct js *js, coroutine_t *coro) {
-  struct for_let_ctx *tmp_stack = js->for_let_stack;
-  int tmp_len = js->for_let_stack_len;
-  int tmp_cap = js->for_let_stack_cap;
-  
-  js->for_let_stack = coro->for_let_stack;
-  js->for_let_stack_len = coro->for_let_stack_len;
-  js->for_let_stack_cap = coro->for_let_stack_cap;
-  
-  coro->for_let_stack = tmp_stack;
-  coro->for_let_stack_len = tmp_len;
-  coro->for_let_stack_cap = tmp_cap;
-}
-
-coro_saved_state_t coro_enter(struct js *js, coroutine_t *coro) {
-  extern UT_array *global_scope_stack;
-  coro_saved_state_t saved = { js->scope, global_scope_stack };
-  js->scope = coro->scope;
-  global_scope_stack = coro->scope_stack;
-  for_let_swap_with_coro(js, coro);
-  return saved;
-}
-
-void coro_leave(struct js *js, coroutine_t *coro, coro_saved_state_t saved) {
-  extern UT_array *global_scope_stack;
-  coro->scope = js->scope;
-  coro->scope_stack = global_scope_stack;
-  js->scope = saved.scope;
-  global_scope_stack = saved.scope_stack;
-  for_let_swap_with_coro(js, coro);
-}
-
 static size_t calculate_coro_stack_size(void) {
   static size_t cached_size = 0;
   if (coro_stack_size_initialized) return cached_size;
@@ -116,147 +82,6 @@ static size_t calculate_coro_stack_size(void) {
   return cached_size;
 }
 
-static void mco_async_entry(mco_coro* mco) {
-  async_exec_context_t *ctx = (async_exec_context_t *)mco_get_user_data(mco);
-  
-  struct js *js = ctx->js;
-  coroutine_t *coro = ctx->coro;
-  jsval_t result;
-  
-  jsval_t saved_super = js->super_val;
-  jsval_t saved_new_target = js->new_target;
-  if (coro) {
-    js->super_val = coro->super_val;
-    js->new_target = coro->new_target;
-  }
-  
-  if (coro && coro->nargs > 0 && coro->args) {
-    result = call_js_code_with_args(js, ctx->code, (jsoff_t)ctx->code_len, ctx->closure_scope, coro->args, coro->nargs, js_mkundef());
-  } else result = call_js(js, ctx->code, (jsoff_t)ctx->code_len, ctx->closure_scope);
-  
-  js->super_val = saved_super;
-  js->new_target = saved_new_target;
-  
-  ctx->result = result;
-  ctx->has_error = is_err(result);
-  
-  if (ctx->has_error) {
-    jsval_t reject_value = js->thrown_value;
-    if (vtype(reject_value) == T_UNDEF) {
-      reject_value = js_mkstr(js, js->errmsg ? js->errmsg : "Unknown error", js->errmsg ? strlen(js->errmsg) : 13);
-    }
-    js->flags &= (uint8_t)~F_THROW;
-    js->thrown_value = js_mkundef();
-    js_reject_promise(js, ctx->promise, reject_value);
-  } else js_resolve_promise(js, ctx->promise, result);
-}
-
-jsval_t start_async_in_coroutine(struct js *js, const char *code, size_t code_len, jsval_t closure_scope, jsval_t *args, int nargs) {
-  if (++coros_this_tick > CORO_PER_TICK_LIMIT) {
-    js->fatal_error = true;
-    return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum async operations per tick exceeded");
-  }
-  
-  jsval_t promise = js_mkpromise(js);  
-  async_exec_context_t *ctx = (async_exec_context_t *)CORO_MALLOC(sizeof(async_exec_context_t));
-  if (!ctx) return js_mkerr(js, "out of memory for async context");
-  
-  ctx->js = js;
-  ctx->code = code;
-  ctx->code_len = code_len;
-  ctx->closure_scope = closure_scope;
-  ctx->result = js_mkundef();
-  ctx->promise = promise;
-  ctx->has_error = false;
-  ctx->coro = NULL;
-  
-  size_t stack_size = calculate_coro_stack_size();
-  mco_desc desc = mco_desc_init(mco_async_entry, stack_size);
-  desc.user_data = ctx;
-  
-  mco_coro* mco = NULL;
-  mco_result res = mco_create(&mco, &desc);
-  if (res != MCO_SUCCESS) {
-    CORO_FREE(ctx);
-    return js_mkerr(js, "failed to create minicoro coroutine");
-  }
-  
-  coroutine_t *coro = (coroutine_t *)CORO_MALLOC(sizeof(coroutine_t));
-  if (!coro) {
-    mco_destroy(mco);
-    CORO_FREE(ctx);
-    return js_mkerr(js, "out of memory for coroutine");
-  }
-  
-  *coro = (coroutine_t){
-    .js = js,
-    .type = CORO_ASYNC_AWAIT,
-    .scope = closure_scope,
-    .this_val = js->this_val,
-    .super_val = js->super_val,
-    .new_target = js->new_target,
-    .awaited_promise = js_mkundef(),
-    .result = js_mkundef(),
-    .async_func = js->current_func,
-    .args = NULL,
-    .nargs = nargs,
-    .is_settled = false,
-    .is_error = false,
-    .is_done = false,
-    .resume_point = 0,
-    .yield_value = js_mkundef(),
-    .next = NULL,
-    .mco = mco,
-    .mco_started = false,
-    .is_ready = true,
-    .for_let_stack = NULL,
-    .for_let_stack_len = 0,
-    .for_let_stack_cap = 0,
-  };
-  
-  if (nargs > 0) {
-    coro->args = (jsval_t *)CORO_MALLOC(sizeof(jsval_t) * nargs);
-    if (!coro->args) {
-      mco_destroy(mco); CORO_FREE(coro); CORO_FREE(ctx);
-      return js_mkerr(js, "out of memory for coroutine args");
-    }
-    memcpy(coro->args, args, sizeof(jsval_t) * nargs);
-  }
-  
-  extern UT_array *global_scope_stack;
-  utarray_new(coro->scope_stack, &jsoff_icd);
-  
-  if (!coro->scope_stack) {
-    mco_destroy(mco); CORO_FREE(coro); CORO_FREE(ctx);
-    return js_mkerr(js, "out of memory for coroutine scope stack");
-  }
-  
-  jsoff_t glob_off = (jsoff_t)vdata(js_glob(js));
-  utarray_push_back(coro->scope_stack, &glob_off);
-  
-  ctx->coro = coro;  
-  enqueue_coroutine(coro);
-  
-  coro_saved_state_t saved = coro_enter(js, coro);
-  res = mco_resume(mco);
-  coro_leave(js, coro, saved);
-  
-  if (res != MCO_SUCCESS && mco_status(mco) != MCO_DEAD) {
-    remove_coroutine(coro);
-    free_coroutine(coro);
-    return js_mkerr(js, "failed to start coroutine");
-  }
-  
-  coro->mco_started = true;
-  if (mco_status(mco) == MCO_DEAD) {
-    remove_coroutine(coro);
-    free_coroutine(coro);
-    js_gc_safepoint(js);
-  }
-  
-  return promise;
-}
-
 static inline void settle_coroutine(coroutine_t *coro, jsval_t *args, int nargs, bool is_error) {
   coro->result = nargs > 0 ? args[0] : js_mkundef();
   coro->is_settled = true;
@@ -264,21 +89,20 @@ static inline void settle_coroutine(coroutine_t *coro, jsval_t *args, int nargs,
   coro->is_ready = true;
 }
 
-static void resume_coroutine_if_suspended(struct js *js, coroutine_t *coro) {
+static void resume_coroutine_if_suspended(ant_t *js, coroutine_t *coro) {
   if (!coro || !coro->mco || mco_status(coro->mco) != MCO_SUSPENDED) return;
 
-  remove_coroutine(coro);
-  coro_saved_state_t saved = coro_enter(js, coro);
-  mco_result res = mco_resume(coro->mco);
-  coro_leave(js, coro, saved);
+  coro->is_ready = false;
+  mco_result res;
+  MCO_RESUME_SAVE(js, coro->mco, res);
 
-  if (res == MCO_SUCCESS && mco_status(coro->mco) != MCO_DEAD) {
-    coro->is_ready = false;
-    enqueue_coroutine(coro);
-  } else free_coroutine(coro);
+  if (res != MCO_SUCCESS || mco_status(coro->mco) == MCO_DEAD) {
+    remove_coroutine(coro);
+    free_coroutine(coro);
+  }
 }
 
-jsval_t resume_coroutine_wrapper(struct js *js, jsval_t *args, int nargs) {
+jsval_t resume_coroutine_wrapper(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t coro_val = js_get_slot(js, me, SLOT_CORO);
   if (vtype(coro_val) != T_NUM) return js_mkundef();
@@ -292,7 +116,7 @@ jsval_t resume_coroutine_wrapper(struct js *js, jsval_t *args, int nargs) {
   return js_mkundef();
 }
 
-jsval_t reject_coroutine_wrapper(struct js *js, jsval_t *args, int nargs) {
+jsval_t reject_coroutine_wrapper(ant_t *js, jsval_t *args, int nargs) {
   jsval_t me = js->current_func;
   jsval_t coro_val = js_get_slot(js, me, SLOT_CORO);
   
diff --git a/src/types/ant.d.ts b/src/types/ant.d.ts
index fd1e1bd..65cce1f 100644
--- a/src/types/ant.d.ts
+++ b/src/types/ant.d.ts
@@ -1,22 +1,21 @@
 type AntType =
-  | 'object'
-  | 'prop'
-  | 'string'
   | 'undefined'
   | 'null'
-  | 'number'
   | 'boolean'
+  | 'number'
+  | 'bigint'
+  | 'string'
+  | 'symbol'
+  | 'object'
+  | 'array'
   | 'function'
-  | 'coderef'
   | 'cfunc'
-  | 'err'
-  | 'array'
+  | 'closure'
   | 'promise'
-  | 'typedarray'
-  | 'bigint'
-  | 'propref'
-  | 'symbol'
   | 'generator'
+  | 'prop'
+  | 'err'
+  | 'typedarray'
   | 'ffi'
   | 'ntarg';
 
diff --git a/src/types/index.d.ts b/src/types/index.d.ts
index d7140ef..c2db1c6 100644
--- a/src/types/index.d.ts
+++ b/src/types/index.d.ts
@@ -16,3 +16,5 @@
 /// <reference path="modules/events.d.ts" />
 /// <reference path="modules/ffi.d.ts" />
 /// <reference path="modules/shell.d.ts" />
+/// <reference path="modules/util.d.ts" />
+/// <reference path="modules/worker_threads.d.ts" />
diff --git a/src/types/modules/fs.d.ts b/src/types/modules/fs.d.ts
index 56ca1ff..4a0c751 100644
--- a/src/types/modules/fs.d.ts
+++ b/src/types/modules/fs.d.ts
@@ -15,13 +15,22 @@ declare module 'fs' {
     W_OK: number;
     X_OK: number;
   };
+  const promises: typeof import('fs/promises');
 
   function readFile(path: string): Promise<string>;
   function readFileSync(path: string): string;
+  function readSync(fd: number, buffer: ArrayBufferView, offset?: number, length?: number, position?: number | null): number;
   function stream(path: string): Promise<string>;
-  function open(path: string): string;
+  function open(path: string, flags?: string, mode?: number): Promise<number>;
+  function openSync(path: string, flags?: string, mode?: number): number;
+  function close(fd: number): Promise<void>;
+  function closeSync(fd: number): void;
   function writeFile(path: string, data: string): Promise<void>;
   function writeFileSync(path: string, data: string): void;
+  function write(fd: number, data: string | ArrayBufferView, offset?: number, length?: number, position?: number | null): Promise<number>;
+  function writeSync(fd: number, data: string | ArrayBufferView, offset?: number, length?: number, position?: number | null): number;
+  function writev(fd: number, buffers: ArrayBufferView[], position?: number): Promise<number>;
+  function writevSync(fd: number, buffers: ArrayBufferView[], position?: number): number;
   function appendFileSync(path: string, data: string): void;
   function copyFileSync(src: string, dest: string): void;
   function renameSync(oldPath: string, newPath: string): void;
@@ -48,3 +57,44 @@ declare module 'ant:fs' {
 declare module 'node:fs' {
   export * from 'fs';
 }
+
+declare module 'fs/promises' {
+  interface Stats {
+    size: number;
+    mode: number;
+    uid: number;
+    gid: number;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+  }
+
+  const constants: {
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+  };
+
+  function readFile(path: string): Promise<string>;
+  function open(path: string, flags?: string, mode?: number): Promise<number>;
+  function close(fd: number): Promise<void>;
+  function writeFile(path: string, data: string): Promise<void>;
+  function write(fd: number, data: string | ArrayBufferView, offset?: number, length?: number, position?: number | null): Promise<number>;
+  function writev(fd: number, buffers: ArrayBufferView[], position?: number): Promise<number>;
+  function unlink(path: string): Promise<void>;
+  function mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  function rmdir(path: string): Promise<void>;
+  function stat(path: string): Promise<Stats>;
+  function exists(path: string): Promise<boolean>;
+  function access(path: string, mode?: number): Promise<void>;
+  function readdir(path: string): Promise<string[]>;
+}
+
+declare module 'ant:fs/promises' {
+  export * from 'fs/promises';
+}
+
+declare module 'node:fs/promises' {
+  export * from 'fs/promises';
+}
diff --git a/src/types/modules/util.d.ts b/src/types/modules/util.d.ts
new file mode 100644
index 0000000..76d067a
--- /dev/null
+++ b/src/types/modules/util.d.ts
@@ -0,0 +1,33 @@
+declare module 'util' {
+  type StyleTextFormat = string | string[];
+
+  interface StyleTextOptions {
+    validateStream?: boolean;
+    stream?: unknown;
+  }
+
+  function format(format?: unknown, ...args: unknown[]): string;
+  function formatWithOptions(
+    inspectOptions: unknown,
+    format?: unknown,
+    ...args: unknown[]
+  ): string;
+  function inspect(value: unknown, options?: unknown): string;
+  function promisify(
+    fn: (...args: unknown[]) => unknown
+  ): (...args: unknown[]) => Promise<unknown>;
+  function stripVTControlCharacters(str: string): string;
+  function styleText(
+    format: StyleTextFormat,
+    text: string,
+    options?: StyleTextOptions
+  ): string;
+}
+
+declare module 'ant:util' {
+  export * from 'util';
+}
+
+declare module 'node:util' {
+  export * from 'util';
+}
diff --git a/src/types/modules/worker_threads.d.ts b/src/types/modules/worker_threads.d.ts
new file mode 100644
index 0000000..9f84c28
--- /dev/null
+++ b/src/types/modules/worker_threads.d.ts
@@ -0,0 +1,59 @@
+declare module 'worker_threads' {
+  interface MessagePort {
+    postMessage(value: unknown): void;
+    on(event: 'message', listener: (value: unknown) => void): this;
+    once(event: 'message', listener: (value: unknown) => void): this;
+    start(): void;
+    close(): void;
+    ref(): void;
+    unref(): void;
+    onmessage: ((event: { data: unknown }) => void) | undefined;
+  }
+
+  class MessageChannel {
+    port1: MessagePort;
+    port2: MessagePort;
+  }
+
+  class MessagePort {
+    private constructor();
+  }
+
+  interface WorkerOptions {
+    workerData?: unknown;
+  }
+
+  class Worker {
+    constructor(filename: string | URL, options?: WorkerOptions);
+    on(event: 'message' | 'exit', listener: (...args: unknown[]) => void): this;
+    once(event: 'message' | 'exit', listener: (...args: unknown[]) => void): this;
+    terminate(): Promise<number>;
+    ref(): this;
+    unref(): this;
+    postMessage(value: unknown): void;
+  }
+
+  const isMainThread: boolean;
+  const threadId: number;
+  const parentPort: {
+    postMessage(value: unknown): void;
+    ref(): void;
+    unref(): void;
+  } | null;
+  const workerData: unknown;
+  const SHARE_ENV: symbol;
+
+  function markAsUntransferable<T>(value: T): T;
+  function receiveMessageOnPort(port: MessagePort): { message: unknown } | undefined;
+  function setEnvironmentData(key: unknown, value: unknown): void;
+  function getEnvironmentData(key: unknown): unknown;
+  function moveMessagePortToContext(port: MessagePort, contextifiedSandbox: unknown): MessagePort;
+}
+
+declare module 'ant:worker_threads' {
+  export * from 'worker_threads';
+}
+
+declare module 'node:worker_threads' {
+  export * from 'worker_threads';
+}
diff --git a/src/types/process.d.ts b/src/types/process.d.ts
index 70ea0ba..0a504e1 100644
--- a/src/types/process.d.ts
+++ b/src/types/process.d.ts
@@ -8,6 +8,14 @@ interface Features {
   typescript: 'transform' | 'none';
 }
 
+interface Versions {
+  node: string;
+  ant: string;
+  v8: string;
+  uv: string;
+  modules: string;
+}
+
 interface Process {
   env: ProcessEnv;
   argv: string[];
@@ -16,7 +24,9 @@ interface Process {
   arch: string;
   exit(code?: number): never;
   cwd(): string;
+  dlopen(module: { exports?: unknown }, filename: string): void;
   features: Features;
+  versions: Versions;
 }
 
 declare const process: Process;
diff --git a/src/utf8.c b/src/utf8.c
index 93d3066..25df978 100644
--- a/src/utf8.c
+++ b/src/utf8.c
@@ -1,60 +1,11 @@
 #include "utf8.h"
 #include <string.h>
 
-int utf8_sequence_length(unsigned char first_byte) {
-  if ((first_byte & 0x80) == 0) return 1;
-  if ((first_byte & 0xE0) == 0xC0) return 2;
-  if ((first_byte & 0xF0) == 0xE0) return 3;
-  if ((first_byte & 0xF8) == 0xF0) return 4;
-  return -1;
-}
-
-int utf8_encode(uint32_t cp, char *out) {
-  if (cp < 0x80) {
-    out[0] = (char)cp;
-    return 1;
-  } else if (cp < 0x800) {
-    out[0] = (char)(0xC0 | (cp >> 6));
-    out[1] = (char)(0x80 | (cp & 0x3F));
-    return 2;
-  } else if (cp < 0x10000) {
-    out[0] = (char)(0xE0 | (cp >> 12));
-    out[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
-    out[2] = (char)(0x80 | (cp & 0x3F));
-    return 3;
-  } else {
-    out[0] = (char)(0xF0 | (cp >> 18));
-    out[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
-    out[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
-    out[3] = (char)(0x80 | (cp & 0x3F));
-    return 4;
-  }
-}
-
-uint32_t utf8_decode(const unsigned char *buf, size_t len, int *seq_len) {
+static uint32_t utf8_decode(const unsigned char *buf, size_t len, int *seq_len) {
   if (len == 0) { *seq_len = 0; return 0; }
-  
-  unsigned char first = buf[0];
-  
-  if (first < 0x80) { *seq_len = 1; return first; }
-  if ((first & 0xE0) == 0xC0 && len >= 2) {
-    if ((buf[1] & 0xC0) != 0x80) { *seq_len = 1; return 0xFFFD; }
-    *seq_len = 2;
-    return ((first & 0x1F) << 6) | (buf[1] & 0x3F);
-  }
-  if ((first & 0xF0) == 0xE0 && len >= 3) {
-    if ((buf[1] & 0xC0) != 0x80 || (buf[2] & 0xC0) != 0x80) { *seq_len = 1; return 0xFFFD; }
-    *seq_len = 3;
-    return ((first & 0x0F) << 12) | ((buf[1] & 0x3F) << 6) | (buf[2] & 0x3F);
-  }
-  if ((first & 0xF8) == 0xF0 && len >= 4) {
-    if ((buf[1] & 0xC0) != 0x80 || (buf[2] & 0xC0) != 0x80 || (buf[3] & 0xC0) != 0x80) { *seq_len = 1; return 0xFFFD; }
-    *seq_len = 4;
-    return ((first & 0x07) << 18) | ((buf[1] & 0x3F) << 12) | ((buf[2] & 0x3F) << 6) | (buf[3] & 0x3F);
-  }
-  
-  *seq_len = 1;
-  return 0xFFFD;
+  utf8proc_int32_t cp;
+  *seq_len = (int)utf8_next(buf, (utf8proc_ssize_t)len, &cp);
+  return cp < 0 ? 0xFFFD : (uint32_t)cp;
 }
 
 size_t utf8_char_len_at(const char *str, size_t byte_len, size_t pos) {
@@ -82,7 +33,6 @@ size_t utf16_strlen(const char *str, size_t byte_len) {
   const unsigned char *p = (const unsigned char *)str;
   const unsigned char *end = p + byte_len;
   
-  // Fast path: check if string is ASCII-only (very common case)
   size_t i = 0;
   for (; i + 8 <= byte_len; i += 8) {
     uint64_t chunk;
@@ -92,16 +42,16 @@ size_t utf16_strlen(const char *str, size_t byte_len) {
   for (; i < byte_len; i++) {
     if (p[i] & 0x80) goto slow_path;
   }
-  return byte_len;  // All ASCII: UTF-16 length == byte length
+  return byte_len;
   
 slow_path:;
-  size_t count = i;  // ASCII chars counted before first non-ASCII
+  size_t count = i;
   p += i;
   while (p < end) {
     unsigned char c = *p;
     if ((c & 0xC0) != 0x80) {
       count++;
-      if ((c & 0xF8) == 0xF0) count++;  // 4-byte UTF-8 = 2 UTF-16 units
+      if ((c & 0xF8) == 0xF0) count++;
     }
     p++;
   }
@@ -132,12 +82,16 @@ int utf16_index_to_byte_offset(
     if (utf16_pos == utf16_idx) {
       if (out_char_bytes) *out_char_bytes = 0;
       return (int)byte_len;
-    }
-    return -1;
+    } return -1;
   }
   
   unsigned char c = *p;
-  size_t slen = (c < 0x80) ? 1 : ((c & 0xE0) == 0xC0) ? 2 : ((c & 0xF0) == 0xE0) ? 3 : ((c & 0xF8) == 0xF0) ? 4 : 1;
+  size_t slen = (c < 0x80) 
+    ? 1 : ((c & 0xE0) == 0xC0) 
+    ? 2 : ((c & 0xF0) == 0xE0) 
+    ? 3 : ((c & 0xF8) == 0xF0) 
+    ? 4 : 1;
+    
   if (out_char_bytes) *out_char_bytes = slen;
   return (int)(p - (const unsigned char *)str);
 }
@@ -152,6 +106,7 @@ int utf16_range_to_byte_range(
 ) {
   const unsigned char *p = (const unsigned char *)str;
   const unsigned char *end = p + byte_len;
+  
   size_t utf16_pos = 0;
   size_t b_start = 0, b_end = byte_len;
   int found_start = 0, found_end = 0;
@@ -174,6 +129,7 @@ int utf16_range_to_byte_range(
   
   *byte_start = b_start;
   *byte_end = b_end;
+  
   return 0;
 }
 
@@ -189,13 +145,22 @@ uint32_t utf16_code_unit_at(const char *str, size_t byte_len, size_t utf16_idx)
     
     if (c < 0x80) { cp = c; slen = 1; units = 1; }
     else if ((c & 0xE0) == 0xC0 && p + 1 < end) {
-      cp = ((c & 0x1F) << 6) | (p[1] & 0x3F); slen = 2; units = 1;
+      cp = ((c & 0x1F) << 6)
+      | (p[1] & 0x3F); 
+      slen = 2; units = 1;
     }
     else if ((c & 0xF0) == 0xE0 && p + 2 < end) {
-      cp = ((c & 0x0F) << 12) | ((p[1] & 0x3F) << 6) | (p[2] & 0x3F); slen = 3; units = 1;
+      cp = ((c & 0x0F) << 12)
+      | ((p[1] & 0x3F) << 6)
+      | (p[2] & 0x3F); 
+      slen = 3; units = 1;
     }
     else if ((c & 0xF8) == 0xF0 && p + 3 < end) {
-      cp = ((c & 0x07) << 18) | ((p[1] & 0x3F) << 12) | ((p[2] & 0x3F) << 6) | (p[3] & 0x3F); slen = 4; units = 2;
+      cp = ((c & 0x07) << 18) 
+      | ((p[1] & 0x3F) << 12) 
+      | ((p[2] & 0x3F) << 6)
+      | (p[3] & 0x3F); 
+      slen = 4; units = 2;
     }
     else { cp = c; slen = 1; units = 1; }
     
@@ -209,6 +174,7 @@ uint32_t utf16_code_unit_at(const char *str, size_t byte_len, size_t utf16_idx)
     p += slen;
     utf16_pos += units;
   }
+  
   return 0xFFFFFFFF;
 }
 
@@ -224,13 +190,22 @@ uint32_t utf16_codepoint_at(const char *str, size_t byte_len, size_t utf16_idx)
     
     if (c < 0x80) { cp = c; slen = 1; units = 1; }
     else if ((c & 0xE0) == 0xC0 && p + 1 < end) {
-      cp = ((c & 0x1F) << 6) | (p[1] & 0x3F); slen = 2; units = 1;
+      cp = ((c & 0x1F) << 6)
+      | (p[1] & 0x3F); 
+      slen = 2; units = 1;
     }
     else if ((c & 0xF0) == 0xE0 && p + 2 < end) {
-      cp = ((c & 0x0F) << 12) | ((p[1] & 0x3F) << 6) | (p[2] & 0x3F); slen = 3; units = 1;
+      cp = ((c & 0x0F) << 12)
+      | ((p[1] & 0x3F) << 6)
+      | (p[2] & 0x3F); 
+      slen = 3; units = 1;
     }
     else if ((c & 0xF8) == 0xF0 && p + 3 < end) {
-      cp = ((c & 0x07) << 18) | ((p[1] & 0x3F) << 12) | ((p[2] & 0x3F) << 6) | (p[3] & 0x3F); slen = 4; units = 2;
+      cp = ((c & 0x07) << 18)
+      | ((p[1] & 0x3F) << 12)
+      | ((p[2] & 0x3F) << 6)
+      | (p[3] & 0x3F); 
+      slen = 4; units = 2;
     }
     else { cp = c; slen = 1; units = 1; }
     
@@ -238,8 +213,10 @@ uint32_t utf16_codepoint_at(const char *str, size_t byte_len, size_t utf16_idx)
     if (units == 2 && utf16_pos + 1 == utf16_idx) {
       return 0xDC00 + ((cp - 0x10000) & 0x3FF);
     }
+    
     p += slen;
     utf16_pos += units;
   }
+  
   return 0xFFFFFFFF;
 }
diff --git a/src/utils.c b/src/utils.c
index f92cf09..59dd789 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -1,15 +1,16 @@
 #include "utils.h"
 #include "messages.h"
 
+#include <oxc.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <sys/stat.h>
 #include <crprintf.h>
 
-static const char *const js_extensions[] = {
-  ".js", ".ts", 
-  ".cjs", ".mjs", 
-  ".jsx", ".tsx", NULL
+const char *const module_resolve_extensions[] = {
+  ".js", ".mjs", ".cjs",
+  ".ts", ".mts", ".cts",
+  ".json", ".node", NULL
 };
 
 int hex_digit(char c) {
@@ -58,10 +59,76 @@ int is_typescript_file(const char *filename) {
   return (strcmp(ext, ".ts") == 0 || strcmp(ext, ".mts") == 0 || strcmp(ext, ".cts") == 0);
 }
 
+int strip_typescript_inplace(
+  char **buffer,
+  size_t len,
+  const char *filename,
+  size_t *out_len,
+  const char **error_detail
+) {
+  if (out_len) *out_len = len;
+  if (error_detail) *error_detail = NULL;
+  if (!is_typescript_file(filename)) return 0;
+
+  if (!buffer || !*buffer) {
+    if (error_detail) *error_detail = "null input/output passed";
+    return OXC_ERR_NULL_INPUT;
+  }
+  
+  char *input = *buffer;
+  char error_buf[256] = {0};
+  size_t stripped_len = 0;
+  
+  int strip_error = OXC_ERR_TRANSFORM_FAILED;
+  char *stripped = OXC_strip_types_owned(
+    input, filename,
+    &stripped_len, &strip_error,
+    error_buf, sizeof(error_buf)
+  );
+
+  if (!stripped) {
+    if (error_buf[0] != '\0') {
+      size_t msg_len = strlen(error_buf);
+      size_t copy_len = msg_len > len ? len : msg_len;
+      memcpy(input, error_buf, copy_len);
+      input[copy_len] = '\0';
+    } else input[0] = '\0';
+
+    if (error_detail) {
+      *error_detail = input[0] != '\0' ? input : "unknown strip error";
+    }
+    
+    return strip_error;
+  }
+
+  char *next = realloc(input, stripped_len + 1);
+  if (!next) {
+    OXC_free_stripped_output(stripped, stripped_len);
+    if (error_detail) *error_detail = "out of memory while resizing strip output buffer";
+    return OXC_ERR_OUTPUT_TOO_LARGE;
+  }
+
+  memcpy(next, stripped, stripped_len + 1);
+  OXC_free_stripped_output(stripped, stripped_len);
+
+  *buffer = next;
+  if (out_len) *out_len = stripped_len;
+  
+  return 0;
+}
+
+static bool is_entrypoint_script_extension(const char *ext) {
+  return 
+    ext && 
+    strcmp(ext, ".json") != 0 &&
+    strcmp(ext, ".node") != 0;
+}
+
 static bool has_js_extension(const char *filename) {
   const char *dot = strrchr(filename, '.');
   if (!dot) return false;
-  for (const char *const *ext = js_extensions; *ext; ext++) {
+  for (const char *const *ext = module_resolve_extensions; *ext; ext++) {
+    if (!is_entrypoint_script_extension(*ext)) continue;
     if (strcmp(dot, *ext) == 0) return true;
   }
   return false;
@@ -74,20 +141,33 @@ char *resolve_js_file(const char *filename) {
   
   struct stat st;
   if (stat(filename, &st) == 0) {
-    if (S_ISREG(st.st_mode)) return strdup(filename);
+    if (S_ISREG(st.st_mode)) {
+      const char *dot = strrchr(filename, '.');
+      if (dot && !has_js_extension(filename)) return NULL;
+      return strdup(filename);
+    }
     if (!S_ISDIR(st.st_mode)) return NULL;
 
     size_t len = strlen(filename);
     int has_slash = (len > 0 && filename[len - 1] == '/');
-    char *index_path = try_oom(len + 10 + (has_slash ? 0 : 1));
-    sprintf(index_path, "%s%sindex.js", filename, has_slash ? "" : "/");
-    return index_path;
+    
+    for (const char *const *ext = module_resolve_extensions; *ext; ext++) {
+      if (!is_entrypoint_script_extension(*ext)) continue;
+      size_t ext_len = strlen(*ext);
+      char *index_path = try_oom(len + 7 + ext_len + 1);
+      sprintf(index_path, "%s%sindex%s", filename, has_slash ? "" : "/", *ext);
+      if (stat(index_path, &st) == 0 && S_ISREG(st.st_mode)) return index_path;
+      free(index_path);
+    }
+    
+    return NULL;
   }
   
   if (has_js_extension(filename)) return NULL;
   size_t base_len = strlen(filename);
   
-  for (const char *const *ext = js_extensions; *ext; ext++) {
+  for (const char *const *ext = module_resolve_extensions; *ext; ext++) {
+    if (!is_entrypoint_script_extension(*ext)) continue;
     size_t ext_len = strlen(*ext);
     char *test_path = try_oom(base_len + ext_len + 1);
     
@@ -102,6 +182,90 @@ char *resolve_js_file(const char *filename) {
   return NULL;
 }
 
+typedef struct {
+  const char *repl; size_t repl_len; size_t *ri;
+  const char *matched; size_t matched_len;
+  const char *str; size_t str_len; size_t position;
+  const repl_capture_t *caps; int ncaptures;
+  char **buf; size_t *buf_len; size_t *buf_cap;
+} rt_ctx_t;
+
+#define RT_APPEND(c, data, dlen) do { \
+  if (*(c)->buf_len + (dlen) >= *(c)->buf_cap) { \
+    *(c)->buf_cap = (*(c)->buf_len + (dlen) + 1) * 2; \
+    *(c)->buf = realloc(*(c)->buf, *(c)->buf_cap); \
+  } \
+  memcpy(*(c)->buf + *(c)->buf_len, data, dlen); *(c)->buf_len += (dlen); \
+} while(0)
+
+static void rt_dollar(rt_ctx_t *c)  { RT_APPEND(c, "$", 1); *c->ri += 2; }
+static void rt_match(rt_ctx_t *c)   { RT_APPEND(c, c->matched, c->matched_len); *c->ri += 2; }
+static void rt_prefix(rt_ctx_t *c)  { RT_APPEND(c, c->str, c->position); *c->ri += 2; }
+
+static void rt_suffix(rt_ctx_t *c) {
+  size_t after = c->position + c->matched_len;
+  if (after < c->str_len) RT_APPEND(c, c->str + after, c->str_len - after);
+  *c->ri += 2;
+}
+
+static void rt_capture(rt_ctx_t *c) {
+  char nc = c->repl[*c->ri + 1];
+  int gn = nc - '0';
+  *c->ri += 2;
+  if (*c->ri < c->repl_len && c->repl[*c->ri] >= '0' && c->repl[*c->ri] <= '9') {
+    int two = gn * 10 + (c->repl[*c->ri] - '0');
+    if (two <= c->ncaptures) { gn = two; (*c->ri)++; }
+  }
+  if (gn > 0 && gn <= c->ncaptures && c->caps[gn - 1].ptr) {
+    RT_APPEND(c, c->caps[gn - 1].ptr, c->caps[gn - 1].len);
+  } else if (gn == 0 || gn > c->ncaptures) {
+    RT_APPEND(c, "$", 1); RT_APPEND(c, &nc, 1);
+  }
+}
+
+typedef void (*rt_handler_t)(rt_ctx_t *);
+static rt_handler_t rt_dispatch[128];
+static bool rt_dispatch_init = false;
+
+static void rt_init_dispatch(void) {
+  if (rt_dispatch_init) return;
+  rt_dispatch['$'] = rt_dollar;
+  rt_dispatch['&'] = rt_match;
+  rt_dispatch['`'] = rt_prefix;
+  rt_dispatch['\''] = rt_suffix;
+  for (int i = '0'; i <= '9'; i++) rt_dispatch[i] = rt_capture;
+  rt_dispatch_init = true;
+}
+
+void repl_template(
+  const char *repl, size_t repl_len,
+  const char *matched, size_t matched_len,
+  const char *str, size_t str_len, size_t position,
+  const repl_capture_t *caps, int ncaptures,
+  char **buf, size_t *buf_len, size_t *buf_cap
+) {
+  rt_init_dispatch();
+  rt_ctx_t c = {
+    repl, repl_len, NULL,
+    matched, matched_len,
+    str, str_len, position,
+    caps, ncaptures,
+    buf, buf_len, buf_cap,
+  };
+  
+  for (size_t ri = 0; ri < repl_len; ) {
+    if (repl[ri] == '$' && ri + 1 < repl_len) {
+      unsigned char nc = (unsigned char)repl[ri + 1];
+      c.ri = &ri;
+      rt_handler_t h = nc < 128 ? rt_dispatch[nc] : NULL;
+      if (h) { h(&c); continue; }
+    }
+    RT_APPEND(&c, &repl[ri], 1); ri++;
+  }
+}
+
+#undef RT_APPEND
+
 void *try_oom(size_t size) {
   void *p = malloc(size);
   if (!p) {
diff --git a/tests/ack.js b/tests/ack.js
index 196b67c..e380e95 100644
--- a/tests/ack.js
+++ b/tests/ack.js
@@ -5,4 +5,4 @@ function ack(i, j) {
   return ack(i - 1, ack(i, j - 1));
 }
 
-console.log(ack(3, 3));
+console.log(ack(3, 6));
diff --git a/tests/bench_array_from.js b/tests/bench_array_from.js
new file mode 100644
index 0000000..927cf32
--- /dev/null
+++ b/tests/bench_array_from.js
@@ -0,0 +1,49 @@
+const ITERATIONS = 1_000_000;
+const source = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const mapFn = x => x * 2;
+
+// --- Polyfill ---
+const ArrayFrom_polyfill = function (src, mapFn, thisArg) {
+  if (src == null) {
+    console.error('TypeError: Cannot convert undefined or null to object');
+    return [];
+  }
+  if (mapFn !== undefined && typeof mapFn !== 'function') {
+    console.error('TypeError: mapFn is not a function');
+    return [];
+  }
+  const arr = [];
+  let i = 0;
+  if (src[Symbol.iterator] != null) {
+    for (const v of src) arr.push(mapFn ? mapFn.call(thisArg, v, i++) : v);
+  } else {
+    const len = src.length >>> 0;
+    for (; i < len; i++) arr.push(mapFn ? mapFn.call(thisArg, src[i], i) : src[i]);
+  }
+  return arr;
+};
+
+// --- Builtin ---
+function benchBuiltin() {
+  const start = performance.now();
+  for (let i = 0; i < ITERATIONS; i++) {
+    Array.from(source, mapFn);
+  }
+  return performance.now() - start;
+}
+
+// --- Polyfill ---
+function benchPolyfill() {
+  const start = performance.now();
+  for (let i = 0; i < ITERATIONS; i++) {
+    ArrayFrom_polyfill(source, mapFn);
+  }
+  return performance.now() - start;
+}
+
+const builtinMs = benchBuiltin();
+const polyfillMs = benchPolyfill();
+
+console.log(`Array.from (builtin):  ${builtinMs.toFixed(2)} ms`);
+console.log(`Array.from (polyfill): ${polyfillMs.toFixed(2)} ms`);
+console.log(`Ratio: builtin is ${(polyfillMs / builtinMs).toFixed(2)}x ${polyfillMs > builtinMs ? 'faster' : 'slower'} than polyfill`);
diff --git a/tests/bench_gc.js b/tests/bench_gc.js
index 15f1f2d..8fd1b24 100644
--- a/tests/bench_gc.js
+++ b/tests/bench_gc.js
@@ -11,10 +11,6 @@ function bench(name, fn, iterations = 1) {
   for (let iter = 0; iter < iterations; iter++) fn();
   const afterAlloc = Ant.stats().arenaUsed;
 
-  console.log('  Waiting 5s before GC...');
-  Ant.sleep(5);
-  Ant.gc();
-
   console.log(`${name}:`);
   console.log(`  Before: ${fmt(before)}, After alloc: ${fmt(afterAlloc)}`);
   console.log(`  Allocated: ${fmt(afterAlloc - before)} (${iterations} iterations)`);
@@ -99,6 +95,3 @@ bench('String array (5000 strings)', stringArray, 5);
 bench('Mixed workload', mixedWorkload, 5);
 
 showStats('Final state', Ant.stats());
-
-console.log('Note: GC runs automatically at safe points.');
-console.log('Use Ant.gc() as a hint to request collection.');
diff --git a/tests/bench_jit_deopt.js b/tests/bench_jit_deopt.js
new file mode 100644
index 0000000..a4286d8
--- /dev/null
+++ b/tests/bench_jit_deopt.js
@@ -0,0 +1,286 @@
+// Benchmark: JIT deoptimization & recompilation
+//
+// Scenarios:
+//   1. Single bailout → recompile → regain JIT speed
+//   2. Repeated bailouts → permanent ban
+//   3. No bailout baseline (pure numeric hot loop)
+//   4. Periodic type instability across rounds
+//   5. Correctness across all JIT states
+//   6. Multi-op arithmetic chain (ADD/SUB/MUL/DIV) bailout recovery
+//   7. Large hot loop — JIT vs interpreter throughput
+//   8. Rapid-fire bailouts (many in quick succession)
+//   9. Comparison operators bailout recovery
+//  10. Closure with upvalue — bailout and recovery
+
+var get_clock = typeof performance !== 'undefined' ? performance.now : Date.now;
+var JIT_THRESHOLD = 100;
+var RECOMPILE_DELAY = 50;
+var ITER = 500000;
+
+function timeit(fn, label) {
+  var best = Infinity;
+  for (var t = 0; t < 3; t++) {
+    var t0 = get_clock();
+    var result = fn();
+    var elapsed = get_clock() - t0;
+    if (elapsed < best) best = elapsed;
+  }
+  console.log('  ' + label + ': ' + best.toFixed(2) + ' ms');
+  return best;
+}
+
+function warmup(fn, n) {
+  for (var i = 0; i < (n || JIT_THRESHOLD + 10); i++) fn(i, i + 1);
+}
+
+// ============================================================
+// Scenario 1: Single bailout then recompile
+// ============================================================
+console.log('--- S1: single bailout + recompile ---');
+
+function addS1(a, b) { return a + b; }
+warmup(addS1);
+
+var s1_before = timeit(function() {
+  var s = 0;
+  for (var i = 0; i < ITER; i++) s = addS1(s, 1);
+  return s;
+}, 'before bailout');
+
+addS1('bail', 'out');
+warmup(addS1, RECOMPILE_DELAY + 10);
+
+var s1_after = timeit(function() {
+  var s = 0;
+  for (var i = 0; i < ITER; i++) s = addS1(s, 1);
+  return s;
+}, 'after recompile');
+
+// ============================================================
+// Scenario 2: Exhaust deopts → permanent ban
+// ============================================================
+console.log('');
+console.log('--- S2: permanent ban ---');
+
+function addS2(a, b) { return a + b; }
+
+for (var deopt = 0; deopt < 4; deopt++) {
+  warmup(addS2);
+  addS2('x' + deopt, 'y');
+  warmup(addS2, RECOMPILE_DELAY + 10);
+}
+// should be banned now regardless of strategy
+for (var i = 0; i < JIT_THRESHOLD * 3; i++) addS2(i, i + 1);
+
+var s2 = timeit(function() {
+  var s = 0;
+  for (var i = 0; i < ITER; i++) s = addS2(s, 1);
+  return s;
+}, 'banned (interpreter)');
+
+// ============================================================
+// Scenario 3: Pure numeric baseline
+// ============================================================
+console.log('');
+console.log('--- S3: pure numeric baseline ---');
+
+function addS3(a, b) { return a + b; }
+warmup(addS3);
+
+var s3 = timeit(function() {
+  var s = 0;
+  for (var i = 0; i < ITER; i++) s = addS3(s, 1);
+  return s;
+}, 'JIT baseline');
+
+// ============================================================
+// Scenario 4: Periodic type instability
+// ============================================================
+console.log('');
+console.log('--- S4: periodic type instability ---');
+
+function addS4(a, b) { return a + b; }
+
+var s4_times = [];
+for (var round = 0; round < 8; round++) {
+  warmup(addS4);
+  var t = timeit(function() {
+    var s = 0;
+    for (var i = 0; i < ITER; i++) s = addS4(s, 1);
+    return s;
+  }, 'round ' + round);
+  s4_times.push(t);
+  addS4('round', String(round));
+  warmup(addS4, RECOMPILE_DELAY + 10);
+}
+
+// ============================================================
+// Scenario 5: Correctness across all JIT states
+// ============================================================
+console.log('');
+console.log('--- S5: correctness ---');
+
+function compute(a, b) { return a + b; }
+var allCorrect = true;
+
+warmup(compute);
+if (compute(20, 22) !== 42) { allCorrect = false; console.log('  FAIL: numeric JIT'); }
+if (compute('hello', ' world') !== 'hello world') { allCorrect = false; console.log('  FAIL: string bailout'); }
+if (compute(100, -58) !== 42) { allCorrect = false; console.log('  FAIL: numeric post-bailout'); }
+warmup(compute, RECOMPILE_DELAY + 10);
+if (compute(20, 22) !== 42) { allCorrect = false; console.log('  FAIL: numeric recompile'); }
+if (compute('foo', 'bar') !== 'foobar') { allCorrect = false; console.log('  FAIL: string bailout 2'); }
+warmup(compute, RECOMPILE_DELAY + 10);
+if (compute(1, 1) !== 2) { allCorrect = false; console.log('  FAIL: numeric recompile 2'); }
+if (compute('a', 'b') !== 'ab') { allCorrect = false; console.log('  FAIL: string bailout 3'); }
+for (var i = 0; i < 500; i++) compute(i, 1);
+if (compute(20, 22) !== 42) { allCorrect = false; console.log('  FAIL: numeric after ban'); }
+console.log('  all correct: ' + allCorrect);
+
+// ============================================================
+// Scenario 6: Multi-op arithmetic chain — bailout recovery
+// ============================================================
+console.log('');
+console.log('--- S6: arithmetic chain bailout ---');
+
+function mathChain(a, b, c) {
+  var x = a + b;
+  var y = x * c;
+  var z = y - a;
+  return z / b;
+}
+
+for (var i = 1; i < JIT_THRESHOLD + 10; i++) mathChain(i, i + 1, 2);
+
+var s6_before = timeit(function() {
+  var s = 0;
+  for (var i = 1; i <= ITER; i++) s = mathChain(i, i + 1, 2);
+  return s;
+}, 'chain before bailout');
+
+// bailout: string in numeric chain triggers coercion
+mathChain('10', 5, 3);
+
+for (var i = 1; i < RECOMPILE_DELAY + 10; i++) mathChain(i, i + 1, 2);
+
+var s6_after = timeit(function() {
+  var s = 0;
+  for (var i = 1; i <= ITER; i++) s = mathChain(i, i + 1, 2);
+  return s;
+}, 'chain after recompile');
+
+// ============================================================
+// Scenario 7: Large hot loop — throughput comparison
+// ============================================================
+console.log('');
+console.log('--- S7: large hot loop throughput ---');
+
+function hotSum(n) {
+  var sum = 0;
+  for (var i = 0; i < n; i++) sum = sum + i;
+  return sum;
+}
+
+warmup(function(i) { hotSum(10); return i; });
+
+var s7_jit = timeit(function() { return hotSum(1000000); }, 'JIT 1M loop');
+
+// bailout
+hotSum('not a number');
+warmup(function(i) { hotSum(10); return i; }, RECOMPILE_DELAY + 10);
+
+var s7_recover = timeit(function() { return hotSum(1000000); }, 'after bailout 1M');
+
+// ============================================================
+// Scenario 8: Rapid-fire bailouts
+// ============================================================
+console.log('');
+console.log('--- S8: rapid-fire bailouts ---');
+
+function addRapid(a, b) { return a + b; }
+
+warmup(addRapid);
+
+// fire 10 bailouts in quick succession, re-warming each time
+for (var k = 0; k < 10; k++) {
+  addRapid('rapid' + k, '!');
+  warmup(addRapid, RECOMPILE_DELAY + 10);
+}
+
+var s8 = timeit(function() {
+  var s = 0;
+  for (var i = 0; i < ITER; i++) s = addRapid(s, 1);
+  return s;
+}, 'after 10 rapid bailouts');
+
+// ============================================================
+// Scenario 9: Comparison operators
+// ============================================================
+console.log('');
+console.log('--- S9: comparison bailout ---');
+
+function ltCmp(a, b) { return a < b; }
+
+for (var i = 0; i < JIT_THRESHOLD + 10; i++) ltCmp(i, 100);
+
+var s9_before = timeit(function() {
+  var c = 0;
+  for (var i = 0; i < ITER; i++) { if (ltCmp(i, ITER / 2)) c++; }
+  return c;
+}, 'LT before bailout');
+
+ltCmp('abc', 'def');
+for (var i = 0; i < RECOMPILE_DELAY + 10; i++) ltCmp(i, 100);
+
+var s9_after = timeit(function() {
+  var c = 0;
+  for (var i = 0; i < ITER; i++) { if (ltCmp(i, ITER / 2)) c++; }
+  return c;
+}, 'LT after recompile');
+
+// ============================================================
+// Scenario 10: Closure with upvalue
+// ============================================================
+console.log('');
+console.log('--- S10: closure upvalue bailout ---');
+
+function makeAccum(init) {
+  var total = init;
+  return function(v) { total = total + v; return total; };
+}
+
+var accum = makeAccum(0);
+for (var i = 0; i < JIT_THRESHOLD + 10; i++) accum(1);
+
+var s10_before = timeit(function() {
+  var a = makeAccum(0);
+  for (var i = 0; i < JIT_THRESHOLD + 10; i++) a(1); // re-JIT the inner fn
+  for (var i = 0; i < ITER; i++) a(1);
+  return a(0);
+}, 'closure before bailout');
+
+// bailout: string into numeric accumulator
+var accum2 = makeAccum(0);
+for (var i = 0; i < JIT_THRESHOLD + 10; i++) accum2(1);
+accum2(' world');
+for (var i = 0; i < RECOMPILE_DELAY + 10; i++) accum2(1);
+
+var s10_after = timeit(function() {
+  var a = makeAccum(0);
+  for (var i = 0; i < JIT_THRESHOLD + 10; i++) a(1);
+  for (var i = 0; i < ITER; i++) a(1);
+  return a(0);
+}, 'closure after recompile');
+
+// ============================================================
+// Summary
+// ============================================================
+console.log('');
+console.log('=== SUMMARY ===');
+console.log('  S1 recovery: ' + (s1_after / s1_before * 100).toFixed(0) + '% of JIT speed');
+console.log('  S3 baseline: ' + s3.toFixed(2) + ' ms');
+console.log('  S2 banned:   ' + s2.toFixed(2) + ' ms (' + (s2 / s3).toFixed(1) + 'x slower than JIT)');
+console.log('  S6 chain recovery: ' + (s6_after / s6_before * 100).toFixed(0) + '%');
+console.log('  S7 loop recovery:  ' + (s7_recover / s7_jit * 100).toFixed(0) + '%');
+console.log('  S9 cmp recovery:   ' + (s9_after / s9_before * 100).toFixed(0) + '%');
+console.log('  S5 correctness: ' + allCorrect);
diff --git a/tests/delete.js b/tests/delete.js
index 027d2fc..113198a 100644
--- a/tests/delete.js
+++ b/tests/delete.js
@@ -4,14 +4,8 @@ const user = {
   active: true
 };
 
-Ant.gc();
-console.log('GC requested');
-
 console.log(user.age); // Output: 30
-
 delete user.age; // The 'delete' operator returns true on success
 
 console.log(user.age); // Output: undefined
 console.log(user); // Output: { name: 'Alice', active: true }
-Ant.gc();
-console.log('GC requested');
diff --git a/tests/ee_crash.js b/tests/ee_crash.js
new file mode 100644
index 0000000..ff1df6e
--- /dev/null
+++ b/tests/ee_crash.js
@@ -0,0 +1,5 @@
+import { EventEmitter } from 'ant:events';
+const ee = new EventEmitter();
+console.log('on type:', typeof ee.on);
+ee.on('x', () => {});
+console.log('done');
diff --git a/tests/repro_nan.js b/tests/repro_nan.js
new file mode 100644
index 0000000..889db20
--- /dev/null
+++ b/tests/repro_nan.js
@@ -0,0 +1,29 @@
+var global_res;
+
+function closure_var(n) {
+  function f(a) {
+    sum++;
+  }
+
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) {
+    f(j);
+    f(j);
+    f(j);
+    f(j);
+  }
+  global_res = sum;
+  return n * 4;
+}
+
+// Warm up and then check for NaN
+for (var i = 0; i < 100; i++) {
+  var n = (i < 10) ? (i + 1) : (i * 100);
+  var result = closure_var(n);
+  var expected = n * 4;
+  if (result !== expected) {
+    console.log("FAIL: closure_var(" + n + ") = " + result + ", expected " + expected + " (iter " + i + ")");
+  }
+}
+console.log("done");
diff --git a/tests/repro_nan2.js b/tests/repro_nan2.js
new file mode 100644
index 0000000..59c20fd
--- /dev/null
+++ b/tests/repro_nan2.js
@@ -0,0 +1,58 @@
+// Test 1: closure_var with upvalue capture (original bug)
+function closure_var(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); f(j); f(j); f(j); }
+  return n * 4;
+}
+
+// Test 2: same loop but no upvalue capture - just a noop inner call
+function no_capture(n) {
+  function f(a) { return 1; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { sum += f(j); }
+  return n;
+}
+
+// Test 3: same structure but no inner call at all
+function no_inner_call(n) {
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { sum += 1; sum += 1; sum += 1; sum += 1; }
+  return n * 4;
+}
+
+// Test 4: closure_var but return sum instead of n*4
+function closure_ret_sum(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); f(j); f(j); f(j); }
+  return sum;
+}
+
+var tests = [
+  ["closure_var", closure_var, function(n) { return n * 4; }],
+  ["no_capture", no_capture, function(n) { return n; }],
+  ["no_inner_call", no_inner_call, function(n) { return n * 4; }],
+  ["closure_ret_sum", closure_ret_sum, function(n) { return n * 4; }],
+];
+
+for (var t = 0; t < tests.length; t++) {
+  var name = tests[t][0], fn = tests[t][1], expect = tests[t][2];
+  var fails = 0;
+  for (var i = 0; i < 60; i++) {
+    var n = (i < 10) ? (i + 1) : (i * 100);
+    var result = fn(n);
+    var exp = expect(n);
+    if (result !== exp) {
+      if (fails < 5)
+        console.log("FAIL " + name + "(" + n + ") = " + result + ", expected " + exp);
+      fails++;
+    }
+  }
+  if (fails > 0) console.log("  " + name + ": " + fails + " failures total");
+  else console.log("  " + name + ": PASS");
+}
diff --git a/tests/repro_nan3.js b/tests/repro_nan3.js
new file mode 100644
index 0000000..b8d0c94
--- /dev/null
+++ b/tests/repro_nan3.js
@@ -0,0 +1,71 @@
+// Isolate: does the NaN come from the return expression or from sum corruption?
+
+// Test A: upvalue capture, return constant (no sum, no n)
+function test_const(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); }
+  return 42;
+}
+
+// Test B: upvalue capture, return n (param read)
+function test_n(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); }
+  return n;
+}
+
+// Test C: upvalue capture, return n * 4
+function test_nmul(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); }
+  return n * 4;
+}
+
+// Test D: upvalue capture, return sum
+function test_sum(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); }
+  return sum;
+}
+
+// Test E: upvalue capture but no call to f in loop, return n * 4
+function test_nocall(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { sum = sum + 1; }
+  return n * 4;
+}
+
+var tests = [
+  ["const",  test_const,  function(n) { return 42; }],
+  ["n",      test_n,      function(n) { return n; }],
+  ["n*4",    test_nmul,   function(n) { return n * 4; }],
+  ["sum",    test_sum,    function(n) { return n; }],
+  ["nocall", test_nocall, function(n) { return n * 4; }],
+];
+
+for (var t = 0; t < tests.length; t++) {
+  var name = tests[t][0], fn = tests[t][1], expect = tests[t][2];
+  var fails = 0;
+  for (var i = 0; i < 40; i++) {
+    var n = (i < 5) ? (i + 1) : (i * 200);
+    var result = fn(n);
+    var exp = expect(n);
+    if (result !== exp) {
+      if (fails < 3)
+        console.log("FAIL " + name + "(" + n + ") = " + result + ", expected " + exp);
+      fails++;
+    }
+  }
+  if (fails > 0) console.log("  " + name + ": " + fails + " failures");
+  else console.log("  " + name + ": PASS");
+}
diff --git a/tests/repro_nan4.js b/tests/repro_nan4.js
new file mode 100644
index 0000000..a3e0f3f
--- /dev/null
+++ b/tests/repro_nan4.js
@@ -0,0 +1,31 @@
+// Test: many SHORT calls to trigger call_count JIT (not OSR back-edge)
+function test_short(n) {
+  function f(a) { sum++; }
+  var j, sum;
+  sum = 0;
+  for (j = 0; j < n; j++) { f(j); }
+  return n;
+}
+
+// Call with small n many times to trigger call_count threshold
+var fails = 0;
+for (var i = 0; i < 200; i++) {
+  var result = test_short(5);
+  if (result !== 5) {
+    if (fails < 3) console.log("FAIL iter " + i + ": test_short(5) = " + result);
+    fails++;
+  }
+}
+console.log("call_count path: " + (fails > 0 ? fails + " failures" : "PASS"));
+
+// Now test with large n to trigger OSR
+fails = 0;
+for (var i = 0; i < 20; i++) {
+  var n = 2000;
+  var result = test_short(n);
+  if (result !== n) {
+    if (fails < 3) console.log("FAIL iter " + i + ": test_short(" + n + ") = " + result);
+    fails++;
+  }
+}
+console.log("OSR path: " + (fails > 0 ? fails + " failures" : "PASS"));
diff --git a/tests/self_tail_call.js b/tests/self_tail_call.js
new file mode 100644
index 0000000..c09d4e0
--- /dev/null
+++ b/tests/self_tail_call.js
@@ -0,0 +1,59 @@
+// Test self-tail-call optimization in JIT
+// Without the optimization, deep recursion blows the native stack.
+
+// 1. Simple countdown — verifies correctness + no stack overflow
+function countdown(n) {
+  if (n <= 0) return 0;
+  return countdown(n - 1);
+}
+
+// 2. Accumulator pattern — tail-recursive sum
+function sum(n, acc) {
+  if (n <= 0) return acc;
+  return sum(n - 1, acc + n);
+}
+
+// 3. Mutual-arg swap (ensures args are copied correctly, not aliased)
+function gcd(a, b) {
+  if (b === 0) return a;
+  return gcd(b, a % b);
+}
+
+// 4. Deep recursion that would stack-overflow without TCO
+const DEEP = 1_000_000;
+
+console.time("countdown 1M");
+const r1 = countdown(DEEP);
+console.timeEnd("countdown 1M");
+console.log("countdown:", r1);
+
+console.time("sum 1M");
+const r2 = sum(DEEP, 0);
+console.timeEnd("sum 1M");
+console.log("sum:", r2);
+
+console.time("gcd");
+const r3 = gcd(1071, 462);
+console.timeEnd("gcd");
+console.log("gcd(1071,462):", r3);
+
+// 5. Stress: 10M iterations to measure loop vs call overhead
+console.time("countdown 10M");
+countdown(10_000_000);
+console.timeEnd("countdown 10M");
+
+// 6. Closure-based self-tail-call (upval self-reference)
+const fib_tail = function f(n, a, b) {
+  if (n <= 0) return a;
+  return f(n - 1, b, a + b);
+};
+
+console.time("fib_tail 100");
+const r4 = fib_tail(100, 0, 1);
+console.timeEnd("fib_tail 100");
+console.log("fib_tail(100):", r4);
+
+console.time("fib_tail 1M");
+const r5 = fib_tail(1_000_000, 0, 1);
+console.timeEnd("fib_tail 1M");
+console.log("fib_tail(1M):", typeof r5 === "number" ? "ok" : "FAIL");
diff --git a/tests/test-async-method-shorthand.js b/tests/test-async-method-shorthand.js
new file mode 100644
index 0000000..5f31ded
--- /dev/null
+++ b/tests/test-async-method-shorthand.js
@@ -0,0 +1,118 @@
+// ============================================
+// TEST: async method shorthand not supported
+// ============================================
+// Bug: { async foo() {} } fails with SyntaxError
+// ============================================
+
+console.log("=== ASYNC METHOD SHORTHAND TESTS ===\n");
+
+// --- BASELINE: Regular async (should work) ---
+
+console.log("1. async function declaration:");
+async function asyncFn1() { return "async-decl"; }
+asyncFn1().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("2. async function expression:");
+const asyncFn2 = async function() { return "async-expr"; };
+asyncFn2().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("3. async arrow function:");
+const asyncFn3 = async () => "async-arrow";
+asyncFn3().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("4. async arrow with body:");
+const asyncFn4 = async () => { return "async-arrow-body"; };
+asyncFn4().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+// --- BASELINE: Method syntax (should work) ---
+
+console.log("5. regular method shorthand:");
+const obj5 = { foo() { return "method"; } };
+console.log("   result: " + obj5.foo());
+console.log("   PASSED\n");
+
+console.log("6. method as property (async):");
+const obj6 = { foo: async function() { return "async-prop"; } };
+obj6.foo().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("7. method as arrow property (async):");
+const obj7 = { foo: async () => "async-arrow-prop" };
+obj7.foo().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+// --- BUG TESTS (these should work per ES2017 but fail in Ant) ---
+
+console.log("8. async method shorthand:");
+console.log("   expected: works per ES2017 spec");
+const obj8 = { async foo() { return "async-shorthand"; } };
+obj8.foo().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("9. async method shorthand with params:");
+const obj9 = { async add(a, b) { return a + b; } };
+obj9.add(2, 3).then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("10. async method shorthand with await:");
+const obj10 = {
+  async fetch() {
+    const result = await Promise.resolve("awaited");
+    return result;
+  }
+};
+obj10.fetch().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("11. multiple async methods:");
+const obj11 = {
+  async foo() { return "foo"; },
+  async bar() { return "bar"; },
+  async baz() { return "baz"; }
+};
+Promise.all([obj11.foo(), obj11.bar(), obj11.baz()]).then(function(v) {
+  console.log("   result: " + v.join(", "));
+});
+console.log("   PASSED\n");
+
+console.log("12. mixed async and sync methods:");
+const obj12 = {
+  sync() { return "sync"; },
+  async async1() { return "async"; },
+  regular: function() { return "regular"; },
+  async async2() { return "async2"; }
+};
+console.log("   sync: " + obj12.sync());
+console.log("   regular: " + obj12.regular());
+obj12.async1().then(function(v) { console.log("   async1: " + v); });
+obj12.async2().then(function(v) { console.log("   async2: " + v); });
+console.log("   PASSED\n");
+
+console.log("13. async method in class:");
+class MyClass {
+  async fetch() { return "class-async"; }
+}
+const inst = new MyClass();
+inst.fetch().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("14. async static method in class:");
+class MyClass2 {
+  static async fetch() { return "static-async"; }
+}
+MyClass2.fetch().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("15. computed async method name:");
+const methodName = "dynamicAsync";
+const obj15 = {
+  async [methodName]() { return "computed-async"; }
+};
+obj15.dynamicAsync().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("=== ALL TESTS PASSED ===");
diff --git a/tests/test-catch-destructuring.js b/tests/test-catch-destructuring.js
new file mode 100644
index 0000000..682b4b8
--- /dev/null
+++ b/tests/test-catch-destructuring.js
@@ -0,0 +1,97 @@
+// ============================================
+// TEST: catch with destructuring not supported
+// ============================================
+// Bug: catch ({ prop }) and catch ([a, b]) fail with SyntaxError
+// ============================================
+
+console.log("=== CATCH DESTRUCTURING TESTS ===\n");
+
+// --- BASELINE (should work) ---
+
+console.log("1. catch with simple identifier:");
+try {
+  throw new Error("test error");
+} catch (e) {
+  console.log("   caught: " + e.message);
+}
+console.log("   PASSED\n");
+
+console.log("2. catch without parameter (ES2019):");
+try {
+  throw new Error("ignored");
+} catch {
+  console.log("   caught without param");
+}
+console.log("   PASSED\n");
+
+console.log("3. catch with manual destructuring (workaround):");
+try {
+  throw { message: "manual", code: 42 };
+} catch (e) {
+  const { message, code } = e;
+  console.log("   message: " + message + ", code: " + code);
+}
+console.log("   PASSED\n");
+
+console.log("4. catch with manual array destructuring (workaround):");
+try {
+  throw [1, 2, 3];
+} catch (e) {
+  const [a, b, c] = e;
+  console.log("   a: " + a + ", b: " + b + ", c: " + c);
+}
+console.log("   PASSED\n");
+
+// --- BUG TESTS (these should work per ES6 but fail in Ant) ---
+
+console.log("5. catch with object destructuring:");
+console.log("   expected: works per ES6 spec");
+try {
+  throw { message: "destructured", code: 99 };
+} catch ({ message, code }) {
+  console.log("   message: " + message + ", code: " + code);
+}
+console.log("   PASSED\n");
+
+console.log("6. catch with array destructuring:");
+console.log("   expected: works per ES6 spec");
+try {
+  throw [10, 20];
+} catch ([a, b]) {
+  console.log("   a: " + a + ", b: " + b);
+}
+console.log("   PASSED\n");
+
+console.log("7. catch with nested object destructuring:");
+try {
+  throw { outer: { inner: "value" } };
+} catch ({ outer: { inner } }) {
+  console.log("   inner: " + inner);
+}
+console.log("   PASSED\n");
+
+console.log("8. catch with default values:");
+try {
+  throw { a: 1 };
+} catch ({ a, b = 99 }) {
+  console.log("   a: " + a + ", b: " + b);
+}
+console.log("   PASSED\n");
+
+console.log("9. catch with renaming:");
+try {
+  throw { longPropertyName: "short" };
+} catch ({ longPropertyName: short }) {
+  console.log("   short: " + short);
+}
+console.log("   PASSED\n");
+
+console.log("10. catch with rest pattern:");
+try {
+  throw [1, 2, 3, 4, 5];
+} catch ([first, ...rest]) {
+  console.log("   first: " + first + ", rest: " + rest);
+}
+console.log("   PASSED\n");
+
+console.log("=== ALL TESTS PASSED ===");
diff --git a/tests/test-shorthand-methods.js b/tests/test-shorthand-methods.js
new file mode 100644
index 0000000..ef51b78
--- /dev/null
+++ b/tests/test-shorthand-methods.js
@@ -0,0 +1,286 @@
+// ============================================
+// TEST: Shorthand method syntax
+// ============================================
+// Tests all variations of method shorthand in objects and classes
+// ============================================
+
+console.log("=== SHORTHAND METHOD TESTS ===\n");
+
+// --- SECTION 1: Basic method shorthand ---
+
+console.log("SECTION 1: Basic method shorthand\n");
+
+console.log("1. Regular method shorthand:");
+const obj1 = { foo() { return "foo"; } };
+console.log("   result: " + obj1.foo());
+console.log("   PASSED\n");
+
+console.log("2. Method with parameters:");
+const obj2 = { add(a, b) { return a + b; } };
+console.log("   result: " + obj2.add(2, 3));
+console.log("   PASSED\n");
+
+console.log("3. Method with rest parameters:");
+const obj3 = { sum(...nums) { return nums.reduce(function(a, b) { return a + b; }, 0); } };
+console.log("   result: " + obj3.sum(1, 2, 3, 4));
+console.log("   PASSED\n");
+
+console.log("4. Method with default parameters:");
+const obj4 = { greet(name = "world") { return "hello " + name; } };
+console.log("   result: " + obj4.greet());
+console.log("   result: " + obj4.greet("ant"));
+console.log("   PASSED\n");
+
+console.log("5. Method with destructuring parameters:");
+const obj5 = { getX({ x }) { return x; } };
+console.log("   result: " + obj5.getX({ x: 42, y: 99 }));
+console.log("   PASSED\n");
+
+console.log("6. Multiple methods:");
+const obj6 = {
+  foo() { return "foo"; },
+  bar() { return "bar"; },
+  baz() { return "baz"; }
+};
+console.log("   result: " + obj6.foo() + ", " + obj6.bar() + ", " + obj6.baz());
+console.log("   PASSED\n");
+
+// --- SECTION 2: Getters and setters ---
+
+console.log("SECTION 2: Getters and setters\n");
+
+console.log("7. Getter:");
+const obj7 = { get value() { return 42; } };
+console.log("   result: " + obj7.value);
+console.log("   PASSED\n");
+
+console.log("8. Setter:");
+const obj8 = { _v: 0, set value(x) { this._v = x; } };
+obj8.value = 99;
+console.log("   result: " + obj8._v);
+console.log("   PASSED\n");
+
+console.log("9. Getter and setter pair:");
+const obj9 = {
+  _v: 0,
+  get value() { return this._v; },
+  set value(x) { this._v = x * 2; }
+};
+obj9.value = 10;
+console.log("   result: " + obj9.value);
+console.log("   PASSED\n");
+
+console.log("10. Computed getter:");
+const prop = "dynamic";
+const obj10 = { get [prop]() { return "computed-getter"; } };
+console.log("   result: " + obj10.dynamic);
+console.log("   PASSED\n");
+
+// --- SECTION 3: Computed property names ---
+
+console.log("SECTION 3: Computed property names\n");
+
+console.log("11. Computed method name (string):");
+const name11 = "myMethod";
+const obj11 = { [name11]() { return "computed"; } };
+console.log("   result: " + obj11.myMethod());
+console.log("   PASSED\n");
+
+console.log("12. Computed method name (expression):");
+const obj12 = { ["foo" + "Bar"]() { return "fooBar"; } };
+console.log("   result: " + obj12.fooBar());
+console.log("   PASSED\n");
+
+console.log("13. Computed method name (symbol):");
+const sym = Symbol("mySymbol");
+const obj13 = { [sym]() { return "symbol-method"; } };
+console.log("   result: " + obj13[sym]());
+console.log("   PASSED\n");
+
+console.log("14. Computed method name (number):");
+const obj14 = { [42]() { return "number-method"; } };
+console.log("   result: " + obj14[42]());
+console.log("   PASSED\n");
+
+// --- SECTION 4: Generator methods ---
+
+console.log("SECTION 4: Generator methods\n");
+
+console.log("15. Generator method shorthand:");
+console.log("   expected: works per ES6 spec");
+const obj15 = { *gen() { yield 1; yield 2; yield 3; } };
+let result15 = [];
+for (const v of obj15.gen()) result15.push(v);
+console.log("   result: " + result15.join(", "));
+console.log("   PASSED\n");
+
+console.log("16. Computed generator method:");
+const obj16 = { *["myGen"]() { yield "a"; yield "b"; } };
+let result16 = [];
+for (const v of obj16.myGen()) result16.push(v);
+console.log("   result: " + result16.join(", "));
+console.log("   PASSED\n");
+
+// --- SECTION 5: Async methods ---
+
+console.log("SECTION 5: Async methods\n");
+
+console.log("17. Async method shorthand:");
+console.log("   expected: works per ES2017 spec");
+const obj17 = { async fetch() { return "async-result"; } };
+obj17.fetch().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("18. Async method with await:");
+const obj18 = {
+  async getData() {
+    const a = await Promise.resolve(1);
+    const b = await Promise.resolve(2);
+    return a + b;
+  }
+};
+obj18.getData().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("19. Computed async method:");
+const obj19 = { async ["asyncMethod"]() { return "computed-async"; } };
+obj19.asyncMethod().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("20. Async generator method:");
+console.log("   expected: works per ES2018 spec");
+const obj20 = {
+  async *asyncGen() {
+    yield await Promise.resolve(1);
+    yield await Promise.resolve(2);
+  }
+};
+(async function() {
+  let result = [];
+  for await (const v of obj20.asyncGen()) result.push(v);
+  console.log("   result: " + result.join(", "));
+})();
+console.log("   PASSED\n");
+
+// --- SECTION 6: Mixed with properties ---
+
+console.log("SECTION 6: Mixed methods and properties\n");
+
+console.log("21. Methods with regular properties:");
+const obj21 = {
+  x: 1,
+  y: 2,
+  getSum() { return this.x + this.y; },
+  z: 3
+};
+console.log("   result: " + obj21.getSum() + ", z=" + obj21.z);
+console.log("   PASSED\n");
+
+console.log("22. Methods with shorthand properties:");
+const a = 1, b = 2;
+const obj22 = {
+  a,
+  b,
+  sum() { return this.a + this.b; }
+};
+console.log("   result: " + obj22.sum());
+console.log("   PASSED\n");
+
+console.log("23. Methods with spread:");
+const base = { foo() { return "base"; } };
+const obj23 = { ...base, bar() { return "extended"; } };
+console.log("   result: " + obj23.foo() + ", " + obj23.bar());
+console.log("   PASSED\n");
+
+// --- SECTION 7: Class methods ---
+
+console.log("SECTION 7: Class methods\n");
+
+console.log("24. Class method:");
+class Class24 {
+  foo() { return "class-method"; }
+}
+console.log("   result: " + new Class24().foo());
+console.log("   PASSED\n");
+
+console.log("25. Class static method:");
+class Class25 {
+  static foo() { return "static-method"; }
+}
+console.log("   result: " + Class25.foo());
+console.log("   PASSED\n");
+
+console.log("26. Class getter/setter:");
+class Class26 {
+  constructor() { this._v = 0; }
+  get value() { return this._v; }
+  set value(x) { this._v = x; }
+}
+const inst26 = new Class26();
+inst26.value = 42;
+console.log("   result: " + inst26.value);
+console.log("   PASSED\n");
+
+console.log("27. Class async method:");
+class Class27 {
+  async fetch() { return "class-async"; }
+}
+new Class27().fetch().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("28. Class static async method:");
+class Class28 {
+  static async fetch() { return "static-async"; }
+}
+Class28.fetch().then(function(v) { console.log("   result: " + v); });
+console.log("   PASSED\n");
+
+console.log("29. Class generator method:");
+class Class29 {
+  *gen() { yield 1; yield 2; }
+}
+let result29 = [];
+for (const v of new Class29().gen()) result29.push(v);
+console.log("   result: " + result29.join(", "));
+console.log("   PASSED\n");
+
+console.log("30. Class computed method:");
+const methodName30 = "dynamic";
+class Class30 {
+  [methodName30]() { return "computed-class-method"; }
+}
+console.log("   result: " + new Class30().dynamic());
+console.log("   PASSED\n");
+
+// --- SECTION 8: this binding ---
+
+console.log("SECTION 8: this binding\n");
+
+console.log("31. Method this binding:");
+const obj31 = {
+  name: "obj31",
+  getName() { return this.name; }
+};
+console.log("   result: " + obj31.getName());
+console.log("   PASSED\n");
+
+console.log("32. Method this with call:");
+const obj32 = {
+  getName() { return this.name; }
+};
+console.log("   result: " + obj32.getName.call({ name: "called" }));
+console.log("   PASSED\n");
+
+console.log("33. Nested method this:");
+const obj33 = {
+  name: "outer",
+  inner: {
+    name: "inner",
+    getName() { return this.name; }
+  }
+};
+console.log("   result: " + obj33.inner.getName());
+console.log("   PASSED\n");
+
+console.log("\n=== ALL TESTS COMPLETE ===");
+console.log("\nIf any test shows 'SyntaxError' before 'PASSED', that feature is broken.");
diff --git a/tests/test_array_callback_thisarg.cjs b/tests/test_array_callback_thisarg.cjs
new file mode 100644
index 0000000..7dc2ca1
--- /dev/null
+++ b/tests/test_array_callback_thisarg.cjs
@@ -0,0 +1,36 @@
+let passed = 0;
+let failed = 0;
+
+function test(name, actual, expected) {
+  if (actual === expected) {
+    console.log("PASS:", name);
+    passed++;
+    return;
+  }
+  console.log("FAIL:", name, "- expected", expected, "got", actual);
+  failed++;
+}
+
+const ctx = { total: 0, seen: "" };
+[1, 2, 3].forEach(function (n) {
+  this.total += n;
+  this.seen += String(n);
+}, ctx);
+test("forEach thisArg", ctx.total, 6);
+test("forEach callback this binding", ctx.seen, "123");
+
+const mapped = [1, 2].map(function (n) {
+  return this.base + n;
+}, { base: 10 });
+test("map thisArg", mapped[0], 11);
+test("map thisArg second value", mapped[1], 12);
+
+const found = [1, 2, 3].find(function (n) {
+  return n > this.min;
+}, { min: 2 });
+test("find thisArg", found, 3);
+
+console.log("Passed:", passed);
+console.log("Failed:", failed);
+
+if (failed > 0) throw new Error("test_array_callback_thisarg failed");
diff --git a/tests/test_async_gc.js b/tests/test_async_gc.js
index d6fa4eb..81fba8b 100644
--- a/tests/test_async_gc.js
+++ b/tests/test_async_gc.js
@@ -3,10 +3,9 @@ async function allocateAndWait() {
   for (let i = 0; i < 100; i = i + 1) {
     data.push({ value: 'test ' + i });
   }
-  console.log('Before await, data length:', data.length);
 
+  console.log('Before await, data length:', data.length);
   await new Promise(resolve => setTimeout(resolve, 10));
-  Ant.gc();
 
   console.log('After await+GC, data length:', data.length);
   return data.length;
@@ -17,12 +16,10 @@ async function main() {
     console.log('Cycle', i + 1);
     let result = await allocateAndWait();
     console.log('Result:', result);
-    Ant.gc();
   }
   console.log('Done');
 }
 
 main().then(() => {
   console.log('=== async done, calling gc ===');
-  Ant.gc();
 });
diff --git a/tests/test_binding_loop_closures.js b/tests/test_binding_loop_closures.js
new file mode 100644
index 0000000..28dcd03
--- /dev/null
+++ b/tests/test_binding_loop_closures.js
@@ -0,0 +1,69 @@
+const failures = [];
+
+function assertArrayEq(name, got, expected) {
+  const ok = got.length === expected.length &&
+    got.every((v, i) => v === expected[i]);
+  if (!ok) {
+    failures.push(`${name}: expected [${expected.join(', ')}], got [${got.join(', ')}]`);
+  }
+}
+
+function collectForInLet() {
+  const funcs = [];
+  for (let key in { a: 1, b: 1, c: 1 }) {
+    funcs.push(() => key);
+  }
+  return funcs.map(fn => fn());
+}
+
+function collectForInConst() {
+  const funcs = [];
+  for (const key in { a: 1, b: 1, c: 1 }) {
+    funcs.push(() => key);
+  }
+  return funcs.map(fn => fn());
+}
+
+function collectForOfLet() {
+  const funcs = [];
+  for (let value of ['x', 'y', 'z']) {
+    funcs.push(() => value);
+  }
+  return funcs.map(fn => fn());
+}
+
+function collectForOfConst() {
+  const funcs = [];
+  for (const value of ['x', 'y', 'z']) {
+    funcs.push(() => value);
+  }
+  return funcs.map(fn => fn());
+}
+
+function collectForOfDestructureLet() {
+  const funcs = [];
+  for (let [k, v] of [['a', 1], ['b', 2], ['c', 3]]) {
+    funcs.push(() => `${k}:${v}`);
+  }
+  return funcs.map(fn => fn());
+}
+
+assertArrayEq('for-in let closure', collectForInLet(), ['a', 'b', 'c']);
+assertArrayEq('for-in const closure', collectForInConst(), ['a', 'b', 'c']);
+assertArrayEq('for-of let closure', collectForOfLet(), ['x', 'y', 'z']);
+assertArrayEq('for-of const closure', collectForOfConst(), ['x', 'y', 'z']);
+assertArrayEq(
+  'for-of let destructuring closure',
+  collectForOfDestructureLet(),
+  ['a:1', 'b:2', 'c:3']
+);
+
+if (failures.length > 0) {
+  console.log('Binding loop closure failures:');
+  for (let i = 0; i < failures.length; i++) {
+    console.log(`  ${i + 1}. ${failures[i]}`);
+  }
+  throw new Error(`Found ${failures.length} binding-loop closure regression(s)`);
+}
+
+console.log('PASS: binding loop closures');
diff --git a/tests/test_computed_assignment_order.js b/tests/test_computed_assignment_order.js
new file mode 100644
index 0000000..3bd2877
--- /dev/null
+++ b/tests/test_computed_assignment_order.js
@@ -0,0 +1,35 @@
+const failures = [];
+
+function assertOrder(name, got, expected) {
+  const ok = got.length === expected.length && got.every((v, i) => v === expected[i]);
+  if (!ok) failures.push(`${name}: expected [${expected.join(', ')}], got [${got.join(', ')}]`);
+}
+
+{
+  const order = [];
+  const base = {};
+  const getObj = () => { order.push('obj'); return base; };
+  const key = () => { order.push('key'); return 'k'; };
+  const rhs = () => { order.push('rhs'); return 1; };
+  getObj()[key()] = rhs();
+  assertOrder('computed assignment order', order, ['obj', 'key', 'rhs']);
+}
+
+{
+  const order = [];
+  const base = {};
+  const getObj = () => { order.push('obj'); return base; };
+  const rhs = () => { order.push('rhs'); return 1; };
+  getObj().x = rhs();
+  assertOrder('named assignment order', order, ['obj', 'rhs']);
+}
+
+if (failures.length) {
+  console.log('Assignment order failures:');
+  for (let i = 0; i < failures.length; i++) {
+    console.log(`  ${i + 1}. ${failures[i]}`);
+  }
+  throw new Error(`Found ${failures.length} assignment-order regression(s)`);
+}
+
+console.log('PASS: assignment evaluation order');
diff --git a/tests/test_coro_resume_safety.js b/tests/test_coro_resume_safety.js
new file mode 100644
index 0000000..d7ff219
--- /dev/null
+++ b/tests/test_coro_resume_safety.js
@@ -0,0 +1,150 @@
+// Test: reactor coroutine resume iteration safety.
+//
+// Verifies that the reactor loop handles coroutine queue mutations during
+// execution correctly:
+//   1. Coroutine A resolves a promise that wakes coroutine B — B may complete
+//      and be freed while A is still in the queue.  The reactor must not
+//      follow a dangling next pointer.
+//   2. Many concurrent coroutines settling each other in chains.
+//   3. A coroutine that spawns new coroutines during execution.
+
+console.log('=== coro resume safety ===');
+
+let passed = 0;
+let failed = 0;
+function assert(cond, msg) {
+  if (cond) passed++;
+  else { failed++; console.log('FAIL: ' + msg); }
+}
+
+// --- Test 1: A resolves B's promise, B completes during A's execution ---
+
+async function test1() {
+  let resolveB;
+  const promiseB = new Promise(r => { resolveB = r; });
+
+  const results = [];
+
+  async function coroB() {
+    const val = await promiseB;
+    results.push('B:' + val);
+  }
+
+  async function coroA() {
+    resolveB('from-A');
+    // After resolving, B becomes ready and may run+complete
+    // before A finishes this tick
+    results.push('A:done');
+  }
+
+  // Start both — B will suspend on promiseB, A will resolve it
+  const bDone = coroB();
+  const aDone = coroA();
+  await aDone;
+  await bDone;
+
+  assert(results.includes('A:done'), 'test1: A completed');
+  assert(results.includes('B:from-A'), 'test1: B got value from A');
+  console.log('test1: ok');
+}
+
+// --- Test 2: chain of coroutines settling each other ---
+
+async function test2() {
+  const N = 20;
+  const resolvers = [];
+  const gates = [];
+  const results = [];
+
+  // Create all promises upfront so resolvers exist before chain[0] runs
+  for (let i = 0; i < N; i++) {
+    gates.push(new Promise(r => { resolvers.push(r); }));
+  }
+
+  async function chainCoro(idx) {
+    if (idx > 0) {
+      const val = await gates[idx];
+      results.push(idx + ':' + val);
+    }
+    if (idx + 1 < N) {
+      resolvers[idx + 1]('from-' + idx);
+    }
+  }
+
+  const promises = [];
+  for (let i = 0; i < N; i++) {
+    promises.push(chainCoro(i));
+  }
+
+  await Promise.all(promises);
+
+  assert(results.length === N - 1, 'test2: all chain links settled (' + results.length + '/' + (N-1) + ')');
+  console.log('test2: ok');
+}
+
+// --- Test 3: coroutine spawns new coroutines during execution ---
+
+async function test3() {
+  const results = [];
+
+  async function spawner() {
+    const children = [];
+    for (let i = 0; i < 10; i++) {
+      children.push((async () => {
+        // Small delay to ensure we go through the event loop
+        await new Promise(r => setTimeout(r, 1));
+        results.push('child-' + i);
+      })());
+    }
+    results.push('spawner-done');
+    await Promise.all(children);
+  }
+
+  await spawner();
+  assert(results.includes('spawner-done'), 'test3: spawner completed');
+  assert(results.length === 11, 'test3: all children completed (' + results.length + '/11)');
+  console.log('test3: ok');
+}
+
+// --- Test 4: mutual resolution — A and B settle each other's promises ---
+
+async function test4() {
+  let resolveForA, resolveForB;
+  const promiseForA = new Promise(r => { resolveForA = r; });
+  const promiseForB = new Promise(r => { resolveForB = r; });
+
+  const results = [];
+
+  async function coroA() {
+    resolveForB('hello-from-A');
+    const val = await promiseForA;
+    results.push('A-got:' + val);
+  }
+
+  async function coroB() {
+    resolveForA('hello-from-B');
+    const val = await promiseForB;
+    results.push('B-got:' + val);
+  }
+
+  await Promise.all([coroA(), coroB()]);
+
+  assert(results.includes('A-got:hello-from-B'), 'test4: A got B\'s value');
+  assert(results.includes('B-got:hello-from-A'), 'test4: B got A\'s value');
+  console.log('test4: ok');
+}
+
+// --- run ---
+
+async function main() {
+  await test1();
+  await test2();
+  await test3();
+  await test4();
+
+  console.log('passed: ' + passed + ', failed: ' + failed);
+  if (failed > 0) { console.log('FAIL'); process.exit(1); }
+  else console.log('OK');
+}
+
+main();
diff --git a/tests/test_date_parse_string.cjs b/tests/test_date_parse_string.cjs
new file mode 100644
index 0000000..dab3935
--- /dev/null
+++ b/tests/test_date_parse_string.cjs
@@ -0,0 +1,33 @@
+let failed = 0;
+
+function check(label, cond, detail) {
+  if (!cond) {
+    failed++;
+    console.log("FAIL", label, detail || "");
+  }
+}
+
+const msZ = Date.parse("2026-02-27T12:00:00Z");
+check("Date.parse Z", msZ === 1772193600000, msZ);
+
+const dZ = new Date("2026-02-27T12:00:00Z");
+check("new Date Z toISOString", dZ.toISOString() === "2026-02-27T12:00:00.000Z", dZ.toISOString());
+
+const dDateOnly = new Date("2026-02-27");
+check("date-only is UTC midnight", dDateOnly.toISOString() === "2026-02-27T00:00:00.000Z", dDateOnly.toISOString());
+
+const dClone = new Date(dZ);
+check("clone from Date object", dClone.getTime() === dZ.getTime(), dClone.getTime() + " vs " + dZ.getTime());
+
+const msOff = Date.parse("2026-02-27T12:00:00+02:30");
+const msOffRef = Date.parse("2026-02-27T09:30:00Z");
+check("timezone offset", msOff === msOffRef, msOff + " vs " + msOffRef);
+
+const invalidParse = Date.parse("not-a-date");
+check("invalid parse is NaN", invalidParse !== invalidParse, invalidParse);
+
+const invalidDate = new Date("not-a-date");
+const invalidTime = invalidDate.getTime();
+check("invalid date getTime is NaN", invalidTime !== invalidTime, invalidTime);
+
+if (failed > 0) throw new Error("test_date_parse_string failed");
diff --git a/tests/test_dynamic_func.js b/tests/test_dynamic_func.js
new file mode 100644
index 0000000..45cfd8c
--- /dev/null
+++ b/tests/test_dynamic_func.js
@@ -0,0 +1,15 @@
+const add = new Function("a", "b", "return a + b");
+console.log("add:", add(2, 3));
+console.log("add:", add(10, 20));
+
+const greet = new Function("name", "return \"Hello, \" + name + \"!\"");
+console.log("greet:", greet("World"));
+
+const noArgs = new Function("return 42");
+console.log("noArgs:", noArgs());
+
+const empty = new Function();
+console.log("empty:", empty());
+
+console.log("toString:", add.toString());
+console.log("done");
diff --git a/tests/test_for_in_closure.js b/tests/test_for_in_closure.js
new file mode 100644
index 0000000..777ed7d
--- /dev/null
+++ b/tests/test_for_in_closure.js
@@ -0,0 +1,22 @@
+const obj = { a: 1, b: 1, c: 1 };
+const funcs = [];
+
+for (let key in obj) {
+  funcs.push(() => key);
+}
+
+const got = funcs.map(fn => fn());
+console.log('for-in let closure:', got.join(' '));
+
+const expected = ['a', 'b', 'c'];
+if (got.length !== expected.length) {
+  throw new Error(`Expected ${expected.length} closures, got ${got.length}`);
+}
+
+for (let i = 0; i < expected.length; i++) {
+  if (got[i] !== expected[i]) {
+    throw new Error(`Expected ${expected.join(' ')}, got ${got.join(' ')}`);
+  }
+}
+
+console.log('PASS');
diff --git a/tests/test_function_constructor_tostring.cjs b/tests/test_function_constructor_tostring.cjs
new file mode 100644
index 0000000..4a66eb6
--- /dev/null
+++ b/tests/test_function_constructor_tostring.cjs
@@ -0,0 +1,37 @@
+let failed = 0;
+
+const bodyObj = {
+  toString() {
+    return "return x + 41;";
+  },
+};
+
+const paramObj = {
+  toString() {
+    return "x";
+  },
+};
+
+try {
+  const fn = Function(paramObj, bodyObj);
+  if (fn(1) !== 42) {
+    failed++;
+    console.log("direct Function() returned wrong value");
+  }
+} catch (e) {
+  failed++;
+  console.log("direct Function() threw:", e && e.message ? e.message : e);
+}
+
+try {
+  const fn2 = Function.apply(null, [paramObj, bodyObj]);
+  if (fn2(2) !== 43) {
+    failed++;
+    console.log("Function.apply() returned wrong value");
+  }
+} catch (e) {
+  failed++;
+  console.log("Function.apply() threw:", e && e.message ? e.message : e);
+}
+
+if (failed > 0) throw new Error("test_function_constructor_tostring failed");
diff --git a/tests/test_gc.js b/tests/test_gc.js
index 079872e..96687da 100644
--- a/tests/test_gc.js
+++ b/tests/test_gc.js
@@ -25,9 +25,8 @@ console.log('  arenaSize:', fmt(stats2.arenaSize));
 console.log('  rss:', fmt(stats2.rss));
 console.log('  arenaUsed increase:', fmt(stats2.arenaUsed - stats1.arenaUsed));
 
-console.log('\n=== Testing Ant.gc() ===');
+console.log('\n=== Testing GC ===');
 arr = null;
-Ant.gc();
 
 console.log('\n=== Stats after GC ===');
 let stats3 = Ant.stats();
@@ -48,7 +47,6 @@ for (let cycle = 0; cycle < 3; cycle = cycle + 1) {
   console.log('  Before GC - arenaUsed:', fmt(before.arenaUsed));
 
   temp = null;
-  Ant.gc();
   console.log('  After GC - arenaUsed:', fmt(Ant.stats().arenaUsed));
 }
 
diff --git a/tests/test_gc_async.js b/tests/test_gc_async.js
index 61d5434..3850bf3 100644
--- a/tests/test_gc_async.js
+++ b/tests/test_gc_async.js
@@ -31,10 +31,8 @@ function render() {
   return lines.join('\n');
 }
 
-async function handleEvent(n) {
-  for (let i = 0; i < 10; i++) {
-    render();
-  }
+async function handleEvent(_) {
+  for (let i = 0; i < 10; i++) render();
 }
 
 for (let count = 1; count <= 500; count++) {
@@ -42,12 +40,11 @@ for (let count = 1; count <= 500; count++) {
   const stats = Ant.stats();
   console.log(
     `tick ${count}: arena ${(stats.arenaUsed / 1024 / 1024).toFixed(1)}MB / ` +
-    `${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, ` +
-    `rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB`
+      `${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, ` +
+      `rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB`
   );
 }
 
 console.log('Done - forcing GC...');
-Ant.gc();
 const after = Ant.stats();
 console.log(`after GC: arena ${(after.arenaUsed / 1024 / 1024).toFixed(1)}MB`);
diff --git a/tests/test_gc_comprehensive.js b/tests/test_gc_comprehensive.js
index 309959f..a0f53cb 100644
--- a/tests/test_gc_comprehensive.js
+++ b/tests/test_gc_comprehensive.js
@@ -19,7 +19,6 @@ function assert(condition, msg) {
 console.log('Test 1: Objects and Arrays');
 let obj1 = { name: 'test', value: 42, nested: { deep: 'value' } };
 let arr1 = [1, 2, 3, { inner: 'object' }, 'string'];
-Ant.gc();
 assert(obj1.name === 'test', 'obj1.name should be "test"');
 assert(obj1.nested.deep === 'value', 'nested object should survive');
 assert(arr1.length === 5, 'array length should be 5');
@@ -32,11 +31,10 @@ let map = new Map();
 map.set('key1', { data: 'value1' });
 map.set('key2', [1, 2, 3]);
 map.set('key3', 'simple string');
-Ant.gc();
 assert(map.get('key1').data === 'value1', 'map value object should survive');
 assert(map.get('key2')[1] === 2, 'map value array should survive');
 assert(map.get('key3') === 'simple string', 'map value string should survive');
-assert(map.size() === 3, 'map size should be 3');
+assert(map.size === 3, 'map size should be 3');
 console.log('  Map: OK\n');
 
 // Test 3: Set survives GC
@@ -46,10 +44,9 @@ let setObj = { id: 123 };
 set.add('value1');
 set.add(42);
 set.add(setObj);
-Ant.gc();
 assert(set.has('value1'), 'set should have "value1"');
 assert(set.has(42), 'set should have 42');
-assert(set.size() === 3, 'set size should be 3');
+assert(set.size === 3, 'set size should be 3');
 console.log('  Set: OK\n');
 
 // Test 4: Property descriptors (getters/setters) survive GC
@@ -67,7 +64,6 @@ Object.defineProperty(descObj, 'prop', {
   configurable: true
 });
 descObj.prop = 'updated';
-Ant.gc();
 assert(descObj.prop === 'updated', 'getter should return updated value');
 descObj.prop = 'after gc';
 assert(descObj.prop === 'after gc', 'setter should work after GC');
@@ -84,7 +80,6 @@ p.then(val => {
   promiseResolved = true;
   promiseValue = val;
 });
-Ant.gc();
 console.log('  Waiting for promise...');
 
 // Test 6: Proxy survives GC
@@ -97,7 +92,6 @@ let proxyHandler = {
   }
 };
 let proxy = new Proxy(proxyTarget, proxyHandler);
-Ant.gc();
 assert(proxy.x === 10, 'proxy.x should be 10');
 assert(proxy.y === 20, 'proxy.y should be 20');
 assert(proxy.sum === 30, 'proxy.sum should be 30');
@@ -120,7 +114,6 @@ function makeCounter() {
 let counter = makeCounter();
 counter.inc();
 counter.inc();
-Ant.gc();
 assert(counter.get() === 2, 'closure should preserve count');
 counter.inc();
 assert(counter.get() === 3, 'closure should work after GC');
@@ -132,7 +125,6 @@ let cycleData = { iteration: 0 };
 for (let i = 0; i < 5; i = i + 1) {
   cycleData.iteration = i;
   cycleData['data' + i] = { value: i * 10 };
-  Ant.gc();
 }
 assert(cycleData.iteration === 4, 'iteration should be 4');
 assert(cycleData.data3.value === 30, 'data3.value should be 30');
@@ -145,7 +137,6 @@ for (let i = 0; i < 1000; i = i + 1) {
   largeArr.push({ index: i, data: 'item ' + i });
 }
 let statsBefore = Ant.stats();
-Ant.gc();
 let statsAfter = Ant.stats();
 assert(largeArr.length === 1000, 'large array should have 1000 elements');
 assert(largeArr[500].index === 500, 'element 500 should be correct');
@@ -167,7 +158,6 @@ let nested = {
   }
 };
 let nestedArr = [[[[['innermost']]]]];
-Ant.gc();
 assert(nested.level1.level2.level3.level4.value === 'deep', 'deep nesting should survive');
 assert(nestedArr[0][0][0][0][0] === 'innermost', 'nested array should survive');
 console.log('  Nested structures: OK\n');
@@ -187,9 +177,6 @@ async function testAsyncGC() {
 
   await new Promise(resolve => setTimeout(resolve, 10));
 
-  // GC inside coroutine (should skip compaction)
-  Ant.gc();
-
   asyncData.value = 'after first await';
 
   await new Promise(resolve => setTimeout(resolve, 10));
diff --git a/tests/test_gc_coro.js b/tests/test_gc_coro.js
index 04ef459..f15efb0 100644
--- a/tests/test_gc_coro.js
+++ b/tests/test_gc_coro.js
@@ -16,12 +16,12 @@ function render() {
   const width = 120;
   const height = 40;
   const lines = [];
-  
+
   // Clear buffer
   for (let y = 0; y < height; y++) {
     lines.push(' '.repeat(width));
   }
-  
+
   // Draw styled content (like the TUI does)
   for (let y = 0; y < height; y++) {
     let text = `\x1b[38;5;196mRow ${y}\x1b[0m: `;
@@ -30,7 +30,7 @@ function render() {
     text = pad(text, width);
     lines[y] = text;
   }
-  
+
   return lines.join('\n');
 }
 
@@ -45,17 +45,18 @@ let count = 0;
 const interval = setInterval(() => {
   count++;
   handleEvent(count);
-  
+
   const stats = Ant.stats();
-  console.log(`tick ${count}: arena ${(stats.arenaUsed / 1024 / 1024).toFixed(1)}MB / ${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB`);
-  
-  if (count >= 500) {  // Run for ~5 seconds
+  console.log(
+    `tick ${count}: arena ${(stats.arenaUsed / 1024 / 1024).toFixed(1)}MB / ${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB`
+  );
+
+  if (count >= 500) {
+    // Run for ~5 seconds
     clearInterval(interval);
-    console.log('Done - forcing GC...');
-    Ant.gc();
     setTimeout(() => {
       const after = Ant.stats();
       console.log(`after GC: arena ${(after.arenaUsed / 1024 / 1024).toFixed(1)}MB`);
     }, 10);
   }
-}, 10);  // 500 * 10ms = 5 seconds
+}, 10); // 500 * 10ms = 5 seconds
diff --git a/tests/test_gc_cycles.js b/tests/test_gc_cycles.js
index 0362e1a..05e5cad 100644
--- a/tests/test_gc_cycles.js
+++ b/tests/test_gc_cycles.js
@@ -6,7 +6,6 @@ for (let i = 0; i < 5; i = i + 1) {
   cycleData.iteration = i;
   cycleData['data' + i] = { value: i * 10 };
   console.log('  Before GC - iteration:', cycleData.iteration);
-  Ant.gc();
   console.log('  After GC - iteration:', cycleData.iteration);
 }
 
diff --git a/tests/test_gc_debug.js b/tests/test_gc_debug.js
index 95f0571..5a8e0b8 100644
--- a/tests/test_gc_debug.js
+++ b/tests/test_gc_debug.js
@@ -3,8 +3,6 @@ console.log('=== Debug GC Test ===\n');
 // Test 1
 console.log('Test 1: Objects');
 let obj1 = { name: 'test', value: 42, nested: { deep: 'value' } };
-Ant.gc();
-console.log('  GC requested');
 console.log('  OK\n');
 
 // Test 2
@@ -12,7 +10,6 @@ console.log('Test 2: Map');
 let map = new Map();
 map.set('key1', { data: 'value1' });
 map.set('key2', [1, 2, 3]);
-Ant.gc();
 console.log('  GC requested');
 console.log('  get key1:', map.get('key1'));
 console.log('  OK\n');
@@ -22,7 +19,6 @@ console.log('Test 3: Set');
 let set = new Set();
 set.add('value1');
 set.add(42);
-Ant.gc();
 console.log('  GC requested');
 console.log('  OK\n');
 
@@ -31,23 +27,25 @@ console.log('Test 4: Property Descriptors');
 let descObj = {};
 let _hidden = 'initial';
 Object.defineProperty(descObj, 'prop', {
-  get: function() { return _hidden; },
-  set: function(v) { _hidden = v; },
+  get: function () {
+    return _hidden;
+  },
+  set: function (v) {
+    _hidden = v;
+  },
   enumerable: true,
   configurable: true
 });
 descObj.prop = 'updated';
-Ant.gc();
 console.log('  GC requested');
 console.log('  prop:', descObj.prop);
 console.log('  OK\n');
 
 // Test 5
 console.log('Test 5: Promises');
-let p = new Promise((resolve) => {
+let p = new Promise(resolve => {
   resolve({ result: 'success' });
 });
-Ant.gc();
 console.log('  GC requested');
 console.log('  OK\n');
 
@@ -55,13 +53,12 @@ console.log('  OK\n');
 console.log('Test 6: Proxy');
 let proxyTarget = { x: 10, y: 20 };
 let proxyHandler = {
-  get: function(target, prop) {
+  get: function (target, prop) {
     if (prop === 'sum') return target.x + target.y;
     return target[prop];
   }
 };
 let proxy = new Proxy(proxyTarget, proxyHandler);
-Ant.gc();
 console.log('  GC requested');
 console.log('  proxy.x:', proxy.x);
 console.log('  OK\n');
@@ -71,13 +68,17 @@ console.log('Test 7: Closures');
 function makeCounter() {
   let count = 0;
   return {
-    inc: function() { count = count + 1; return count; },
-    get: function() { return count; }
+    inc: function () {
+      count = count + 1;
+      return count;
+    },
+    get: function () {
+      return count;
+    }
   };
 }
 let counter = makeCounter();
 counter.inc();
-Ant.gc();
 console.log('  GC requested');
 console.log('  count:', counter.get());
 console.log('  OK\n');
diff --git a/tests/test_gc_in_coro.js b/tests/test_gc_in_coro.js
new file mode 100644
index 0000000..fec3c64
--- /dev/null
+++ b/tests/test_gc_in_coro.js
@@ -0,0 +1,155 @@
+// Test: GC compaction runs correctly inside coroutines.
+
+console.log('=== GC-in-coroutine test ===');
+
+let passed = 0;
+let failed = 0;
+
+function assert(cond, msg) {
+  if (cond) { passed++; }
+  else { failed++; console.log('FAIL: ' + msg); }
+}
+
+function trace(msg) { console.log('[trace] ' + msg); }
+
+// --- helpers ---
+
+function allocBulk(n) {
+  const arr = [];
+  for (let i = 0; i < n; i++) {
+    arr.push({ idx: i, data: 'item_' + i + '_' + 'x'.repeat(64) });
+  }
+  return arr;
+}
+
+function verifyBulk(arr, label) {
+  for (let i = 0; i < arr.length; i++) {
+    assert(arr[i].idx === i, label + ': idx mismatch at ' + i);
+    assert(arr[i].data.startsWith('item_' + i + '_'), label + ': data mismatch at ' + i);
+  }
+}
+
+// --- Test 1: pre-existing objects survive GC inside coroutine ---
+
+trace('allocating preAlloc');
+const preAlloc = allocBulk(200);
+trace('preAlloc done, length=' + preAlloc.length);
+
+async function test1() {
+  trace('test1: start');
+  verifyBulk(preAlloc, 'test1-preAlloc');
+  trace('test1: preAlloc verified');
+
+  const innerAlloc = allocBulk(200);
+  verifyBulk(innerAlloc, 'test1-innerAlloc');
+  verifyBulk(preAlloc, 'test1-preAlloc-after');
+  trace('test1: done');
+}
+
+// --- Test 2: cross-coroutine references ---
+
+const shared = { value: 'original', children: [] };
+
+async function test2() {
+  trace('test2: start');
+  for (let i = 0; i < 100; i++) {
+    shared.children.push({ ref: i, str: 'child_' + i });
+  }
+
+  assert(shared.value === 'original', 'test2: shared.value');
+  assert(shared.children.length === 100, 'test2: children.length');
+  for (let i = 0; i < 100; i++) {
+    assert(shared.children[i].ref === i, 'test2: child ref ' + i);
+  }
+  trace('test2: done');
+}
+
+// --- Test 3: nested async (coroutine-in-coroutine) ---
+
+async function inner(depth) {
+  const obj = { depth, payload: 'nested_' + depth + '_' + 'y'.repeat(32) };
+  if (depth > 0) {
+    await inner(depth - 1);
+  }
+  assert(obj.depth === depth, 'test3: depth mismatch at ' + depth);
+  assert(obj.payload.startsWith('nested_' + depth), 'test3: payload at ' + depth);
+  return obj;
+}
+
+async function test3() {
+  trace('test3: start');
+  await inner(8);
+  trace('test3: done');
+}
+
+// --- Test 4: allocation pressure inside coroutine (natural GC trigger) ---
+
+async function test4() {
+  trace('test4: start');
+  const anchors = [];
+  for (let wave = 0; wave < 20; wave++) {
+    const batch = [];
+    for (let i = 0; i < 500; i++) {
+      batch.push({ wave, i, s: 'w' + wave + '_i' + i + '_' + 'z'.repeat(128) });
+    }
+    anchors.push(batch);
+  }
+
+  for (let wave = 0; wave < anchors.length; wave++) {
+    const batch = anchors[wave];
+    assert(batch.length === 500, 'test4: wave ' + wave + ' length');
+    assert(batch[0].wave === wave, 'test4: wave ' + wave + ' tag');
+    assert(batch[499].i === 499, 'test4: wave ' + wave + ' last idx');
+  }
+  trace('test4: done');
+}
+
+// --- Test 5: await + GC interleaving ---
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function test5() {
+  trace('test5: start');
+  const before = allocBulk(100);
+  await delay(1);
+  trace('test5: after first await');
+  verifyBulk(before, 'test5-before-await');
+
+  const after = allocBulk(100);
+  await delay(1);
+  trace('test5: after second await');
+  verifyBulk(before, 'test5-before-final');
+  verifyBulk(after, 'test5-after-final');
+  trace('test5: done');
+}
+
+// --- run all ---
+
+trace('calling main()');
+
+async function main() {
+  trace('main: start');
+  await test1();
+  trace('main: test1 complete');
+  await test2();
+  trace('main: test2 complete');
+  await test3();
+  trace('main: test3 complete');
+  await test4();
+  trace('main: test4 complete');
+  await test5();
+  trace('main: test5 complete');
+
+  console.log('passed: ' + passed + ', failed: ' + failed);
+  if (failed > 0) {
+    console.log('FAIL');
+    process.exit(1);
+  } else {
+    console.log('OK');
+  }
+}
+
+main();
+trace('main() returned (promise pending)');
diff --git a/tests/test_gc_large.js b/tests/test_gc_large.js
index e2404dc..e15faf4 100644
--- a/tests/test_gc_large.js
+++ b/tests/test_gc_large.js
@@ -33,13 +33,6 @@ console.log('');
 // Free the objects
 largeObjects = null;
 
-Ant.gc();
-console.log('GC 1 requested');
-Ant.gc();
-console.log('GC 2 requested');
-Ant.gc();
-console.log('GC 3 requested');
-
 let stats3 = Ant.stats();
 console.log('\nAfter 3x GC:');
 console.log('  arenaUsed:', fmt(stats3.arenaUsed));
diff --git a/tests/test_gc_minimal8.js b/tests/test_gc_minimal8.js
index 131551f..d495765 100644
--- a/tests/test_gc_minimal8.js
+++ b/tests/test_gc_minimal8.js
@@ -5,30 +5,36 @@ console.log('Starting...');
 console.log('Creating Map...');
 let map = new Map();
 map.set('key1', { data: 'value1' });
-Ant.gc();
 
 let set = new Set();
 set.add('value1');
-Ant.gc();
 
 let descObj = {};
 Object.defineProperty(descObj, 'prop', {
-  get: function() { return 'test'; },
-  set: function(v) { },
+  get: function () {
+    return 'test';
+  },
+  set: function (v) {}
 });
-Ant.gc();
 
 let proxyTarget = { x: 10 };
-let proxy = new Proxy(proxyTarget, { get: function(t, p) { return t[p]; } });
-Ant.gc();
+let proxy = new Proxy(proxyTarget, {
+  get: function (t, p) {
+    return t[p];
+  }
+});
 
 function makeCounter() {
   let count = 0;
-  return { inc: function() { count = count + 1; return count; } };
+  return {
+    inc: function () {
+      count = count + 1;
+      return count;
+    }
+  };
 }
 let counter = makeCounter();
 counter.inc();
-Ant.gc();
 
 // Now Test 8
 console.log('Test 8: Multiple GC Cycles');
@@ -37,6 +43,5 @@ for (let i = 0; i < 5; i = i + 1) {
   console.log('Cycle', i);
   cycleData.iteration = i;
   cycleData['data' + i] = { value: i * 10 };
-  Ant.gc();
 }
 console.log('Done');
diff --git a/tests/test_gc_simple.js b/tests/test_gc_simple.js
index 0361ba5..e7743d3 100644
--- a/tests/test_gc_simple.js
+++ b/tests/test_gc_simple.js
@@ -3,16 +3,12 @@ console.log('=== Simple GC Test ===\n');
 // Test 1: Basic objects
 console.log('Test 1: Objects');
 let obj1 = { name: 'test', value: 42 };
-console.log('Before GC:', obj1.name);
-Ant.gc();
 console.log('After GC:', obj1.name);
 
 // Test 2: Map
 console.log('\nTest 2: Map');
 let map = new Map();
 map.set('key1', 'value1');
-console.log('Before GC:', map.get('key1'));
-Ant.gc();
 console.log('After GC:', map.get('key1'));
 
 console.log('\n=== Done ===');
diff --git a/tests/test_gc_stress10.js b/tests/test_gc_stress10.js
index 7fdf3ac..066f7b8 100644
--- a/tests/test_gc_stress10.js
+++ b/tests/test_gc_stress10.js
@@ -7,7 +7,7 @@ const logs = [
   { time: '10:23:48', level: 'WARN', message: 'Cache directory not found, creating...' },
   { time: '10:24:05', level: 'ERROR', message: 'Failed to load plugin: missing-plugin' },
   { time: '10:24:06', level: 'WARN', message: 'Running with reduced functionality' },
-  { time: '10:24:10', level: 'INFO', message: 'Ready to accept connections' },
+  { time: '10:24:10', level: 'INFO', message: 'Ready to accept connections' }
 ];
 
 function render() {
@@ -22,8 +22,20 @@ function render() {
   screen.write(2, 20, colors.magenta + '└──────────────────────────────────────────┘' + codes.reset);
 }
 
+const t0 = Date.now();
 for (let frame = 0; frame < 50000; frame++) {
   render();
+  const stats = Ant.stats();
+  const elapsed = ((Date.now() - t0) / 1000).toFixed(2);
+  console.log(
+    `frame ${frame}: arena ${(stats.arenaUsed / 1024 / 1024).toFixed(1)}MB / ` +
+      `${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, ` +
+      `rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB, ` +
+      `elapsed ${elapsed}s`
+  );
 }
 
+const total = ((Date.now() - t0) / 1000).toFixed(2);
+const final_stats = Ant.stats();
+console.log(`Done: ${total}s, arena ${(final_stats.arenaUsed / 1024 / 1024).toFixed(1)}MB, ` + `rss ${(final_stats.rss / 1024 / 1024).toFixed(1)}MB`);
 console.log('OK');
diff --git a/tests/test_gc_tco.js b/tests/test_gc_tco.js
index c24a4a6..2948651 100644
--- a/tests/test_gc_tco.js
+++ b/tests/test_gc_tco.js
@@ -18,7 +18,6 @@ function assert(cond, msg) {
   }
 }
 
-// Inflate arena past 10MB so Ant.gc() actually compacts
 function inflateArena() {
   let junk = [];
   for (let i = 0; i < 40000; i++) {
@@ -38,7 +37,6 @@ let _garbage = inflateArena();
 
 function tailWithObjects(n, obj) {
   if (n <= 0) return obj;
-  Ant.gc();
   return tailWithObjects(n - 1, { value: obj.value + 1, prev: obj });
 }
 
@@ -48,7 +46,10 @@ assert(result1.value === 200, 'final value should be 200, got ' + result1.value)
 let walk = result1;
 let chainOk = true;
 for (let i = 200; i >= 0; i--) {
-  if (walk.value !== i) { chainOk = false; break; }
+  if (walk.value !== i) {
+    chainOk = false;
+    break;
+  }
   walk = walk.prev;
 }
 assert(chainOk, 'object chain should be intact through all 200 links');
@@ -62,7 +63,6 @@ _garbage = inflateArena();
 
 function pingStr(n, s) {
   if (n <= 0) return s;
-  Ant.gc();
   return pongStr(n - 1, s + 'p');
 }
 function pongStr(n, s) {
@@ -86,14 +86,13 @@ function makeAccumulator() {
   function loop(n) {
     if (n <= 0) return captured;
     captured.sum += n;
-    Ant.gc();
     return loop(n - 1);
   }
   return loop;
 }
 
 let accResult = makeAccumulator()(500);
-assert(accResult.sum === 500 * 501 / 2, 'sum should be 125250, got ' + accResult.sum);
+assert(accResult.sum === (500 * 501) / 2, 'sum should be 125250, got ' + accResult.sum);
 console.log('  Closure scope through tail calls: OK\n');
 
 // ---------------------------------------------------------------------------
@@ -105,7 +104,6 @@ _garbage = inflateArena();
 function multiArg(n, arr, obj, str) {
   if (n <= 0) return { arr, obj, str };
   arr.push(n);
-  Ant.gc();
   return multiArg(n - 1, arr, { v: obj.v + 1, inner: obj }, str + 'x');
 }
 
@@ -123,7 +121,6 @@ _garbage = inflateArena();
 
 function deepTail(n, acc) {
   if (n <= 0) return acc;
-  if (n % 500 === 0) Ant.gc();
   return deepTail(n - 1, acc + 1);
 }
 
@@ -140,7 +137,6 @@ _garbage = inflateArena();
 function step1(n, data) {
   if (n <= 0) return data;
   data.a++;
-  Ant.gc();
   return step2(n - 1, data);
 }
 function step2(n, data) {
@@ -171,7 +167,6 @@ function freshArrays(n, results) {
   let data = new Array(50);
   for (let i = 0; i < 50; i++) data[i] = n;
   results.push(data);
-  if (n % 10 === 0) Ant.gc();
   return freshArrays(n - 1, results);
 }
 
diff --git a/tests/test_gc_timer.js b/tests/test_gc_timer.js
index a61da2b..bd77f1c 100644
--- a/tests/test_gc_timer.js
+++ b/tests/test_gc_timer.js
@@ -45,14 +45,12 @@ const interval = setInterval(() => {
   const stats = Ant.stats();
   console.log(
     `tick ${count}: arena ${(stats.arenaUsed / 1024 / 1024).toFixed(1)}MB / ` +
-    `${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, ` +
-    `rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB`
+      `${(stats.arenaSize / 1024 / 1024).toFixed(1)}MB, ` +
+      `rss ${(stats.rss / 1024 / 1024).toFixed(1)}MB`
   );
 
   if (count >= 500) {
     clearInterval(interval);
-    console.log('Done - forcing GC...');
-    Ant.gc();
     const after = Ant.stats();
     console.log(`after GC: arena ${(after.arenaUsed / 1024 / 1024).toFixed(1)}MB`);
   }
diff --git a/tests/test_if_else_var.cjs b/tests/test_if_else_var.cjs
new file mode 100644
index 0000000..b0f2a8c
--- /dev/null
+++ b/tests/test_if_else_var.cjs
@@ -0,0 +1,17 @@
+function pickFiles(basedir, relfiles) {
+  if (relfiles) var files = relfiles.map((r) => `${basedir}/${r}`);
+  else var files = basedir;
+  return files;
+}
+
+const a = pickFiles("/tmp", ["a.js", "b.js"]);
+if (!Array.isArray(a) || a.length !== 2 || a[0] !== "/tmp/a.js") {
+  throw new Error("if-branch var statement failed");
+}
+
+const b = pickFiles("/tmp/base", null);
+if (b !== "/tmp/base") {
+  throw new Error("else-branch var statement failed");
+}
+
+console.log("ok");
diff --git a/tests/test_jit_handlekey.js b/tests/test_jit_handlekey.js
new file mode 100644
index 0000000..15f3061
--- /dev/null
+++ b/tests/test_jit_handlekey.js
@@ -0,0 +1,201 @@
+// Reproduce "undeclared reg 0" MIR error: switch statement with many
+// string-constant cases, method calls, and property access — matching
+// the exact bytecode pattern of a TUI handleKey function.
+
+const keys = {
+  UP: '\x1b[A',
+  DOWN: '\x1b[B',
+  RIGHT: '\x1b[C',
+  LEFT: '\x1b[D',
+  PAGE_UP: '\x1b[5~',
+  PAGE_DOWN: '\x1b[6~',
+  ENTER: '\r',
+  ESCAPE: '\x1b',
+  TAB: '\t',
+  BACKSPACE: '\x7f',
+  HOME: '\x1b[H',
+  END: '\x1b[F',
+  CTRL_C: '\x03',
+};
+
+const list = {
+  index: 0,
+  items: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+  selectNext() { this.index = Math.min(this.items.length - 1, this.index + 1); },
+  selectPrev() { this.index = Math.max(0, this.index - 1); },
+  pageDown() { this.index = Math.min(this.items.length - 1, this.index + 5); },
+  pageUp() { this.index = Math.max(0, this.index - 5); },
+  getSelected() { return this.items[this.index]; },
+};
+
+const logList = {
+  index: 0,
+  items: ['a', 'b', 'c'],
+  selectNext() { this.index = Math.min(this.items.length - 1, this.index + 1); },
+  selectPrev() { this.index = Math.max(0, this.index - 1); },
+  pageDown() { this.index = Math.min(this.items.length - 1, this.index + 5); },
+  pageUp() { this.index = Math.max(0, this.index - 5); },
+};
+
+const state = {
+  view: 'tasks',
+  searchMode: false,
+  searchQuery: '',
+  taskFilter: 'all',
+  settingsIndex: 0,
+};
+
+let renderCount = 0;
+function render() { renderCount++; }
+
+// Use switch(key) — this generates DUP+CONST+SEQ+JMP_FALSE chains where
+// the discriminant stays on the vstack across branch targets.
+function handleKey(key) {
+  if (state.searchMode) {
+    if (key === keys.ESCAPE) {
+      state.searchMode = false;
+      state.searchQuery = '';
+      render();
+      return;
+    }
+    if (key === keys.ENTER) {
+      state.searchMode = false;
+      render();
+      return;
+    }
+    return;
+  }
+
+  switch (key) {
+    case 'q':
+    case keys.CTRL_C:
+      return;
+
+    case '1':
+      state.view = 'dashboard';
+      render();
+      break;
+    case '2':
+      state.view = 'tasks';
+      render();
+      break;
+    case '3':
+      state.view = 'logs';
+      render();
+      break;
+    case '4':
+      state.view = 'settings';
+      render();
+      break;
+
+    case '?':
+      render();
+      break;
+    case 'm':
+      render();
+      break;
+
+    case keys.UP:
+    case 'k':
+      if (state.view === 'tasks') list.selectPrev();
+      else if (state.view === 'logs') logList.selectPrev();
+      else if (state.view === 'settings') state.settingsIndex = Math.max(0, state.settingsIndex - 1);
+      render();
+      break;
+
+    case keys.DOWN:
+    case 'j':
+      if (state.view === 'tasks') list.selectNext();
+      else if (state.view === 'logs') logList.selectNext();
+      else if (state.view === 'settings') state.settingsIndex = Math.min(9, state.settingsIndex + 1);
+      render();
+      break;
+
+    case keys.PAGE_UP:
+      if (state.view === 'tasks') list.pageUp();
+      else if (state.view === 'logs') logList.pageUp();
+      render();
+      break;
+
+    case keys.PAGE_DOWN:
+      if (state.view === 'tasks') list.pageDown();
+      else if (state.view === 'logs') logList.pageDown();
+      render();
+      break;
+
+    case keys.ENTER:
+    case keys.RIGHT:
+      if (state.view === 'tasks') {
+        const item = list.getSelected();
+        if (item) {
+          const desc = 'item_' + String(item);
+          if (desc.length > 0) render();
+        }
+      }
+      render();
+      break;
+
+    case keys.LEFT:
+      render();
+      break;
+
+    case keys.HOME:
+      list.index = 0;
+      render();
+      break;
+
+    case keys.END:
+      list.index = list.items.length - 1;
+      render();
+      break;
+
+    case keys.TAB:
+      state.view = 'dashboard';
+      render();
+      break;
+
+    case '/':
+      if (state.view === 'tasks') {
+        state.searchMode = true;
+        state.searchQuery = '';
+      }
+      render();
+      break;
+
+    case 'a':
+      if (state.view === 'tasks') { state.taskFilter = 'all'; render(); }
+      break;
+    case 't':
+      if (state.view === 'tasks') { state.taskFilter = 'todo'; render(); }
+      break;
+    case 'p':
+      if (state.view === 'tasks') { state.taskFilter = 'in_progress'; render(); }
+      break;
+    case 'd':
+      if (state.view === 'tasks') { state.taskFilter = 'done'; render(); }
+      break;
+    case 'P':
+      render();
+      break;
+    case 'D':
+      render();
+      break;
+    case 'N':
+      render();
+      break;
+  }
+}
+
+const scrollKeys = [
+  keys.UP, keys.DOWN, keys.UP, keys.DOWN,
+  keys.PAGE_UP, keys.PAGE_DOWN,
+  keys.UP, keys.DOWN, 'k', 'j',
+  keys.ENTER, keys.LEFT, keys.RIGHT,
+  keys.HOME, keys.END, keys.TAB,
+];
+
+for (let i = 0; i < 500; i++) {
+  handleKey(scrollKeys[i % scrollKeys.length]);
+}
+
+console.log('OK: rendered', renderCount, 'times, list index:', list.index);
diff --git a/tests/test_jit_map_string_concat.js b/tests/test_jit_map_string_concat.js
new file mode 100644
index 0000000..c6f8d5b
--- /dev/null
+++ b/tests/test_jit_map_string_concat.js
@@ -0,0 +1,50 @@
+// Reproduce JIT crash: Array.map callback with string concatenation + upvalues
+// The callback uses OP_ADD on strings (triggers bailout) and OP_GET_UPVAL.
+
+const codes = { reset: '\x1b[0m' };
+
+function createGrid(width, height) {
+  const chars = Array(height).fill(null).map(() => Array(width).fill(' '));
+  const styles = Array(height).fill(null).map(() => Array(width).fill(''));
+  return { chars, styles };
+}
+
+function render() {
+  const width = 20;
+  const height = 10;
+  const grid = createGrid(width, height);
+
+  // Set some styled cells
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (x === 5) grid.styles[y][x] = '\x1b[32m';
+    }
+  }
+
+  // This .map() callback captures `grid` and `codes` as upvalues,
+  // and does string concatenation (OP_ADD with strings → JIT bailout).
+  const rows = grid.chars.map((row, y) => {
+    let line = '';
+    let currentStyle = '';
+    for (let x = 0; x < row.length; x++) {
+      const nextStyle = grid.styles[y][x];
+      if (nextStyle !== currentStyle) {
+        line += nextStyle || codes.reset;
+        currentStyle = nextStyle;
+      }
+      line += row[x];
+    }
+    return line + codes.reset;
+  });
+
+  return rows.join('\n');
+}
+
+// Call render() enough times to trigger JIT compilation of the .map() callback.
+// With SV_JIT_THRESHOLD=100 and 10 rows per render, ~11 renders should trigger it.
+let result;
+for (let i = 0; i < 20; i++) {
+  result = render();
+}
+
+console.log('OK: JIT map+string concat survived', result.length, 'chars');
diff --git a/tests/test_jit_missing_arg_normalization.cjs b/tests/test_jit_missing_arg_normalization.cjs
new file mode 100644
index 0000000..ec17e5f
--- /dev/null
+++ b/tests/test_jit_missing_arg_normalization.cjs
@@ -0,0 +1,42 @@
+let failed = 0;
+
+function SourceLike(aLine, aColumn, aSource, aChunks, aName) {
+  this.children = [];
+  this.line = aLine == null ? null : aLine;
+  this.column = aColumn == null ? null : aColumn;
+  this.source = aSource == null ? null : aSource;
+  this.name = aName == null ? null : aName;
+  if (aChunks != null) this.add(aChunks);
+}
+
+SourceLike.prototype.add = function add(aChunk) {
+  if (Array.isArray(aChunk)) {
+    aChunk.forEach(function (chunk) {
+      this.add(chunk);
+    }, this);
+    return;
+  }
+  if (typeof aChunk === "string") {
+    this.children.push(aChunk);
+    return;
+  }
+  throw new Error("unexpected chunk type: " + typeof aChunk);
+};
+
+const driver = {
+  merge: function merge() {
+    for (let i = 0; i < 3000; i++) {
+      const s = new SourceLike(1, 2, 3);
+      s.add(["x"]);
+    }
+  },
+};
+
+try {
+  driver.merge();
+} catch (e) {
+  failed++;
+  console.log("fail:", e && e.message ? e.message : e);
+}
+
+if (failed > 0) throw new Error("test_jit_missing_arg_normalization failed");
diff --git a/tests/test_jit_num_add_ok.js b/tests/test_jit_num_add_ok.js
new file mode 100644
index 0000000..fa530c6
--- /dev/null
+++ b/tests/test_jit_num_add_ok.js
@@ -0,0 +1,13 @@
+// Control test: JIT ADD with numbers only (no bailout) — should NOT crash
+function test() {
+  const arr = [1, 2, 3, 4, 5];
+  const result = arr.map((v) => {
+    return v + 10;
+  });
+  return result;
+}
+
+for (let i = 0; i < 25; i++) {
+  const r = test();
+  if (i === 24) console.log('OK:', r.join(', '));
+}
diff --git a/tests/test_jit_string_add_bailout.js b/tests/test_jit_string_add_bailout.js
new file mode 100644
index 0000000..79e966a
--- /dev/null
+++ b/tests/test_jit_string_add_bailout.js
@@ -0,0 +1,18 @@
+// Minimal repro: JIT bailout on string ADD inside a hot callback
+function test() {
+  const prefix = 'hello';
+  const arr = [1, 2, 3, 4, 5];
+
+  // Callback captures `prefix` as upvalue and does string + string
+  const result = arr.map((v) => {
+    return prefix + String(v);
+  });
+
+  return result;
+}
+
+// Trigger JIT: 5 items * 21 calls = 105 > threshold(100)
+for (let i = 0; i < 25; i++) {
+  const r = test();
+  if (i === 24) console.log('OK:', r.join(', '));
+}
diff --git a/tests/test_map.js b/tests/test_map.js
index 48ab5cd..db788d6 100644
--- a/tests/test_map.js
+++ b/tests/test_map.js
@@ -6,7 +6,7 @@ map.set('key1', 'value1');
 map.set('key2', 42);
 map.set('key3', true);
 
-console.log('Map size:', map.size()); // Should be 3
+console.log('Map size:', map.size); // Should be 3
 console.log('Get key1:', map.get('key1')); // Should be 'value1'
 console.log('Get key2:', map.get('key2')); // Should be 42
 console.log('Get key3:', map.get('key3')); // Should be true
@@ -18,7 +18,7 @@ console.log('Has missing:', map.has('missing')); // Should be false
 // Test delete()
 console.log('Delete key2:', map.delete('key2')); // Should be true
 console.log('Has key2 after delete:', map.has('key2')); // Should be false
-console.log('Map size after delete:', map.size()); // Should be 2
+console.log('Map size after delete:', map.size); // Should be 2
 
 // Test overwrite
 map.set('key1', 'newvalue1');
@@ -26,7 +26,7 @@ console.log('Get key1 after overwrite:', map.get('key1')); // Should be 'newvalu
 
 // Test clear()
 map.clear();
-console.log('Map size after clear:', map.size()); // Should be 0
+console.log('Map size after clear:', map.size); // Should be 0
 console.log('Has key1 after clear:', map.has('key1')); // Should be false
 
 // Test with different key types
@@ -37,6 +37,6 @@ map.set(null, 'null key');
 console.log('Get number key:', map.get(123)); // Should be 'number key'
 console.log('Get boolean key:', map.get(true)); // Should be 'boolean key'
 console.log('Get null key:', map.get(null)); // Should be 'null key'
-console.log('Final map size:', map.size()); // Should be 3
+console.log('Final map size:', map.size); // Should be 3
 
-console.log('Map tests completed!');
\ No newline at end of file
+console.log('Map tests completed!');
diff --git a/tests/test_map_gc.js b/tests/test_map_gc.js
index fc476d5..c97e1d7 100644
--- a/tests/test_map_gc.js
+++ b/tests/test_map_gc.js
@@ -18,9 +18,6 @@ console.log('  map.get("key1"):', map.get('key1'));
 console.log('  map.get("key2"):', map.get('key2'));
 console.log('  map.get("key3"):', map.get('key3'));
 
-Ant.gc();
-console.log('\nGC requested');
-
 console.log('\nAfter GC:');
 console.log('  map.size:', map.size);
 console.log('  map.get("key1"):', map.get('key1'));
diff --git a/tests/test_regex_equals_literal.cjs b/tests/test_regex_equals_literal.cjs
new file mode 100644
index 0000000..31d16cb
--- /dev/null
+++ b/tests/test_regex_equals_literal.cjs
@@ -0,0 +1,9 @@
+const EQUAL_RE = /=/g;
+const x = "a=b=c";
+const out = x.replace(EQUAL_RE, ":");
+
+if (out !== "a:b:c") {
+  throw new Error("regex '/=/' literal parsed incorrectly");
+}
+
+console.log("ok");
diff --git a/tests/test_set.js b/tests/test_set.js
index 2c0408a..5ad3630 100644
--- a/tests/test_set.js
+++ b/tests/test_set.js
@@ -7,7 +7,7 @@ set.add('value2');
 set.add(42);
 set.add(true);
 
-console.log('Set size:', set.size()); // Should be 4
+console.log('Set size:', set.size); // Should be 4
 console.log('Has value1:', set.has('value1')); // Should be true
 console.log('Has value2:', set.has('value2')); // Should be true
 console.log('Has 42:', set.has(42)); // Should be true
@@ -17,32 +17,32 @@ console.log('Has missing:', set.has('missing')); // Should be false
 // Test delete()
 console.log('Delete value2:', set.delete('value2')); // Should be true
 console.log('Has value2 after delete:', set.has('value2')); // Should be false
-console.log('Set size after delete:', set.size()); // Should be 3
+console.log('Set size after delete:', set.size); // Should be 3
 
 // Test adding duplicates (should not increase size)
 set.add('value1'); // Adding duplicate
-console.log('Set size after duplicate add:', set.size()); // Should still be 3
+console.log('Set size after duplicate add:', set.size); // Should still be 3
 
 // Test with different value types
 set.add(123);
 set.add(null);
-set.add({key: 'object'});
+set.add({ key: 'object' });
 
 console.log('Has 123:', set.has(123)); // Should be true
 console.log('Has null:', set.has(null)); // Should be true
-console.log('Has object:', set.has({key: 'object'})); // Should be true
-console.log('Final set size:', set.size()); // Should be 7
+console.log('Has object:', set.has({ key: 'object' })); // Should be true
+console.log('Final set size:', set.size); // Should be 7
 
 // Test clear()
 set.clear();
-console.log('Set size after clear:', set.size()); // Should be 0
+console.log('Set size after clear:', set.size); // Should be 0
 console.log('Has value1 after clear:', set.has('value1')); // Should be false
 
 // Test chaining
 set.add('a').add('b').add('c');
-console.log('Set size after chaining:', set.size()); // Should be 3
+console.log('Set size after chaining:', set.size); // Should be 3
 console.log('Has a:', set.has('a')); // Should be true
 console.log('Has b:', set.has('b')); // Should be true
 console.log('Has c:', set.has('c')); // Should be true
 
-console.log('Set tests completed!');
\ No newline at end of file
+console.log('Set tests completed!');
diff --git a/tests/test_silver_eval.js b/tests/test_silver_eval.js
new file mode 100644
index 0000000..54eb3cb
--- /dev/null
+++ b/tests/test_silver_eval.js
@@ -0,0 +1,35 @@
+let x = 1 + 2;
+console.log('1 + 2 =', x);
+
+let y = x * 10;
+console.log('x * 10 =', y);
+
+function add(a, b) {
+  return a + b;
+}
+console.log('add(3, 4) =', add(3, 4));
+
+// closures
+function counter() {
+  let n = 0;
+  return function () {
+    n = n + 1;
+    return n;
+  };
+}
+let c = counter();
+console.log('counter:', c(), c(), c());
+
+// control flow
+let sum = 0;
+for (let i = 0; i < 10; i = i + 1) {
+  sum = sum + i;
+}
+console.log('sum 0..9 =', sum);
+
+// fibonacci
+function fib(n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}
+console.log('fib(10) =', fib(10));
diff --git a/tests/test_string_pad_unicode.cjs b/tests/test_string_pad_unicode.cjs
new file mode 100644
index 0000000..6b78ffc
--- /dev/null
+++ b/tests/test_string_pad_unicode.cjs
@@ -0,0 +1,23 @@
+let failed = 0;
+
+function check(name, cond, detail) {
+  if (!cond) {
+    failed++;
+    console.log("FAIL", name, detail || "");
+  }
+}
+
+const s = "false — must be >= 0";
+const p = s.padEnd(25);
+check("padEnd length with em dash", p.length === 25, p.length);
+check("padEnd content with em dash", p === "false — must be >= 0     ", JSON.stringify(p));
+
+const p2 = s.padStart(25);
+check("padStart length with em dash", p2.length === 25, p2.length);
+check("padStart content with em dash", p2 === "     false — must be >= 0", JSON.stringify(p2));
+
+const p3 = "ab".padEnd(5, "—");
+check("padEnd unicode pad string", p3 === "ab———", JSON.stringify(p3));
+check("padEnd unicode pad length", p3.length === 5, p3.length);
+
+if (failed > 0) throw new Error("test_string_pad_unicode failed");
diff --git a/tests/test_super_getter_receiver.cjs b/tests/test_super_getter_receiver.cjs
new file mode 100644
index 0000000..3de5742
--- /dev/null
+++ b/tests/test_super_getter_receiver.cjs
@@ -0,0 +1,51 @@
+let passed = 0;
+let failed = 0;
+
+function test(name, actual, expected) {
+  if (actual === expected) {
+    console.log("PASS:", name);
+    passed++;
+    return;
+  }
+  console.log("FAIL:", name, "- expected", expected, "got", actual);
+  failed++;
+}
+
+class Parent {
+  constructor() {
+    this.nodes = [1, 2, 3];
+  }
+  get names() {
+    return this.nodes.reduce((sum, n) => sum + n, 0);
+  }
+}
+
+class Child extends Parent {
+  get names() {
+    return super.names + 1;
+  }
+}
+
+class Base {
+  get value() {
+    return this.tag;
+  }
+}
+
+class Derived extends Base {
+  constructor() {
+    super();
+    this.tag = "ok";
+  }
+  get value() {
+    return super.value;
+  }
+}
+
+test("super getter uses child receiver", new Child().names, 7);
+test("super getter resolves child fields", new Derived().value, "ok");
+
+console.log("Passed:", passed);
+console.log("Failed:", failed);
+
+if (failed > 0) throw new Error("test_super_getter_receiver failed");
diff --git a/tests/test_sv_async.js b/tests/test_sv_async.js
new file mode 100644
index 0000000..08db5e7
--- /dev/null
+++ b/tests/test_sv_async.js
@@ -0,0 +1,90 @@
+// Test basic async/await in bytecode VM
+
+let passed = 0;
+let failed = 0;
+
+function test(name, actual, expected) {
+  if (actual === expected) {
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } else {
+    console.log(`  ✗ ${name}: expected ${expected}, got ${actual}`);
+    failed++;
+  }
+}
+
+// Test 1: async function returns a promise
+async function simple() {
+  return 42;
+}
+
+let p = simple();
+test('async returns promise', typeof p, 'object');
+
+// Test 2: await a resolved value
+async function awaitValue() {
+  let x = await 10;
+  return x + 5;
+}
+
+// Test 3: await a promise
+async function awaitPromise() {
+  let p = new Promise((resolve) => {
+    setTimeout(() => resolve(100), 10);
+  });
+  let val = await p;
+  return val;
+}
+
+// Test 4: multiple awaits
+async function multiAwait() {
+  let a = await Promise.resolve(1);
+  let b = await Promise.resolve(2);
+  let c = await Promise.resolve(3);
+  return a + b + c;
+}
+
+// Test 5: await in sequence
+async function sequential() {
+  let result = 0;
+  for (let i = 0; i < 5; i++) {
+    result += await Promise.resolve(i);
+  }
+  return result; // 0+1+2+3+4 = 10
+}
+
+// Test 6: async error handling
+async function throwInAsync() {
+  throw new Error('async error');
+}
+
+// Test 7: try/catch in async
+async function tryCatchAsync() {
+  try {
+    await Promise.reject('rejected');
+    return 'should not reach';
+  } catch (e) {
+    return 'caught: ' + e;
+  }
+}
+
+// Run tests
+console.log('Async/Await Tests\n');
+
+simple().then(v => test('simple async return', v, 42));
+
+awaitValue().then(v => test('await non-promise', v, 15));
+
+awaitPromise().then(v => test('await promise', v, 100));
+
+multiAwait().then(v => test('multiple awaits', v, 6));
+
+sequential().then(v => test('sequential awaits', v, 10));
+
+throwInAsync().catch(e => test('async throw rejects', e.message, 'async error'));
+
+tryCatchAsync().then(v => test('try/catch in async', v, 'caught: rejected'));
+
+setTimeout(() => {
+  console.log(`\n${passed} passed, ${failed} failed`);
+}, 200);
diff --git a/tests/test_tco_monad.js b/tests/test_tco_monad.js
index 5dab835..68cb9ce 100644
--- a/tests/test_tco_monad.js
+++ b/tests/test_tco_monad.js
@@ -11,7 +11,7 @@ const bind = (m, f) =>
 const pure = v => MkM(tc => eta => ({ tag: 1, h2: { h2: tc, h3: v } }));
 
 let chain = pure(0);
-for (let i = 0; i < 800; i++) {
+for (let i = 0; i < 1000; i++) {
   chain = bind(chain, v => pure(v + 1));
 }
 const result = chain.h1({})(0);
diff --git a/tests/test_template_regex_brace.cjs b/tests/test_template_regex_brace.cjs
new file mode 100644
index 0000000..09734c7
--- /dev/null
+++ b/tests/test_template_regex_brace.cjs
@@ -0,0 +1,17 @@
+function assertEq(actual, expected, label) {
+  if (actual !== expected) {
+    throw new Error(`${label}: expected '${expected}' got '${actual}'`);
+  }
+}
+
+const _ = "";
+const code = "foo";
+const generated = `export default${_ || (/^[{[\-\/]/.test(code) ? "" : " ")}${code};`;
+assertEq(generated, "export default foo;", "generated template");
+
+const rootPath = "resolve";
+const key = "alias";
+const dotted = `${rootPath}.${key}`;
+assertEq(dotted, "resolve.alias", "dotted template");
+
+console.log("ok");
diff --git a/tests/test_this.js b/tests/test_this.js
index dcda157..d15aee7 100644
--- a/tests/test_this.js
+++ b/tests/test_this.js
@@ -5,10 +5,12 @@ const user = {
     console.log(this);
 
     console.log(globalThis.Ant.version);
+    try {
+      console.log(this.crypto.randomUUID());
+    } catch (err) {
+      console.log(err);
+    }
     console.log(window.crypto.randomUUID());
-
-    console.log('\nexpecting error below');
-    console.log(this.crypto.randomUUID());
   }
 };
 
diff --git a/tests/test_timer_chain_iter.js b/tests/test_timer_chain_iter.js
index fbcbb9c..726ca08 100644
--- a/tests/test_timer_chain_iter.js
+++ b/tests/test_timer_chain_iter.js
@@ -72,7 +72,7 @@ const render = () => {
 
 let ticks = 0;
 const start = performance.now();
-const duration = 30000;
+const duration = 2000;
 const batch_size = 100;
 
 const run = () => {
diff --git a/tests/test_ub_class.js b/tests/test_ub_class.js
new file mode 100644
index 0000000..41a086f
--- /dev/null
+++ b/tests/test_ub_class.js
@@ -0,0 +1,8 @@
+const Bar = class bar {
+  static name() {}
+};
+
+delete Bar.name;
+
+console.log(Bar.name); // expected '' got undefined
+console.log(typeof Bar.name); // expected 'string' got 'undefined'
diff --git a/vendor/mir.wrap b/vendor/mir.wrap
new file mode 100644
index 0000000..54dc1e6
--- /dev/null
+++ b/vendor/mir.wrap
@@ -0,0 +1,8 @@
+[wrap-git]
+url = https://github.com/vnmakarov/mir.git
+revision = head
+patch_directory = mir
+depth = 1
+
+[provide]
+mir = mir_dep
diff --git a/vendor/packagefiles/mir/meson.build b/vendor/packagefiles/mir/meson.build
new file mode 100644
index 0000000..90299da
--- /dev/null
+++ b/vendor/packagefiles/mir/meson.build
@@ -0,0 +1,34 @@
+project('mir', 'c')
+
+cc = meson.get_compiler('c')
+cpu = host_machine.cpu_family()
+
+# mir-gen-<arch>.c files are #include'd directly inside mir-gen.c — they are
+# NOT standalone compilation units and must not be listed as sources here.
+mir_sources = files('mir.c', 'mir-gen.c')
+
+mir_warn_args = cc.get_supported_arguments([
+  '-Wno-unused-function',
+  '-Wno-unused-variable',
+  '-Wno-unused-parameter',
+  '-Wno-sign-compare',
+  '-Wno-missing-field-initializers',
+  '-Wno-implicit-fallthrough',
+  '-Wno-pedantic',
+  '-Wno-format-nonliteral',
+  '-Wno-cast-function-type',
+  '-Wno-double-promotion',
+  '-Wno-conversion',
+])
+
+mir_lib = static_library(
+  'mir',
+  mir_sources,
+  c_args: mir_warn_args,
+  install: false,
+)
+
+mir_dep = declare_dependency(
+  link_with: mir_lib,
+  include_directories: include_directories('.'),
+)
diff --git a/vendor/packagefiles/uriparser/meson.build b/vendor/packagefiles/uriparser/meson.build
new file mode 100644
index 0000000..fcf674f
--- /dev/null
+++ b/vendor/packagefiles/uriparser/meson.build
@@ -0,0 +1,60 @@
+project('uriparser', 'c', version: '1.0.0', default_options: ['c_std=c99', 'warning_level=0'])
+
+cc = meson.get_compiler('c')
+
+conf = configuration_data()
+conf.set_quoted('PACKAGE_VERSION', meson.project_version())
+conf.set('HAVE_REALLOCARRAY', cc.has_function('reallocarray'))
+
+configure_file(
+  output: 'UriConfig.h',
+  configuration: conf,
+)
+
+uriparser_src = files(
+  'src/UriCommon.c',
+  'src/UriCompare.c',
+  'src/UriCopy.c',
+  'src/UriEscape.c',
+  'src/UriFile.c',
+  'src/UriIp4.c',
+  'src/UriIp4Base.c',
+  'src/UriMemory.c',
+  'src/UriNormalize.c',
+  'src/UriNormalizeBase.c',
+  'src/UriParse.c',
+  'src/UriParseBase.c',
+  'src/UriQuery.c',
+  'src/UriRecompose.c',
+  'src/UriResolve.c',
+  'src/UriSetFragment.c',
+  'src/UriSetHostAuto.c',
+  'src/UriSetHostCommon.c',
+  'src/UriSetHostIp4.c',
+  'src/UriSetHostIp6.c',
+  'src/UriSetHostIpFuture.c',
+  'src/UriSetHostRegName.c',
+  'src/UriSetPath.c',
+  'src/UriSetPort.c',
+  'src/UriSetQuery.c',
+  'src/UriSetScheme.c',
+  'src/UriSetUserInfo.c',
+  'src/UriShorten.c',
+  'src/UriVersion.c',
+)
+
+uriparser_lib = static_library(
+  'uriparser',
+  uriparser_src,
+  include_directories: [
+    include_directories('include'),
+    include_directories('src'),
+  ],
+  c_args: ['-DURI_STATIC_BUILD', '-DURI_NO_UNICODE', '-DURI_LIBRARY_BUILD'],
+)
+
+uriparser_dep = declare_dependency(
+  link_with: uriparser_lib,
+  include_directories: include_directories('include'),
+  compile_args: ['-DURI_STATIC_BUILD', '-DURI_NO_UNICODE'],
+)
diff --git a/vendor/uriparser.wrap b/vendor/uriparser.wrap
new file mode 100644
index 0000000..7a0ba71
--- /dev/null
+++ b/vendor/uriparser.wrap
@@ -0,0 +1,8 @@
+[wrap-git]
+url = https://github.com/uriparser/uriparser.git
+revision = uriparser-1.0.0
+patch_directory = uriparser
+depth = 1
+
+[provide]
+uriparser = uriparser_dep
diff --git a/vendor/utf8proc.wrap b/vendor/utf8proc.wrap
new file mode 100644
index 0000000..44f8f40
--- /dev/null
+++ b/vendor/utf8proc.wrap
@@ -0,0 +1,13 @@
+[wrap-file]
+directory = utf8proc-2.10.0
+source_url = https://github.com/JuliaStrings/utf8proc/releases/download/v2.10.0/utf8proc-2.10.0.tar.gz
+source_filename = utf8proc-2.10.0.tar.gz
+source_hash = 276a37dc4d1dd24d7896826a579f4439d1e5fe33603add786bb083cab802e23e
+patch_filename = utf8proc_2.10.0-1_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/utf8proc_2.10.0-1/get_patch
+patch_hash = be16c4514603e922f9636045699fe1a6f844d340b9b7c14b809e47253b06a844
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/utf8proc_2.10.0-1/utf8proc-2.10.0.tar.gz
+wrapdb_version = 2.10.0-1
+
+[provide]
+libutf8proc = utf8proc_dep