diff --git a/dump_mcode.cm b/dump_mcode.cm
new file mode 100644
index 00000000..291b6e46
--- /dev/null
+++ b/dump_mcode.cm
@@ -0,0 +1,20 @@
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+var mcode = use("mcode")
+var streamline = use("streamline")
+
+var name = args[0]
+var src = text(fd.slurp(name))
+var tok = tokenize(src, name)
+var ast = parse(tok.tokens, src, name, tokenize)
+var folded = fold(ast)
+var compiled = mcode(folded)
+var optimized = streamline(compiled)
+var out = json.encode(optimized)
+var f = fd.open("/tmp/mcode_dump.json", "w")
+fd.write(f, out)
+fd.close(f)
+print("wrote /tmp/mcode_dump.json")
diff --git a/internal/bootstrap.cm b/internal/bootstrap.cm
index 09fb543f..26b10d95 100644
--- a/internal/bootstrap.cm
+++ b/internal/bootstrap.cm
@@ -1,5 +1,5 @@
 // Hidden vars come from env:
-//   CLI mode (cell_init):       os, args, core_path, shop_path, use_mcode
+//   CLI mode (cell_init):       os, args, core_path, shop_path, emit_qbe
 //   Actor spawn (script_startup): os, json, nota, wota, actorsym, init, core_path, shop_path
 // args[0] = script name, args[1..] = user args
 var load_internal = os.load_internal
@@ -45,14 +45,11 @@ use_cache['tokenize'] = tokenize_mod
 use_cache['parse'] = parse_mod
 use_cache['fold'] = fold_mod
 
-// Optionally load mcode compiler module
-var mcode_mod = null
+// Always load mcode compiler module
+var mcode_mod = boot_load("mcode", boot_env)
+use_cache['mcode'] = mcode_mod
 var streamline_mod = null
 var qbe_emit_mod = null
