xbintsc 0.3.87 → 0.5.20

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));
@@ -64,7 +186,7 @@ xt_value xt_object_static(xt_value name, int32_t argc, xt_value *argv) {
   }
   if (strcmp(fn, "create") == 0) {
     xt_value proto = xt_arg_at(argc, argv, 0);
-    return xt_object_new_with_proto(proto == XT_NULL ? XT_UNDEFINED : proto);
+    return xt_object_new_with_proto(proto == XT_NULL ? XT_NULL : proto);
   }
   return XT_UNDEFINED;
 }

package/runtime/xt_stdlib2/regexp-match.inc

@@ -203,7 +203,7 @@ xt_value xt_regexp_exec(xt_value target, xt_value input) {
     }
     xt_array_push(out, groupValue);
   }
-  xt_set(out, xt_string_from_cstr("index"), xt_number((double)matches[0].rm_so));
+  xt_set(out, xt_string_from_cstr("index"), xt_number((double)xt_string_unit_offset(text, matches[0].rm_so)));
   xt_set(out, xt_string_from_cstr("input"), textValue);
   xt_set(out, xt_string_from_cstr("groups"), XT_UNDEFINED);
   free(matches);
@@ -351,7 +351,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
         }
         xt_array_push(argArray, groupValue);
       }
