xbintsc 0.3.81 → 0.5.6

package/runtime/xt_promise.c

@@ -1,10 +1,12 @@
 /*
- * xbintsc runtime — promises and async support.
+ * xbintsc runtime — promises and the microtask queue.
  *
- * There is no event loop in the runtime, so promises use a microtask queue
- * that the compiler drains when the program body finishes (and that `await`
- * drains on demand). This gives synchronous-looking `async`/`await` semantics
- * for the common case where every awaited value is already settled.
+ * Promise reactions are queued as microtasks and run when the program body
+ * finishes, by the event loop between callbacks, and on demand. `await` lives
+ * in `xt_async.c`: an `async` function runs on a coroutine, so awaiting a
+ * promise that is still pending suspends it and registers a waiter here. When
+ * the promise settles, the waiter becomes a microtask that resumes the
+ * coroutine. Everything is single-threaded and non-blocking.
  */
 
 #include "rt_internal.h"
@@ -12,10 +14,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define XT_PROMISE_PENDING 0
-#define XT_PROMISE_FULFILLED 1
-#define XT_PROMISE_REJECTED 2
-
 typedef struct xt_promise xt_promise;
 
 typedef struct {
@@ -23,6 +21,9 @@ typedef struct {
   xt_value on_fulfilled;
   xt_value on_rejected;
   xt_promise *result;
+  /* Non-NULL for an `async` coroutine waiting on this promise. Such a reaction
+   * has no handlers: running it resumes the coroutine instead. */
+  void *async;
 } xt_reaction;
 
 struct xt_promise {
@@ -87,6 +88,7 @@ static void xt_promise_gc_scan_roots(void) {
     xt_gc_mark_value(reaction->on_fulfilled);
     xt_gc_mark_value(reaction->on_rejected);
     xt_gc_mark_header((xt_header *)reaction->result);
+    if (reaction->async) xt_gc_mark_header((xt_header *)reaction->async);
   }
 }
 
@@ -107,6 +109,7 @@ void xt_promise_gc_trace(xt_header *header) {
     xt_gc_mark_value(reaction->on_fulfilled);
     xt_gc_mark_value(reaction->on_rejected);
     xt_gc_mark_header((xt_header *)reaction->result);
+    if (reaction->async) xt_gc_mark_header((xt_header *)reaction->async);
   }
 }
 