-if (use_mcode) {
-  mcode_mod = boot_load("mcode", boot_env)
-  use_cache['mcode'] = mcode_mod
-}
 
 // Warn if any .cm source is newer than its .mach bytecode
 function check_mach_stale() {
@@ -146,33 +143,26 @@ function load_module(name, env) {
 
 // Load optimization pipeline modules (needs analyze to be defined)
 var qbe_macros = null
-if (use_mcode) {
-  streamline_mod = load_module("streamline", boot_env)
-  use_cache['streamline'] = streamline_mod
-  if (emit_qbe) {
-    qbe_macros = load_module("qbe", boot_env)
-    qbe_emit_mod = load_module("qbe_emit", boot_env)
-    use_cache['qbe'] = qbe_macros
-    use_cache['qbe_emit'] = qbe_emit_mod
-  }
+streamline_mod = load_module("streamline", boot_env)
+use_cache['streamline'] = streamline_mod
+if (emit_qbe) {
+  qbe_macros = load_module("qbe", boot_env)
+  qbe_emit_mod = load_module("qbe_emit", boot_env)
+  use_cache['qbe'] = qbe_macros
+  use_cache['qbe_emit'] = qbe_emit_mod
 }
 
-// Run AST through either mcode or mach pipeline
+// Run AST through mcode pipeline → register VM
 function run_ast(name, ast, env) {
-  var compiled = null
-  var optimized = null
+  var compiled = mcode_mod(ast)
+  var optimized = streamline_mod(compiled)
   var qbe_il = null
-  if (use_mcode) {
-    compiled = mcode_mod(ast)
-    optimized = streamline_mod(compiled)
-    if (emit_qbe) {
-      qbe_il = qbe_emit_mod(optimized, qbe_macros)
-      print(qbe_il)
-      return null
-    }
-    return mcode_run(name, json.encode(optimized), env)
+  if (emit_qbe) {
+    qbe_il = qbe_emit_mod(optimized, qbe_macros)
+    print(qbe_il)
+    return null
   }
-  return mach_eval_ast(name, json.encode(ast), env)
+  return mach_eval_mcode(name, json.encode(optimized), env)
 }
 
 // use() with ƿit pipeline for .cm modules
diff --git a/internal/bootstrap.mach b/internal/bootstrap.mach
index f2696e69..2dc682f4 100644
Binary files a/internal/bootstrap.mach and b/internal/bootstrap.mach differ
diff --git a/source/cell.c b/source/cell.c
index e1a9e073..e28f18df 100644
--- a/source/cell.c
+++ b/source/cell.c
@@ -211,9 +211,9 @@ void script_startup(cell_rt *prt)
     JS_SetPropertyStr(js, hidden_env, "init", JS_NULL);
   }
 
-  // Set args and use_mcode to null/false for actor spawn (not CLI mode)
+  // Set args to null for actor spawn (not CLI mode)
   JS_SetPropertyStr(js, hidden_env, "args", JS_NULL);
-  JS_SetPropertyStr(js, hidden_env, "use_mcode", JS_NewBool(js, 0));
+  /* use_mcode no longer needed — new bootstrap always uses mcode pipeline */
 
   if (core_path)
     JS_SetPropertyStr(js, hidden_env, "core_path", JS_NewString(js, core_path));
@@ -290,7 +290,7 @@ static void print_usage(const char *prog)
   printf("Options:\n");
   printf("  --core <path>              Set core path directly (overrides CELL_CORE)\n");
   printf("  --shop <path>              Set shop path (overrides CELL_SHOP)\n");
-  printf("  --mcode <script> [args]    Run through mcode compilation pipeline\n");
+  printf("  --emit-qbe                 Emit QBE IL (for native compilation)\n");
   printf("  --test [heap_size]         Run C test suite\n");
   printf("  -h, --help                 Show this help message\n");
   printf("\nEnvironment:\n");
@@ -322,7 +322,6 @@ int cell_init(int argc, char **argv)
   }
 
   /* Default: run script through bootstrap pipeline */
-  int use_mcode = 0;
   int emit_qbe = 0;
   int arg_start = 1;
   const char *shop_override = NULL;
@@ -331,10 +330,9 @@ int cell_init(int argc, char **argv)
   // Parse flags (order-independent)
   while (arg_start < argc && argv[arg_start][0] == '-') {
     if (strcmp(argv[arg_start], "--mcode") == 0) {
-      use_mcode = 1;
+      /* --mcode is now always on; accept and ignore for compat */
       arg_start++;
     } else if (strcmp(argv[arg_start], "--emit-qbe") == 0) {
-      use_mcode = 1;  // QBE requires mcode pipeline
       emit_qbe = 1;
       arg_start++;
     } else if (strcmp(argv[arg_start], "--shop") == 0) {
@@ -420,7 +418,7 @@ int cell_init(int argc, char **argv)
   JS_SetPropertyStr(ctx, hidden_env, "core_path", JS_NewString(ctx, core_path));
   JS_SetPropertyStr(ctx, hidden_env, "shop_path",
     shop_path ? JS_NewString(ctx, shop_path) : JS_NULL);
-  JS_SetPropertyStr(ctx, hidden_env, "use_mcode", JS_NewBool(ctx, use_mcode));
+  /* use_mcode no longer needed — new bootstrap always uses mcode pipeline */
   JS_SetPropertyStr(ctx, hidden_env, "emit_qbe", JS_NewBool(ctx, emit_qbe));
   JS_SetPropertyStr(ctx, hidden_env, "actorsym", JS_DupValue(ctx, cli_rt->actor_sym_ref.val));
   JS_SetPropertyStr(ctx, hidden_env, "json", js_json_use(ctx));
diff --git a/source/mach.c b/source/mach.c
index f180843f..4c1f489a 100644
--- a/source/mach.c
+++ b/source/mach.c
@@ -3443,6 +3443,492 @@ JSValue JS_CallRegisterVM(JSContext *ctx, JSCodeRegister *code,
     case MACH_THROW:
       goto disrupt;
 
+    /* === New mcode-derived opcodes === */
+
+    /* Typed integer arithmetic — inline with overflow to float */
+    case MACH_ADD_INT: {
+      int32_t ia = JS_VALUE_GET_INT(frame->slots[b]);
+      int32_t ib = JS_VALUE_GET_INT(frame->slots[c]);
+      int64_t r = (int64_t)ia + (int64_t)ib;
+      frame->slots[a] = (r >= INT32_MIN && r <= INT32_MAX)
+          ? JS_NewInt32(ctx, (int32_t)r) : JS_NewFloat64(ctx, (double)r);
+      break;
+    }
+    case MACH_SUB_INT: {
+      int32_t ia = JS_VALUE_GET_INT(frame->slots[b]);
+      int32_t ib = JS_VALUE_GET_INT(frame->slots[c]);
+      int64_t r = (int64_t)ia - (int64_t)ib;
+      frame->slots[a] = (r >= INT32_MIN && r <= INT32_MAX)
+          ? JS_NewInt32(ctx, (int32_t)r) : JS_NewFloat64(ctx, (double)r);
+      break;
+    }
+    case MACH_MUL_INT: {
+      int32_t ia = JS_VALUE_GET_INT(frame->slots[b]);
+      int32_t ib = JS_VALUE_GET_INT(frame->slots[c]);
+      int64_t r = (int64_t)ia * (int64_t)ib;
+      frame->slots[a] = (r >= INT32_MIN && r <= INT32_MAX)
+          ? JS_NewInt32(ctx, (int32_t)r) : JS_NewFloat64(ctx, (double)r);
+      break;
+    }
+    case MACH_DIV_INT: {
+      int32_t ia = JS_VALUE_GET_INT(frame->slots[b]);
+      int32_t ib = JS_VALUE_GET_INT(frame->slots[c]);
+      if (ib == 0) { frame->slots[a] = JS_NULL; break; }
+      if (ia % ib == 0) frame->slots[a] = JS_NewInt32(ctx, ia / ib);
+      else frame->slots[a] = JS_NewFloat64(ctx, (double)ia / (double)ib);
+      break;
+    }
+    case MACH_MOD_INT: {
+      int32_t ia = JS_VALUE_GET_INT(frame->slots[b]);
+      int32_t ib = JS_VALUE_GET_INT(frame->slots[c]);
+      if (ib == 0) { frame->slots[a] = JS_NULL; break; }
+      frame->slots[a] = JS_NewInt32(ctx, ia % ib);
+      break;
+    }
+    case MACH_NEG_INT: {
+      int32_t i = JS_VALUE_GET_INT(frame->slots[b]);
+      if (i == INT32_MIN)
+        frame->slots[a] = JS_NewFloat64(ctx, -(double)i);
+      else
+        frame->slots[a] = JS_NewInt32(ctx, -i);
+      break;
+    }
+
+    /* Typed float arithmetic */
+    case MACH_ADD_FLOAT: {
+      double da, db;
+      JS_ToFloat64(ctx, &da, frame->slots[b]);
+      JS_ToFloat64(ctx, &db, frame->slots[c]);
+      frame->slots[a] = JS_NewFloat64(ctx, da + db);
+      break;
+    }
+    case MACH_SUB_FLOAT: {
+      double da, db;
+      JS_ToFloat64(ctx, &da, frame->slots[b]);
+      JS_ToFloat64(ctx, &db, frame->slots[c]);
+      frame->slots[a] = JS_NewFloat64(ctx, da - db);
+      break;
+    }
+    case MACH_MUL_FLOAT: {
+      double da, db;
+      JS_ToFloat64(ctx, &da, frame->slots[b]);
+      JS_ToFloat64(ctx, &db, frame->slots[c]);
+      frame->slots[a] = JS_NewFloat64(ctx, da * db);
+      break;
+    }
+    case MACH_DIV_FLOAT: {
+      double da, db;
+      JS_ToFloat64(ctx, &da, frame->slots[b]);
+      JS_ToFloat64(ctx, &db, frame->slots[c]);
+      if (db == 0.0) { frame->slots[a] = JS_NULL; break; }
+      frame->slots[a] = JS_NewFloat64(ctx, da / db);
+      break;
+    }
+    case MACH_MOD_FLOAT: {
+      double da, db;
+      JS_ToFloat64(ctx, &da, frame->slots[b]);
+      JS_ToFloat64(ctx, &db, frame->slots[c]);
+      if (db == 0.0) { frame->slots[a] = JS_NULL; break; }
+      frame->slots[a] = JS_NewFloat64(ctx, fmod(da, db));
+      break;
+    }
+    case MACH_NEG_FLOAT: {
+      double d;
+      JS_ToFloat64(ctx, &d, frame->slots[b]);
+      frame->slots[a] = JS_NewFloat64(ctx, -d);
+      break;
+    }
+
+    /* Text concatenation */
+    case MACH_CONCAT: {
+      JSValue res = JS_ConcatString(ctx, frame->slots[b], frame->slots[c]);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (JS_IsException(res)) goto disrupt;
+      frame->slots[a] = res;
+      break;
+    }
+
+    /* Typed integer comparisons */
+    case MACH_EQ_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_INT(frame->slots[b]) == JS_VALUE_GET_INT(frame->slots[c]));
+      break;
+    case MACH_NE_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_INT(frame->slots[b]) != JS_VALUE_GET_INT(frame->slots[c]));
+      break;
+    case MACH_LT_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_INT(frame->slots[b]) < JS_VALUE_GET_INT(frame->slots[c]));
+      break;
+    case MACH_LE_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_INT(frame->slots[b]) <= JS_VALUE_GET_INT(frame->slots[c]));
+      break;
+    case MACH_GT_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_INT(frame->slots[b]) > JS_VALUE_GET_INT(frame->slots[c]));
+      break;
+    case MACH_GE_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_INT(frame->slots[b]) >= JS_VALUE_GET_INT(frame->slots[c]));
+      break;
+
+    /* Typed float comparisons */
+    case MACH_EQ_FLOAT: case MACH_NE_FLOAT:
+    case MACH_LT_FLOAT: case MACH_LE_FLOAT:
+    case MACH_GT_FLOAT: case MACH_GE_FLOAT: {
+      double da, db;
+      JS_ToFloat64(ctx, &da, frame->slots[b]);
+      JS_ToFloat64(ctx, &db, frame->slots[c]);
+      int r;
+      switch (op) {
+      case MACH_EQ_FLOAT: r = (da == db); break;
+      case MACH_NE_FLOAT: r = (da != db); break;
+      case MACH_LT_FLOAT: r = (da <  db); break;
+      case MACH_LE_FLOAT: r = (da <= db); break;
+      case MACH_GT_FLOAT: r = (da >  db); break;
+      case MACH_GE_FLOAT: r = (da >= db); break;
+      default: r = 0; break;
+      }
+      frame->slots[a] = JS_NewBool(ctx, r);
+      break;
+    }
+
+    /* Typed text comparisons */
+    case MACH_EQ_TEXT: case MACH_NE_TEXT:
+    case MACH_LT_TEXT: case MACH_LE_TEXT:
+    case MACH_GT_TEXT: case MACH_GE_TEXT: {
+      int cmp = js_string_compare_value(ctx, frame->slots[b], frame->slots[c], FALSE);
+      int r;
+      switch (op) {
+      case MACH_EQ_TEXT: r = (cmp == 0); break;
+      case MACH_NE_TEXT: r = (cmp != 0); break;
+      case MACH_LT_TEXT: r = (cmp <  0); break;
+      case MACH_LE_TEXT: r = (cmp <= 0); break;
+      case MACH_GT_TEXT: r = (cmp >  0); break;
+      case MACH_GE_TEXT: r = (cmp >= 0); break;
+      default: r = 0; break;
+      }
+      frame->slots[a] = JS_NewBool(ctx, r);
+      break;
+    }
+
+    /* Typed bool comparisons */
+    case MACH_EQ_BOOL:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_BOOL(frame->slots[b]) == JS_VALUE_GET_BOOL(frame->slots[c]));
+      break;
+    case MACH_NE_BOOL:
+      frame->slots[a] = JS_NewBool(ctx, JS_VALUE_GET_BOOL(frame->slots[b]) != JS_VALUE_GET_BOOL(frame->slots[c]));
+      break;
+
+    /* Identity check */
+    case MACH_IS_IDENTICAL: {
+      JSValue va = JS_IsPtr(frame->slots[b]) ? JS_MKPTR(chase(frame->slots[b])) : frame->slots[b];
+      JSValue vb = JS_IsPtr(frame->slots[c]) ? JS_MKPTR(chase(frame->slots[c])) : frame->slots[c];
+      frame->slots[a] = JS_NewBool(ctx, va == vb);
+      break;
+    }
+
+    /* Type checks */
+    case MACH_IS_INT:
+      frame->slots[a] = JS_NewBool(ctx, JS_IsInt(frame->slots[b]));
+      break;
+    case MACH_IS_NUM:
+      frame->slots[a] = JS_NewBool(ctx, JS_IsNumber(frame->slots[b]));
+      break;
+    case MACH_IS_TEXT:
+      frame->slots[a] = JS_NewBool(ctx, JS_IsText(frame->slots[b]));
+      break;
+    case MACH_IS_BOOL:
+      frame->slots[a] = JS_NewBool(ctx, JS_IsBool(frame->slots[b]));
+      break;
+    case MACH_IS_NULL:
+      frame->slots[a] = JS_NewBool(ctx, JS_IsNull(frame->slots[b]));
+      break;
+    case MACH_TYPEOF: {
+      JSValue val = frame->slots[b];
+      const char *tname = "unknown";
+      if (JS_IsNull(val)) tname = "null";
+      else if (JS_IsInt(val) || JS_IsNumber(val)) tname = "number";
+      else if (JS_IsBool(val)) tname = "logical";
+      else if (JS_IsText(val)) tname = "text";
+      else if (JS_IsFunction(val)) tname = "function";
+      else if (JS_IsArray(val)) tname = "array";
+      else if (JS_IsRecord(val)) tname = "object";
+      JSValue res = JS_NewString(ctx, tname);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      frame->slots[a] = res;
+      break;
+    }
+
+    /* Logical */
+    case MACH_NOT: {
+      int bval = JS_ToBool(ctx, frame->slots[b]);
+      frame->slots[a] = JS_NewBool(ctx, !bval);
+      break;
+    }
+    case MACH_AND: {
+      int ba = JS_ToBool(ctx, frame->slots[b]);
+      int bb = JS_ToBool(ctx, frame->slots[c]);
+      frame->slots[a] = JS_NewBool(ctx, ba && bb);
+      break;
+    }
+    case MACH_OR: {
+      int ba = JS_ToBool(ctx, frame->slots[b]);
+      int bb = JS_ToBool(ctx, frame->slots[c]);
+      frame->slots[a] = JS_NewBool(ctx, ba || bb);
+      break;
+    }
+
+    /* Bitwise (mcode names — delegate to same code as legacy) */
+    case MACH_BITNOT: {
+      int32_t i;
+      JS_ToInt32(ctx, &i, frame->slots[b]);
+      frame->slots[a] = JS_NewInt32(ctx, ~i);
+      break;
+    }
+    case MACH_BITAND: case MACH_BITOR: case MACH_BITXOR: {
+      int32_t ia, ib;
+      JS_ToInt32(ctx, &ia, frame->slots[b]);
+      JS_ToInt32(ctx, &ib, frame->slots[c]);
+      int32_t r;
+      if (op == MACH_BITAND) r = ia & ib;
+      else if (op == MACH_BITOR) r = ia | ib;
+      else r = ia ^ ib;
+      frame->slots[a] = JS_NewInt32(ctx, r);
+      break;
+    }
+
+    /* Property access (mcode names) */
+    case MACH_LOAD_FIELD: {
+      JSValue obj = frame->slots[b];
+      JSValue key = code->cpool[c];
+      if (JS_IsFunction(obj)) {
+        JSFunction *fn_chk = JS_VALUE_GET_FUNCTION(obj);
+        if (fn_chk->length != 2) {
+          JS_ThrowTypeError(ctx, "cannot read property of non-proxy function");
+          frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+          goto disrupt;
+        }
+      }
+      JSValue val = JS_GetProperty(ctx, obj, key);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (JS_IsException(val)) goto disrupt;
+      frame->slots[a] = val;
+      break;
+    }
+    case MACH_STORE_FIELD: {
+      JSValue obj = frame->slots[a];
+      JSValue key = code->cpool[b];
+      JSValue val = frame->slots[c];
+      int ret = JS_SetProperty(ctx, obj, key, val);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (ret < 0) goto disrupt;
+      break;
+    }
+    case MACH_LOAD_INDEX: {
+      JSValue obj = frame->slots[b];
+      JSValue idx = frame->slots[c];
+      JSValue val;
+      if (JS_IsInt(idx))
+        val = JS_GetPropertyUint32(ctx, obj, JS_VALUE_GET_INT(idx));
+      else
+        val = JS_GetProperty(ctx, obj, idx);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (JS_IsException(val)) goto disrupt;
+      frame->slots[a] = val;
+      break;
+    }
+    case MACH_STORE_INDEX: {
+      JSValue obj = frame->slots[a];
+      JSValue idx = frame->slots[b];
+      JSValue val = frame->slots[c];
+      int ret;
+      if (JS_IsInt(idx))
+        ret = JS_SetPropertyUint32(ctx, obj, JS_VALUE_GET_INT(idx), val);
+      else
+        ret = JS_SetProperty(ctx, obj, idx, val);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (ret < 0) goto disrupt;
+      break;
+    }
+    case MACH_LOAD_DYNAMIC: {
+      JSValue obj = frame->slots[b];
+      JSValue key = frame->slots[c];
+      JSValue val;
+      if (JS_IsInt(key))
+        val = JS_GetPropertyUint32(ctx, obj, JS_VALUE_GET_INT(key));
+      else
+        val = JS_GetProperty(ctx, obj, key);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (JS_IsException(val)) goto disrupt;
+      frame->slots[a] = val;
+      break;
+    }
+    case MACH_STORE_DYNAMIC: {
+      JSValue obj = frame->slots[a];
+      JSValue key = frame->slots[b];
+      JSValue val = frame->slots[c];
+      int ret;
+      if (JS_IsInt(key))
+        ret = JS_SetPropertyUint32(ctx, obj, JS_VALUE_GET_INT(key), val);
+      else if (JS_IsArray(obj)) {
+        JS_ThrowTypeError(ctx, "array index must be a number");
+        ret = -1;
+      } else {
+        ret = JS_SetProperty(ctx, obj, key, val);
+      }
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (ret < 0) goto disrupt;
+      break;
+    }
+
+    /* New record */
+    case MACH_NEWRECORD: {
+      JSValue obj = JS_NewObject(ctx);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      if (JS_IsException(obj)) goto disrupt;
+      frame->slots[a] = obj;
+      break;
+    }
+
+    /* Decomposed function calls (inlined from qbe_helpers) */
+    case MACH_FRAME:
+    case MACH_GOFRAME: {
+      /* A=frame_slot, B=func_reg, C=argc */
+      JSValue func_val = frame->slots[b];
+      if (!JS_IsFunction(func_val)) {
+        JS_ThrowTypeError(ctx, "not a function");
+        frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+        goto disrupt;
+      }
+      int nr = c + 2; /* argc + this + func overhead */
+      JSFrameRegister *call_frame = alloc_frame_register(ctx, nr);
+      if (!call_frame) {
+        frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+        goto disrupt;
+      }
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      func_val = frame->slots[b]; /* re-read after GC */
+      call_frame->function = func_val;
+      frame->slots[a] = JS_MKPTR(call_frame);
+      break;
+    }
+    case MACH_SETARG: {
+      /* A=frame_slot, B=arg_idx, C=val_reg */
+      JSFrameRegister *fr = (JSFrameRegister *)JS_VALUE_GET_PTR(frame->slots[a]);
+      fr->slots[b] = frame->slots[c];
+      break;
+    }
+    case MACH_INVOKE: {
+      /* A=frame_slot, B=result_slot */
+      JSFrameRegister *fr = (JSFrameRegister *)JS_VALUE_GET_PTR(frame->slots[a]);
+      int nr = (int)objhdr_cap56(fr->hdr);
+      int c_argc = (nr >= 2) ? nr - 2 : 0;
+      JSValue fn_val = fr->function;
+      JSFunction *fn = JS_VALUE_GET_FUNCTION(fn_val);
+
+      if (fn->kind == JS_FUNC_KIND_REGISTER) {
+        /* Register function: switch frames inline (fast path) */
+        JSCodeRegister *fn_code = fn->u.reg.code;
+        JSFrameRegister *new_frame = alloc_frame_register(ctx, fn_code->nr_slots);
+        if (!new_frame) {
+          frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+          goto disrupt;
+        }
+        frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+        fr = (JSFrameRegister *)JS_VALUE_GET_PTR(frame->slots[a]);
+        fn_val = fr->function;
+        fn = JS_VALUE_GET_FUNCTION(fn_val);
+        fn_code = fn->u.reg.code;
+        new_frame->function = fn_val;
+        /* Copy this + args from call frame to new frame */
+        int copy_count = (c_argc < fn_code->arity) ? c_argc : fn_code->arity;
+        new_frame->slots[0] = fr->slots[0]; /* this */
+        for (int i = 0; i < copy_count; i++)
+          new_frame->slots[1 + i] = fr->slots[1 + i];
+        /* Save return info */
+        frame->address = JS_NewInt32(ctx, (pc << 16) | b);
+        new_frame->caller = JS_MKPTR(frame);
+        frame = new_frame;
+        frame_ref.val = JS_MKPTR(frame);
+        code = fn_code;
+        env = fn->u.reg.env_record;
+        pc = code->entry_point;
+      } else {
+        /* C or bytecode function: push args onto value stack */
+        int vs_base = ctx->value_stack_top;
+        for (int i = 0; i < c_argc; i++)
+          ctx->value_stack[vs_base + i] = fr->slots[i + 1];
+        ctx->value_stack_top = vs_base + c_argc;
+        ctx->reg_current_frame = frame_ref.val;
+        ctx->current_register_pc = pc > 0 ? pc - 1 : 0;
+        JSValue ret;
+        if (fn->kind == JS_FUNC_KIND_C)
+          ret = js_call_c_function(ctx, fn_val, fr->slots[0], c_argc, &ctx->value_stack[vs_base]);
+        else
+          ret = JS_CallInternal(ctx, fn_val, fr->slots[0], c_argc, &ctx->value_stack[vs_base], 0);
+        ctx->value_stack_top = vs_base;
+        frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+        ctx->reg_current_frame = JS_NULL;
+        if (JS_IsException(ret)) goto disrupt;
+        frame->slots[b] = ret;
+      }
+      break;
+    }
+    case MACH_GOINVOKE: {
+      /* Async invoke: call and discard result */
+      JSFrameRegister *fr = (JSFrameRegister *)JS_VALUE_GET_PTR(frame->slots[a]);
+      int nr = (int)objhdr_cap56(fr->hdr);
+      int c_argc = (nr >= 2) ? nr - 2 : 0;
+      int vs_base = ctx->value_stack_top;
+      for (int i = 0; i < c_argc; i++)
+        ctx->value_stack[vs_base + i] = fr->slots[i + 1];
+      ctx->value_stack_top = vs_base + c_argc;
+      ctx->reg_current_frame = frame_ref.val;
+      ctx->current_register_pc = pc > 0 ? pc - 1 : 0;
+      JSValue ret = JS_Call(ctx, fr->function, fr->slots[0],
+                            c_argc, &ctx->value_stack[vs_base]);
+      ctx->value_stack_top = vs_base;
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      ctx->reg_current_frame = JS_NULL;
+      if (JS_IsException(ret)) goto disrupt;
+      break;
+    }
+
+    /* Jump if not null */
+    case MACH_JMPNOTNULL: {
+      if (!JS_IsNull(frame->slots[a])) {
+        int offset = MACH_GET_sBx(instr);
+        pc = (uint32_t)((int32_t)pc + offset);
+      }
+      break;
+    }
+
+    /* Disrupt (mcode alias) */
+    case MACH_DISRUPT:
+      goto disrupt;
+
+    /* Variable storage: env/global[K(Bx)] = R(A) */
+    case MACH_SET_VAR: {
+      int bx = MACH_GET_Bx(instr);
+      JSValue key = code->cpool[bx];
+      JSValue val = frame->slots[a];
+      JSValue cur_env = JS_VALUE_GET_FUNCTION(frame->function)->u.reg.env_record;
+      if (!JS_IsNull(cur_env)) {
+        JS_SetProperty(ctx, cur_env, key, val);
+      } else {
+        JS_SetProperty(ctx, ctx->global_obj, key, val);
+      }
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      break;
+    }
+
+    /* Has-property check (mcode name) */
+    case MACH_IN: {
+      JSValue key = frame->slots[b];
+      JSValue obj = frame->slots[c];
+      int has = JS_HasProperty(ctx, obj, key);
+      frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
+      frame->slots[a] = JS_NewBool(ctx, has > 0);
+      break;
+    }
+
     default:
       result = JS_ThrowInternalError(ctx, "unknown register VM opcode %d", op);
       goto done;