-      xt_array_push(argArray, xt_number((double)start));
+      xt_array_push(argArray, xt_number((double)xt_string_unit_offset(text, 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));

package/runtime/xt_stdlib2/set.inc

@@ -17,6 +17,8 @@ int32_t xt_set_size(xt_value value) {
 xt_value xt_iter_length(xt_value value) {
   if (xt_is_map(value)) return xt_number((double)xt_map_size(value));
   if (xt_is_set(value)) return xt_number((double)xt_set_size(value));
+  /* Strings iterate by code point, not by UTF-16 unit. */
+  if (XT_IS_STRING(value)) return xt_number((double)xt_string_code_point_count(xt_as_string(value)));
   return xt_array_length(value);
 }
 
@@ -53,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;
 }
 
@@ -70,12 +72,16 @@ xt_value xt_iter_has(xt_value value, xt_value index) {
   if (xt_is_generator(value)) return xt_bool(xt_generator_has_next(value));
   if (xt_is_map(value)) return xt_bool(xt_to_int32(index) < xt_map_size(value));
   if (xt_is_set(value)) return xt_bool(xt_to_int32(index) < xt_set_size(value));
+  if (XT_IS_STRING(value))
+    return xt_bool(xt_to_int32(index) <
+                   (int32_t)xt_string_code_point_count(xt_as_string(value)));
   return xt_bool(xt_to_int32(index) < xt_to_int32(xt_array_length(value)));
 }
 
 xt_value xt_iter_value(xt_value value, xt_value index) {
   if (xt_is_iterator_state(value)) return ((xt_iterator_state *)XT_GET_PTR(value))->cached;
   if (xt_is_generator(value)) return xt_generator_iter_value(value);
+  if (XT_IS_STRING(value)) return xt_string_code_point_value(xt_as_string(value), xt_to_int32(index));
   if (xt_is_map(value)) {
     xt_map *map = (xt_map *)XT_GET_PTR(value);
     int64_t i = (int64_t)xt_to_int32(index);

package/runtime/xt_stdlib2/strings.inc

@@ -1,26 +1,28 @@
 /* -- string methods ------------------------------------------------------- */
 
+/* `padStart`/`padEnd` measure the target length in UTF-16 code units and may
+ * cut the pad string through a surrogate pair. */
 static xt_value xt_string_pad(xt_value value, xt_value lengthValue, xt_value padValue, int start) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   int32_t target = xt_to_int32(lengthValue);
-  if (target <= (int32_t)s->length) return value;
-  xt_string *pad = xt_as_string(xt_to_string(padValue == XT_UNDEFINED ? xt_string_from_cstr(" ") : padValue));
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (target <= units) return value;
+  xt_value padSymbol = padValue == XT_UNDEFINED ? xt_string_from_cstr(" ") : padValue;
+  xt_string *pad = xt_as_string(xt_to_string(padSymbol));
   if (!pad || pad->length == 0) return value;
-  size_t total = (size_t)target;
-  xt_string *out = xt_string_alloc(total);
-  char *mutable = xt_string_mutable(out);
-  const char *text = xt_string_bytes(s);
-  const char *padBytes = xt_string_bytes(pad);
-  size_t needed = total - s->length;
-  if (start) {
-    for (size_t i = 0; i < needed; i++) mutable[i] = padBytes[i % pad->length];
-    memcpy(mutable + needed, text, s->length);
-  } else {
-    memcpy(mutable, text, s->length);
-    for (size_t i = 0; i < needed; i++) mutable[s->length + i] = padBytes[i % pad->length];
+  int32_t padUnits = (int32_t)xt_string_utf16_length(pad);
+  if (padUnits <= 0) return value;
+  uint32_t needed = (uint32_t)(target - units);
+  xt_value padding = xt_string_from_cstr("");
+  uint32_t filled = 0;
+  while (filled < needed) {
+    uint32_t remaining = needed - filled;
+    int32_t chunk = remaining < (uint32_t)padUnits ? (int32_t)remaining : padUnits;
+    padding = xt_add(padding, xt_string_slice_units(pad, 0, chunk));
+    filled += (uint32_t)chunk;
   }
-  return XT_FROM_PTR(XT_TAG_STRING, out);
+  return start ? xt_add(padding, value) : xt_add(value, padding);
 }
 
 static xt_value xt_string_trim_side(xt_value value, int start) {
@@ -37,10 +39,11 @@ static xt_value xt_string_trim_side(xt_value value, int start) {
 static xt_value xt_string_at(xt_value value, xt_value indexValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return XT_UNDEFINED;
+  int32_t units = (int32_t)xt_string_utf16_length(s);
   int32_t index = indexValue == XT_UNDEFINED ? 0 : xt_to_int32(indexValue);
-  if (index < 0) index += (int32_t)s->length;
-  if (index < 0 || (uint32_t)index >= s->length) return XT_UNDEFINED;
-  return xt_string_new(xt_string_bytes(s) + index, 1);
+  if (index < 0) index += units;
+  if (index < 0 || index >= units) return XT_UNDEFINED;
+  return xt_string_unit_value(s, index);
 }
 
 static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
@@ -49,7 +52,18 @@ static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_v
   if (!s) return value;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
-  if (!search || search->length == 0) return value;
+  if (!search || search->length == 0) {
+    /* An empty search inserts the replacement before every UTF-16 code unit
+     * and once at the end. */
+    int32_t units = (int32_t)xt_string_utf16_length(s);
+    xt_value replacementText = xt_to_string(replacementValue);
+    xt_value result = replacementText;
+    for (int32_t i = 0; i < units; i++) {
+      result = xt_add(result, xt_string_unit_value(s, i));
+      result = xt_add(result, replacementText);
+    }
+    return result;
+  }
   const char *text = xt_string_bytes(s);
   const char *needle = xt_string_bytes(search);
   const char *repl = xt_string_bytes(replacement);
@@ -74,6 +88,33 @@ static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_v
   return result;
 }
 
+/* `limit` is a UTF-16 index; the last possible match starts at or before it. */
+static xt_value xt_string_last_index_of(xt_string *s, xt_string *needle, int32_t limit) {
+  if (!s || !needle) return xt_number(-1);
+  const char *text = xt_string_bytes(s);
+  const char *need = xt_string_bytes(needle);
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (limit < 0) limit = 0;
+  if (limit > units) limit = units;
+  if (needle->length == 0) return xt_number((double)limit);
+  /* The low half of a surrogate pair is a match candidate of its own, but a
+   * byte search from the pair start cannot see it. */
+  if (!xt_string_is_boundary(s, limit)) {
+    xt_string *tail = xt_as_string(xt_string_slice_units(s, limit, units));
+    if (needle->length <= tail->length &&
+        memcmp(xt_string_bytes(tail), need, needle->length) == 0)
+      return xt_number((double)limit);
+  }
+  if (needle->length > s->length) return xt_number(-1);
+  int32_t i = xt_string_byte_offset(s, limit);
+  if (i > (int32_t)s->length - (int32_t)needle->length) i = (int32_t)s->length - (int32_t)needle->length;
+  for (; i >= 0; i--) {
+    if (((unsigned char)text[i] & 0xC0) == 0x80) continue; /* not a code-point boundary */
+    if (memcmp(text + i, need, needle->length) == 0) return xt_number((double)xt_string_unit_offset(s, i));
+  }
+  return xt_number(-1);
+}
+
 xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
   *handled = 1;
   if (strcmp(method, "at") == 0) return xt_string_at(target, xt_arg_at(argc, argv, 0));
@@ -93,34 +134,22 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     xt_value regexp = xt_arg_at(argc, argv, 0);
     if (xt_is_regexp(regexp)) {
       int32_t start = 0;
-      if (xt_regexp_find(regexp, target, 0, &start, NULL)) return xt_number((double)start);
+      if (xt_regexp_find(regexp, target, 0, &start, NULL)) {
+        xt_string *text = xt_as_string(xt_to_string(target));
+        return xt_number((double)xt_string_unit_offset(text, start));
+      }
       return xt_number(-1);
     }
     *handled = 0;
     return XT_UNDEFINED;
   }
-  if (strcmp(method, "replaceAll") == 0) {
-    xt_value searchValue = xt_arg_at(argc, argv, 0);
-    if (xt_is_regexp(searchValue)) return xt_regexp_replace(target, searchValue, xt_arg_at(argc, argv, 1));
-    *handled = 0;
-    return XT_UNDEFINED;
-  }
   if (strcmp(method, "lastIndexOf") == 0) {
     xt_string *s = xt_as_string(target);
     xt_string *needle = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
     if (!s || !needle) return xt_number(-1);
-    int32_t limit = (argc >= 2 && argv[1] != XT_UNDEFINED) ? xt_to_int32(argv[1]) : (int32_t)s->length;
-    if (limit > (int32_t)s->length) limit = (int32_t)s->length;
-    int32_t nlen = (int32_t)needle->length;
-    if (nlen == 0) return xt_number((double)(limit < 0 ? 0 : limit));
-    const char *text = xt_string_bytes(s);
-    const char *need = xt_string_bytes(needle);
-    int32_t i = limit;
-    if (i > (int32_t)s->length - nlen) i = (int32_t)s->length - nlen;
-    for (; i >= 0; i--) {
-      if (memcmp(text + i, need, (size_t)nlen) == 0) return xt_number((double)i);
-    }
-    return xt_number(-1);
+    int32_t limit = (argc >= 2 && argv[1] != XT_UNDEFINED) ? xt_to_int32(argv[1])
+                                                          : (int32_t)xt_string_utf16_length(s);
+    return xt_string_last_index_of(s, needle, limit);
   }
   if (strcmp(method, "localeCompare") == 0) {
     xt_string *a = xt_as_string(target);
@@ -132,8 +161,9 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     xt_string *s = xt_as_string(target);
     if (!s) return XT_UNDEFINED;
     int32_t index = xt_to_int32(xt_arg_at(argc, argv, 0));
-    if (index < 0 || (uint32_t)index >= s->length) return XT_UNDEFINED;
-    return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
+    int32_t code = xt_string_code_point_at(s, index);
+    if (code < 0) return XT_UNDEFINED;
+    return xt_number((double)code);
   }
   if (strcmp(method, "valueOf") == 0 || strcmp(method, "toString") == 0) return target;
   *handled = 0;

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;
+}