xbintsc 0.3.87 → 0.5.20

package/runtime/rt.h

@@ -96,7 +96,10 @@ xt_value xt_string_from_cstr(const char *data);
  * Materialises a lazily concatenated string, so the returned pointer is stable
  * until the string is collected. */
 const char *xt_string_data(xt_value value);
+/** Byte length of the UTF-8 storage (what I/O and C extensions consume). */
 int32_t xt_string_length_value(xt_value value);
+/** JavaScript `String.prototype.length`: UTF-16 code units. */
+int32_t xt_string_utf16_length_value(xt_value value);
 
 /* -- bigint -------------------------------------------------------------- */
 xt_value xt_bigint_from_string(const char *data, size_t len);
@@ -125,6 +128,12 @@ xt_value xt_instance_of(xt_value value, xt_value ctor);
 xt_value xt_instance_of_builtin(xt_value value, int32_t id);
 xt_value xt_function_set_prototype(xt_value fn, xt_value proto);
 xt_value xt_function_get_prototype(xt_value fn);
+/** Mark a closure as a generator so calling it creates a suspended generator. */
+xt_value xt_function_set_generator(xt_value fn);
+/** Mark a closure as an `async` function so calling it starts a coroutine. */
+xt_value xt_function_set_async(xt_value fn);
+/** Mark a closure as an `async function*` (generator + async iterator). */
+xt_value xt_function_set_async_generator(xt_value fn);
 
 /* -- conversions ---------------------------------------------------------- */
 int xt_truthy(xt_value v);
@@ -163,6 +172,10 @@ xt_value xt_not(xt_value a);
 /* -- objects -------------------------------------------------------------- */
 xt_value xt_object_new(void);
 xt_value xt_object_new_with_proto(xt_value proto);
+/** The shared `Object.prototype` object (root of the ordinary object chain). */
+xt_value xt_object_prototype(void);
+/** The shared `Function.prototype` object. */
+xt_value xt_function_prototype(void);
 xt_value xt_object_get(xt_value obj, xt_value key);
 xt_value xt_object_get_prototype(xt_value obj);
 xt_value xt_object_set_prototype(xt_value obj, xt_value proto);
@@ -193,6 +206,17 @@ xt_value xt_symbol_static(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_symbol_get(xt_value name);
 
 /* -- standard library dispatch -------------------------------------------- */
+/* -- built-in constructors as first-class values -------------------------- */
+/** The first-class value of a built-in constructor (`Array`, `Map`, ...). */
+xt_value xt_builtin_constructor(xt_value name);
+/** A static method/value of a first-class constructor (`A.isArray`, ...). */
+xt_value xt_builtin_static_value(xt_value ctor, xt_value key);
+/** The constructor prototype for a runtime object kind (`Map` -> Map.prototype). */
+xt_value xt_builtin_prototype_for_kind(int32_t kind);
+/** `Array(...)` / `new Array(...)`. */
+xt_value xt_array_ctor(int32_t argc, xt_value *argv);
+/** `Object(...)` / `new Object(...)`. */
+xt_value xt_object_ctor(int32_t argc, xt_value *argv);
 /** Call `target[name](...)`, falling back to built-in Array/String methods. */
 xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *argv);
 /** Implements `Math.<name>(...)`; the name is interned by the compiler. */
@@ -207,6 +231,14 @@ xt_value xt_object_static(xt_value name, int32_t argc, xt_value *argv);
 /** Implements `Number.<name>(...)` / `String.<name>(...)` statics. */
 xt_value xt_number_static(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv);
+/** Typed-array constructor/static/prototype dispatch by constructor name. */
+xt_value xt_typed_array_ctor_by_name(xt_value name, int32_t argc, xt_value *argv);
+xt_value xt_typed_array_static_by_name(xt_value name, xt_value method, int32_t argc, xt_value *argv);
+xt_value xt_typed_array_prototype(xt_value name);
+/** Error-family construction and prototype lookup by constructor name. */
+xt_value xt_error_ctor_by_name(xt_value name, int32_t argc, xt_value *argv);
+xt_value xt_error_prototype(xt_value name);
+xt_value xt_error_constructor(xt_value name);
 /** Map / Set constructors and dispatch. */
 xt_value xt_map_ctor(int32_t argc, xt_value *argv);
 xt_value xt_set_ctor(int32_t argc, xt_value *argv);