@@ -133,6 +136,7 @@ static void xt_promise_resolve_into(xt_promise *result, xt_value value) {
     reaction->on_fulfilled = XT_UNDEFINED;
     reaction->on_rejected = XT_UNDEFINED;
     reaction->result = result;
+    reaction->async = NULL;
     if (other->reaction_count >= other->reaction_capacity) {
       other->reaction_capacity = other->reaction_capacity == 0 ? 4 : other->reaction_capacity * 2;
       other->reactions = (xt_reaction **)realloc(other->reactions, sizeof(xt_reaction *) * other->reaction_capacity);
@@ -156,6 +160,16 @@ static xt_value xt_promise_run_reactions(void) {
   while (xt_microtask_head < xt_microtask_count) {
     xt_reaction *reaction = xt_microtasks[xt_microtask_head++];
     xt_promise *promise = reaction->promise;
+    if (reaction->async) {
+      /* A suspended `async` coroutine: resume it with the settled value. It
+       * runs until it completes or awaits another pending promise. */
+      void *async = reaction->async;
+      int rejected = promise->state == XT_PROMISE_REJECTED;
+      xt_value settled = promise->value;
+      free(reaction);
+      xt_async_wake(async, settled, rejected);
+      continue;
+    }
     xt_value handler = promise->state == XT_PROMISE_FULFILLED ? reaction->on_fulfilled : reaction->on_rejected;
     if (XT_IS_FUNCTION(handler)) {
       xt_value arg = promise->value;
@@ -181,16 +195,46 @@ void xt_drain_microtasks(void) {
   }
 }
 
-xt_value xt_await(xt_value value) {
+/* -- helpers used by the async coroutine runtime -------------------------- */
+
+xt_value xt_promise_create(void) { return xt_promise_value(xt_promise_new()); }
+
+void xt_promise_fulfill(xt_value promise, xt_value value) {
+  xt_promise *target = xt_as_promise(promise);
+  if (target) xt_promise_resolve_into(target, value);
+}
+
+void xt_promise_reject_value(xt_value promise, xt_value value) {
+  xt_promise *target = xt_as_promise(promise);
+  if (target) xt_promise_settle(target, XT_PROMISE_REJECTED, value);
+}
+
+int xt_promise_state_of(xt_value value) {
   xt_promise *promise = xt_as_promise(value);
-  if (!promise) return value;
-  int guard = 0;
-  while (promise->state == XT_PROMISE_PENDING && guard++ < 100000) xt_drain_microtasks();
-  if (promise->state == XT_PROMISE_REJECTED) {
-    xt_throw(promise->value);
-    return XT_UNDEFINED;
+  return promise ? promise->state : -1;
+}
+
+xt_value xt_promise_value_of(xt_value value) {
+  xt_promise *promise = xt_as_promise(value);
+  return promise ? promise->value : value;
+}
+
+void xt_promise_add_async_waiter(xt_value promiseValue, void *async) {
+  xt_promise *promise = xt_as_promise(promiseValue);
+  if (!promise || promise->state != XT_PROMISE_PENDING) return;
+  xt_reaction *reaction = (xt_reaction *)malloc(sizeof(xt_reaction));
+  if (!reaction) abort();
+  reaction->promise = promise;
+  reaction->on_fulfilled = XT_UNDEFINED;
+  reaction->on_rejected = XT_UNDEFINED;
+  reaction->result = NULL;
+  reaction->async = async;
+  if (promise->reaction_count >= promise->reaction_capacity) {
+    promise->reaction_capacity = promise->reaction_capacity == 0 ? 4 : promise->reaction_capacity * 2;
+    promise->reactions = (xt_reaction **)realloc(promise->reactions, sizeof(xt_reaction *) * promise->reaction_capacity);
+    if (!promise->reactions) abort();
   }
-  return promise->value;
+  promise->reactions[promise->reaction_count++] = reaction;
 }
 
 /* -- C-callable resolve / reject ------------------------------------------ */
@@ -316,6 +360,7 @@ xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt
     reaction->on_fulfilled = xt_arg_at(argc, argv, 0);
     reaction->on_rejected = xt_arg_at(argc, argv, 1);
     reaction->result = result;
+    reaction->async = NULL;
     if (promise->state == XT_PROMISE_PENDING) {
       if (promise->reaction_count >= promise->reaction_capacity) {
         promise->reaction_capacity = promise->reaction_capacity == 0 ? 4 : promise->reaction_capacity * 2;

package/runtime/xt_stdlib/arrays.inc

@@ -47,11 +47,11 @@ static xt_value xt_array_join(xt_value value, xt_value separator) {
   if (!out) abort();
   out[0] = '\0';
   for (uint32_t i = 0; i < array->length; i++) {
-    if (i > 0) xt_buffer_append(&out, &length, &capacity, sep->data, sep->length);
+    if (i > 0) xt_buffer_append(&out, &length, &capacity, xt_string_bytes(sep), sep->length);
     xt_value item = array->items[i];
     if (item == XT_UNDEFINED || item == XT_NULL) continue;
     xt_string *str = xt_as_string(xt_to_string(item));
-    xt_buffer_append(&out, &length, &capacity, str->data, str->length);
+    xt_buffer_append(&out, &length, &capacity, xt_string_bytes(str), str->length);
   }
   xt_value result = xt_string_new(out, length);
   free(out);

package/runtime/xt_stdlib/dispatch.inc

@@ -40,6 +40,7 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   *handled = 1;
   if (strcmp(method, "charAt") == 0) return xt_string_char_at(target, xt_arg_at(argc, argv, 0));
   if (strcmp(method, "charCodeAt") == 0) return xt_string_char_code_at(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "codePointAt") == 0) return xt_string_code_point_at_value(target, xt_arg_at(argc, argv, 0));
   if (strcmp(method, "indexOf") == 0) return xt_string_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "includes") == 0) return xt_bool(xt_truthy(xt_ne(xt_string_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1)), xt_number(-1))));
   if (strcmp(method, "slice") == 0) return xt_string_slice(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
@@ -51,8 +52,8 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   if (strcmp(method, "trim") == 0) return xt_string_trim(target);
   if (strcmp(method, "replace") == 0) return xt_string_replace(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "repeat") == 0) return xt_string_repeat(target, xt_arg_at(argc, argv, 0));
-  if (strcmp(method, "startsWith") == 0) return xt_string_starts_with(target, xt_arg_at(argc, argv, 0));
-  if (strcmp(method, "endsWith") == 0) return xt_string_ends_with(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "startsWith") == 0) return xt_string_starts_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  if (strcmp(method, "endsWith") == 0) return xt_string_ends_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "concat") == 0) return xt_string_concat_args(target, argc, argv);
   *handled = 0;
   return XT_UNDEFINED;
@@ -286,11 +287,19 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     if (kind != XT_OBJECT_KIND_OBJECT && kind != XT_OBJECT_KIND_FUNCTION) {
       xt_value result = xt_ext_container_method(target, method, argc, argv, &handled);
       if (handled) return result;
+      /* Containers keep their methods in dedicated C dispatch tables, but
+       * still inherit `Object.prototype` (`new Map().toString()`). */
+      xt_value inherited = xt_get(target, name);
+      if (XT_IS_FUNCTION(inherited)) return xt_call_with_this(inherited, target, argc, argv);
     }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
     xt_value result = xt_ext_object_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    /* Inherited Object.prototype methods on containers without a property bag
+     * (`new Map().toString()`, ...). */
+    xt_value inherited = xt_get(target, name);
+    if (XT_IS_FUNCTION(inherited)) return xt_call_with_this(inherited, target, argc, argv);
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: object has no callable method '%s'", method);
@@ -322,7 +331,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
       /* Bound functions report `name` as "bound <target>" and reduce `length`
        * by the number of pre-bound arguments, like the specification. */
       xt_function *targetFn = (xt_function *)XT_GET_PTR(target);
-      const char *base = targetFn->name ? targetFn->name->data : "";
+      const char *base = targetFn->name ? xt_string_bytes(targetFn->name) : "";
       char boundName[256];
       snprintf(boundName, sizeof(boundName), "bound %s", base);
       int32_t prebound = argc > 1 ? argc - 1 : 0;
@@ -333,10 +342,17 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
+    /* Statics of a first-class built-in constructor (`const A = Array;
+     * A.isArray(x)`). */
+    xt_value builtinStatic = xt_builtin_static_value(target, name);
+    if (builtinStatic != XT_UNDEFINED) {
+      if (XT_IS_FUNCTION(builtinStatic)) return xt_call_with_this(builtinStatic, target, argc, argv);
+      return builtinStatic;
+    }
     if (strcmp(method, "toString") == 0) {
       /* Source text is not retained; report a native-style representation. */
       xt_function *self = (xt_function *)XT_GET_PTR(target);
-      const char *selfName = self->name ? self->name->data : "";
+      const char *selfName = self->name ? xt_string_bytes(self->name) : "";
       char buffer[256];
       snprintf(buffer, sizeof(buffer), "function %s() { [native code] }", selfName);
       return xt_string_from_cstr(buffer);

package/runtime/xt_stdlib/strings.inc

@@ -1,53 +1,79 @@
 /* -- string methods ------------------------------------------------------- */
 
+/* Byte-level search. `from` is a byte offset; returns a byte offset or -1. */
 static int32_t xt_string_find(xt_string *haystack, xt_string *needle, int32_t from) {
   if (from < 0) from = 0;
   if ((uint32_t)from > haystack->length) return -1;
   if (needle->length == 0) return from;
+  const char *hay = xt_string_bytes(haystack);
+  const char *need = xt_string_bytes(needle);
   for (uint32_t i = (uint32_t)from; i + needle->length <= haystack->length; i++) {
-    if (memcmp(haystack->data + i, needle->data, needle->length) == 0) return (int32_t)i;
+    if (memcmp(hay + i, need, needle->length) == 0) return (int32_t)i;
   }
   return -1;
 }
 
+/* JavaScript indexes strings in UTF-16 code units; the byte search above is
+ * still correct because every JS index maps to a code-point boundary. */
 static xt_value xt_string_char_at(xt_value value, xt_value indexValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
   int32_t index = xt_to_int32(indexValue);
-  if (index < 0 || (uint32_t)index >= s->length) return xt_string_from_cstr("");
-  return xt_string_new(s->data + index, 1);
+  if (index < 0 || (uint32_t)index >= xt_string_utf16_length(s)) return xt_string_from_cstr("");
+  return xt_string_unit_value(s, index);
 }
 
 static xt_value xt_string_char_code_at(xt_value value, xt_value indexValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_number(NAN);
   int32_t index = xt_to_int32(indexValue);
-  if (index < 0 || (uint32_t)index >= s->length) return xt_number(NAN);
-  return xt_number((double)(unsigned char)s->data[index]);
+  int32_t unit = xt_string_code_unit(s, index);
+  if (unit < 0) return xt_number(NAN);
+  return xt_number((double)unit);
+}
+
+static xt_value xt_string_code_point_at_value(xt_value value, xt_value indexValue) {
+  xt_string *s = xt_as_string(value);
+  if (!s) return XT_UNDEFINED;
+  int32_t index = xt_to_int32(indexValue);
+  int32_t code = xt_string_code_point_at(s, index);
+  if (code < 0) return XT_UNDEFINED;
+  return xt_number((double)code);
 }
 
 static xt_value xt_string_index_of(xt_value value, xt_value needleValue, xt_value fromValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_number(-1);
   xt_string *needle = xt_as_string(xt_to_string(needleValue));
+  int32_t units = (int32_t)xt_string_utf16_length(s);
   int32_t from = fromValue == XT_UNDEFINED ? 0 : xt_to_int32(fromValue);
-  return xt_number((double)xt_string_find(s, needle, from));
+  if (from < 0) from = 0;
+  if (from > units) from = units;
+  /* A start position inside a surrogate pair leaves a lone low half; slice the
+   * tail so a search for the whole pair correctly fails. */
+  if (!xt_string_is_boundary(s, from)) {
+    xt_string *tail = xt_as_string(xt_string_slice_units(s, from, units));
+    int32_t at = xt_string_find(tail, needle, 0);
+    return xt_number(at < 0 ? -1.0 : (double)(from + xt_string_unit_offset(tail, at)));
+  }
+  int32_t at = xt_string_find(s, needle, xt_string_byte_offset(s, from));
+  return xt_number(at < 0 ? -1.0 : (double)xt_string_unit_offset(s, at));
 }
 
 static xt_value xt_string_slice(xt_value value, xt_value startValue, xt_value endValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
-  int32_t len = (int32_t)s->length;
+  int32_t len = (int32_t)xt_string_utf16_length(s);
   int32_t start = startValue == XT_UNDEFINED ? 0 : xt_to_int32(startValue);
   int32_t end = endValue == XT_UNDEFINED ? len : xt_to_int32(endValue);
   xt_normalize_slice(len, &start, &end);
-  return xt_string_new(s->data + start, (size_t)(end - start));
+  return xt_string_slice_units(s, start, end);
 }
 
 static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_value endValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
-  int32_t len = (int32_t)s->length;
+  int32_t len = (int32_t)xt_string_utf16_length(s);
   int32_t start = startValue == XT_UNDEFINED ? 0 : xt_to_int32(startValue);
   int32_t end = endValue == XT_UNDEFINED ? len : xt_to_int32(endValue);
   if (start < 0) start = 0;
@@ -59,13 +85,13 @@ static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_valu
     start = end;
     end = swap;
   }
-  return xt_string_new(s->data + start, (size_t)(end - start));
+  return xt_string_slice_units(s, start, end);
 }
 
 static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value lengthValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
