xbintsc 0.5.6 → 0.5.21

package/runtime/xt_stdlib2/objects.inc

@@ -35,9 +35,131 @@ static xt_value xt_object_group_by(xt_value value, xt_value fn) {
   return result;
 }
 
+/* -- property descriptors ------------------------------------------------- */
+
+/* `attr` defaults for `defineProperty` are all false; literal properties are
+ * all true. Store the bits per key under a symbol so the flag table stays out
+ * of Object.keys / JSON. Writable/enumerable are reported truthfully, but the
+ * runtime does not enforce them on later writes or enumeration yet. */
+static xt_value xt_object_descriptor_flags_key_value = XT_UNDEFINED;
+
+static xt_value xt_object_descriptor_flags_key(void) {
+  if (!xt_is_symbol(xt_object_descriptor_flags_key_value)) {
+    xt_object_descriptor_flags_key_value =
+        xt_symbol_new(xt_string_from_cstr("__propertyDescriptorFlags"));
+    xt_gc_add_root(&xt_object_descriptor_flags_key_value);
+  }
+  return xt_object_descriptor_flags_key_value;
+}
+
+static xt_value xt_object_descriptor_flags(xt_value target) {
+  if (!XT_IS_OBJECT(target)) return XT_UNDEFINED;
+  xt_value flags = xt_object_get(target, xt_object_descriptor_flags_key());
+  if (!XT_IS_OBJECT(flags)) {
+    flags = xt_object_new();
+    xt_object_set(target, xt_object_descriptor_flags_key(), flags);
+  }
+  return flags;
+}
+
+static int xt_object_descriptor_mask(xt_value target, xt_value key) {
+  if (!XT_IS_OBJECT(target)) return 7;
+  xt_value flags = xt_object_get(target, xt_object_descriptor_flags_key());
+  if (!XT_IS_OBJECT(flags)) return 7;
+  xt_value mask = xt_object_get(flags, key);
+  return mask == XT_UNDEFINED ? 7 : xt_to_int32(mask);
+}
+
+static xt_value xt_object_data_descriptor(xt_value value, int enumerable, int configurable,
+                                         int writable) {
+  xt_value descriptor = xt_object_new();
+  xt_object_set(descriptor, xt_string_from_cstr("value"), value);
+  xt_object_set(descriptor, xt_string_from_cstr("writable"), xt_bool(writable));
+  xt_object_set(descriptor, xt_string_from_cstr("enumerable"), xt_bool(enumerable));
+  xt_object_set(descriptor, xt_string_from_cstr("configurable"), xt_bool(configurable));
+  return descriptor;
+}
+
+static xt_value xt_object_get_own_property_descriptor(xt_value target, xt_value key) {
+  if (XT_IS_ARRAY(target)) {
+    if (XT_IS_STRING(key) && xt_as_string(key)->length == 6 &&
+        memcmp(xt_string_bytes(xt_as_string(key)), "length", 6) == 0) {
+      return xt_object_data_descriptor(xt_array_length(target), 0, 0, 1);
+    }
+    xt_value item = xt_get(target, key);
+    if (item != XT_UNDEFINED) return xt_object_data_descriptor(item, 1, 1, 1);
+    return XT_UNDEFINED;
+  }
+  if (!XT_IS_OBJECT(target)) return XT_UNDEFINED;
+  xt_object *object = (xt_object *)XT_GET_PTR(target);
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT && object->header.kind != XT_OBJECT_KIND_ERROR) {
+    return XT_UNDEFINED;
+  }
+  xt_property *property = xt_object_find_property(object, xt_to_property_key(key));
+  if (!property) return XT_UNDEFINED;
+  int mask = xt_object_descriptor_mask(target, key);
+  if (property->getter != XT_UNDEFINED || property->setter != XT_UNDEFINED) {
+    xt_value descriptor = xt_object_new();
+    if (property->getter != XT_UNDEFINED) {
+      xt_object_set(descriptor, xt_string_from_cstr("get"), property->getter);
+    }
+    if (property->setter != XT_UNDEFINED) {
+      xt_object_set(descriptor, xt_string_from_cstr("set"), property->setter);
+    }
+    xt_object_set(descriptor, xt_string_from_cstr("enumerable"), xt_bool((mask & 2) != 0));
+    xt_object_set(descriptor, xt_string_from_cstr("configurable"), xt_bool((mask & 4) != 0));
+    return descriptor;
+  }
+  return xt_object_data_descriptor(property->value, (mask & 2) != 0, (mask & 4) != 0,
+                                   (mask & 1) != 0);
+}
+
+static xt_value xt_object_define_property(xt_value target, xt_value key, xt_value descriptor) {
+  if (!XT_IS_OBJECT(descriptor)) return target;
+  int writable = xt_truthy(xt_object_get(descriptor, xt_string_from_cstr("writable")));
+  int enumerable = xt_truthy(xt_object_get(descriptor, xt_string_from_cstr("enumerable")));
+  int configurable = xt_truthy(xt_object_get(descriptor, xt_string_from_cstr("configurable")));
+  int mask = (writable ? 1 : 0) | (enumerable ? 2 : 0) | (configurable ? 4 : 0);
+  xt_value flags = xt_object_descriptor_flags(target);
+  if (XT_IS_OBJECT(flags)) xt_object_set(flags, key, xt_number((double)mask));
+  xt_value getter = xt_object_get(descriptor, xt_string_from_cstr("get"));
+  xt_value setter = xt_object_get(descriptor, xt_string_from_cstr("set"));
+  if (getter != XT_UNDEFINED || setter != XT_UNDEFINED) {
+    if (getter != XT_UNDEFINED) xt_object_define_getter(target, key, getter);
+    if (setter != XT_UNDEFINED) xt_object_define_setter(target, key, setter);
+    return target;
+  }
+  if (xt_object_has_own(descriptor, xt_string_from_cstr("value"))) {
+    xt_set(target, key, xt_object_get(descriptor, xt_string_from_cstr("value")));
+  }
+  return target;
+}
+
+static xt_value xt_object_get_own_property_descriptors(xt_value target) {
+  xt_value result = xt_object_new();
+  xt_value names = xt_object_own_property_names(target);
+  xt_array *keys = xt_as_array(names);
+  if (!keys) return result;
+  for (uint32_t i = 0; i < keys->length; i++) {
+    xt_value descriptor = xt_object_get_own_property_descriptor(target, keys->items[i]);
+    if (descriptor != XT_UNDEFINED) xt_object_set(result, keys->items[i], descriptor);
+  }
+  return result;
+}
+
 xt_value xt_object_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
+  if (strcmp(fn, "getOwnPropertyDescriptor") == 0) {
+    return xt_object_get_own_property_descriptor(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  }
+  if (strcmp(fn, "getOwnPropertyDescriptors") == 0) {
+    return xt_object_get_own_property_descriptors(xt_arg_at(argc, argv, 0));
+  }
+  if (strcmp(fn, "defineProperty") == 0) {
+    return xt_object_define_property(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1),
+                                      xt_arg_at(argc, argv, 2));
+  }
   if (strcmp(fn, "keys") == 0) return xt_object_keys(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "getOwnPropertyNames") == 0) return xt_object_own_property_names(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "getOwnPropertySymbols") == 0) return xt_object_own_property_symbols(xt_arg_at(argc, argv, 0));

package/runtime/xt_stdlib2/set.inc

@@ -55,7 +55,7 @@ xt_value xt_iter_open(xt_value value) {
       return XT_FROM_PTR(XT_TAG_OBJECT, state);
     }
   }
-  xt_throw(xt_string_from_cstr("TypeError: value is not iterable"));
+  xt_throw(xt_error_from_message("TypeError: value is not iterable"));
   return XT_UNDEFINED;
 }
 

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)));