@@ -229,6 +261,8 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv);
 xt_value xt_fetch(int32_t argc, xt_value *argv);
 /** Construct a `TypeError` with one message argument (used by `fetch`). */
 xt_value xt_type_error_ctor(int32_t argc, xt_value *argv);
+/** Construct a `RangeError` with one message argument. */
+xt_value xt_range_error_ctor(int32_t argc, xt_value *argv);
 
 /* -- promises / async ----------------------------------------------------- */
 xt_value xt_promise_resolve(xt_value value);
@@ -285,6 +319,12 @@ xt_value xt_set_timeout(int32_t argc, xt_value *argv);
 xt_value xt_clear_timeout(int32_t argc, xt_value *argv);
 xt_value xt_set_interval(int32_t argc, xt_value *argv);
 xt_value xt_clear_interval(int32_t argc, xt_value *argv);
+/* `setImmediate` runs on the timer queue with a zero delay; `clearImmediate`
+ * is an alias of `clearTimeout` (ids share one namespace). */
+xt_value xt_set_immediate(int32_t argc, xt_value *argv);
+xt_value xt_clear_immediate(int32_t argc, xt_value *argv);
+/* Schedule `callback` on the promise microtask queue (same FIFO as `.then`). */
+xt_value xt_queue_microtask(int32_t argc, xt_value *argv);
 
 /* -- global functions ------------------------------------------------------ */
 xt_value xt_parse_int(int32_t argc, xt_value *argv);
@@ -298,6 +338,8 @@ xt_value xt_decode_uri(int32_t argc, xt_value *argv);
 xt_value xt_number_ctor(int32_t argc, xt_value *argv);
 xt_value xt_string_ctor(int32_t argc, xt_value *argv);
 xt_value xt_boolean_ctor(int32_t argc, xt_value *argv);
+/* Deep clone arrays/objects/Map/Set/Date/RegExp/typed arrays. */
+xt_value xt_structured_clone(int32_t argc, xt_value *argv);
 /** `key in obj` (the key is the left operand). */
 xt_value xt_in(xt_value key, xt_value obj);
 /** `delete obj[key]`; removes object properties, clears array elements. */
@@ -314,6 +356,8 @@ extern char **xt_program_argv;
 
 /* -- arrays --------------------------------------------------------------- */
 xt_value xt_array_new(int32_t count, xt_value *items);
+/** The shared `Array.prototype` array. */
+xt_value xt_array_prototype(void);
 xt_value xt_array_get(xt_value arr, xt_value index);
 xt_value xt_array_set(xt_value arr, xt_value index, xt_value value);
 xt_value xt_array_push(xt_value arr, xt_value value);
@@ -328,6 +372,9 @@ xt_value xt_iter_value(xt_value value, xt_value index);
 
 /* -- generic member access ------------------------------------------------ */
 xt_value xt_get(xt_value target, xt_value key);
