xbintsc 0.3.79 → 0.3.87

package/runtime/xt_io/exception.inc

@@ -14,6 +14,162 @@ static xt_try_frame *g_try_top = NULL;
 int32_t xt_program_argc = 0;
 char **xt_program_argv = NULL;
 
+/* ------------------------------------------------------------------------- */
+/* Shadow call stack                                                         */
+/* ------------------------------------------------------------------------- */
+
+/*
+ * Compiled functions push one frame on entry and pop it before returning, so
+ * `Error` can capture a JavaScript-level stack without any debug metadata.
+ * Generator bodies are not tracked (they switch stacks and can be suspended
+ * indefinitely); a normal function called from a generator is tracked normally.
+ *
+ * `name`/`file` point into the module's static string constants; the runtime
+ * never frees them. The depth is trimmed when a `try` frame is left, so frames
+ * from calls unwound by a throw cannot leak into a later stack.
+ */
+#define XT_STACK_MAX_DEPTH 256
+
+typedef struct {
+  const char *name;
+  const char *file;
+  int32_t line;
+} xt_stack_entry;
+
+static xt_stack_entry g_stack[XT_STACK_MAX_DEPTH];
+static int32_t g_stack_depth = 0;
+
+void xt_stack_push(const char *name, const char *file, int32_t line) {
+  if (g_stack_depth >= XT_STACK_MAX_DEPTH) return;
+  xt_stack_entry *entry = &g_stack[g_stack_depth++];
+  entry->name = name;
+  entry->file = file;
+  entry->line = line;
+}
+
+void xt_stack_pop(void) {
+  if (g_stack_depth > 0) g_stack_depth--;
+}
+
+int32_t xt_stack_depth(void) { return g_stack_depth; }
+
+void xt_stack_set_line(int32_t line) {
+  /* Called just before an `Error` is constructed, so the innermost frame
+   * reports the construction line rather than the function's declaration. */
+  if (g_stack_depth > 0) g_stack[g_stack_depth - 1].line = line;
+}
+
+void xt_stack_trim(int32_t depth) {
+  if (depth < 0) depth = 0;
+  if (depth < g_stack_depth) g_stack_depth = depth;
+}
+
+static void xt_stack_append(char **buffer, size_t *length, size_t *capacity, const char *text) {
+  size_t count = strlen(text);
+  if (*length + count + 1 > *capacity) {
+    size_t next = *capacity ? *capacity : 256;
+    while (next < *length + count + 1) next *= 2;
+    char *grown = (char *)realloc(*buffer, next);
+    if (!grown) return;
+    *buffer = grown;
+    *capacity = next;
+  }
+  memcpy(*buffer + *length, text, count);
+  *length += count;
+  (*buffer)[*length] = 0;
+}
+
+xt_value xt_stack_capture(const char *name, const char *message) {
+  const char *header = name && name[0] ? name : "Error";
+  char *buffer = NULL;
+  size_t length = 0;
+  size_t capacity = 0;
+  xt_stack_append(&buffer, &length, &capacity, header);
+  if (message && message[0]) {
+    xt_stack_append(&buffer, &length, &capacity, ": ");
+    xt_stack_append(&buffer, &length, &capacity, message);
+  }
+  xt_stack_append(&buffer, &length, &capacity, "\n");
+  for (int32_t index = g_stack_depth - 1; index >= 0; index--) {
+    const xt_stack_entry *entry = &g_stack[index];
+    char line[24];
+    xt_stack_append(&buffer, &length, &capacity, "    at ");
+    xt_stack_append(&buffer, &length, &capacity, entry->name && entry->name[0] ? entry->name : "anonymous");
+    xt_stack_append(&buffer, &length, &capacity, " (");
+    xt_stack_append(&buffer, &length, &capacity, entry->file && entry->file[0] ? entry->file : "<anonymous>");
+    if (entry->line > 0) {
+      snprintf(line, sizeof(line), ":%d", (int)entry->line);
+      xt_stack_append(&buffer, &length, &capacity, line);
+    }
+    xt_stack_append(&buffer, &length, &capacity, ")\n");
+  }
+  xt_value result = xt_string_new(buffer ? buffer : "", length);
+  free(buffer);
+  return result;
+}
+
+xt_value xt_error_stack(xt_value error) {
+  if (!XT_IS_OBJECT(error)) return XT_UNDEFINED;
+  xt_object *object = (xt_object *)XT_GET_PTR(error);
+  if (object->header.kind != XT_OBJECT_KIND_ERROR) return XT_UNDEFINED;
+  return object->error_stack;
+}
+
+/* ------------------------------------------------------------------------- */
+/* Fatal-signal diagnostics                                                  */
+/* ------------------------------------------------------------------------- */
+
+static char g_crash_report[16384];
+
+static int xt_format_stack(char *out, size_t size) {
+  int written = 0;
+  for (int32_t index = g_stack_depth - 1; index >= 0 && written < (int)size; index--) {
+    const xt_stack_entry *entry = &g_stack[index];
+    int count = snprintf(out + written, size - (size_t)written, "    at %s (%s:%d)\n",
+                         entry->name && entry->name[0] ? entry->name : "anonymous",
+                         entry->file && entry->file[0] ? entry->file : "<anonymous>", (int)entry->line);
+    if (count < 0) break;
+    written += count;
+  }
+  return written < (int)size ? written : (int)size - 1;
+}
+
+#if defined(_WIN32)
+
+static LONG WINAPI xt_fatal_exception(EXCEPTION_POINTERS *info) {
+  unsigned long code =
+      info && info->ExceptionRecord ? (unsigned long)info->ExceptionRecord->ExceptionCode : 0UL;
+  int written = snprintf(g_crash_report, sizeof(g_crash_report), "\nxbintsc: fatal exception 0x%08lx\n", code);
+  written += xt_format_stack(g_crash_report + written, sizeof(g_crash_report) - (size_t)written);
+  _write(2, g_crash_report, (unsigned int)written);
+  _exit(1);
+  return EXCEPTION_EXECUTE_HANDLER;
+}
+
+void xt_install_crash_handler(void) { SetUnhandledExceptionFilter(xt_fatal_exception); }
+
+#else
+
+static void xt_fatal_signal(int sig) {
+  int written = snprintf(g_crash_report, sizeof(g_crash_report), "\nxbintsc: fatal signal %d\n", sig);
+  written += xt_format_stack(g_crash_report + written, sizeof(g_crash_report) - (size_t)written);
+  ssize_t ignored = write(STDERR_FILENO, g_crash_report, (size_t)written);
+  (void)ignored;
+  _exit(128 + sig);
+}
+
+void xt_install_crash_handler(void) {
+  signal(SIGSEGV, xt_fatal_signal);
+  signal(SIGABRT, xt_fatal_signal);
+  signal(SIGFPE, xt_fatal_signal);
+  signal(SIGBUS, xt_fatal_signal);
+#ifdef SIGILL
+  signal(SIGILL, xt_fatal_signal);
+#endif
+}
+
+#endif
+
 #if defined(_WIN32)
 /*
  * The UCRT validates its low-level I/O arguments and, when one is out of
@@ -107,18 +263,23 @@ void *xt_try_enter(void) {
   if (!frame) abort();
   frame->prev = g_try_top;
   frame->exception = XT_UNDEFINED;
+  frame->stack_depth = g_stack_depth;
   g_try_top = frame;
   return (void *)frame;
 }
 
 xt_value xt_try_exception(void *framePtr) {
   xt_try_frame *frame = (xt_try_frame *)framePtr;
-  return frame ? frame->exception : XT_UNDEFINED;
+  if (!frame) return XT_UNDEFINED;
+  /* A throw longjmps past the calls it unwinds; drop their shadow frames. */
+  xt_stack_trim(frame->stack_depth);
+  return frame->exception;
 }
 
 void xt_try_leave(void *framePtr) {
   xt_try_frame *frame = (xt_try_frame *)framePtr;
   if (frame && g_try_top == frame) {
+    xt_stack_trim(frame->stack_depth);
     g_try_top = frame->prev;
     free(frame);
   }
@@ -135,8 +296,16 @@ void xt_throw(xt_value v) {
     g_try_top->exception = v;
     longjmp(g_try_top->buf, 1);
   }
+  xt_value stack = xt_error_stack(v);
+  if (stack != XT_UNDEFINED) {
+    xt_string *text = xt_as_string(stack);
+    if (text) {
+      fprintf(stderr, "Uncaught %s\n", xt_string_bytes(text));
+      exit(1);
+    }
+  }
   xt_value message = xt_to_string(v);
   xt_string *s = xt_as_string(message);
-  fprintf(stderr, "Uncaught %s\n", s->data);
+  fprintf(stderr, "Uncaught %s\n", xt_string_bytes(s));
   exit(1);
 }

