xbintsc 0.5.6 → 0.5.20

package/runtime/xt_array_buffer.c

@@ -0,0 +1,284 @@
+/*
+ * xbintsc runtime — ArrayBuffer and DataView.
+ *
+ * An ArrayBuffer is a plain object holding its bytes as an array of numbers
+ * under a private symbol, plus a public `byteLength`. A DataView is another
+ * plain object that points at the buffer and exposes the get/set accessors;
+ * every accessor assembles the bytes explicitly, so the default big-endian
+ * order and the optional `littleEndian` argument follow ECMAScript.
+ *
+ * Keeping both as ordinary objects means the garbage collector, property
+ * lookup and the rest of the runtime need no new object kind. Typed arrays
+ * are buffer-backed views over this object and share its bytes; `new
+ * Uint8Array(buffer, offset, length)`, `.buffer` and `subarray` are handled by
+ * xt_typed_array.c.
+ */
+
+#include "rt_internal.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+static xt_value xt_ab_data_key_value = XT_UNDEFINED;
+
+static xt_value xt_ab_data_key(void) {
+  /* A symbol key keeps the backing bytes out of Object.keys / JSON.stringify,
+   * like the platform's internal [[ArrayBufferData]] slot. */
+  if (!xt_is_symbol(xt_ab_data_key_value)) {
+    xt_ab_data_key_value = xt_symbol_new(xt_string_from_cstr("__arrayBufferData"));
+    xt_gc_add_root(&xt_ab_data_key_value);
+  }
+  return xt_ab_data_key_value;
+}
+
+static xt_value xt_ab_data(xt_value buffer) {  if (!XT_IS_OBJECT(buffer)) return XT_UNDEFINED;
+  return xt_object_get(buffer, xt_ab_data_key());
+}
+
+static int xt_ab_is_buffer(xt_value value) {
+  return XT_IS_ARRAY(xt_ab_data(value));
+}
+
+static xt_value xt_ab_new(uint32_t length) {
+  xt_value buffer = xt_object_new();
+  xt_object_set(buffer, xt_string_from_cstr("byteLength"), xt_number((double)length));
+  xt_value data = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < length; i++) xt_array_push(data, xt_number(0));
+  xt_object_set(buffer, xt_ab_data_key(), data);
+  return buffer;
+}
+
+static xt_value xt_ab_slice(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv);
+static void xt_ab_install(xt_value object, const char *name, void *fn);
+
+xt_value xt_array_buffer_ctor(int32_t argc, xt_value *argv) {
+  double length = xt_to_number(xt_arg_at(argc, argv, 0));
+  if (!(length >= 0) || length > 4294967295.0) length = 0;
+  xt_value buffer = xt_ab_new((uint32_t)length);
+  xt_ab_install(buffer, "slice", (void *)xt_ab_slice);
+  return buffer;
+}
+
+int xt_is_array_buffer(xt_value value) { return xt_ab_is_buffer(value); }
+
+uint32_t xt_array_buffer_byte_length(xt_value value) {
+  if (!xt_ab_is_buffer(value)) return 0;
+  return (uint32_t)xt_to_number(xt_get(value, xt_string_from_cstr("byteLength")));
+}
+
+uint8_t xt_array_buffer_get_byte(xt_value buffer, uint32_t index) {
+  xt_value data = xt_ab_data(buffer);
+  if (!XT_IS_ARRAY(data)) return 0;
+  return (uint8_t)xt_to_int32(xt_get(data, xt_number((double)index)));
+}
+
+void xt_array_buffer_set_byte(xt_value buffer, uint32_t index, uint8_t value) {
+  xt_value data = xt_ab_data(buffer);
+  if (!XT_IS_ARRAY(data)) return;
+  xt_set(data, xt_number((double)index), xt_number((double)value));
+}
+
+static xt_value xt_ab_slice(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value data = xt_ab_data(thisValue);
+  if (!XT_IS_ARRAY(data)) return xt_ab_new(0);
+  int32_t length = xt_to_int32(xt_array_length(data));
+  int32_t start = argc > 0 && argv[0] != XT_UNDEFINED ? xt_to_int32(argv[0]) : 0;
+  int32_t end = argc > 1 && argv[1] != XT_UNDEFINED ? xt_to_int32(argv[1]) : length;
+  if (start < 0) start += length;
+  if (end < 0) end += length;
+  if (start < 0) start = 0;
+  if (end > length) end = length;
+  if (end < start) end = start;
+  xt_value result = xt_ab_new(0);
+  xt_ab_install(result, "slice", (void *)xt_ab_slice);
+  xt_value source = xt_ab_data(result);
+  for (int32_t i = start; i < end; i++) xt_array_push(source, xt_get(data, xt_number((double)i)));
+  xt_object_set(result, xt_string_from_cstr("byteLength"), xt_number((double)(end - start)));
+  return result;
+}
+
+static void xt_ab_install(xt_value object, const char *name, void *fn) {
+  xt_object_set(object, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+xt_value xt_array_buffer_static(xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return XT_UNDEFINED;
+  if (strcmp(method, "isView") == 0) {
+    xt_value value = xt_arg_at(argc, argv, 0);
+    if (xt_typed_array_kind_of(value) >= 0) return XT_TRUE;
+    if (!XT_IS_OBJECT(value)) return XT_FALSE;
+    if (((xt_object *)XT_GET_PTR(value))->header.kind != XT_OBJECT_KIND_OBJECT) return XT_FALSE;
+    xt_value buffer = xt_object_get(value, xt_string_from_cstr("buffer"));
+    return xt_bool(xt_ab_is_buffer(buffer) &&
+                   xt_object_get(value, xt_string_from_cstr("byteLength")) != XT_UNDEFINED);
+  }
+  return XT_UNDEFINED;
+}
+
+/* -- DataView ------------------------------------------------------------- */
+
+enum {
+  XT_DV_U8,
+  XT_DV_I8,
+  XT_DV_U16,
+  XT_DV_I16,
+  XT_DV_U32,
+  XT_DV_I32,
+  XT_DV_F32,
+  XT_DV_F64,
+};
+
+static uint32_t xt_dv_width(int kind) {
+  switch (kind) {
+    case XT_DV_U8:
+    case XT_DV_I8:
+      return 1;
+    case XT_DV_U16:
+    case XT_DV_I16:
+      return 2;
+    case XT_DV_U32:
+    case XT_DV_I32:
+    case XT_DV_F32:
+      return 4;
+    default:
+      return 8;
+  }
+}
+
+static int xt_dv_signed(int kind) {
+  return kind == XT_DV_I8 || kind == XT_DV_I16 || kind == XT_DV_I32;
+}
+
+static xt_value xt_dv_data(xt_value view) {
+  return xt_ab_data(xt_get(view, xt_string_from_cstr("buffer")));
+}
+
+static uint32_t xt_dv_offset(xt_value view) {
+  return (uint32_t)xt_to_number(xt_get(view, xt_string_from_cstr("byteOffset")));
+}
+
+static uint32_t xt_dv_length(xt_value view) {
+  return (uint32_t)xt_to_number(xt_get(view, xt_string_from_cstr("byteLength")));
+}
+
+static int xt_dv_check(xt_value view, xt_value indexValue, uint32_t width, uint32_t *out) {
+  double raw = xt_to_number(indexValue);
+  if (!(raw >= 0)) raw = -1;
+  int64_t index = (int64_t)raw;
+  if (index < 0 || (uint64_t)index + width > xt_dv_length(view)) {
+    xt_value message = xt_string_from_cstr("Offset is outside the bounds of the DataView");
+    xt_throw(xt_range_error_ctor(1, &message));
+  }
+  *out = xt_dv_offset(view) + (uint32_t)index;
+  return 1;
+}
+
+static uint64_t xt_dv_read_bits(xt_value view, uint32_t offset, uint32_t width, int little) {
+  xt_value data = xt_dv_data(view);
+  uint64_t value = 0;
+  for (uint32_t i = 0; i < width; i++) {
+    uint32_t index = little ? offset + width - 1 - i : offset + i;
+    uint64_t byte = (uint64_t)xt_to_number(xt_get(data, xt_number((double)index)));
+    value = (value << 8) | (byte & 0xff);
+  }
+  return value;
+}
+
+static void xt_dv_write_bits(xt_value view, uint32_t offset, uint32_t width, uint64_t value,
+                             int little) {
+  xt_value data = xt_dv_data(view);
+  for (uint32_t i = 0; i < width; i++) {
+    uint32_t shift = little ? i * 8 : (width - 1 - i) * 8;
+    uint32_t index = offset + i;
+    xt_set(data, xt_number((double)index), xt_number((double)((value >> shift) & 0xff)));
+  }
+}
+
+static xt_value xt_dv_method(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  int kind = (int)xt_to_number(xt_closure_env(env, 0));
+  int setter = (int)xt_to_number(xt_closure_env(env, 1));
+  uint32_t width = xt_dv_width(kind);
+  uint32_t offset = 0;
+  xt_dv_check(thisValue, xt_arg_at(argc, argv, 0), width, &offset);
+  int little = argc > (setter ? 2 : 1) && xt_truthy(xt_arg_at(argc, argv, setter ? 2 : 1));
+  if (setter) {
+    double value = xt_to_number(xt_arg_at(argc, argv, 1));
+    uint64_t bits;
+    if (kind == XT_DV_F32) {
+      float narrowed = (float)value;
+      uint32_t raw;
+      memcpy(&raw, &narrowed, sizeof(raw));
+      bits = raw;
+    } else if (kind == XT_DV_F64) {
+      double raw = value;
+      memcpy(&bits, &raw, sizeof(bits));
+    } else if (kind == XT_DV_I8) {
+      bits = (uint64_t)(uint8_t)(int8_t)xt_to_int32(xt_number(value));
+    } else if (kind == XT_DV_I16) {
+      bits = (uint64_t)(uint16_t)(int16_t)xt_to_int32(xt_number(value));
+    } else if (kind == XT_DV_I32) {
+      bits = (uint64_t)(uint32_t)(int32_t)xt_to_int32(xt_number(value));
+    } else {
+      bits = (uint64_t)(uint32_t)xt_to_int32(xt_number(value));
+    }
+    xt_dv_write_bits(thisValue, offset, width, bits, little);
+    return XT_UNDEFINED;
+  }
+  uint64_t bits = xt_dv_read_bits(thisValue, offset, width, little);
+  if (kind == XT_DV_F32) {
+    uint32_t raw = (uint32_t)bits;
+    float value;
+    memcpy(&value, &raw, sizeof(value));
+    return xt_number((double)value);
+  }
+  if (kind == XT_DV_F64) {
+    double value;
+    memcpy(&value, &bits, sizeof(value));
+    return xt_number(value);
+  }
+  if (xt_dv_signed(kind)) {
+    int64_t signedValue = (int64_t)bits;
+    if (width < 8) {
+      uint64_t signBit = 1ULL << (width * 8 - 1);
+      if (bits & signBit) signedValue = (int64_t)(bits | (~0ULL << (width * 8)));
+    }
+    return xt_number((double)signedValue);
+  }
+  return xt_number((double)bits);
+}
+
+xt_value xt_data_view_ctor(int32_t argc, xt_value *argv) {
+  xt_value buffer = xt_arg_at(argc, argv, 0);
+  if (!xt_ab_is_buffer(buffer)) {
+    xt_value message = xt_string_from_cstr("First argument to DataView constructor must be an ArrayBuffer");
+    xt_throw(xt_type_error_ctor(1, &message));
+  }
+  uint32_t bufferLength = (uint32_t)xt_to_number(xt_get(buffer, xt_string_from_cstr("byteLength")));
+  double rawOffset = argc > 1 ? xt_to_number(argv[1]) : 0;
+  uint32_t offset = rawOffset > 0 ? (uint32_t)rawOffset : 0;
+  double rawLength = argc > 2 && argv[2] != XT_UNDEFINED ? xt_to_number(argv[2]) : (double)(bufferLength - offset);
+  uint32_t length = rawLength > 0 ? (uint32_t)rawLength : 0;
+  if (offset > bufferLength || length > bufferLength - offset) {
+    xt_value message = xt_string_from_cstr("Invalid DataView length");
+    xt_throw(xt_range_error_ctor(1, &message));
+  }
+  xt_value view = xt_object_new();
+  xt_object_set(view, xt_string_from_cstr("buffer"), buffer);
+  xt_object_set(view, xt_string_from_cstr("byteOffset"), xt_number((double)offset));
+  xt_object_set(view, xt_string_from_cstr("byteLength"), xt_number((double)length));
+  static const char *const getters[] = {"getUint8", "getInt8", "getUint16", "getInt16",
+                                        "getUint32", "getInt32", "getFloat32", "getFloat64"};
+  static const char *const setters[] = {"setUint8", "setInt8", "setUint16", "setInt16",
+                                        "setUint32", "setInt32", "setFloat32", "setFloat64"};
+  for (int kind = 0; kind < 8; kind++) {
+    for (int isSetter = 0; isSetter < 2; isSetter++) {
+      xt_value environment[2] = {xt_number((double)kind), xt_number((double)isSetter)};
+      xt_value closure = xt_closure_new((void *)xt_dv_method, 2, environment);
+      xt_object_set(view, xt_string_from_cstr(isSetter ? setters[kind] : getters[kind]), closure);
+    }
+  }
+  return view;
+}

package/runtime/xt_async.c

@@ -11,10 +11,10 @@
  * a real C stack, `try`/`finally`, loops and locals all survive the suspension
  * without a state-machine transform.
  *
- * `await` on an already-settled value keeps the historical fast path: it
- * returns (or throws) synchronously instead of forcing a microtask turn. This
- * makes the common "await a synchronous builtin" case cheap and preserves the
- * existing ordering guarantees.
+ * `await` always yields: even a non-promise or an already-settled promise
+ * queues a microtask before the body resumes, matching the specification's
+ * interleaving with pending `.then` callbacks. (Top-level `await`, with no
+ * coroutine to suspend, still blocks on the event loop.)
  */
 
 #include "rt_internal.h"
@@ -103,32 +103,50 @@ xt_value xt_async_call(xt_value function, xt_value thisValue, int32_t argc, xt_v
 }
 
 void xt_async_wake(void *asyncPointer, xt_value value, int rejected) {
+  if (!asyncPointer) return;
+  /* Async generators park the same kind of waiter, but their completion sends
+   * a promise to the current `.next()` request instead of settling a single
+   * `async` promise. */
+  if (((xt_header *)asyncPointer)->kind == XT_OBJECT_KIND_GENERATOR) {
+    xt_generator_wake(asyncPointer, value, rejected);
+    return;
+  }
   xt_async *async = (xt_async *)asyncPointer;
-  if (!async || async->done || !async->coroutine) return;
+  if (async->done || !async->coroutine) return;
   async->resume_value = value;
   async->await_threw = rejected;
   xt_async_resume(async);
 }
 
-/* `await value`: unwrap promises, suspending the running async coroutine when
- * the promise is still pending. */
+/* `await value`: every await yields once. A settled promise (or a plain value)
+ * queues a microtask before resuming, so an await always interleaves with
+ * pending `.then` callbacks exactly like the specification. */
 xt_value xt_await(xt_value value) {
-  int state = xt_promise_state_of(value);
-  if (state < 0) return value;
-  if (state == XT_PROMISE_REJECTED) {
-    xt_throw(xt_promise_value_of(value));
-    return XT_UNDEFINED;
-  }
-  if (state == XT_PROMISE_FULFILLED) return xt_promise_value_of(value);
+  /* An `await` inside an async generator suspends that generator's coroutine
+   * while leaving the current `.next()` promise pending. */
+  xt_value generatorResult;
+  if (xt_generator_await(value, &generatorResult)) return generatorResult;
 
+  int state = xt_promise_state_of(value);
   xt_async *async = g_active_async;
-  if (async && async->coroutine) {
-    async->await_threw = 0;
-    async->resume_value = XT_UNDEFINED;
-    xt_promise_add_async_waiter(value, async);
-    xt_coroutine_leave(async->coroutine);
-    /* The waiter resumed us. A rejection is rethrown inside the coroutine so
-     * its own `try`/`catch` and `finally` see it. */
+  if (async && async->coroutine && xt_coroutine_is_current(async->coroutine)) {
+    if (state == XT_PROMISE_PENDING) {
+      async->await_threw = 0;
+      async->resume_value = XT_UNDEFINED;
+      xt_promise_add_async_waiter(value, async);
+      xt_coroutine_leave(async->coroutine);
+    } else {
+      int rejected = state == XT_PROMISE_REJECTED;
+      xt_value settled = (state == XT_PROMISE_FULFILLED || rejected)
+                             ? xt_promise_value_of(value)
+                             : value;
+      async->await_threw = rejected;
+      async->resume_value = settled;
+      xt_promise_queue_async_wake(async, settled, rejected);
+      xt_coroutine_leave(async->coroutine);
+    }
+    /* The waiter/queued microtask resumed us. A rejection is rethrown inside
+     * the coroutine so its own `try`/`catch` and `finally` see it. */
     if (async->await_threw) {
       async->await_threw = 0;
       xt_throw(async->resume_value);
@@ -137,6 +155,13 @@ xt_value xt_await(xt_value value) {
     return async->resume_value;
   }
 
+  if (state < 0) return value;
+  if (state == XT_PROMISE_REJECTED) {
+    xt_throw(xt_promise_value_of(value));
+    return XT_UNDEFINED;
+  }
+  if (state == XT_PROMISE_FULFILLED) return xt_promise_value_of(value);
+
   /* No coroutine to suspend (top-level `await`, or `await` reached outside an
    * async function): block on the reactor until the promise settles, exactly
    * like a synchronous embedder waiting for the event loop. The loop returns

package/runtime/xt_bigint/helpers.inc

@@ -54,7 +54,7 @@ static void bi_throw_type(const char *message) {
   size_t len = strlen(message);
   char *buffer = (char *)malloc(len + 16);
   snprintf(buffer, len + 16, "TypeError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   free(buffer);
 }
 
@@ -62,7 +62,7 @@ static void bi_throw_range(const char *message) {
   size_t len = strlen(message);
   char *buffer = (char *)malloc(len + 16);
   snprintf(buffer, len + 16, "RangeError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   free(buffer);
 }
 
@@ -70,7 +70,7 @@ static void bi_throw_syntax(const char *message) {
   size_t len = strlen(message);
   char *buffer = (char *)malloc(len + 16);
   snprintf(buffer, len + 16, "SyntaxError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   free(buffer);
 }
 

package/runtime/xt_builtins.c

@@ -87,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();
@@ -201,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();
 }
 
@@ -378,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) {
@@ -410,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;
       }
     }
@@ -448,8 +453,7 @@ 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 = 0;
-  function->is_async = 0;
+  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);
@@ -464,12 +468,13 @@ 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. */
@@ -493,7 +498,7 @@ 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);
@@ -538,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
 };
@@ -554,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

@@ -45,6 +45,9 @@ typedef struct {
   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)                                            \
@@ -126,7 +129,7 @@ xt_value xt_array_ctor(int32_t argc, xt_value *argv) {
   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_string_from_cstr("RangeError: Invalid array length"));
+      xt_throw(xt_error_from_message("RangeError: Invalid array length"));
       return XT_UNDEFINED;
     }
     xt_value array = xt_array_new(0, NULL);
@@ -166,6 +169,9 @@ static xt_value xt_builtin_ctor_call(const char *name, int32_t argc, xt_value *a
   }
   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);
@@ -264,6 +270,7 @@ 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",
@@ -277,7 +284,7 @@ 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",
+    "resolve", "reject", "all", "allSettled", "race", "any", "withResolvers",
 };
 static const char *const XT_TYPED_ARRAY_STATICS[] = {"from", "of"};
 
@@ -378,6 +385,9 @@ xt_value xt_builtin_prototype_for_kind(int32_t kind) {
   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;