+/** Interned shape/offset inline cache for a property read. `cache` points at
+ * two zero-initialised i64 words owned by the generated code. */
+xt_value xt_get_ic(xt_value target, xt_value key, int64_t *cache);
 xt_value xt_set(xt_value target, xt_value key, xt_value value);
 /* Materialise a first-class runtime method value (`arr.map`) as an unbound
  * closure that expects the receiver through `this`. Returns `XT_UNDEFINED` when

package/runtime/rt_internal.h

@@ -21,12 +21,15 @@
  *    code free of write barriers and makes the first implementation small and
  *    predictable. Replacing it with a precise/conservative collector is an
  *    isolated change behind `xt_alloc` plus root registration.
- *  * Strings are UTF-8. Concatenation is lazy: a `+` between two non-empty
- *    strings builds an immutable cons node (`flat == NULL`) and the bytes are
- *    materialised once, on first observation, by `xt_string_bytes`. This keeps
- *    `s += x` in a loop linear instead of copying the accumulated prefix every
- *    iteration. JavaScript measures string length in UTF-16 code units;
- *    `xt_string_length` currently reports code points (see README).
+ *  * Strings are stored as UTF-8 (with lone surrogate halves kept as WTF-8) but
+ *    expose JavaScript's UTF-16 view: `length`, indexing, slicing, searching
+ *    and splitting all count UTF-16 code units. `xt_string_length` is the raw
+ *    byte length (what extensions and I/O need), while
+ *    `xt_string_utf16_length` is the JavaScript `.length`. Concatenation is
+ *    lazy: a `+` between two non-empty strings builds an immutable cons node
+ *    (`flat == NULL`) and the bytes are materialised once, on first
+ *    observation, by `xt_string_bytes`. This keeps `s += x` in a loop linear
+ *    instead of copying the accumulated prefix every iteration.
  *  * Objects use a small linear property list. Fine for the language subset
  *    xbintsc targets today; swap for a hash map when the profile demands it.
  */
@@ -55,6 +58,11 @@
 #define XT_OBJECT_KIND_ERROR 12
 #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. */