package/runtime/xt_io/inspect.inc

@@ -5,12 +5,12 @@
 static void xt_print_value(xt_value v, FILE *out) {
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    fwrite(s->data, 1, s->length, out);
+    fwrite(xt_string_bytes(s), 1, s->length, out);
     return;
   }
   xt_value text = xt_to_string(v);
   xt_string *s = xt_as_string(text);
-  fwrite(s->data, 1, s->length, out);
+  fwrite(xt_string_bytes(s), 1, s->length, out);
 }
 
 void xt_print(xt_value v) { xt_print_value(v, stdout); }
@@ -48,10 +48,11 @@ static void xt_inspect_pop(void) {
 
 static int xt_inspect_identifier_key(xt_string *key) {
   if (key->length == 0) return 0;
-  char c = key->data[0];
+  const char *bytes = xt_string_bytes(key);
+  char c = bytes[0];
   if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$')) return 0;
   for (uint32_t i = 1; i < key->length; i++) {
-    c = key->data[i];
+    c = bytes[i];
     if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '$')) return 0;
   }
   return 1;
@@ -60,16 +61,17 @@ static int xt_inspect_identifier_key(xt_string *key) {
 /* Render a string the way `util.inspect` does inside a container: quoted,
  * preferring whichever quote character needs fewer escapes. */
 static void xt_inspect_string(xt_string *s, FILE *out) {
+  const char *bytes = xt_string_bytes(s);
   int hasSingle = 0;
   int hasDouble = 0;
   for (uint32_t i = 0; i < s->length; i++) {
-    if (s->data[i] == '\'') hasSingle = 1;
-    else if (s->data[i] == '"') hasDouble = 1;
+    if (bytes[i] == '\'') hasSingle = 1;
+    else if (bytes[i] == '"') hasDouble = 1;
   }
   char quote = (hasSingle && !hasDouble) ? '"' : '\'';
   fputc(quote, out);
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     switch (c) {
       case '\\': fputs("\\\\", out); break;
       case '\n': fputs("\\n", out); break;
@@ -90,13 +92,13 @@ static void xt_inspect_string(xt_string *s, FILE *out) {
 static void xt_inspect(xt_value v, FILE *out, int nested) {
   if (xt_is_symbol(v)) {
     xt_string *text = xt_as_string(xt_symbol_to_string(v));
-    fwrite(text->data, 1, text->length, out);
+    fwrite(xt_string_bytes(text), 1, text->length, out);
     return;
   }
   if (XT_IS_BIGINT(v)) {
     xt_value text = xt_bigint_to_decimal(v);
     xt_string *s = xt_as_string(text);
-    fwrite(s->data, 1, s->length, out);
+    fwrite(xt_string_bytes(s), 1, s->length, out);
     fputc('n', out);
     return;
   }
@@ -130,10 +132,10 @@ static void xt_inspect(xt_value v, FILE *out, int nested) {
         xt_value key = extra->properties[i].key;
         if (xt_is_symbol(key)) {
           xt_string *text = xt_as_string(xt_symbol_to_string(key));
-          fwrite(text->data, 1, text->length, out);
+          fwrite(xt_string_bytes(text), 1, text->length, out);
         } else {
           xt_string *keyString = xt_as_string(key);
-          fwrite(keyString->data, 1, keyString->length, out);
+          fwrite(xt_string_bytes(keyString), 1, keyString->length, out);
         }
         fputs(": ", out);
         xt_inspect(extra->properties[i].value, out, 1);
@@ -170,10 +172,10 @@ static void xt_inspect(xt_value v, FILE *out, int nested) {
         written++;
         if (isSymbol) {
           xt_string *text = xt_as_string(xt_symbol_to_string(key));
-          fwrite(text->data, 1, text->length, out);
+          fwrite(xt_string_bytes(text), 1, text->length, out);
         } else {
           xt_string *keyString = xt_as_string(key);
-          if (xt_inspect_identifier_key(keyString)) fwrite(keyString->data, 1, keyString->length, out);
+          if (xt_inspect_identifier_key(keyString)) fwrite(xt_string_bytes(keyString), 1, keyString->length, out);
           else xt_inspect_string(keyString, out);
         }
         fputs(": ", out);

package/runtime/xt_io.c

@@ -37,7 +37,12 @@
 #if defined(_WIN32)
 #include <fcntl.h>
 #include <io.h>
+#include <process.h>
 #include <winsock2.h>
+#include <windows.h>
+#else
+#include <signal.h>
+#include <unistd.h>
 #endif
 
 #include "xt_io/exception.inc"

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

@@ -322,7 +322,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;
@@ -336,7 +336,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     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

@@ -4,8 +4,10 @@ static int32_t xt_string_find(xt_string *haystack, xt_string *needle, int32_t fr
   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;
 }
@@ -15,7 +17,7 @@ static xt_value xt_string_char_at(xt_value value, xt_value indexValue) {
   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);
+  return xt_string_new(xt_string_bytes(s) + index, 1);
 }
 
 static xt_value xt_string_char_code_at(xt_value value, xt_value indexValue) {
@@ -23,7 +25,7 @@ static xt_value xt_string_char_code_at(xt_value value, xt_value indexValue) {
   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]);
+  return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
 }
 
 static xt_value xt_string_index_of(xt_value value, xt_value needleValue, xt_value fromValue) {
@@ -41,7 +43,7 @@ static xt_value xt_string_slice(xt_value value, xt_value startValue, xt_value en
   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_new(xt_string_bytes(s) + start, (size_t)(end - start));
 }
 
 static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_value endValue) {
@@ -59,7 +61,7 @@ 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_new(xt_string_bytes(s) + start, (size_t)(end - start));
 }
 
 static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value lengthValue) {
@@ -73,7 +75,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_new(xt_string_bytes(s) + start, (size_t)length);
 }
 
 static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_value limitValue) {
@@ -87,21 +89,23 @@ 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));
+    for (uint32_t i = 0; i < s->length; i++) xt_array_push(result, xt_string_new(bytes + i, 1));
   } 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,9 +116,11 @@ 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));
   }
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
@@ -122,11 +128,12 @@ static xt_value xt_string_case(xt_value value, int upper) {
 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,11 +144,14 @@ 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);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
