xbintsc 0.5.6 → 0.5.20

package/runtime/xt_structured_clone.c

@@ -0,0 +1,159 @@
+/*
+ * xbintsc runtime — `structuredClone`.
+ *
+ * Deep-clones arrays, plain objects, Map, Set, Date, RegExp and typed arrays,
+ * preserving shared references and cycles. Functions, symbols, promises,
+ * generators and iterators cannot be cloned, matching the platform API.
+ *
+ * The clone table maps source pointer -> clone. It lives on the C stack for
+ * the duration of the call; every clone is also reachable from its parent (or
+ * the current frame) while it is being filled, so the conservative stack scan
+ * keeps it alive across the allocations that happen during cloning.
+ */
+
+#include "rt_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  xt_value source;
+  xt_value clone;
+} xt_clone_entry;
+
+typedef struct {
+  xt_clone_entry *entries;
+  uint32_t count;
+  uint32_t capacity;
+} xt_clone_context;
+
+static _Noreturn void xt_clone_fail(const char *kind) {
+  char message[160];
+  snprintf(message, sizeof(message), "%s could not be cloned.", kind);
+  xt_value argument = xt_string_from_cstr(message);
+  xt_throw(xt_type_error_ctor(1, &argument));
+  abort();
+}
+
+static xt_value xt_clone_lookup(xt_clone_context *context, xt_value source) {
+  for (uint32_t i = 0; i < context->count; i++) {
+    if (context->entries[i].source == source) return context->entries[i].clone;
+  }
+  return XT_UNDEFINED;
+}
+
+static void xt_clone_remember(xt_clone_context *context, xt_value source, xt_value clone) {
+  if (context->count >= context->capacity) {
+    uint32_t capacity = context->capacity == 0 ? 8 : context->capacity * 2;
+    xt_clone_entry *entries =
+        (xt_clone_entry *)realloc(context->entries, sizeof(xt_clone_entry) * capacity);
+    if (!entries) abort();
+    context->entries = entries;
+    context->capacity = capacity;
+  }
+  context->entries[context->count].source = source;
+  context->entries[context->count].clone = clone;
+  context->count++;
+}
+
+static xt_value xt_clone_value(xt_clone_context *context, xt_value value) {
+  if (value == XT_UNDEFINED || value == XT_NULL || XT_IS_BOOL(value) || XT_IS_NUMBER(value) ||
+      XT_IS_STRING(value) || XT_IS_BIGINT(value)) {
+    return value;
+  }
+  if (XT_IS_FUNCTION(value)) xt_clone_fail("function");
+  if (xt_is_symbol(value)) xt_clone_fail("symbol");
+
+  xt_value existing = xt_clone_lookup(context, value);
+  if (existing != XT_UNDEFINED) return existing;
+
+  /* A typed array's own `slice` already produces an element-wise copy of the
+   * same concrete type. */
+  if (xt_typed_array_kind_of(value) >= 0) {
+    return xt_call_method(value, xt_string_from_cstr("slice"), 0, NULL);
+  }
+
+  if (XT_IS_ARRAY(value)) {
+    xt_value clone = xt_array_new(0, NULL);
+    xt_clone_remember(context, value, clone);
+    xt_array *array = xt_as_array(value);
+    for (uint32_t i = 0; i < array->length; i++) {
+      xt_array_push(clone, xt_clone_value(context, array->items[i]));
+    }
+    return clone;
+  }
+
+  if (!XT_IS_OBJECT(value)) xt_clone_fail("value");
+  xt_object *object = (xt_object *)XT_GET_PTR(value);
+
+  if (object->header.kind == XT_OBJECT_KIND_MAP) {
+    xt_map *map = (xt_map *)object;
+    xt_value clone = xt_map_ctor(0, NULL);
+    xt_clone_remember(context, value, clone);
+    for (uint32_t i = 0; i < map->count; i++) {
+      xt_value args[2] = {xt_clone_value(context, map->keys[i]),
+                          xt_clone_value(context, map->values[i])};
+      xt_call_method(clone, xt_string_from_cstr("set"), 2, args);
+    }
+    return clone;
+  }
+
+  if (object->header.kind == XT_OBJECT_KIND_SET) {
+    xt_set_object *set = (xt_set_object *)object;
+    xt_value clone = xt_set_ctor(0, NULL);
+    xt_clone_remember(context, value, clone);
+    for (uint32_t i = 0; i < set->count; i++) {
+      xt_value args[1] = {xt_clone_value(context, set->values[i])};
+      xt_call_method(clone, xt_string_from_cstr("add"), 1, args);
+    }
+    return clone;
+  }
+
+  if (object->header.kind == XT_OBJECT_KIND_DATE) {
+    xt_value time = xt_call_method(value, xt_string_from_cstr("getTime"), 0, NULL);
+    xt_value clone = xt_date_ctor(1, &time);
+    xt_clone_remember(context, value, clone);
+    return clone;
+  }
+
+  if (object->header.kind == XT_OBJECT_KIND_REGEXP) {
+    xt_value args[2] = {xt_get(value, xt_string_from_cstr("source")),
+                        xt_get(value, xt_string_from_cstr("flags"))};
+    xt_value clone = xt_regexp_ctor(2, args);
+    xt_clone_remember(context, value, clone);
+    return clone;
+  }
+
+  if (object->header.kind == XT_OBJECT_KIND_PROMISE) xt_clone_fail("Promise");
+  if (object->header.kind == XT_OBJECT_KIND_WEAK_MAP) xt_clone_fail("WeakMap");
+  if (object->header.kind == XT_OBJECT_KIND_WEAK_SET) xt_clone_fail("WeakSet");
+  if (object->header.kind == XT_OBJECT_KIND_WEAK_REF) xt_clone_fail("WeakRef");
+  if (object->header.kind == XT_OBJECT_KIND_GENERATOR) xt_clone_fail("generator");
+  if (object->header.kind == XT_OBJECT_KIND_ITERATOR) xt_clone_fail("iterator");
+  if (object->header.kind == XT_OBJECT_KIND_ASYNC) xt_clone_fail("async function");
+
+  /* Plain objects and Errors are cloned as data: own enumerable string keys,
+   * no prototype. That is what the platform algorithm does for ordinary
+   * objects and class instances. */
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT && object->header.kind != XT_OBJECT_KIND_ERROR) {
+    xt_clone_fail("value");
+  }
+  xt_value clone = xt_object_new();
+  xt_clone_remember(context, value, clone);
+  xt_value keys = xt_object_keys(value);
+  xt_array *keyArray = xt_as_array(keys);
+  if (!keyArray) return clone;
+  for (uint32_t i = 0; i < keyArray->length; i++) {
+    xt_value key = keyArray->items[i];
+    xt_object_set(clone, key, xt_clone_value(context, xt_object_get(value, key)));
+  }
+  return clone;
+}
+
+xt_value xt_structured_clone(int32_t argc, xt_value *argv) {
+  xt_clone_context context = {NULL, 0, 0};
+  xt_value clone = xt_clone_value(&context, xt_arg_at(argc, argv, 0));
+  free(context.entries);
+  return clone;
+}

