xbintsc 0.5.6 → 0.5.21

package/runtime/xt_async_io.c

@@ -0,0 +1,333 @@
+/*
+ * xbintsc runtime — asynchronous I/O offload pool.
+ *
+ * JavaScript's `await` can suspend an `async` body on a pending promise, but
+ * the host still has to provide the work that eventually settles it. Sockets
+ * and timers are readiness based and live directly on the `select(2)` reactor;
+ * file I/O and DNS have no portable readiness notification, so they run on a
+ * small pool of worker threads and report back through the same reactor.
+ *
+ * The threading contract is the important part:
+ *
+ *   - `job->run` executes on a worker thread and may only touch plain C memory
+ *     (paths, buffers, syscalls). It must never call the `xt_*` value API, the
+ *     collector, `xt_throw`, or the event loop.
+ *   - `job->complete` executes on the main thread after the reactor wakes up.
+ *     That is where results become `xt_value`s, promises settle, and a job may
+ *     submit follow-up work (fetch redirects do exactly that).
+ *   - `job->roots` keeps values needed across the suspension alive. They are
+ *     written on the main thread and scanned by the collector like any other
+ *     root.
+ *
+ * Completion wakes the reactor through a self-pipe (POSIX) or a loopback UDP
+ * socket (Windows, whose `select` only understands sockets). The reactor also
+ * polls the pool every iteration, so a failed wakeup degrades to a short wait
+ * rather than a hang.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <winsock2.h>
+#include <windows.h>
+#include <process.h>
+#else
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <unistd.h>
+#endif
+
+#define XT_ASYNC_WORKERS 4
+/* A fallback bound for the reactor wait while work is outstanding. With a
+ * working wakeup the wait ends immediately when a job completes. */
+#define XT_ASYNC_POLL_MS 10
+
+static xt_async_job *xt_async_work_head = NULL;
+static xt_async_job *xt_async_work_tail = NULL;
+static xt_async_job *xt_async_done_head = NULL;
+static xt_async_job *xt_async_done_tail = NULL;
+
+/* Every submitted, not-yet-released job. Mutated only on the main thread. */
+static xt_async_job *xt_async_live_head = NULL;
+
+static int xt_async_pending_jobs = 0;
+static int xt_async_workers_started = 0;
+static int xt_async_worker_count = 0;
+static int xt_async_roots_registered = 0;
+static int xt_async_watcher_fd = -1;
+
+#if defined(_WIN32)
+/* Statically initialised like the POSIX primitives below: the reactor polls
+ * the pool on every timer/socket iteration, even when no async job was ever
+ * submitted, so the lock must be usable before `xt_async_submit` runs. */
+static SRWLOCK xt_async_lock = SRWLOCK_INIT;
+static CONDITION_VARIABLE xt_async_cond = CONDITION_VARIABLE_INIT;
+static SOCKET xt_async_wake_socket = INVALID_SOCKET;
+#define XT_ASYNC_LOCK() AcquireSRWLockExclusive(&xt_async_lock)
+#define XT_ASYNC_UNLOCK() ReleaseSRWLockExclusive(&xt_async_lock)
+static void xt_async_cond_wait(void) {
+  SleepConditionVariableSRW(&xt_async_cond, &xt_async_lock, INFINITE, 0);
+}
+static void xt_async_cond_signal(void) { WakeConditionVariable(&xt_async_cond); }
+#else
+static pthread_mutex_t xt_async_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t xt_async_cond = PTHREAD_COND_INITIALIZER;
+static int xt_async_wake_pipe[2] = {-1, -1};
+#define XT_ASYNC_LOCK() pthread_mutex_lock(&xt_async_lock)
+#define XT_ASYNC_UNLOCK() pthread_mutex_unlock(&xt_async_lock)
+static void xt_async_cond_wait(void) { pthread_cond_wait(&xt_async_cond, &xt_async_lock); }
+static void xt_async_cond_signal(void) { pthread_cond_signal(&xt_async_cond); }
+#endif
+
+static void xt_async_scan_roots(void);
+
+/* -- wakeup channel ------------------------------------------------------- */
+
+static int xt_async_wake_fd(void) {
+#if defined(_WIN32)
+  return (int)xt_async_wake_socket;
+#else
+  return xt_async_wake_pipe[0];
+#endif
+}
+
+static void xt_async_wake_create(void) {
+#if defined(_WIN32)
+  if (xt_async_wake_socket != INVALID_SOCKET) return;
+  SOCKET socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
+  if (socket_fd == INVALID_SOCKET) return;
+  struct sockaddr_in address;
+  memset(&address, 0, sizeof(address));
+  address.sin_family = AF_INET;
+  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  address.sin_port = 0;
+  if (bind(socket_fd, (struct sockaddr *)&address, sizeof(address)) != 0) {
+    closesocket(socket_fd);
+    return;
+  }
+  int length = (int)sizeof(address);
+  if (getsockname(socket_fd, (struct sockaddr *)&address, &length) != 0 ||
+      connect(socket_fd, (struct sockaddr *)&address, sizeof(address)) != 0) {
+    closesocket(socket_fd);
+    return;
+  }
+  u_long nonBlocking = 1;
+  ioctlsocket(socket_fd, FIONBIO, &nonBlocking);
+  xt_async_wake_socket = socket_fd;
+#else
+  if (xt_async_wake_pipe[0] >= 0) return;
+  if (pipe(xt_async_wake_pipe) != 0) {
+    xt_async_wake_pipe[0] = -1;
+    xt_async_wake_pipe[1] = -1;
+    return;
+  }
+  for (int i = 0; i < 2; i++) {
+    int flags = fcntl(xt_async_wake_pipe[i], F_GETFL, 0);
+    if (flags >= 0) fcntl(xt_async_wake_pipe[i], F_SETFL, flags | O_NONBLOCK);
+  }
+#endif
+}
+
+/* Called by a worker after it queues a completion. */
+static void xt_async_wakeup(void) {
+#if defined(_WIN32)
+  if (xt_async_wake_socket == INVALID_SOCKET) return;
+  char byte = 1;
+  send(xt_async_wake_socket, &byte, 1, 0);
+#else
+  if (xt_async_wake_pipe[1] < 0) return;
+  char byte = 1;
+  ssize_t ignored = write(xt_async_wake_pipe[1], &byte, 1);
+  (void)ignored;
+#endif
+}
+
+static void xt_async_wake_drain(void) {
+#if defined(_WIN32)
+  if (xt_async_wake_socket == INVALID_SOCKET) return;
+  char buffer[256];
+  while (recv(xt_async_wake_socket, buffer, (int)sizeof(buffer), 0) > 0) {
+  }
+#else
+  if (xt_async_wake_pipe[0] < 0) return;
+  char buffer[256];
+  while (read(xt_async_wake_pipe[0], buffer, sizeof(buffer)) > 0) {
+  }
+#endif
+}
+
+static void xt_async_wake_handler(void *userdata, int events) {
+  (void)userdata;
+  (void)events;
+  xt_async_poll();
+}
+
+/* -- queue helpers (lock held) -------------------------------------------- */
+
+static void xt_async_push_work(xt_async_job *job) {
+  job->next = NULL;
+  if (xt_async_work_tail) xt_async_work_tail->next = job;
+  else xt_async_work_head = job;
+  xt_async_work_tail = job;
+}
+
+static void xt_async_push_done(xt_async_job *job) {
+  job->next = NULL;
+  if (xt_async_done_tail) xt_async_done_tail->next = job;
+  else xt_async_done_head = job;
+  xt_async_done_tail = job;
+}
+
+static xt_async_job *xt_async_pop_work(void) {
+  xt_async_job *job = xt_async_work_head;
+  if (!job) return NULL;
+  xt_async_work_head = job->next;
+  if (!xt_async_work_head) xt_async_work_tail = NULL;
+  return job;
+}
+
+static xt_async_job *xt_async_pop_done(void) {
+  xt_async_job *job = xt_async_done_head;
+  if (!job) return NULL;
+  xt_async_done_head = job->next;
+  if (!xt_async_done_head) xt_async_done_tail = NULL;
+  return job;
+}
+
+/* -- live job registry (main thread only) --------------------------------- */
+
+static void xt_async_live_add(xt_async_job *job) {
+  job->live_prev = NULL;
+  job->live_next = xt_async_live_head;
+  if (xt_async_live_head) xt_async_live_head->live_prev = job;
+  xt_async_live_head = job;
+}
+
+static void xt_async_live_remove(xt_async_job *job) {
+  if (job->live_prev) job->live_prev->live_next = job->live_next;
+  else xt_async_live_head = job->live_next;
+  if (job->live_next) job->live_next->live_prev = job->live_prev;
+  job->live_next = NULL;
+  job->live_prev = NULL;
+}
+
+static void xt_async_scan_roots(void) {
+  for (xt_async_job *job = xt_async_live_head; job; job = job->live_next) {
+    for (int i = 0; i < XT_ASYNC_ROOT_SLOTS; i++) xt_gc_mark_value(job->roots[i]);
+  }
+}
+
+static void xt_async_register_roots(void) {
+  if (xt_async_roots_registered) return;
+  xt_async_roots_registered = 1;
+  xt_gc_register_root_provider(xt_async_scan_roots);
+}
+
+/* -- worker threads -------------------------------------------------------- */
+
+static void xt_async_worker_run(void) {
+  for (;;) {
+    XT_ASYNC_LOCK();
+    xt_async_job *job = xt_async_pop_work();
+    while (!job) {
+      xt_async_cond_wait();
+      job = xt_async_pop_work();
+    }
+    XT_ASYNC_UNLOCK();
+    if (job->run) job->run(job);
+    XT_ASYNC_LOCK();
+    xt_async_push_done(job);
+    XT_ASYNC_UNLOCK();
+    xt_async_wakeup();
+  }
+}
+
+#if defined(_WIN32)
+static unsigned __stdcall xt_async_worker_entry(void *argument) {
+  (void)argument;
+  xt_async_worker_run();
+  return 0;
+}
+#else
+static void *xt_async_worker_entry(void *argument) {
+  (void)argument;
+  xt_async_worker_run();
+  return NULL;
+}
+#endif
+
+/* Spawn the pool lazily. Called with the lock held so a worker that starts
+ * immediately blocks until the queue is published. */
+static void xt_async_start_workers(void) {
+  if (xt_async_workers_started) return;
+  xt_async_workers_started = 1;
+  for (int i = 0; i < XT_ASYNC_WORKERS; i++) {
+#if defined(_WIN32)
+    uintptr_t handle = _beginthreadex(NULL, 0, xt_async_worker_entry, NULL, 0, NULL);
+    if (handle == 0) break;
+    CloseHandle((HANDLE)handle);
+#else
+    pthread_t thread;
+    if (pthread_create(&thread, NULL, xt_async_worker_entry, NULL) != 0) break;
+    pthread_detach(thread);
+#endif
+    xt_async_worker_count++;
+  }
+}
+
+/* -- public API ------------------------------------------------------------ */
+
+int xt_async_pending(void) { return xt_async_pending_jobs; }
+
+void xt_async_submit(xt_async_job *job) {
+  if (!job || !job->run) {
+    if (job && job->release) job->release(job);
+    else free(job);
+    return;
+  }
+  xt_async_register_roots();
+  xt_async_live_add(job);
+  xt_async_pending_jobs++;
+
+  xt_async_wake_create();
+  if (xt_async_watcher_fd < 0 && xt_async_wake_fd() >= 0) {
+    if (xt_loop_add(xt_async_wake_fd(), XT_IO_READ, xt_async_wake_handler, NULL) == 0) {
+      xt_async_watcher_fd = xt_async_wake_fd();
+    }
+  }
+
+  XT_ASYNC_LOCK();
+  xt_async_start_workers();
+  if (xt_async_worker_count > 0) {
+    xt_async_push_work(job);
+    xt_async_cond_signal();
+    XT_ASYNC_UNLOCK();
+    return;
+  }
+  /* No worker could be created: complete on the reactor's next poll. */
+  xt_async_push_done(job);
+  XT_ASYNC_UNLOCK();
+}
+
+void xt_async_poll(void) {
+  if (xt_async_watcher_fd >= 0) xt_async_wake_drain();
+  for (;;) {
+    XT_ASYNC_LOCK();
+    xt_async_job *job = xt_async_pop_done();
+    XT_ASYNC_UNLOCK();
+    if (!job) break;
+    if (job->complete) job->complete(job);
+    xt_async_live_remove(job);
+    if (job->release) job->release(job);
+    else free(job);
+    xt_async_pending_jobs--;
+  }
+  if (xt_async_pending_jobs == 0 && xt_async_watcher_fd >= 0) {
+    xt_loop_remove(xt_async_watcher_fd);
+    xt_async_watcher_fd = -1;
+  }
+}