@@ -70,13 +78,18 @@ typedef struct xt_header {
 
 /* A string is either *flat* (`flat` points at `capacity` bytes, the last one
  * NUL) or a *cons* node (`flat == NULL`, `left`/`right` name the operands).
- * `length` is always the total byte length, so `.length`, comparisons and the
- * GC never need to force a cons node. `xt_string_bytes` turns a cons node into
- * a flat one in place; treat the result as immutable and never write through a
- * pointer obtained from it. */
+ * `length` is the raw UTF-8 byte length; `utf16_length` (cached, 0 means
+ * "not computed yet" and is also the length of the empty string) is the same
+ * text measured in UTF-16 code units, which is what JavaScript observes.
+ * `code_point_count` is the number of Unicode scalar values (used by
+ * `for...of` and `Array.from`). `xt_string_bytes` turns a cons node into a flat
+ * one in place; treat the result as immutable and never write through a pointer
+ * obtained from it. */
 typedef struct xt_string {
   xt_header header;
   uint32_t length;
+  uint32_t utf16_length;
+  uint32_t code_point_count;
   uint32_t capacity;
   char *flat;
   struct xt_string *left;
@@ -102,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;
@@ -125,6 +151,10 @@ typedef struct {
   /* Named (non-index) properties such as `raw` on template strings or
    * `index`/`input` on RegExp match results, stored in an `xt_object`. */
   xt_value extra;
+  /* The array's [[Prototype]] (`Array.prototype` for ordinary arrays). Arrays
+   * are a distinct allocation kind, so this field is what lets
+   * `Object.getPrototypeOf([])` and `x instanceof <Array alias>` work. */
+  xt_value prototype;
 } xt_array;
 
 typedef struct {
@@ -139,6 +169,16 @@ typedef struct {
   /* Set on generator function objects: calling the closure does not run the
    * body, it creates a suspended generator (see xt_generator.c). */
   uint8_t is_generator;
+  /* 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. */
+  const char *builtin_name;
 } xt_function;
 
 /* Allocation and garbage collection (xt_alloc.c).
@@ -197,10 +237,40 @@ 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
+ * `leave`. Exception frames and GC stack regions are swapped alongside the C
+ * stack. Generators and async functions own one each. */
+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);
 
 /* Value / string helpers shared across translation units (xt_values.c). */
 xt_string *xt_string_alloc(size_t length);
@@ -210,6 +280,42 @@ int xt_string_equals(xt_string *a, xt_string *b);
 /* Contiguous UTF-8 bytes of a string, flattening a cons node in place on first
  * use. The result is NUL-terminated at `s->length`; never write through it. */
 const char *xt_string_bytes(xt_string *s);
+
+/* UTF-8 <-> UTF-16 helpers (xt_values/utf16.inc). Decoding accepts WTF-8, so
+ * lone surrogate halves produced by indexing survive a round trip. */
+uint32_t xt_utf8_decode(const char *data, size_t length, size_t *width);
+size_t xt_utf8_encode(uint32_t code, char *out);
+uint32_t xt_utf8_utf16_length(const char *data, size_t length);
+void xt_utf8_measure(const char *data, size_t length, uint32_t *units, uint32_t *points);
+/* Combine an adjacent WTF-8 high/low surrogate pair into one four-byte
+ * sequence, in place. Returns the resulting byte length. */
+size_t xt_utf8_normalize_surrogates(char *data, size_t length);
+
+/* Publish a manually filled buffer (`xt_string_alloc` + `xt_string_mutable`):
+ * normalises surrogate pairs, records the byte length and caches the UTF-16 and
+ * code-point counts. */
+void xt_string_finish(xt_string *s);
+uint32_t xt_string_utf16_length(xt_string *s);
+uint32_t xt_string_code_point_count(xt_string *s);
+/* UTF-16 code unit at `index`, or -1 when out of range. */
+int32_t xt_string_code_unit(xt_string *s, int32_t index);
+/* Unicode code point beginning at UTF-16 index `index` (combining a surrogate
+ * pair), or -1 when out of range. */
+int32_t xt_string_code_point_at(xt_string *s, int32_t index);
+/* A one-code-unit string (a lone surrogate when `index` points into a pair). */
+xt_value xt_string_unit_value(xt_string *s, int32_t index);
+xt_value xt_string_from_code_point(uint32_t code);
+xt_value xt_string_from_units(const uint16_t *units, size_t count);
+/* Copy UTF-16 range [start, end), splitting a surrogate pair when needed. */
+xt_value xt_string_slice_units(xt_string *s, int32_t start, int32_t end);
+/* Byte offset / UTF-16 index conversions; both clamp to the string bounds. */
+int32_t xt_string_byte_offset(xt_string *s, int32_t unit_index);
+int32_t xt_string_unit_offset(xt_string *s, int32_t byte_offset);
+/* True when `unit_index` sits on a code-point boundary (not between the two
+ * halves of a surrogate pair). */
+int xt_string_is_boundary(xt_string *s, int32_t unit_index);
+/* The `index`-th Unicode code point (for `for...of` and `Array.from`). */
+xt_value xt_string_code_point_value(xt_string *s, int32_t index);
 /* Mutable bytes of a string just created with `xt_string_alloc` (never a cons
  * node). Used by the constructors that fill a buffer before publishing it. */
 char *xt_string_mutable(xt_string *s);
@@ -251,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);
@@ -278,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);
@@ -288,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);
@@ -298,6 +420,40 @@ 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
+ * promise settles, so the event loop can make progress in between. */
+#define XT_PROMISE_PENDING 0
+#define XT_PROMISE_FULFILLED 1
+#define XT_PROMISE_REJECTED 2
+xt_value xt_async_call(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv);
+/* Resume `async` with the settlement of the promise it awaited. Called by the
+ * microtask runner when the promise settles. */
+void xt_async_wake(void *async, xt_value value, int rejected);
+/* Create a pending promise / settle an existing one (used by xt_async.c). */
+xt_value xt_promise_create(void);
+void xt_promise_fulfill(xt_value promise, xt_value value);
+void xt_promise_reject_value(xt_value promise, xt_value value);
+/* `-1` when `value` is not a promise, otherwise PENDING / FULFILLED / REJECTED. */
+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`
@@ -359,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;
@@ -379,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);
@@ -393,5 +575,18 @@ 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);
 
 #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;
@@ -389,6 +400,18 @@ static void xt_gc_process(xt_header *header) {
     case XT_OBJECT_KIND_GENERATOR:
       xt_generator_gc_trace(header);
       return;
+    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. */
@@ -426,12 +449,22 @@ 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;
     case XT_OBJECT_KIND_GENERATOR:
       xt_generator_gc_release(header);
       break;
+    case XT_OBJECT_KIND_ASYNC:
+      xt_async_gc_release(header);
+      break;
     default:
       break;
   }
@@ -472,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;
   }
@@ -491,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;
       }