xbintsc 0.3.35 → 0.3.49

package/runtime/xt_generator.c

@@ -45,14 +45,23 @@ typedef struct xt_generator {
   int done;
   int threw;
   int booted;
+  /* Private stack bounds, registered as an active stack region while the
+   * generator runs and scanned conservatively while it is suspended. */
+  char *stack;
+  size_t stack_size;
+  int stack_pushed;
   void *saved_try_top;
 #ifdef _WIN32
   void *fiber;
   void *caller_fiber;
+  /* `SwitchToFiber` keeps the resumer's callee-saved registers in an opaque
+   * fiber context (POSIX stores them in `caller`), so snapshot them for the
+   * collector before switching away. */
+  jmp_buf caller_regs;
+  int has_caller_regs;
 #else
   ucontext_t ctx;
   ucontext_t caller;
-  char *stack;
 #endif
 } xt_generator;
 
@@ -93,6 +102,27 @@ static void xt_generator_suspend(xt_generator *gen) {
 
 /* Runs on the generator's private stack. */
 static void xt_generator_run(xt_generator *gen) {
+#ifdef _WIN32
+  /* The fiber stack is not observable from the outside; capture its bounds
+   * here (before the body allocates anything) so a collection during the body
+   * has a valid scan region. */
+  if (!gen->stack) {
+    MEMORY_BASIC_INFORMATION info;
+    uintptr_t here = (uintptr_t)&info;
+    if (VirtualQuery((LPCVOID)here, &info, sizeof(info))) {
+      /* Use the *committed* region containing the current frame: a Windows
+       * stack reserves more than it commits, and `AllocationBase + RegionSize`
+       * can fall in uncommitted memory. `BaseAddress + RegionSize` is the
+       * stack top. */
+      gen->stack = (char *)info.BaseAddress;
+      gen->stack_size = info.RegionSize;
+    }
+  }
+#endif
+  if (gen->stack && gen->stack_size && !gen->stack_pushed) {
+    xt_gc_push_stack((uintptr_t)gen->stack, (uintptr_t)gen->stack + gen->stack_size);
+    gen->stack_pushed = 1;
+  }
   void *boundary = xt_try_enter();
   if (xt_try_setjmp(boundary) == 0) {
     xt_function *function = (xt_function *)XT_GET_PTR(gen->function);
@@ -127,6 +157,7 @@ static void xt_generator_boot(xt_generator *gen) {
   size_t size = 1 << 20;
   gen->stack = (char *)malloc(size);
   if (!gen->stack) abort();
+  gen->stack_size = size;
   if (getcontext(&gen->ctx) != 0) abort();
   gen->ctx.uc_stack.ss_sp = gen->stack;
   gen->ctx.uc_stack.ss_size = size;
@@ -146,6 +177,9 @@ static void xt_generator_dispose(xt_generator *gen) {
     gen->fiber = NULL;
   }
   gen->caller_fiber = NULL;
+  /* `DeleteFiber` releases the stack: never scan it again. */
+  gen->stack = NULL;
+  gen->stack_size = 0;
 #else
   if (gen->stack) {
     free(gen->stack);
@@ -158,9 +192,20 @@ static void xt_generator_resume(xt_generator *gen) {
   if (!gen->booted) xt_generator_boot(gen);
   xt_generator *previous = g_active_generator;
   g_active_generator = gen;
+  /* Record where the current (calling) stack suspends before switching away.
+   * On Windows the first push happens inside the fiber once its stack bounds
+   * are known, so the caller's region must be marked suspended here, on the
+   * caller's own stack. */
+  xt_gc_suspend((uintptr_t)&gen);
+  if (gen->stack && gen->stack_size && !gen->stack_pushed) {
+    xt_gc_push_stack((uintptr_t)gen->stack, (uintptr_t)gen->stack + gen->stack_size);
+    gen->stack_pushed = 1;
+  }
   void *caller_try = xt_try_mark();
   xt_try_restore(gen->saved_try_top);
 #ifdef _WIN32
+  _setjmp(gen->caller_regs);
+  gen->has_caller_regs = 1;
   gen->caller_fiber = GetCurrentFiber();
   SwitchToFiber(gen->fiber);
 #else
@@ -168,15 +213,63 @@ static void xt_generator_resume(xt_generator *gen) {
 #endif
   gen->saved_try_top = xt_try_mark();
   xt_try_restore(caller_try);
+  if (gen->stack_pushed) {
+    xt_gc_pop_stack();
+    gen->stack_pushed = 0;
+  }
   if (gen->done) xt_generator_dispose(gen);
   g_active_generator = previous;
 }
 
+/* The active generator is only reachable through this static pointer, and its
+ * private stack holds values that are invisible to a scan of the main stack. */
+static void xt_generator_gc_scan_roots(void) {
+  if (!g_active_generator) return;
+  xt_gc_mark_header((xt_header *)g_active_generator);
+}
+
+static void xt_generator_gc_register(void) {
+  static int registered = 0;
+  if (registered) return;
+  registered = 1;
+  xt_gc_register_root_provider(xt_generator_gc_scan_roots);
+}
+
+void xt_generator_gc_trace(xt_header *header) {
+  xt_generator *gen = (xt_generator *)header;
+  size_t payload = header->size > sizeof(xt_header) ? header->size - sizeof(xt_header) : 0;
+  xt_gc_scan_region((const char *)header + sizeof(xt_header), payload);
+  if (gen->args && gen->argc > 0) {
+    xt_gc_scan_region(gen->args, sizeof(xt_value) * (size_t)gen->argc);
+  }
+  if (gen->stack && gen->stack_size) xt_gc_scan_region(gen->stack, gen->stack_size);
+#ifndef _WIN32
+  /* Registers saved by `swapcontext` at the last yield are not on the stack. */
+  xt_gc_scan_region(&gen->ctx, sizeof(gen->ctx));
+#else
+  if (gen->has_caller_regs) xt_gc_scan_region(&gen->caller_regs, sizeof(gen->caller_regs));
+#endif
+}
+
+void xt_generator_gc_release(xt_header *header) {
+  xt_generator *gen = (xt_generator *)header;
+  free(gen->args);
+#ifdef _WIN32
+  if (gen->fiber) DeleteFiber(gen->fiber);
+#else
+  free(gen->stack);
+#endif
+}
+
 xt_value xt_generator_new(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv) {
   xt_generator *gen = (xt_generator *)xt_alloc(sizeof(xt_generator), XT_OBJECT_KIND_GENERATOR);
   gen->function = function;
   gen->this_value = thisValue;
   gen->argc = argc;
+  gen->args = NULL;
+  gen->stack = NULL;
+  gen->stack_size = 0;
+  gen->stack_pushed = 0;
   gen->result = XT_UNDEFINED;
   gen->sent = XT_UNDEFINED;
   gen->iter_value = XT_UNDEFINED;
@@ -185,6 +278,7 @@ xt_value xt_generator_new(xt_value function, xt_value thisValue, int32_t argc, x
     if (!gen->args) abort();
     memcpy(gen->args, argv, sizeof(xt_value) * (size_t)argc);
   }
+  xt_generator_gc_register();
   return XT_FROM_PTR(XT_TAG_OBJECT, gen);
 }
 

package/runtime/xt_loop.c

@@ -130,14 +130,22 @@ static int64_t xt_timer_next_due(void) {
 static void xt_timer_compact(void) {
   uint32_t write = 0;
   for (uint32_t read = 0; read < xt_timer_count; read++) {
-    if (!xt_timers[read].active) continue;
+    if (!xt_timers[read].active) {
+      free(xt_timers[read].args);
+      xt_timers[read].args = NULL;
+      xt_timers[read].argc = 0;
+      continue;
+    }
     if (write != read) xt_timers[write] = xt_timers[read];
     write++;
   }
   xt_timer_count = write;
 }
 
+static void xt_loop_gc_register(void);
+
 static uint64_t xt_timer_add(xt_value callback, int64_t delay_ms, int64_t interval_ms, int32_t argc, xt_value *argv) {
+  xt_loop_gc_register();
   if (xt_timer_count >= xt_timer_capacity) {
     xt_timer_capacity = xt_timer_capacity == 0 ? 16 : xt_timer_capacity * 2;
     xt_timer *grown = (xt_timer *)realloc(xt_timers, sizeof(xt_timer) * xt_timer_capacity);
@@ -170,6 +178,31 @@ static int xt_timer_cancel(uint64_t id) {
   return 0;
 }
 
+/* Watchers and pending timers hold values outside the value graph: the timer
+ * callbacks/arguments live in the flat array, and extension watchers keep an
+ * `xt_value *` box in their opaque userdata (the `xt_loop_add` convention). */
+static void xt_loop_gc_scan_roots(void) {
+  for (int i = 0; i < xt_loop_watcher_count; i++) {
+    if (!xt_loop_watchers[i].active) continue;
+    xt_value *boxed = (xt_value *)xt_loop_watchers[i].userdata;
+    if (boxed) xt_gc_mark_value(*boxed);
+  }
+  for (uint32_t i = 0; i < xt_timer_count; i++) {
+    if (!xt_timers[i].active) continue;
+    xt_gc_mark_value(xt_timers[i].callback);
+    if (xt_timers[i].args && xt_timers[i].argc > 0) {
+      xt_gc_scan_region(xt_timers[i].args, sizeof(xt_value) * (size_t)xt_timers[i].argc);
+    }
+  }
+}
+
+static void xt_loop_gc_register(void) {
+  static int registered = 0;
+  if (registered) return;
+  registered = 1;
+  xt_gc_register_root_provider(xt_loop_gc_scan_roots);
+}
+
 /* Invoke every timer whose deadline has passed. Timers scheduled by a callback
  * (or by a microtask) are left for the next reactor iteration, so a recursive
  * `setTimeout(fn, 0)` cannot spin forever inside a single call. */
@@ -232,6 +265,7 @@ xt_value xt_clear_interval(int32_t argc, xt_value *argv) {
 
 int xt_loop_add(int fd, int events, xt_io_handler handler, void *userdata) {
   if (fd < 0 || !handler) return -1;
+  xt_loop_gc_register();
   xt_loop_watcher *existing = xt_loop_find(fd);
   if (existing) {
     existing->events = events;

package/runtime/xt_promise.c

@@ -63,6 +63,8 @@ static xt_value xt_promise_value(xt_promise *promise) {
   return XT_FROM_PTR(XT_TAG_OBJECT, promise);
 }
 
+static void xt_promise_gc_register(void);
+
 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;
@@ -70,9 +72,52 @@ static xt_promise *xt_promise_new(void) {
   promise->reactions = NULL;
   promise->reaction_count = 0;
   promise->reaction_capacity = 0;
+  xt_promise_gc_register();
   return promise;
 }
 
+/* Reactions are plain `malloc` blocks referenced from promises and from the
+ * microtask queue, so neither can be found by scanning the heap: the queue is
+ * a root provider and a promise traces the reactions it still owns. */
+static void xt_promise_gc_scan_roots(void) {
+  for (uint32_t i = xt_microtask_head; i < xt_microtask_count; i++) {
+    xt_reaction *reaction = xt_microtasks[i];
+    if (!reaction) continue;
+    xt_gc_mark_header((xt_header *)reaction->promise);
+    xt_gc_mark_value(reaction->on_fulfilled);
+    xt_gc_mark_value(reaction->on_rejected);
+    xt_gc_mark_header((xt_header *)reaction->result);
+  }
+}
+
+static void xt_promise_gc_register(void) {
+  static int registered = 0;
+  if (registered) return;
+  registered = 1;
+  xt_gc_register_root_provider(xt_promise_gc_scan_roots);
+}
+
+void xt_promise_gc_trace(xt_header *header) {
+  xt_promise *promise = (xt_promise *)header;
+  xt_gc_mark_value(promise->value);
+  for (uint32_t i = 0; i < promise->reaction_count; i++) {
+    xt_reaction *reaction = promise->reactions[i];
+    if (!reaction) continue;
+    xt_gc_mark_header((xt_header *)reaction->promise);
+    xt_gc_mark_value(reaction->on_fulfilled);
+    xt_gc_mark_value(reaction->on_rejected);
+    xt_gc_mark_header((xt_header *)reaction->result);
+  }
+}
+
+void xt_promise_gc_release(xt_header *header) {
+  xt_promise *promise = (xt_promise *)header;
+  /* Pending reactions are owned solely by the promise; queued ones live in
+   * `xt_microtasks` and are freed as they run. */
+  for (uint32_t i = 0; i < promise->reaction_count; i++) free(promise->reactions[i]);
+  free(promise->reactions);
+}
+
 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) {
@@ -122,6 +167,7 @@ static xt_value xt_promise_run_reactions(void) {
     } else {
       xt_promise_settle(reaction->result, XT_PROMISE_REJECTED, promise->value);
     }
+    free(reaction);
   }
   xt_microtask_head = 0;
   xt_microtask_count = 0;

package/runtime/xt_stdlib2/error.inc

@@ -19,6 +19,7 @@ static int xt_error_is_family(const char *name) {
 static xt_value xt_error_root_proto = XT_UNDEFINED;
 
 static xt_value xt_error_proto_for(const char *name) {
+  xt_gc_add_root(&xt_error_root_proto);
   if (!XT_IS_OBJECT(xt_error_root_proto)) {
     xt_error_root_proto = xt_object_new();
     xt_object_set(xt_error_root_proto, xt_string_from_cstr("name"),

package/runtime/xt_stdlib2/regexp-match.inc

@@ -326,8 +326,10 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     int32_t end = (int32_t)matches[0].rm_eo;
     xt_regexp_append(&out, &length, &capacity, text->data + cursor, (size_t)(start - cursor));
     if (useFunction) {
-      xt_value *args = (xt_value *)malloc(sizeof(xt_value) * (size_t)(jsTotal + 3));
-      args[0] = xt_string_new(text->data + start, (int64_t)(end - start));
+      /* Accumulate in an `xt_array` so the earlier match/group strings stay
+         reachable while later groups (and the callback itself) allocate. */
+      xt_value argArray = xt_array_new(0, NULL);
+      xt_array_push(argArray, xt_string_new(text->data + start, (int64_t)(end - start)));
       for (int g = 1; g <= jsTotal; g++) {
         xt_value groupValue = XT_UNDEFINED;
         for (int i = 0; i < groupCount; i++) {
@@ -337,12 +339,11 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
           }
           break;
         }
-        args[g] = groupValue;
+        xt_array_push(argArray, groupValue);
       }
-      args[jsTotal + 1] = xt_number((double)start);
-      args[jsTotal + 2] = xt_to_string(value);
-      xt_value produced = xt_closure_call(replacementValue, jsTotal + 3, args);
-      free(args);
+      xt_array_push(argArray, xt_number((double)start));
+      xt_array_push(argArray, xt_to_string(value));
+      xt_value produced = xt_closure_call(replacementValue, jsTotal + 3, xt_as_array(argArray)->items);
       xt_string *producedText = xt_as_string(xt_to_string(produced));
       if (producedText) xt_regexp_append(&out, &length, &capacity, producedText->data, producedText->length);
     } else {

package/runtime/xt_symbol.c

@@ -57,6 +57,7 @@ static int g_well_known_ready = 0;
 static void xt_symbol_init_well_known(void) {
   if (g_well_known_ready) return;
   g_well_known_ready = 1;
+  xt_gc_add_root_range(g_well_known, XT_WELL_KNOWN_COUNT);
   for (int i = 0; i < XT_WELL_KNOWN_COUNT; i++) {
     char buffer[64];
     snprintf(buffer, sizeof(buffer), "Symbol.%s", XT_WELL_KNOWN_NAMES[i]);
@@ -116,6 +117,7 @@ xt_value xt_symbol(int32_t argc, xt_value *argv) {
 static xt_value g_symbol_registry = XT_UNDEFINED;
 
 xt_value xt_symbol_for(xt_value key) {
+  xt_gc_add_root(&g_symbol_registry);
   xt_value keyString = xt_to_string(key);
   if (g_symbol_registry == XT_UNDEFINED) g_symbol_registry = xt_object_new();
   xt_value existing = xt_object_get(g_symbol_registry, keyString);

package/runtime/xt_typed_array/construction.inc

@@ -0,0 +1,142 @@
+/* xbintsc runtime - typed array constructors, prototypes and statics.
+ * Included by `xt_typed_array.c` as part of a single translation unit. */
+
+/* -- construction --------------------------------------------------------- */
+
+static void xt_ta_define(xt_value proto, const char *name, void *fn) {
+  xt_object_set(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+static xt_value xt_ta_proto(int kind) {
+  static int registered = 0;
+  if (!registered) {
+    registered = 1;
+    xt_gc_add_root_range(xt_ta_protos, XT_TA_KIND_COUNT);
+  }
+  if (kind < 0 || kind >= XT_TA_KIND_COUNT) return XT_UNDEFINED;
+  if (xt_ta_protos[kind]) return xt_ta_protos[kind];
+  xt_value proto = xt_object_new();
+  xt_ta_protos[kind] = proto;
+  xt_object_set(proto, xt_string_from_cstr("BYTES_PER_ELEMENT"), xt_number((double)xt_ta_bytes[kind]));
+  xt_ta_define(proto, "fill", (void *)xt_ta_method_fill);
+  xt_ta_define(proto, "set", (void *)xt_ta_method_set);
+  xt_ta_define(proto, "slice", (void *)xt_ta_method_slice);
+  xt_ta_define(proto, "subarray", (void *)xt_ta_method_slice);
+  xt_ta_define(proto, "join", (void *)xt_ta_method_join);
+  xt_ta_define(proto, "toString", (void *)xt_ta_method_to_string);
+  xt_ta_define(proto, "toLocaleString", (void *)xt_ta_method_to_string);
+  xt_ta_define(proto, "indexOf", (void *)xt_ta_method_index_of);
+  xt_ta_define(proto, "lastIndexOf", (void *)xt_ta_method_last_index_of);
+  xt_ta_define(proto, "includes", (void *)xt_ta_method_includes);
+  xt_ta_define(proto, "forEach", (void *)xt_ta_method_for_each);
+  xt_ta_define(proto, "map", (void *)xt_ta_method_map);
+  xt_ta_define(proto, "filter", (void *)xt_ta_method_filter);
+  xt_ta_define(proto, "every", (void *)xt_ta_method_every);
+  xt_ta_define(proto, "some", (void *)xt_ta_method_some);
+  xt_ta_define(proto, "find", (void *)xt_ta_method_find);
+  xt_ta_define(proto, "findIndex", (void *)xt_ta_method_find_index);
+  xt_ta_define(proto, "reduce", (void *)xt_ta_method_reduce);
+  xt_ta_define(proto, "reverse", (void *)xt_ta_method_reverse);
+  xt_ta_define(proto, "sort", (void *)xt_ta_method_sort);
+  xt_ta_define(proto, "copyWithin", (void *)xt_ta_method_copy_within);
+  xt_ta_define(proto, "at", (void *)xt_ta_method_at);
+  xt_ta_define(proto, "keys", (void *)xt_ta_method_keys);
+  xt_ta_define(proto, "values", (void *)xt_ta_method_values);
+  xt_ta_define(proto, "entries", (void *)xt_ta_method_entries);
+  return proto;
+}
+
+static xt_value xt_ta_new(int kind, uint32_t length) {
+  xt_value array = xt_object_new_with_proto(xt_ta_proto(kind));
+  xt_object_set(array, xt_string_from_cstr("length"), xt_number((double)length));
+  xt_object_set(array, xt_string_from_cstr("byteLength"), xt_number((double)length * xt_ta_bytes[kind]));
+  xt_object_set(array, xt_string_from_cstr("byteOffset"), xt_number(0));
+  for (uint32_t i = 0; i < length; i++) xt_ta_store(array, kind, i, 0);
+  return array;
+}
+
+/* Length of any value a typed array can be built from, or 0 when it is not
+ * array-like (strings/iterables are intentionally not treated as element
+ * sources yet). */
+static int xt_ta_length_of(xt_value value, uint32_t *out) {
+  if (XT_IS_ARRAY(value)) {
+    *out = (uint32_t)xt_to_number(xt_array_length(value));
+    return 1;
+  }
+  if (XT_IS_STRING(value)) {
+    *out = xt_as_string(value)->length;
+    return 1;
+  }
+  if (xt_typed_array_kind_of(value) >= 0) {
+    *out = xt_ta_length(value);
+    return 1;
+  }
+  if (XT_IS_OBJECT(value)) {
+    xt_value length = xt_object_get_cstr(value, "length");
+    if (length != XT_UNDEFINED) {
+      double size = xt_to_number(length);
+      *out = size > 0 ? (uint32_t)size : 0;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static xt_value xt_ta_from_value(int kind, xt_value value, xt_value mapFn, xt_value thisArg, int haveMap) {
+  uint32_t length = 0;
+  if (!xt_ta_length_of(value, &length)) length = 0;
+  xt_value array = xt_ta_new(kind, length);
+  for (uint32_t i = 0; i < length; i++) {
+    xt_value item = xt_get(value, xt_number((double)i));
+    if (haveMap) {
+      xt_value args[3] = {item, xt_number((double)i), array};
+      item = xt_call_with_this(mapFn, thisArg, 3, args);
+    }
+    xt_ta_store(array, kind, i, xt_to_number(item));
+  }
+  return array;
+}
+
+static xt_value xt_ta_ctor_impl(int kind, int32_t argc, xt_value *argv) {
+  if (argc == 0) return xt_ta_new(kind, 0);
+  xt_value argument = argv[0];
+  /* Objects (arrays / typed arrays / array-likes / iterables) are copied
+   * element-wise; every other argument is a length via `ToIndex`. */
+  if (XT_IS_ARRAY(argument) || XT_IS_OBJECT(argument)) {
+    return xt_ta_from_value(kind, argument, XT_UNDEFINED, XT_UNDEFINED, 0);
+  }
+  double size = xt_to_number(argument);
+  return xt_ta_new(kind, size > 0 ? (uint32_t)trunc(size) : 0);
+}
+
+static xt_value xt_ta_static_impl(int kind, xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return XT_UNDEFINED;
+  if (strcmp(method, "from") == 0) {
+    int haveMap = argc > 1 && XT_IS_FUNCTION(argv[1]);
+    return xt_ta_from_value(kind, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1), xt_arg_at(argc, argv, 2), haveMap);
+  }
+  if (strcmp(method, "of") == 0) {
+    xt_value array = xt_ta_new(kind, (uint32_t)argc);
+    for (int32_t i = 0; i < argc; i++) xt_ta_store(array, kind, (uint32_t)i, xt_to_number(argv[i]));
+    return array;
+  }
+  return XT_UNDEFINED;
+}
+
+#define XT_TA_CTOR(suffix, kind) \
+  xt_value xt_ta_##suffix##_ctor(int32_t argc, xt_value *argv) { return xt_ta_ctor_impl(kind, argc, argv); } \
+  xt_value xt_ta_##suffix##_static(xt_value name, int32_t argc, xt_value *argv) { \
+    return xt_ta_static_impl(kind, name, argc, argv); \
+  }
+
+XT_TA_CTOR(u8, XT_TA_U8)
+XT_TA_CTOR(i8, XT_TA_I8)
+XT_TA_CTOR(u8c, XT_TA_U8C)
+XT_TA_CTOR(u16, XT_TA_U16)
+XT_TA_CTOR(i16, XT_TA_I16)
+XT_TA_CTOR(u32, XT_TA_U32)
+XT_TA_CTOR(i32, XT_TA_I32)
+XT_TA_CTOR(f32, XT_TA_F32)
+XT_TA_CTOR(f64, XT_TA_F64)
+

package/runtime/xt_typed_array/elements.inc

@@ -0,0 +1,92 @@
+/* xbintsc runtime - typed array element conversion, storage and helpers.
+ * Included by `xt_typed_array.c` as part of a single translation unit. */
+
+/* -- element conversion --------------------------------------------------- */
+
+/* ECMAScript `ToUintN` / `ToIntN`: truncate, then wrap modulo 2^N. */
+static double xt_ta_wrap(double value, double modulus) {
+  if (isnan(value) || isinf(value)) return 0;
+  double result = fmod(trunc(value), modulus);
+  if (result < 0) result += modulus;
+  return result;
+}
+
+double xt_typed_array_coerce(int kind, double value) {
+  switch (kind) {
+    case XT_TA_U8:
+      return xt_ta_wrap(value, 256.0);
+    case XT_TA_I8: {
+      double wrapped = xt_ta_wrap(value, 256.0);
+      return wrapped >= 128.0 ? wrapped - 256.0 : wrapped;
+    }
+    case XT_TA_U8C:
+      if (isnan(value) || value <= 0) return 0;
+      if (value >= 255) return 255;
+      return rint(value);
+    case XT_TA_U16:
+      return xt_ta_wrap(value, 65536.0);
+    case XT_TA_I16: {
+      double wrapped = xt_ta_wrap(value, 65536.0);
+      return wrapped >= 32768.0 ? wrapped - 65536.0 : wrapped;
+    }
+    case XT_TA_U32:
+      return xt_ta_wrap(value, 4294967296.0);
+    case XT_TA_I32: {
+      double wrapped = xt_ta_wrap(value, 4294967296.0);
+      return wrapped >= 2147483648.0 ? wrapped - 4294967296.0 : wrapped;
+    }
+    case XT_TA_F32:
+      return (double)(float)value;
+    case XT_TA_F64:
+    default:
+      return value;
+  }
+}
+
+int xt_typed_array_kind_of(xt_value value) {
+  if (!XT_IS_OBJECT(value)) return -1;
+  xt_object *object = (xt_object *)XT_GET_PTR(value);
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT) return -1;
+  for (int kind = 0; kind < XT_TA_KIND_COUNT; kind++) {
+    if (xt_ta_protos[kind] && object->prototype == xt_ta_protos[kind]) return kind;
+  }
+  return -1;
+}
+
+/* -- element storage ------------------------------------------------------ */
+
+static uint32_t xt_ta_length(xt_value array) {
+  double length = xt_to_number(xt_object_get_cstr(array, "length"));
+  if (!(length > 0)) return 0;
+  return (uint32_t)length;
+}
+
+static xt_value xt_ta_element(xt_value array, uint32_t index) {
+  char key[24];
+  snprintf(key, sizeof(key), "%u", index);
+  return xt_object_get_cstr(array, key);
+}
+
+static void xt_ta_store(xt_value array, int kind, uint32_t index, double value) {
+  char key[24];
+  snprintf(key, sizeof(key), "%u", index);
+  xt_object_set(array, xt_string_from_cstr(key), xt_number(xt_typed_array_coerce(kind, value)));
+}
+
+/* -- helpers -------------------------------------------------------------- */
+
+static int32_t xt_ta_relative(int32_t index, int32_t length) {
+  if (index < 0) index += length;
+  if (index < 0) index = 0;
+  if (index > length) index = length;
+  return index;
+}
+
+static xt_value xt_ta_append(xt_value array, int kind, xt_value value) {
+  uint32_t length = xt_ta_length(array);
+  xt_object_set(array, xt_string_from_cstr("length"), xt_number((double)(length + 1)));
+  xt_object_set(array, xt_string_from_cstr("byteLength"), xt_number((double)(length + 1) * xt_ta_bytes[kind]));
+  xt_ta_store(array, kind, length, xt_to_number(value));
+  return array;
+}
+