@@ -155,7 +165,9 @@ 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);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
@@ -164,7 +176,7 @@ static xt_value xt_string_starts_with(xt_value value, xt_value searchValue) {
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(s->data, search->data, search->length) == 0);
+  return xt_bool(memcmp(xt_string_bytes(s), xt_string_bytes(search), search->length) == 0);
 }
 
 static xt_value xt_string_ends_with(xt_value value, xt_value searchValue) {
@@ -172,7 +184,7 @@ static xt_value xt_string_ends_with(xt_value value, xt_value searchValue) {
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(s->data + s->length - search->length, search->data, search->length) == 0);
+  return xt_bool(memcmp(xt_string_bytes(s) + s->length - search->length, xt_string_bytes(search), 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);
+      const char *bytes = xt_string_bytes(s);
       for (uint32_t i = 0; i < s->length; i++) {
-        xt_value item = xt_string_new(s->data + i, 1);
+        xt_value item = xt_string_new(bytes + i, 1);
         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

@@ -50,6 +50,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 +73,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 +120,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);
@@ -159,6 +169,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 +182,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;
 }

package/runtime/xt_stdlib2/json.inc

@@ -120,7 +120,7 @@ xt_value xt_json_parse(int32_t argc, xt_value *argv) {
   xt_value input = xt_to_string(xt_arg_at(argc, argv, 0));
   xt_string *s = xt_as_string(input);
   if (!s) return XT_UNDEFINED;
-  xt_json_cursor cursor = {s->data, s->length, 0};
+  xt_json_cursor cursor = {xt_string_bytes(s), s->length, 0};
   return xt_json_parse_value(&cursor);
 }
 
@@ -193,9 +193,10 @@ static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_va
   }
   if (XT_IS_STRING(value)) {
     xt_string *s = xt_as_string(value);
+    const char *bytes = xt_string_bytes(s);
     *out = xt_add(*out, xt_string_from_cstr("\""));
     for (uint32_t i = 0; i < s->length; i++) {
-      char ch = s->data[i];
+      char ch = bytes[i];
       if (ch == '"') *out = xt_add(*out, xt_string_from_cstr("\\\""));
       else if (ch == '\\') *out = xt_add(*out, xt_string_from_cstr("\\\\"));
       else if (ch == '\n') *out = xt_add(*out, xt_string_from_cstr("\\n"));

package/runtime/xt_stdlib2/number-string-statics.inc

@@ -43,6 +43,7 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
   if (!fn) return XT_UNDEFINED;
   if (strcmp(fn, "fromCharCode") == 0 || strcmp(fn, "fromCodePoint") == 0) {
     xt_string *out = xt_string_alloc((size_t)argc * 4 + 1);
+    char *mutable = xt_string_mutable(out);
     size_t length = 0;
     for (int32_t i = 0; i < argc; i++) {
       unsigned code = (unsigned)xt_to_int32(argv[i]);
@@ -52,9 +53,10 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
       else if (code < 0x800) { buffer[bytes++] = (char)(0xC0 | (code >> 6)); buffer[bytes++] = (char)(0x80 | (code & 0x3F)); }
       else if (code < 0x10000) { buffer[bytes++] = (char)(0xE0 | (code >> 12)); buffer[bytes++] = (char)(0x80 | ((code >> 6) & 0x3F)); buffer[bytes++] = (char)(0x80 | (code & 0x3F)); }
       else { buffer[bytes++] = (char)(0xF0 | (code >> 18)); buffer[bytes++] = (char)(0x80 | ((code >> 12) & 0x3F)); buffer[bytes++] = (char)(0x80 | ((code >> 6) & 0x3F)); buffer[bytes++] = (char)(0x80 | (code & 0x3F)); }
-      memcpy(out->data + length, buffer, (size_t)bytes);
+      memcpy(mutable + length, buffer, (size_t)bytes);
       length += (size_t)bytes;
     }
+    mutable[length] = '\0';
     out->length = (uint32_t)length;
     return XT_FROM_PTR(XT_TAG_STRING, out);
   }