@@ -3502,9 +3988,534 @@ done:
 }
 
 /* ============================================================
-   MCODE Generator — AST to MCODE JSON (string-based IR)
+   MCODE Lowering — mcode JSON IR → MachInstr32
    ============================================================ */
 
+typedef struct {
+  MachInstr32 *code;
+  int code_count, code_cap;
+  MachCPoolEntry *cpool;
+  int cpool_count, cpool_cap;
+  MachLineEntry *lines;
+  int nr_slots;
+  struct { const char *name; int pc; } *labels;
+  int label_count, label_cap;
+  struct { int pc; const char *label; int is_sJ; int reg_a; } *patches;
+  int patch_count, patch_cap;
+  int *flat_to_pc;
+  int flat_count;
+} McodeLowerState;
+
+static void ml_emit(McodeLowerState *s, MachInstr32 instr, int line, int col) {
+  if (s->code_count >= s->code_cap) {
+    int nc = s->code_cap ? s->code_cap * 2 : 64;
+    s->code = sys_realloc(s->code, nc * sizeof(MachInstr32));
+    s->lines = sys_realloc(s->lines, nc * sizeof(MachLineEntry));
+    s->code_cap = nc;
+  }
+  s->lines[s->code_count] = (MachLineEntry){(uint16_t)line, (uint16_t)col};
+  s->code[s->code_count++] = instr;
+}
+
+static int ml_cpool_int(McodeLowerState *s, int32_t val) {
+  for (int i = 0; i < s->cpool_count; i++)
+    if (s->cpool[i].type == MACH_CP_INT && s->cpool[i].ival == val) return i;
+  if (s->cpool_count >= s->cpool_cap) {
+    int nc = s->cpool_cap ? s->cpool_cap * 2 : 16;
+    s->cpool = sys_realloc(s->cpool, nc * sizeof(MachCPoolEntry));
+    s->cpool_cap = nc;
+  }
+  s->cpool[s->cpool_count] = (MachCPoolEntry){.type = MACH_CP_INT, .ival = val};
+  return s->cpool_count++;
+}
+
+static int ml_cpool_float(McodeLowerState *s, double val) {
+  for (int i = 0; i < s->cpool_count; i++)
+    if (s->cpool[i].type == MACH_CP_FLOAT && s->cpool[i].fval == val) return i;
+  if (s->cpool_count >= s->cpool_cap) {
+    int nc = s->cpool_cap ? s->cpool_cap * 2 : 16;
+    s->cpool = sys_realloc(s->cpool, nc * sizeof(MachCPoolEntry));
+    s->cpool_cap = nc;
+  }
+  s->cpool[s->cpool_count] = (MachCPoolEntry){.type = MACH_CP_FLOAT, .fval = val};
+  return s->cpool_count++;
+}
+
+static int ml_cpool_str(McodeLowerState *s, const char *str) {
+  if (!str) { fprintf(stderr, "ml_cpool_str: NULL string\n"); str = ""; }
+  for (int i = 0; i < s->cpool_count; i++)
+    if (s->cpool[i].type == MACH_CP_STR && strcmp(s->cpool[i].str, str) == 0) return i;
+  if (s->cpool_count >= s->cpool_cap) {
+    int nc = s->cpool_cap ? s->cpool_cap * 2 : 16;
+    s->cpool = sys_realloc(s->cpool, nc * sizeof(MachCPoolEntry));
+    s->cpool_cap = nc;
+  }
+  char *dup = sys_malloc(strlen(str) + 1);
+  memcpy(dup, str, strlen(str) + 1);
+  s->cpool[s->cpool_count] = (MachCPoolEntry){.type = MACH_CP_STR, .str = dup};
+  return s->cpool_count++;
+}
+
+static void ml_label(McodeLowerState *s, const char *name) {
+  if (s->label_count >= s->label_cap) {
+    int nc = s->label_cap ? s->label_cap * 2 : 32;
+    s->labels = sys_realloc(s->labels, nc * sizeof(s->labels[0]));
+    s->label_cap = nc;
+  }
+  s->labels[s->label_count].name = name;
+  s->labels[s->label_count].pc = s->code_count;
+  s->label_count++;
+}
+
+static void ml_patch(McodeLowerState *s, int pc, const char *label, int is_sJ, int reg_a) {
+  if (s->patch_count >= s->patch_cap) {
+    int nc = s->patch_cap ? s->patch_cap * 2 : 32;
+    s->patches = sys_realloc(s->patches, nc * sizeof(s->patches[0]));
+    s->patch_cap = nc;
+  }
+  s->patches[s->patch_count].pc = pc;
+  s->patches[s->patch_count].label = label;
+  s->patches[s->patch_count].is_sJ = is_sJ;
+  s->patches[s->patch_count].reg_a = reg_a;
+  s->patch_count++;
+}
+
+static int ml_int(cJSON *arr, int idx) {
+  return (int)cJSON_GetArrayItem(arr, idx)->valuedouble;
+}
+
+/* Lower one function's mcode instructions to MachInstr32 */
+static MachCode *mcode_lower_func(cJSON *fobj, const char *filename) {
+  McodeLowerState s = {0};
+  int nr_args = (int)cJSON_GetNumberValue(
+      cJSON_GetObjectItemCaseSensitive(fobj, "nr_args"));
+  int nr_close = (int)cJSON_GetNumberValue(
+      cJSON_GetObjectItemCaseSensitive(fobj, "nr_close_slots"));
+  s.nr_slots = (int)cJSON_GetNumberValue(
+      cJSON_GetObjectItemCaseSensitive(fobj, "nr_slots"));
+  int dis_raw = (int)cJSON_GetNumberValue(
+      cJSON_GetObjectItemCaseSensitive(fobj, "disruption_pc"));
+  cJSON *nm = cJSON_GetObjectItemCaseSensitive(fobj, "name");
+  const char *name = nm ? cJSON_GetStringValue(nm) : NULL;
+  cJSON *fn_j = cJSON_GetObjectItemCaseSensitive(fobj, "filename");
+  const char *fname = fn_j ? cJSON_GetStringValue(fn_j) : filename;
+  cJSON *instrs = cJSON_GetObjectItemCaseSensitive(fobj, "instructions");
+  int n = instrs ? cJSON_GetArraySize(instrs) : 0;
+
+  s.flat_to_pc = sys_malloc((n + 1) * sizeof(int));
+  s.flat_count = n;
+
+  for (int i = 0; i < n; i++) {
+    cJSON *it = cJSON_GetArrayItem(instrs, i);
+    s.flat_to_pc[i] = s.code_count;
+    if (cJSON_IsString(it)) {
+      ml_label(&s, it->valuestring);
+      continue;
+    }
+    int sz = cJSON_GetArraySize(it);
+    const char *op = cJSON_GetArrayItem(it, 0)->valuestring;
+    int line = ml_int(it, sz - 2);
+    int col = ml_int(it, sz - 1);
+
+#define A1 ml_int(it,1)
+#define A2 ml_int(it,2)
+#define A3 ml_int(it,3)
+#define A4 ml_int(it,4)
+#define EM(instr) ml_emit(&s, (instr), line, col)
+#define ABC3(opc) EM(MACH_ABC(opc, A1, A2, A3))
+#define AB2(opc)  EM(MACH_ABC(opc, A1, A2, 0))
+
+    if (strcmp(op, "access") == 0) {
+      int dest = A1;
+      cJSON *val = cJSON_GetArrayItem(it, 2);
+      if (cJSON_IsNumber(val)) {
+        double dv = val->valuedouble;
+        int32_t iv = (int32_t)dv;
+        if ((double)iv == dv && iv >= -32768 && iv <= 32767)
+          EM(MACH_AsBx(MACH_LOADI, dest, iv));
+        else if ((double)iv == dv)
+          EM(MACH_ABx(MACH_LOADK, dest, ml_cpool_int(&s, iv)));
+        else
+          EM(MACH_ABx(MACH_LOADK, dest, ml_cpool_float(&s, dv)));
+      } else if (cJSON_IsString(val)) {
+        EM(MACH_ABx(MACH_LOADK, dest, ml_cpool_str(&s, val->valuestring)));
+      } else if (cJSON_IsObject(val)) {
+        const char *vn = cJSON_GetStringValue(
+            cJSON_GetObjectItemCaseSensitive(val, "name"));
+        EM(MACH_ABx(MACH_GETNAME, dest, ml_cpool_str(&s, vn)));
+      }
+    }
+    else if (strcmp(op, "int") == 0) {
+      int dest = A1, v = A2;
+      if (v >= -32768 && v <= 32767)
+        EM(MACH_AsBx(MACH_LOADI, dest, v));
+      else
+        EM(MACH_ABx(MACH_LOADK, dest, ml_cpool_int(&s, v)));
+    }
+    else if (strcmp(op, "true") == 0)    { EM(MACH_ABC(MACH_LOADTRUE, A1, 0, 0)); }
+    else if (strcmp(op, "false") == 0)   { EM(MACH_ABC(MACH_LOADFALSE, A1, 0, 0)); }
+    else if (strcmp(op, "null") == 0)    { EM(MACH_ABC(MACH_LOADNULL, A1, 0, 0)); }
+    else if (strcmp(op, "move") == 0)    { AB2(MACH_MOVE); }
+    /* Typed integer arithmetic */
+    else if (strcmp(op, "add_int") == 0) { ABC3(MACH_ADD_INT); }
+    else if (strcmp(op, "sub_int") == 0) { ABC3(MACH_SUB_INT); }
+    else if (strcmp(op, "mul_int") == 0) { ABC3(MACH_MUL_INT); }
+    else if (strcmp(op, "div_int") == 0) { ABC3(MACH_DIV_INT); }
+    else if (strcmp(op, "mod_int") == 0) { ABC3(MACH_MOD_INT); }
+    else if (strcmp(op, "neg_int") == 0) { AB2(MACH_NEG_INT); }
+    /* Typed float arithmetic */
+    else if (strcmp(op, "add_float") == 0) { ABC3(MACH_ADD_FLOAT); }
+    else if (strcmp(op, "sub_float") == 0) { ABC3(MACH_SUB_FLOAT); }
+    else if (strcmp(op, "mul_float") == 0) { ABC3(MACH_MUL_FLOAT); }
+    else if (strcmp(op, "div_float") == 0) { ABC3(MACH_DIV_FLOAT); }
+    else if (strcmp(op, "mod_float") == 0) { ABC3(MACH_MOD_FLOAT); }
+    else if (strcmp(op, "neg_float") == 0) { AB2(MACH_NEG_FLOAT); }
+    /* Text */
+    else if (strcmp(op, "concat") == 0)  { ABC3(MACH_CONCAT); }
+    /* Generic arithmetic */
+    else if (strcmp(op, "pow") == 0)     { ABC3(MACH_POW); }
+    /* Typed integer comparisons */
+    else if (strcmp(op, "eq_int") == 0)  { ABC3(MACH_EQ_INT); }
+    else if (strcmp(op, "ne_int") == 0)  { ABC3(MACH_NE_INT); }
+    else if (strcmp(op, "lt_int") == 0)  { ABC3(MACH_LT_INT); }
+    else if (strcmp(op, "le_int") == 0)  { ABC3(MACH_LE_INT); }
+    else if (strcmp(op, "gt_int") == 0)  { ABC3(MACH_GT_INT); }
+    else if (strcmp(op, "ge_int") == 0)  { ABC3(MACH_GE_INT); }
+    /* Typed float comparisons */
+    else if (strcmp(op, "eq_float") == 0) { ABC3(MACH_EQ_FLOAT); }
+    else if (strcmp(op, "ne_float") == 0) { ABC3(MACH_NE_FLOAT); }
+    else if (strcmp(op, "lt_float") == 0) { ABC3(MACH_LT_FLOAT); }
+    else if (strcmp(op, "le_float") == 0) { ABC3(MACH_LE_FLOAT); }
+    else if (strcmp(op, "gt_float") == 0) { ABC3(MACH_GT_FLOAT); }
+    else if (strcmp(op, "ge_float") == 0) { ABC3(MACH_GE_FLOAT); }
+    /* Typed text comparisons */
+    else if (strcmp(op, "eq_text") == 0) { ABC3(MACH_EQ_TEXT); }
+    else if (strcmp(op, "ne_text") == 0) { ABC3(MACH_NE_TEXT); }
+    else if (strcmp(op, "lt_text") == 0) { ABC3(MACH_LT_TEXT); }
+    else if (strcmp(op, "le_text") == 0) { ABC3(MACH_LE_TEXT); }
+    else if (strcmp(op, "gt_text") == 0) { ABC3(MACH_GT_TEXT); }
+    else if (strcmp(op, "ge_text") == 0) { ABC3(MACH_GE_TEXT); }
+    /* Typed bool comparisons */
+    else if (strcmp(op, "eq_bool") == 0) { ABC3(MACH_EQ_BOOL); }
+    else if (strcmp(op, "ne_bool") == 0) { ABC3(MACH_NE_BOOL); }
+    /* Special comparisons */
+    else if (strcmp(op, "is_identical") == 0) { ABC3(MACH_IS_IDENTICAL); }
+    else if (strcmp(op, "eq_tol") == 0) {
+      /* A=dest, B=a, C=b; tolerance in operand 4 */
+      int dest = A1, ra = A2, rb = A3, rt = A4;
+      /* Move to consecutive scratch slots at end of frame */
+      int base = s.nr_slots;
+      s.nr_slots += 3;
+      EM(MACH_ABC(MACH_MOVE, base, ra, 0));
+      EM(MACH_ABC(MACH_MOVE, base + 1, rb, 0));
+      EM(MACH_ABC(MACH_MOVE, base + 2, rt, 0));
+      EM(MACH_ABC(MACH_EQ_TOL, dest, base, 3));
+    }
+    else if (strcmp(op, "ne_tol") == 0) {
+      int dest = A1, ra = A2, rb = A3, rt = A4;
+      int base = s.nr_slots;
+      s.nr_slots += 3;
+      EM(MACH_ABC(MACH_MOVE, base, ra, 0));
+      EM(MACH_ABC(MACH_MOVE, base + 1, rb, 0));
+      EM(MACH_ABC(MACH_MOVE, base + 2, rt, 0));
+      EM(MACH_ABC(MACH_NEQ_TOL, dest, base, 3));
+    }
+    /* Type checks */
+    else if (strcmp(op, "is_int") == 0)  { AB2(MACH_IS_INT); }
+    else if (strcmp(op, "is_num") == 0)  { AB2(MACH_IS_NUM); }
+    else if (strcmp(op, "is_text") == 0) { AB2(MACH_IS_TEXT); }
+    else if (strcmp(op, "is_bool") == 0) { AB2(MACH_IS_BOOL); }
+    else if (strcmp(op, "is_null") == 0) { AB2(MACH_IS_NULL); }
+    else if (strcmp(op, "typeof") == 0)  { AB2(MACH_TYPEOF); }
+    /* Logical */
+    else if (strcmp(op, "not") == 0)     { AB2(MACH_NOT); }
+    else if (strcmp(op, "and") == 0)     { ABC3(MACH_AND); }
+    else if (strcmp(op, "or") == 0)      { ABC3(MACH_OR); }
+    /* Bitwise */
+    else if (strcmp(op, "bitnot") == 0)  { AB2(MACH_BITNOT); }
+    else if (strcmp(op, "bitand") == 0)  { ABC3(MACH_BITAND); }
+    else if (strcmp(op, "bitor") == 0)   { ABC3(MACH_BITOR); }
+    else if (strcmp(op, "bitxor") == 0)  { ABC3(MACH_BITXOR); }
+    else if (strcmp(op, "shl") == 0)     { ABC3(MACH_SHL); }
+    else if (strcmp(op, "shr") == 0)     { ABC3(MACH_SHR); }
+    else if (strcmp(op, "ushr") == 0)    { ABC3(MACH_USHR); }
+    /* Property access */
+    else if (strcmp(op, "load_field") == 0) {
+      int dest = A1, obj = A2;
+      const char *key = cJSON_GetArrayItem(it, 3)->valuestring;
+      EM(MACH_ABC(MACH_LOAD_FIELD, dest, obj, ml_cpool_str(&s, key)));
+    }
+    else if (strcmp(op, "store_field") == 0) {
+      int obj = A1, val = A2;
+      const char *key = cJSON_GetArrayItem(it, 3)->valuestring;
+      EM(MACH_ABC(MACH_STORE_FIELD, obj, ml_cpool_str(&s, key), val));
+    }
+    else if (strcmp(op, "load_index") == 0)   { ABC3(MACH_LOAD_INDEX); }
+    else if (strcmp(op, "store_index") == 0) {
+      /* mcode: store_index obj val idx → VM: R(A)[R(B)] = R(C) */
+      EM(MACH_ABC(MACH_STORE_INDEX, A1, A3, A2));
+    }
+    else if (strcmp(op, "load_dynamic") == 0)  { ABC3(MACH_LOAD_DYNAMIC); }
+    else if (strcmp(op, "store_dynamic") == 0) {
+      /* mcode: store_dynamic obj val key → VM: R(A)[R(B)] = R(C) */
+      EM(MACH_ABC(MACH_STORE_DYNAMIC, A1, A3, A2));
+    }
+    /* Delete */
+    else if (strcmp(op, "delete") == 0) {
+      ABC3(MACH_DELETEINDEX);
+    }
+    /* Array/Object creation */
+    else if (strcmp(op, "array") == 0) {
+      int dest = A1, count = A2;
+      EM(MACH_ABC(MACH_NEWARRAY, dest, 0, 0));
+      for (int j = 0; j < count; j++) {
+        int elem = ml_int(it, 3 + j);
+        EM(MACH_ABC(MACH_PUSH, dest, elem, 0));
+      }
+    }
+    else if (strcmp(op, "record") == 0) {
+      EM(MACH_ABC(MACH_NEWRECORD, A1, 0, 0));
+    }
+    /* Push/Pop */
+    else if (strcmp(op, "push") == 0) {
+      EM(MACH_ABC(MACH_PUSH, A1, A2, 0));
+    }
+    else if (strcmp(op, "pop") == 0) {
+      EM(MACH_ABC(MACH_POP, A1, A2, 0));
+    }
+    /* Closure access */
+    else if (strcmp(op, "get") == 0) {
+      /* mcode: get dest slot level → GETUP A=dest B=level C=slot */
+      EM(MACH_ABC(MACH_GETUP, A1, A3, A2));
+    }
+    else if (strcmp(op, "put") == 0) {
+      /* mcode: put src slot level → SETUP A=src B=level C=slot */
+      EM(MACH_ABC(MACH_SETUP, A1, A3, A2));
+    }
+    /* Function creation */
+    else if (strcmp(op, "function") == 0) {
+      EM(MACH_ABx(MACH_CLOSURE, A1, A2));
+    }
+    /* Decomposed function calls */
+    else if (strcmp(op, "frame") == 0) {
+      EM(MACH_ABC(MACH_FRAME, A1, A2, A3));
+    }
+    else if (strcmp(op, "setarg") == 0) {
+      EM(MACH_ABC(MACH_SETARG, A1, A2, A3));
+    }
+    else if (strcmp(op, "invoke") == 0) {
+      EM(MACH_ABC(MACH_INVOKE, A1, A2, 0));
+    }
+    else if (strcmp(op, "goframe") == 0) {
+      EM(MACH_ABC(MACH_GOFRAME, A1, A2, A3));
+    }
+    else if (strcmp(op, "goinvoke") == 0) {
+      EM(MACH_ABC(MACH_GOINVOKE, A1, 0, 0));
+    }
+    /* Control flow */
+    else if (strcmp(op, "jump") == 0) {
+      const char *lbl = cJSON_GetArrayItem(it, 1)->valuestring;
+      int pc_now = s.code_count;
+      EM(MACH_sJ(MACH_JMP, 0));
+      ml_patch(&s, pc_now, lbl, 1, 0);
+    }
+    else if (strcmp(op, "jump_true") == 0) {
+      int reg = A1;
+      const char *lbl = cJSON_GetArrayItem(it, 2)->valuestring;
+      int pc_now = s.code_count;
+      EM(MACH_AsBx(MACH_JMPTRUE, reg, 0));
+      ml_patch(&s, pc_now, lbl, 0, reg);
+    }
+    else if (strcmp(op, "jump_false") == 0) {
+      int reg = A1;
+      const char *lbl = cJSON_GetArrayItem(it, 2)->valuestring;
+      int pc_now = s.code_count;
+      EM(MACH_AsBx(MACH_JMPFALSE, reg, 0));
+      ml_patch(&s, pc_now, lbl, 0, reg);
+    }
+    else if (strcmp(op, "jump_not_null") == 0) {
+      int reg = A1;
+      const char *lbl = cJSON_GetArrayItem(it, 2)->valuestring;
+      int pc_now = s.code_count;
+      EM(MACH_AsBx(MACH_JMPNOTNULL, reg, 0));
+      ml_patch(&s, pc_now, lbl, 0, reg);
+    }
+    /* Return / error */
+    else if (strcmp(op, "return") == 0) {
+      EM(MACH_ABC(MACH_RETURN, A1, 0, 0));
+    }
+    else if (strcmp(op, "disrupt") == 0) {
+      EM(MACH_ABC(MACH_DISRUPT, 0, 0, 0));
+    }
+    /* Variable storage */
+    else if (strcmp(op, "set_var") == 0) {
+      const char *vname = cJSON_GetArrayItem(it, 1)->valuestring;
+      int val_reg = A2;
+      EM(MACH_ABx(MACH_SET_VAR, val_reg, ml_cpool_str(&s, vname)));
+    }
+    /* Misc */
+    else if (strcmp(op, "in") == 0) {
+      EM(MACH_ABC(MACH_IN, A1, A2, A3));
+    }
+    else if (strcmp(op, "regexp") == 0) {
+      int dest = A1;
+      const char *pat = cJSON_GetArrayItem(it, 2)->valuestring;
+      const char *flg = cJSON_GetArrayItem(it, 3)->valuestring;
+      EM(MACH_ABC(MACH_REGEXP, dest, ml_cpool_str(&s, pat), ml_cpool_str(&s, flg)));
+    }
+    else {
+      /* Unknown opcode — emit NOP */
+      EM(MACH_ABC(MACH_NOP, 0, 0, 0));
+    }
+  }
+  /* Sentinel for flat_to_pc */
+  s.flat_to_pc[n] = s.code_count;
+
+#undef A1
+#undef A2
+#undef A3
+#undef A4
+#undef EM
+#undef ABC3
+#undef AB2
+
+  /* Resolve pending jump patches */
+  for (int i = 0; i < s.patch_count; i++) {
+    int target = -1;
+    for (int j = 0; j < s.label_count; j++) {
+      if (strcmp(s.labels[j].name, s.patches[i].label) == 0) {
+        target = s.labels[j].pc;
+        break;
+      }
+    }
+    if (target < 0) {
+      fprintf(stderr, "mcode_lower: unknown label '%s'\n", s.patches[i].label);
+      continue;
+    }
+    int offset = target - (s.patches[i].pc + 1);
+    if (s.patches[i].is_sJ) {
+      int old_op = MACH_GET_OP(s.code[s.patches[i].pc]);
+      s.code[s.patches[i].pc] = MACH_sJ(old_op, offset);
+    } else {
+      int old_op = MACH_GET_OP(s.code[s.patches[i].pc]);
+      s.code[s.patches[i].pc] = MACH_AsBx(old_op, s.patches[i].reg_a, offset);
+    }
+  }
+
+  MachCode *mc = sys_malloc(sizeof(MachCode));
+  memset(mc, 0, sizeof(MachCode));
+  mc->arity = nr_args;
+  mc->nr_close_slots = nr_close;
+  mc->nr_slots = s.nr_slots;
+  mc->entry_point = 0;
+  mc->instr_count = s.code_count;
+  mc->instructions = s.code;
+  mc->cpool_count = s.cpool_count;
+  mc->cpool = s.cpool;
+  mc->line_table = s.lines;
+  if (name && name[0]) {
+    mc->name = sys_malloc(strlen(name) + 1);
+    memcpy(mc->name, name, strlen(name) + 1);
+  }
+  if (fname) {
+    mc->filename = sys_malloc(strlen(fname) + 1);
+    memcpy(mc->filename, fname, strlen(fname) + 1);
+  }
+  mc->disruption_pc = 0;
+  if (dis_raw > 0 && dis_raw < s.flat_count)
+    mc->disruption_pc = s.flat_to_pc[dis_raw];
+
+  sys_free(s.flat_to_pc);
+  sys_free(s.labels);
+  sys_free(s.patches);
+  return mc;
+}
+
+/* Assign nested functions to each MachCode based on CLOSURE instructions.
+   all_funcs is the flat array from the mcode JSON; compiled[i] is the
+   compiled MachCode for all_funcs[i]. mc is a compiled MachCode (main or
+   one of the flat functions). Scans its instructions for MACH_CLOSURE Bx
+   and builds mc->functions with remapped local indices. */
+static void mcode_assign_children(MachCode *mc, MachCode **compiled, int total) {
+  /* Count unique CLOSURE references */
+  int *refs = NULL;
+  int ref_count = 0, ref_cap = 0;
+  for (uint32_t i = 0; i < mc->instr_count; i++) {
+    if (MACH_GET_OP(mc->instructions[i]) == MACH_CLOSURE) {
+      int bx = MACH_GET_Bx(mc->instructions[i]);
+      /* Check if already in refs */
+      int found = 0;
+      for (int j = 0; j < ref_count; j++) {
+        if (refs[j] == bx) { found = 1; break; }
+      }
+      if (!found) {
+        if (ref_count >= ref_cap) {
+          ref_cap = ref_cap ? ref_cap * 2 : 8;
+          refs = sys_realloc(refs, ref_cap * sizeof(int));
+        }
+        refs[ref_count++] = bx;
+      }
+    }
+  }
+  if (ref_count == 0) { sys_free(refs); return; }
+
+  /* Build local functions array (preserve original order by flat index) */
+  /* Sort refs by value to maintain consistent ordering */
+  for (int i = 0; i < ref_count - 1; i++)
+    for (int j = i + 1; j < ref_count; j++)
+      if (refs[i] > refs[j]) { int t = refs[i]; refs[i] = refs[j]; refs[j] = t; }
+
+  mc->func_count = ref_count;
+  mc->functions = sys_malloc(ref_count * sizeof(MachCode *));
+  for (int i = 0; i < ref_count; i++)
+    mc->functions[i] = (refs[i] < total) ? compiled[refs[i]] : NULL;
+
+  /* Remap CLOSURE Bx: flat index → local index */
+  for (uint32_t i = 0; i < mc->instr_count; i++) {
+    if (MACH_GET_OP(mc->instructions[i]) == MACH_CLOSURE) {
+      int a = MACH_GET_A(mc->instructions[i]);
+      int bx = MACH_GET_Bx(mc->instructions[i]);
+      for (int j = 0; j < ref_count; j++) {
+        if (refs[j] == bx) {
+          mc->instructions[i] = MACH_ABx(MACH_CLOSURE, a, j);
+          break;
+        }
+      }
+    }
+  }
+  sys_free(refs);
+}
+
+/* Compile mcode JSON IR to MachCode binary.
+   mcode_json has: functions[], main{}, filename, name */
+MachCode *mach_compile_mcode(cJSON *mcode_json) {
+  const char *filename = cJSON_GetStringValue(
+      cJSON_GetObjectItemCaseSensitive(mcode_json, "filename"));
+  cJSON *funcs_arr = cJSON_GetObjectItemCaseSensitive(mcode_json, "functions");
+  int func_count = funcs_arr ? cJSON_GetArraySize(funcs_arr) : 0;
+
+  /* Compile all flat functions */
+  MachCode **compiled = NULL;
+  if (func_count > 0) {
+    compiled = sys_malloc(func_count * sizeof(MachCode *));
+    memset(compiled, 0, func_count * sizeof(MachCode *));
+    for (int i = 0; i < func_count; i++)
+      compiled[i] = mcode_lower_func(cJSON_GetArrayItem(funcs_arr, i), filename);
+  }
+
+  /* Compile main */
+  cJSON *main_obj = cJSON_GetObjectItemCaseSensitive(mcode_json, "main");
+  MachCode *main_code = mcode_lower_func(main_obj, filename);
+
+  /* Assign nested functions to each compiled unit */
+  for (int i = 0; i < func_count; i++)
+    mcode_assign_children(compiled[i], compiled, func_count);
+  mcode_assign_children(main_code, compiled, func_count);
+
+  sys_free(compiled);
+  return main_code;
+}
+
 
 /* ============================================================
    MACH Public API
diff --git a/source/quickjs-internal.h b/source/quickjs-internal.h
index 1e2df97e..4cc3dd98 100644
--- a/source/quickjs-internal.h
+++ b/source/quickjs-internal.h
@@ -464,6 +464,8 @@ typedef struct { uint16_t line; uint16_t col; } MachLineEntry;
 #define MACH_GET_sJ(i)   ((int32_t)((i) & 0xFFFFFF00) >> 8)
 
 typedef enum MachOpcode {
+  /* === Legacy opcodes (used by existing .mach files) === */
+
   /* Constants & Loading */
   MACH_LOADK,         /* R(A) = K(Bx)           — load from constant pool (ABx) */
   MACH_LOADI,         /* R(A) = (int16_t)sBx    — load small integer (AsBx) */