package/runtime/xt_async_io.h

@@ -0,0 +1,47 @@
+/*
+ * xbintsc runtime — asynchronous I/O offload API.
+ *
+ * Declared separately from `rt_internal.h` so the internal header stays within
+ * the repository's file-size budget. Extensions that offload blocking work
+ * include `rt_internal.h`, which includes this header.
+ */
+#ifndef XT_RT_ASYNC_IO_H
+#define XT_RT_ASYNC_IO_H
+
+#include "rt.h"
+
+/*
+ * Some host operations (file I/O, DNS, a blocking HTTP exchange) have no
+ * portable readiness notification, so they run on a small worker pool and
+ * report back to the main thread. The contract is strict: `run` executes on a
+ * worker and may only touch plain C memory, while `complete` executes on the
+ * main thread and may build/consume `xt_value`s.
+ *
+ * A job begins with this struct. `roots` keeps up to four values alive while
+ * the job is queued or running: the slots are scanned by the collector and are
+ * only written from the main thread. `next` links the work/completion queue and
+ * is owned by the pool; callers never touch it. `release` (optional) frees the
+ * job after `complete` returns.
+ */
+#define XT_ASYNC_ROOT_SLOTS 4
+
+typedef struct xt_async_job xt_async_job;
+
+struct xt_async_job {
+  xt_async_job *next;
+  xt_async_job *live_next;
+  xt_async_job *live_prev;
+  void (*run)(xt_async_job *job);
+  void (*complete)(xt_async_job *job);
+  void (*release)(xt_async_job *job);
+  xt_value roots[XT_ASYNC_ROOT_SLOTS];
+};
+
+/** Queue `job` on a worker (never blocks the caller). Takes ownership. */
+void xt_async_submit(xt_async_job *job);
+/** Number of submitted jobs whose completion has not run yet. */
+int xt_async_pending(void);
+/** Run completed jobs and drop the loop watcher when the queue becomes idle. */
+void xt_async_poll(void);
+
+#endif /* XT_RT_ASYNC_IO_H */

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;