-  int32_t len = (int32_t)s->length;
+  int32_t len = (int32_t)xt_string_utf16_length(s);
   int32_t start = startValue == XT_UNDEFINED ? 0 : xt_to_int32(startValue);
   if (start < 0) start += len;
   if (start < 0) start = 0;
@@ -73,7 +99,7 @@ static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value l
   int32_t length = lengthValue == XT_UNDEFINED ? len - start : xt_to_int32(lengthValue);
   if (length < 0) length = 0;
   if (start + length > len) length = len - start;
-  return xt_string_new(s->data + start, (size_t)length);
+  return xt_string_slice_units(s, start, start + length);
 }
 
 static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_value limitValue) {
@@ -87,21 +113,26 @@ static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_valu
     return result;
   }
   xt_string *sep = xt_as_string(xt_to_string(separatorValue));
+  const char *bytes = xt_string_bytes(s);
+  const char *sepBytes = xt_string_bytes(sep);
   if (sep->length == 0) {
-    for (uint32_t i = 0; i < s->length; i++) xt_array_push(result, xt_string_new(s->data + i, 1));
+    /* Splitting on the empty string yields one string per UTF-16 code unit,
+     * so an emoji becomes its two surrogate halves. */
+    int32_t units = (int32_t)xt_string_utf16_length(s);
+    for (int32_t i = 0; i < units; i++) xt_array_push(result, xt_string_unit_value(s, i));
   } else {
     uint32_t start = 0;
     uint32_t i = 0;
     while (i + sep->length <= s->length) {
-      if (memcmp(s->data + i, sep->data, sep->length) == 0) {
-        xt_array_push(result, xt_string_new(s->data + start, i - start));
+      if (memcmp(bytes + i, sepBytes, sep->length) == 0) {
+        xt_array_push(result, xt_string_new(bytes + start, i - start));
         i += sep->length;
         start = i;
       } else {
         i++;
       }
     }
-    xt_array_push(result, xt_string_new(s->data + start, s->length - start));
+    xt_array_push(result, xt_string_new(bytes + start, s->length - start));
   }
   xt_array *array = xt_as_array(result);
   if ((int64_t)array->length > limit) array->length = (uint32_t)limit;
@@ -112,21 +143,25 @@ static xt_value xt_string_case(xt_value value, int upper) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   xt_string *out = xt_string_alloc(s->length);
+  const char *bytes = xt_string_bytes(s);
+  char *mutable = xt_string_mutable(out);
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
-    out->data[i] = (char)(upper ? toupper((int)c) : tolower((int)c));
+    unsigned char c = (unsigned char)bytes[i];
+    mutable[i] = (char)(upper ? toupper((int)c) : tolower((int)c));
   }
