xbintsc 0.3.79 → 0.3.87

package/runtime/ext_node/fs/fd_ops.c

@@ -76,7 +76,7 @@ static unsigned char *xt_fs_value_bytes(xt_value value, size_t *outLength) {
     *outLength = 0;
     return NULL;
   }
-  if (length > 0) memcpy(bytes, string->data, length);
+  if (length > 0) memcpy(bytes, xt_string_bytes(string), length);
   *outLength = length;
   return bytes;
 }

package/runtime/rt.h

@@ -92,7 +92,9 @@ xt_value xt_bool(int b);
 xt_value xt_number(double d);
 xt_value xt_string_new(const char *data, size_t len);
 xt_value xt_string_from_cstr(const char *data);
-/** Raw UTF-8 bytes of a string value (NULL for non-strings); not NUL-safe. */
+/** Raw UTF-8 bytes of a string value (NULL for non-strings); not NUL-safe.
+ * Materialises a lazily concatenated string, so the returned pointer is stable
+ * until the string is collected. */
 const char *xt_string_data(xt_value value);
 int32_t xt_string_length_value(xt_value value);
 
@@ -119,6 +121,8 @@ xt_value xt_function_set_metadata(xt_value fn, xt_value name, int32_t arity);
 xt_value xt_this(void);
 xt_value xt_new(xt_value ctor, int32_t argc, xt_value *argv);
 xt_value xt_instance_of(xt_value value, xt_value ctor);
+/** `value instanceof <built-in constructor>`; id from `BUILTIN_INSTANCEOF`. */
+xt_value xt_instance_of_builtin(xt_value value, int32_t id);
 xt_value xt_function_set_prototype(xt_value fn, xt_value proto);
 xt_value xt_function_get_prototype(xt_value fn);
 
@@ -177,6 +181,8 @@ xt_value xt_object_values(xt_value obj);
 xt_value xt_object_entries(xt_value obj);
 xt_value xt_object_assign(int32_t argc, xt_value *argv);
 xt_value xt_object_spread(xt_value target, xt_value source);
+/** Own enumerable properties of `source` except the keys in `argv` (object rest). */
+xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv);
 
 /* -- symbols -------------------------------------------------------------- */
 /** Implements `Symbol(description)`. */
@@ -340,6 +346,16 @@ void xt_throw(xt_value v);
 void *xt_try_enter(void);
 xt_value xt_try_exception(void *frame);
 void xt_try_leave(void *frame);
+/**
+ * JavaScript-level shadow stack. Generated code pushes `(name, file, line)` on
+ * function entry and pops before returning; `Error` construction walks it to
+ * build `.stack`, and a fatal native signal dumps it. The strings are static
+ * module data, so the runtime never owns them.
+ */
+void xt_stack_push(const char *name, const char *file, int32_t line);
+void xt_stack_pop(void);
+/** Set the innermost frame's line (called just before `new Error(...)`). */
+void xt_stack_set_line(int32_t line);
 void xt_console_log(int32_t argc, xt_value *argv);
 void xt_console_info(int32_t argc, xt_value *argv);
 void xt_console_warn(int32_t argc, xt_value *argv);

package/runtime/rt_internal.h

@@ -21,8 +21,12 @@
  *    code free of write barriers and makes the first implementation small and
  *    predictable. Replacing it with a precise/conservative collector is an
  *    isolated change behind `xt_alloc` plus root registration.
- *  * Strings are UTF-8. JavaScript measures string length in UTF-16 code
- *    units; `xt_string_length` currently reports code points (see README).
+ *  * Strings are UTF-8. Concatenation is lazy: a `+` between two non-empty
+ *    strings builds an immutable cons node (`flat == NULL`) and the bytes are
+ *    materialised once, on first observation, by `xt_string_bytes`. This keeps
+ *    `s += x` in a loop linear instead of copying the accumulated prefix every
+ *    iteration. JavaScript measures string length in UTF-16 code units;
+ *    `xt_string_length` currently reports code points (see README).
  *  * Objects use a small linear property list. Fine for the language subset
  *    xbintsc targets today; swap for a hash map when the profile demands it.
  */
