xbintsc 0.3.87 → 0.5.20

package/runtime/xt_builtins.c

@@ -18,23 +18,22 @@
 
 xt_value xt_object_values(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
-  if (!XT_IS_OBJECT(value)) return result;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) {
-    if (XT_IS_STRING(obj->properties[i].key)) xt_array_push(result, obj->properties[i].value);
-  }
+  xt_value keys = xt_object_keys(value);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) xt_array_push(result, xt_get(value, array->items[i]));
   return result;
 }
 
 xt_value xt_object_entries(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
-  if (!XT_IS_OBJECT(value)) return result;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) {
-    if (!XT_IS_STRING(obj->properties[i].key)) continue;
+  xt_value keys = xt_object_keys(value);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) {
     xt_value pair = xt_array_new(0, NULL);
-    xt_array_push(pair, obj->properties[i].key);
-    xt_array_push(pair, obj->properties[i].value);
+    xt_array_push(pair, array->items[i]);
+    xt_array_push(pair, xt_get(value, array->items[i]));
     xt_array_push(result, pair);
   }
   return result;
@@ -45,8 +44,11 @@ xt_value xt_object_assign(int32_t argc, xt_value *argv) {
   xt_value target = argv[0];
   if (!XT_IS_OBJECT(target)) return target;
   for (int32_t i = 1; i < argc; i++) {
-    if (!XT_IS_OBJECT(argv[i])) continue;
-    xt_object *source = (xt_object *)XT_GET_PTR(argv[i]);
+    if (!XT_IS_OBJECT(argv[i]) && !XT_IS_ARRAY(argv[i]) && !XT_IS_STRING(argv[i])) continue;
+    /* Arrays and strings contribute their index properties, exactly like
+     * `{ ..."ab" }` / `Object.assign({}, [1, 2])` in ECMAScript. */
+    xt_value properties = xt_object_rest(argv[i], 0, NULL);
+    xt_object *source = (xt_object *)XT_GET_PTR(properties);
     for (uint32_t j = 0; j < source->count; j++) {
       xt_object_set(target, source->properties[j].key, source->properties[j].value);
     }
@@ -85,7 +87,7 @@ static void xt_object_rest_copy(xt_value target, xt_value key, xt_value value, i
  */
 xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv) {
   if (source == XT_UNDEFINED || source == XT_NULL) {
-    xt_throw(xt_string_from_cstr("TypeError: Cannot destructure null or undefined"));
+    xt_throw(xt_error_from_message("TypeError: Cannot destructure null or undefined"));
     return XT_UNDEFINED;
   }
   xt_value result = xt_object_new();
@@ -102,11 +104,11 @@ xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv) {
 
   if (XT_IS_STRING(source)) {
     xt_string *string = (xt_string *)XT_GET_PTR(source);
-    const char *bytes = xt_string_bytes(string);
-    for (uint32_t i = 0; i < string->length; i++) {
+    uint32_t units = xt_string_utf16_length(string);
+    for (uint32_t i = 0; i < units; i++) {
       char buffer[16];
       snprintf(buffer, sizeof(buffer), "%u", i);
-      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_new(bytes + i, 1), argc, argv);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_unit_value(string, (int32_t)i), argc, argv);
     }
     return result;
   }
@@ -199,7 +201,7 @@ xt_value xt_is_finite(int32_t argc, xt_value *argv) {
 static _Noreturn void xt_throw_uri_error(const char *message) {
   char buffer[96];
   snprintf(buffer, sizeof(buffer), "URIError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   abort();
 }
 
@@ -376,6 +378,10 @@ XT_BUILTIN_TRAMPOLINE(xt_builtin_value_setTimeout, xt_set_timeout)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_clearTimeout, xt_clear_timeout)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_setInterval, xt_set_interval)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_clearInterval, xt_clear_interval)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_setImmediate, xt_set_immediate)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_clearImmediate, xt_clear_immediate)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_queueMicrotask, xt_queue_microtask)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_structuredClone, xt_structured_clone)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_fetch, xt_fetch)
 
 xt_value xt_in(xt_value key, xt_value value) {
@@ -395,7 +401,7 @@ xt_value xt_in(xt_value key, xt_value value) {
     xt_string *k = xt_as_string(xt_to_string(key));
     if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
     int32_t index = xt_to_int32(key);
-    return xt_bool(index >= 0 && (uint32_t)index < s->length);
+    return xt_bool(index >= 0 && (uint32_t)index < xt_string_utf16_length(s));
   }
   return XT_FALSE;
 }
