xbintsc 0.5.6 → 0.5.21

package/runtime/xt_loop.c

@@ -33,6 +33,10 @@
 
 #define XT_LOOP_MAX_WATCHERS 1024
 
+/* Fallback wait bound while offloaded I/O is outstanding; the completion
+ * channel normally wakes `select` immediately. */
+#define XT_ASYNC_POLL_MS 10
+
 typedef struct {
   int fd;
   int events;
@@ -88,8 +92,23 @@ static int64_t xt_loop_now_ms(void) {
 #endif
 }
 
-static void xt_loop_sleep_ms(int ms) {
-  if (ms <= 0) return;
+/* Fractional monotonic milliseconds for `performance.now()`. Kept separate from
+ * xt_loop_now_ms(), which only needs whole milliseconds for timer deadlines. */
+double xt_monotonic_ms(void) {
+#if defined(_WIN32)
+  static LARGE_INTEGER frequency;
+  if (frequency.QuadPart == 0) QueryPerformanceFrequency(&frequency);
+  LARGE_INTEGER counter;
+  QueryPerformanceCounter(&counter);
+  return (double)counter.QuadPart * 1000.0 / (double)frequency.QuadPart;
+#else
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1000000.0;
+#endif
+}
+
+static void xt_loop_sleep_ms(int ms) {  if (ms <= 0) return;
 #if defined(_WIN32)
   Sleep((DWORD)ms);
 #else
@@ -228,7 +247,7 @@ static void xt_timer_run_due(void) {
 xt_value xt_set_timeout(int32_t argc, xt_value *argv) {
   xt_value callback = xt_arg_at(argc, argv, 0);
   if (!XT_IS_FUNCTION(callback)) {
-    xt_throw(xt_string_from_cstr("TypeError: The \"callback\" argument must be of type function"));
+    xt_throw(xt_error_from_message("TypeError: The \"callback\" argument must be of type function"));
     return XT_UNDEFINED;
   }
   int64_t delay = xt_timer_delay_arg(xt_arg_at(argc, argv, 1));
@@ -240,7 +259,7 @@ xt_value xt_set_timeout(int32_t argc, xt_value *argv) {
 xt_value xt_set_interval(int32_t argc, xt_value *argv) {
   xt_value callback = xt_arg_at(argc, argv, 0);
   if (!XT_IS_FUNCTION(callback)) {
-    xt_throw(xt_string_from_cstr("TypeError: The \"callback\" argument must be of type function"));
+    xt_throw(xt_error_from_message("TypeError: The \"callback\" argument must be of type function"));
     return XT_UNDEFINED;
   }
   int64_t delay = xt_timer_delay_arg(xt_arg_at(argc, argv, 1));
@@ -263,6 +282,27 @@ xt_value xt_clear_interval(int32_t argc, xt_value *argv) {
   return XT_UNDEFINED;
 }
 
+xt_value xt_set_immediate(int32_t argc, xt_value *argv) {
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) {
+    xt_value message = xt_string_from_cstr("The \"callback\" argument must be of type function");
+    xt_throw(xt_type_error_ctor(1, &message));
+    return XT_UNDEFINED;
+  }
+  int32_t extra = argc > 1 ? argc - 1 : 0;
+  uint64_t id = xt_timer_add(callback, 0, 0, extra, extra > 0 ? argv + 1 : NULL);
+  return xt_number((double)id);
+}
+
+xt_value xt_clear_immediate(int32_t argc, xt_value *argv) {
+  return xt_clear_timeout(argc, argv);
+}
+
+/* Reset to 1 while the reactor is dispatching handlers. Reusing a removed slot
+ * mid-dispatch would make the new watcher observe the current `fd_set`, so a
+ * registration from inside a callback appends instead. */
+static int xt_loop_dispatching = 0;
+
 int xt_loop_add(int fd, int events, xt_io_handler handler, void *userdata) {
   if (fd < 0 || !handler) return -1;
   xt_loop_gc_register();
@@ -273,6 +313,21 @@ int xt_loop_add(int fd, int events, xt_io_handler handler, void *userdata) {
     existing->userdata = userdata;
     return 0;
   }
+  /* Reuse a slot left by a removed watcher (the async pool toggles its wakeup
+   * descriptor on and off, and sockets are opened and closed repeatedly). */
+  if (!xt_loop_dispatching) {
+    for (int i = 0; i < xt_loop_watcher_count; i++) {
+      xt_loop_watcher *slot = &xt_loop_watchers[i];
+      if (slot->active) continue;
+      slot->fd = fd;
+      slot->events = events;
+      slot->handler = handler;
+      slot->userdata = userdata;
+      slot->active = 1;
+      xt_loop_active_count++;
+      return 0;
+    }
+  }
   if (xt_loop_watcher_count >= XT_LOOP_MAX_WATCHERS) return -1;
   xt_loop_watcher *watcher = &xt_loop_watchers[xt_loop_watcher_count++];
   watcher->fd = fd;
@@ -306,7 +361,8 @@ void xt_loop_set_main(xt_main_loop_fn fn) { xt_loop_main = fn; }
 int xt_loop_poll(int timeout_ms) {
   int has_fds = xt_loop_active_count > 0;
   int64_t next_due = xt_timer_next_due();
-  if (!has_fds && next_due < 0) {
+  int async_pending = xt_async_pending() > 0;
+  if (!has_fds && next_due < 0 && !async_pending) {
     xt_drain_microtasks();
     return 0;
   }
@@ -319,11 +375,15 @@ int xt_loop_poll(int timeout_ms) {
     if (delta > 100000000) delta = 100000000;
     if (wait_ms < 0 || delta < (int64_t)wait_ms) wait_ms = (int)delta;
   }
+  /* The completion channel normally wakes `select` immediately; polling every
+   * few milliseconds keeps progress even if it could not be registered. */
+  if (async_pending && (wait_ms < 0 || wait_ms > XT_ASYNC_POLL_MS)) wait_ms = XT_ASYNC_POLL_MS;
 
   /* Timers only: sleep, then run whatever is due. */
   if (!has_fds) {
     xt_loop_sleep_ms(wait_ms);
     xt_timer_run_due();
+    xt_async_poll();
     xt_drain_microtasks();
     return (int)(xt_loop_active_count + xt_timer_active_count());
   }
@@ -341,7 +401,9 @@ int xt_loop_poll(int timeout_ms) {
     if (watcher->fd > maxFd) maxFd = watcher->fd;
   }
   if (maxFd < 0) {
+    xt_loop_sleep_ms(wait_ms);
     xt_timer_run_due();
+    xt_async_poll();
     xt_drain_microtasks();
     return (int)(xt_loop_active_count + xt_timer_active_count());
   }
@@ -359,7 +421,13 @@ int xt_loop_poll(int timeout_ms) {
 
   if (ready > 0) {
     /* Collect the ready watchers first: handlers may add/remove descriptors. */
-    for (int i = 0; i < xt_loop_watcher_count; i++) {
+    int previousDispatching = xt_loop_dispatching;
+    xt_loop_dispatching = 1;
+    /* Snapshot the table: a handler may register a new descriptor, and it must
+     * wait for the next iteration rather than being tested against this
+     * iteration's `fd_set`. */
+    int dispatchCount = xt_loop_watcher_count;
+    for (int i = 0; i < dispatchCount; i++) {
       xt_loop_watcher *watcher = &xt_loop_watchers[i];
       if (!watcher->active) continue;
       int events = 0;
@@ -367,9 +435,11 @@ int xt_loop_poll(int timeout_ms) {
       if ((watcher->events & XT_IO_WRITE) && FD_ISSET(watcher->fd, &writeSet)) events |= XT_IO_WRITE;
       if (events) watcher->handler(watcher->userdata, events);
     }
+    xt_loop_dispatching = previousDispatching;
   }
 
   xt_timer_run_due();
+  xt_async_poll();
   xt_drain_microtasks();
   return (int)(xt_loop_active_count + xt_timer_active_count());
 }
@@ -386,4 +456,6 @@ void xt_run_event_loop(void) {
   }
 }
 
-int xt_loop_has_work(void) { return xt_loop_active_count > 0 || xt_timer_active_count() > 0; }
+int xt_loop_has_work(void) {
+  return xt_loop_active_count > 0 || xt_timer_active_count() > 0 || xt_async_pending() > 0;
+}

package/runtime/xt_performance.c

@@ -0,0 +1,37 @@
+/*
+ * xbintsc runtime — `performance.now()`.
+ *
+ * The namespace is dispatched two ways: `performance.now()` lowers to
+ * xt_performance_call(name, argc, argv), while reading the method as a value
+ * (`const now = performance.now`) goes through xt_performance_get(name), which
+ * returns a closure with the standard ABI. Both read the same monotonic clock.
+ */
+
+#include "rt_internal.h"
+
+#include <string.h>
+
+static xt_value xt_performance_now_value(xt_value thisValue, xt_value env, int32_t argc,
+                                         xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_number(xt_monotonic_ms());
+}
+
+xt_value xt_performance_get(xt_value name) {
+  const char *key = xt_string_data(name);
+  if (key != NULL && strcmp(key, "now") == 0) {
+    return xt_closure_new((void *)xt_performance_now_value, 0, NULL);
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_performance_call(xt_value name, int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  const char *key = xt_string_data(name);
+  if (key != NULL && strcmp(key, "now") == 0) return xt_number(xt_monotonic_ms());
+  return XT_UNDEFINED;
+}

package/runtime/xt_promise.c

@@ -199,6 +199,23 @@ void xt_drain_microtasks(void) {
 
 xt_value xt_promise_create(void) { return xt_promise_value(xt_promise_new()); }
 
+/* Queue a microtask that resumes a suspended async coroutine with an already
+ * settled value. Reusing a reaction keeps FIFO order with pending `.then`
+ * callbacks (the specification always yields once per `await`). */
+void xt_promise_queue_async_wake(void *asyncPointer, xt_value settled, int rejected) {
+  xt_promise *promise = xt_promise_new();
+  promise->state = rejected ? XT_PROMISE_REJECTED : XT_PROMISE_FULFILLED;
+  promise->value = settled;
+  xt_reaction *reaction = (xt_reaction *)malloc(sizeof(xt_reaction));
+  if (!reaction) abort();
+  reaction->promise = promise;
+  reaction->on_fulfilled = XT_UNDEFINED;
+  reaction->on_rejected = XT_UNDEFINED;
+  reaction->result = NULL;
+  reaction->async = asyncPointer;
+  xt_microtask_push(reaction);
+}
+
 void xt_promise_fulfill(xt_value promise, xt_value value) {
   xt_promise *target = xt_as_promise(promise);
   if (target) xt_promise_resolve_into(target, value);
@@ -287,9 +304,34 @@ xt_value xt_promise_reject(xt_value value) {
   return xt_promise_value(promise);
 }
 
+static xt_value xt_promise_with_resolvers_resolve(xt_value thisValue, xt_value env, int32_t argc,
+                                                  xt_value *argv) {
+  (void)thisValue;
+  xt_promise_fulfill(xt_closure_env(env, 0), xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_promise_with_resolvers_reject(xt_value thisValue, xt_value env, int32_t argc,
+                                                 xt_value *argv) {
+  (void)thisValue;
+  xt_promise_reject_value(xt_closure_env(env, 0), xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
 xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
+  if (strcmp(fn, "withResolvers") == 0) {
+    xt_value promise = xt_promise_create();
+    xt_value environment[1] = {promise};
+    xt_value result = xt_object_new();
+    xt_object_set(result, xt_string_from_cstr("promise"), promise);
+    xt_object_set(result, xt_string_from_cstr("resolve"),
+                  xt_closure_new((void *)xt_promise_with_resolvers_resolve, 1, environment));
+    xt_object_set(result, xt_string_from_cstr("reject"),
+                  xt_closure_new((void *)xt_promise_with_resolvers_reject, 1, environment));
+    return result;
+  }
   if (strcmp(fn, "resolve") == 0) return xt_promise_resolve(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "reject") == 0) return xt_promise_reject(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "all") == 0 || strcmp(fn, "allSettled") == 0 || strcmp(fn, "race") == 0 || strcmp(fn, "any") == 0) {
@@ -321,7 +363,12 @@ xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
           xt_promise_settle(result, XT_PROMISE_REJECTED, inner->value);
           return xt_promise_value(result);
         }
-        xt_value settled = xt_await(item);
+        xt_value settled;
+        if (xt_promise_state_of(item) == XT_PROMISE_FULFILLED) {
+          settled = xt_promise_value_of(item);
+        } else {
+          settled = xt_await(item);
+        }
         if (strcmp(fn, "any") == 0 || strcmp(fn, "race") == 0) {
           xt_promise_settle(result, XT_PROMISE_FULFILLED, settled);
           return xt_promise_value(result);
@@ -386,3 +433,18 @@ xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt
   *handled = 0;
   return XT_UNDEFINED;
 }
+
+xt_value xt_queue_microtask(int32_t argc, xt_value *argv) {
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) {
+    xt_value message = xt_string_from_cstr("The \"callback\" argument must be of type function");
+    xt_throw(xt_type_error_ctor(1, &message));
+    return XT_UNDEFINED;
+  }
+  /* Reuse the promise reaction queue: a settled promise's `then` callback is
+   * exactly a microtask, and it keeps FIFO order with pending `.then`s. */
+  xt_value promise = xt_promise_resolve(XT_UNDEFINED);
+  int handled = 0;
+  xt_promise_method(promise, "then", 1, &callback, &handled);
+  return XT_UNDEFINED;
+}

package/runtime/xt_stdlib/arrays.inc

@@ -150,7 +150,7 @@ static xt_value xt_array_reduce(xt_value value, xt_value fn, int32_t hasInitial,
     accumulator = array->items[0];
     i = 1;
   } else {
-    xt_throw(xt_string_from_cstr("TypeError: Reduce of empty array with no initial value"));
+    xt_throw(xt_error_from_message("TypeError: Reduce of empty array with no initial value"));
     return XT_UNDEFINED;
   }
   for (; i < array->length; i++) {

package/runtime/xt_stdlib/dispatch.inc

@@ -1,5 +1,16 @@
 /* -- method dispatch ------------------------------------------------------ */
 
+/* A method that no built-in table recognises must throw, exactly like a
+ * missing property called as a function in JavaScript. Returning `undefined`
+ * made typos and unimplemented APIs (e.g. `"x".normalize()`) fail silently. */
+static _Noreturn void xt_throw_no_method(const char *type, const char *method) {
+  char message[256];
+  snprintf(message, sizeof(message), "TypeError: %s has no callable method '%s'", type, method);
+  xt_value argument = xt_string_from_cstr(message);
+  xt_throw(xt_type_error_ctor(1, &argument));
+  abort();
+}
+
 static xt_value xt_array_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
   *handled = 1;
   if (strcmp(method, "push") == 0) {
@@ -92,7 +103,7 @@ static xt_value xt_method_value_invoke(xt_value thisValue, xt_value env, int32_t
     snprintf(message, sizeof(message),
              "TypeError: Cannot read properties of undefined (reading '%s')",
              method ? method : "method");
-    xt_throw(xt_string_from_cstr(message));
+    xt_throw(xt_error_from_message(message));
   }
   return xt_call_method(thisValue, name, argc, argv);
 }
@@ -159,6 +170,18 @@ static const xt_method_spec XT_SET_METHODS[] = {
   {"entries", 0}, {"forEach", 1},
 };
 
+static const xt_method_spec XT_WEAKMAP_METHODS[] = {
+  {"get", 1}, {"set", 2}, {"has", 1}, {"delete", 1},
+};
+
+static const xt_method_spec XT_WEAKSET_METHODS[] = {
+  {"add", 1}, {"has", 1}, {"delete", 1},
+};
+
+static const xt_method_spec XT_WEAKREF_METHODS[] = {
+  {"deref", 0},
+};
+
 static const xt_method_spec XT_REGEXP_METHODS[] = {
   {"test", 1}, {"exec", 1}, {"toString", 0},
 };
@@ -215,6 +238,12 @@ xt_value xt_method_value(xt_value target, xt_value name) {
       known = xt_method_lookup(XT_MAP_METHODS, XT_NAME_COUNT(XT_MAP_METHODS), method, &arity);
     } else if (kind == XT_OBJECT_KIND_SET) {
       known = xt_method_lookup(XT_SET_METHODS, XT_NAME_COUNT(XT_SET_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_WEAK_MAP) {
+      known = xt_method_lookup(XT_WEAKMAP_METHODS, XT_NAME_COUNT(XT_WEAKMAP_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_WEAK_SET) {
+      known = xt_method_lookup(XT_WEAKSET_METHODS, XT_NAME_COUNT(XT_WEAKSET_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_WEAK_REF) {
+      known = xt_method_lookup(XT_WEAKREF_METHODS, XT_NAME_COUNT(XT_WEAKREF_METHODS), method, &arity);
     } else if (kind == XT_OBJECT_KIND_REGEXP) {
       known = xt_method_lookup(XT_REGEXP_METHODS, XT_NAME_COUNT(XT_REGEXP_METHODS), method, &arity);
     } else if (kind == XT_OBJECT_KIND_PROMISE) {
@@ -240,7 +269,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
    * resolve it as an ordinary property and call it with `target` as `this`. */
   if (xt_is_symbol(name)) {
     if (target == XT_UNDEFINED || target == XT_NULL) {
-      xt_throw(xt_string_from_cstr("TypeError: Cannot read properties of null (reading a Symbol)"));
+      xt_throw(xt_error_from_message("TypeError: Cannot read properties of null (reading a Symbol)"));
     }
     xt_value fn = xt_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
@@ -253,7 +282,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
      * `target` as `this`, instead of silently returning undefined. */
     xt_value fn = xt_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
-    xt_throw(xt_string_from_cstr("TypeError: value at computed index is not a function"));
+    xt_throw(xt_error_from_message("TypeError: value at computed index is not a function"));
     return XT_UNDEFINED;
   }
   if (target == XT_UNDEFINED || target == XT_NULL) {
@@ -261,13 +290,13 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     char message[256];
     snprintf(message, sizeof(message),
              "TypeError: Cannot read properties of %s (reading '%s')", base, method);
-    xt_throw(xt_string_from_cstr(message));
+    xt_throw(xt_error_from_message(message));
   }
   int handled = 0;
   if (xt_is_symbol(target)) {
     if (strcmp(method, "toString") == 0) return xt_symbol_to_string(target);
     if (strcmp(method, "valueOf") == 0) return target;
-    return XT_UNDEFINED;
+    xt_throw_no_method("symbol", method);
   }
   if (XT_IS_OBJECT(target)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(target);
@@ -303,7 +332,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: object has no callable method '%s'", method);
-      xt_throw(xt_string_from_cstr(message));
+      xt_throw(xt_error_from_message(message));
     }
     return XT_UNDEFINED;
   }
@@ -360,32 +389,38 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: function has no callable method '%s'", method);
-      xt_throw(xt_string_from_cstr(message));
+      xt_throw(xt_error_from_message(message));
     }
     return XT_UNDEFINED;
   }
   if (XT_IS_ARRAY(target)) {
     xt_value result = xt_ext_array_method(target, method, argc, argv, &handled);
     if (handled) return result;
-    return xt_array_method(target, method, argc, argv, &handled);
+    result = xt_array_method(target, method, argc, argv, &handled);
+    if (handled) return result;
+    xt_throw_no_method("array", method);
   }
   if (XT_IS_STRING(target)) {
     xt_value result = xt_ext_string_method(target, method, argc, argv, &handled);
     if (handled) return result;
-    return xt_string_method(target, method, argc, argv, &handled);
+    result = xt_string_method(target, method, argc, argv, &handled);
+    if (handled) return result;
+    xt_throw_no_method("string", method);
   }
   if (XT_IS_BIGINT(target)) {
     xt_value result = xt_bigint_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    xt_throw_no_method("bigint", method);
   }
   if (XT_IS_NUMBER(target)) {
     xt_value result = xt_ext_number_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    xt_throw_no_method("number", method);
   }
   if (target == XT_TRUE || target == XT_FALSE) {
     if (strcmp(method, "toString") == 0) return target == XT_TRUE ? xt_string_from_cstr("true") : xt_string_from_cstr("false");
     if (strcmp(method, "valueOf") == 0) return target;
-    return XT_UNDEFINED;
+    xt_throw_no_method("boolean", method);
   }
-  return XT_UNDEFINED;
+  xt_throw_no_method("value", method);
 }

package/runtime/xt_stdlib/strings.inc

@@ -190,7 +190,7 @@ static xt_value xt_string_repeat(xt_value value, xt_value countValue) {
   if (!s) return value;
   int32_t count = xt_to_int32(countValue);
   if (count < 0) {
-    xt_throw(xt_string_from_cstr("RangeError: Invalid count value"));
+    xt_throw(xt_error_from_message("RangeError: Invalid count value"));
     return XT_UNDEFINED;
   }
   xt_string *out = xt_string_alloc((size_t)s->length * (size_t)count);

package/runtime/xt_stdlib2/array-statics.inc

@@ -1,5 +1,16 @@
 /* -- Array statics -------------------------------------------------------- */
 
+/* True when `Array.from` should consume the value through the iteration
+ * protocol instead of the array-like `length` path. Typed arrays stay on the
+ * length path because their indexed properties already work that way. */
+static int xt_array_from_is_iterable(xt_value value) {
+  if (xt_is_map(value) || xt_is_set(value) || xt_is_generator(value)) return 1;
+  if (XT_IS_OBJECT(value) && xt_typed_array_kind_of(value) < 0) {
+    return XT_IS_FUNCTION(xt_object_get(value, xt_symbol_well_known("iterator")));
+  }
+  return 0;
+}
+
 xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
@@ -24,6 +35,20 @@ xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv) {
         if (XT_IS_FUNCTION(mapper)) { xt_value args[2] = {item, xt_number((double)i)}; item = xt_closure_call(mapper, 2, args); }
         xt_array_push(out, item);
       }
+    } else if (xt_array_from_is_iterable(source)) {
+      /* Map, Set, generators, iterator objects and custom `[Symbol.iterator]`
+       * values do not expose a `length`; walk their `next()` protocol instead
+       * of silently producing an empty array. */
+      xt_value iterator = xt_iter_open(source);
+      for (uint32_t i = 0;; i++) {
+        if (!xt_truthy(xt_iter_has(iterator, xt_number((double)i)))) break;
+        xt_value item = xt_iter_value(iterator, xt_number((double)i));
+        if (XT_IS_FUNCTION(mapper)) {
+          xt_value args[2] = {item, xt_number((double)i)};
+          item = xt_closure_call(mapper, 2, args);
+        }
+        xt_array_push(out, item);
+      }
     } else {
       double length = xt_to_number(xt_get(source, xt_string_from_cstr("length")));
       for (int32_t i = 0; i < (int32_t)length; i++) {

package/runtime/xt_stdlib2/arrays.inc

@@ -85,7 +85,7 @@ static xt_value xt_array_sort(xt_value value, xt_value fn) {
   int hasFn = XT_IS_FUNCTION(fn);
   xt_value *scratch = (xt_value *)malloc(sizeof(xt_value) * array->length);
   if (!scratch) {
-    xt_throw(xt_string_from_cstr("RangeError: out of memory in Array.prototype.sort"));
+    xt_throw(xt_error_from_message("RangeError: out of memory in Array.prototype.sort"));
     return value;
   }
   xt_array_merge_sort(array->items, scratch, array->length, fn, hasFn);
@@ -225,7 +225,9 @@ static xt_value xt_array_with(xt_value value, xt_value indexValue, xt_value newV
   int32_t index = xt_to_int32(indexValue);
   if (index < 0) index += (int32_t)array->length;
   if (index < 0 || index >= (int32_t)array->length) {
-    xt_throw(xt_add(xt_string_from_cstr("RangeError: Invalid index : "), xt_to_string(indexValue)));
+    xt_value message =
+        xt_add(xt_string_from_cstr("RangeError: Invalid index : "), xt_to_string(indexValue));
+    xt_throw(xt_error_from_message(xt_string_data(message)));
     return copy;
   }
   array->items[index] = newValue;
@@ -266,7 +268,7 @@ xt_value xt_ext_array_method(xt_value target, const char *method, int32_t argc,
     xt_value acc;
     if (argc >= 2) acc = argv[1];
     else if (array->length > 0) acc = array->items[i--];
-    else { xt_throw(xt_string_from_cstr("TypeError: Reduce of empty array with no initial value")); return XT_UNDEFINED; }
+    else { xt_throw(xt_error_from_message("TypeError: Reduce of empty array with no initial value")); return XT_UNDEFINED; }
     for (; i >= 0; i--) {
       xt_value args[4] = {acc, array->items[i], xt_number((double)i), target};
       acc = xt_closure_call(fn, 4, args);

package/runtime/xt_stdlib2/container.inc

@@ -2,6 +2,11 @@ xt_value xt_ext_container_method(xt_value target, const char *method, int32_t ar
   xt_object *obj = (xt_object *)XT_GET_PTR(target);
   if (obj->header.kind == XT_OBJECT_KIND_MAP) return xt_map_method(target, method, argc, argv, handled);
   if (obj->header.kind == XT_OBJECT_KIND_SET) return xt_set_method(target, method, argc, argv, handled);
+  if (obj->header.kind == XT_OBJECT_KIND_WEAK_MAP ||
+      obj->header.kind == XT_OBJECT_KIND_WEAK_SET ||
+      obj->header.kind == XT_OBJECT_KIND_WEAK_REF) {
+    return xt_weak_method(target, method, argc, argv, handled);
+  }
   if (obj->header.kind == XT_OBJECT_KIND_DATE) return xt_date_method(target, method, argc, argv, handled);
   if (obj->header.kind == XT_OBJECT_KIND_REGEXP) {
     xt_regexp *regexp = (xt_regexp *)obj;