diff --git a/examples/embed/embed.c b/examples/embed/embed.c
index 42c3420..6d17532 100644
--- a/examples/embed/embed.c
+++ b/examples/embed/embed.c
@@ -2,16 +2,18 @@
  * Ant JavaScript Engine - Embedding Example
  * This demonstrates how to embed the Ant JS engine in a C application.
  *
- * meson setup build -Dbuild_examples=true
- * meson compile -C build
+ * to build:
+ * ./libant/build.sh  
+ * ./libant/example.sh  
  *
- * ./build/embed_example
+ * to run:
+ * ./libant/dist/embed
  */
 
+#include <ant.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ant.h>
 
 #define SEPARATOR "════════════════════════════════════════════════════════════"
 #define SUBSEP    "────────────────────────────────────────────────────────────"
@@ -22,23 +24,36 @@ static void print_header(int num, const char *title) {
   printf("%s\n\n", SUBSEP);
 }
 
-static void example_basic_eval(void) {
-  print_header(1, "Basic Evaluation");
-
+static struct js *create_js_runtime(void *stack_base) {
   struct js *js = js_create_dynamic(0, 0);
   if (!js) {
     fprintf(stderr, "Failed to create JS runtime\n");
-    return;
+    return NULL;
   }
 
+  js_setstackbase(js, stack_base);
+
+  static char *default_argv[] = { "embed_example", NULL };
+  ant_runtime_init(js, 1, default_argv, NULL);
+
+  return js;
+}
+
+static void example_basic_eval(void) {
+  print_header(1, "Basic Evaluation");
+
+  volatile char stack_base;
+  struct js *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));
 
-  if (js_type(result) == JS_NUM) {
+  if (vtype(result) == T_NUM) {
     printf("  Result: %g\n", js_getnum(result));
-  } else if (js_type(result) == JS_ERR) {
+  } else if (vtype(result) == T_ERR) {
     printf("  Error: %s\n", js_str(js, result));
   }
 
@@ -57,7 +72,7 @@ static jsval_t my_add(struct js *js, jsval_t *args, int nargs) {
 }
 
 static jsval_t my_greet(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || js_type(args[0]) != JS_STR) {
+  if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "greet() expects a string");
   }
 