@@ -64,11 +68,19 @@ typedef struct xt_header {
 
 #define XT_GC_MARK 0x01u
 
-typedef struct {
+/* A string is either *flat* (`flat` points at `capacity` bytes, the last one
+ * NUL) or a *cons* node (`flat == NULL`, `left`/`right` name the operands).
+ * `length` is always the total byte length, so `.length`, comparisons and the
+ * GC never need to force a cons node. `xt_string_bytes` turns a cons node into
+ * a flat one in place; treat the result as immutable and never write through a
+ * pointer obtained from it. */
+typedef struct xt_string {
   xt_header header;
   uint32_t length;
   uint32_t capacity;
-  char *data;
+  char *flat;
+  struct xt_string *left;
+  struct xt_string *right;
 } xt_string;
 
 /* Sign-magnitude arbitrary-precision integer; see xt_bigint.c. */
@@ -99,6 +111,10 @@ typedef struct {
   uint8_t frozen;
   uint8_t is_array_base;
   uint16_t reserved2;
+  /* Captured `Error.stack` for XT_OBJECT_KIND_ERROR, XT_UNDEFINED otherwise.
+   * Deliberately not a property: `Object.keys`, `for...in` and JSON.stringify
+   * must not see it, while `error.stack` returns it through `xt_get`. */
+  xt_value error_stack;
 } xt_object;
 
 typedef struct {
@@ -191,6 +207,12 @@ xt_string *xt_string_alloc(size_t length);
 xt_string *xt_as_string(xt_value value);
 int32_t xt_string_length(xt_string *s);
 int xt_string_equals(xt_string *a, xt_string *b);
+/* Contiguous UTF-8 bytes of a string, flattening a cons node in place on first
+ * use. The result is NUL-terminated at `s->length`; never write through it. */
+const char *xt_string_bytes(xt_string *s);
+/* Mutable bytes of a string just created with `xt_string_alloc` (never a cons
+ * node). Used by the constructors that fill a buffer before publishing it. */
+char *xt_string_mutable(xt_string *s);
 int32_t xt_to_int32(xt_value v);
 
 /* ECMAScript number formatting (xt_values.c). */
@@ -284,6 +306,10 @@ typedef struct xt_try_frame {
   jmp_buf buf;
   struct xt_try_frame *prev;
   xt_value exception;
+  /* Shadow-stack depth when the protected region was entered; restored when
+   * the region is left (normally or through a throw) so frames from unwound
+   * calls do not leak into later stack traces. */
+  int32_t stack_depth;
 } xt_try_frame;
 /* Save a try frame with clang's `_setjmp` built-in.
  *
@@ -300,6 +326,23 @@ typedef struct xt_try_frame {
 void *xt_try_mark(void);
 void xt_try_restore(void *mark);
 
+/* -- shadow call stack and diagnostics (xt_io/exception.inc) --------------- */
+/* Generated code pushes a frame on entry and pops it before returning, so an
+ * Error can capture a JavaScript-level stack without any debug metadata. Frame
+ * strings live in the module's static data and are never freed. */
+void xt_stack_push(const char *name, const char *file, int32_t line);
+void xt_stack_pop(void);
+int32_t xt_stack_depth(void);
+void xt_stack_set_line(int32_t line);
+/* Restore the depth saved by a try frame after unwinding inner calls. */
+void xt_stack_trim(int32_t depth);
+/* Format `Name: message` plus the current frames as an `Error.stack` string. */
+xt_value xt_stack_capture(const char *name, const char *message);
+/* The captured stack of an error object, or XT_UNDEFINED. */
+xt_value xt_error_stack(xt_value error);
+/* Best-effort stack dump on a fatal native signal / unhandled exception. */
+void xt_install_crash_handler(void);
+
 /* -- collection / date / regexp representations --------------------------- */
 typedef struct {
   xt_header header;

package/runtime/xt_alloc.c

@@ -210,6 +210,9 @@ void xt_gc_init(void) {
       g_gc_threshold_pinned = 1;
     }
   }
+  /* A crash is the one case where the JavaScript-level shadow stack is the
+   * most useful thing to print; install the handler once per process. */
+  xt_install_crash_handler();
 }
 
 void xt_gc_arm(void) { g_gc_armed = 1; }
@@ -328,7 +331,16 @@ static void xt_gc_process(xt_header *header) {
   const void *base = (const char *)header + sizeof(xt_header);
 
   switch (header->kind) {
-    case XT_OBJECT_KIND_STRING:
+    case XT_OBJECT_KIND_STRING: {
+      /* A flat string holds bytes only. A cons node is an immutable rope whose
+       * children must stay alive until `xt_string_bytes` materialises it. */
+      xt_string *string = (xt_string *)header;
+      if (string->flat == NULL) {
+        if (string->left) xt_gc_gray_push(&string->left->header);
+        if (string->right) xt_gc_gray_push(&string->right->header);
+      }
+      return;
+    }
     case XT_OBJECT_KIND_BIGINT:
     case XT_OBJECT_KIND_DATE:
       /* Numbers/bytes only: no references to follow. */
@@ -392,7 +404,7 @@ static void xt_gc_process(xt_header *header) {
 static void xt_gc_release(xt_header *header) {
   switch (header->kind) {
     case XT_OBJECT_KIND_STRING:
-      free(((xt_string *)header)->data);
+      free(((xt_string *)header)->flat);
       break;
     case XT_OBJECT_KIND_BIGINT:
       free(((xt_bigint *)header)->limbs);

package/runtime/xt_bigint/conversions.inc

@@ -41,7 +41,7 @@ static xt_value bi_from_xt_value(xt_value value) {
   if (XT_IS_NUMBER(value)) return xt_bigint_from_double(xt_to_double(value));
   if (XT_IS_STRING(value)) {
     xt_string *s = xt_as_string(value);
-    return xt_bigint_from_string(s->data, s->length);
+    return xt_bigint_from_string(xt_string_bytes(s), s->length);
   }
   if (value == XT_TRUE) return xt_bigint_from_i64(1);
   if (value == XT_FALSE) return xt_bigint_from_i64(0);

package/runtime/xt_builtins.c

@@ -62,9 +62,77 @@ xt_value xt_object_spread(xt_value target, xt_value source) {
   return xt_object_assign(2, args);
 }
 
+/* True when `key` is one of the explicitly destructured properties. */
+static int xt_object_rest_excludes(xt_value key, int32_t argc, xt_value *argv) {
+  for (int32_t i = 0; i < argc; i++) {
+    if (xt_property_key_equals(key, argv[i])) return 1;
+  }
+  return 0;
+}
+
+static void xt_object_rest_copy(xt_value target, xt_value key, xt_value value, int32_t argc, xt_value *argv) {
+  if (xt_object_rest_excludes(key, argc, argv)) return;
+  xt_object_set(target, key, value);
+}
+
+/*
+ * `const { a, ...rest } = source` (and the assignment / parameter forms).
+ *
+ * Copies the *own enumerable* properties that the pattern did not name, in
+ * insertion order. Arrays and strings contribute their index properties, like
+ * ECMAScript; accessor properties are read through their getter, with the
+ * source as the receiver.
+ */
+xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv) {
+  if (source == XT_UNDEFINED || source == XT_NULL) {
+    xt_throw(xt_string_from_cstr("TypeError: Cannot destructure null or undefined"));
+    return XT_UNDEFINED;
+  }
+  xt_value result = xt_object_new();
+
+  if (XT_IS_ARRAY(source)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(source);
+    for (uint32_t i = 0; i < array->length; i++) {
+      char buffer[16];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), array->items[i], argc, argv);
+    }
+    return result;
+  }
+
+  if (XT_IS_STRING(source)) {
+    xt_string *string = (xt_string *)XT_GET_PTR(source);
+    const char *bytes = xt_string_bytes(string);
+    for (uint32_t i = 0; i < string->length; i++) {
+      char buffer[16];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_new(bytes + i, 1), argc, argv);
+    }
+    return result;
+  }
+
+  if (!XT_IS_OBJECT(source) && !XT_IS_FUNCTION(source)) return result;
+  xt_object *object = xt_as_object(source);
+  if (!object) return result;
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT && object->header.kind != XT_OBJECT_KIND_ERROR) {
+    /* Map/Set/Date/RegExp/Promise have no own enumerable string properties. */
+    return result;
+  }
+  for (uint32_t i = 0; i < object->count; i++) {
+    xt_property *property = &object->properties[i];
+    if (xt_object_rest_excludes(property->key, argc, argv)) continue;
+    xt_value value = property->value;
+    if (property->getter != XT_UNDEFINED && XT_IS_FUNCTION(property->getter)) {
+      value = xt_call_with_this(property->getter, source, 0, NULL);
+    }
+    xt_object_set(result, property->key, value);
+  }
+  return result;
+}
+
 xt_value xt_parse_int(int32_t argc, xt_value *argv) {
   xt_string *s = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
-  const char *p = s->data;
+  const char *p = xt_string_bytes(s);
   /* JavaScript `parseInt` semantics: skip leading whitespace, accept an
      optional sign, pick the radix (auto-detecting a `0x` prefix), read the
      longest run of valid digits and accumulate into a double. Accumulating as
@@ -107,9 +175,10 @@ xt_value xt_parse_int(int32_t argc, xt_value *argv) {
 
 xt_value xt_parse_float(int32_t argc, xt_value *argv) {
   xt_string *s = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
+  const char *bytes = xt_string_bytes(s);
   char *end = NULL;
-  double value = strtod(s->data, &end);
-  if (end == s->data) return xt_number(NAN);
+  double value = strtod(bytes, &end);
+  if (end == bytes) return xt_number(NAN);
   return xt_number(value);
 }
 
@@ -140,6 +209,7 @@ static int xt_uri_is_kept(const char *allowed, unsigned char c) {
 
 static xt_value xt_uri_encode(xt_value input, const char *allowed) {
   xt_string *s = xt_as_string(xt_to_string(input));
+  const char *bytes = xt_string_bytes(s);
   static const char hex[] = "0123456789ABCDEF";
   char *out = (char *)malloc((size_t)s->length * 3 + 1);
   if (!out) {
@@ -148,7 +218,7 @@ static xt_value xt_uri_encode(xt_value input, const char *allowed) {
   }
   size_t written = 0;
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     if (xt_uri_is_kept(allowed, c)) {
       out[written++] = (char)c;
     } else {
@@ -173,6 +243,7 @@ static int xt_hex_value(int c) {
  * escapes for reserved characters are copied through unchanged. */
 static xt_value xt_uri_decode(xt_value input, int component) {
   xt_string *s = xt_as_string(xt_to_string(input));
+  const char *bytes = xt_string_bytes(s);
   char *out = (char *)malloc((size_t)s->length + 1);
   if (!out) {
     fprintf(stderr, "xbintsc: out of memory\n");
@@ -181,22 +252,22 @@ static xt_value xt_uri_decode(xt_value input, int component) {
   size_t written = 0;
   uint32_t i = 0;
   while (i < s->length) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     if (c != '%') {
       out[written++] = (char)c;
       i++;
       continue;
     }
     if (i + 2 >= s->length) xt_throw_uri_error("URI malformed");
-    int h1 = xt_hex_value((unsigned char)s->data[i + 1]);
-    int h2 = xt_hex_value((unsigned char)s->data[i + 2]);
+    int h1 = xt_hex_value((unsigned char)bytes[i + 1]);
+    int h2 = xt_hex_value((unsigned char)bytes[i + 2]);
     if (h1 < 0 || h2 < 0) xt_throw_uri_error("URI malformed");
     unsigned char b = (unsigned char)((h1 << 4) | h2);
     if (b < 0x80) {
       if (!component && xt_uri_is_kept(";/?:@&=+$,#", b)) {
-        out[written++] = s->data[i];
-        out[written++] = s->data[i + 1];
-        out[written++] = s->data[i + 2];
+        out[written++] = bytes[i];
+        out[written++] = bytes[i + 1];
+        out[written++] = bytes[i + 2];
       } else {
         out[written++] = (char)b;
       }
@@ -213,9 +284,9 @@ static xt_value xt_uri_decode(xt_value input, int component) {
     for (int k = 1; k <= extra; k++) {
       uint32_t pos = i + (uint32_t)k * 3;
       if (pos + 2 >= s->length) xt_throw_uri_error("URI malformed");
-      if (s->data[pos] != '%') xt_throw_uri_error("URI malformed");
-      int c1 = xt_hex_value((unsigned char)s->data[pos + 1]);
-      int c2 = xt_hex_value((unsigned char)s->data[pos + 2]);
+      if (bytes[pos] != '%') xt_throw_uri_error("URI malformed");
+      int c1 = xt_hex_value((unsigned char)bytes[pos + 1]);
+      int c2 = xt_hex_value((unsigned char)bytes[pos + 2]);
       if (c1 < 0 || c2 < 0) xt_throw_uri_error("URI malformed");
       unsigned char cb = (unsigned char)((c1 << 4) | c2);
       if ((cb & 0xC0) != 0x80) xt_throw_uri_error("URI malformed");
@@ -322,7 +393,7 @@ xt_value xt_in(xt_value key, xt_value value) {
     if (xt_is_symbol(key)) return XT_FALSE;
     xt_string *s = xt_as_string(value);
     xt_string *k = xt_as_string(xt_to_string(key));
-    if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return XT_TRUE;
+    if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
     int32_t index = xt_to_int32(key);
     return xt_bool(index >= 0 && (uint32_t)index < s->length);
   }
@@ -446,6 +517,57 @@ xt_value xt_instance_of(xt_value value, xt_value ctor) {
   return XT_FALSE;
 }
 
+/*
+ * `value instanceof Array` (and the rest of the built-in constructors).
+ *
+ * Built-in constructors are not first-class values: the codegen recognises the
+ * name and asks this helper instead. Ids match `BUILTIN_INSTANCEOF` in
+ * `src/codegen/generator/tables.ts`; 16..24 map onto the runtime's `XT_TA_*`
+ * order (Uint8Array first).
+ */
+enum {
+  XT_INSTANCE_ARRAY = 0,
+  XT_INSTANCE_OBJECT = 1,
+  XT_INSTANCE_FUNCTION = 2,
+  XT_INSTANCE_MAP = 3,
+  XT_INSTANCE_SET = 4,
+  XT_INSTANCE_DATE = 5,
+  XT_INSTANCE_REGEXP = 6,
+  XT_INSTANCE_PROMISE = 7,
+  XT_INSTANCE_TYPED_ARRAY_FIRST = 16,
+  XT_INSTANCE_TYPED_ARRAY_LAST = 24
+};
+
+static int xt_value_has_kind(xt_value value, uint8_t kind) {
+  return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == kind;
+}
+
+xt_value xt_instance_of_builtin(xt_value value, int32_t id) {
+  switch (id) {
+    case XT_INSTANCE_ARRAY:
+      return xt_bool(XT_IS_ARRAY(value));
+    case XT_INSTANCE_OBJECT:
+      return xt_bool(XT_IS_OBJECT(value) || XT_IS_ARRAY(value) || XT_IS_FUNCTION(value));
+    case XT_INSTANCE_FUNCTION:
+      return xt_bool(XT_IS_FUNCTION(value));
+    case XT_INSTANCE_MAP:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_MAP));
+    case XT_INSTANCE_SET:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_SET));
+    case XT_INSTANCE_DATE:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_DATE));
+    case XT_INSTANCE_REGEXP:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_REGEXP));
+    case XT_INSTANCE_PROMISE:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_PROMISE));
+    default:
+      if (id >= XT_INSTANCE_TYPED_ARRAY_FIRST && id <= XT_INSTANCE_TYPED_ARRAY_LAST) {
+        return xt_bool(xt_typed_array_kind_of(value) == id - XT_INSTANCE_TYPED_ARRAY_FIRST);
+      }
+      return XT_FALSE;
+  }
+}
+
 xt_value xt_closure_env(xt_value value, int32_t index) {
   if (!XT_IS_FUNCTION(value)) return XT_UNDEFINED;
   xt_function *function = (xt_function *)XT_GET_PTR(value);

package/runtime/xt_containers/access.inc

@@ -13,7 +13,7 @@ static void xt_throw_read_of_nullish(xt_value target, xt_value key) {
   char keybuf[128];
   xt_string *k = XT_IS_STRING(key) ? xt_as_string(key) : xt_as_string(xt_to_string(key));
   uint32_t n = k->length < sizeof(keybuf) - 1 ? k->length : (uint32_t)(sizeof(keybuf) - 1);
-  memcpy(keybuf, k->data, n);
+  memcpy(keybuf, xt_string_bytes(k), n);
   keybuf[n] = 0;
   char message[256];
   snprintf(message, sizeof(message),
@@ -27,7 +27,7 @@ xt_value xt_get(xt_value target, xt_value key) {
     /* `arr.length` must read the array's length, never an element. */
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0)
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0)
         return xt_number((double)((xt_array *)XT_GET_PTR(target))->length);
       /* Named (non-index) properties such as `raw`/`index`/`input`. */
       uint32_t ignored = 0;
@@ -57,11 +57,11 @@ xt_value xt_get(xt_value target, xt_value key) {
     /* Functions expose own `name` / `length` (arity) properties. */
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) {
         int32_t arity = ((xt_function *)XT_GET_PTR(target))->arity;
         return xt_number(arity >= 0 ? (double)arity : 0.0);
       }
-      if (k->length == 4 && memcmp(k->data, "name", 4) == 0) {
+      if (k->length == 4 && memcmp(xt_string_bytes(k), "name", 4) == 0) {
         xt_string *name = ((xt_function *)XT_GET_PTR(target))->name;
         return name ? XT_FROM_PTR(XT_TAG_STRING, name) : xt_string_from_cstr("");
       }
@@ -79,7 +79,7 @@ xt_value xt_get(xt_value target, xt_value key) {
     if (obj->header.kind == XT_OBJECT_KIND_SYMBOL) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
-        if (k->length == 11 && memcmp(k->data, "description", 11) == 0) {
+        if (k->length == 11 && memcmp(xt_string_bytes(k), "description", 11) == 0) {
           return xt_symbol_description(target);
         }
       }
@@ -88,7 +88,7 @@ xt_value xt_get(xt_value target, xt_value key) {
     if (obj->header.kind == XT_OBJECT_KIND_MAP || obj->header.kind == XT_OBJECT_KIND_SET) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
-        if (k->length == 4 && memcmp(k->data, "size", 4) == 0) {
+        if (k->length == 4 && memcmp(xt_string_bytes(k), "size", 4) == 0) {
           int32_t size = obj->header.kind == XT_OBJECT_KIND_MAP ? xt_map_size(target) : xt_set_size(target);
           return xt_number((double)size);
         }
@@ -100,9 +100,10 @@ xt_value xt_get(xt_value target, xt_value key) {
     }
     if (obj->header.kind == XT_OBJECT_KIND_ERROR && XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 5 && memcmp(k->data, "stack", 5) == 0) {
-        xt_value own = xt_object_get(target, key);
-        return own != XT_UNDEFINED ? own : xt_error_to_string(target);
+      if (k->length == 5 && memcmp(xt_string_bytes(k), "stack", 5) == 0) {
+        xt_value captured = xt_error_stack(target);
+        if (captured != XT_UNDEFINED) return captured;
+        return xt_error_to_string(target);
       }
     }
     {
@@ -117,16 +118,16 @@ xt_value xt_get(xt_value target, xt_value key) {
     xt_string *s = xt_as_string(target);
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return xt_number((double)s->length);
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return xt_number((double)s->length);
       uint32_t index = 0;
       if (xt_key_is_array_index(k, &index) && index < s->length) {
-        return xt_string_new(s->data + index, 1);
+        return xt_string_new(xt_string_bytes(s) + index, 1);
       }
       return xt_method_value(target, key);
     }
     if (XT_IS_NUMBER(key)) {
       int32_t index = xt_to_int32(key);
-      if (index >= 0 && (uint32_t)index < s->length) return xt_string_new(s->data + index, 1);
+      if (index >= 0 && (uint32_t)index < s->length) return xt_string_new(xt_string_bytes(s) + index, 1);
     }
     return XT_UNDEFINED;
   }
@@ -142,7 +143,7 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
     /* Assigning `arr.length` truncates or extends the array. */
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) {
         xt_array *array = (xt_array *)XT_GET_PTR(target);
         int32_t n = xt_to_int32(value);
         if (n < 0) n = 0;
@@ -169,9 +170,9 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
     if (typed >= 0) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
-        if ((k->length == 6 && memcmp(k->data, "length", 6) == 0) ||
-            (k->length == 10 && memcmp(k->data, "byteLength", 10) == 0) ||
-            (k->length == 10 && memcmp(k->data, "byteOffset", 10) == 0)) {
+        if ((k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) ||
+            (k->length == 10 && memcmp(xt_string_bytes(k), "byteLength", 10) == 0) ||
+            (k->length == 10 && memcmp(xt_string_bytes(k), "byteOffset", 10) == 0)) {
           xt_throw(xt_string_from_cstr("TypeError: Cannot assign to read only property"));
           return value;
         }

package/runtime/xt_containers/objects.inc

@@ -54,10 +54,11 @@ static xt_property *xt_object_find(xt_object *obj, xt_value key) {
  */
 static int xt_key_is_array_index(xt_string *key, uint32_t *out) {
   if (key->length == 0 || key->length > 10) return 0;
-  if (key->data[0] == '0' && key->length != 1) return 0; /* "0" is canonical, "01" is not */
+  const char *bytes = xt_string_bytes(key);
+  if (bytes[0] == '0' && key->length != 1) return 0; /* "0" is canonical, "01" is not */
   uint64_t value = 0;
   for (uint32_t i = 0; i < key->length; i++) {
-    char ch = key->data[i];
+    char ch = bytes[i];
     if (ch < '0' || ch > '9') return 0;
     value = value * 10 + (uint64_t)(ch - '0');
   }
@@ -117,7 +118,7 @@ int xt_property_key_equals(xt_value a, xt_value b) {
 static int xt_key_is_prototype(xt_value key) {
   if (!XT_IS_STRING(key)) return 0;
   xt_string *k = xt_as_string(key);
-  return k && k->length == 9 && memcmp(k->data, "prototype", 9) == 0;
+  return k && k->length == 9 && memcmp(xt_string_bytes(k), "prototype", 9) == 0;
 }
 
 xt_value xt_object_get(xt_value value, xt_value key) {