@@ -474,7 +476,7 @@ typedef enum MachOpcode {
   /* Movement */
   MACH_MOVE,          /* R(A) = R(B) */
 
-  /* Arithmetic (ABC) */
+  /* Generic arithmetic (ABC) — used by legacy .mach */
   MACH_ADD,           /* R(A) = R(B) + R(C) */
   MACH_SUB,           /* R(A) = R(B) - R(C) */
   MACH_MUL,           /* R(A) = R(B) * R(C) */
@@ -485,7 +487,7 @@ typedef enum MachOpcode {
   MACH_INC,           /* R(A) = R(B) + 1 */
   MACH_DEC,           /* R(A) = R(B) - 1 */
 
-  /* Comparison (ABC) */
+  /* Generic comparison (ABC) — used by legacy .mach */
   MACH_EQ,            /* R(A) = (R(B) == R(C)) */
   MACH_NEQ,           /* R(A) = (R(B) != R(C)) */
   MACH_LT,            /* R(A) = (R(B) < R(C)) */
@@ -493,7 +495,7 @@ typedef enum MachOpcode {
   MACH_GT,            /* R(A) = (R(B) > R(C)) */
   MACH_GE,            /* R(A) = (R(B) >= R(C)) */
 
-  /* Logical/Bitwise */
+  /* Logical/Bitwise — used by legacy .mach */
   MACH_LNOT,          /* R(A) = !R(B) */
   MACH_BNOT,          /* R(A) = ~R(B) */
   MACH_BAND,          /* R(A) = R(B) & R(C) */
@@ -503,7 +505,7 @@ typedef enum MachOpcode {
   MACH_SHR,           /* R(A) = R(B) >> R(C) */
   MACH_USHR,          /* R(A) = R(B) >>> R(C) */
 
-  /* Property access */
+  /* Property access — used by legacy .mach */
   MACH_GETFIELD,      /* R(A) = R(B)[K(C)]      — named property */
   MACH_SETFIELD,      /* R(A)[K(B)] = R(C)      — named property */
   MACH_GETINDEX,      /* R(A) = R(B)[R(C)]      — computed property */
@@ -524,12 +526,12 @@ typedef enum MachOpcode {
   MACH_JMPFALSE,      /* if !R(A): pc += sBx    — (iAsBx format) */
   MACH_JMPNULL,       /* if R(A)==null: pc += sBx */
 
-  /* Function calls — Lua-style consecutive registers */
+  /* Function calls — Lua-style consecutive registers (legacy .mach) */
   MACH_CALL,          /* Call R(A) with B args R(A+1)..R(A+B), C=0 discard, C=1 keep result in R(A) */
   MACH_RETURN,        /* Return R(A) */
   MACH_RETNIL,        /* Return null */
 
-  /* Object/array creation */
+  /* Object/array creation — legacy .mach */
   MACH_NEWOBJECT,     /* R(A) = {} */
   MACH_NEWARRAY,      /* R(A) = new array, B = element count in R(A+1)..R(A+B) */
   MACH_CLOSURE,       /* R(A) = closure(functions[Bx]) (ABx) */
@@ -551,10 +553,112 @@ typedef enum MachOpcode {
 
   MACH_NOP,
 
+  /* === New mcode-derived opcodes (1:1 mapping to mcode IR) === */
+
+  /* Typed integer arithmetic (ABC) */
+  MACH_ADD_INT,       /* R(A) = R(B) + R(C) — int, overflow → float */
+  MACH_SUB_INT,       /* R(A) = R(B) - R(C) — int */
+  MACH_MUL_INT,       /* R(A) = R(B) * R(C) — int */
+  MACH_DIV_INT,       /* R(A) = R(B) / R(C) — int */
+  MACH_MOD_INT,       /* R(A) = R(B) % R(C) — int */
+  MACH_NEG_INT,       /* R(A) = -R(B) — int (AB) */
+
+  /* Typed float arithmetic (ABC) */
+  MACH_ADD_FLOAT,     /* R(A) = R(B) + R(C) — float */
+  MACH_SUB_FLOAT,     /* R(A) = R(B) - R(C) — float */
+  MACH_MUL_FLOAT,     /* R(A) = R(B) * R(C) — float */
+  MACH_DIV_FLOAT,     /* R(A) = R(B) / R(C) — float */
+  MACH_MOD_FLOAT,     /* R(A) = R(B) % R(C) — float */
+  MACH_NEG_FLOAT,     /* R(A) = -R(B) — float (AB) */
+
+  /* Text */
+  MACH_CONCAT,        /* R(A) = R(B) ++ R(C) — string concatenation */
+
+  /* Typed integer comparisons (ABC) */
+  MACH_EQ_INT,        /* R(A) = (R(B) == R(C)) — int */
+  MACH_NE_INT,        /* R(A) = (R(B) != R(C)) — int */
+  MACH_LT_INT,        /* R(A) = (R(B) <  R(C)) — int */
+  MACH_LE_INT,        /* R(A) = (R(B) <= R(C)) — int */
+  MACH_GT_INT,        /* R(A) = (R(B) >  R(C)) — int */
+  MACH_GE_INT,        /* R(A) = (R(B) >= R(C)) — int */
+
+  /* Typed float comparisons (ABC) */
+  MACH_EQ_FLOAT,      /* R(A) = (R(B) == R(C)) — float */
+  MACH_NE_FLOAT,      /* R(A) = (R(B) != R(C)) — float */
+  MACH_LT_FLOAT,      /* R(A) = (R(B) <  R(C)) — float */
+  MACH_LE_FLOAT,      /* R(A) = (R(B) <= R(C)) — float */
+  MACH_GT_FLOAT,      /* R(A) = (R(B) >  R(C)) — float */
+  MACH_GE_FLOAT,      /* R(A) = (R(B) >= R(C)) — float */
+
+  /* Typed text comparisons (ABC) */
+  MACH_EQ_TEXT,        /* R(A) = (R(B) == R(C)) — text */
+  MACH_NE_TEXT,        /* R(A) = (R(B) != R(C)) — text */
+  MACH_LT_TEXT,        /* R(A) = (R(B) <  R(C)) — text */
+  MACH_LE_TEXT,        /* R(A) = (R(B) <= R(C)) — text */
+  MACH_GT_TEXT,        /* R(A) = (R(B) >  R(C)) — text */
+  MACH_GE_TEXT,        /* R(A) = (R(B) >= R(C)) — text */
+
+  /* Typed bool comparisons (ABC) */
+  MACH_EQ_BOOL,       /* R(A) = (R(B) == R(C)) — bool */
+  MACH_NE_BOOL,       /* R(A) = (R(B) != R(C)) — bool */
+
+  /* Special comparisons */
+  MACH_IS_IDENTICAL,  /* R(A) = (R(B) === R(C)) — identity check (ABC) */
+
+  /* Type checks (AB) */
+  MACH_IS_INT,        /* R(A) = is_int(R(B)) */
+  MACH_IS_NUM,        /* R(A) = is_num(R(B)) */
+  MACH_IS_TEXT,       /* R(A) = is_text(R(B)) */
+  MACH_IS_BOOL,       /* R(A) = is_bool(R(B)) */
+  MACH_IS_NULL,       /* R(A) = is_null(R(B)) */
+  MACH_TYPEOF,        /* R(A) = typeof(R(B)) */
+
+  /* Logical (mcode-style) */
+  MACH_NOT,           /* R(A) = !R(B) — boolean not (AB) */
+  MACH_AND,           /* R(A) = R(B) && R(C) (ABC) */
+  MACH_OR,            /* R(A) = R(B) || R(C) (ABC) */
+
+  /* Bitwise (mcode names) */
+  MACH_BITNOT,        /* R(A) = ~R(B) (AB) */
+  MACH_BITAND,        /* R(A) = R(B) & R(C) (ABC) */
+  MACH_BITOR,         /* R(A) = R(B) | R(C) (ABC) */
+  MACH_BITXOR,        /* R(A) = R(B) ^ R(C) (ABC) */
+
+  /* Property access (mcode names) */
+  MACH_LOAD_FIELD,    /* R(A) = R(B).K(C) — named property (ABC) */
+  MACH_STORE_FIELD,   /* R(A).K(B) = R(C) — named property (ABC) */
+  MACH_LOAD_INDEX,    /* R(A) = R(B)[R(C)] — integer index (ABC) */
+  MACH_STORE_INDEX,   /* R(A)[R(B)] = R(C) — integer index (ABC) */
+  MACH_LOAD_DYNAMIC,  /* R(A) = R(B)[R(C)] — dynamic key (ABC) */
+  MACH_STORE_DYNAMIC, /* R(A)[R(B)] = R(C) — dynamic key (ABC) */
+
+  /* Object/Array creation (mcode names) */
+  MACH_NEWRECORD,     /* R(A) = {} — new empty record (A only) */
+
+  /* Decomposed function calls (mcode-style) */
+  MACH_FRAME,         /* R(A) = frame(R(B), C) — alloc call frame (ABC) */
+  MACH_SETARG,        /* frame R(A)[B] = R(C) — set arg in frame (ABC) */
+  MACH_INVOKE,        /* R(B) = invoke(R(A)) — call frame, result in R(B) (AB) */
+  MACH_GOFRAME,       /* R(A) = goframe(R(B), C) — async frame (ABC) */
+  MACH_GOINVOKE,      /* goinvoke(R(A)) — async invoke, no result (A only) */
+
+  /* Control flow */
+  MACH_JMPNOTNULL,    /* if R(A)!=null: pc += sBx (iAsBx) */
+
+  /* Error handling */
+  MACH_DISRUPT,       /* trigger disruption (A only) */
+
+  /* Variable storage */
+  MACH_SET_VAR,       /* env/global[K(Bx)] = R(A) — store to var (ABx) */
+
+  /* Misc */
+  MACH_IN,            /* R(A) = (R(B) in R(C)) — has property (ABC) */
+
   MACH_OP_COUNT
 } MachOpcode;
 
 static const char *mach_opcode_names[MACH_OP_COUNT] = {
+  /* Legacy */
   [MACH_LOADK] = "loadk",
   [MACH_LOADI] = "loadi",
   [MACH_LOADNULL] = "loadnull",
@@ -614,6 +718,70 @@ static const char *mach_opcode_names[MACH_OP_COUNT] = {
   [MACH_EQ_TOL] = "eq_tol",
   [MACH_NEQ_TOL] = "neq_tol",
   [MACH_NOP] = "nop",
+  /* Mcode-derived */
+  [MACH_ADD_INT] = "add_int",
+  [MACH_SUB_INT] = "sub_int",
+  [MACH_MUL_INT] = "mul_int",
+  [MACH_DIV_INT] = "div_int",
+  [MACH_MOD_INT] = "mod_int",
+  [MACH_NEG_INT] = "neg_int",
+  [MACH_ADD_FLOAT] = "add_float",
+  [MACH_SUB_FLOAT] = "sub_float",
+  [MACH_MUL_FLOAT] = "mul_float",
+  [MACH_DIV_FLOAT] = "div_float",
+  [MACH_MOD_FLOAT] = "mod_float",
+  [MACH_NEG_FLOAT] = "neg_float",
+  [MACH_CONCAT] = "concat",
+  [MACH_EQ_INT] = "eq_int",
+  [MACH_NE_INT] = "ne_int",
+  [MACH_LT_INT] = "lt_int",
+  [MACH_LE_INT] = "le_int",
+  [MACH_GT_INT] = "gt_int",
+  [MACH_GE_INT] = "ge_int",
+  [MACH_EQ_FLOAT] = "eq_float",
+  [MACH_NE_FLOAT] = "ne_float",
+  [MACH_LT_FLOAT] = "lt_float",
+  [MACH_LE_FLOAT] = "le_float",
+  [MACH_GT_FLOAT] = "gt_float",
+  [MACH_GE_FLOAT] = "ge_float",
+  [MACH_EQ_TEXT] = "eq_text",
+  [MACH_NE_TEXT] = "ne_text",
+  [MACH_LT_TEXT] = "lt_text",
+  [MACH_LE_TEXT] = "le_text",
+  [MACH_GT_TEXT] = "gt_text",
+  [MACH_GE_TEXT] = "ge_text",
+  [MACH_EQ_BOOL] = "eq_bool",
+  [MACH_NE_BOOL] = "ne_bool",
+  [MACH_IS_IDENTICAL] = "is_identical",
+  [MACH_IS_INT] = "is_int",
+  [MACH_IS_NUM] = "is_num",
+  [MACH_IS_TEXT] = "is_text",
+  [MACH_IS_BOOL] = "is_bool",
+  [MACH_IS_NULL] = "is_null",
+  [MACH_TYPEOF] = "typeof",
+  [MACH_NOT] = "not",
+  [MACH_AND] = "and",
+  [MACH_OR] = "or",
+  [MACH_BITNOT] = "bitnot",
+  [MACH_BITAND] = "bitand",
+  [MACH_BITOR] = "bitor",
+  [MACH_BITXOR] = "bitxor",
+  [MACH_LOAD_FIELD] = "load_field",
+  [MACH_STORE_FIELD] = "store_field",
+  [MACH_LOAD_INDEX] = "load_index",
+  [MACH_STORE_INDEX] = "store_index",
+  [MACH_LOAD_DYNAMIC] = "load_dynamic",
+  [MACH_STORE_DYNAMIC] = "store_dynamic",
+  [MACH_NEWRECORD] = "newrecord",
+  [MACH_FRAME] = "frame",
+  [MACH_SETARG] = "setarg",
+  [MACH_INVOKE] = "invoke",
+  [MACH_GOFRAME] = "goframe",
+  [MACH_GOINVOKE] = "goinvoke",
+  [MACH_JMPNOTNULL] = "jmpnotnull",
+  [MACH_DISRUPT] = "disrupt",
+  [MACH_SET_VAR] = "set_var",
+  [MACH_IN] = "in",
 };
 
 /* Compiled register-based code (off-heap, never GC'd).
diff --git a/source/quickjs.h b/source/quickjs.h
index 9ef8f9a1..8c773150 100644
--- a/source/quickjs.h
+++ b/source/quickjs.h
@@ -1106,6 +1106,9 @@ JSValue JS_RunMach (JSContext *ctx, const char *ast_json, JSValue env);
 /* Deserialize and execute pre-compiled MACH binary bytecode. */
 JSValue JS_RunMachBin(JSContext *ctx, const uint8_t *data, size_t size, JSValue env);
 
+/* Compile mcode JSON IR to MachCode binary. */
+MachCode *mach_compile_mcode(struct cJSON *mcode_json);
+
 /* Execute MCODE from cJSON tree. Takes ownership of root. */
 JSValue JS_CallMcodeTree (JSContext *ctx, struct cJSON *root);
 
diff --git a/source/runtime.c b/source/runtime.c
index 01970372..0e026a06 100644
--- a/source/runtime.c
+++ b/source/runtime.c
@@ -10249,6 +10249,55 @@ static JSValue js_mcode_run (JSContext *ctx, JSValue this_val, int argc, JSValue
   return result;
 }
 
+/* mach_eval_mcode(name, mcode_json, env?) - compile mcode IR and run via register VM */
+static JSValue js_mach_eval_mcode (JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+  if (argc < 2 || !JS_IsText (argv[0]) || !JS_IsText (argv[1]))
+    return JS_ThrowTypeError (ctx, "mach_eval_mcode requires (name, mcode_json) text arguments");
+
+  const char *name = JS_ToCString (ctx, argv[0]);
+  if (!name) return JS_EXCEPTION;
+
+  const char *json_str = JS_ToCString (ctx, argv[1]);
+  if (!json_str) {
+    JS_FreeCString (ctx, name);
+    return JS_EXCEPTION;
+  }
+
+  cJSON *mcode = cJSON_Parse (json_str);
+  JS_FreeCString (ctx, json_str);
+
+  if (!mcode) {
+    JS_FreeCString (ctx, name);
+    return JS_ThrowSyntaxError (ctx, "mach_eval_mcode: failed to parse mcode JSON");
+  }
+
+  /* Set filename on the mcode root if not present */
+  if (!cJSON_GetObjectItemCaseSensitive (mcode, "filename"))
+    cJSON_AddStringToObject (mcode, "filename", name);
+
+  /* Compile mcode IR → MachCode binary */
+  MachCode *mc = mach_compile_mcode (mcode);
+  cJSON_Delete (mcode);
+
+  if (!mc) {
+    JS_FreeCString (ctx, name);
+    return JS_ThrowInternalError (ctx, "mach_eval_mcode: compilation failed");
+  }
+
+  JSValue env = (argc >= 3 && JS_IsObject (argv[2])) ? argv[2] : JS_NULL;
+
+  JSGCRef env_ref;
+  JS_PushGCRef (ctx, &env_ref);
+  env_ref.val = env;
+
+  JSCodeRegister *code = JS_LoadMachCode (ctx, mc, env_ref.val);
+  JS_FreeMachCode (mc);
+  JSValue result = JS_CallRegisterVM (ctx, code, ctx->global_obj, 0, NULL, env_ref.val, JS_NULL);
+  JS_PopGCRef (ctx, &env_ref);
+  JS_FreeCString (ctx, name);
+  return result;
+}
+
 /* ============================================================================
  * stone() function - deep freeze with blob support
  * ============================================================================
@@ -11353,6 +11402,7 @@ static void JS_AddIntrinsicBaseObjects (JSContext *ctx) {
     js_set_global_cfunc(ctx, "mcode_run", js_mcode_run, 3);
     js_set_global_cfunc(ctx, "mach_compile_ast", js_mach_compile_ast, 2);
     js_set_global_cfunc(ctx, "mach_load", js_mach_load, 2);
+    js_set_global_cfunc(ctx, "mach_eval_mcode", js_mach_eval_mcode, 3);
     js_set_global_cfunc(ctx, "stone", js_cell_stone, 1);
     js_set_global_cfunc(ctx, "length", js_cell_length, 1);
     js_set_global_cfunc(ctx, "call", js_cell_call, 3);
diff --git a/test_parse_boot.cm b/test_parse_boot.cm
new file mode 100644
index 00000000..05dd3cdf
--- /dev/null
+++ b/test_parse_boot.cm
@@ -0,0 +1,42 @@
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+
+var src = text(fd.slurp("internal/bootstrap.cm"))
+var tok_result = tokenize(src, "bootstrap.cm")
+var ast = parse(tok_result.tokens, src, "bootstrap.cm", tokenize)
+var i = 0
+var folded = null
+var ast_json = null
+var f = null
+var bytecode = null
+var has_errors = ast.errors != null && length(ast.errors) > 0
+if (has_errors) {
+  print("PARSE ERRORS:")
+  while (i < length(ast.errors)) {
+    print(text(ast.errors[i].line) + ":" + text(ast.errors[i].column) + " " + ast.errors[i].message)
+    i = i + 1
+  }
+} else {
+  print("Parse OK")
+  print("  statements: " + text(length(ast.statements)))
+  if (ast.functions != null) {
+    print("  functions: " + text(length(ast.functions)))
+  } else {
+    print("  functions: null")
+  }
+  folded = fold(ast)
+  ast_json = json.encode(folded)
+  f = fd.open("/tmp/bootstrap_ast.json", "w")
+  fd.write(f, ast_json)
+  fd.close(f)
+  print("Wrote AST to /tmp/bootstrap_ast.json")
+  bytecode = mach_compile_ast("bootstrap", ast_json)
+  print("Bytecode size: " + text(length(bytecode)))
+  f = fd.open("/tmp/bootstrap_test.mach", "w")
+  fd.write(f, bytecode)
+  fd.close(f)
+  print("Wrote bytecode to /tmp/bootstrap_test.mach")
+}