@@ -85,7 +100,8 @@ static jsval_t my_create_point(struct js *js, jsval_t *args, int nargs) {
 static void example_c_functions(void) {
   print_header(2, "C Functions");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   js_mkscope(js);
@@ -113,7 +129,8 @@ static void example_c_functions(void) {
 static void example_objects_arrays(void) {
   print_header(3, "Objects and Arrays");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   js_mkscope(js);
@@ -144,20 +161,21 @@ static void example_objects_arrays(void) {
 static void example_error_handling(void) {
   print_header(4, "Error Handling");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *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));
-  if (js_type(r1) == JS_ERR) {
+  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));
-  if (js_type(r2) == JS_ERR) {
+  if (vtype(r2) == T_ERR) {
     printf("  Reference error: %s\n", js_str(js, r2));
   }
 
@@ -166,7 +184,7 @@ static void example_error_handling(void) {
 
   const char *type_err = "add('not', 'numbers')";
   jsval_t r3 = js_eval(js, type_err, strlen(type_err));
-  if (js_type(r3) == JS_ERR) {
+  if (vtype(r3) == T_ERR) {
     printf("  Type error:      %s\n", js_str(js, r3));
   }
 
@@ -176,7 +194,8 @@ static void example_error_handling(void) {
 static void example_call_js_from_c(void) {
   print_header(5, "Calling JS from C");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   jsval_t scope = js_mkscope(js);
@@ -185,7 +204,6 @@ static void example_call_js_from_c(void) {
     "function multiply(a, b) {"
     "    return a * b;"
     "}"
-
     "function formatName(first, last) {"
     "    return last + ', ' + first;"
     "}";
@@ -213,7 +231,8 @@ static void example_call_js_from_c(void) {
 static void example_iterate_properties(void) {
   print_header(6, "Iterating Properties");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   js_mkscope(js);
@@ -221,7 +240,7 @@ static void example_iterate_properties(void) {
   const char *code = "({ name: 'Alice', age: 30, city: 'NYC' })";
   jsval_t obj = js_eval(js, code, strlen(code));
 
-  js_prop_iter_t iter = js_prop_iter_begin(js, obj);
+  ant_iter_t iter = js_prop_iter_begin(js, obj);
   const char *key;
   size_t key_len;
   jsval_t value;
@@ -256,7 +275,8 @@ static jsval_t method_get_full_name(struct js *js, jsval_t *args, int nargs) {
 static void example_this_context(void) {
   print_header(7, "'this' Context");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   js_mkscope(js);
@@ -278,7 +298,8 @@ static void example_this_context(void) {
 static void example_stateful_session(void) {
   print_header(8, "Stateful Session");
 
-  struct js *js = js_create_dynamic(0, 0);
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
   if (!js) return;
 
   js_mkscope(js);
@@ -294,7 +315,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]));
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       printf("  Error in script %d: %s\n", i, js_str(js, result));
       break;
     }
@@ -305,6 +326,135 @@ static void example_stateful_session(void) {
   js_destroy(js);
 }
 
+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);
+  if (!js) return;
+
+  init_symbol_module();
+  init_builtin_module();
+  init_timer_module();
+
+  jsval_t scope = js_mkscope(js);
+
+  const char *code =
+    "let results = [];"
+    ""
+    "setTimeout(() => {"
+    "  results.push('timer 1 (50ms)');"
+    "}, 50);"
+    ""
+    "setTimeout(() => {"
+    "  results.push('timer 2 (10ms)');"
+    "}, 10);"
+    ""
+    "Promise.resolve('promise 1').then(v => {"
+    "  results.push(v);"
+    "});"
+    ""
+    "queueMicrotask(() => {"
+    "  results.push('microtask');"
+    "});"
+    ""
+    "results.push('sync');";
+
+  jsval_t result = js_eval(js, code, strlen(code));
+  if (vtype(result) == T_ERR) {
+    printf("  Error: %s\n", js_str(js, result));
+    js_destroy(js);
+    return;
+  }
+
+  js_run_event_loop(js);
+
+  jsval_t results = js_get(js, scope, "results");
+
+  printf("  Execution order:\n");
+  jsoff_t len = js_arr_len(js, results);
+  for (jsoff_t i = 0; i < len; i++) {
+    jsval_t item = js_arr_get(js, results, i);
+    printf("    %llu. %s\n", (unsigned long long)i + 1, js_str(js, item));
+  }
+
+  js_destroy(js);
+}
+
+static void example_console_logging(void) {
+  print_header(10, "Console Logging");
+
+  volatile char stack_base;
+  struct js *js = create_js_runtime((void *)&stack_base);
+  if (!js) return;
+
+  init_console_module();
+  js_mkscope(js);
+
+  const char *code =
+    "console.log('Hello from JavaScript!');"
+    "console.log('Number:', 42, 'Boolean:', true);"
+    "console.log('Object:', { name: 'test', value: 123 });"
+    "console.log('Array:', [1, 2, 3]);"
+    "console.warn('This is a warning');"
+    "console.error('This is an error');"
+    "'done'";
+
+  jsval_t result = js_eval(js, code, strlen(code));
+  if (vtype(result) == T_ERR) {
+    printf("  Error: %s\n", js_str(js, result));
+  }
+
+  js_destroy(js);
+}
+
+static void example_global_this(void) {
+  print_header(11, "GlobalThis");
+
+  volatile char stack_base;
+  struct js *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));
+  js_set(js, global, "myString", js_mkstr(js, "hello from C", 12));
+  js_set(js, global, "myBool", js_mktrue());
+
+  jsval_t myObj = js_mkobj(js);
+  js_set(js, myObj, "a", js_mknum(1));
+  js_set(js, myObj, "b", js_mknum(2));
+  js_set(js, global, "myObject", myObj);
+
+  const char *code =
+    "console.log('globalThis.myNumber:', globalThis.myNumber);"
+    "console.log('globalThis.myString:', globalThis.myString);"
+    "console.log('globalThis.myBool:', globalThis.myBool);"
+    "console.log('globalThis.myObject:', globalThis.myObject);"
+    ""
+    "globalThis.addedFromJS = 'I was added from JavaScript';"
+    "console.log('globalThis.addedFromJS:', globalThis.addedFromJS);"
+    ""
+    "console.log('\\nAll custom globals:');"
+    "console.log('  myNumber:', myNumber);"
+    "console.log('  myString:', myString);"
+    "console.log('  myBool:', myBool);"
+    "console.log('  myObject:', myObject);"
+    "console.log('  addedFromJS:', addedFromJS);"
+    "console.log(this)";
+
+  jsval_t result = js_eval(js, code, strlen(code));
+  if (vtype(result) == T_ERR) {
+    printf("  Error: %s\n", js_str(js, result));
+  }
+
+  jsval_t added = js_get(js, global, "addedFromJS");
+  printf("\n  Read from C: addedFromJS = %s\n", js_str(js, added));
+
+  js_destroy(js);
+}
 
 int main(void) {
   printf("\n%s\n", SEPARATOR);
@@ -319,6 +469,9 @@ int main(void) {
   example_iterate_properties();
   example_this_context();
   example_stateful_session();
+  example_async_event_loop();
+  example_console_logging();
+  example_global_this();
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/include/ant.h b/include/ant.h
index 9991281..43fe4e3 100644
--- a/include/ant.h
+++ b/include/ant.h
@@ -33,11 +33,6 @@
 #define GC_FWD_ARGS jsval_t (*fwd_val)(void *ctx, jsval_t old), void *ctx
 #define GC_UPDATE_ARGS ant_t *js, jsoff_t (*fwd_off)(void *ctx, jsoff_t old), GC_FWD_ARGS
 
-enum {
-  JS_UNDEF, JS_NULL, JS_TRUE, JS_FALSE, JS_STR, JS_NUM,
-  JS_ERR, JS_PRIV, JS_PROMISE, JS_OBJ, JS_FUNC, JS_SYMBOL
-};
-
 #define JS_DESC_W (1 << 0)
 #define JS_DESC_E (1 << 1)
 #define JS_DESC_C (1 << 2)
@@ -82,7 +77,20 @@ void js_setthis(ant_t *, jsval_t);
 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 *);
-bool js_iter(ant_t *js, jsval_t iterable, bool (*callback)(ant_t *js, jsval_t value, void *udata), void *udata);
+
+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);
+
+bool js_iter(
+  ant_t *js, 
+  jsval_t iterable,
+  bool (*callback)(
+    ant_t *js,
+    jsval_t value,
+    void *udata
+  ), 
+  void *udata
+);
 
 uint64_t js_sym_id(jsval_t sym);
 const char *js_sym_desc(ant_t *js, jsval_t sym);
@@ -93,7 +101,6 @@ const char *js_sym_key(jsval_t sym);
 jsval_t js_mkobj(ant_t *);
 jsval_t js_newobj(ant_t *);
 jsval_t js_mkarr(ant_t *);
-void js_arr_push(ant_t *, jsval_t arr, jsval_t val);
 jsval_t js_mkstr(ant_t *, const void *, size_t);
 jsval_t js_mkbigint(ant_t *, const char *digits, size_t len, bool negative);
 jsval_t js_mksym(ant_t *, const char *desc);
@@ -110,6 +117,7 @@ void js_set(ant_t *, jsval_t, const char *, jsval_t);
 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);
 
 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);
@@ -119,10 +127,6 @@ jsval_t js_get_proto(ant_t *, jsval_t obj);
 jsval_t js_get_ctor_proto(ant_t *, const char *name, size_t len);
 jsval_t js_tostring_val(ant_t *js, jsval_t value);
 
-int js_type(jsval_t val);
-int js_type_ex(ant_t *js, jsval_t val);
-
-int js_getbool(jsval_t val);
 uint8_t vtype(jsval_t val);
 size_t vdata(jsval_t val);
 
diff --git a/include/internal.h b/include/internal.h
index 9fc4deb..b56b2bf 100644
--- a/include/internal.h
+++ b/include/internal.h
@@ -84,8 +84,10 @@ enum {
 #define NANBOX_DATA_MASK  0x0000FFFFFFFFFFFFULL
 
 #define TYPE_FLAG(t) (1u << (t))
+
 #define T_NEEDS_PROTO_FALLBACK (TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_ARR) | 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))
+#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))
 
 jsoff_t esize(jsoff_t w);
 
@@ -102,5 +104,21 @@ jsval_t mkval(uint8_t type, uint64_t data);
 jsval_t resolveprop(struct js *js, jsval_t v);
 
 #define is_non_numeric(v) ((1u << vtype(v)) & T_NON_NUMERIC_MASK)
+#define is_object_type(v) ((1u << vtype(v)) & T_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; 
+}
+
+#define js_true  (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT) | 1)
+#define js_false (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT))
 
 #endif
diff --git a/libant/scripts/header.sh b/libant/scripts/header.sh
index a593df0..5774397 100755
--- a/libant/scripts/header.sh
+++ b/libant/scripts/header.sh
@@ -17,8 +17,14 @@ VENDOR_DIR="$SCRIPT_DIR/vendor"
 HEADERS=(
   "config.h:$CONFIG_H"
   "common.h:$INCLUDE_DIR/common.h"
-  "compat.h:$INCLUDE_DIR/compat.h"
+  "types.h:$INCLUDE_DIR/types.h"
   "ant.h:$INCLUDE_DIR/ant.h"
+  "internal.h:$INCLUDE_DIR/internal.h"
+  "roots.h:$INCLUDE_DIR/roots.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"
   "minicoro.h:$VENDOR_DIR/minicoro/minicoro.h"
   "runtime.h:$INCLUDE_DIR/runtime.h"
@@ -90,7 +96,7 @@ for entry in "${HEADERS[@]}"; do
       continue
     fi
     
-    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"(config\.h|compat\.h|ant\.h|utils\.h|arena\.h|runtime\.h|internal\.h)\" ]]; then
+    if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"(config\.h|common\.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
diff --git a/src/ant.c b/src/ant.c
index 5d448d3..2b53514 100644
--- a/src/ant.c
+++ b/src/ant.c
@@ -594,29 +594,6 @@ inline size_t js_getbrk(struct js *js) {
   return (size_t) js->brk;
 }
 
-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; 
-}
-
-#define T_OBJECT_MASK (TYPE_FLAG(T_OBJ) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_PROMISE))
-#define is_object_type(v) ((1u << vtype(v)) & T_OBJECT_MASK)
-
-static inline bool is_true(jsval_t v) {
-  return vtype(v) == T_BOOL && vdata(v) != 0;
-}
-
-static inline bool is_false(jsval_t v) {
-  return vtype(v) == T_BOOL && vdata(v) == 0;
-}
-
 static inline uint8_t unhex(uint8_t c) {
   return (c & 0xF) + (c >> 6) * 9;
 }
@@ -1881,7 +1858,7 @@ static size_t strobj(struct js *js, jsval_t obj, char *buf, size_t len) {
   bool is_dataview = (tlen == 8 && memcmp(tag_str, "DataView", 8) == 0);
   if (is_dataview) {
     jsval_t dv_data_val = js_get_slot(js, obj, SLOT_DATA);
-    if (js_type(dv_data_val) == JS_NUM) {
+    if (vtype(dv_data_val) == T_NUM) {
       DataViewData *dv = (DataViewData *)(uintptr_t)tod(dv_data_val);
       if (dv && dv->buffer) {
         n += cpy(buf + n, REMAIN(n, len), "DataView {\n", 11);
@@ -2276,7 +2253,7 @@ static size_t strfunc(struct js *js, jsval_t value, char *buf, size_t len) {
   jsval_t builtin_slot = get_slot(js, func_obj, SLOT_BUILTIN);
   jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
   
-  bool is_async = is_true(async_slot);
+  bool is_async = (async_slot == js_true);
   bool has_code = (vtype(code_slot) == T_CFUNC);
   
   const struct func_format *fmt = &formats[is_async];
@@ -2957,7 +2934,7 @@ jsval_t js_newobj(struct js *js) {
   return obj;
 }
 
-static jsoff_t arr_length(struct js *js, jsval_t arr) {
+jsoff_t js_arr_len(struct js *js, jsval_t arr) {
   if (vtype(arr) != T_ARR) return 0;
   jsoff_t max_idx = 0;
   bool found_length_prop = false;
@@ -2983,7 +2960,7 @@ static jsoff_t arr_length(struct js *js, jsval_t arr) {
   return max_idx;
 }
 
-static jsval_t arr_get(struct js *js, jsval_t arr, jsoff_t idx) {
+jsval_t js_arr_get(struct js *js, jsval_t arr, jsoff_t idx) {
   if (vtype(arr) != T_ARR) return js_mkundef();
   char idxstr[16];
   size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)idx);
@@ -5366,7 +5343,7 @@ jsval_t resolveprop(struct js *js, jsval_t v) {
     
     if (is_arr_off(js, obj_off) && streq(key_str, len, "length", 6)) {
       jsval_t arr = mkval(T_ARR, obj_off);
-      return tov(D(arr_length(js, arr)));
+      return tov(D(js_arr_len(js, arr)));
     }
     
     jsval_t obj = mkval(T_OBJ, obj_off);
@@ -5633,7 +5610,7 @@ static jsval_t do_bracket_op(struct js *js, jsval_t l, jsval_t r) {
         return mkval(T_PROP, len_off);
       }
       jsval_t key = js_mkstr(js, "length", 6);
-      jsval_t len_val = tov(D(arr_length(js, obj)));
+      jsval_t len_val = tov(D(js_arr_len(js, obj)));
       jsval_t prop = setprop(js, obj, key, len_val);
       return prop;
     }
@@ -5912,9 +5889,9 @@ static int parse_call_args(struct js *js, UT_array *args, jsval_t *err_out) {
     jsval_t arg = resolveprop(js, js_expr(js));
     if (is_err(arg)) { *err_out = arg; return -1; }
     if (is_spread && vtype(arg) == T_ARR) {
-      jsoff_t len = arr_length(js, arg);
+      jsoff_t len = js_arr_len(js, arg);
       for (jsoff_t i = 0; i < len; i++) {
-        jsval_t elem = arr_get(js, arg, i);
+        jsval_t elem = js_arr_get(js, arg, i);
         utarray_push_back(args, &elem);
       }
     } else utarray_push_back(args, &arg);
@@ -6045,13 +6022,13 @@ static jsval_t bind_destruct_pattern(struct js *js, const char *p, jsoff_t len,
     if (is_rest && is_arr) {
       jsval_t rest = js_mkarr(js);
       if (is_err(rest)) return rest;
-      jsoff_t alen = arr_length(js, val);
-      for (jsoff_t i = idx; i < alen; i++) js_arr_push(js, rest, arr_get(js, val, i));
+      jsoff_t alen = js_arr_len(js, val);
+      for (jsoff_t i = idx; i < alen; i++) js_arr_push(js, rest, js_arr_get(js, val, i));
       prop_val = rest;
     } else if (is_rest) {
       prop_val = mkobj(js, 0);
     } else if (is_arr) {
-      prop_val = arr_get(js, val, idx);
+      prop_val = js_arr_get(js, val, idx);
     } else {
       jsoff_t off = lkp(js, val, &p[src_pos], src_len);
       prop_val = off > 0 ? resolveprop(js, mkval(T_PROP, off)) : js_mkundef();
@@ -6300,9 +6277,9 @@ static jsval_t call_js_internal(
     jsval_t arg = resolveprop(js, js_expr(js));
     caller_pos = js->pos;
     if (is_spread && vtype(arg) == T_ARR) {
-      jsoff_t len = arr_length(js, arg);
+      jsoff_t len = js_arr_len(js, arg);
       for (jsoff_t i = 0; i < len; i++) {
-        jsval_t elem = arr_get(js, arg, i);
+        jsval_t elem = js_arr_get(js, arg, i);
         utarray_push_back(args_arr, &elem);
       }
     } else {
@@ -6893,7 +6870,7 @@ static jsval_t do_call_op(struct js *js, jsval_t func, jsval_t args) {
         push_this(captured_this);
       }
       
-      if (is_true(get_slot(js, func_obj, SLOT_DEFAULT_CTOR))) {
+      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) {
@@ -7689,7 +7666,7 @@ static jsval_t js_arr_destruct_assign(struct js *js) {
       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 : arr_length(js, 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);
@@ -7701,7 +7678,7 @@ static jsval_t js_arr_destruct_assign(struct js *js) {
             jsoff_t slen, soff = vstr(js, arr, &slen);
             elem = js_mkstr(js, (char *)&js->mem[soff + i], 1);
           } else {
-            elem = arr_get(js, arr, i);
+            elem = js_arr_get(js, arr, i);
           }
           js_arr_push(js, rest_arr, elem);
         }
@@ -7715,7 +7692,7 @@ static jsval_t js_arr_destruct_assign(struct js *js) {
             prop_val = js_mkundef();
           }
         } else {
-          prop_val = arr_get(js, arr, index);
+          prop_val = js_arr_get(js, arr, index);
         }
         
         if (vtype(prop_val) == T_UNDEF && default_len > 0) {
@@ -7826,7 +7803,7 @@ static jsval_t js_arr_literal(struct js *js) {
       goto next_elem;
     }
 
-    jsoff_t len = arr_length(js, resolved);
+    jsoff_t len = js_arr_len(js, resolved);
     for (jsoff_t i = 0; i < len; i++) {
       char src_idx[16], dst_idx[16];
       snprintf(src_idx, sizeof(src_idx), "%u", (unsigned)i);
@@ -9716,9 +9693,9 @@ obj_destruct_rest:;
           const char *key; jsoff_t klen;
           get_prop_key(js, scan, &key, &klen);
           bool is_picked = false;
-          jsoff_t picked_len = arr_length(js, picked_keys);
+          jsoff_t picked_len = js_arr_len(js, picked_keys);
           for (jsoff_t i = 0; i < picked_len; i++) {
-            jsval_t pk = arr_get(js, picked_keys, 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; }
@@ -9898,7 +9875,7 @@ obj_destruct_next:
           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 : arr_length(js, 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);
@@ -9910,7 +9887,7 @@ obj_destruct_next:
                 jsoff_t slen, soff = vstr(js, arr, &slen);
                 elem = js_mkstr(js, (char *)&js->mem[soff + i], 1);
               } else {
-                elem = arr_get(js, arr, i);
+                elem = js_arr_get(js, arr, i);
               }
               js_arr_push(js, rest_arr, elem);
             }
@@ -9924,7 +9901,7 @@ obj_destruct_next:
                 prop_val = js_mkundef();
               }
             } else {
-              prop_val = arr_get(js, arr, index);
+              prop_val = js_arr_get(js, arr, index);
             }
             
             if (vtype(prop_val) == T_UNDEF && default_len > 0) {
@@ -12797,7 +12774,8 @@ static jsval_t builtin_function_toString(struct js *js, jsval_t *args, int nargs
     
     if (code && code_len > 0) {
       jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
-      bool is_async = is_true(async_slot);
+      
+      bool is_async = (async_slot == js_true);
       bool is_arrow = vtype(get_slot(js, func_obj, SLOT_ARROW)) != T_UNDEF;
       
       if (is_arrow) {
@@ -20336,7 +20314,7 @@ static jsval_t esm_load_module(struct js *js, esm_module_t *mod) {
   }
   
   jsval_t default_val = js_get_slot(js, ns, SLOT_DEFAULT);
-  mod->default_export = js_type(default_val) != JS_UNDEF ? default_val : ns;
+  mod->default_export = vtype(default_val) != T_UNDEF ? default_val : ns;
   
   mod->is_loaded = true;
   mod->is_loading = false;
@@ -20621,7 +20599,7 @@ static jsval_t js_import_stmt(struct js *js) {
     jsval_t default_val;
     if (vtype(ns) == T_OBJ) {
       jsval_t slot_val = js_get_slot(js, ns, SLOT_DEFAULT);
-      default_val = js_type(slot_val) != JS_UNDEF ? slot_val : ns;
+      default_val = vtype(slot_val) != T_UNDEF ? slot_val : ns;
     } else default_val = ns;
     setprop(js, js->scope, js_mkstr(js, default_name, default_len), default_val);
     
@@ -20945,17 +20923,17 @@ static jsval_t builtin_Map(struct js *js, jsval_t *args, int nargs) {
   if (nargs == 0 || vtype(args[0]) != T_ARR) return map_obj;
   
   jsval_t iterable = args[0];
-  jsoff_t length = arr_length(js, iterable);
+  jsoff_t length = js_arr_len(js, iterable);
   
   for (jsoff_t i = 0; i < length; i++) {
-    jsval_t entry = arr_get(js, iterable, i);
+    jsval_t entry = js_arr_get(js, iterable, i);
     if (vtype(entry) != T_ARR) continue;
     
-    jsoff_t entry_len = arr_length(js, entry);
+    jsoff_t entry_len = js_arr_len(js, entry);
     if (entry_len < 2) continue;
     
-    jsval_t key = arr_get(js, entry, 0);
-    jsval_t value = arr_get(js, entry, 1);
+    jsval_t key = js_arr_get(js, entry, 0);
+    jsval_t value = js_arr_get(js, entry, 1);
     const char *key_str = jsval_to_key(js, key);
     
     map_entry_t *map_entry;
@@ -20997,10 +20975,10 @@ static jsval_t builtin_Set(struct js *js, jsval_t *args, int nargs) {
   if (nargs == 0 || vtype(args[0]) != T_ARR) return set_obj;
   
   jsval_t iterable = args[0];
-  jsoff_t length = arr_length(js, iterable);
+  jsoff_t length = js_arr_len(js, iterable);
   
   for (jsoff_t i = 0; i < length; i++) {
-    jsval_t value = arr_get(js, iterable, i);
+    jsval_t value = js_arr_get(js, iterable, i);
     const char *key_str = jsval_to_key(js, value);
     
     set_entry_t *entry;
@@ -21353,17 +21331,17 @@ static jsval_t builtin_WeakMap(struct js *js, jsval_t *args, int nargs) {
   if (nargs == 0 || vtype(args[0]) != T_ARR) return wm_obj;
   
   jsval_t iterable = args[0];
-  jsoff_t length = arr_length(js, iterable);
+  jsoff_t length = js_arr_len(js, iterable);
   
   for (jsoff_t i = 0; i < length; i++) {
-    jsval_t entry = arr_get(js, iterable, i);
+    jsval_t entry = js_arr_get(js, iterable, i);
     if (vtype(entry) != T_ARR) continue;
     
-    jsoff_t entry_len = arr_length(js, entry);
+    jsoff_t entry_len = js_arr_len(js, entry);
     if (entry_len < 2) continue;
     
-    jsval_t key = arr_get(js, entry, 0);
-    jsval_t value = arr_get(js, entry, 1);
+    jsval_t key = js_arr_get(js, entry, 0);
+    jsval_t value = js_arr_get(js, entry, 1);
     
     if (vtype(key) != T_OBJ) return js_mkerr(js, "WeakMap key must be an object");
     
@@ -21401,10 +21379,10 @@ static jsval_t builtin_WeakSet(struct js *js, jsval_t *args, int nargs) {
   if (nargs == 0 || vtype(args[0]) != T_ARR) return ws_obj;
   
   jsval_t iterable = args[0];
-  jsoff_t length = arr_length(js, iterable);
+  jsoff_t length = js_arr_len(js, iterable);
   
   for (jsoff_t i = 0; i < length; i++) {
-    jsval_t value = arr_get(js, iterable, i);
+    jsval_t value = js_arr_get(js, iterable, i);
     
     if (vtype(value) != T_OBJ) return js_mkerr(js, "WeakSet value must be an object");
     
@@ -21480,7 +21458,7 @@ static jsval_t finreg_register(struct js *js, jsval_t *args, int nargs) {
   if (vtype(registrations) != T_ARR) return js_mkundef();
   
   jsval_t entry = mkarr(js);
-  jsoff_t len = arr_length(js, registrations);
+  jsoff_t len = js_arr_len(js, registrations);
   
   char idx[16];
   size_t idx_len = uint_to_str(idx, sizeof(idx), 0);
@@ -21510,13 +21488,13 @@ static jsval_t finreg_unregister(struct js *js, jsval_t *args, int nargs) {
   jsval_t registrations = get_slot(js, this_val, SLOT_MAP);
   if (vtype(registrations) != T_ARR) return js_mkfalse();
   
-  jsoff_t len = arr_length(js, registrations);
+  jsoff_t len = js_arr_len(js, registrations);
   bool removed = false;
   
   for (jsoff_t i = 0; i < len; i++) {
-    jsval_t entry = arr_get(js, registrations, i);
+    jsval_t entry = js_arr_get(js, registrations, i);
     if (vtype(entry) != T_ARR) continue;
-    jsval_t entry_token = arr_get(js, entry, 2);
+    jsval_t entry_token = js_arr_get(js, entry, 2);
     if (vtype(entry_token) == T_OBJ && vdata(entry_token) == vdata(token)) {
       char idx[16]; size_t idx_len = uint_to_str(idx, sizeof(idx), i);
       setprop(js, registrations, js_mkstr(js, idx, idx_len), js_mkundef());
@@ -22531,8 +22509,6 @@ void js_destroy(struct js *js) {
 }
 
 inline double js_getnum(jsval_t value) { return tod(value); }
-inline int js_getbool(jsval_t value) { return vdata(value) & 1 ? 1 : 0; }
-
 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; }
@@ -22731,31 +22707,6 @@ void js_merge_obj(struct js *js, jsval_t dst, jsval_t src) {
   }
 }
 
-int js_type(jsval_t val) {
-  switch (vtype(val)) {
-    case T_UNDEF:   return JS_UNDEF;
-    case T_NULL:    return JS_NULL;
-    case T_BOOL:    return vdata(val) == 0 ? JS_FALSE: JS_TRUE;
-    case T_STR:     return JS_STR;
-    case T_NUM:     return JS_NUM;
-    case T_ERR:     return JS_ERR;
-    case T_PROMISE: return JS_PROMISE;
-    case T_SYMBOL:  return JS_SYMBOL;
-    
-    case T_OBJ:
-    case T_ARR:     return JS_OBJ;
-    case T_FUNC:    return JS_FUNC;
-    
-    default:        return JS_PRIV;
-  }
-}
-
-int js_type_ex(struct js *js, jsval_t val) {
-  (void)js;
-  if (vtype(val) == T_SYMBOL) return JS_SYMBOL;
-  return js_type(val);
-}
-
 #define UTARRAY_EACH(arr, type, var) \
   if (arr) for (type *var = (type *)utarray_front(arr), *_end = var + utarray_len(arr); var < _end; var++)
 
diff --git a/src/main.c b/src/main.c
index 73abb93..c371815 100644
--- a/src/main.c
+++ b/src/main.c
@@ -14,6 +14,7 @@
 #include "runtime.h"
 #include "snapshot.h"
 #include "esm/remote.h"
+#include "internal.h"
 
 #include "modules/builtin.h"
 #include "modules/buffer.h"
@@ -60,11 +61,11 @@ static void eval_code(struct js *js, struct arg_str *eval, struct arg_lit *print
   jsval_t result = js_eval(js, script, len);
   js_run_event_loop(js);
   
-  if (js_type(result) == JS_ERR) {
+  if (vtype(result) == T_ERR) {
     fprintf(stderr, "%s\n", js_str(js, result));
     js_result = EXIT_FAILURE;
   } else if (print->count > 0) {
-    if (js_type(result) == JS_STR) {
+    if (vtype(result) == T_STR) {
       char *str = js_getstr(js, result, NULL);
       if (str) printf("%s\n", str);
     } else {
@@ -150,7 +151,7 @@ static int execute_module(struct js *js, const char *filename) {
   jsval_t result = js_eval(js, js_code, js_len);
   free(js_code);
   
-  if (js_type(result) == JS_ERR) {
+  if (vtype(result) == T_ERR) {
     fprintf(stderr, "%s\n", js_str(js, result));
     return EXIT_FAILURE;
   }
@@ -254,7 +255,7 @@ int main(int argc, char *argv[]) {
   ant_standard_library("child_process", child_process_library);
 
   jsval_t snapshot_result = ant_load_snapshot(js);
-  if (js_type(snapshot_result) == JS_ERR) {
+  if (vtype(snapshot_result) == T_ERR) {
     fprintf(stderr, "Warning: Failed to load snapshot: %s\n", js_str(js, snapshot_result));
   }
 
diff --git a/src/modules/atomics.c b/src/modules/atomics.c
index 15b3398..5940c74 100644
--- a/src/modules/atomics.c
+++ b/src/modules/atomics.c
@@ -8,6 +8,7 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "internal.h"
 #include "runtime.h"
 
 #include "modules/buffer.h"
@@ -676,7 +677,7 @@ static jsval_t js_atomics_wait(struct js *js, jsval_t *args, int nargs) {
   int32_t expected_value = (int32_t)js_getnum(args[2]);
   int64_t timeout_ms = -1;
   
-  if (nargs > 3 && js_type(args[3]) == JS_NUM) {
+  if (nargs > 3 && vtype(args[3]) == T_NUM) {
     timeout_ms = (int64_t)js_getnum(args[3]);
   }
   
@@ -747,7 +748,7 @@ static jsval_t js_atomics_notify(struct js *js, jsval_t *args, int nargs) {
   }
   
   int count = -1;
-  if (nargs > 2 && js_type(args[2]) == JS_NUM) {
+  if (nargs > 2 && vtype(args[2]) == T_NUM) {
     count = (int)js_getnum(args[2]);
   }
   
diff --git a/src/modules/buffer.c b/src/modules/buffer.c
index 101db38..163a76b 100644
--- a/src/modules/buffer.c
+++ b/src/modules/buffer.c
@@ -12,6 +12,7 @@
 #include "ant.h"
 #include "errors.h"
 #include "arena.h"
+#include "internal.h"
 #include "runtime.h"
 
 #include "modules/buffer.h"
@@ -185,7 +186,7 @@ static size_t get_element_size(TypedArrayType type) {
 // ArrayBuffer constructor
 static jsval_t js_arraybuffer_constructor(struct js *js, jsval_t *args, int nargs) {
   size_t length = 0;
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) {
+  if (nargs > 0 && vtype(args[0]) == T_NUM) {
     length = (size_t)js_getnum(args[0]);
   }
   
@@ -197,7 +198,7 @@ static jsval_t js_arraybuffer_constructor(struct js *js, jsval_t *args, int narg
   jsval_t obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11);
   
-  if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto);
   js_set_slot(js, obj, SLOT_BUFFER, ANT_PTR(data));
   js_set(js, obj, "byteLength", js_mknum((double)length));
   
@@ -209,7 +210,7 @@ static jsval_t js_arraybuffer_slice(struct js *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 (js_type(data_val) != JS_NUM) {
+  if (vtype(data_val) != T_NUM) {
     return js_mkerr(js, "Not an ArrayBuffer");
   }
   
@@ -218,8 +219,8 @@ static jsval_t js_arraybuffer_slice(struct js *js, jsval_t *args, int nargs) {
   
   ssize_t len = (ssize_t)data->length;
   ssize_t begin = 0, end = len;
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]);
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]);
+  if (nargs > 0 && vtype(args[0]) == T_NUM) begin = (ssize_t)js_getnum(args[0]);
+  if (nargs > 1 && vtype(args[1]) == T_NUM) end = (ssize_t)js_getnum(args[1]);
   
   begin = normalize_index(begin, len);
   end = normalize_index(end, len);
@@ -234,7 +235,7 @@ static jsval_t js_arraybuffer_slice(struct js *js, jsval_t *args, int nargs) {
   jsval_t new_obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11);
   
-  if (js_type(proto) == JS_OBJ) js_set_proto(js, new_obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, new_obj, proto);
   js_set_slot(js, new_obj, SLOT_BUFFER, ANT_PTR(new_data));
   js_set(js, new_obj, "byteLength", js_mknum((double)new_length));
   
@@ -292,7 +293,7 @@ static bool typedarray_index_setter(struct js *js, jsval_t obj, const char *key,
   TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_val);
   if (!ta_data || index >= ta_data->length) return false;
   
-  double num_val = js_type(value) == JS_NUM ? js_getnum(value) : 0;
+  double num_val = vtype(value) == T_NUM ? js_getnum(value) : 0;
   uint8_t *data = ta_data->buffer->data + ta_data->byte_offset;
   
   static const void *dispatch[] = {
@@ -318,7 +319,7 @@ static bool typedarray_index_setter(struct js *js, jsval_t obj, const char *key,
 static jsval_t create_arraybuffer_obj(struct js *js, ArrayBufferData *buffer) {
   jsval_t ab_obj = js_mkobj(js);
   jsval_t ab_proto = js_get_ctor_proto(js, "ArrayBuffer", 11);
-  if (js_type(ab_proto) == JS_OBJ) js_set_proto(js, ab_obj, ab_proto);
+  if (vtype(ab_proto) == T_OBJ) js_set_proto(js, ab_obj, ab_proto);
   
   js_set_slot(js, ab_obj, SLOT_BUFFER, js_mknum((double)(uintptr_t)buffer));
   js_set(js, ab_obj, "byteLength", js_mknum((double)buffer->length));
@@ -344,7 +345,7 @@ static jsval_t create_typed_array_with_buffer(
   
   jsval_t obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, type_name, strlen(type_name));
-  if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto);
   
   js_set_slot(js, obj, SLOT_BUFFER, js_mktypedarray(ta_data));
   js_set(js, obj, "length", js_mknum((double)length));
@@ -392,7 +393,7 @@ static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs
     return create_typed_array(js, type, buffer, 0, 0, type_name);
   }
   
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     size_t length = (size_t)js_getnum(args[0]);
     size_t element_size = get_element_size(type);
     ArrayBufferData *buffer = create_array_buffer_data(length * element_size);
@@ -401,17 +402,17 @@ static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs
   }
   
   jsval_t buffer_data_val = js_get_slot(js, args[0], SLOT_BUFFER);
-  if (js_type(buffer_data_val) == JS_NUM) {
+  if (vtype(buffer_data_val) == T_NUM) {
     ArrayBufferData *buffer = (ArrayBufferData *)(uintptr_t)js_getnum(buffer_data_val);
     size_t byte_offset = 0;
     size_t length = buffer->length;
     
-    if (nargs > 1 && js_type(args[1]) == JS_NUM) {
+    if (nargs > 1 && vtype(args[1]) == T_NUM) {
       byte_offset = (size_t)js_getnum(args[1]);
     }
     
     size_t element_size = get_element_size(type);
-    if (nargs > 2 && js_type(args[2]) == JS_NUM) {
+    if (nargs > 2 && vtype(args[2]) == T_NUM) {
       length = (size_t)js_getnum(args[2]);
     } else {
       length = (buffer->length - byte_offset) / element_size;
@@ -420,13 +421,13 @@ static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs
     return create_typed_array_with_buffer(js, type, buffer, byte_offset, length, type_name, args[0]);
   }
   
-  int arg_type = js_type(args[0]);
-  if (arg_type == JS_OBJ) {
+  int arg_type = vtype(args[0]);
+  if (arg_type == T_OBJ) {
     jsval_t len_val = js_get(js, args[0], "length");
     size_t length = 0; jsval_t *values = NULL;
     bool is_iterable = false;
     
-    if (js_type(len_val) == JS_NUM) length = (size_t)js_getnum(len_val); else {
+    if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val); else {
       iter_collect_ctx_t ctx = { .values = NULL, .length = 0, .capacity = 16 };
       ctx.values = malloc(ctx.capacity * sizeof(jsval_t));
       if (!ctx.values) return js_mkerr(js, "Failed to allocate memory");
@@ -438,7 +439,7 @@ static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs
       } else free(ctx.values);
     }
     
-    if (length > 0 || is_iterable || js_type(len_val) == JS_NUM) {
+    if (length > 0 || is_iterable || vtype(len_val) == T_NUM) {
       size_t element_size = get_element_size(type);
       ArrayBufferData *buffer = create_array_buffer_data(length * element_size);
       if (!buffer) { if (values) free(values); return js_mkerr(js, "Failed to allocate buffer"); }
@@ -458,7 +459,7 @@ static jsval_t js_typedarray_constructor(struct js *js, jsval_t *args, int nargs
           snprintf(idx_str, sizeof(idx_str), "%zu", i);
           elem = js_get(js, args[0], idx_str);
         }
-        double val = js_type(elem) == JS_NUM ? js_getnum(elem) : 0;
+        double val = vtype(elem) == T_NUM ? js_getnum(elem) : 0;
         
         if (type > TYPED_ARRAY_BIGUINT64) goto W_DONE;
         goto *write_dispatch[type];
@@ -493,8 +494,8 @@ static jsval_t js_typedarray_slice(struct js *js, jsval_t *args, int nargs) {
   ssize_t len = (ssize_t)ta_data->length;
   ssize_t begin = 0, end = len;
   
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]);
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]);
+  if (nargs > 0 && vtype(args[0]) == T_NUM) begin = (ssize_t)js_getnum(args[0]);
+  if (nargs > 1 && vtype(args[1]) == T_NUM) end = (ssize_t)js_getnum(args[1]);
   
   begin = normalize_index(begin, len);
   end = normalize_index(end, len);
@@ -525,8 +526,8 @@ static jsval_t js_typedarray_subarray(struct js *js, jsval_t *args, int nargs) {
   ssize_t len = (ssize_t)ta_data->length;
   ssize_t begin = 0, end = len;
   
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]);
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]);
+  if (nargs > 0 && vtype(args[0]) == T_NUM) begin = (ssize_t)js_getnum(args[0]);
+  if (nargs > 1 && vtype(args[1]) == T_NUM) end = (ssize_t)js_getnum(args[1]);
   
   begin = normalize_index(begin, len);
   end = normalize_index(end, len);
@@ -548,13 +549,13 @@ static jsval_t js_typedarray_fill(struct js *js, jsval_t *args, int nargs) {
   if (!ta_data) return js_mkerr(js, "Invalid TypedArray");
   
   double value = 0;
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) value = js_getnum(args[0]);
+  if (nargs > 0 && vtype(args[0]) == T_NUM) value = js_getnum(args[0]);
   
   ssize_t len = (ssize_t)ta_data->length;
   ssize_t start = 0, end = len;
   
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) start = (ssize_t)js_getnum(args[1]);
-  if (nargs > 2 && js_type(args[2]) == JS_NUM) end = (ssize_t)js_getnum(args[2]);
+  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]);
   
   start = normalize_index(start, len);
   end = normalize_index(end, len);
@@ -642,8 +643,8 @@ static jsval_t js_typedarray_toSorted(struct js *js, jsval_t *args, int nargs) {
   TypedArrayData *result_ta = (TypedArrayData *)js_gettypedarray(result_ta_val);
   uint8_t *data = result_ta->buffer->data;
   
-  jsval_t comparefn = (nargs > 0 && js_type(args[0]) == JS_FUNC) ? args[0] : js_mkundef();
-  bool has_comparefn = js_type(comparefn) == JS_FUNC;
+  jsval_t comparefn = (nargs > 0 && vtype(args[0]) == T_FUNC) ? args[0] : js_mkundef();
+  bool has_comparefn = vtype(comparefn) == T_FUNC;
   
   for (size_t i = 1; i < length; i++) {
     for (size_t j = i; j > 0; j--) {
@@ -774,7 +775,7 @@ static jsval_t js_dataview_constructor(struct js *js, jsval_t *args, int nargs)
   }
   
   jsval_t buffer_data_val = js_get_slot(js, args[0], SLOT_BUFFER);
-  if (js_type(buffer_data_val) != JS_NUM) {
+  if (vtype(buffer_data_val) != T_NUM) {
     return js_mkerr(js, "First argument must be an ArrayBuffer");
   }
   
@@ -782,11 +783,11 @@ static jsval_t js_dataview_constructor(struct js *js, jsval_t *args, int nargs)
   size_t byte_offset = 0;
   size_t byte_length = buffer->length;
   
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) {
+  if (nargs > 1 && vtype(args[1]) == T_NUM) {
     byte_offset = (size_t)js_getnum(args[1]);
   }
   
-  if (nargs > 2 && js_type(args[2]) == JS_NUM) {
+  if (nargs > 2 && vtype(args[2]) == T_NUM) {
     byte_length = (size_t)js_getnum(args[2]);
   } else {
     byte_length = buffer->length - byte_offset;
@@ -802,7 +803,7 @@ static jsval_t js_dataview_constructor(struct js *js, jsval_t *args, int nargs)
   
   jsval_t obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "DataView", 8);
-  if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto);
   
   js_set_slot(js, obj, SLOT_DATA, ANT_PTR(dv_data));
   js_mkprop_fast(js, obj, "buffer", 6, args[0]);
@@ -821,7 +822,7 @@ static jsval_t js_dataview_getUint8(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -843,7 +844,7 @@ static jsval_t js_dataview_setUint8(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -866,7 +867,7 @@ static jsval_t js_dataview_getInt16(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -897,7 +898,7 @@ static jsval_t js_dataview_getInt32(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -928,7 +929,7 @@ static jsval_t js_dataview_getFloat32(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -961,7 +962,7 @@ static jsval_t js_dataview_setInt16(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -994,7 +995,7 @@ static jsval_t js_dataview_setInt32(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -1031,7 +1032,7 @@ static jsval_t js_dataview_setFloat32(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -1070,7 +1071,7 @@ static jsval_t js_dataview_getFloat64(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -1105,7 +1106,7 @@ static jsval_t js_dataview_setFloat64(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA);
   
-  if (js_type(dv_data_val) != JS_NUM) {
+  if (vtype(dv_data_val) != T_NUM) {
     return js_mkerr(js, "Not a DataView");
   }
   
@@ -1195,12 +1196,12 @@ static BufferEncoding parse_encoding(const char *enc, size_t len) {
 static jsval_t js_buffer_from(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "Buffer.from requires at least one argument");
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     size_t len;
     char *str = js_getstr(js, args[0], &len);
     
     BufferEncoding encoding = ENC_UTF8;
-    if (nargs >= 2 && js_type(args[1]) == JS_STR) {
+    if (nargs >= 2 && vtype(args[1]) == T_STR) {
       size_t enc_len;
       char *enc_str = js_getstr(js, args[1], &enc_len);
       encoding = parse_encoding(enc_str, enc_len);
@@ -1249,7 +1250,7 @@ static jsval_t js_buffer_from(struct js *js, jsval_t *args, int nargs) {
   }
   
   jsval_t length_val = js_get(js, args[0], "length");
-  if (js_type(length_val) == JS_NUM) {
+  if (vtype(length_val) == T_NUM) {
     size_t len = (size_t)js_getnum(length_val);
     ArrayBufferData *buffer = create_array_buffer_data(len);
     if (!buffer) return js_mkerr(js, "Failed to allocate buffer");
@@ -1258,7 +1259,7 @@ static jsval_t js_buffer_from(struct js *js, jsval_t *args, int nargs) {
       char idx_str[32];
       snprintf(idx_str, sizeof(idx_str), "%zu", i);
       jsval_t elem = js_get(js, args[0], idx_str);
-      if (js_type(elem) == JS_NUM) {
+      if (vtype(elem) == T_NUM) {
         buffer->data[i] = (uint8_t)js_getnum(elem);
       }
     }
@@ -1304,7 +1305,7 @@ static jsval_t js_buffer_toString(struct js *js, jsval_t *args, int nargs) {
   if (!ta_data) return js_mkerr(js, "Invalid Buffer");
   
   BufferEncoding encoding = ENC_UTF8;
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     size_t enc_len;
     char *enc_str = js_getstr(js, args[0], &enc_len);
     encoding = parse_encoding(enc_str, enc_len);
@@ -1370,11 +1371,11 @@ static jsval_t js_buffer_write(struct js *js, jsval_t *args, int nargs) {
   size_t offset = 0;
   size_t length = ta_data->byte_length;
   
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) {
+  if (nargs > 1 && vtype(args[1]) == T_NUM) {
     offset = (size_t)js_getnum(args[1]);
   }
   
-  if (nargs > 2 && js_type(args[2]) == JS_NUM) {
+  if (nargs > 2 && vtype(args[2]) == T_NUM) {
     length = (size_t)js_getnum(args[2]);
   }
   
@@ -1393,7 +1394,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) {
   if (nargs < 1) return js_mkfalse();
-  if (js_type(args[0]) != JS_OBJ) return js_mkfalse();
+  if (vtype(args[0]) != T_OBJ) return js_mkfalse();
   
   jsval_t proto = js_get_proto(js, args[0]);
   jsval_t buffer_proto = js_get_ctor_proto(js, "Buffer", 6);
@@ -1403,7 +1404,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) {
-  if (nargs < 1 || js_type(args[0]) != JS_STR) return js_mkfalse();
+  if (nargs < 1 || vtype(args[0]) != T_STR) return js_mkfalse();
   
   size_t len;
   char *enc = js_getstr(js, args[0], &len);
@@ -1431,15 +1432,15 @@ static jsval_t js_buffer_byteLength(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t arg = args[0];
   
-  if (js_type(arg) == JS_OBJ) {
+  if (vtype(arg) == T_OBJ) {
     jsval_t bytelen = js_get(js, arg, "byteLength");
-    if (js_type(bytelen) == JS_NUM) return bytelen;
+    if (vtype(bytelen) == T_NUM) return bytelen;
     
     jsval_t len = js_get(js, arg, "length");
-    if (js_type(len) == JS_NUM) return len;
+    if (vtype(len) == T_NUM) return len;
   }
   
-  if (js_type(arg) == JS_STR) {
+  if (vtype(arg) == T_STR) {
     size_t len;
     js_getstr(js, arg, &len);
     return js_mknum((double)len);
@@ -1450,20 +1451,20 @@ 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) {
-  if (nargs < 1 || js_type(args[0]) != JS_OBJ) {
+  if (nargs < 1 || vtype(args[0]) != T_OBJ) {
     return js_mkerr(js, "First argument must be an array");
   }
   
   jsval_t list = args[0];
   jsval_t len_val = js_get(js, list, "length");
-  if (js_type(len_val) != JS_NUM) {
+  if (vtype(len_val) != T_NUM) {
     return js_mkerr(js, "First argument must be an array");
   }
   
   size_t list_len = (size_t)js_getnum(len_val);
   size_t total_length = 0;
   
-  if (nargs > 1 && js_type(args[1]) == JS_NUM) {
+  if (nargs > 1 && vtype(args[1]) == T_NUM) {
     total_length = (size_t)js_getnum(args[1]);
   } else {
     for (size_t i = 0; i < list_len; i++) {
@@ -1471,7 +1472,7 @@ static jsval_t js_buffer_concat(struct js *js, jsval_t *args, int nargs) {
       snprintf(idx, sizeof(idx), "%zu", i);
       jsval_t buf = js_get(js, list, idx);
       jsval_t buf_len = js_get(js, buf, "length");
-      if (js_type(buf_len) == JS_NUM) total_length += (size_t)js_getnum(buf_len);
+      if (vtype(buf_len) == T_NUM) total_length += (size_t)js_getnum(buf_len);
     }
   }
   
@@ -1531,7 +1532,7 @@ static jsval_t js_buffer_compare(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t js_sharedarraybuffer_constructor(struct js *js, jsval_t *args, int nargs) {
   size_t length = 0;
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) {
+  if (nargs > 0 && vtype(args[0]) == T_NUM) {
     length = (size_t)js_getnum(args[0]);
   }
   
@@ -1543,7 +1544,7 @@ static jsval_t js_sharedarraybuffer_constructor(struct js *js, jsval_t *args, in
   jsval_t obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "SharedArrayBuffer", 17);
   
-  if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto);
   js_set_slot(js, obj, SLOT_BUFFER, ANT_PTR(data));
   js_set(js, obj, "byteLength", js_mknum((double)length));
   
diff --git a/src/modules/builtin.c b/src/modules/builtin.c
index 4c56149..e292da2 100644
--- a/src/modules/builtin.c
+++ b/src/modules/builtin.c
@@ -29,7 +29,7 @@ static void general_signal_handler(int signum) {
   struct js *js = signal_handlers[signum].js;
   jsval_t handler = signal_handlers[signum].handler;
   
-  if (js && js_type(handler) != JS_UNDEF) {
+  if (js && vtype(handler) != T_UNDEF) {
     jsval_t args[] = {js_mknum(signum)};
     js_call(js, handler, args, 1);
   }
diff --git a/src/modules/child_process.c b/src/modules/child_process.c
index aa4ede1..395deae 100644
--- a/src/modules/child_process.c
+++ b/src/modules/child_process.c
@@ -24,6 +24,8 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "internal.h"
+
 #include "modules/child_process.h"
 #include "modules/symbol.h"
 
@@ -135,7 +137,7 @@ static void emit_event(child_process_t *cp, const char *name, jsval_t *args, int
   while (i < evt->count) {
     child_listener_t *l = &evt->listeners[i];
     jsval_t result = js_call(cp->js, l->callback, args, nargs);
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in child_process '%s' listener: %s\n", name, js_str(cp->js, result));
     }
     if (l->once) {
@@ -169,7 +171,7 @@ static void check_completion(child_process_t *cp) {
     jsval_t close_args[2] = { js_mknum((double)cp->exit_code), cp->term_signal ? js_mknum((double)cp->term_signal) : js_mknull() };
     emit_event(cp, "close", close_args, 2);
     
-    if (js_type(cp->promise) != JS_UNDEF) {
+    if (vtype(cp->promise) != T_UNDEF) {
       jsval_t result = js_mkobj(cp->js);
       js_set(cp->js, result, "stdout", stdout_val);
       js_set(cp->js, result, "stderr", stderr_val);
@@ -316,11 +318,11 @@ static void on_stderr_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *b
 static jsval_t child_on(struct js *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 (js_type(args[0]) != JS_STR) return js_mkerr(js, "Event name must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "Callback must be a function");
+  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 cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
-  if (js_type(cp_ptr) == JS_UNDEF) return js_mkerr(js, "Invalid child process object");
+  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);
   
@@ -345,11 +347,11 @@ static jsval_t child_on(struct js *js, jsval_t *args, int nargs) {
 static jsval_t child_once(struct js *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 (js_type(args[0]) != JS_STR) return js_mkerr(js, "Event name must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "Callback must be a function");
+  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 cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
-  if (js_type(cp_ptr) == JS_UNDEF) return js_mkerr(js, "Invalid child process object");
+  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);
   
@@ -375,16 +377,16 @@ static jsval_t child_kill(struct js *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 (js_type(cp_ptr) == JS_UNDEF) return js_mkfalse();
+  if (vtype(cp_ptr) == T_UNDEF) return js_mkfalse();
   
   child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
   if (cp->exited) return js_mkfalse();
   
   int sig = SIGTERM;
   if (nargs > 0) {
-    if (js_type(args[0]) == JS_NUM) {
+    if (vtype(args[0]) == T_NUM) {
       sig = (int)js_getnum(args[0]);
-    } else if (js_type(args[0]) == JS_STR) {
+    } else if (vtype(args[0]) == T_STR) {
       size_t sig_len;
       char *sig_str = js_getstr(js, args[0], &sig_len);
       if (strncmp(sig_str, "SIGTERM", sig_len) == 0) sig = SIGTERM;
@@ -404,7 +406,7 @@ static jsval_t child_write(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "write() requires data argument");
   
   jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
-  if (js_type(cp_ptr) == JS_UNDEF) return js_mkerr(js, "Invalid child process object");
+  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);
   if (cp->stdin_closed) return js_mkfalse();
@@ -435,7 +437,7 @@ static jsval_t child_end(struct js *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 (js_type(cp_ptr) == JS_UNDEF) return js_mkundef();
+  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) {
@@ -481,7 +483,7 @@ static char **parse_args_array(struct js *js, jsval_t arr, int *count) {
     char idx[16];
     snprintf(idx, sizeof(idx), "%d", i);
     jsval_t val = js_get(js, arr, idx);
-    if (js_type(val) == JS_STR) {
+    if (vtype(val) == T_STR) {
       size_t arg_len;
       char *arg = js_getstr(js, val, &arg_len);
       args[i] = strndup(arg, arg_len);
@@ -503,7 +505,7 @@ static void free_args_array(char **args, int count) {
 
 static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "spawn() requires a command");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
   ensure_cp_loop();
   
@@ -517,16 +519,16 @@ static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) {
   bool use_shell = false;
   bool detached = false;
   
-  if (nargs >= 2 && js_type(args[1]) == JS_OBJ) {
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
     jsval_t len_val = js_get(js, args[1], "length");
-    if (js_type(len_val) == JS_NUM) {
+    if (vtype(len_val) == T_NUM) {
       spawn_args = parse_args_array(js, args[1], &spawn_argc);
     }
   }
   
-  if (nargs >= 3 && js_type(args[2]) == JS_OBJ) {
+  if (nargs >= 3 && vtype(args[2]) == T_OBJ) {
     jsval_t cwd_val = js_get(js, args[2], "cwd");
-    if (js_type(cwd_val) == JS_STR) {
+    if (vtype(cwd_val) == T_STR) {
       size_t cwd_len;
       char *cwd_str = js_getstr(js, cwd_val, &cwd_len);
       cwd = strndup(cwd_str, cwd_len);
@@ -648,7 +650,7 @@ static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "exec() requires a command");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
   ensure_cp_loop();
   
@@ -657,9 +659,9 @@ static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) {
   char *cmd_str = strndup(cmd, cmd_len);
   
   char *cwd = NULL;
-  if (nargs >= 2 && js_type(args[1]) == JS_OBJ) {
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
     jsval_t cwd_val = js_get(js, args[1], "cwd");
-    if (js_type(cwd_val) == JS_STR) {
+    if (vtype(cwd_val) == T_STR) {
       size_t cwd_len;
       char *cwd_s = js_getstr(js, cwd_val, &cwd_len);
       cwd = strndup(cwd_s, cwd_len);
@@ -730,7 +732,7 @@ static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t builtin_execSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "execSync() requires a command");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
   size_t cmd_len;
   char *cmd = js_getstr(js, args[0], &cmd_len);
@@ -795,7 +797,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) {
   if (nargs < 1) return js_mkerr(js, "spawnSync() requires a command");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
   size_t cmd_len;
   char *cmd = js_getstr(js, args[0], &cmd_len);
@@ -806,16 +808,16 @@ static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
   char *input = NULL;
   size_t input_len = 0;
   
-  if (nargs >= 2 && js_type(args[1]) == JS_OBJ) {
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
     jsval_t len_val = js_get(js, args[1], "length");
-    if (js_type(len_val) == JS_NUM) {
+    if (vtype(len_val) == T_NUM) {
       spawn_args = parse_args_array(js, args[1], &spawn_argc);
     }
   }
   
-  if (nargs >= 3 && js_type(args[2]) == JS_OBJ) {
+  if (nargs >= 3 && vtype(args[2]) == T_OBJ) {
     jsval_t input_val = js_get(js, args[2], "input");
-    if (js_type(input_val) == JS_STR) {
+    if (vtype(input_val) == T_STR) {
       input = js_getstr(js, input_val, &input_len);
     }
   }
@@ -940,7 +942,7 @@ static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
 #else
 static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "spawnSync() requires a command");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string");
   
   size_t cmd_len;
   char *cmd = js_getstr(js, args[0], &cmd_len);
@@ -951,16 +953,16 @@ static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
   char *input = NULL;
   size_t input_len = 0;
   
-  if (nargs >= 2 && js_type(args[1]) == JS_OBJ) {
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
     jsval_t len_val = js_get(js, args[1], "length");
-    if (js_type(len_val) == JS_NUM) {
+    if (vtype(len_val) == T_NUM) {
       spawn_args = parse_args_array(js, args[1], &spawn_argc);
     }
   }
   
-  if (nargs >= 3 && js_type(args[2]) == JS_OBJ) {
+  if (nargs >= 3 && vtype(args[2]) == T_OBJ) {
     jsval_t input_val = js_get(js, args[2], "input");
-    if (js_type(input_val) == JS_STR) {
+    if (vtype(input_val) == T_STR) {
       input = js_getstr(js, input_val, &input_len);
     }
   }
@@ -1080,7 +1082,7 @@ static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t builtin_fork(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "fork() requires a module path");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Module path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "Module path must be a string");
   size_t path_len;
   
   char *path = js_getstr(js, args[0], &path_len);
@@ -1110,9 +1112,9 @@ static jsval_t builtin_fork(struct js *js, jsval_t *args, int nargs) {
   jsval_t args_arr = js_mkarr(js);
   js_arr_push(js, args_arr, js_mkstr(js, path_str, path_len));
   
-  if (nargs >= 2 && js_type(args[1]) == JS_OBJ) {
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
     jsval_t exec_args = js_get(js, args[1], "execArgv");
-    if (js_type(exec_args) == JS_OBJ) {
+    if (vtype(exec_args) == T_OBJ) {
       jsval_t len_val = js_get(js, exec_args, "length");
       int arr_len = (int)js_getnum(len_val);
       for (int i = 0; i < arr_len; i++) {
diff --git a/src/modules/events.c b/src/modules/events.c
index 4a5654e..60426d2 100644
--- a/src/modules/events.c
+++ b/src/modules/events.c
@@ -8,6 +8,7 @@
 #include "errors.h"
 #include "arena.h"
 #include "runtime.h"
+#include "internal.h"
 
 #include "modules/events.h"
 #include "modules/symbol.h"
@@ -39,7 +40,7 @@ static inline void remove_listener_at(EventType *evt, int i) {
 static EventType **get_or_create_emitter_events(struct js *js, jsval_t this_obj) {
   jsval_t slot = js_get_slot(js, this_obj, SLOT_DATA);
   
-  if (js_type(slot) == JS_UNDEF) {
+  if (vtype(slot) == T_UNDEF) {
     EventType **events = ant_calloc(sizeof(EventType *));
     *events = NULL;
     js_set_slot(js, this_obj, SLOT_DATA, ANT_PTR(events));
@@ -109,7 +110,7 @@ static jsval_t js_add_event_listener_method(struct js *js, jsval_t *args, int na
   
   char *event_type = js_getstr(js, args[0], NULL);
   if (event_type == NULL) return js_mkerr(js, "eventType must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function");
   
   EventType *evt = find_or_create_emitter_event_type(js, this_obj, event_type);
   if (evt == NULL) return js_mkerr(js, "failed to create event type");
@@ -119,9 +120,9 @@ static jsval_t js_add_event_listener_method(struct js *js, jsval_t *args, int na
   }
   
   bool once = false;
-  if (nargs >= 3 && js_type(args[2]) != JS_UNDEF) {
+  if (nargs >= 3 && vtype(args[2]) != T_UNDEF) {
     jsval_t once_val = js_get(js, args[2], "once");
-    if (js_type(once_val) != JS_UNDEF) once = js_truthy(js, once_val);
+    if (vtype(once_val) != T_UNDEF) once = js_truthy(js, once_val);
   }
   
   EventListener *listener = &evt->listeners[evt->listener_count++];
@@ -142,7 +143,7 @@ static jsval_t js_add_event_listener(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr(js, "eventType must be a string");
   }
   
-  if (js_type(args[1]) != JS_FUNC) {
+  if (vtype(args[1]) != T_FUNC) {
     return js_mkerr(js, "listener must be a function");
   }
   
@@ -156,9 +157,9 @@ static jsval_t js_add_event_listener(struct js *js, jsval_t *args, int nargs) {
   }
   
   bool once = false;
-  if (nargs >= 3 && js_type(args[2]) != JS_UNDEF) {
+  if (nargs >= 3 && vtype(args[2]) != T_UNDEF) {
     jsval_t once_val = js_get(js, args[2], "once");
-    if (js_type(once_val) != JS_UNDEF) once = js_truthy(js, once_val);
+    if (vtype(once_val) != T_UNDEF) once = js_truthy(js, once_val);
   }
   
   EventListener *listener = &evt->listeners[evt->listener_count++];
@@ -231,7 +232,7 @@ static jsval_t js_dispatch_event_method(struct js *js, jsval_t *args, int nargs)
   js_set(js, event_obj, "target", this_obj);
   js_set(js, event_obj, get_toStringTag_sym_key(), js_mkstr(js, "Event", 5));
   
-  if (nargs >= 2 && js_type(args[1]) != JS_UNDEF) {
+  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
     js_set(js, event_obj, "detail", args[1]);
   }
   
@@ -241,7 +242,7 @@ static jsval_t js_dispatch_event_method(struct js *js, jsval_t *args, int nargs)
     EventListener *listener = &evt->listeners[i];
     jsval_t result = js_call(js, listener->listener, listener_args, 1);
     
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result));
     }
     
@@ -271,7 +272,7 @@ static jsval_t js_dispatch_event(struct js *js, jsval_t *args, int nargs) {
   js_set(js, event_obj, "type", args[0]);
   js_set(js, event_obj, get_toStringTag_sym_key(), js_mkstr(js, "Event", 5));
   
-  if (nargs >= 2 && js_type(args[1]) != JS_UNDEF) {
+  if (nargs >= 2 && vtype(args[1]) != T_UNDEF) {
     js_set(js, event_obj, "detail", args[1]);
   }
   
@@ -281,7 +282,7 @@ static jsval_t js_dispatch_event(struct js *js, jsval_t *args, int nargs) {
     EventListener *listener = &evt->listeners[i];
     jsval_t result = js_call(js, listener->listener, listener_args, 1);
     
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result));
     }
     
@@ -333,7 +334,7 @@ static jsval_t js_eventemitter_on(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr(js, "event must be a string");
   }
   
-  if (js_type(args[1]) != JS_FUNC) {
+  if (vtype(args[1]) != T_FUNC) {
     return js_mkerr(js, "listener must be a function");
   }
   
@@ -366,7 +367,7 @@ static jsval_t js_eventemitter_once(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr(js, "event must be a string");
   }
   
-  if (js_type(args[1]) != JS_FUNC) {
+  if (vtype(args[1]) != T_FUNC) {
     return js_mkerr(js, "listener must be a function");
   }
   
@@ -439,7 +440,7 @@ static jsval_t js_eventemitter_emit(struct js *js, jsval_t *args, int nargs) {
     EventListener *listener = &evt->listeners[i];
     jsval_t result = js_call(js, listener->listener, listener_args, listener_nargs);
     
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result));
     }
     
diff --git a/src/modules/fetch.c b/src/modules/fetch.c
index 12cb07c..8f52817 100644
--- a/src/modules/fetch.c
+++ b/src/modules/fetch.c
@@ -12,6 +12,7 @@
 #include "errors.h"
 #include "config.h"
 #include "common.h"
+#include "internal.h"
 #include "runtime.h"
 #include "modules/fetch.h"
 #include "modules/json.h"
@@ -76,7 +77,7 @@ static jsval_t response_json(struct js *js, jsval_t *args, int nargs) {
   jsval_t parsed = js_json_parse(js, &body, 1);
   jsval_t promise = js_mkpromise(js);
   
-  if (js_type(parsed) == JS_ERR) {
+  if (vtype(parsed) == T_ERR) {
     js_reject_promise(js, promise, parsed);
   } else js_resolve_promise(js, promise, parsed);
   
@@ -270,15 +271,15 @@ static jsval_t do_fetch_microtask(struct js *js, jsval_t *args, int nargs) {
   char *body = NULL;
   size_t body_len = 0;
   
-  if (js_type(options_val) == JS_OBJ) {
+  if (vtype(options_val) == T_OBJ) {
     jsval_t method_val = js_get(js, options_val, "method");
-    if (js_type(method_val) == JS_STR) {
+    if (vtype(method_val) == T_STR) {
       char *method_str = js_getstr(js, method_val, NULL);
       if (method_str) method = method_str;
     }
     
     jsval_t body_val = js_get(js, options_val, "body");
-    if (js_type(body_val) == JS_STR) {
+    if (vtype(body_val) == T_STR) {
       body = js_getstr(js, body_val, NULL);
       if (body) body_len = strlen(body);
     }
@@ -301,9 +302,9 @@ static jsval_t do_fetch_microtask(struct js *js, jsval_t *args, int nargs) {
   snprintf(user_agent, sizeof(user_agent), "ant/%s", ANT_VERSION);
   tlsuv_http_req_header(req->http_req, "User-Agent", user_agent);
   
-  if (js_type(options_val) == JS_OBJ) {
+  if (vtype(options_val) == T_OBJ) {
     jsval_t headers_val = js_get(js, options_val, "headers");
-    if (js_type(headers_val) == JS_OBJ) {
+    if (vtype(headers_val) == T_OBJ) {
       ant_iter_t iter = js_prop_iter_begin(js, headers_val);
       const char *key;
       size_t key_len;
@@ -329,7 +330,7 @@ static jsval_t do_fetch_microtask(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t js_fetch(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "fetch requires at least 1 argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "fetch URL must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "fetch URL must be a string");
   
   jsval_t url_val = args[0];
   jsval_t options_val = nargs > 1 ? args[1] : js_mkundef();
diff --git a/src/modules/ffi.c b/src/modules/ffi.c
index 866e0c7..e2b34aa 100644
--- a/src/modules/ffi.c
+++ b/src/modules/ffi.c
@@ -16,6 +16,8 @@
 #include <uthash.h>
 
 #include "errors.h"
+#include "internal.h"
+
 #include "modules/ffi.h"
 #include "modules/symbol.h"
 
@@ -151,7 +153,7 @@ static void ffi_init_array(void) {
 }
 
 static jsval_t ffi_dlopen(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || js_type(args[0]) != JS_STR) {
+  if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "dlopen() requires library name string");
   }
 
@@ -200,13 +202,13 @@ 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) {
-  if (nargs < 2 || js_type(args[0]) != JS_STR) {
+  if (nargs < 2 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "define() requires function name string and signature");
   }
 
   jsval_t this_obj = js_getthis(js);
   jsval_t lib_ptr_val = js_get(js, this_obj, "__lib_ptr");
-  if (js_type(lib_ptr_val) != JS_NUM) {
+  if (vtype(lib_ptr_val) != T_NUM) {
     return js_mkerr(js, "Invalid library object");
   }
 
@@ -214,9 +216,9 @@ static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) {
   const char *func_name = js_getstr(js, args[0], &func_name_len);
 
   jsval_t sig = args[1];
-  int sig_type = js_type(sig);
-  if (sig_type == JS_STR || sig_type == JS_NUM || sig_type == JS_NULL ||
-      sig_type == JS_UNDEF) {
+  int sig_type = vtype(sig);
+  if (sig_type == T_STR || sig_type == T_NUM || sig_type == T_NULL ||
+      sig_type == T_UNDEF) {
     return js_mkerr(js,
                     "Signature must be an array [returnType, [argTypes...]] or "
                     "an object {args: [...], returns: type}");
@@ -229,16 +231,16 @@ static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) {
   jsval_t returns_val = js_get(js, sig, "returns");
   jsval_t args_val = js_get(js, sig, "args");
 
-  if (js_type(returns_val) != JS_UNDEF && js_type(args_val) != JS_UNDEF) {
-    if (js_type(returns_val) != JS_STR) {
+  if (vtype(returns_val) != T_UNDEF && vtype(args_val) != T_UNDEF) {
+    if (vtype(returns_val) != T_STR) {
       return js_mkerr(js, "Return type must be a string");
     }
     ret_type_str = js_getstr(js, returns_val, NULL);
     arg_types_arr = args_val;
 
-    if (js_type(arg_types_arr) == JS_STR || js_type(arg_types_arr) == JS_NUM ||
-        js_type(arg_types_arr) == JS_NULL ||
-        js_type(arg_types_arr) == JS_UNDEF) {
+    if (vtype(arg_types_arr) == T_STR || vtype(arg_types_arr) == T_NUM ||
+        vtype(arg_types_arr) == T_NULL ||
+        vtype(arg_types_arr) == T_UNDEF) {
       return js_mkerr(js, "Argument types must be an array");
     }
 
@@ -246,16 +248,16 @@ static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) {
     arg_count = (int)js_getnum(length_val);
   } else {
     jsval_t ret_type_val = js_get(js, sig, "0");
-    if (js_type(ret_type_val) != JS_STR) {
+    if (vtype(ret_type_val) != T_STR) {
       return js_mkerr(js, "Return type must be a string");
     }
 
     ret_type_str = js_getstr(js, ret_type_val, NULL);
     arg_types_arr = js_get(js, sig, "1");
 
-    int arg_arr_type = js_type(arg_types_arr);
-    if (arg_arr_type == JS_STR || arg_arr_type == JS_NUM ||
-        arg_arr_type == JS_NULL || arg_arr_type == JS_UNDEF) {
+    int arg_arr_type = vtype(arg_types_arr);
+    if (arg_arr_type == T_STR || arg_arr_type == T_NUM ||
+        arg_arr_type == T_NULL || arg_arr_type == T_UNDEF) {
       return js_mkerr(js, "Argument types must be an array");
     }
 
@@ -300,7 +302,7 @@ static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) {
       snprintf(idx_str, sizeof(idx_str), "%d", i);
       jsval_t arg_type_val = js_get(js, arg_types_arr, idx_str);
 
-      if (js_type(arg_type_val) != JS_STR) {
+      if (vtype(arg_type_val) != T_STR) {
         free(func->arg_types);
         free(func);
         return js_mkerr(js, "Argument type must be a string");
@@ -348,7 +350,7 @@ 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) {
   jsval_t lib_obj = js_getthis(js);
-  if (nargs < 1 || js_type(args[0]) != JS_STR)
+  if (nargs < 1 || vtype(args[0]) != T_STR)
     return js_mkerr(js, "call() requires function name string");
 
   size_t func_name_len;
@@ -442,7 +444,7 @@ jsval_t ffi_call_by_index(struct js *js, unsigned int func_index, jsval_t *args,
 }
 
 static jsval_t ffi_alloc_memory(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || js_type(args[0]) != JS_NUM) {
+  if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "alloc() requires size");
   }
 
@@ -475,7 +477,7 @@ 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) {
-  if (nargs < 1 || js_type(args[0]) != JS_NUM) {
+  if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "free() requires pointer");
   }
 
@@ -502,7 +504,7 @@ 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) {
-  if (nargs < 2 || js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_STR) {
+  if (nargs < 2 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) {
     return js_mkerr(js, "read() requires pointer and type");
   }
 
@@ -530,7 +532,7 @@ 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) {
-  if (nargs < 3 || js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_STR) {
+  if (nargs < 3 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) {
     return js_mkerr(js, "write() requires pointer, type, and value");
   }
 
@@ -560,7 +562,7 @@ 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) {
-  if (nargs < 1 || js_type(args[0]) != JS_NUM) return js_mkerr(js, "pointer() requires pointer");
+  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]);
 
   pthread_mutex_lock(&ffi_pointers_mutex);
@@ -573,7 +575,7 @@ static jsval_t ffi_get_pointer(struct js *js, jsval_t *args, int nargs) {
 }
 
 static jsval_t ffi_read_ptr(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 2 || js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_STR) {
+  if (nargs < 2 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) {
     return js_mkerr(js, "readPtr() requires pointer and type");
   }
 
@@ -627,7 +629,7 @@ static void ffi_callback_handler(ffi_cif *cif, void *ret, void **args, void *use
     } else if (cb->ret_type == &ffi_type_double) {
       *(double *)ret = js_getnum(result);
     } else if (cb->ret_type == &ffi_type_pointer) {
-      if (js_type(result) == JS_NUM) {
+      if (vtype(result) == T_NUM) {
         *(void **)ret = (void *)(uint64_t)js_getnum(result);
       } else {
         *(void **)ret = NULL;
@@ -641,8 +643,8 @@ static jsval_t ffi_create_callback(struct js *js, jsval_t *args, int nargs) {
 
   jsval_t js_func = args[0];
   jsval_t sig = args[1];
-  int sig_type = js_type(sig);
-  if (sig_type == JS_STR || sig_type == JS_NUM || sig_type == JS_NULL || sig_type == JS_UNDEF) {
+  int sig_type = vtype(sig);
+  if (sig_type == T_STR || sig_type == T_NUM || sig_type == T_NULL || sig_type == T_UNDEF) {
     return js_mkerr(js, "Signature must be an object {args: [...], returns: type}");
   }
 
@@ -653,15 +655,15 @@ static jsval_t ffi_create_callback(struct js *js, jsval_t *args, int nargs) {
   jsval_t returns_val = js_get(js, sig, "returns");
   jsval_t args_val = js_get(js, sig, "args");
 
-  if (js_type(returns_val) != JS_UNDEF && js_type(args_val) != JS_UNDEF) {
-    if (js_type(returns_val) != JS_STR) return js_mkerr(js, "Return type must be a string");
+  if (vtype(returns_val) != T_UNDEF && vtype(args_val) != T_UNDEF) {
+    if (vtype(returns_val) != T_STR) return js_mkerr(js, "Return type must be a string");
     ret_type_str = js_getstr(js, returns_val, NULL);
     arg_types_arr = args_val;
     jsval_t length_val = js_get(js, arg_types_arr, "length");
     arg_count = (int)js_getnum(length_val);
   } else {
     jsval_t ret_type_val = js_get(js, sig, "0");
-    if (js_type(ret_type_val) != JS_STR) return js_mkerr(js, "Return type must be a string");
+    if (vtype(ret_type_val) != T_STR) return js_mkerr(js, "Return type must be a string");
     ret_type_str = js_getstr(js, ret_type_val, NULL);
     arg_types_arr = js_get(js, sig, "1");
     jsval_t length_val = js_get(js, arg_types_arr, "length");
@@ -696,7 +698,7 @@ static jsval_t ffi_create_callback(struct js *js, jsval_t *args, int nargs) {
       snprintf(idx_str, sizeof(idx_str), "%d", i);
       jsval_t arg_type_val = js_get(js, arg_types_arr, idx_str);
 
-      if (js_type(arg_type_val) != JS_STR) {
+      if (vtype(arg_type_val) != T_STR) {
         for (int j = 0; j < i; j++) free(cb->arg_type_strs[j]);
         free(cb->arg_types);
         free(cb->arg_type_strs);
@@ -758,7 +760,7 @@ 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) {
-  if (nargs < 1 || js_type(args[0]) != JS_NUM) {
+  if (nargs < 1 || vtype(args[0]) != T_NUM) {
     return js_mkerr(js, "freeCallback() requires callback pointer");
   }
 
@@ -919,7 +921,7 @@ do_double: {
     goto do_done;
   }
 do_pointer: {
-    if (js_type(val) == JS_STR) {
+    if (vtype(val) == T_STR) {
       size_t str_len;
       const char *str = js_getstr(js, val, &str_len);
       void *ptr = (void *)str;
diff --git a/src/modules/fs.c b/src/modules/fs.c
index aa7ed0f..fd42f58 100644
--- a/src/modules/fs.c
+++ b/src/modules/fs.c
@@ -275,7 +275,7 @@ static void on_stat_complete(uv_fs_t *uv_req) {
   
   jsval_t stat_obj = js_mkobj(req->js);
   jsval_t proto = js_get_ctor_proto(req->js, "Stats", 5);
-  if (js_type(proto) == JS_OBJ) js_set_proto(req->js, stat_obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(req->js, stat_obj, proto);
   
   uv_stat_t *st = &uv_req->statbuf;
   js_set_slot(req->js, stat_obj, SLOT_DATA, js_mknum((double)st->st_mode));
@@ -360,7 +360,7 @@ static void ensure_fs_loop(void) {
 static jsval_t builtin_fs_readFileSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readFileSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readFileSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readFileSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -411,7 +411,7 @@ static jsval_t builtin_fs_readFileSync(struct js *js, jsval_t *args, int nargs)
 
 static jsval_t builtin_fs_readBytesSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readBytesSync() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readBytesSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytesSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -462,7 +462,7 @@ static jsval_t builtin_fs_readBytesSync(struct js *js, jsval_t *args, int nargs)
 static jsval_t builtin_fs_readFile(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readFile() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readFile() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readFile() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -495,7 +495,7 @@ static jsval_t builtin_fs_readFile(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_readBytes(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readBytes() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readBytes() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytes() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -528,8 +528,8 @@ static jsval_t builtin_fs_readBytes(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_writeFileSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writeFileSync() requires path and data arguments");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "writeFileSync() path must be a string");
-  if (js_type(args[1]) != JS_STR) return js_mkerr(js, "writeFileSync() data must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFileSync() path must be a string");
+  if (vtype(args[1]) != T_STR) return js_mkerr(js, "writeFileSync() data must be a string");
   
   size_t path_len, data_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -561,8 +561,8 @@ static jsval_t builtin_fs_writeFileSync(struct js *js, jsval_t *args, int nargs)
 static jsval_t builtin_fs_copyFileSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "copyFileSync() requires src and dest arguments");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "copyFileSync() src must be a string");
-  if (js_type(args[1]) != JS_STR) return js_mkerr(js, "copyFileSync() dest must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "copyFileSync() src must be a string");
+  if (vtype(args[1]) != T_STR) return js_mkerr(js, "copyFileSync() dest must be a string");
   
   size_t src_len, dest_len;
   char *src = js_getstr(js, args[0], &src_len);
@@ -618,8 +618,8 @@ static jsval_t builtin_fs_copyFileSync(struct js *js, jsval_t *args, int nargs)
 static jsval_t builtin_fs_renameSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "renameSync() requires oldPath and newPath arguments");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "renameSync() oldPath must be a string");
-  if (js_type(args[1]) != JS_STR) return js_mkerr(js, "renameSync() newPath must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "renameSync() oldPath must be a string");
+  if (vtype(args[1]) != T_STR) return js_mkerr(js, "renameSync() newPath must be a string");
   
   size_t old_len, new_len;
   char *old_path = js_getstr(js, args[0], &old_len);
@@ -651,8 +651,8 @@ static jsval_t builtin_fs_renameSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_appendFileSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "appendFileSync() requires path and data arguments");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "appendFileSync() path must be a string");
-  if (js_type(args[1]) != JS_STR) return js_mkerr(js, "appendFileSync() data must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "appendFileSync() path must be a string");
+  if (vtype(args[1]) != T_STR) return js_mkerr(js, "appendFileSync() data must be a string");
   
   size_t path_len, data_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -684,8 +684,8 @@ static jsval_t builtin_fs_appendFileSync(struct js *js, jsval_t *args, int nargs
 static jsval_t builtin_fs_writeFile(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkerr(js, "writeFile() requires path and data arguments");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "writeFile() path must be a string");
-  if (js_type(args[1]) != JS_STR) return js_mkerr(js, "writeFile() data must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFile() path must be a string");
+  if (vtype(args[1]) != T_STR) return js_mkerr(js, "writeFile() data must be a string");
   
   size_t path_len, data_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -729,7 +729,7 @@ static jsval_t builtin_fs_writeFile(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_unlinkSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "unlinkSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "unlinkSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlinkSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -753,7 +753,7 @@ static jsval_t builtin_fs_unlinkSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_unlink(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "unlink() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "unlink() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlink() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -786,7 +786,7 @@ static jsval_t builtin_fs_unlink(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_mkdirSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "mkdirSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "mkdirSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdirSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -797,15 +797,15 @@ static jsval_t builtin_fs_mkdirSync(struct js *js, jsval_t *args, int nargs) {
   
   if (nargs < 2) goto do_mkdir;
   
-  switch (js_type(args[1])) {
-    case JS_NUM:
+  switch (vtype(args[1])) {
+    case T_NUM:
       mode = (int)js_getnum(args[1]);
       break;
-    case JS_OBJ: {
+    case T_OBJ: {
       jsval_t opt = args[1];
-      recursive = js_type(js_get(js, opt, "recursive")) == JS_TRUE;
+      recursive = js_get(js, opt, "recursive") == js_true;
       jsval_t mode_val = js_get(js, opt, "mode");
-      if (js_type(mode_val) == JS_NUM) mode = (int)js_getnum(mode_val);
+      if (vtype(mode_val) == T_NUM) mode = (int)js_getnum(mode_val);
       break;
     }
   }
@@ -838,14 +838,14 @@ do_mkdir:
 static jsval_t builtin_fs_mkdir(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "mkdir() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "mkdir() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdir() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
   if (!path) return js_mkerr(js, "Failed to get path string");
   
   int mode = 0755;
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     mode = (int)js_getnum(args[1]);
   }
   
@@ -876,7 +876,7 @@ static jsval_t builtin_fs_mkdir(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_rmdirSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "rmdirSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "rmdirSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdirSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -904,7 +904,7 @@ static jsval_t builtin_fs_rmdirSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_rmdir(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "rmdir() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "rmdir() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdir() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -938,7 +938,7 @@ static jsval_t stat_isFile(struct js *js, jsval_t *args, int nargs) {
   jsval_t this = js_getthis(js);
   jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
   
-  if (js_type(mode_val) != JS_NUM) return js_mkfalse();
+  if (vtype(mode_val) != T_NUM) return js_mkfalse();
   mode_t mode = (mode_t)js_getnum(mode_val);
   
   return S_ISREG(mode) ? js_mktrue() : js_mkfalse();
@@ -948,7 +948,7 @@ static jsval_t stat_isDirectory(struct js *js, jsval_t *args, int nargs) {
   jsval_t this = js_getthis(js);
   jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
   
-  if (js_type(mode_val) != JS_NUM) return js_mkfalse();
+  if (vtype(mode_val) != T_NUM) return js_mkfalse();
   mode_t mode = (mode_t)js_getnum(mode_val);
   
   return S_ISDIR(mode) ? js_mktrue() : js_mkfalse();
@@ -958,7 +958,7 @@ static jsval_t stat_isSymbolicLink(struct js *js, jsval_t *args, int nargs) {
   jsval_t this = js_getthis(js);
   jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
   
-  if (js_type(mode_val) != JS_NUM) return js_mkfalse();
+  if (vtype(mode_val) != T_NUM) return js_mkfalse();
   mode_t mode = (mode_t)js_getnum(mode_val);
   
   return S_ISLNK(mode) ? js_mktrue() : js_mkfalse();
@@ -967,7 +967,7 @@ static jsval_t stat_isSymbolicLink(struct js *js, jsval_t *args, int nargs) {
 static jsval_t create_stats_object(struct js *js, struct stat *st) {
   jsval_t stat_obj = js_mkobj(js);
   jsval_t proto = js_get_ctor_proto(js, "Stats", 5);
-  if (js_type(proto) == JS_OBJ) js_set_proto(js, stat_obj, proto);
+  if (vtype(proto) == T_OBJ) js_set_proto(js, stat_obj, proto);
   
   js_set_slot(js, stat_obj, SLOT_DATA, js_mknum((double)st->st_mode));
   js_set(js, stat_obj, "size", js_mknum((double)st->st_size));
@@ -1002,7 +1002,7 @@ static const char *errno_to_code(int err_num) {
 static jsval_t builtin_fs_statSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "statSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "statSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "statSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -1027,7 +1027,7 @@ static jsval_t builtin_fs_statSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_stat(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "stat() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "stat() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "stat() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -1060,7 +1060,7 @@ static jsval_t builtin_fs_stat(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_existsSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "existsSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "existsSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "existsSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -1079,7 +1079,7 @@ static jsval_t builtin_fs_existsSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_exists(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "exists() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "exists() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "exists() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -1112,14 +1112,14 @@ static jsval_t builtin_fs_exists(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_accessSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "accessSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "accessSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "accessSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
   if (!path) return js_mkerr(js, "Failed to get path string");
   
   int mode = F_OK;
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     mode = (int)js_getnum(args[1]);
   }
   
@@ -1140,14 +1140,14 @@ static jsval_t builtin_fs_accessSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_access(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "access() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "access() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "access() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
   if (!path) return js_mkerr(js, "Failed to get path string");
   
   int mode = F_OK;
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     mode = (int)js_getnum(args[1]);
   }
   
@@ -1178,7 +1178,7 @@ static jsval_t builtin_fs_access(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_readdirSync(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readdirSync() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readdirSync() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdirSync() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -1212,7 +1212,7 @@ static jsval_t builtin_fs_readdirSync(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_fs_readdir(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "readdir() requires a path argument");
   
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readdir() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdir() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
diff --git a/src/modules/io.c b/src/modules/io.c
index c83a4bd..523c77c 100644
--- a/src/modules/io.c
+++ b/src/modules/io.c
@@ -280,7 +280,7 @@ void console_print(struct js *js, jsval_t *args, int nargs, const char *color, F
     const char *space = i == 0 ? "" : " ";
     io_puts(space, stream);
     
-    if (js_type(args[i]) == JS_STR) {
+    if (vtype(args[i]) == T_STR) {
       char *str = js_getstr(js, args[i], NULL);
       io_print(str, stream);
     } else {
@@ -324,7 +324,7 @@ static jsval_t js_console_assert(struct js *js, jsval_t *args, int nargs) {
       const char *space = i == 1 ? "" : " ";
       io_puts(space, stderr);
       
-      if (js_type(args[i]) == JS_STR) {
+      if (vtype(args[i]) == T_STR) {
         char *str = js_getstr(js, args[i], NULL);
         io_print(str, stderr);
       } else {
@@ -341,7 +341,7 @@ static jsval_t js_console_assert(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t js_console_trace(struct js *js, jsval_t *args, int nargs) {
   fprintf(stderr, "Console Trace");
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     fprintf(stderr, ": ");
     char *str = js_getstr(js, args[0], NULL);
     fprintf(stderr, "%s", str);
@@ -378,7 +378,7 @@ static int console_timer_count = 0;
 
 static jsval_t js_console_time(struct js *js, jsval_t *args, int nargs) {
   const char *label = "default";
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     label = js_getstr(js, args[0], NULL);
   }
   
@@ -400,7 +400,7 @@ static jsval_t js_console_time(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t js_console_timeEnd(struct js *js, jsval_t *args, int nargs) {
   const char *label = "default";
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     label = js_getstr(js, args[0], NULL);
   }
   
@@ -528,7 +528,7 @@ static void inspect_value(struct js *js, jsval_t val, FILE *stream, int depth, i
   
   if (t == T_UNDEF) { fprintf(stream, "undefined"); return; }
   if (t == T_NULL)  { fprintf(stream, "null"); return; }
-  if (t == T_BOOL)  { fprintf(stream, js_getbool(val) ? "true" : "false"); return; }
+  if (t == T_BOOL)  { fprintf(stream, val == js_true ? "true" : "false"); return; }
   if (t == T_NUM)   { fprintf(stream, "%g", js_getnum(val)); return; }
   if (t == T_ERR)   { fprintf(stream, "[Error]"); return; }
   
@@ -632,7 +632,7 @@ static void inspect_object_full(struct js *js, jsval_t obj, FILE *stream, int de
   jsval_t proto = js_get_proto(js, obj);
   inspect_print_indent(stream, inner_depth);
   fprintf(stream, "[[Prototype]]: ");
-  if (js_type(proto) == JS_NULL) {
+  if (vtype(proto) == T_NULL) {
     fprintf(stream, "null\n");
   } else {
     fprintf(stream, "\n");
diff --git a/src/modules/json.c b/src/modules/json.c
index a7d573b..348f82e 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 "modules/json.h"
 #include "modules/symbol.h"
 
@@ -108,7 +109,7 @@ 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) {
   if (is_internal_prop(key, (jsoff_t)key_len)) return 1;
-  if (js_type(value) != JS_OBJ) return 0;
+  if (vtype(value) != T_OBJ) return 0;
   return vtype(js_get_slot(js, value, SLOT_CODE)) == T_CFUNC;
 }
 
@@ -151,19 +152,19 @@ static inline int key_matches(const char *a, size_t a_len, const char *b, size_t
 }
 
 static int is_key_in_replacer_arr(struct js *js, json_cycle_ctx *ctx, const char *key, size_t key_len) {
-  if (js_type(ctx->replacer_arr) != JS_OBJ) return 1;
+  if (vtype(ctx->replacer_arr) != T_OBJ) return 1;
   
   for (int i = 0; i < ctx->replacer_arr_len; i++) {
     char idxstr[32];
     snprintf(idxstr, sizeof(idxstr), "%d", i);
     jsval_t item = js_get(js, ctx->replacer_arr, idxstr);
-    int type = js_type(item);
+    int type = vtype(item);
     
-    if (type == JS_STR) {
+    if (type == T_STR) {
       size_t item_len;
       char *item_str = js_getstr(js, item, &item_len);
       if (key_matches(item_str, item_len, key, key_len)) return 1;
-    } else if (type == JS_NUM) {
+    } else if (type == T_NUM) {
       char numstr[32];
       snprintf(numstr, sizeof(numstr), "%.0f", js_getnum(item));
       if (key_matches(numstr, strlen(numstr), key, key_len)) return 1;
@@ -175,26 +176,26 @@ static int is_key_in_replacer_arr(struct js *js, json_cycle_ctx *ctx, const char
 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_impl(struct js *js, yyjson_mut_doc *doc, jsval_t val, json_cycle_ctx *ctx, int in_array) {
-  int type = js_type(val);
+  int type = vtype(val);
   yyjson_mut_val *result = NULL;
   
-  if (type == JS_OBJ) {
+  if (type == T_OBJ) {
     jsval_t toJSON = js_get(js, val, "toJSON");
-    if (js_type(toJSON) == JS_FUNC) {
+    if (vtype(toJSON) == T_FUNC) {
       jsval_t r = js_call(js, toJSON, &val, 1);
-      if (js_type(r) == JS_ERR) { ctx->has_cycle = 1; return NULL; }
+      if (vtype(r) == T_ERR) { ctx->has_cycle = 1; return NULL; }
       return jsval_to_yyjson_impl(js, doc, r, ctx, in_array);
     }
   }
   
   switch (type) {
-    case JS_UNDEF:  return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE;
-    case JS_NULL:   return yyjson_mut_null(doc);
-    case JS_TRUE:   return yyjson_mut_bool(doc, true);
-    case JS_FALSE:  return yyjson_mut_bool(doc, false);
-    case JS_FUNC:   return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE;
+    case T_NULL:   return yyjson_mut_null(doc);
+    case T_BOOL:   return yyjson_mut_bool(doc, val == js_true);
+    
+    case T_UNDEF:  return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE;
+    case T_FUNC:   return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE;
     
-    case JS_NUM: {
+    case T_NUM: {
       double num = js_getnum(val);
       if (isnan(num) || isinf(num)) return yyjson_mut_null(doc);
       if (
@@ -205,13 +206,13 @@ static yyjson_mut_val *jsval_to_yyjson_impl(struct js *js, yyjson_mut_doc *doc,
       return yyjson_mut_real(doc, num);
     }
     
-    case JS_STR: {
+    case T_STR: {
       size_t len;
       char *str = js_getstr(js, val, &len);
       return yyjson_mut_strncpy(doc, str, len);
     }
     
-    case JS_OBJ: break;
+    case T_OBJ: break;
     default: return yyjson_mut_null(doc);
   }
   
@@ -220,7 +221,7 @@ static yyjson_mut_val *jsval_to_yyjson_impl(struct js *js, yyjson_mut_doc *doc,
   
   jsval_t length_val = js_get(js, val, "length");
   
-  if (js_type(length_val) == JS_NUM) {
+  if (vtype(length_val) == T_NUM) {
     yyjson_mut_val *arr = yyjson_mut_arr(doc);
     int length = (int)js_getnum(length_val);
     
@@ -254,8 +255,8 @@ static yyjson_mut_val *jsval_to_yyjson_impl(struct js *js, yyjson_mut_doc *doc,
       free(p->key); continue;
     }
     
-    int ptype = js_type(p->value);
-    if (ptype == JS_UNDEF || ptype == JS_FUNC) { free(p->key); continue; }
+    int ptype = vtype(p->value);
+    if (ptype == T_UNDEF || ptype == T_FUNC) { free(p->key); continue; }
     
     yyjson_mut_val *jval = jsval_to_yyjson_with_key(js, doc, p->key, p->value, ctx, 0);
     if (ctx->has_cycle) { free_props(props, 0, i); ctx->holder = saved_holder; goto done; }
@@ -275,14 +276,14 @@ done:
 }
 
 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) {
-  if (js_type(ctx->replacer_func) != JS_FUNC)
+  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);
   
-  if (js_type(transformed) == JS_ERR) {
+  if (vtype(transformed) == T_ERR) {
     ctx->has_cycle = 1;
     return NULL;
   }
@@ -297,15 +298,15 @@ static yyjson_mut_val *jsval_to_yyjson(struct js *js, yyjson_mut_doc *doc, jsval
 static jsval_t apply_reviver(struct js *js, jsval_t holder, const char *key, jsval_t reviver) {
   jsval_t val = js_get(js, holder, key);
   
-  if (js_type(val) == JS_OBJ) {
+  if (vtype(val) == T_OBJ) {
     jsval_t len_val = js_get(js, val, "length");
-    if (js_type(len_val) == JS_NUM) {
+    if (vtype(len_val) == T_NUM) {
       int length = (int)js_getnum(len_val);
       for (int i = 0; i < length; i++) {
         char idxstr[32];
         snprintf(idxstr, sizeof(idxstr), "%d", i);
         jsval_t new_elem = apply_reviver(js, val, idxstr, reviver);
-        if (js_type(new_elem) == JS_UNDEF) js_del(js, val, idxstr);
+        if (vtype(new_elem) == T_UNDEF) js_del(js, val, idxstr);
         else js_set(js, val, idxstr, new_elem);
       }
     } else {
@@ -332,7 +333,7 @@ static jsval_t apply_reviver(struct js *js, jsval_t holder, const char *key, jsv
         size_t klen;
         char *kstr = js_getstr(js, key_str, &klen);
         jsval_t new_val = apply_reviver(js, val, kstr, reviver);
-        if (js_type(new_val) == JS_UNDEF) js_del(js, val, kstr);
+        if (vtype(new_val) == T_UNDEF) js_del(js, val, kstr);
         else js_set(js, val, kstr, new_val);
       }
     }
@@ -346,7 +347,7 @@ static jsval_t apply_reviver(struct js *js, jsval_t holder, const char *key, jsv
 
 jsval_t js_json_parse(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "JSON.parse() requires at least 1 argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "JSON.parse() argument must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "JSON.parse() argument must be a string");
   
   size_t len;
   char *json_str = js_getstr(js, args[0], &len);
@@ -357,7 +358,7 @@ jsval_t js_json_parse(struct js *js, jsval_t *args, int nargs) {
   jsval_t result = yyjson_to_jsval(js, yyjson_doc_get_root(doc));
   yyjson_doc_free(doc);
   
-  if (nargs >= 2 && js_type(args[1]) == JS_FUNC) {
+  if (nargs >= 2 && vtype(args[1]) == T_FUNC) {
     jsval_t reviver = args[1];
     jsval_t root = js_mkobj(js);
     js_set(js, root, "", result);
@@ -370,9 +371,9 @@ jsval_t js_json_parse(struct js *js, jsval_t *args, int nargs) {
 static yyjson_write_flag get_write_flags(jsval_t *args, int nargs) {
   if (nargs < 3) return 0;
   
-  int type = js_type(args[2]);
-  if (type == JS_UNDEF || type == JS_NULL) return 0;
-  if (type != JS_NUM) return YYJSON_WRITE_PRETTY;
+  int type = vtype(args[2]);
+  if (type == T_UNDEF || type == T_NULL) return 0;
+  if (type != T_NUM) return YYJSON_WRITE_PRETTY;
   
   int indent = (int)js_getnum(args[2]);
   if (indent <= 0) return 0;
@@ -390,8 +391,8 @@ jsval_t js_json_stringify(struct js *js, jsval_t *args, int nargs) {
   
   if (nargs < 1) return js_mkerr(js, "JSON.stringify() requires at least 1 argument");
   
-  int top_type = js_type(args[0]);
-  if (top_type == JS_UNDEF || top_type == JS_FUNC || top_type == JS_SYMBOL)
+  int top_type = vtype(args[0]);
+  if (top_type == T_UNDEF || top_type == T_FUNC || top_type == T_SYMBOL)
     return js_mkundef();
   
   ctx.js = js;
@@ -402,13 +403,13 @@ jsval_t js_json_stringify(struct js *js, jsval_t *args, int nargs) {
   
   if (nargs >= 2) {
     jsval_t replacer = args[1];
-    int replacer_type = js_type(replacer);
+    int replacer_type = vtype(replacer);
     
-    if (replacer_type == JS_FUNC) {
+    if (replacer_type == T_FUNC) {
       ctx.replacer_func = replacer;
-    } else if (replacer_type == JS_OBJ) {
+    } else if (replacer_type == T_OBJ) {
       jsval_t len_val = js_get(js, replacer, "length");
-      if (js_type(len_val) == JS_NUM) {
+      if (vtype(len_val) == T_NUM) {
         ctx.replacer_arr = replacer;
         ctx.replacer_arr_len = (int)js_getnum(len_val);
       }
diff --git a/src/modules/localstorage.c b/src/modules/localstorage.c
index 25ce180..0676b9e 100644
--- a/src/modules/localstorage.c
+++ b/src/modules/localstorage.c
@@ -8,6 +8,7 @@
 #include "errors.h"
 #include "arena.h"
 #include "runtime.h"
+#include "internal.h"
 
 #include "modules/symbol.h"
 #include "modules/localstorage.h"
@@ -221,7 +222,7 @@ static jsval_t js_localstorage_key(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr(js, "Failed to execute 'key' on 'Storage': 1 argument required");
   }
   
-  if (js_type(args[0]) != JS_NUM) {
+  if (vtype(args[0]) != T_NUM) {
     return js_mknull();
   }
   
diff --git a/src/modules/navigator.c b/src/modules/navigator.c
index e332d92..5eef073 100644
--- a/src/modules/navigator.c
+++ b/src/modules/navigator.c
@@ -15,6 +15,7 @@
 #include "errors.h"
 #include "config.h"
 #include "runtime.h"
+#include "internal.h"
 #include "modules/navigator.h"
 #include "modules/symbol.h"
 
@@ -159,17 +160,17 @@ static void execute_lock_callback(struct js *js, const char *name, lock_mode_t m
   
   jsval_t result = js_call(js, callback, &lock_obj, 1);
   
-  if (js_type(result) == JS_ERR) {
+  if (vtype(result) == T_ERR) {
     release_lock(name);
     js_reject_promise(js, outer_promise, result);
     process_pending_requests(js);
     return;
   }
   
-  if (js_type(result) == JS_PROMISE) {
+  if (vtype(result) == T_PROMISE) {
     jsval_t then_fn = js_get(js, result, "then");
     
-    if (js_type(then_fn) == JS_FUNC) {
+    if (vtype(then_fn) == T_FUNC) {
       jsval_t name_str = js_mkstr(js, name, strlen(name));
       
       jsval_t on_resolve = js_mkfun(lock_then_handler);
@@ -247,20 +248,19 @@ static jsval_t locks_request(struct js *js, jsval_t *args, int nargs) {
     options = args[1];
     callback = args[2];
     
-    if (js_type(options) == JS_OBJ) {
+    if (vtype(options) == T_OBJ) {
       jsval_t mode_val = js_get(js, options, "mode");
-      if (js_type(mode_val) == JS_STR) {
+      if (vtype(mode_val) == T_STR) {
         size_t mode_len;
         char *mode_str = js_getstr(js, mode_val, &mode_len);
         if (mode_str && strcmp(mode_str, "shared") == 0) mode = LOCK_MODE_SHARED;
       }
       
-      jsval_t if_avail_val = js_get(js, options, "ifAvailable");
-      if (js_type(if_avail_val) == JS_TRUE) if_available = true;
+      if (js_get(js, options, "ifAvailable") == js_true) if_available = true;
     }
   }
   
-  if (js_type(callback) != JS_FUNC) {
+  if (vtype(callback) != T_FUNC) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Callback must be a function");
   }
   
@@ -270,9 +270,9 @@ static jsval_t locks_request(struct js *js, jsval_t *args, int nargs) {
     jsval_t null_val = js_mknull();
     jsval_t result = js_call(js, callback, &null_val, 1);
     
-    if (js_type(result) == JS_PROMISE) {
+    if (vtype(result) == T_PROMISE) {
       jsval_t then_fn = js_get(js, result, "then");
-      if (js_type(then_fn) == JS_FUNC) {
+      if (vtype(then_fn) == T_FUNC) {
         jsval_t on_resolve = js_mkfun(lock_then_handler);
         js_set(js, on_resolve, "_lockName", js_mkstr(js, "", 0));
         js_set(js, on_resolve, "_outerPromise", promise);
diff --git a/src/modules/observable.c b/src/modules/observable.c
index 1233ebe..b54be2f 100644
--- a/src/modules/observable.c
+++ b/src/modules/observable.c
@@ -16,18 +16,18 @@ static inline bool is_callable(jsval_t val) {
 
 static bool subscription_closed(struct js *js, jsval_t subscription) {
   jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER);
-  return js_type(observer) == JS_UNDEF;
+  return vtype(observer) == T_UNDEF;
 }
 
 static void cleanup_subscription(struct js *js, jsval_t subscription) {
   jsval_t cleanup = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP);
-  if (js_type(cleanup) == JS_UNDEF) return;
+  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);
   
-  if (js_type(result) == JS_ERR) fprintf(stderr, "Error in subscription cleanup: %s\n", js_str(js, result));
+  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) {
@@ -42,7 +42,7 @@ static jsval_t js_subscription_get_closed(struct js *js, jsval_t *args, int narg
   (void)args; (void)nargs;
   jsval_t subscription = js_getthis(js);
   
-  if (js_type(subscription) != JS_OBJ) return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.closed getter called on non-object");
+  if (vtype(subscription) != T_OBJ) return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.closed getter called on non-object");
   return subscription_closed(js, subscription) ? js_mktrue() : js_mkfalse();
 }
 
@@ -50,7 +50,7 @@ static jsval_t js_subscription_unsubscribe(struct js *js, jsval_t *args, int nar
   (void)args; (void)nargs;
   jsval_t subscription = js_getthis(js);
   
-  if (js_type(subscription) != JS_OBJ) {
+  if (vtype(subscription) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.unsubscribe called on non-object");
   }
   
@@ -72,12 +72,12 @@ static jsval_t js_subobs_get_closed(struct js *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t O = js_getthis(js);
   
-  if (js_type(O) != JS_OBJ) {
+  if (vtype(O) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.closed getter called on non-object");
   }
   
   jsval_t subscription = js_get_slot(js, O, SLOT_DATA);
-  if (js_type(subscription) != JS_OBJ) {
+  if (vtype(subscription) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver");
   }
   
@@ -87,26 +87,26 @@ static jsval_t js_subobs_get_closed(struct js *js, jsval_t *args, int nargs) {
 static jsval_t js_subobs_next(struct js *js, jsval_t *args, int nargs) {
   jsval_t O = js_getthis(js);
   
-  if (js_type(O) != JS_OBJ) {
+  if (vtype(O) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.next called on non-object");
   }
   
   jsval_t subscription = js_get_slot(js, O, SLOT_DATA);
-  if (js_type(subscription) != JS_OBJ) {
+  if (vtype(subscription) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver");
   }
   
   if (subscription_closed(js, subscription)) return js_mkundef();
   
   jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER);
-  if (js_type(observer) != JS_OBJ) return js_mkundef();
+  if (vtype(observer) != T_OBJ) return js_mkundef();
   
   jsval_t nextMethod = js_get(js, observer, "next");
   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);
-    if (js_type(result) == JS_ERR) fprintf(stderr, "Error in observer.next: %s\n", js_str(js, result));
+    if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.next: %s\n", js_str(js, result));
   }
   
   return js_mkundef();
@@ -115,12 +115,12 @@ static jsval_t js_subobs_next(struct js *js, jsval_t *args, int nargs) {
 static jsval_t js_subobs_error(struct js *js, jsval_t *args, int nargs) {
   jsval_t O = js_getthis(js);
   
-  if (js_type(O) != JS_OBJ) {
+  if (vtype(O) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.error called on non-object");
   }
   
   jsval_t subscription = js_get_slot(js, O, SLOT_DATA);
-  if (js_type(subscription) != JS_OBJ) {
+  if (vtype(subscription) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver");
   }
   
@@ -129,13 +129,13 @@ static jsval_t js_subobs_error(struct js *js, jsval_t *args, int nargs) {
   jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER);
   js_set_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER, js_mkundef());
   
-  if (js_type(observer) == JS_OBJ) {
+  if (vtype(observer) == T_OBJ) {
     jsval_t errorMethod = js_get(js, observer, "error");
     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);
-      if (js_type(result) == JS_ERR) fprintf(stderr, "Error in observer.error: %s\n", js_str(js, result));
+      if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.error: %s\n", js_str(js, result));
     }
   }
   
@@ -147,12 +147,12 @@ static jsval_t js_subobs_complete(struct js *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   jsval_t O = js_getthis(js);
   
-  if (js_type(O) != JS_OBJ) {
+  if (vtype(O) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.complete called on non-object");
   }
   
   jsval_t subscription = js_get_slot(js, O, SLOT_DATA);
-  if (js_type(subscription) != JS_OBJ) {
+  if (vtype(subscription) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver");
   }
   
@@ -161,11 +161,11 @@ static jsval_t js_subobs_complete(struct js *js, jsval_t *args, int nargs) {
   jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER);
   js_set_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER, js_mkundef());
   
-  if (js_type(observer) == JS_OBJ) {
+  if (vtype(observer) == T_OBJ) {
     jsval_t completeMethod = js_get(js, observer, "complete");
     if (is_callable(completeMethod)) {
       jsval_t result = js_call_with_this(js, completeMethod, observer, NULL, 0);
-      if (js_type(result) == JS_ERR) fprintf(stderr, "Error in observer.complete: %s\n", js_str(js, result));
+      if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.complete: %s\n", js_str(js, result));
     }
   }
   
@@ -193,7 +193,7 @@ static jsval_t js_cleanup_fn(struct js *js, jsval_t *args, int nargs) {
   jsval_t F = js_getcurrentfunc(js);
   jsval_t subscription = js_get_slot(js, F, SLOT_DATA);
   
-  if (js_type(subscription) != JS_OBJ) return js_mkundef();
+  if (vtype(subscription) != T_OBJ) return js_mkundef();
   
   jsval_t unsubscribe = js_get(js, subscription, "unsubscribe");
   if (is_callable(unsubscribe)) {
@@ -207,13 +207,13 @@ static jsval_t execute_subscriber(struct js *js, jsval_t subscriber, jsval_t obs
   jsval_t call_args[1] = {observer};
   jsval_t subscriberResult = js_call(js, subscriber, call_args, 1);
   
-  if (js_type(subscriberResult) == JS_ERR) return subscriberResult;
-  if (js_type(subscriberResult) == JS_NULL || js_type(subscriberResult) == JS_UNDEF) return js_mkundef();
+  if (vtype(subscriberResult) == T_ERR) return subscriberResult;
+  if (vtype(subscriberResult) == T_NULL || vtype(subscriberResult) == T_UNDEF) return js_mkundef();
   if (is_callable(subscriberResult)) return subscriberResult;
   
-  if (js_type(subscriberResult) == JS_OBJ) {
+  if (vtype(subscriberResult) == T_OBJ) {
     jsval_t result = js_get(js, subscriberResult, "unsubscribe");
-    if (js_type(result) == JS_UNDEF) {
+    if (vtype(result) == T_UNDEF) {
       return js_mkerr_typed(js, JS_ERR_TYPE, "Subscriber return value must have an unsubscribe method");
     }
     
@@ -229,7 +229,7 @@ static jsval_t execute_subscriber(struct js *js, jsval_t subscriber, jsval_t obs
 static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs) {
   jsval_t O = js_getthis(js);
   
-  if (js_type(O) != JS_OBJ) {
+  if (vtype(O) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Observable.prototype.subscribe called on non-object");
   }
   
@@ -249,7 +249,7 @@ static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs)
     js_set(js, observer, "next", nextCallback);
     js_set(js, observer, "error", errorCallback);
     js_set(js, observer, "complete", completeCallback);
-  } else if (nargs > 0 && js_type(args[0]) == JS_OBJ) {
+  } else if (nargs > 0 && vtype(args[0]) == T_OBJ) {
     observer = args[0];
   } else observer = js_mkobj(js);
   
@@ -260,7 +260,7 @@ static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs)
   if (is_callable(start)) {
     jsval_t start_args[1] = {subscription};
     jsval_t result = js_call_with_this(js, start, observer, start_args, 1);
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       fprintf(stderr, "Error in observer.start: %s\n", js_str(js, result));
     }
     if (subscription_closed(js, subscription)) return subscription;
@@ -269,7 +269,7 @@ static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs)
   jsval_t subscriptionObserver = create_subscription_observer(js, subscription);
   jsval_t subscriberResult = execute_subscriber(js, subscriber, subscriptionObserver);
   
-  if (js_type(subscriberResult) == JS_ERR) {
+  if (vtype(subscriberResult) == T_ERR) {
     jsval_t thrown_error = js->thrown_value;
     js->thrown_value = js_mkundef();
     js->flags &= ~F_THROW;
@@ -318,7 +318,7 @@ static jsval_t js_of_subscriber(struct js *js, jsval_t *args, int nargs) {
   jsval_t subscription = js_get_slot(js, observer, SLOT_DATA);
   
   jsval_t length_val = js_get(js, items, "length");
-  int length = (js_type(length_val) == JS_NUM) ? (int)js_getnum(length_val) : 0;
+  int length = (vtype(length_val) == T_NUM) ? (int)js_getnum(length_val) : 0;
   
   for (int i = 0; i < length; i++) {
     char key[16];
@@ -331,7 +331,7 @@ static jsval_t js_of_subscriber(struct js *js, jsval_t *args, int nargs) {
       js_call_with_this(js, next, observer, next_args, 1);
     }
     
-    if (js_type(subscription) == JS_OBJ && subscription_closed(js, subscription)) return js_mkundef();
+    if (vtype(subscription) == T_OBJ && subscription_closed(js, subscription)) return js_mkundef();
   }
   
   jsval_t complete = js_get(js, observer, "complete");
@@ -354,7 +354,7 @@ static jsval_t js_from_delegating(struct js *js, jsval_t *args, int nargs) {
   jsval_t F = js_getcurrentfunc(js);
   
   jsval_t observable = js_get_slot(js, F, SLOT_DATA);
-  if (js_type(observable) != JS_OBJ) return js_mkundef();
+  if (vtype(observable) != T_OBJ) return js_mkundef();
   
   jsval_t subscribe = js_get(js, observable, "subscribe");
   if (is_callable(subscribe)) {
@@ -381,7 +381,7 @@ static jsval_t js_from_iteration(struct js *js, jsval_t *args, int nargs) {
   }
   
   jsval_t iterator = js_call_with_this(js, iteratorMethod, iterable, NULL, 0);
-  if (js_type(iterator) != JS_OBJ) {
+  if (vtype(iterator) != T_OBJ) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Iterator must return an object");
   }
   
@@ -392,7 +392,7 @@ 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);
-    if (js_type(next) == JS_ERR) return next;
+    if (vtype(next) == T_ERR) return next;
     
     jsval_t done = js_get(js, next, "done");
     if (js_truthy(js, done)) {
@@ -408,7 +408,7 @@ static jsval_t js_from_iteration(struct js *js, jsval_t *args, int nargs) {
       js_call_with_this(js, obs_next, observer, next_args, 1);
     }
     
-    if (js_type(subscription) == JS_OBJ && subscription_closed(js, subscription)) {
+    if (vtype(subscription) == T_OBJ && subscription_closed(js, subscription)) {
       jsval_t returnMethod = js_get(js, iterator, "return");
       if (is_callable(returnMethod)) js_call_with_this(js, returnMethod, iterator, NULL, 0);
       return js_mkundef();
@@ -420,7 +420,7 @@ static jsval_t js_observable_from(struct js *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];
   
-  if (js_type(x) == JS_NULL || js_type(x) == JS_UNDEF) {
+  if (vtype(x) == T_NULL || vtype(x) == T_UNDEF) {
     return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert null or undefined to observable");
   }
   
@@ -429,7 +429,7 @@ static jsval_t js_observable_from(struct js *js, jsval_t *args, int nargs) {
   if (is_callable(observableMethod)) {
     jsval_t observable = js_call_with_this(js, observableMethod, x, NULL, 0);
     
-    if (js_type(observable) != JS_OBJ) {
+    if (vtype(observable) != T_OBJ) {
       return js_mkerr_typed(js, JS_ERR_TYPE, "@@observable must return an object");
     }
     
diff --git a/src/modules/os.c b/src/modules/os.c
index 050c83a..faf5b3e 100644
--- a/src/modules/os.c
+++ b/src/modules/os.c
@@ -35,6 +35,7 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "internal.h"
 #include "modules/symbol.h"
 
 #ifdef _WIN32
@@ -522,7 +523,7 @@ static jsval_t os_networkInterfaces(struct js *js, jsval_t *args, int nargs) {
   
   for (pCurrAddresses = pAddresses; pCurrAddresses; pCurrAddresses = pCurrAddresses->Next) {
     jsval_t iface_arr = js_get(js, result, pCurrAddresses->AdapterName);
-    if (js_type(iface_arr) != JS_OBJ) {
+    if (vtype(iface_arr) != T_OBJ) {
       iface_arr = js_mkarr(js);
       js_set(js, result, pCurrAddresses->AdapterName, iface_arr);
     }
@@ -700,16 +701,16 @@ static void apply_mac_to_iface(struct js *js, jsval_t result, const char *name,
   format_mac_address(mac_str, sizeof(mac_str), mac_bytes);
   
   jsval_t iface_arr = js_get(js, result, name);
-  if (js_type(iface_arr) != JS_OBJ) return;
+  if (vtype(iface_arr) != T_OBJ) return;
   
   jsval_t len_val = js_get(js, iface_arr, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
   
   for (int i = 0; i < len; i++) {
     char idx[16];
     snprintf(idx, sizeof(idx), "%d", i);
     jsval_t entry = js_get(js, iface_arr, idx);
-    if (js_type(entry) == JS_OBJ)
+    if (vtype(entry) == T_OBJ)
       js_set(js, entry, "mac", js_mkstr(js, mac_str, strlen(mac_str)));
   }
 }
@@ -728,7 +729,7 @@ static jsval_t os_networkInterfaces(struct js *js, jsval_t *args, int nargs) {
     if (family != AF_INET && family != AF_INET6) continue;
     
     jsval_t iface_arr = js_get(js, result, ifa->ifa_name);
-    if (js_type(iface_arr) != JS_OBJ) {
+    if (vtype(iface_arr) != T_OBJ) {
       iface_arr = js_mkarr(js);
       js_set(js, result, ifa->ifa_name, iface_arr);
     }
@@ -779,7 +780,7 @@ static jsval_t os_userInfo(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t os_getPriority(struct js *js, jsval_t *args, int nargs) {
   int pid = 0;
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) {
+  if (nargs > 0 && vtype(args[0]) == T_NUM) {
     pid = (int)js_getnum(args[0]);
   }
   
@@ -796,12 +797,12 @@ static jsval_t os_setPriority(struct js *js, jsval_t *args, int nargs) {
   int priority = 0;
   
   if (nargs == 1) {
-    if (js_type(args[0]) != JS_NUM) {
+    if (vtype(args[0]) != T_NUM) {
       return js_mkerr_typed(js, JS_ERR_TYPE, "priority must be a number");
     }
     priority = (int)js_getnum(args[0]);
   } else if (nargs >= 2) {
-    if (js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_NUM) {
+    if (vtype(args[0]) != T_NUM || vtype(args[1]) != T_NUM) {
       return js_mkerr_typed(js, JS_ERR_TYPE, "pid and priority must be numbers");
     }
     pid = (int)js_getnum(args[0]);
diff --git a/src/modules/path.c b/src/modules/path.c
index 1f60745..bfb8f9f 100644
--- a/src/modules/path.c
+++ b/src/modules/path.c
@@ -6,6 +6,7 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "internal.h"
 #include "modules/symbol.h"
 
 #ifndef PATH_MAX
@@ -39,7 +40,7 @@ static char* normalize_separators(const char *path, size_t len) {
 
 static jsval_t builtin_path_basename(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "basename() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "basename() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "basename() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -49,7 +50,7 @@ static jsval_t builtin_path_basename(struct js *js, jsval_t *args, int nargs) {
   if (!path_copy) return js_mkerr(js, "Out of memory");
   char *base = basename(path_copy);
   
-  if (nargs >= 2 && js_type(args[1]) == JS_STR) {
+  if (nargs >= 2 && vtype(args[1]) == T_STR) {
     size_t ext_len;
     char *ext = js_getstr(js, args[1], &ext_len);
     
@@ -67,7 +68,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) {
   if (nargs < 1) return js_mkerr(js, "dirname() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "dirname() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "dirname() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -85,7 +86,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) {
   if (nargs < 1) return js_mkerr(js, "extname() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "extname() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "extname() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -193,7 +194,7 @@ fail:
 // path.normalize(path)
 static jsval_t builtin_path_normalize(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "normalize() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "normalize() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "normalize() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -224,7 +225,7 @@ static jsval_t builtin_path_join(struct js *js, jsval_t *args, int nargs) {
   int valid_segments = 0;
   
   for (int i = 0; i < nargs; i++) {
-    if (js_type(args[i]) == JS_STR) {
+    if (vtype(args[i]) == T_STR) {
       segments[valid_segments] = js_getstr(js, args[i], &lengths[valid_segments]);
       if (segments[valid_segments] && lengths[valid_segments] > 0) {
         total_len += lengths[valid_segments] + 1; // +1 for separator
@@ -289,7 +290,7 @@ static jsval_t builtin_path_resolve(struct js *js, jsval_t *args, int nargs) {
   if (!result) return js_mkerr(js, "Out of memory");
   
   for (int i = 0; i < nargs; i++) {
-    if (js_type(args[i]) != JS_STR) continue;
+    if (vtype(args[i]) != T_STR) continue;
     
     size_t seg_len;
     char *segment = js_getstr(js, args[i], &seg_len);
@@ -322,8 +323,8 @@ 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) {
   if (nargs < 2) return js_mkerr(js, "relative() requires from and to arguments");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "relative() from must be a string");
-  if (js_type(args[1]) != JS_STR) return js_mkerr(js, "relative() to must be a string");
+  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");
   
   size_t from_len, to_len;
   char *from = js_getstr(js, args[0], &from_len);
@@ -338,7 +339,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) {
   if (nargs < 1) return js_mkerr(js, "isAbsolute() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "isAbsolute() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "isAbsolute() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -356,7 +357,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) {
   if (nargs < 1) return js_mkerr(js, "parse() requires a path argument");
-  if (js_type(args[0]) != JS_STR) return js_mkerr(js, "parse() path must be a string");
+  if (vtype(args[0]) != T_STR) return js_mkerr(js, "parse() path must be a string");
   
   size_t path_len;
   char *path = js_getstr(js, args[0], &path_len);
@@ -398,7 +399,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) {
   if (nargs < 1) return js_mkerr(js, "format() requires a path object argument");
-  if (js_type(args[0]) != JS_OBJ) return js_mkerr(js, "format() argument must be an object");
+  if (vtype(args[0]) != T_OBJ) return js_mkerr(js, "format() argument must be an object");
   
   jsval_t obj = args[0];
   
@@ -411,7 +412,7 @@ static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
   char result[PATH_MAX] = {0};
   size_t pos = 0;
   
-  if (js_type(dir_val) == JS_STR) {
+  if (vtype(dir_val) == T_STR) {
     size_t len;
     char *str = js_getstr(js, dir_val, &len);
     if (str && len > 0 && pos + len < PATH_MAX) {
@@ -421,7 +422,7 @@ static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
         result[pos++] = PATH_SEP;
       }
     }
-  } else if (js_type(root_val) == JS_STR) {
+  } else if (vtype(root_val) == T_STR) {
     size_t len;
     char *str = js_getstr(js, root_val, &len);
     if (str && len > 0 && pos + len < PATH_MAX) {
@@ -430,7 +431,7 @@ static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
     }
   }
   
-  if (js_type(base_val) == JS_STR) {
+  if (vtype(base_val) == T_STR) {
     size_t len;
     char *str = js_getstr(js, base_val, &len);
     if (str && len > 0 && pos + len < PATH_MAX) {
@@ -438,7 +439,7 @@ static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
       pos += len;
     }
   } else {
-    if (js_type(name_val) == JS_STR) {
+    if (vtype(name_val) == T_STR) {
       size_t len;
       char *str = js_getstr(js, name_val, &len);
       if (str && len > 0 && pos + len < PATH_MAX) {
@@ -446,7 +447,7 @@ static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) {
         pos += len;
       }
     }
-    if (js_type(ext_val) == JS_STR) {
+    if (vtype(ext_val) == T_STR) {
       size_t len;
       char *str = js_getstr(js, ext_val, &len);
       if (str && len > 0 && pos + len < PATH_MAX) {
diff --git a/src/modules/process.c b/src/modules/process.c
index d26770c..d238d1e 100644
--- a/src/modules/process.c
+++ b/src/modules/process.c
@@ -414,10 +414,10 @@ static void on_sigwinch(uv_signal_t *handle, int signum) {
   if (!rt->js) return;
   
   jsval_t process_obj = js_get(rt->js, js_glob(rt->js), "process");
-  if (js_type(process_obj) != JS_OBJ) return;
+  if (vtype(process_obj) != T_OBJ) return;
   
   jsval_t stdout_obj = js_get(rt->js, process_obj, "stdout");
-  if (js_type(stdout_obj) != JS_OBJ) return;
+  if (vtype(stdout_obj) != T_OBJ) return;
   
   int rows = 0, cols = 0;
   get_tty_size(STDOUT_FILENO, &rows, &cols);
@@ -464,7 +464,7 @@ static jsval_t js_stdin_on(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return this_obj;
   
   char *event = js_getstr(js, args[0], NULL);
-  if (!event || js_type(args[1]) != JS_FUNC) return this_obj;
+  if (!event || vtype(args[1]) != T_FUNC) return this_obj;
   
   ProcessEventType *evt = find_or_create_stdin_event(event);
   if (!ensure_listener_capacity(evt)) return this_obj;
@@ -516,7 +516,7 @@ static jsval_t js_stdout_on(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return this_obj;
   
   char *event = js_getstr(js, args[0], NULL);
-  if (!event || js_type(args[1]) != JS_FUNC) return this_obj;
+  if (!event || vtype(args[1]) != T_FUNC) return this_obj;
   
   ProcessEventType *evt = find_or_create_stdout_event(event);
   if (!ensure_listener_capacity(evt)) return this_obj;
@@ -535,7 +535,7 @@ static jsval_t js_stdout_once(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return this_obj;
   
   char *event = js_getstr(js, args[0], NULL);
-  if (!event || js_type(args[1]) != JS_FUNC) return this_obj;
+  if (!event || vtype(args[1]) != T_FUNC) return this_obj;
   
   ProcessEventType *evt = find_or_create_stdout_event(event);
   if (!ensure_listener_capacity(evt)) return this_obj;
@@ -623,7 +623,7 @@ static jsval_t js_stderr_on(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return this_obj;
   
   char *event = js_getstr(js, args[0], NULL);
-  if (!event || js_type(args[1]) != JS_FUNC) return this_obj;
+  if (!event || vtype(args[1]) != T_FUNC) return this_obj;
   
   ProcessEventType *evt = find_or_create_stderr_event(event);
   if (!ensure_listener_capacity(evt)) return this_obj;
@@ -640,7 +640,7 @@ static jsval_t js_stderr_once(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 2) return this_obj;
   
   char *event = js_getstr(js, args[0], NULL);
-  if (!event || js_type(args[1]) != JS_FUNC) return this_obj;
+  if (!event || vtype(args[1]) != T_FUNC) return this_obj;
   
   ProcessEventType *evt = find_or_create_stderr_event(event);
   if (!ensure_listener_capacity(evt)) return this_obj;
@@ -686,7 +686,7 @@ static jsval_t process_hrtime(ant_t *js, jsval_t *args, int nargs) {
   if (nargs > 0 && vtype(args[0]) == T_ARR) {
     jsval_t prev_sec = js_get(js, args[0], "0");
     jsval_t prev_nsec = js_get(js, args[0], "1");
-    if (js_type(prev_sec) == JS_NUM && js_type(prev_nsec) == JS_NUM) {
+    if (vtype(prev_sec) == T_NUM && vtype(prev_nsec) == T_NUM) {
       uint64_t prev = (uint64_t)js_getnum(prev_sec) * 1000000000ULL + (uint64_t)js_getnum(prev_nsec);
       now = now - prev;
     }
@@ -760,11 +760,11 @@ static jsval_t process_cpu_usage(ant_t *js, jsval_t *args, int nargs) {
     int64_t user_usec = rusage.ru_utime.tv_sec * 1000000LL + rusage.ru_utime.tv_usec;
     int64_t sys_usec = rusage.ru_stime.tv_sec * 1000000LL + rusage.ru_stime.tv_usec;
     
-    if (nargs > 0 && js_type(args[0]) == JS_OBJ) {
+    if (nargs > 0 && vtype(args[0]) == T_OBJ) {
       jsval_t prev_user = js_get(js, args[0], "user");
       jsval_t prev_system = js_get(js, args[0], "system");
-      if (js_type(prev_user) == JS_NUM) user_usec -= (int64_t)js_getnum(prev_user);
-      if (js_type(prev_system) == JS_NUM) sys_usec -= (int64_t)js_getnum(prev_system);
+      if (vtype(prev_user) == T_NUM) user_usec -= (int64_t)js_getnum(prev_user);
+      if (vtype(prev_system) == T_NUM) sys_usec -= (int64_t)js_getnum(prev_system);
     }
     
     js_set(js, obj, "user", js_mknum((double)user_usec));
@@ -779,15 +779,15 @@ static jsval_t process_cpu_usage(ant_t *js, jsval_t *args, int nargs) {
 
 static jsval_t process_kill(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "process.kill requires at least 1 argument");
-  if (js_type(args[0]) != JS_NUM) return js_mkerr(js, "pid must be a number");
+  if (vtype(args[0]) != T_NUM) return js_mkerr(js, "pid must be a number");
   
   int pid = (int)js_getnum(args[0]);
   int sig = SIGTERM;
   
   if (nargs > 1) {
-    if (js_type(args[1]) == JS_NUM) {
+    if (vtype(args[1]) == T_NUM) {
       sig = (int)js_getnum(args[1]);
-    } else if (js_type(args[1]) == JS_STR) {
+    } else if (vtype(args[1]) == T_STR) {
       char *sig_name = js_getstr(js, args[1], NULL);
       if (sig_name) {
         int signum = get_signal_number(sig_name);
@@ -824,7 +824,7 @@ static jsval_t process_umask(ant_t *js, jsval_t *args, int nargs) {
   (void)args; (void)nargs;
   return js_mknum(0);
 #else
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) {
+  if (nargs > 0 && vtype(args[0]) == T_NUM) {
     int new_mask = (int)js_getnum(args[0]);
     int old_mask = umask((mode_t)new_mask);
     return js_mknum(old_mask);
@@ -877,9 +877,9 @@ static jsval_t process_setuid(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "process.setuid requires 1 argument");
   
   uid_t uid;
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     uid = (uid_t)js_getnum(args[0]);
-  } else if (js_type(args[0]) == JS_STR) {
+  } else if (vtype(args[0]) == T_STR) {
     char *name = js_getstr(js, args[0], NULL);
     struct passwd *pwd = getpwnam(name);
     if (!pwd) return js_mkerr(js, "setuid user not found");
@@ -896,9 +896,9 @@ static jsval_t process_setgid(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "process.setgid requires 1 argument");
   
   gid_t gid;
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     gid = (gid_t)js_getnum(args[0]);
-  } else if (js_type(args[0]) == JS_STR) {
+  } else if (vtype(args[0]) == T_STR) {
     char *name = js_getstr(js, args[0], NULL);
     struct group *grp = getgrnam(name);
     if (!grp) return js_mkerr(js, "setgid group not found");
@@ -915,9 +915,9 @@ static jsval_t process_seteuid(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "process.seteuid requires 1 argument");
   
   uid_t uid;
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     uid = (uid_t)js_getnum(args[0]);
-  } else if (js_type(args[0]) == JS_STR) {
+  } else if (vtype(args[0]) == T_STR) {
     char *name = js_getstr(js, args[0], NULL);
     struct passwd *pwd = getpwnam(name);
     if (!pwd) return js_mkerr(js, "seteuid user not found");
@@ -934,9 +934,9 @@ static jsval_t process_setegid(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "process.setegid requires 1 argument");
   
   gid_t gid;
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     gid = (gid_t)js_getnum(args[0]);
-  } else if (js_type(args[0]) == JS_STR) {
+  } else if (vtype(args[0]) == T_STR) {
     char *name = js_getstr(js, args[0], NULL);
     struct group *grp = getgrnam(name);
     if (!grp) return js_mkerr(js, "setegid group not found");
@@ -964,9 +964,9 @@ static jsval_t process_setgroups(ant_t *js, jsval_t *args, int nargs) {
     char idx[16];
     snprintf(idx, sizeof(idx), "%d", i);
     jsval_t val = js_get(js, args[0], idx);
-    if (js_type(val) == JS_NUM) {
+    if (vtype(val) == T_NUM) {
       groups[i] = (gid_t)js_getnum(val);
-    } else if (js_type(val) == JS_STR) {
+    } else if (vtype(val) == T_STR) {
       char *name = js_getstr(js, val, NULL);
       struct group *grp = getgrnam(name);
       if (!grp) { free(groups); return js_mkerr(js, "group not found"); }
@@ -992,9 +992,9 @@ static jsval_t process_initgroups(ant_t *js, jsval_t *args, int nargs) {
   if (!user) return js_mkerr(js, "user must be a string");
   
   gid_t gid;
-  if (js_type(args[1]) == JS_NUM) {
+  if (vtype(args[1]) == T_NUM) {
     gid = (gid_t)js_getnum(args[1]);
-  } else if (js_type(args[1]) == JS_STR) {
+  } else if (vtype(args[1]) == T_STR) {
     char *name = js_getstr(js, args[1], NULL);
     struct group *grp = getgrnam(name);
     if (!grp) return js_mkerr(js, "group not found");
@@ -1076,7 +1076,7 @@ static void load_dotenv_file(ant_t *js, jsval_t env_obj) {
 static jsval_t process_exit(ant_t *js, jsval_t *args, int nargs) {
   int code = 0;
   
-  if (nargs > 0 && js_type(args[0]) == JS_NUM) {
+  if (nargs > 0 && vtype(args[0]) == T_NUM) {
     code = (int)js_getnum(args[0]);
   }
   
@@ -1120,7 +1120,7 @@ static jsval_t process_on(ant_t *js, jsval_t *args, int nargs) {
   
   char *event = js_getstr(js, args[0], NULL);
   if (!event) return js_mkerr(js, "event must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function");
   
   int signum = get_signal_number(event);
   if (signum > 0) {
@@ -1146,7 +1146,7 @@ static jsval_t process_once(ant_t *js, jsval_t *args, int nargs) {
   
   char *event = js_getstr(js, args[0], NULL);
   if (!event) return js_mkerr(js, "event must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function");
   
   int signum = get_signal_number(event);
   if (signum > 0) {
@@ -1198,7 +1198,7 @@ static jsval_t process_off(ant_t *js, jsval_t *args, int nargs) {
 static jsval_t process_remove_all_listeners(ant_t *js, jsval_t *args, int nargs) {
   jsval_t process_obj = js_get(js, js_glob(js), "process");
   
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     char *event = js_getstr(js, args[0], NULL);
     if (event) {
       ProcessEventType *evt = NULL;
@@ -1245,7 +1245,7 @@ static jsval_t process_listener_count(ant_t *js, jsval_t *args, int nargs) {
 
 static jsval_t process_set_max_listeners(ant_t *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "setMaxListeners requires 1 argument");
-  if (js_type(args[0]) != JS_NUM) return js_mkerr(js, "n must be a number");
+  if (vtype(args[0]) != T_NUM) return js_mkerr(js, "n must be a number");
   
   int n = (int)js_getnum(args[0]);
   if (n < 0) return js_mkerr(js, "n must be non-negative");
diff --git a/src/modules/readline.c b/src/modules/readline.c
index d0a1f30..9404b20 100644
--- a/src/modules/readline.c
+++ b/src/modules/readline.c
@@ -24,6 +24,8 @@
 #include "ant.h"
 #include "errors.h"
 #include "runtime.h"
+#include "internal.h"
+
 #include "modules/readline.h"
 #include "modules/symbol.h"
 
@@ -493,7 +495,7 @@ static void on_stdin_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *bu
       jsval_t line_val = js_mkstr(js, line, strlen(line));
       emit_event(js, iface, "line", &line_val, 1);
       
-      if (js_type(iface->pending_question_resolve) == JS_FUNC) {
+      if (vtype(iface->pending_question_resolve) == T_FUNC) {
         js_call(js, iface->pending_question_resolve, &line_val, 1);
         iface->pending_question_resolve = js_mkundef();
         iface->pending_question_reject = js_mkundef();
@@ -586,7 +588,7 @@ static void process_line(struct js *js, rl_interface_t *iface) {
   jsval_t line_val = js_mkstr(js, line, strlen(line));
   emit_event(js, iface, "line", &line_val, 1);
   
-  if (js_type(iface->pending_question_resolve) == JS_FUNC) {
+  if (vtype(iface->pending_question_resolve) == T_FUNC) {
     js_call(js, iface->pending_question_resolve, &line_val, 1);
     iface->pending_question_resolve = js_mkundef();
     iface->pending_question_reject = js_mkundef();
@@ -601,7 +603,7 @@ static void process_line(struct js *js, rl_interface_t *iface) {
 
 static rl_interface_t *get_interface(struct js *js, jsval_t this_obj) {
   jsval_t id_val = js_get(js, this_obj, "_rl_id");
-  if (js_type(id_val) != JS_NUM) return NULL;
+  if (vtype(id_val) != T_NUM) return NULL;
   
   uint64_t id = (uint64_t)js_getnum(id_val);
   rl_interface_t *iface = NULL;
@@ -618,7 +620,7 @@ static jsval_t rl_interface_on(struct js *js, jsval_t *args, int nargs) {
   
   char *event = js_getstr(js, args[0], NULL);
   if (!event) return js_mkerr(js, "event must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function");
   
   RLEventType *evt = find_or_create_event_type(iface, event);
   if (evt->listener_count >= MAX_LISTENERS_PER_EVENT) {
@@ -641,7 +643,7 @@ static jsval_t rl_interface_once(struct js *js, jsval_t *args, int nargs) {
   
   char *event = js_getstr(js, args[0], NULL);
   if (!event) return js_mkerr(js, "event must be a string");
-  if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function");
+  if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function");
   
   RLEventType *evt = find_or_create_event_type(iface, event);
   if (evt->listener_count >= MAX_LISTENERS_PER_EVENT) {
@@ -861,14 +863,14 @@ static jsval_t rl_interface_write(struct js *js, jsval_t *args, int nargs) {
     emit_event(js, iface, "resume", NULL, 0);
   }
   
-  if (nargs >= 2 && js_type(args[1]) == JS_OBJ) {
+  if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
     jsval_t key = args[1];
     jsval_t name_val = js_get(js, key, "name");
     jsval_t ctrl_val = js_get(js, key, "ctrl");
     jsval_t meta_val = js_get(js, key, "meta");
     jsval_t shift_val = js_get(js, key, "shift");
     
-    char *name = (js_type(name_val) == JS_STR) ? js_getstr(js, name_val, NULL) : NULL;
+    char *name = (vtype(name_val) == T_STR) ? js_getstr(js, name_val, NULL) : NULL;
     bool ctrl = js_truthy(js, ctrl_val);
     bool meta = js_truthy(js, meta_val);
     bool shift = js_truthy(js, shift_val);
@@ -879,7 +881,7 @@ static jsval_t rl_interface_write(struct js *js, jsval_t *args, int nargs) {
     }
   }
   
-  if (nargs < 1 || js_type(args[0]) == JS_NULL || js_type(args[0]) == JS_UNDEF) {
+  if (nargs < 1 || vtype(args[0]) == T_NULL || vtype(args[0]) == T_UNDEF) {
     return js_mkundef();
   }
   
@@ -934,7 +936,7 @@ static jsval_t rl_interface_question_callback(struct js *js, jsval_t *args, int
   char *query = js_getstr(js, args[0], &query_len);
   if (!query) return js_mkerr(js, "query must be a string");
   
-  if (js_type(args[1]) != JS_FUNC) {
+  if (vtype(args[1]) != T_FUNC) {
     return js_mkerr(js, "callback must be a function");
   }
   
@@ -1057,7 +1059,7 @@ static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "createInterface requires options");
   
   jsval_t options = args[0];
-  if (js_type(options) != JS_OBJ) return js_mkerr(js, "options must be an object");
+  if (vtype(options) != T_OBJ) return js_mkerr(js, "options must be an object");
   
   rl_interface_t *iface = calloc(1, sizeof(rl_interface_t));
   if (!iface) return js_mkerr(js, "out of memory");
@@ -1086,11 +1088,10 @@ static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
   iface->output_stream = js_get(js, options, "output");
   
   jsval_t terminal_val = js_get(js, options, "terminal");
-  iface->terminal = (js_type(terminal_val) == JS_TRUE) || 
-                    (js_type(terminal_val) == JS_UNDEF);
+  iface->terminal = terminal_val == js_true || vtype(terminal_val) == T_UNDEF;
   
   jsval_t history_size_val = js_get(js, options, "historySize");
-  iface->history_size = (js_type(history_size_val) == JS_NUM) 
+  iface->history_size = (vtype(history_size_val) == T_NUM) 
     ? (int)js_getnum(history_size_val) 
     : DEFAULT_HISTORY_SIZE;
   
@@ -1098,30 +1099,30 @@ static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
   iface->remove_history_duplicates = js_truthy(js, remove_dup_val);
   
   jsval_t prompt_val = js_get(js, options, "prompt");
-  if (js_type(prompt_val) == JS_STR) {
+  if (vtype(prompt_val) == T_STR) {
     free(iface->prompt);
     iface->prompt = strdup(js_getstr(js, prompt_val, NULL));
   }
   
   jsval_t crlf_delay_val = js_get(js, options, "crlfDelay");
-  iface->crlf_delay = (js_type(crlf_delay_val) == JS_NUM) 
+  iface->crlf_delay = (vtype(crlf_delay_val) == T_NUM) 
     ? (int)js_getnum(crlf_delay_val) 
     : 100;
   if (iface->crlf_delay < 100) iface->crlf_delay = 100;
   
   jsval_t tab_size_val = js_get(js, options, "tabSize");
-  iface->tab_size = (js_type(tab_size_val) == JS_NUM) 
+  iface->tab_size = (vtype(tab_size_val) == T_NUM) 
     ? (int)js_getnum(tab_size_val) 
     : DEFAULT_TAB_SIZE;
   if (iface->tab_size < 1) iface->tab_size = 1;
   
   jsval_t completer_val = js_get(js, options, "completer");
-  iface->completer = (js_type(completer_val) == JS_FUNC) ? completer_val : js_mkundef();
+  iface->completer = (vtype(completer_val) == T_FUNC) ? completer_val : js_mkundef();
   
   jsval_t history_val = js_get(js, options, "history");
-  if (js_type(history_val) == JS_OBJ) {
+  if (vtype(history_val) == T_OBJ) {
     jsval_t len_val = js_get(js, history_val, "length");
-    int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+    int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
     
     rl_history_init(&iface->history, iface->history_size);
     
@@ -1129,7 +1130,7 @@ static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
       char key[16];
       snprintf(key, sizeof(key), "%d", i);
       jsval_t item = js_get(js, history_val, key);
-      if (js_type(item) == JS_STR) {
+      if (vtype(item) == T_STR) {
         char *line = js_getstr(js, item, NULL);
         if (line) rl_history_add(&iface->history, line, false);
       }
@@ -1173,7 +1174,7 @@ static jsval_t rl_create_interface(struct js *js, jsval_t *args, int nargs) {
 
 static jsval_t rl_create_interface_promises(struct js *js, jsval_t *args, int nargs) {
   jsval_t iface_obj = rl_create_interface(js, args, nargs);
-  if (js_type(iface_obj) == JS_ERR) return iface_obj;
+  if (vtype(iface_obj) == T_ERR) return iface_obj;
   js_set(js, iface_obj, "question", js_mkfun(rl_interface_question_promise));
   
   return iface_obj;
@@ -1210,7 +1211,7 @@ static jsval_t rl_cursor_to(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 2) return js_mkfalse();
   int x = (int)js_getnum(args[1]);
   
-  if (nargs >= 3 && js_type(args[2]) == JS_NUM) {
+  if (nargs >= 3 && vtype(args[2]) == T_NUM) {
     int y = (int)js_getnum(args[2]);
     printf("\033[%d;%dH", y + 1, x + 1);
   } else {
diff --git a/src/modules/reflect.c b/src/modules/reflect.c
index 4f4cdfc..5a2cb35 100644
--- a/src/modules/reflect.c
+++ b/src/modules/reflect.c
@@ -4,6 +4,8 @@
 #include "ant.h"
 #include "errors.h"
 #include "runtime.h"
+#include "internal.h"
+
 #include "modules/reflect.h"
 #include "modules/symbol.h"
 
@@ -13,10 +15,10 @@ static jsval_t reflect_get(struct js *js, jsval_t *args, int nargs) {
   jsval_t target = args[0];
   jsval_t key = args[1];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkundef();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkundef();
   
-  if (js_type(key) != JS_STR) return js_mkundef();
+  if (vtype(key) != T_STR) return js_mkundef();
   
   char *key_str = js_getstr(js, key, NULL);
   if (!key_str) return js_mkundef();
@@ -31,10 +33,10 @@ static jsval_t reflect_set(struct js *js, jsval_t *args, int nargs) {
   jsval_t key = args[1];
   jsval_t value = args[2];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
-  if (js_type(key) != JS_STR) return js_mkfalse();
+  if (vtype(key) != T_STR) return js_mkfalse();
   
   char *key_str = js_getstr(js, key, NULL);
   if (!key_str) return js_mkfalse();
@@ -49,16 +51,16 @@ static jsval_t reflect_has(struct js *js, jsval_t *args, int nargs) {
   jsval_t target = args[0];
   jsval_t key = args[1];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
-  if (js_type(key) != JS_STR) return js_mkfalse();
+  if (vtype(key) != T_STR) return js_mkfalse();
   
   char *key_str = js_getstr(js, key, NULL);
   if (!key_str) return js_mkfalse();
   
   jsval_t val = js_get(js, target, key_str);
-  return js_type(val) != JS_UNDEF ? js_mktrue() : js_mkfalse();
+  return vtype(val) != T_UNDEF ? js_mktrue() : js_mkfalse();
 }
 
 static jsval_t reflect_delete_property(struct js *js, jsval_t *args, int nargs) {
@@ -67,10 +69,10 @@ static jsval_t reflect_delete_property(struct js *js, jsval_t *args, int nargs)
   jsval_t target = args[0];
   jsval_t key = args[1];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
-  if (js_type(key) != JS_STR) return js_mkfalse();
+  if (vtype(key) != T_STR) return js_mkfalse();
   
   size_t key_len;
   char *key_str = js_getstr(js, key, &key_len);
@@ -87,8 +89,8 @@ static jsval_t reflect_own_keys(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t target = args[0];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) {
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) {
     return js_mkerr(js, "Reflect.ownKeys called on non-object");
   }
   
@@ -114,13 +116,13 @@ static jsval_t reflect_construct(struct js *js, jsval_t *args, int nargs) {
   jsval_t target = args[0];
   jsval_t args_arr = args[1];
   
-  if (js_type(target) != JS_FUNC) {
+  if (vtype(target) != T_FUNC) {
     return js_mkerr(js, "Reflect.construct: first argument must be a constructor");
   }
   
   jsval_t length_val = js_get(js, args_arr, "length");
   int arg_count = 0;
-  if (js_type(length_val) == JS_NUM) {
+  if (vtype(length_val) == T_NUM) {
     arg_count = (int)js_getnum(length_val);
   }
   
@@ -141,7 +143,7 @@ static jsval_t reflect_construct(struct js *js, jsval_t *args, int nargs) {
   
   if (call_args) free(call_args);
   
-  if (js_type(result) == JS_OBJ || js_type(result) == JS_FUNC) {
+  if (vtype(result) == T_OBJ || vtype(result) == T_FUNC) {
     return result;
   }
   return new_obj;
@@ -156,13 +158,13 @@ static jsval_t reflect_apply(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_arg = args[1];
   jsval_t args_arr = args[2];
   
-  if (js_type(target) != JS_FUNC) {
+  if (vtype(target) != T_FUNC) {
     return js_mkerr(js, "Reflect.apply: first argument must be a function");
   }
   
   jsval_t length_val = js_get(js, args_arr, "length");
   int arg_count = 0;
-  if (js_type(length_val) == JS_NUM) {
+  if (vtype(length_val) == T_NUM) {
     arg_count = (int)js_getnum(length_val);
   }
   
@@ -190,16 +192,16 @@ static jsval_t reflect_get_own_property_descriptor(struct js *js, jsval_t *args,
   jsval_t target = args[0];
   jsval_t key = args[1];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkundef();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkundef();
   
-  if (js_type(key) != JS_STR) return js_mkundef();
+  if (vtype(key) != T_STR) return js_mkundef();
   
   char *key_str = js_getstr(js, key, NULL);
   if (!key_str) return js_mkundef();
   
   jsval_t value = js_get(js, target, key_str);
-  if (js_type(value) == JS_UNDEF) return js_mkundef();
+  if (vtype(value) == T_UNDEF) return js_mkundef();
   
   jsval_t desc = js_mkobj(js);
   js_set(js, desc, "value", value);
@@ -217,11 +219,11 @@ static jsval_t reflect_define_property(struct js *js, jsval_t *args, int nargs)
   jsval_t key = args[1];
   jsval_t descriptor = args[2];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
-  if (js_type(key) != JS_STR) return js_mkfalse();
-  if (js_type(descriptor) != JS_OBJ) return js_mkfalse();
+  if (vtype(key) != T_STR) return js_mkfalse();
+  if (vtype(descriptor) != T_OBJ) return js_mkfalse();
   
   char *key_str = js_getstr(js, key, NULL);
   if (!key_str) return js_mkfalse();
@@ -238,9 +240,9 @@ static jsval_t reflect_get_prototype_of(struct js *js, jsval_t *args, int nargs)
   }
   
   jsval_t target = args[0];
-  int t = js_type(target);
+  int t = vtype(target);
   
-  if (t != JS_OBJ && t != JS_FUNC) {
+  if (t != T_OBJ && t != T_FUNC) {
     return js_mkerr(js, "Reflect.getPrototypeOf: argument must be an object");
   }
   
@@ -253,11 +255,11 @@ static jsval_t reflect_set_prototype_of(struct js *js, jsval_t *args, int nargs)
   jsval_t target = args[0];
   jsval_t proto = args[1];
   
-  int t = js_type(target);
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  int t = vtype(target);
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
-  int pt = js_type(proto);
-  if (pt != JS_OBJ && pt != JS_FUNC && pt != JS_NULL) return js_mkfalse();
+  int pt = vtype(proto);
+  if (pt != T_OBJ && pt != T_FUNC && pt != T_NULL) return js_mkfalse();
   
   js_set_proto(js, target, proto);
   return js_mktrue();
@@ -267,15 +269,12 @@ static jsval_t reflect_is_extensible(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkfalse();
   
   jsval_t target = args[0];
-  int t = js_type(target);
-  
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  int t = vtype(target);
   
-  jsval_t frozen = js_get_slot(js, target, SLOT_FROZEN);
-  if (js_type(frozen) == JS_TRUE) return js_mkfalse();
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
-  jsval_t sealed = js_get_slot(js, target, SLOT_SEALED);
-  if (js_type(sealed) == JS_TRUE) return js_mkfalse();
+  if (js_get_slot(js, target, SLOT_FROZEN) == js_true) return js_false;
+  if (js_get_slot(js, target, SLOT_SEALED) == js_true) return js_false;
   
   return js_mktrue();
 }
@@ -284,9 +283,9 @@ static jsval_t reflect_prevent_extensions(struct js *js, jsval_t *args, int narg
   if (nargs < 1) return js_mkfalse();
   
   jsval_t target = args[0];
-  int t = js_type(target);
+  int t = vtype(target);
   
-  if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse();
+  if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
   
   js_set_slot(js, target, SLOT_EXTENSIBLE, js_mkfalse());
   return js_mktrue();
diff --git a/src/modules/server.c b/src/modules/server.c
index e839616..06dab22 100644
--- a/src/modules/server.c
+++ b/src/modules/server.c
@@ -12,6 +12,8 @@
 #include "ant.h"
 #include "config.h"
 #include "runtime.h"
+#include "internal.h"
+
 #include "modules/server.h"
 #include "modules/timer.h"
 #include "modules/json.h"
@@ -344,9 +346,9 @@ static jsval_t js_set_prop(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t store_obj = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(store_obj) == JS_UNDEF) return js_mkundef();
+  if (vtype(store_obj) == T_UNDEF) return js_mkundef();
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     size_t key_len;
     const char *key = js_getstr(js, args[0], &key_len);
     js_set(js, store_obj, key, args[1]);
@@ -360,9 +362,9 @@ static jsval_t js_get_prop(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t store_obj = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(store_obj) == JS_UNDEF) return js_mkundef();
+  if (vtype(store_obj) == T_UNDEF) return js_mkundef();
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     size_t key_len;
     const char *key = js_getstr(js, args[0], &key_len);
     return js_get(js, store_obj, key);
@@ -376,12 +378,12 @@ static jsval_t req_header(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t headers_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(headers_val) != JS_NUM) return js_mkundef();
+  if (vtype(headers_val) != T_NUM) return js_mkundef();
   
   UT_array *headers = (UT_array *)(unsigned long)js_getnum(headers_val);
   if (!headers) return js_mkundef();
   
-  if (js_type(args[0]) != JS_STR) return js_mkundef();
+  if (vtype(args[0]) != T_STR) return js_mkundef();
   size_t name_len;
   const char *search_name = js_getstr(js, args[0], &name_len);
   
@@ -400,12 +402,12 @@ static jsval_t res_header(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx || !ctx->custom_headers) return js_mkundef();
   
-  if (js_type(args[0]) == JS_STR && js_type(args[1]) == JS_STR) {
+  if (vtype(args[0]) == T_STR && vtype(args[1]) == T_STR) {
     custom_header_t header;
     header.name = js_getstr(js, args[0], NULL);
     header.value = js_getstr(js, args[1], NULL);
@@ -420,12 +422,12 @@ static jsval_t res_status(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx) return js_mkundef();
   
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     ctx->status = (int)js_getnum(args[0]);
   }
   
@@ -437,20 +439,20 @@ static jsval_t res_body(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx) return js_mkundef();
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     ctx->body = js_getstr(js, args[0], &ctx->body_len);
   }
   
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     ctx->status = (int)js_getnum(args[1]);
   }
   
-  if (nargs >= 3 && js_type(args[2]) == JS_STR) {
+  if (nargs >= 3 && vtype(args[2]) == T_STR) {
     ctx->content_type = js_getstr(js, args[2], NULL);
   } else {
     ctx->content_type = "text/plain";
@@ -466,16 +468,16 @@ static jsval_t res_html(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx) return js_mkundef();
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     ctx->body = js_getstr(js, args[0], &ctx->body_len);
   }
   
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     ctx->status = (int)js_getnum(args[1]);
   }
   
@@ -490,7 +492,7 @@ static jsval_t res_json(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx) return js_mkundef();
@@ -498,9 +500,9 @@ static jsval_t res_json(struct js *js, jsval_t *args, int nargs) {
   jsval_t stringify_args[1] = { args[0] };
   jsval_t result = js_json_stringify(js, stringify_args, 1);
   
-  if (js_type(result) == JS_STR) {
+  if (vtype(result) == T_STR) {
     ctx->body = js_getstr(js, result, &ctx->body_len);
-  } else if (js_type(result) == JS_ERR) {
+  } else if (vtype(result) == T_ERR) {
     const char *json_str = js_str(js, args[0]);
     if (json_str) {
       ctx->body = (char *)json_str;
@@ -508,7 +510,7 @@ static jsval_t res_json(struct js *js, jsval_t *args, int nargs) {
     }
   }
   
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     ctx->status = (int)js_getnum(args[1]);
   }
   
@@ -523,7 +525,7 @@ static jsval_t res_notFound(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx) return js_mkundef();
@@ -542,17 +544,17 @@ static jsval_t res_redirect(struct js *js, jsval_t *args, int nargs) {
   
   jsval_t fn = js_getcurrentfunc(js);
   jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA);
-  if (js_type(ctx_val) != JS_NUM) return js_mkundef();
+  if (vtype(ctx_val) != T_NUM) return js_mkundef();
   
   response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val);
   if (!ctx) return js_mkundef();
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     ctx->redirect_location = js_getstr(js, args[0], NULL);
   }
   
   ctx->status = 302;
-  if (nargs >= 2 && js_type(args[1]) == JS_NUM) {
+  if (nargs >= 2 && vtype(args[1]) == T_NUM) {
     ctx->status = (int)js_getnum(args[1]);
   }
   
@@ -733,7 +735,7 @@ static void handle_http_request(client_t *client, http_request_t *http_req) {
   res_ctx->next = server->pending_responses;
   server->pending_responses = res_ctx;
   
-  if (server->handler != 0 && js_type(server->handler) != JS_UNDEF) {
+  if (server->handler != 0 && vtype(server->handler) != T_UNDEF) {
     jsval_t ctx = js_mkobj(server->js);
     
     jsval_t req = js_mkobj(server->js);
@@ -760,9 +762,9 @@ static void handle_http_request(client_t *client, http_request_t *http_req) {
   
     jsval_t args[1] = {ctx};
     result = js_call(server->js, server->handler, args, 1);
-    if (js_type(result) == JS_PROMISE) return;
+    if (vtype(result) == T_PROMISE) return;
     
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       const char *error_msg = js_str(server->js, result);
       fprintf(stderr, "Handler error: %s\n", error_msg);
       
@@ -937,7 +939,7 @@ jsval_t js_serve(struct js *js, jsval_t *args, int nargs) {
   }
   
   int port = 8000;
-  if (js_type(args[0]) == JS_NUM) {
+  if (vtype(args[0]) == T_NUM) {
     port = (int)js_getnum(args[0]);
   }
   
diff --git a/src/modules/sessionstorage.c b/src/modules/sessionstorage.c
index d81b0d4..f0e40f2 100644
--- a/src/modules/sessionstorage.c
+++ b/src/modules/sessionstorage.c
@@ -6,6 +6,7 @@
 #include "errors.h"
 #include "arena.h"
 #include "runtime.h"
+#include "internal.h"
 
 #include "modules/symbol.h"
 #include "modules/sessionstorage.h"
@@ -138,7 +139,7 @@ static jsval_t js_sessionstorage_key(struct js *js, jsval_t *args, int nargs) {
     return js_mkerr(js, "Failed to execute 'key' on 'Storage': 1 argument required");
   }
   
-  if (js_type(args[0]) != JS_NUM) {
+  if (vtype(args[0]) != T_NUM) {
     return js_mknull();
   }
   
diff --git a/src/modules/shell.c b/src/modules/shell.c
index 775f2f2..d73bad4 100644
--- a/src/modules/shell.c
+++ b/src/modules/shell.c
@@ -13,6 +13,7 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "internal.h"
 #include "modules/symbol.h"
 
 static jsval_t builtin_shell_text(struct js *js, jsval_t *args, int nargs);
@@ -111,8 +112,8 @@ static jsval_t builtin_shell_lines(struct js *js, jsval_t *args, int nargs) {
 static jsval_t builtin_shell_dollar(struct js *js, jsval_t *args, int nargs) {
   if (nargs < 1) return js_mkerr(js, "$() requires at least one argument");
     
-  if (js_type(args[0]) != JS_OBJ) {
-    if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) != T_OBJ) {
+    if (vtype(args[0]) == T_STR) {
       size_t cmd_len;
       char *cmd = js_getstr(js, args[0], &cmd_len);
       if (!cmd) return js_mkerr(js, "Failed to get command string");
@@ -138,7 +139,7 @@ static jsval_t builtin_shell_dollar(struct js *js, jsval_t *args, int nargs) {
     snprintf(idx_str, sizeof(idx_str), "%d", i);
     
     jsval_t str_val = js_get(js, strings_array, idx_str);
-    if (js_type(str_val) == JS_STR) {
+    if (vtype(str_val) == T_STR) {
       size_t str_len;
       char *str = js_getstr(js, str_val, &str_len);
       
@@ -161,12 +162,12 @@ static jsval_t builtin_shell_dollar(struct js *js, jsval_t *args, int nargs) {
       char val_str[256];
       size_t val_len = 0;
       
-      if (js_type(val) == JS_STR) {
+      if (vtype(val) == T_STR) {
         size_t len;
         char *s = js_getstr(js, val, &len);
         val_len = len < sizeof(val_str) - 1 ? len : sizeof(val_str) - 1;
         memcpy(val_str, s, val_len);
-      } else if (js_type(val) == JS_NUM) {
+      } else if (vtype(val) == T_NUM) {
         val_len = snprintf(val_str, sizeof(val_str), "%g", js_getnum(val));
       }
       
diff --git a/src/modules/symbol.c b/src/modules/symbol.c
index a56efb1..b60442d 100644
--- a/src/modules/symbol.c
+++ b/src/modules/symbol.c
@@ -5,6 +5,7 @@
 #include "ant.h"
 #include "errors.h"
 #include "runtime.h"
+#include "internal.h"
 #include "modules/symbol.h"
 
 static jsval_t g_iterator_sym = 0;
@@ -29,14 +30,14 @@ const char *get_observable_sym_key(void) { return g_observable_sym_key; }
 
 static jsval_t builtin_Symbol(struct js *js, jsval_t *args, int nargs) {
   const char *desc = NULL;
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     desc = js_getstr(js, args[0], NULL);
   }
   return js_mksym(js, desc);
 }
 
 static jsval_t builtin_Symbol_for(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || js_type(args[0]) != JS_STR) {
+  if (nargs < 1 || vtype(args[0]) != T_STR) {
     return js_mkerr(js, "Symbol.for requires a string argument");
   }
   
@@ -47,7 +48,7 @@ static jsval_t builtin_Symbol_for(struct js *js, jsval_t *args, int nargs) {
 }
 
 static jsval_t builtin_Symbol_keyFor(struct js *js, jsval_t *args, int nargs) {
-  if (nargs < 1 || js_type(args[0]) != JS_SYMBOL) {
+  if (nargs < 1 || vtype(args[0]) != T_SYMBOL) {
     return js_mkundef();
   }
   
@@ -90,7 +91,7 @@ static jsval_t array_iterator(struct js *js, jsval_t *args, int nargs) {
   jsval_t arr = js_getthis(js);
   
   jsval_t len_val = js_get(js, arr, "length");
-  int len = js_type(len_val) == JS_NUM ? (int)js_getnum(len_val) : 0;
+  int len = vtype(len_val) == T_NUM ? (int)js_getnum(len_val) : 0;
   
   jsval_t iter = js_mkobj(js);
   js_set(js, iter, "__arr", arr);
diff --git a/src/modules/textcodec.c b/src/modules/textcodec.c
index 3c2af86..0bec000 100644
--- a/src/modules/textcodec.c
+++ b/src/modules/textcodec.c
@@ -2,8 +2,11 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "internal.h"
 #include "runtime.h"
 #include "errors.h"
+#include "internal.h"
+
 #include "modules/textcodec.h"
 #include "modules/buffer.h"
 #include "modules/symbol.h"
@@ -13,7 +16,7 @@ static jsval_t js_textencoder_encode(struct js *js, jsval_t *args, int nargs) {
   size_t str_len = 0;
   const char *str = "";
   
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     str = js_getstr(js, args[0], &str_len);
     if (!str) {
       str = "";
@@ -27,7 +30,7 @@ static jsval_t js_textencoder_encode(struct js *js, jsval_t *args, int nargs) {
   jsval_t len_arg = js_mknum((double)str_len);
   jsval_t arr = js_call(js, uint8array_ctor, &len_arg, 1);
   
-  if (js_type(arr) == JS_ERR) return arr;
+  if (vtype(arr) == T_ERR) return arr;
   
   if (str_len > 0) {
     jsval_t ta_data_val = js_get_slot(js, arr, SLOT_BUFFER);
@@ -47,7 +50,7 @@ static jsval_t js_textencoder_encodeInto(struct js *js, jsval_t *args, int nargs
   size_t str_len = 0;
   const char *str = "";
   
-  if (js_type(args[0]) == JS_STR) {
+  if (vtype(args[0]) == T_STR) {
     str = js_getstr(js, args[0], &str_len);
     if (!str) {
       str = "";
@@ -102,7 +105,7 @@ static jsval_t js_textdecoder_decode(struct js *js, jsval_t *args, int nargs) {
   }
   
   jsval_t ab_data_val = js_get_slot(js, args[0], SLOT_BUFFER);
-  if (js_type(ab_data_val) == JS_NUM) {
+  if (vtype(ab_data_val) == T_NUM) {
     ArrayBufferData *ab_data = (ArrayBufferData *)(uintptr_t)js_getnum(ab_data_val);
     if (!ab_data || !ab_data->data) return js_mkstr(js, "", 0);    
     return js_mkstr(js, (const char *)ab_data->data, ab_data->length);
@@ -115,7 +118,7 @@ static jsval_t js_textdecoder_constructor(struct js *js, jsval_t *args, int narg
   const char *encoding = "utf-8";
   size_t encoding_len = 5;
   
-  if (nargs > 0 && js_type(args[0]) == JS_STR) {
+  if (nargs > 0 && vtype(args[0]) == T_STR) {
     encoding = js_getstr(js, args[0], &encoding_len);
     if (encoding && (
         strcasecmp(encoding, "utf-8") == 0 || 
diff --git a/src/modules/url.c b/src/modules/url.c
index ceb2bd4..f5be070 100644
--- a/src/modules/url.c
+++ b/src/modules/url.c
@@ -7,6 +7,7 @@
 
 #include "ant.h"
 #include "errors.h"
+#include "internal.h"
 #include "runtime.h"
 #include "modules/url.h"
 
@@ -353,10 +354,10 @@ static jsval_t usp_get(struct js *js, jsval_t *args, int nargs) {
   if (!key) return js_mknull();
 
   jsval_t entries = js_get(js, this_val, "_entries");
-  if (js_type(entries) != JS_OBJ) return js_mknull();
+  if (vtype(entries) != T_OBJ) return js_mknull();
 
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   for (int i = 0; i < len; i++) {
     char idx[16];
@@ -379,10 +380,10 @@ static jsval_t usp_getAll(struct js *js, jsval_t *args, int nargs) {
 
   jsval_t result = js_mkarr(js);
   jsval_t entries = js_get(js, this_val, "_entries");
-  if (js_type(entries) != JS_OBJ) return result;
+  if (vtype(entries) != T_OBJ) return result;
 
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   for (int i = 0; i < len; i++) {
     char idx[16];
@@ -404,10 +405,10 @@ static jsval_t usp_has(struct js *js, jsval_t *args, int nargs) {
   if (!key) return js_mkfalse();
 
   jsval_t entries = js_get(js, this_val, "_entries");
-  if (js_type(entries) != JS_OBJ) return js_mkfalse();
+  if (vtype(entries) != T_OBJ) return js_mkfalse();
 
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   for (int i = 0; i < len; i++) {
     char idx[16];
@@ -422,11 +423,11 @@ static jsval_t usp_has(struct js *js, jsval_t *args, int nargs) {
 
 static void usp_sync_url(struct js *js, jsval_t this_val) {
   jsval_t url_obj = js_get(js, this_val, "_url");
-  if (js_type(url_obj) != JS_OBJ) return;
+  if (vtype(url_obj) != T_OBJ) return;
 
   jsval_t entries = js_get(js, this_val, "_entries");
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   size_t buf_size = 1024;
   char *buf = malloc(buf_size);
@@ -467,7 +468,7 @@ static jsval_t usp_set(struct js *js, jsval_t *args, int nargs) {
 
   jsval_t entries = js_get(js, this_val, "_entries");
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   jsval_t new_entries = js_mkarr(js);
   int found = 0;
@@ -524,7 +525,7 @@ static jsval_t usp_delete(struct js *js, jsval_t *args, int nargs) {
 
   jsval_t entries = js_get(js, this_val, "_entries");
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   jsval_t new_entries = js_mkarr(js);
   for (int i = 0; i < len; i++) {
@@ -548,7 +549,7 @@ static jsval_t usp_toString(struct js *js, jsval_t *args, int nargs) {
   jsval_t this_val = js_getthis(js);
   jsval_t entries = js_get(js, this_val, "_entries");
   jsval_t len_val = js_get(js, entries, "length");
-  int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0;
+  int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
 
   size_t buf_size = 1024;
   char *buf = malloc(buf_size);
@@ -584,7 +585,7 @@ static jsval_t js_URLSearchParams(struct js *js, jsval_t *args, int nargs) {
   jsval_t entries = js_mkarr(js);
   js_set(js, usp, "_entries", entries);
 
-  if (nargs < 1 || js_type(args[0]) != JS_STR) goto done_parse;
+  if (nargs < 1 || vtype(args[0]) != T_STR) goto done_parse;
   char *init = js_getstr(js, args[0], NULL);
   if (!init) goto done_parse;
 
diff --git a/src/repl.c b/src/repl.c
index 44d9722..f901655 100644
--- a/src/repl.c
+++ b/src/repl.c
@@ -22,6 +22,7 @@
 #include "repl.h"
 #include "config.h"
 #include "runtime.h"
+#include "internal.h"
 #include "modules/io.h"
 
 #define MAX_HISTORY 512
@@ -119,9 +120,9 @@ static cmd_result_t cmd_load(struct js *js, history_t *history, const char *arg)
     
     jsval_t result = js_eval(js, file_buffer, len);
     js_run_event_loop(js);
-    if (js_type(result) == JS_ERR) {
+    if (vtype(result) == T_ERR) {
       fprintf(stderr, "%s\n", js_str(js, result));
-    } else if (js_type(result) != JS_UNDEF) {
+    } else if (vtype(result) != T_UNDEF) {
       printf("%s\n", js_str(js, result));
     }
     
@@ -609,7 +610,7 @@ void ant_repl_run() {
     jsval_t eval_result = js_eval(js, multiline_buf, multiline_len);
     js_run_event_loop(js);
     
-    if (js_type(eval_result) == JS_ERR) {
+    if (vtype(eval_result) == T_ERR) {
       fprintf(stderr, "%s\n", js_str(js, eval_result));
     } else {
       const char *str = js_str(js, eval_result);
diff --git a/src/runtime.c b/src/runtime.c
index 3ff2694..5d8377e 100644
--- a/src/runtime.c
+++ b/src/runtime.c
@@ -91,18 +91,20 @@ void code_arena_reset(void) {
 }
 
 struct ant_runtime *ant_runtime_init(struct js *js, int argc, char **argv, struct arg_file *ls_p) {
-  runtime.js = js;
-  runtime.ant_obj = js_newobj(js);
-  runtime.flags = 0;
-
-  runtime.argc = argc;
-  runtime.argv = argv;
-  runtime.ls_fp = ls_p->count > 0 ? ls_p->filename[0] : NULL;
-
-  js_set(js, js_glob(js), "global", js_glob(js));
-  js_set(js, js_glob(js), "window", js_glob(js));
-  js_set(js, js_glob(js), "globalThis", js_glob(js));
-  js_set(js, js_glob(js), "Ant", runtime.ant_obj);
+  runtime = (struct ant_runtime){
+    .js = js,
+    .ant_obj = js_newobj(js),
+    .flags = 0,
+    .argc = argc,
+    .argv = argv,
+    .ls_fp = (ls_p && ls_p->count > 0) ? ls_p->filename[0] : NULL,
+  };
+
+  jsval_t global = js_glob(js);
+  js_set(js, global, "global", global);
+  js_set(js, global, "window", global);
+  js_set(js, global, "globalThis", global);
+  js_set(js, global, "Ant", runtime.ant_obj);
 
   return &runtime;
 }
\ No newline at end of file
diff --git a/src/snapshot.c b/src/snapshot.c
index 7774c85..3eee536 100644
--- a/src/snapshot.c
+++ b/src/snapshot.c
@@ -3,13 +3,14 @@
 #include "ant.h"
 #include "errors.h"
 #include "snapshot.h"
+#include "internal.h"
 #include "snapshot_data.h"
 
 jsval_t ant_load_snapshot(struct js *js) {
   if (!js) return js_mkerr(js, "invalid js runtime");
   jsval_t result = js_eval(js, (const char *)ant_snapshot_source, ant_snapshot_source_len);
   
-  if (js_type(result) == JS_ERR) return result;
+  if (vtype(result) == T_ERR) return result;
   return js_mktrue();
 }
 
diff --git a/tests/test_closure_spec.js b/tests/test_closure_spec.js
new file mode 100644
index 0000000..961a2ed
--- /dev/null
+++ b/tests/test_closure_spec.js
@@ -0,0 +1,58 @@
+// test_closure.js - Test closure scoping across async boundaries
+
+let results = [];
+
+// Test 1: Sync push
+results.push('1. sync');
+
+// Test 2: setTimeout with closure
+setTimeout(() => {
+  results.push('4. timeout 50ms');
+}, 50);
+
+setTimeout(() => {
+  results.push('3. timeout 10ms');
+}, 10);
+
+// Test 3: Promise with closure
+Promise.resolve('2. promise').then(v => {
+  results.push(v);
+});
+
+// Test 4: queueMicrotask with closure
+queueMicrotask(() => {
+  results.push('2. microtask');
+});
+
+// Test 5: Nested closure
+const outer = 'outer-value';
+setTimeout(() => {
+  const inner = 'inner-value';
+  setTimeout(() => {
+    results.push(`5. nested: ${outer}, ${inner}`);
+  }, 10);
+}, 60);
+
+// Final timeout to print results
+setTimeout(() => {
+  console.log('Results length:', results.length);
+  console.log('Results:');
+  for (let i = 0; i < results.length; i++) {
+    console.log(' ', results[i]);
+  }
+
+  // Expected order:
+  // 1. sync
+  // 2. promise (microtask)
+  // 2. microtask (microtask)
+  // 3. timeout 10ms
+  // 4. timeout 50ms
+  // 5. nested: outer-value, inner-value
+
+  console.log('\nExpected 6 items, got:', results.length);
+  if (results.length === 6) {
+    console.log('✓ PASS: All closures captured correctly');
+  } else {
+    console.log('✗ FAIL: Missing items - closure bug');
+  }
+}, 200);