package/runtime/xt_symbol.c

@@ -89,7 +89,7 @@ xt_value xt_symbol_description(xt_value value) {
 xt_value xt_symbol_to_string(xt_value value) {
   xt_symbol_data *symbol = xt_as_symbol(value);
   if (!symbol) {
-    xt_throw(xt_string_from_cstr(
+    xt_throw(xt_error_from_message(
         "TypeError: Symbol.prototype.toString requires that 'this' be a Symbol"));
   }
   xt_string *description =
@@ -129,7 +129,7 @@ xt_value xt_symbol_for(xt_value key) {
 
 xt_value xt_symbol_key_for(xt_value value) {
   if (!xt_is_symbol(value)) {
-    xt_throw(xt_string_from_cstr("TypeError: Symbol.keyFor requires a symbol"));
+    xt_throw(xt_error_from_message("TypeError: Symbol.keyFor requires a symbol"));
   }
   if (g_symbol_registry == XT_UNDEFINED) return XT_UNDEFINED;
   xt_value keys = xt_object_keys(g_symbol_registry);

package/runtime/xt_text_codec.c

@@ -0,0 +1,69 @@
+/*
+ * xbintsc runtime — TextEncoder / TextDecoder.
+ *
+ * Strings are stored as UTF-8 (lone surrogate halves as WTF-8), so encoding is
+ * a byte copy and decoding is a byte copy back. The constructors return plain
+ * objects holding the method closures, which is the same shape the rest of the
+ * runtime uses for first-class methods.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+
+static xt_value xt_text_encoder_encode(xt_value thisValue, xt_value env, int32_t argc,
+                                       xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  xt_value input = xt_arg_at(argc, argv, 0);
+  /* `encode()` with no argument encodes the empty string, like the web API. */
+  xt_value text = input == XT_UNDEFINED ? xt_string_from_cstr("") : xt_to_string(input);
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  xt_value length = xt_number((double)string->length);
+  xt_value array = xt_typed_array_ctor_by_name(xt_string_from_cstr("Uint8Array"), 1, &length);
+  for (uint32_t i = 0; i < string->length; i++) {
+    xt_set(array, xt_number((double)i), xt_number((double)(unsigned char)bytes[i]));
+  }
+  return array;
+}
+
+static xt_value xt_text_decoder_decode(xt_value thisValue, xt_value env, int32_t argc,
+                                       xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  xt_value input = xt_arg_at(argc, argv, 0);
+  if (input == XT_UNDEFINED) return xt_string_from_cstr("");
+  uint32_t length = (uint32_t)xt_to_number(xt_get(input, xt_string_from_cstr("length")));
+  char *bytes = (char *)malloc(length == 0 ? 1 : length);
+  if (!bytes) abort();
+  for (uint32_t i = 0; i < length; i++) {
+    double byte = xt_to_number(xt_get(input, xt_number((double)i)));
+    bytes[i] = (char)((int)byte & 0xff);
+  }
+  xt_value result = xt_string_new(bytes, length);
+  free(bytes);
+  return result;
+}
+
+xt_value xt_text_encoder_ctor(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  xt_value encoder = xt_object_new();
+  xt_object_set(encoder, xt_string_from_cstr("encode"),
+                xt_closure_new((void *)xt_text_encoder_encode, 0, NULL));
+  xt_object_set(encoder, xt_string_from_cstr("encoding"), xt_string_from_cstr("utf-8"));
+  return encoder;
+}
+
+xt_value xt_text_decoder_ctor(int32_t argc, xt_value *argv) {
+  (void)argv;
+  xt_value decoder = xt_object_new();
+  xt_object_set(decoder, xt_string_from_cstr("decode"),
+                xt_closure_new((void *)xt_text_decoder_decode, 0, NULL));
+  /* The only supported encoding is UTF-8; report the canonical label even when
+   * the caller passed "utf8" (as TextDecoder does). */
+  (void)argc;
+  xt_object_set(decoder, xt_string_from_cstr("encoding"), xt_string_from_cstr("utf-8"));
+  return decoder;
+}

package/runtime/xt_typed_array/construction.inc

@@ -21,7 +21,7 @@ static xt_value xt_ta_proto(int 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, "subarray", (void *)xt_ta_method_subarray);
   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);
@@ -50,15 +50,23 @@ static xt_value xt_ta_proto(int kind) {
   return proto;
 }
 
-static xt_value xt_ta_new(int kind, uint32_t length) {
+static xt_value xt_ta_view(int kind, xt_value buffer, uint32_t byteOffset, 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);
+  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((double)byteOffset));
+  xt_object_set(array, xt_ta_buffer_key(), buffer);
+  xt_object_set(array, xt_ta_offset_key(), xt_number((double)byteOffset));
   return array;
 }
 
+static xt_value xt_ta_new(int kind, uint32_t length) {
+  xt_value byteLength = xt_number((double)length * xt_ta_bytes[kind]);
+  xt_value buffer = xt_array_buffer_ctor(1, &byteLength);
+  return xt_ta_view(kind, buffer, 0, length);
+}
+
 /* 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). */
@@ -106,6 +114,28 @@ static xt_value xt_ta_from_value(int kind, xt_value value, xt_value mapFn, xt_va
 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];
+  if (xt_is_array_buffer(argument)) {
+    uint32_t bufferLength = xt_array_buffer_byte_length(argument);
+    double rawOffset = argc > 1 ? xt_to_number(argv[1]) : 0;
+    uint32_t offset = rawOffset > 0 ? (uint32_t)rawOffset : 0;
+    uint32_t width = (uint32_t)xt_ta_bytes[kind];
+    if (offset % width != 0 || offset > bufferLength) {
+      xt_value message = xt_string_from_cstr("start offset is not aligned or out of bounds");
+      xt_throw(xt_range_error_ctor(1, &message));
+    }
+    uint32_t length;
+    if (argc > 2 && argv[2] != XT_UNDEFINED) {
+      double rawLength = xt_to_number(argv[2]);
+      length = rawLength > 0 ? (uint32_t)rawLength : 0;
+    } else {
+      length = (bufferLength - offset) / width;
+    }
+    if (length > (bufferLength - offset) / width) {
+      xt_value message = xt_string_from_cstr("Invalid typed array length");
+      xt_throw(xt_range_error_ctor(1, &message));
+    }
+    return xt_ta_view(kind, argument, offset, length);
+  }
   /* 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)) {

package/runtime/xt_typed_array/elements.inc

@@ -53,6 +53,158 @@ int xt_typed_array_kind_of(xt_value value) {
   return -1;
 }
 
+const char *xt_typed_array_name_of(int kind) {
+  if (kind < 0 || kind >= XT_TA_KIND_COUNT) return NULL;
+  return xt_ta_names[kind];
+}
+
+/* -- buffer-backed views -------------------------------------------------- */
+
+/* The backing ArrayBuffer and byte offset live under private symbols, so a
+ * typed array's observable own properties stay `length`/`byteLength`/
+ * `byteOffset` plus `.buffer` (handled in access.inc). */
+static xt_value xt_ta_buffer_key_value = XT_UNDEFINED;
+static xt_value xt_ta_offset_key_value = XT_UNDEFINED;
+
+static xt_value xt_ta_buffer_key(void) {
+  if (!xt_is_symbol(xt_ta_buffer_key_value)) {
+    xt_ta_buffer_key_value = xt_symbol_new(xt_string_from_cstr("__typedArrayBuffer"));
+    xt_gc_add_root(&xt_ta_buffer_key_value);
+  }
+  return xt_ta_buffer_key_value;
+}
+
+static xt_value xt_ta_offset_key(void) {
+  if (!xt_is_symbol(xt_ta_offset_key_value)) {
+    xt_ta_offset_key_value = xt_symbol_new(xt_string_from_cstr("__typedArrayOffset"));
+    xt_gc_add_root(&xt_ta_offset_key_value);
+  }
+  return xt_ta_offset_key_value;
+}
+
+xt_value xt_typed_array_buffer_of(xt_value array) {
+  if (xt_typed_array_kind_of(array) < 0) return XT_UNDEFINED;
+  return xt_object_get(array, xt_ta_buffer_key());
+}
+
+uint32_t xt_typed_array_byte_offset_of(xt_value array) {
+  if (xt_typed_array_kind_of(array) < 0) return 0;
+  return (uint32_t)xt_to_number(xt_object_get(array, xt_ta_offset_key()));
+}
+
+xt_value xt_typed_array_read(xt_value array, uint32_t index) {
+  int kind = xt_typed_array_kind_of(array);
+  if (kind < 0) return XT_UNDEFINED;
+  xt_value buffer = xt_typed_array_buffer_of(array);
+  if (!xt_is_array_buffer(buffer)) {
+    char key[24];
+    snprintf(key, sizeof(key), "%u", index);
+    return xt_object_get_cstr(array, key);
+  }
+  uint32_t width = (uint32_t)xt_ta_bytes[kind];
+  uint32_t offset = xt_typed_array_byte_offset_of(array) + index * width;
+  if (offset + width > xt_array_buffer_byte_length(buffer)) return XT_UNDEFINED;
+  uint8_t raw[8];
+  for (uint32_t i = 0; i < width; i++) raw[i] = xt_array_buffer_get_byte(buffer, offset + i);
+  switch (kind) {
+    case XT_TA_U8:
+      return xt_number((double)raw[0]);
+    case XT_TA_I8:
+      return xt_number((double)(int8_t)raw[0]);
+    case XT_TA_U8C:
+      return xt_number((double)raw[0]);
+    case XT_TA_U16: {
+      uint16_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_I16: {
+      int16_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_U32: {
+      uint32_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_I32: {
+      int32_t value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    case XT_TA_F32: {
+      float value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number((double)value);
+    }
+    default: {
+      double value;
+      memcpy(&value, raw, sizeof(value));
+      return xt_number(value);
+    }
+  }
+}
+
+void xt_typed_array_write(xt_value array, uint32_t index, xt_value value) {
+  int kind = xt_typed_array_kind_of(array);
+  if (kind < 0) return;
+  xt_value buffer = xt_typed_array_buffer_of(array);
+  if (!xt_is_array_buffer(buffer)) {
+    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, xt_to_number(value))));
+    return;
+  }
+  uint32_t width = (uint32_t)xt_ta_bytes[kind];
+  uint32_t offset = xt_typed_array_byte_offset_of(array) + index * width;
+  if (offset + width > xt_array_buffer_byte_length(buffer)) return;
+  double coerced = xt_typed_array_coerce(kind, xt_to_number(value));
+  uint8_t raw[8];
+  memset(raw, 0, sizeof(raw));
+  switch (kind) {
+    case XT_TA_U8:
+    case XT_TA_U8C:
+      raw[0] = (uint8_t)coerced;
+      break;
+    case XT_TA_I8:
+      raw[0] = (uint8_t)(int8_t)coerced;
+      break;
+    case XT_TA_U16: {
+      uint16_t stored = (uint16_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_I16: {
+      int16_t stored = (int16_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_U32: {
+      uint32_t stored = (uint32_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_I32: {
+      int32_t stored = (int32_t)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    case XT_TA_F32: {
+      float stored = (float)coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+    default: {
+      double stored = coerced;
+      memcpy(raw, &stored, sizeof(stored));
+      break;
+    }
+  }
+  for (uint32_t i = 0; i < width; i++) xt_array_buffer_set_byte(buffer, offset + i, raw[i]);
+}
+
 /* -- element storage ------------------------------------------------------ */
 
 static uint32_t xt_ta_length(xt_value array) {
@@ -62,12 +214,19 @@ static uint32_t xt_ta_length(xt_value array) {
 }
 
 static xt_value xt_ta_element(xt_value array, uint32_t index) {
+  if (xt_is_array_buffer(xt_typed_array_buffer_of(array))) {
+    return xt_typed_array_read(array, 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) {
+  if (xt_is_array_buffer(xt_typed_array_buffer_of(array))) {
+    xt_typed_array_write(array, index, xt_number(value));
+    return;
+  }
   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)));

package/runtime/xt_typed_array/methods.inc

@@ -24,7 +24,7 @@ static xt_value xt_ta_method_set(xt_value self, xt_value env, int32_t argc, xt_v
   if (!xt_ta_length_of(source, &sourceLength)) return XT_UNDEFINED;
   int32_t offset = argc > 1 ? xt_to_int32(argv[1]) : 0;
   if (offset < 0 || offset + (int32_t)sourceLength > (int32_t)xt_ta_length(self)) {
-    xt_throw(xt_string_from_cstr("RangeError: offset is out of bounds"));
+    xt_throw(xt_error_from_message("RangeError: offset is out of bounds"));
     return XT_UNDEFINED;
   }
   for (uint32_t i = 0; i < sourceLength; i++) {
@@ -47,6 +47,20 @@ static xt_value xt_ta_method_slice(xt_value self, xt_value env, int32_t argc, xt
   return out;
 }
 
+static xt_value xt_ta_method_subarray(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int kind = xt_typed_array_kind_of(self);
+  if (kind < 0) return XT_UNDEFINED;
+  xt_value buffer = xt_typed_array_buffer_of(self);
+  if (!xt_is_array_buffer(buffer)) return xt_ta_method_slice(self, env, argc, argv);
+  int32_t length = (int32_t)xt_ta_length(self);
+  int32_t start = xt_ta_relative(argc > 0 && argv[0] != XT_UNDEFINED ? xt_to_int32(argv[0]) : 0, length);
+  int32_t end = xt_ta_relative(argc > 1 && argv[1] != XT_UNDEFINED ? xt_to_int32(argv[1]) : length, length);
+  if (end < start) end = start;
+  uint32_t offset = xt_typed_array_byte_offset_of(self) + (uint32_t)start * (uint32_t)xt_ta_bytes[kind];
+  return xt_ta_view(kind, buffer, offset, (uint32_t)(end - start));
+}
+
 static xt_value xt_ta_method_join(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   xt_value separator = argc > 0 && argv[0] != XT_UNDEFINED ? xt_to_string(argv[0]) : xt_string_from_cstr(",");
@@ -137,14 +151,16 @@ static xt_value xt_ta_method_filter(xt_value self, xt_value env, int32_t argc, x
   xt_value callback = xt_arg_at(argc, argv, 0);
   xt_value thisArg = xt_arg_at(argc, argv, 1);
   int32_t length = (int32_t)xt_ta_length(self);
-  xt_value out = xt_ta_new(kind, 0);
+  /* A fixed-length buffer cannot grow, so collect matches first and build the
+   * result typed array from that array. */
+  xt_value matches = xt_array_new(0, NULL);
   for (int32_t i = 0; i < length; i++) {
     xt_value args[3] = {xt_ta_element(self, (uint32_t)i), xt_number((double)i), self};
     if (xt_truthy(xt_call_with_this(callback, thisArg, 3, args))) {
-      xt_ta_append(out, kind, xt_ta_element(self, (uint32_t)i));
+      xt_array_push(matches, xt_ta_element(self, (uint32_t)i));
     }
   }
-  return out;
+  return xt_ta_from_value(kind, matches, XT_UNDEFINED, XT_UNDEFINED, 0);
 }
 
 static xt_value xt_ta_method_every(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -208,7 +224,7 @@ static xt_value xt_ta_method_reduce(xt_value self, xt_value env, int32_t argc, x
     accumulator = xt_ta_element(self, 0);
     index = 1;
   } else {
-    xt_throw(xt_string_from_cstr("TypeError: Reduce of empty array with no initial value"));
+    xt_throw(xt_error_from_message("TypeError: Reduce of empty array with no initial value"));
     return XT_UNDEFINED;
   }
   for (; index < length; index++) {

package/runtime/xt_typed_array.c

@@ -1,16 +1,12 @@
 /*
  * xbintsc runtime - typed arrays.
  *
- * JavaScript TypedArrays are modelled as plain property-bag objects with one
- * numbered property per element plus `length`, `byteLength` and `byteOffset`.
- * Every write is coerced to the array's element type, so
- * `new Uint8Array(2)[0] = 300` stores 44 exactly like ECMAScript and a
- * `Float32Array` round-trips through single precision.
- *
- * There is no shared `ArrayBuffer` backing store: `slice` / `subarray` return
- * independent copies and the `.buffer` property is not exposed. That matches
- * xbintsc's runtime, which has no distinct binary value type (strings are
- * UTF-8 byte arrays and `Buffer` is likewise a property bag).
+ * A TypedArray is a view over an `ArrayBuffer`: its elements live in the
+ * buffer's bytes at `byteOffset`, and `length` / `byteLength` describe the
+ * window. `subarray` shares that buffer; `slice` copies into a new one.
+ * Every write is coerced to the element type, so `new Uint8Array(2)[0] = 300`
+ * stores 44 exactly like ECMAScript and a `Float32Array` round-trips through
+ * single precision.
  */
 
 #include "rt_internal.h"
@@ -46,6 +42,7 @@ static xt_value xt_ta_protos[XT_TA_KIND_COUNT];
 static xt_value xt_ta_method_fill(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_set(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_slice(xt_value, xt_value, int32_t, xt_value *);
+static xt_value xt_ta_method_subarray(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_join(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_to_string(xt_value, xt_value, int32_t, xt_value *);
 static xt_value xt_ta_method_index_of(xt_value, xt_value, int32_t, xt_value *);