@@ -408,6 +414,7 @@ xt_value xt_delete(xt_value value, xt_value key) {
       if (xt_property_key_equals(obj->properties[i].key, k)) {
         for (uint32_t j = i + 1; j < obj->count; j++) obj->properties[j - 1] = obj->properties[j];
         obj->count--;
+        xt_object_shape_changed(obj);
         break;
       }
     }
@@ -446,6 +453,8 @@ xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
   function->properties = NULL;
   function->environment = NULL;
   function->prototype = XT_UNDEFINED;
+  function->is_generator = function->is_async = function->is_async_generator = 0;
+  function->builtin_name = NULL;
   if (env_count > 0) {
     function->environment = (xt_value *)malloc(sizeof(xt_value) * (size_t)env_count);
     for (int32_t i = 0; i < env_count; i++) function->environment[i] = env[i];
@@ -459,13 +468,17 @@ xt_value xt_closure_call(xt_value value, int32_t argc, xt_value *argv) {
 
 xt_value xt_call_with_this(xt_value value, xt_value thisValue, int32_t argc, xt_value *argv) {
   if (!XT_IS_FUNCTION(value)) {
-    xt_throw(xt_string_from_cstr("TypeError: value is not a function"));
+    xt_throw(xt_error_from_message("TypeError: value is not a function"));
     return XT_UNDEFINED;
   }
   xt_function *function = (xt_function *)XT_GET_PTR(value);
   /* Calling a generator function returns a suspended generator instead of
-   * running the body. */
+   * running the body. `async function*` is a generator whose `.next()` returns
+   * promises; `xt_generator_new` reads the marker from the closure. */
   if (function->is_generator) return xt_generator_new(value, thisValue, argc, argv);
+  /* An `async` function runs its body on a coroutine and returns a promise,
+   * which may already be settled or may resolve after an event-loop turn. */
+  if (function->is_async) return xt_async_call(value, thisValue, argc, argv);
   /* The closure value itself is threaded through as `env` so the callee can
    * read its captures with xt_closure_env(env, i). */
   return function->code(thisValue, value, argc, argv);
@@ -478,11 +491,6 @@ xt_value xt_function_set_prototype(xt_value value, xt_value proto) {
   return value;
 }
 
-xt_value xt_function_set_generator(xt_value value) {
-  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_generator = 1;
-  return value;
-}
-
 xt_value xt_function_get_prototype(xt_value value) {
   if (XT_IS_FUNCTION(value)) return ((xt_function *)XT_GET_PTR(value))->prototype;
   return XT_UNDEFINED;
@@ -490,29 +498,29 @@ xt_value xt_function_get_prototype(xt_value value) {
 
 xt_value xt_new(xt_value ctor, int32_t argc, xt_value *argv) {
   if (!XT_IS_FUNCTION(ctor)) {
-    xt_throw(xt_string_from_cstr("TypeError: constructor is not a function"));
+    xt_throw(xt_error_from_message("TypeError: constructor is not a function"));
     return XT_UNDEFINED;
   }
   xt_function *function = (xt_function *)XT_GET_PTR(ctor);
   xt_value proto = function->prototype;
   xt_value instance = xt_object_new_with_proto(XT_IS_OBJECT(proto) ? proto : XT_UNDEFINED);
   xt_value result = function->code(instance, ctor, argc, argv);
-  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result)) return result;
+  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result) || XT_IS_FUNCTION(result)) return result;
   return instance;
 }
 
 xt_value xt_instance_of(xt_value value, xt_value ctor) {
   if (!XT_IS_FUNCTION(ctor)) return XT_FALSE;
   xt_value proto = ((xt_function *)XT_GET_PTR(ctor))->prototype;
-  if (!XT_IS_OBJECT(proto)) return XT_FALSE;
-  if (!XT_IS_OBJECT(value)) return XT_FALSE;
-  xt_object *cur = (xt_object *)XT_GET_PTR(value);
-  xt_object *target = (xt_object *)XT_GET_PTR(proto);
-  cur = (xt_object *)XT_GET_PTR(XT_IS_OBJECT(cur->prototype) ? cur->prototype : XT_UNDEFINED);
-  while (cur) {
-    if (cur == target) return XT_TRUE;
-    if (!XT_IS_OBJECT(cur->prototype)) break;
-    cur = (xt_object *)XT_GET_PTR(cur->prototype);
+  if (XT_IS_OBJECT(proto) || XT_IS_ARRAY(proto) || XT_IS_FUNCTION(proto)) {
+    /* Walk the value's [[Prototype]] chain. `xt_object_get_prototype` knows the
+     * layout of every kind (arrays carry a prototype field; Map/Set/Date/... use
+     * their built-in prototype), so this is safe for containers too. */
+    xt_value cursor = xt_object_get_prototype(value);
+    while (cursor != XT_UNDEFINED && cursor != XT_NULL) {
+      if (cursor == proto) return XT_TRUE;
+      cursor = xt_object_get_prototype(cursor);
+    }
   }
   return XT_FALSE;
 }
@@ -520,10 +528,11 @@ xt_value xt_instance_of(xt_value value, xt_value ctor) {
 /*
  * `value instanceof Array` (and the rest of the built-in constructors).
  *
- * Built-in constructors are not first-class values: the codegen recognises the
- * name and asks this helper instead. Ids match `BUILTIN_INSTANCEOF` in
- * `src/codegen/generator/tables.ts`; 16..24 map onto the runtime's `XT_TA_*`
- * order (Uint8Array first).
+ * The codegen recognises the direct spelling and asks this helper instead of
+ * materialising the constructor value; an alias (`const A = Array`) goes
+ * through the ordinary prototype chain in `xt_instance_of`. Ids match
+ * `BUILTIN_INSTANCEOF` in `src/codegen/generator/tables.ts`; 16..24 map onto
+ * the runtime's `XT_TA_*` order (Uint8Array first).
  */
 enum {
   XT_INSTANCE_ARRAY = 0,
@@ -534,6 +543,7 @@ enum {
   XT_INSTANCE_DATE = 5,
   XT_INSTANCE_REGEXP = 6,
   XT_INSTANCE_PROMISE = 7,
+  XT_INSTANCE_WEAK_MAP = 8, XT_INSTANCE_WEAK_SET = 9, XT_INSTANCE_WEAK_REF = 10,
   XT_INSTANCE_TYPED_ARRAY_FIRST = 16,
   XT_INSTANCE_TYPED_ARRAY_LAST = 24
 };
@@ -550,16 +560,14 @@ xt_value xt_instance_of_builtin(xt_value value, int32_t id) {
       return xt_bool(XT_IS_OBJECT(value) || XT_IS_ARRAY(value) || XT_IS_FUNCTION(value));
     case XT_INSTANCE_FUNCTION:
       return xt_bool(XT_IS_FUNCTION(value));
-    case XT_INSTANCE_MAP:
-      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_MAP));
-    case XT_INSTANCE_SET:
-      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_SET));
-    case XT_INSTANCE_DATE:
-      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_DATE));
-    case XT_INSTANCE_REGEXP:
-      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_REGEXP));
-    case XT_INSTANCE_PROMISE:
-      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_PROMISE));
+    case XT_INSTANCE_MAP: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_MAP));
+    case XT_INSTANCE_SET: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_SET));
+    case XT_INSTANCE_WEAK_MAP: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_WEAK_MAP));
+    case XT_INSTANCE_WEAK_SET: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_WEAK_SET));
+    case XT_INSTANCE_WEAK_REF: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_WEAK_REF));
+    case XT_INSTANCE_DATE: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_DATE));
+    case XT_INSTANCE_REGEXP: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_REGEXP));
+    case XT_INSTANCE_PROMISE: return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_PROMISE));
     default:
       if (id >= XT_INSTANCE_TYPED_ARRAY_FIRST && id <= XT_INSTANCE_TYPED_ARRAY_LAST) {
         return xt_bool(xt_typed_array_kind_of(value) == id - XT_INSTANCE_TYPED_ARRAY_FIRST);

package/runtime/xt_constructors.c

@@ -0,0 +1,399 @@
+/*
+ * xbintsc runtime - built-in constructors as first-class values.
+ *
+ * `Array`, `Object`, `Map`, the Error family, typed arrays and the other
+ * globals were previously only recognised by name in the code generator. This
+ * unit turns them into ordinary function values:
+ *
+ *     const A = Array;
+ *     const a = new A(1, 2, 3);
+ *     A.isArray(a);              // statics travel with the value
+ *     a instanceof A;            // prototype chain, not the name
+ *
+ * Every constructor is cached (and registered as a GC root), has metadata
+ * (`name` / `length`), a `prototype` object and a `builtin_name` that the
+ * property path uses to resolve statics.
+ */
+
+#include "rt_internal.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* -- constructor table ---------------------------------------------------- */
+
+enum {
+  XT_PROTO_OBJECT,
+  XT_PROTO_ARRAY,
+  XT_PROTO_FUNCTION,
+  XT_PROTO_PLAIN,
+  XT_PROTO_ERROR,
+  XT_PROTO_TYPED
+};
+
+typedef struct {
+  const char *name;
+  int32_t arity;
+  int32_t prototype;
+} xt_ctor_spec;
+
+#define XT_CTOR_SPECS(X)                                                       \
+  X(Array, 1, XT_PROTO_ARRAY)                                              \
+  X(Object, 1, XT_PROTO_OBJECT)                                            \
+  X(Function, 1, XT_PROTO_FUNCTION)                                        \
+  X(Map, 0, XT_PROTO_PLAIN)                                                \
+  X(Set, 0, XT_PROTO_PLAIN)                                                \
+  X(WeakMap, 0, XT_PROTO_PLAIN)                                            \
+  X(WeakSet, 0, XT_PROTO_PLAIN)                                            \
+  X(WeakRef, 1, XT_PROTO_PLAIN)                                            \
+  X(Date, 7, XT_PROTO_PLAIN)                                               \
+  X(RegExp, 2, XT_PROTO_PLAIN)                                             \
+  X(Promise, 1, XT_PROTO_PLAIN)                                            \
+  X(Uint8Array, 3, XT_PROTO_TYPED)                                        \
+  X(Int8Array, 3, XT_PROTO_TYPED)                                         \
+  X(Uint8ClampedArray, 3, XT_PROTO_TYPED)                                 \
+  X(Uint16Array, 3, XT_PROTO_TYPED)                                       \
+  X(Int16Array, 3, XT_PROTO_TYPED)                                        \
+  X(Uint32Array, 3, XT_PROTO_TYPED)                                       \
+  X(Int32Array, 3, XT_PROTO_TYPED)                                        \
+  X(Float32Array, 3, XT_PROTO_TYPED)                                      \
+  X(Float64Array, 3, XT_PROTO_TYPED)                                      \
+  X(Error, 1, XT_PROTO_ERROR)                                             \
+  X(TypeError, 1, XT_PROTO_ERROR)                                         \
+  X(RangeError, 1, XT_PROTO_ERROR)                                        \
+  X(SyntaxError, 1, XT_PROTO_ERROR)                                       \
+  X(ReferenceError, 1, XT_PROTO_ERROR)                                    \
+  X(EvalError, 1, XT_PROTO_ERROR)                                         \
+  X(URIError, 1, XT_PROTO_ERROR)                                          \
+  X(AggregateError, 2, XT_PROTO_ERROR)                                    \
+  X(Number, 1, XT_PROTO_PLAIN)                                            \
+  X(String, 1, XT_PROTO_PLAIN)                                            \
+  X(Boolean, 1, XT_PROTO_PLAIN)                                           \
+  X(BigInt, 1, XT_PROTO_PLAIN)                                            \
+  X(Symbol, 0, XT_PROTO_PLAIN)
+
+#define XT_CTOR_ENUM(name, arity, proto) XT_CTOR_##name,
+enum { XT_CTOR_SPECS(XT_CTOR_ENUM) XT_CTOR_COUNT };
+#undef XT_CTOR_ENUM
+
+#define XT_CTOR_ENTRY(name, arity, proto) {#name, arity, proto},
+static const xt_ctor_spec XT_CTOR_TABLE[XT_CTOR_COUNT] = {XT_CTOR_SPECS(XT_CTOR_ENTRY)};
+#undef XT_CTOR_ENTRY
+
+static xt_value xt_ctor_cache[XT_CTOR_COUNT];
+static xt_value xt_ctor_plain_protos[XT_CTOR_COUNT];
+static int xt_ctor_cache_ready = 0;
+
+static void xt_ctor_cache_init(void) {
+  if (xt_ctor_cache_ready) return;
+  xt_ctor_cache_ready = 1;
+  xt_gc_add_root_range(xt_ctor_cache, XT_CTOR_COUNT);
+  xt_gc_add_root_range(xt_ctor_plain_protos, XT_CTOR_COUNT);
+  for (int i = 0; i < XT_CTOR_COUNT; i++) {
+    xt_ctor_cache[i] = XT_UNDEFINED;
+    xt_ctor_plain_protos[i] = XT_UNDEFINED;
+  }
+}
+
+static int xt_ctor_index(const char *name) {
+  if (!name) return -1;
+  for (int i = 0; i < XT_CTOR_COUNT; i++) {
+    if (strcmp(XT_CTOR_TABLE[i].name, name) == 0) return i;
+  }
+  return -1;
+}
+
+/* -- construction --------------------------------------------------------- */
+
+static int xt_ctor_is_typed_array(const char *name) {
+  int index = xt_ctor_index(name);
+  return index >= XT_CTOR_Uint8Array && index <= XT_CTOR_Float64Array;
+}
+
+static int xt_ctor_is_error(const char *name) {
+  static const char *const names[] = {
+      "Error",     "TypeError", "RangeError",  "SyntaxError",
+      "ReferenceError", "EvalError", "URIError", "AggregateError",
+  };
+  for (size_t i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
+    if (strcmp(name, names[i]) == 0) return 1;
+  }
+  return 0;
+}
+
+xt_value xt_array_ctor(int32_t argc, xt_value *argv) {
+  /* `Array(3)` allocates a length-3 array; any other argument list becomes the
+   * elements. */
+  if (argc == 1 && XT_IS_NUMBER(argv[0])) {
+    double length = xt_to_number(argv[0]);
+    if (!(length >= 0) || floor(length) != length || length > 4294967295.0) {
+      xt_throw(xt_error_from_message("RangeError: Invalid array length"));
+      return XT_UNDEFINED;
+    }
+    xt_value array = xt_array_new(0, NULL);
+    if (length > 0) xt_array_set(array, xt_number(length - 1), XT_UNDEFINED);
+    return array;
+  }
+  return xt_array_new(argc, argv);
+}
+
+xt_value xt_object_ctor(int32_t argc, xt_value *argv) {
+  if (argc == 0) return xt_object_new();
+  xt_value value = argv[0];
+  if (value == XT_UNDEFINED || value == XT_NULL) return xt_object_new();
+  /* `Object(value)` returns the object unchanged. Primitives are not boxed in
+   * this runtime, so they pass through like `new Object(primitive)` did. */
+  return value;
+}
+
+/* `Function()` / `new Function()`: source evaluation is not supported, so the
+ * constructor gives an empty function (declared functions get their metadata
+ * from the codegen; this body simply does nothing). */
+static xt_value xt_function_ctor_body(xt_value thisValue, xt_value env, int32_t argc,
+                                      xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_builtin_ctor_call(const char *name, int32_t argc, xt_value *argv) {
+  xt_value nameValue = xt_string_from_cstr(name);
+  if (strcmp(name, "Array") == 0) return xt_array_ctor(argc, argv);
+  if (strcmp(name, "Object") == 0) return xt_object_ctor(argc, argv);
+  if (strcmp(name, "Function") == 0) {
+    return xt_closure_new((void *)xt_function_ctor_body, 0, NULL);
+  }
+  if (strcmp(name, "Map") == 0) return xt_map_ctor(argc, argv);
+  if (strcmp(name, "Set") == 0) return xt_set_ctor(argc, argv);
+  if (strcmp(name, "WeakMap") == 0) return xt_weak_map_ctor(argc, argv);
+  if (strcmp(name, "WeakSet") == 0) return xt_weak_set_ctor(argc, argv);
+  if (strcmp(name, "WeakRef") == 0) return xt_weak_ref_ctor(argc, argv);
+  if (strcmp(name, "Date") == 0) return xt_date_ctor(argc, argv);
+  if (strcmp(name, "RegExp") == 0) return xt_regexp_ctor(argc, argv);
+  if (strcmp(name, "Promise") == 0) return xt_promise_ctor(argc, argv);
+  if (strcmp(name, "Number") == 0) return xt_number_ctor(argc, argv);
+  if (strcmp(name, "String") == 0) return xt_string_ctor(argc, argv);
+  if (strcmp(name, "Boolean") == 0) return xt_boolean_ctor(argc, argv);
+  if (strcmp(name, "BigInt") == 0) return xt_bigint_ctor(argc, argv);
+  if (strcmp(name, "Symbol") == 0) return xt_symbol(argc, argv);
+  if (xt_ctor_is_typed_array(name)) return xt_typed_array_ctor_by_name(nameValue, argc, argv);
+  if (xt_ctor_is_error(name)) return xt_error_ctor_by_name(nameValue, argc, argv);
+  return XT_UNDEFINED;
+}
+
+/* The closure body of every first-class constructor. The name travels in
+ * environment slot 0. */
+static xt_value xt_builtin_ctor_invoke(xt_value thisValue, xt_value env, int32_t argc,
+                                       xt_value *argv) {
+  (void)thisValue;
+  xt_value nameValue = xt_closure_env(env, 0);
+  const char *name = xt_string_data(nameValue);
+  if (!name) return XT_UNDEFINED;
+  return xt_builtin_ctor_call(name, argc, argv);
+}
+
+/* -- prototypes ----------------------------------------------------------- */
+
+static xt_value xt_ctor_prototype(int index, xt_value nameValue) {
+  const xt_ctor_spec *spec = &XT_CTOR_TABLE[index];
+  switch (spec->prototype) {
+    case XT_PROTO_OBJECT:
+      return xt_object_prototype();
+    case XT_PROTO_ARRAY:
+      return xt_array_prototype();
+    case XT_PROTO_FUNCTION:
+      return xt_function_prototype();
+    case XT_PROTO_ERROR:
+      return xt_error_prototype(nameValue);
+    case XT_PROTO_TYPED:
+      return xt_typed_array_prototype(nameValue);
+    case XT_PROTO_PLAIN:
+    default:
+      if (xt_ctor_plain_protos[index] == XT_UNDEFINED) {
+        xt_ctor_plain_protos[index] = xt_object_new();
+      }
+      return xt_ctor_plain_protos[index];
+  }
+}
+
+xt_value xt_builtin_constructor(xt_value nameValue) {
+  if (!XT_IS_STRING(nameValue)) return XT_UNDEFINED;
+  xt_ctor_cache_init();
+  const char *name = xt_string_data(nameValue);
+  int index = xt_ctor_index(name);
+  if (index < 0) return XT_UNDEFINED;
+  if (xt_ctor_cache[index] != XT_UNDEFINED) return xt_ctor_cache[index];
+
+  /* The Error family already has a first-class constructor factory that keeps
+   * one closure per prototype (`__ctor`), so reuse it to keep
+   * `err.constructor === Error` stable no matter which side is evaluated
+   * first. */
+  if (xt_ctor_is_error(name)) {
+    xt_value errorCtor = xt_error_constructor(nameValue);
+    if (errorCtor != XT_UNDEFINED) {
+      xt_ctor_cache[index] = errorCtor;
+      return errorCtor;
+    }
+  }
+
+  xt_value env[1] = {nameValue};
+  xt_value closure = xt_closure_new((void *)xt_builtin_ctor_invoke, 1, env);
+  xt_function *function = (xt_function *)XT_GET_PTR(closure);
+  function->builtin_name = XT_CTOR_TABLE[index].name;
+  xt_function_set_metadata(closure, nameValue, XT_CTOR_TABLE[index].arity);
+  /* Cache before resolving the prototype: `Array.prototype` and
+   * `Object.prototype` install their `constructor` property by asking for the
+   * constructor again. */
+  xt_ctor_cache[index] = closure;
+
+  xt_value proto = xt_ctor_prototype(index, nameValue);
+  if (proto != XT_UNDEFINED) {
+    xt_function_set_prototype(closure, proto);
+    /* `Array.prototype` and `Object.prototype` install their own constructor
+     * while resolving the prototype above; every other prototype gets it here. */
+    int32_t kind = XT_CTOR_TABLE[index].prototype;
+    if (kind != XT_PROTO_ARRAY && kind != XT_PROTO_OBJECT) {
+      xt_object_set(proto, xt_string_from_cstr("constructor"), closure);
+    }
+  }
+  return closure;
+}
+
+/* -- statics -------------------------------------------------------------- */
+
+static const char *const XT_ARRAY_STATICS[] = {"isArray", "of", "from"};
+static const char *const XT_OBJECT_STATICS[] = {
+    "keys", "values", "entries", "assign", "getOwnPropertyNames",
+    "getOwnPropertySymbols", "groupBy", "freeze", "isFrozen", "fromEntries",
+    "getPrototypeOf", "setPrototypeOf", "hasOwn", "is", "create",
+    "defineProperty", "getOwnPropertyDescriptor", "getOwnPropertyDescriptors",
+};
+static const char *const XT_NUMBER_STATICS[] = {
+    "isInteger", "isSafeInteger", "isFinite", "isNaN", "parseFloat", "parseInt",
+};
+static const char *const XT_NUMBER_CONSTANTS[] = {
+    "MAX_SAFE_INTEGER", "MIN_SAFE_INTEGER", "MAX_VALUE", "MIN_VALUE", "EPSILON",
+    "POSITIVE_INFINITY", "NEGATIVE_INFINITY", "NaN",
+};
+static const char *const XT_STRING_STATICS[] = {"fromCharCode", "fromCodePoint", "raw"};
+static const char *const XT_BIGINT_STATICS[] = {"asIntN", "asUintN"};
+static const char *const XT_SYMBOL_STATICS[] = {"for", "keyFor"};
+static const char *const XT_DATE_STATICS[] = {"now", "parse", "UTC"};
+static const char *const XT_PROMISE_STATICS[] = {
+    "resolve", "reject", "all", "allSettled", "race", "any", "withResolvers",
+};
+static const char *const XT_TYPED_ARRAY_STATICS[] = {"from", "of"};
+
+static int xt_name_in(const char *name, const char *const *names, size_t count) {
+  for (size_t i = 0; i < count; i++) {
+    if (strcmp(name, names[i]) == 0) return 1;
+  }
+  return 0;
+}
+
+#define XT_NAMES_COUNT(names) (sizeof(names) / sizeof((names)[0]))
+
+static int xt_ctor_has_static(const char *namespace, const char *method) {
+  if (strcmp(namespace, "Array") == 0)
+    return xt_name_in(method, XT_ARRAY_STATICS, XT_NAMES_COUNT(XT_ARRAY_STATICS));
+  if (strcmp(namespace, "Object") == 0)
+    return xt_name_in(method, XT_OBJECT_STATICS, XT_NAMES_COUNT(XT_OBJECT_STATICS));
+  if (strcmp(namespace, "Number") == 0)
+    return xt_name_in(method, XT_NUMBER_STATICS, XT_NAMES_COUNT(XT_NUMBER_STATICS));
+  if (strcmp(namespace, "String") == 0)
+    return xt_name_in(method, XT_STRING_STATICS, XT_NAMES_COUNT(XT_STRING_STATICS));
+  if (strcmp(namespace, "BigInt") == 0)
+    return xt_name_in(method, XT_BIGINT_STATICS, XT_NAMES_COUNT(XT_BIGINT_STATICS));
+  if (strcmp(namespace, "Symbol") == 0)
+    return xt_name_in(method, XT_SYMBOL_STATICS, XT_NAMES_COUNT(XT_SYMBOL_STATICS));
+  if (strcmp(namespace, "Date") == 0)
+    return xt_name_in(method, XT_DATE_STATICS, XT_NAMES_COUNT(XT_DATE_STATICS));
+  if (strcmp(namespace, "Promise") == 0)
+    return xt_name_in(method, XT_PROMISE_STATICS, XT_NAMES_COUNT(XT_PROMISE_STATICS));
+  if (xt_ctor_is_typed_array(namespace))
+    return xt_name_in(method, XT_TYPED_ARRAY_STATICS, XT_NAMES_COUNT(XT_TYPED_ARRAY_STATICS));
+  return 0;
+}
+
+static xt_value xt_builtin_static_call(const char *namespace, const char *method, int32_t argc,
+                                       xt_value *argv) {
+  xt_value nameValue = xt_string_from_cstr(namespace);
+  xt_value methodValue = xt_string_from_cstr(method);
+  if (strcmp(namespace, "Array") == 0) return xt_array_static(methodValue, argc, argv);
+  if (strcmp(namespace, "Object") == 0) return xt_object_static(methodValue, argc, argv);
+  if (strcmp(namespace, "Number") == 0) return xt_number_static(methodValue, argc, argv);
+  if (strcmp(namespace, "String") == 0) return xt_string_static(methodValue, argc, argv);
+  if (strcmp(namespace, "BigInt") == 0) return xt_bigint_static(methodValue, argc, argv);
+  if (strcmp(namespace, "Symbol") == 0) return xt_symbol_static(methodValue, argc, argv);
+  if (strcmp(namespace, "Date") == 0) return xt_date_static(methodValue, argc, argv);
+  if (strcmp(namespace, "Promise") == 0) return xt_promise_static(methodValue, argc, argv);
+  if (xt_ctor_is_typed_array(namespace))
+    return xt_typed_array_static_by_name(nameValue, methodValue, argc, argv);
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_builtin_static_invoke(xt_value thisValue, xt_value env, int32_t argc,
+                                         xt_value *argv) {
+  (void)thisValue;
+  const char *namespace = xt_string_data(xt_closure_env(env, 0));
+  const char *method = xt_string_data(xt_closure_env(env, 1));
+  if (!namespace || !method) return XT_UNDEFINED;
+  return xt_builtin_static_call(namespace, method, argc, argv);
+}
+
+xt_value xt_builtin_static_value(xt_value ctor, xt_value key) {
+  if (!XT_IS_FUNCTION(ctor) || !XT_IS_STRING(key)) return XT_UNDEFINED;
+  xt_function *function = (xt_function *)XT_GET_PTR(ctor);
+  const char *namespace = function->builtin_name;
+  if (!namespace) return XT_UNDEFINED;
+  const char *method = xt_string_data(key);
+  if (!method) return XT_UNDEFINED;
+
+  /* Values that are not functions. */
+  if (strcmp(namespace, "Symbol") == 0) {
+    xt_value wellKnown = xt_symbol_get(key);
+    if (wellKnown != XT_UNDEFINED) return wellKnown;
+  }
+  if (strcmp(namespace, "Number") == 0 &&
+      xt_name_in(method, XT_NUMBER_CONSTANTS, XT_NAMES_COUNT(XT_NUMBER_CONSTANTS))) {
+    return xt_number_static(key, 0, NULL);
+  }
+  if (xt_ctor_is_typed_array(namespace) && strcmp(method, "BYTES_PER_ELEMENT") == 0) {
+    xt_value nameValue = xt_string_from_cstr(namespace);
+    xt_value proto = xt_typed_array_prototype(nameValue);
+    return xt_object_get(proto, key);
+  }
+
+  if (!xt_ctor_has_static(namespace, method)) return XT_UNDEFINED;
+  if (xt_truthy(xt_object_has_own(ctor, key))) return xt_object_get(ctor, key);
+
+  xt_value env[2] = {xt_string_from_cstr(namespace), key};
+  xt_value closure = xt_closure_new((void *)xt_builtin_static_invoke, 2, env);
+  xt_function_set_metadata(closure, key, 0);
+  xt_object_set(ctor, key, closure);
+  return closure;
+}
+
+/* -- prototype lookup for runtime kinds ----------------------------------- */
+
+xt_value xt_builtin_prototype_for_kind(int32_t kind) {
+  const char *name = NULL;
+  switch (kind) {
+    case XT_OBJECT_KIND_MAP: name = "Map"; break;
+    case XT_OBJECT_KIND_SET: name = "Set"; break;
+    case XT_OBJECT_KIND_WEAK_MAP: name = "WeakMap"; break;
+    case XT_OBJECT_KIND_WEAK_SET: name = "WeakSet"; break;
+    case XT_OBJECT_KIND_WEAK_REF: name = "WeakRef"; break;
+    case XT_OBJECT_KIND_DATE: name = "Date"; break;
+    case XT_OBJECT_KIND_REGEXP: name = "RegExp"; break;
+    case XT_OBJECT_KIND_PROMISE: name = "Promise"; break;
+    case XT_OBJECT_KIND_SYMBOL: name = "Symbol"; break;
+    default: return XT_UNDEFINED;
+  }
+  xt_value constructor = xt_builtin_constructor(xt_string_from_cstr(name));
+  return xt_function_get_prototype(constructor);
+}