xbintsc 0.5.6 → 0.5.21

package/runtime/rt_internal.h

@@ -59,6 +59,10 @@
 #define XT_OBJECT_KIND_GENERATOR 13
 #define XT_OBJECT_KIND_ITERATOR 14
 #define XT_OBJECT_KIND_ASYNC 15
+#define XT_OBJECT_KIND_ASYNC_ITERATOR 16
+#define XT_OBJECT_KIND_WEAK_MAP 17
+#define XT_OBJECT_KIND_WEAK_SET 18
+#define XT_OBJECT_KIND_WEAK_REF 19
 
 /* Common header for every heap object. `flags` bit 0 is the collector's mark
  * bit; it is cleared on every surviving object at the end of a sweep. */
@@ -111,11 +115,24 @@ typedef struct {
   xt_value setter;
 } xt_property;
 
+/* Hidden-class descriptor for ordinary objects. Shapes are interned by their
+ * (parent, key) transition and never freed, so an object's shape pointer is a
+ * stable layout identity. Shape keys are rooted by a collector provider in
+ * xt_containers/shapes.inc. */
+typedef struct xt_shape {
+  xt_value key;
+  uint32_t count;
+  struct xt_shape *parent;
+  struct xt_shape *next;     /* hash-bucket chain */
+  struct xt_shape *all_next; /* every shape, for the GC root provider */
+} xt_shape;
+
 typedef struct {
   xt_header header;
   uint32_t count;
   uint32_t capacity;
   xt_property *properties;
+  xt_shape *shape;
   xt_value prototype;
   uint8_t frozen;
   uint8_t is_array_base;
@@ -155,6 +172,9 @@ typedef struct {
   /* Set on `async` function objects: calling the closure starts a coroutine
    * (see xt_async.c) and immediately returns the promise it resolves. */
   uint8_t is_async;
+  /* Set on `async function*` objects. `is_generator` is also set, but the call
+   * path checks this flag first so the generator is created in async mode. */
+  uint8_t is_async_generator;
   /* Non-NULL for the first-class value of a built-in constructor ("Array",
    * "Map", ...). It lets property access resolve the constructor's statics
    * (`const A = Array; A.isArray(x)`). Points at a static string. */
@@ -217,12 +237,26 @@ void xt_gc_scan_region(const void *base, size_t bytes);
 
 /* Kind-specific hooks for allocations with separately allocated sub-objects.
  * Implemented by the translation unit that owns the representation. */
+/* Weak-reference processing. `xt_weak_gc_process_once` marks values whose
+ * WeakMap key is already marked and returns 1 when it marked anything (the
+ * caller repeats until the ephemeron fixed point). `xt_weak_gc_clear` empties
+ * WeakRefs whose target stayed unmarked, and `xt_weak_gc_compact` drops dead
+ * WeakMap/WeakSet entries. */
+int xt_weak_gc_process_once(void);
+void xt_weak_gc_clear(void);
+void xt_weak_gc_compact(void);
+/* Mark-state queries used by the weak-reference pass. */
+int xt_gc_value_is_marked(xt_value value);
+/* Iterate every allocation (used by the weak-reference pass). */
+xt_header *xt_gc_heap_head(void);
+
 void xt_promise_gc_trace(xt_header *header);
 void xt_promise_gc_release(xt_header *header);
 void xt_generator_gc_trace(xt_header *header);
 void xt_generator_gc_release(xt_header *header);
 void xt_async_gc_trace(xt_header *header);
 void xt_async_gc_release(xt_header *header);
+void xt_async_iterator_gc_trace(xt_header *header);
 
 /* Stackful coroutines (xt_coroutine.c). A coroutine owns a private C stack and
  * switches to it with `ucontext`/fibers; `enter` runs until the body calls
@@ -232,6 +266,9 @@ typedef struct xt_coroutine xt_coroutine;
 xt_coroutine *xt_coroutine_create(void (*entry)(void *), void *arg);
 void xt_coroutine_enter(xt_coroutine *co);
 void xt_coroutine_leave(xt_coroutine *co);
+/* The coroutine whose body is currently executing, or NULL on the main stack. */
+xt_coroutine *xt_coroutine_current(void);
+int xt_coroutine_is_current(xt_coroutine *co);
 void xt_coroutine_gc_trace(xt_coroutine *co);
 void xt_coroutine_release(xt_coroutine *co);
 
@@ -320,6 +357,11 @@ void xt_array_reserve(xt_array *array, uint32_t needed);
 /* Object helpers used by the standard library. */
 xt_object *xt_as_object(xt_value value);
 xt_property *xt_object_find_property(xt_object *obj, xt_value key);
+/* Hidden-class helpers. `xt_object_shape_changed` rebuilds the shape after a
+ * property was inserted out of order or deleted. `xt_shape_empty` stays local
+ * to xt_containers.c, which is why it has no prototype here. */
+xt_shape *xt_shape_transition(xt_shape *parent, xt_value key);
+void xt_object_shape_changed(xt_object *obj);
 
 /* Property keys are either strings or symbols. */
 xt_value xt_to_property_key(xt_value key);
@@ -347,6 +389,14 @@ xt_value xt_regexp_split(xt_value value, xt_value regexp, xt_value limit);
 xt_value xt_regexp_get_property(xt_value regexp, xt_value key);
 int32_t xt_map_size(xt_value value);
 int32_t xt_set_size(xt_value value);
+/* WeakMap / WeakSet / WeakRef (xt_weak.c). */
+int xt_is_weak_map(xt_value value);
+int xt_is_weak_set(xt_value value);
+int xt_is_weak_ref(xt_value value);
+xt_value xt_weak_map_ctor(int32_t argc, xt_value *argv);
+xt_value xt_weak_set_ctor(int32_t argc, xt_value *argv);
+xt_value xt_weak_ref_ctor(int32_t argc, xt_value *argv);
+xt_value xt_weak_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
 /* `for...of` iteration: dispatch over arrays, strings, Maps and Sets. */
 xt_value xt_iter_length(xt_value value);
 xt_value xt_iter_value(xt_value value, xt_value index);
@@ -357,6 +407,9 @@ xt_value xt_iter_has(xt_value value, xt_value index);
  * protocols, or a wrapper around `value[Symbol.iterator]()` otherwise. */
 xt_value xt_iter_open(xt_value value);
 
+/* Monotonic clock in fractional milliseconds (xt_loop.c), for `performance.now`. */
+double xt_monotonic_ms(void);
+
 /* Stackful generators (xt_generator.c). */
 int xt_is_generator(xt_value value);
 xt_value xt_generator_new(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv);
@@ -367,6 +420,18 @@ xt_value xt_yield(xt_value value);
 xt_value xt_yield_star(xt_value delegate);
 int xt_generator_has_next(xt_value generator);
 xt_value xt_generator_iter_value(xt_value generator);
+/* Async-generator support. `xt_generator_await` handles an `await` inside an
+ * async generator and returns 1; it returns 0 when no async generator is
+ * running (ordinary/async code handles the await itself). */
+int xt_generator_await(xt_value value, xt_value *result);
+void xt_generator_wake(void *generator, xt_value value, int rejected);
+int xt_is_async_generator(xt_value value);
+/* `[Symbol.asyncIterator]()` for a generator object. */
+xt_value xt_async_iterator_method(void);
+/* `for await...of`: resolve the async iteration protocol once, then pull one
+ * step per call. Both return a promise for the step object. */
+xt_value xt_async_iter_open(xt_value value);
+xt_value xt_async_iter_next(xt_value iterator);
 
 /* Async coroutines (xt_async.c). Calling an `async` function runs its body on
  * a coroutine that suspends at a pending `await` and resumes when the awaited
@@ -387,6 +452,8 @@ int xt_promise_state_of(xt_value value);
 xt_value xt_promise_value_of(xt_value value);
 /* Register a coroutine to resume when `promise` settles (it must be pending). */
 void xt_promise_add_async_waiter(xt_value promise, void *async);
+/* Queue a microtask that resumes `async` with an already settled value. */
+void xt_promise_queue_async_wake(void *async, xt_value settled, int rejected);
 
 /* Exception-frame plumbing shared with the generator runtime. The struct is
  * public so a coroutine can `_setjmp` its own boundary directly (a `setjmp`
@@ -448,6 +515,29 @@ typedef struct {
   uint32_t capacity;
 } xt_set_object;
 
+/* Weak collections. Keys (WeakMap/WeakSet) and the target of a WeakRef are
+ * deliberately not traced by the collector: `xt_weak_gc_*` in xt_weak.c
+ * implements the ephemeron fixed point and clears unreachable refs. */
+typedef struct {
+  xt_header header;
+  xt_value *keys;
+  xt_value *values;
+  uint32_t count;
+  uint32_t capacity;
+} xt_weak_map;
+
+typedef struct {
+  xt_header header;
+  xt_value *values;
+  uint32_t count;
+  uint32_t capacity;
+} xt_weak_set;
+
+typedef struct {
+  xt_header header;
+  xt_value target;
+} xt_weak_ref;
+
 typedef struct {
   xt_header header;
   double time;
@@ -468,6 +558,9 @@ xt_value xt_ext_object_method(xt_value target, const char *method, int32_t argc,
 
 /* Error family helpers (xt_stdlib2.c). */
 xt_value xt_error_to_string(xt_value error);
+/* Turn an internal "TypeError: message" / "RangeError: message" string into a
+ * real Error-family value so `catch` observes an Error, not a string. */
+xt_value xt_error_from_message(const char *message);
 xt_value xt_aggregate_error_ctor(int32_t argc, xt_value *argv);
 xt_value xt_ext_container_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
 xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
@@ -482,5 +575,20 @@ xt_value xt_arg_at(int32_t argc, xt_value *argv, int32_t index);
 /* Typed arrays (xt_typed_array.c). */
 int xt_typed_array_kind_of(xt_value value);
 double xt_typed_array_coerce(int kind, double value);
+/* Buffer-backed element access; the array must be a typed-array value. */
+xt_value xt_typed_array_read(xt_value array, uint32_t index);
+void xt_typed_array_write(xt_value array, uint32_t index, xt_value value);
+xt_value xt_typed_array_buffer_of(xt_value array);
+uint32_t xt_typed_array_byte_offset_of(xt_value array);
+const char *xt_typed_array_name_of(int kind);
+
+/* ArrayBuffer helpers (xt_array_buffer.c). */
+int xt_is_array_buffer(xt_value value);
+uint32_t xt_array_buffer_byte_length(xt_value value);
+uint8_t xt_array_buffer_get_byte(xt_value buffer, uint32_t index);
+void xt_array_buffer_set_byte(xt_value buffer, uint32_t index, uint8_t value);
+xt_value xt_array_buffer_ctor(int32_t argc, xt_value *argv);
+
+#include "xt_async_io.h"
 
 #endif /* XT_RT_INTERNAL_H */

package/runtime/xt_alloc.c

@@ -303,6 +303,17 @@ void xt_gc_mark_value(xt_value value) {
   }
 }
 
+int xt_gc_value_is_marked(xt_value value) {
+  if (!(XT_IS_STRING(value) || XT_IS_OBJECT(value) || XT_IS_ARRAY(value) ||
+        XT_IS_FUNCTION(value) || XT_IS_BIGINT(value))) {
+    return 0;
+  }
+  xt_header *header = xt_gc_table_lookup((uintptr_t)XT_GET_PTR(value));
+  return header != NULL && (header->flags & XT_GC_MARK) != 0;
+}
+
+xt_header *xt_gc_heap_head(void) { return g_heap_head; }
+
 void xt_gc_scan_region(const void *base, size_t bytes) {
   if (!base) return;
   const uint64_t *words = (const uint64_t *)base;
@@ -392,6 +403,15 @@ static void xt_gc_process(xt_header *header) {
     case XT_OBJECT_KIND_ASYNC:
       xt_async_gc_trace(header);
       return;
+    case XT_OBJECT_KIND_ASYNC_ITERATOR:
+      xt_async_iterator_gc_trace(header);
+      return;
+    case XT_OBJECT_KIND_WEAK_MAP:
+    case XT_OBJECT_KIND_WEAK_SET:
+    case XT_OBJECT_KIND_WEAK_REF:
+      /* Weak references are not traced; `xt_weak_gc_*` owns the ephemeron
+       * fixed point after the ordinary mark phase. */
+      return;
     default:
       /* Symbols, regexps, iterators and any future kind whose references live
        * inline: the payload scan covers them. */
@@ -429,6 +449,13 @@ static void xt_gc_release(xt_header *header) {
     case XT_OBJECT_KIND_SET:
       free(((xt_set_object *)header)->values);
       break;
+    case XT_OBJECT_KIND_WEAK_MAP:
+      free(((xt_weak_map *)header)->keys);
+      free(((xt_weak_map *)header)->values);
+      break;
+    case XT_OBJECT_KIND_WEAK_SET:
+      free(((xt_weak_set *)header)->values);
+      break;
     case XT_OBJECT_KIND_PROMISE:
       xt_promise_gc_release(header);
       break;
@@ -478,16 +505,25 @@ void xt_gc_collect(void) {
 
   xt_gc_table_build();
   xt_gc_mark_roots();
-  while (g_gray_count > 0) {
-    xt_header *header = g_gray[--g_gray_count];
-    xt_gc_process(header);
+  /* Ephemeron fixed point: a WeakMap value is reachable only when its key is
+   * reachable. Marking a value can reach further keys, so repeat until a pass
+   * marks nothing new. WeakRefs are cleared only after this settles, because
+   * an ephemeron may still keep their target alive. */
+  for (;;) {
+    while (g_gray_count > 0) {
+      xt_header *header = g_gray[--g_gray_count];
+      xt_gc_process(header);
+    }
+    if (!xt_weak_gc_process_once()) break;
   }
+  xt_weak_gc_clear();
+  xt_weak_gc_compact();
 
   xt_header **link = &g_heap_head;
   xt_header *header = g_heap_head;
-  size_t live_by_kind[16];
-  size_t bytes_by_kind[16];
-  for (int i = 0; i < 16; i++) {
+  size_t live_by_kind[32];
+  size_t bytes_by_kind[32];
+  for (int i = 0; i < 32; i++) {
     live_by_kind[i] = 0;
     bytes_by_kind[i] = 0;
   }
@@ -497,7 +533,7 @@ void xt_gc_collect(void) {
       header->flags &= (uint8_t)~XT_GC_MARK;
       link = &header->gc_next;
       if (trace) {
-        size_t kind = header->kind < 16 ? header->kind : 0;
+        size_t kind = header->kind < 32 ? header->kind : 0;
         live_by_kind[kind]++;
         bytes_by_kind[kind] += header->size;
       }

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