xbintsc 0.1.8 → 0.1.10

package/runtime/xt_builtins.c

@@ -160,6 +160,7 @@ xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
   function->arity = -1;
   function->properties = NULL;
   function->environment = NULL;
+  function->prototype = XT_UNDEFINED;
   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];
@@ -168,6 +169,10 @@ xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
 }
 
 xt_value xt_closure_call(xt_value value, int32_t argc, xt_value *argv) {
+  return xt_call_with_this(value, XT_UNDEFINED, argc, 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"));
     return XT_UNDEFINED;
@@ -175,7 +180,48 @@ xt_value xt_closure_call(xt_value value, int32_t argc, xt_value *argv) {
   xt_function *function = (xt_function *)XT_GET_PTR(value);
   /* 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(value, argc, argv);
+  return function->code(thisValue, value, argc, argv);
+}
+
+xt_value xt_this(void) { return XT_UNDEFINED; }
+
+xt_value xt_function_set_prototype(xt_value value, xt_value proto) {
+  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->prototype = proto;
+  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;
+}
+
+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"));
+    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;
+  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);
+  }
+  return XT_FALSE;
 }
 
 xt_value xt_closure_env(xt_value value, int32_t index) {

package/runtime/xt_containers.c

@@ -28,14 +28,30 @@ static void xt_object_reserve(xt_object *obj, uint32_t needed) {
   obj->capacity = capacity;
 }
 
-xt_value xt_object_new(void) {
+xt_value xt_object_new(void) { return xt_object_new_with_proto(XT_UNDEFINED); }
+
+xt_value xt_object_new_with_proto(xt_value proto) {
   xt_object *obj = (xt_object *)xt_alloc(sizeof(xt_object), XT_OBJECT_KIND_OBJECT);
   obj->count = 0;
   obj->capacity = 0;
   obj->properties = NULL;
+  obj->prototype = proto;
+  obj->frozen = 0;
+  obj->is_array_base = 0;
   return XT_FROM_PTR(XT_TAG_OBJECT, obj);
 }
 
+xt_object *xt_as_object(xt_value value) {
+  if (XT_IS_OBJECT(value)) return (xt_object *)XT_GET_PTR(value);
+  if (XT_IS_FUNCTION(value)) {
+    /* Functions carry their own property bag (used for static members). */
+    xt_function *fn = (xt_function *)XT_GET_PTR(value);
+    if (!fn->properties) fn->properties = (xt_object *)XT_GET_PTR(xt_object_new_with_proto(XT_UNDEFINED));
+    return fn->properties;
+  }
+  return NULL;
+}
+
 static xt_property *xt_object_find(xt_object *obj, xt_string *key) {
   for (uint32_t i = 0; i < obj->count; i++) {
     if (xt_string_equals(obj->properties[i].key, key)) return &obj->properties[i];
@@ -43,17 +59,30 @@ static xt_property *xt_object_find(xt_object *obj, xt_string *key) {
   return NULL;
 }
 
+xt_property *xt_object_find_property(xt_object *obj, xt_string *key) {
+  return obj ? xt_object_find(obj, key) : NULL;
+}
+
 xt_value xt_object_get(xt_value value, xt_value key) {
-  if (!XT_IS_OBJECT(value)) return XT_UNDEFINED;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return XT_UNDEFINED;
   xt_value keyString = xt_to_string(key);
-  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
-  return prop ? prop->value : XT_UNDEFINED;
+  xt_string *k = xt_as_string(keyString);
+  /* Walk the prototype chain like JavaScript property lookup. */
+  xt_object *cur = obj;
+  while (cur) {
+    xt_property *prop = xt_object_find(cur, k);
+    if (prop) return prop->value;
+    if (!XT_IS_OBJECT(cur->prototype)) break;
+    cur = (xt_object *)XT_GET_PTR(cur->prototype);
+  }
+  return XT_UNDEFINED;
 }
 
 xt_value xt_object_set(xt_value value, xt_value key, xt_value newValue) {
-  if (!XT_IS_OBJECT(value)) return newValue;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return newValue;
+  if (obj->frozen) return newValue;
   xt_value keyString = xt_to_string(key);
   xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
   if (prop) {
@@ -67,6 +96,48 @@ xt_value xt_object_set(xt_value value, xt_value key, xt_value newValue) {
   return newValue;
 }
 
+xt_value xt_object_get_prototype(xt_value value) {
+  xt_object *obj = xt_as_object(value);
+  if (obj) return obj->prototype;
+  return XT_UNDEFINED;
+}
+
+xt_value xt_object_set_prototype(xt_value value, xt_value proto) {
+  xt_object *obj = xt_as_object(value);
+  if (obj && !obj->frozen) obj->prototype = proto;
+  return value;
+}
+
+xt_value xt_object_freeze(xt_value value) {
+  xt_object *obj = xt_as_object(value);
+  if (obj) obj->frozen = 1;
+  return value;
+}
+
+int xt_object_is_frozen(xt_value value) {
+  xt_object *obj = xt_as_object(value);
+  return obj ? obj->frozen : 0;
+}
+
+xt_value xt_object_has_own(xt_value value, xt_value key) {
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return XT_FALSE;
+  xt_value keyString = xt_to_string(key);
+  return xt_bool(xt_object_find(obj, xt_as_string(keyString)) != NULL);
+}
+
+xt_value xt_object_from_entries(xt_value entries) {
+  xt_value result = xt_object_new();
+  xt_array *array = xt_as_array(entries);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) {
+    xt_array *pair = xt_as_array(array->items[i]);
+    if (!pair || pair->length < 2) continue;
+    xt_object_set(result, pair->items[0], pair->items[1]);
+  }
+  return result;
+}
+
 xt_value xt_object_has(xt_value value, xt_value key) {
   if (!XT_IS_OBJECT(value)) return XT_FALSE;
   xt_object *obj = (xt_object *)XT_GET_PTR(value);
@@ -190,7 +261,22 @@ xt_value xt_array_spread(xt_value target, xt_value source) {
 
 xt_value xt_get(xt_value target, xt_value key) {
   if (XT_IS_ARRAY(target)) return xt_array_get(target, key);
-  if (XT_IS_OBJECT(target)) return xt_object_get(target, key);
+  if (XT_IS_FUNCTION(target)) return xt_object_get(target, key);
+  if (XT_IS_OBJECT(target)) {
+    /* Map/Set expose `.size`; promises, dates and regexps have their own
+     * getters implemented in the standard library. */
+    xt_object *obj = (xt_object *)XT_GET_PTR(target);
+    if (obj->header.kind == XT_OBJECT_KIND_MAP || obj->header.kind == XT_OBJECT_KIND_SET) {
+      if (XT_IS_STRING(key)) {
+        xt_string *k = xt_as_string(key);
+        if (k->length == 4 && memcmp(k->data, "size", 4) == 0) {
+          int32_t size = obj->header.kind == XT_OBJECT_KIND_MAP ? xt_map_size(target) : xt_set_size(target);
+          return xt_number((double)size);
+        }
+      }
+    }
+    return xt_object_get(target, key);
+  }
   if (XT_IS_STRING(target)) {
     /* Property access on a string: `.length` and numeric indexing. */
     xt_string *s = xt_as_string(target);
@@ -207,6 +293,7 @@ xt_value xt_get(xt_value target, xt_value key) {
 
 xt_value xt_set(xt_value target, xt_value key, xt_value value) {
   if (XT_IS_ARRAY(target)) return xt_array_set(target, key, value);
+  if (XT_IS_FUNCTION(target)) return xt_object_set(target, key, value);
   if (XT_IS_OBJECT(target)) return xt_object_set(target, key, value);
   return value;
 }

package/runtime/xt_io.c

@@ -12,6 +12,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
 /* ------------------------------------------------------------------------- */
 /* Exceptions and output                                                     */
@@ -31,6 +32,15 @@ typedef struct xt_try_frame {
 
 static xt_try_frame *g_try_top = NULL;
 
+/* Program arguments, captured once by `xt_set_program_args` from `main`. */
+int32_t xt_program_argc = 0;
+char **xt_program_argv = NULL;
+
+void xt_set_program_args(int32_t argc, char **argv) {
+  xt_program_argc = argc;
+  xt_program_argv = argv;
+}
+
 void *xt_try_enter(void) {
   xt_try_frame *frame = (xt_try_frame *)calloc(1, sizeof(xt_try_frame));
   if (!frame) abort();
@@ -131,3 +141,115 @@ static void xt_console_write(int32_t argc, xt_value *argv, FILE *out) {
 void xt_console_info(int32_t argc, xt_value *argv) { xt_console_write(argc, argv, stdout); }
 void xt_console_warn(int32_t argc, xt_value *argv) { xt_console_write(argc, argv, stderr); }
 void xt_console_error(int32_t argc, xt_value *argv) { xt_console_write(argc, argv, stderr); }
+
+xt_value xt_console_dir(int32_t argc, xt_value *argv) {
+  xt_console_write(argc, argv, stdout);
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_trace(int32_t argc, xt_value *argv) {
+  fputs("Trace", stderr);
+  for (int32_t i = 0; i < argc; i++) {
+    fputc(' ', stderr);
+    xt_inspect(argv[i], stderr);
+  }
+  fputc('\n', stderr);
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_assert(int32_t argc, xt_value *argv) {
+  if (argc == 0 || !xt_truthy(argv[0])) {
+    fputs("Assertion failed", stderr);
+    if (argc > 1) fputs(":", stderr);
+    for (int32_t i = 1; i < argc; i++) {
+      fputc(' ', stderr);
+      xt_inspect(argv[i], stderr);
+    }
+    fputc('\n', stderr);
+  }
+  return XT_UNDEFINED;
+}
+
+#define XT_CONSOLE_MAX_LABELS 32
+static char *xt_console_labels[XT_CONSOLE_MAX_LABELS];
+static long xt_console_counts[XT_CONSOLE_MAX_LABELS];
+static clock_t xt_console_timers[XT_CONSOLE_MAX_LABELS];
+static int xt_console_label_count = 0;
+static int xt_console_depth = 0;
+
+static int xt_console_find_label(const char *label) {
+  for (int i = 0; i < xt_console_label_count; i++) {
+    if (strcmp(xt_console_labels[i], label) == 0) return i;
+  }
+  if (xt_console_label_count >= XT_CONSOLE_MAX_LABELS) return -1;
+  int index = xt_console_label_count++;
+  xt_console_labels[index] = (char *)malloc(strlen(label) + 1);
+  strcpy(xt_console_labels[index], label);
+  xt_console_counts[index] = 0;
+  xt_console_timers[index] = 0;
+  return index;
+}
+
+static const char *xt_console_label(int32_t argc, xt_value *argv) {
+  if (argc == 0) return "default";
+  return xt_string_data(xt_to_string(argv[0]));
+}
+
+xt_value xt_console_count(int32_t argc, xt_value *argv) {
+  const char *label = xt_console_label(argc, argv);
+  int index = xt_console_find_label(label ? label : "default");
+  if (index < 0) return XT_UNDEFINED;
+  xt_console_counts[index]++;
+  printf("%s: %ld\n", xt_console_labels[index], xt_console_counts[index]);
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_count_reset(int32_t argc, xt_value *argv) {
+  const char *label = xt_console_label(argc, argv);
+  int index = xt_console_find_label(label ? label : "default");
+  if (index >= 0) xt_console_counts[index] = 0;
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_group(int32_t argc, xt_value *argv) {
+  xt_console_write(argc, argv, stdout);
+  xt_console_depth++;
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_group_end(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  if (xt_console_depth > 0) xt_console_depth--;
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_table(int32_t argc, xt_value *argv) {
+  xt_console_write(argc, argv, stdout);
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_time(int32_t argc, xt_value *argv) {
+  const char *label = xt_console_label(argc, argv);
+  int index = xt_console_find_label(label ? label : "default");
+  if (index >= 0) xt_console_timers[index] = clock();
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_time_log(int32_t argc, xt_value *argv) {
+  const char *label = xt_console_label(argc, argv);
+  int index = xt_console_find_label(label ? label : "default");
+  if (index >= 0 && xt_console_timers[index] != 0) {
+    double ms = (double)(clock() - xt_console_timers[index]) * 1000.0 / CLOCKS_PER_SEC;
+    printf("%s: %.3fms\n", xt_console_labels[index], ms);
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_console_time_end(int32_t argc, xt_value *argv) {
+  xt_console_time_log(argc, argv);
+  const char *label = xt_console_label(argc, argv);
+  int index = xt_console_find_label(label ? label : "default");
+  if (index >= 0) xt_console_timers[index] = 0;
+  return XT_UNDEFINED;
+}

package/runtime/xt_promise.c

@@ -0,0 +1,292 @@
+/*
+ * xbintsc runtime — promises and async support.
+ *
+ * There is no event loop in the runtime, so promises use a microtask queue
+ * that the compiler drains when the program body finishes (and that `await`
+ * drains on demand). This gives synchronous-looking `async`/`await` semantics
+ * for the common case where every awaited value is already settled.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#define XT_PROMISE_PENDING 0
+#define XT_PROMISE_FULFILLED 1
+#define XT_PROMISE_REJECTED 2
+
+typedef struct xt_promise xt_promise;
+
+typedef struct {
+  xt_promise *promise;
+  xt_value on_fulfilled;
+  xt_value on_rejected;
+  xt_promise *result;
+} xt_reaction;
+
+struct xt_promise {
+  xt_header header;
+  int state;
+  xt_value value;
+  xt_reaction **reactions;
+  uint32_t reaction_count;
+  uint32_t reaction_capacity;
+};
+
+/* -- microtask queue ------------------------------------------------------ */
+
+static xt_reaction **xt_microtasks = NULL;
+static uint32_t xt_microtask_count = 0;
+static uint32_t xt_microtask_head = 0;
+static uint32_t xt_microtask_capacity = 0;
+
+static void xt_microtask_push(xt_reaction *reaction) {
+  if (xt_microtask_count >= xt_microtask_capacity) {
+    xt_microtask_capacity = xt_microtask_capacity == 0 ? 16 : xt_microtask_capacity * 2;
+    xt_microtasks = (xt_reaction **)realloc(xt_microtasks, sizeof(xt_reaction *) * xt_microtask_capacity);
+    if (!xt_microtasks) abort();
+  }
+  xt_microtasks[xt_microtask_count++] = reaction;
+}
+
+int xt_is_promise(xt_value value) {
+  return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_PROMISE;
+}
+
+static xt_promise *xt_as_promise(xt_value value) {
+  if (!xt_is_promise(value)) return NULL;
+  return (xt_promise *)XT_GET_PTR(value);
+}
+
+static xt_value xt_promise_value(xt_promise *promise) {
+  return XT_FROM_PTR(XT_TAG_OBJECT, promise);
+}
+
+static xt_promise *xt_promise_new(void) {
+  xt_promise *promise = (xt_promise *)xt_alloc(sizeof(xt_promise), XT_OBJECT_KIND_PROMISE);
+  promise->state = XT_PROMISE_PENDING;
+  promise->value = XT_UNDEFINED;
+  promise->reactions = NULL;
+  promise->reaction_count = 0;
+  promise->reaction_capacity = 0;
+  return promise;
+}
+
+static void xt_promise_settle(xt_promise *promise, int state, xt_value value);
+
+static void xt_promise_resolve_into(xt_promise *result, xt_value value) {
+  xt_promise *other = xt_as_promise(value);
+  if (!other) {
+    xt_promise_settle(result, XT_PROMISE_FULFILLED, value);
+    return;
+  }
+  if (other->state == XT_PROMISE_PENDING) {
+    xt_reaction *reaction = (xt_reaction *)malloc(sizeof(xt_reaction));
+    if (!reaction) abort();
+    reaction->promise = other;
+    reaction->on_fulfilled = XT_UNDEFINED;
+    reaction->on_rejected = XT_UNDEFINED;
+    reaction->result = result;
+    if (other->reaction_count >= other->reaction_capacity) {
+      other->reaction_capacity = other->reaction_capacity == 0 ? 4 : other->reaction_capacity * 2;
+      other->reactions = (xt_reaction **)realloc(other->reactions, sizeof(xt_reaction *) * other->reaction_capacity);
+      if (!other->reactions) abort();
+    }
+    other->reactions[other->reaction_count++] = reaction;
+  } else {
+    xt_promise_settle(result, other->state, other->value);
+  }
+}
+
+static void xt_promise_settle(xt_promise *promise, int state, xt_value value) {
+  if (promise->state != XT_PROMISE_PENDING) return;
+  promise->state = state;
+  promise->value = value;
+  for (uint32_t i = 0; i < promise->reaction_count; i++) xt_microtask_push(promise->reactions[i]);
+  promise->reaction_count = 0;
+}
+
+static xt_value xt_promise_run_reactions(void) {
+  while (xt_microtask_head < xt_microtask_count) {
+    xt_reaction *reaction = xt_microtasks[xt_microtask_head++];
+    xt_promise *promise = reaction->promise;
+    xt_value handler = promise->state == XT_PROMISE_FULFILLED ? reaction->on_fulfilled : reaction->on_rejected;
+    if (XT_IS_FUNCTION(handler)) {
+      xt_value arg = promise->value;
+      xt_value out;
+      out = xt_closure_call(handler, 1, &arg);
+      xt_promise_resolve_into(reaction->result, out);
+    } else if (promise->state == XT_PROMISE_FULFILLED) {
+      xt_promise_settle(reaction->result, XT_PROMISE_FULFILLED, promise->value);
+    } else {
+      xt_promise_settle(reaction->result, XT_PROMISE_REJECTED, promise->value);
+    }
+  }
+  xt_microtask_head = 0;
+  xt_microtask_count = 0;
+  return XT_UNDEFINED;
+}
+
+void xt_drain_microtasks(void) {
+  for (int guard = 0; guard < 100000; guard++) {
+    if (xt_microtask_head >= xt_microtask_count) break;
+    xt_promise_run_reactions();
+  }
+}
+
+xt_value xt_await(xt_value value) {
+  xt_promise *promise = xt_as_promise(value);
+  if (!promise) return value;
+  int guard = 0;
+  while (promise->state == XT_PROMISE_PENDING && guard++ < 100000) xt_drain_microtasks();
+  if (promise->state == XT_PROMISE_REJECTED) {
+    xt_throw(promise->value);
+    return XT_UNDEFINED;
+  }
+  return promise->value;
+}
+
+/* -- C-callable resolve / reject ------------------------------------------ */
+
+static xt_value xt_promise_resolve_cb(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  xt_value promiseValue = xt_closure_env(env, 0);
+  xt_promise *promise = xt_as_promise(promiseValue);
+  if (promise) xt_promise_resolve_into(promise, xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_promise_reject_cb(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  xt_value promiseValue = xt_closure_env(env, 0);
+  xt_promise *promise = xt_as_promise(promiseValue);
+  if (promise) xt_promise_settle(promise, XT_PROMISE_REJECTED, xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_make_callback(xt_code_fn fn, xt_value promiseValue) {
+  xt_value env[1] = {promiseValue};
+  return xt_closure_new((void *)fn, 1, env);
+}
+
+xt_value xt_promise_ctor(int32_t argc, xt_value *argv) {
+  xt_promise *promise = xt_promise_new();
+  xt_value promiseValue = xt_promise_value(promise);
+  xt_value executor = xt_arg_at(argc, argv, 0);
+  if (XT_IS_FUNCTION(executor)) {
+    xt_value args[2];
+    args[0] = xt_make_callback(xt_promise_resolve_cb, promiseValue);
+    args[1] = xt_make_callback(xt_promise_reject_cb, promiseValue);
+    xt_closure_call(executor, 2, args);
+  }
+  return promiseValue;
+}
+
+xt_value xt_promise_resolve(xt_value value) {
+  xt_promise *existing = xt_as_promise(value);
+  if (existing) return value;
+  xt_promise *promise = xt_promise_new();
+  xt_promise_resolve_into(promise, value);
+  return xt_promise_value(promise);
+}
+
+xt_value xt_promise_reject(xt_value value) {
+  xt_promise *promise = xt_promise_new();
+  xt_promise_settle(promise, XT_PROMISE_REJECTED, value);
+  return xt_promise_value(promise);
+}
+
+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, "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) {
+    xt_value iterable = xt_arg_at(argc, argv, 0);
+    int all = strcmp(fn, "all") == 0 || strcmp(fn, "allSettled") == 0;
+    xt_promise *result = xt_promise_new();
+    xt_value values = xt_array_new(0, NULL);
+    if (XT_IS_ARRAY(iterable)) {
+      xt_array *array = xt_as_array(iterable);
+      int anyRejected = 0;
+      for (uint32_t i = 0; i < array->length; i++) {
+        xt_value item = array->items[i];
+        xt_promise *inner = xt_is_promise(item) ? xt_as_promise(item) : NULL;
+        int rejected = inner && inner->state == XT_PROMISE_REJECTED;
+        if (strcmp(fn, "allSettled") == 0) {
+          xt_value record = xt_object_new();
+          xt_object_set(record, xt_string_from_cstr("status"), xt_string_from_cstr(rejected ? "rejected" : "fulfilled"));
+          xt_object_set(record, xt_string_from_cstr(rejected ? "reason" : "value"), rejected ? inner->value : item);
+          xt_array_push(values, record);
+          continue;
+        }
+        if (rejected) {
+          if (strcmp(fn, "any") == 0) {
+            anyRejected++;
+            continue;
+          }
+          xt_promise_settle(result, XT_PROMISE_REJECTED, inner->value);
+          return xt_promise_value(result);
+        }
+        xt_value 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);
+        }
+        xt_array_push(values, settled);
+      }
+      if (strcmp(fn, "any") == 0 && anyRejected > 0) {
+        xt_promise_settle(result, XT_PROMISE_REJECTED, xt_string_from_cstr("AggregateError: all promises rejected"));
+        return xt_promise_value(result);
+      }
+    }
+    if (all) xt_promise_settle(result, XT_PROMISE_FULFILLED, values);
+    else xt_promise_settle(result, XT_PROMISE_REJECTED, xt_string_from_cstr("AggregateError: no promises"));
+    return xt_promise_value(result);
+  }
+  return XT_UNDEFINED;
+}
+
+/* -- instance methods ----------------------------------------------------- */
+
+xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
+  *handled = 1;
+  xt_promise *promise = xt_as_promise(target);
+  if (!promise) {
+    *handled = 0;
+    return XT_UNDEFINED;
+  }
+  if (strcmp(method, "then") == 0) {
+    xt_promise *result = xt_promise_new();
+    xt_reaction *reaction = (xt_reaction *)malloc(sizeof(xt_reaction));
+    if (!reaction) abort();
+    reaction->promise = promise;
+    reaction->on_fulfilled = xt_arg_at(argc, argv, 0);
+    reaction->on_rejected = xt_arg_at(argc, argv, 1);
+    reaction->result = result;
+    if (promise->state == XT_PROMISE_PENDING) {
+      if (promise->reaction_count >= promise->reaction_capacity) {
+        promise->reaction_capacity = promise->reaction_capacity == 0 ? 4 : promise->reaction_capacity * 2;
+        promise->reactions = (xt_reaction **)realloc(promise->reactions, sizeof(xt_reaction *) * promise->reaction_capacity);
+        if (!promise->reactions) abort();
+      }
+      promise->reactions[promise->reaction_count++] = reaction;
+    } else {
+      xt_microtask_push(reaction);
+    }
+    return xt_promise_value(result);
+  }
+  if (strcmp(method, "catch") == 0) {
+    xt_value args[2] = {XT_UNDEFINED, xt_arg_at(argc, argv, 0)};
+    return xt_promise_method(target, "then", 2, args, handled);
+  }
+  if (strcmp(method, "finally") == 0) {
+    xt_value fn = xt_arg_at(argc, argv, 0);
+    /* Approximate: run the handler, then propagate the original value. */
+    if (XT_IS_FUNCTION(fn)) xt_closure_call(fn, 0, NULL);
+    return target;
+  }
+  *handled = 0;
+  return XT_UNDEFINED;
+}