+  xt_string_finish(out);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
 static xt_value xt_string_trim(xt_value value) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
+  const char *bytes = xt_string_bytes(s);
   uint32_t start = 0;
   uint32_t end = s->length;
-  while (start < end && isspace((unsigned char)s->data[start])) start++;
-  while (end > start && isspace((unsigned char)s->data[end - 1])) end--;
-  return xt_string_new(s->data + start, end - start);
+  while (start < end && isspace((unsigned char)bytes[start])) start++;
+  while (end > start && isspace((unsigned char)bytes[end - 1])) end--;
+  return xt_string_new(bytes + start, end - start);
 }
 
 static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value replacementValue) {
@@ -137,12 +172,16 @@ static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value
   xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
   int32_t at = xt_string_find(s, search, 0);
   if (at < 0) return value;
+  const char *text = xt_string_bytes(s);
+  const char *repl = xt_string_bytes(replacement);
   size_t total = s->length - search->length + replacement->length;
   xt_string *out = xt_string_alloc(total);
-  memcpy(out->data, s->data, (size_t)at);
-  memcpy(out->data + at, replacement->data, replacement->length);
-  memcpy(out->data + at + replacement->length, s->data + at + search->length,
+  char *mutable = xt_string_mutable(out);
+  memcpy(mutable, text, (size_t)at);
+  memcpy(mutable + at, repl, replacement->length);
+  memcpy(mutable + at + replacement->length, text + at + search->length,
          s->length - (size_t)at - search->length);
+  xt_string_finish(out);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
@@ -155,24 +194,54 @@ static xt_value xt_string_repeat(xt_value value, xt_value countValue) {
     return XT_UNDEFINED;
   }
   xt_string *out = xt_string_alloc((size_t)s->length * (size_t)count);
-  for (int32_t i = 0; i < count; i++) memcpy(out->data + (size_t)i * s->length, s->data, s->length);
+  const char *bytes = xt_string_bytes(s);
+  char *mutable = xt_string_mutable(out);
+  for (int32_t i = 0; i < count; i++) memcpy(mutable + (size_t)i * s->length, bytes, s->length);
+  xt_string_finish(out);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
-static xt_value xt_string_starts_with(xt_value value, xt_value searchValue) {
+static xt_value xt_string_starts_with(xt_value value, xt_value searchValue, xt_value positionValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
+  const char *sBytes = xt_string_bytes(s);
+  const char *searchBytes = xt_string_bytes(search);
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  int32_t position = positionValue == XT_UNDEFINED ? 0 : xt_to_int32(positionValue);
+  if (position < 0) position = 0;
+  if (position > units) position = units;
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(s->data, search->data, search->length) == 0);
+  if (!xt_string_is_boundary(s, position)) {
+    xt_string *tail = xt_as_string(xt_string_slice_units(s, position, units));
+    if (search->length > tail->length) return XT_FALSE;
+    return xt_bool(memcmp(xt_string_bytes(tail), searchBytes, search->length) == 0);
+  }
+  int32_t at = xt_string_byte_offset(s, position);
+  if ((uint32_t)at + search->length > s->length) return XT_FALSE;
+  return xt_bool(memcmp(sBytes + at, searchBytes, search->length) == 0);
 }
 
-static xt_value xt_string_ends_with(xt_value value, xt_value searchValue) {
+static xt_value xt_string_ends_with(xt_value value, xt_value searchValue, xt_value endValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
+  const char *sBytes = xt_string_bytes(s);
+  const char *searchBytes = xt_string_bytes(search);
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  int32_t end = endValue == XT_UNDEFINED ? units : xt_to_int32(endValue);
+  if (end < 0) end = 0;
+  if (end > units) end = units;
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(s->data + s->length - search->length, search->data, search->length) == 0);
+  if (!xt_string_is_boundary(s, end)) {
+    xt_string *prefix = xt_as_string(xt_string_slice_units(s, 0, end));
+    if (search->length > prefix->length) return XT_FALSE;
+    return xt_bool(memcmp(xt_string_bytes(prefix) + prefix->length - search->length,
+                          searchBytes, search->length) == 0);
+  }
+  int32_t at = xt_string_byte_offset(s, end);
+  if ((uint32_t)at < search->length) return XT_FALSE;
+  return xt_bool(memcmp(sBytes + at - search->length, searchBytes, search->length) == 0);
 }
 
 static xt_value xt_string_concat_args(xt_value value, int32_t argc, xt_value *argv) {

package/runtime/xt_stdlib2/array-statics.inc

@@ -18,8 +18,9 @@ xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv) {
       }
     } else if (XT_IS_STRING(source)) {
       xt_string *s = xt_as_string(source);
-      for (uint32_t i = 0; i < s->length; i++) {
-        xt_value item = xt_string_new(s->data + i, 1);
+      uint32_t points = xt_string_code_point_count(s);
+      for (uint32_t i = 0; i < points; i++) {
+        xt_value item = xt_string_code_point_value(s, (int32_t)i);
         if (XT_IS_FUNCTION(mapper)) { xt_value args[2] = {item, xt_number((double)i)}; item = xt_closure_call(mapper, 2, args); }
         xt_array_push(out, item);
       }

package/runtime/xt_stdlib2/arrays.inc

@@ -46,7 +46,7 @@ static int xt_array_default_compare(xt_value a, xt_value b) {
   xt_string *sa = xt_as_string(xt_to_string(a));
   xt_string *sb = xt_as_string(xt_to_string(b));
   uint32_t n = sa->length < sb->length ? sa->length : sb->length;
-  int cmp = n ? memcmp(sa->data, sb->data, n) : 0;
+  int cmp = n ? memcmp(xt_string_bytes(sa), xt_string_bytes(sb), n) : 0;
   if (cmp != 0) return cmp < 0 ? -1 : 1;
   if (sa->length == sb->length) return 0;
   return sa->length < sb->length ? -1 : 1;

package/runtime/xt_stdlib2/error.inc

@@ -26,6 +26,8 @@ static xt_value xt_error_proto_for(const char *name) {
                   xt_string_from_cstr("Error"));
     xt_object_set(xt_error_root_proto, xt_string_from_cstr("message"),
                   xt_string_from_cstr(""));
+    xt_value constructor = xt_error_constructor(xt_string_from_cstr("Error"));
+    xt_object_set(xt_error_root_proto, xt_string_from_cstr("constructor"), constructor);
   }
   if (strcmp(name, "Error") == 0) return xt_error_root_proto;
   xt_value key = xt_string_from_cstr(name);
@@ -41,6 +43,8 @@ static xt_value xt_error_proto_for(const char *name) {
   xt_object_set(proto, xt_string_from_cstr("name"), key);
   xt_object_set(proto, xt_string_from_cstr("message"), xt_string_from_cstr(""));
   xt_object_set(registry, key, proto);
+  xt_value constructor = xt_error_constructor(key);
+  xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
   return proto;
 }
 
@@ -50,6 +54,15 @@ xt_value xt_error_prototype(xt_value nameValue) {
   return xt_error_proto_for(name);
 }
 
+/* Capture `Error.stack` into the object's private field (not a property, so it
+ * stays out of Object.keys/JSON.stringify, like V8's own non-enumerable stack). */
+static void xt_error_capture_stack(xt_value error, const char *name, xt_value message) {
+  if (!XT_IS_OBJECT(error)) return;
+  xt_string *text = xt_as_string(xt_to_string(message));
+  xt_value stack = xt_stack_capture(name, text ? xt_string_bytes(text) : "");
+  ((xt_object *)XT_GET_PTR(error))->error_stack = stack;
+}
+
 static xt_value xt_make_error(const char *name, int32_t argc, xt_value *argv) {
   if (!xt_error_is_family(name)) name = "Error";
   xt_value error = xt_object_new();
@@ -64,9 +77,10 @@ static xt_value xt_make_error(const char *name, int32_t argc, xt_value *argv) {
   } else {
     message = xt_arg_at(argc, argv, 0);
   }
+  xt_value messageValue = message == XT_UNDEFINED ? xt_string_from_cstr("") : message;
   xt_object_set(error, xt_string_from_cstr("name"), xt_string_from_cstr(name));
-  xt_object_set(error, xt_string_from_cstr("message"),
-                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  xt_object_set(error, xt_string_from_cstr("message"), messageValue);
+  xt_error_capture_stack(error, name, messageValue);
   return error;
 }
 
@@ -110,10 +124,10 @@ xt_value xt_error_to_string(xt_value error) {
   if (ms->length == 0) return nameStr;
   size_t total = ns->length + 2 + ms->length;
   char *buffer = (char *)malloc(total + 1);
-  memcpy(buffer, ns->data, ns->length);
+  memcpy(buffer, xt_string_bytes(ns), ns->length);
   buffer[ns->length] = ':';
   buffer[ns->length + 1] = ' ';
-  memcpy(buffer + ns->length + 2, ms->data, ms->length);
+  memcpy(buffer + ns->length + 2, xt_string_bytes(ms), ms->length);
   buffer[total] = '\0';
   xt_value result = xt_string_new(buffer, total);
   free(buffer);
@@ -152,6 +166,13 @@ xt_value xt_aggregate_error_ctor(int32_t argc, xt_value *argv) {
   return xt_make_error("AggregateError", argc, argv);
 }
 
+/* Dispatch used by the first-class constructor factory (`const E = TypeError`). */
+xt_value xt_error_ctor_by_name(xt_value nameValue, int32_t argc, xt_value *argv) {
+  const char *name = XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : "Error";
+  if (!xt_error_is_family(name)) name = "Error";
+  return xt_make_error(name, argc, argv);
+}
+
 /* `super(message)` inside a subclass of the builtin Error family: initialize
  * the already-allocated instance instead of creating a fresh object. The
  * parent's name selects the default `name` (`TypeError`, ...). */
@@ -159,6 +180,11 @@ xt_value xt_error_init(xt_value thisValue, xt_value nameValue, int32_t argc,
                        xt_value *argv) {
   const char *name = XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : "Error";
   if (!xt_error_is_family(name)) name = "Error";
+  /* `class MyError extends Error` allocates a plain object first; mark it as an
+   * Error so `.stack` and the error-specific property access apply. */
+  if (XT_IS_OBJECT(thisValue)) {
+    ((xt_object *)XT_GET_PTR(thisValue))->header.kind = XT_OBJECT_KIND_ERROR;
+  }
   xt_object_set(thisValue, xt_string_from_cstr("name"), xt_string_from_cstr(name));
   xt_value message;
   if (strcmp(name, "AggregateError") == 0) {
@@ -167,7 +193,8 @@ xt_value xt_error_init(xt_value thisValue, xt_value nameValue, int32_t argc,
   } else {
     message = xt_arg_at(argc, argv, 0);
   }
-  xt_object_set(thisValue, xt_string_from_cstr("message"),
-                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  xt_value messageValue = message == XT_UNDEFINED ? xt_string_from_cstr("") : message;
+  xt_object_set(thisValue, xt_string_from_cstr("message"), messageValue);
+  xt_error_capture_stack(thisValue, name, messageValue);
   return thisValue;
 }