xbintsc 0.3.79 → 0.3.87

package/runtime/xt_stdlib2/regexp-match.inc

@@ -109,8 +109,11 @@ static int xt_regexp_run(xt_value regexpValue, xt_value input, int32_t start,
   if ((uint32_t)start > text->length) return 0;
   int flags = REG_EXTENDED;
   xt_string *f = xt_as_string(regexp->flags);
-  if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'i') flags |= REG_ICASE;
-  char *translated = xt_regexp_translate_js(pattern->data, jsGroups, groupCount);
+  if (f) {
+    const char *flagBytes = xt_string_bytes(f);
+    for (uint32_t i = 0; i < f->length; i++) if (flagBytes[i] == 'i') flags |= REG_ICASE;
+  }
+  char *translated = xt_regexp_translate_js(xt_string_bytes(pattern), jsGroups, groupCount);
   if (!translated) return 0;
   regex_t compiled;
   if (regcomp(&compiled, translated, flags) != 0) {
@@ -118,7 +121,7 @@ static int xt_regexp_run(xt_value regexpValue, xt_value input, int32_t start,
     return 0;
   }
   free(translated);
-  int ok = regexec(&compiled, text->data + start, nmatch, matches, 0) == 0;
+  int ok = regexec(&compiled, xt_string_bytes(text) + start, nmatch, matches, 0) == 0;
   regfree(&compiled);
   if (!ok) return 0;
   for (size_t i = 0; i < nmatch; i++) {
@@ -142,7 +145,8 @@ static int xt_regexp_is_global(xt_value regexpValue) {
   xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
   xt_string *f = xt_as_string(regexp->flags);
   if (!f) return 0;
-  for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'g') return 1;
+  const char *flags = xt_string_bytes(f);
+  for (uint32_t i = 0; i < f->length; i++) if (flags[i] == 'g') return 1;
   return 0;
 }
 
@@ -154,7 +158,7 @@ static int xt_regexp_js_group_count(xt_value regexpValue) {
   int count = (int)pattern->length + 1;
   int *groups = (int *)malloc(sizeof(int) * (size_t)count);
   int groupCount = 0;
-  char *translated = xt_regexp_translate_js(pattern->data, groups, &groupCount);
+  char *translated = xt_regexp_translate_js(xt_string_bytes(pattern), groups, &groupCount);
   free(translated);
   int total = 0;
   for (int i = 0; i < groupCount; i++) if (groups[i] > total) total = groups[i];
@@ -177,6 +181,7 @@ xt_value xt_regexp_exec(xt_value target, xt_value input) {
   if (!matches || !groups) { free(matches); free(groups); return XT_NULL; }
   xt_value textValue = xt_to_string(input);
   xt_string *text = xt_as_string(textValue);
+  const char *textBytes = xt_string_bytes(text);
   int groupCount = 0;
   if (!xt_regexp_run(target, input, 0, matches, cap, groups, &groupCount)) {
     free(matches);
@@ -186,13 +191,13 @@ xt_value xt_regexp_exec(xt_value target, xt_value input) {
   int jsTotal = 0;
   for (int i = 0; i < groupCount; i++) if (groups[i] > jsTotal) jsTotal = groups[i];
   xt_value out = xt_array_new(0, NULL);
-  xt_array_push(out, xt_string_new(text->data + matches[0].rm_so, (int64_t)(matches[0].rm_eo - matches[0].rm_so)));
+  xt_array_push(out, xt_string_new(textBytes + matches[0].rm_so, (int64_t)(matches[0].rm_eo - matches[0].rm_so)));
   for (int g = 1; g <= jsTotal; g++) {
     xt_value groupValue = XT_UNDEFINED;
     for (int i = 0; i < groupCount; i++) {
       if (groups[i] != g) continue;
       if (matches[i + 1].rm_so >= 0) {
-        groupValue = xt_string_new(text->data + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
+        groupValue = xt_string_new(textBytes + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
       }
       break;
     }
@@ -212,6 +217,7 @@ xt_value xt_regexp_match(xt_value input, xt_value regexp) {
   if (!xt_regexp_is_global(regexp)) return xt_regexp_exec(regexp, input);
   xt_value textValue = xt_to_string(input);
   xt_string *text = xt_as_string(textValue);
+  const char *textBytes = xt_string_bytes(text);
   xt_value results = xt_array_new(0, NULL);
   int32_t cursor = 0;
   int found = 0;
@@ -220,7 +226,7 @@ xt_value xt_regexp_match(xt_value input, xt_value regexp) {
     int32_t end = 0;
     if (!xt_regexp_find(regexp, input, cursor, &start, &end)) break;
     found = 1;
-    xt_array_push(results, xt_string_new(text->data + start, (int64_t)(end - start)));
+    xt_array_push(results, xt_string_new(textBytes + start, (int64_t)(end - start)));
     cursor = end > start ? end : end + 1;
   }
   return found ? results : XT_NULL;
@@ -241,10 +247,11 @@ static void xt_regexp_append(char **out, size_t *length, size_t *capacity, const
 static void xt_regexp_append_group(char **out, size_t *length, size_t *capacity,
                                    xt_string *text, regmatch_t *matches, int *groups,
                                    int groupCount, int group) {
+  const char *textBytes = xt_string_bytes(text);
   for (int i = 0; i < groupCount; i++) {
     if (groups[i] != group) continue;
     if (matches[i + 1].rm_so >= 0) {
-      xt_regexp_append(out, length, capacity, text->data + matches[i + 1].rm_so,
+      xt_regexp_append(out, length, capacity, textBytes + matches[i + 1].rm_so,
                        (size_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
     }
     return;
@@ -255,32 +262,34 @@ static void xt_regexp_expand_replacement(char **out, size_t *length, size_t *cap
                                          xt_string *replacement, xt_string *text,
                                          regmatch_t *matches, int *groups, int groupCount,
                                          int jsTotal) {
+  const char *repl = xt_string_bytes(replacement);
+  const char *textBytes = xt_string_bytes(text);
   size_t start = (size_t)matches[0].rm_so;
   size_t end = (size_t)matches[0].rm_eo;
   for (size_t i = 0; i < replacement->length; i++) {
-    char c = replacement->data[i];
+    char c = repl[i];
     if (c != '$' || i + 1 >= replacement->length) {
       xt_regexp_append(out, length, capacity, &c, 1);
       continue;
     }
-    char next = replacement->data[i + 1];
+    char next = repl[i + 1];
     if (next == '$') {
       xt_regexp_append(out, length, capacity, "$", 1);
       i++;
     } else if (next == '&') {
-      xt_regexp_append(out, length, capacity, text->data + start, end - start);
+      xt_regexp_append(out, length, capacity, textBytes + start, end - start);
       i++;
     } else if (next == '`') {
-      xt_regexp_append(out, length, capacity, text->data, start);
+      xt_regexp_append(out, length, capacity, textBytes, start);
       i++;
     } else if (next == '\'') {
-      xt_regexp_append(out, length, capacity, text->data + end, text->length - end);
+      xt_regexp_append(out, length, capacity, textBytes + end, text->length - end);
       i++;
     } else if (next >= '0' && next <= '9') {
       int value = next - '0';
       int digits = 1;
-      if (i + 2 < replacement->length && replacement->data[i + 2] >= '0' && replacement->data[i + 2] <= '9') {
-        int two = value * 10 + (replacement->data[i + 2] - '0');
+      if (i + 2 < replacement->length && repl[i + 2] >= '0' && repl[i + 2] <= '9') {
+        int two = value * 10 + (repl[i + 2] - '0');
         if (two <= jsTotal) { value = two; digits = 2; }
       }
       if (value >= 1 && value <= jsTotal) {
@@ -299,6 +308,7 @@ static void xt_regexp_expand_replacement(char **out, size_t *length, size_t *cap
 xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replacementValue) {
   xt_string *text = xt_as_string(xt_to_string(value));
   if (!text) return value;
+  const char *textBytes = xt_string_bytes(text);
   int global = xt_regexp_is_global(regexpValue);
   int useFunction = XT_IS_FUNCTION(replacementValue);
   xt_string *replacement = NULL;
@@ -324,18 +334,18 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     if (!xt_regexp_run(regexpValue, value, cursor, matches, cap, groups, &groupCount)) break;
     int32_t start = (int32_t)matches[0].rm_so;
     int32_t end = (int32_t)matches[0].rm_eo;
-    xt_regexp_append(&out, &length, &capacity, text->data + cursor, (size_t)(start - cursor));
+    xt_regexp_append(&out, &length, &capacity, textBytes + cursor, (size_t)(start - cursor));
     if (useFunction) {
       /* Accumulate in an `xt_array` so the earlier match/group strings stay
          reachable while later groups (and the callback itself) allocate. */
       xt_value argArray = xt_array_new(0, NULL);
-      xt_array_push(argArray, xt_string_new(text->data + start, (int64_t)(end - start)));
+      xt_array_push(argArray, xt_string_new(textBytes + start, (int64_t)(end - start)));
       for (int g = 1; g <= jsTotal; g++) {
         xt_value groupValue = XT_UNDEFINED;
         for (int i = 0; i < groupCount; i++) {
           if (groups[i] != g) continue;
           if (matches[i + 1].rm_so >= 0) {
-            groupValue = xt_string_new(text->data + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
+            groupValue = xt_string_new(textBytes + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
           }
           break;
         }
@@ -345,7 +355,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
       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));
-      if (producedText) xt_regexp_append(&out, &length, &capacity, producedText->data, producedText->length);
+      if (producedText) xt_regexp_append(&out, &length, &capacity, xt_string_bytes(producedText), producedText->length);
     } else {
       xt_regexp_expand_replacement(&out, &length, &capacity, replacement, text, matches, groups, groupCount, jsTotal);
     }
@@ -355,7 +365,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     } else {
       /* Zero-width match: copy one byte so the scan always progresses. */
       if (cursor >= (int32_t)text->length) break;
-      xt_regexp_append(&out, &length, &capacity, text->data + cursor, 1);
+      xt_regexp_append(&out, &length, &capacity, textBytes + cursor, 1);
       cursor++;
     }
     if (!global) break;
@@ -367,7 +377,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     return value;
   }
   size_t tail = text->length - (size_t)cursor;
-  xt_regexp_append(&out, &length, &capacity, text->data + cursor, tail);
+  xt_regexp_append(&out, &length, &capacity, textBytes + cursor, tail);
   xt_value result = xt_string_new(out, (int64_t)length);
   free(out);
   free(matches);
@@ -381,6 +391,7 @@ xt_value xt_regexp_split(xt_value value, xt_value regexpValue, xt_value limitVal
   xt_value result = xt_array_new(0, NULL);
   xt_string *text = xt_as_string(xt_to_string(value));
   if (!text) return result;
+  const char *textBytes = xt_string_bytes(text);
   int64_t limit = limitValue == XT_UNDEFINED ? 0x7fffffff : (int64_t)xt_to_int32(limitValue);
   if (limit <= 0) return result;
   xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
@@ -400,14 +411,14 @@ xt_value xt_regexp_split(xt_value value, xt_value regexpValue, xt_value limitVal
     int32_t end = (int32_t)matches[0].rm_eo;
     if (start != q) { q++; continue; }
     if (end == p) { q++; continue; }
-    xt_array_push(result, xt_string_new(text->data + p, (int64_t)(q - p)));
+    xt_array_push(result, xt_string_new(textBytes + p, (int64_t)(q - p)));
     if ((int64_t)xt_as_array(result)->length >= limit) { free(matches); free(groups); return result; }
     for (int g = 1; g <= jsTotal; g++) {
       xt_value groupValue = XT_UNDEFINED;
       for (int i = 0; i < groupCount; i++) {
         if (groups[i] != g) continue;
         if (matches[i + 1].rm_so >= 0) {
-          groupValue = xt_string_new(text->data + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
+          groupValue = xt_string_new(textBytes + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
         }
         break;
       }
@@ -418,7 +429,7 @@ xt_value xt_regexp_split(xt_value value, xt_value regexpValue, xt_value limitVal
     q = p;
   }
   if ((int64_t)xt_as_array(result)->length < limit) {
-    xt_array_push(result, xt_string_new(text->data + p, (int64_t)(len - p)));
+    xt_array_push(result, xt_string_new(textBytes + p, (int64_t)(len - p)));
   }
   free(matches);
   free(groups);
@@ -431,16 +442,20 @@ xt_value xt_regexp_get_property(xt_value target, xt_value key) {
   if (!XT_IS_STRING(key)) return XT_UNDEFINED;
   xt_string *k = xt_as_string(key);
   xt_string *f = xt_as_string(regexp->flags);
+  const char *keyBytes = xt_string_bytes(k);
   int flag = 0;
-  if (k->length == 6 && memcmp(k->data, "source", 6) == 0) return regexp->source;
-  if (k->length == 5 && memcmp(k->data, "flags", 5) == 0) return regexp->flags;
-  if (k->length == 9 && memcmp(k->data, "lastIndex", 9) == 0) return xt_number(0);
-  if (k->length == 6 && memcmp(k->data, "global", 6) == 0) flag = 'g';
-  else if (k->length == 10 && memcmp(k->data, "ignoreCase", 10) == 0) flag = 'i';
-  else if (k->length == 9 && memcmp(k->data, "multiline", 9) == 0) flag = 'm';
-  else if (k->length == 6 && memcmp(k->data, "sticky", 6) == 0) flag = 'y';
+  if (k->length == 6 && memcmp(keyBytes, "source", 6) == 0) return regexp->source;
+  if (k->length == 5 && memcmp(keyBytes, "flags", 5) == 0) return regexp->flags;
+  if (k->length == 9 && memcmp(keyBytes, "lastIndex", 9) == 0) return xt_number(0);
+  if (k->length == 6 && memcmp(keyBytes, "global", 6) == 0) flag = 'g';
+  else if (k->length == 10 && memcmp(keyBytes, "ignoreCase", 10) == 0) flag = 'i';
+  else if (k->length == 9 && memcmp(keyBytes, "multiline", 9) == 0) flag = 'm';
+  else if (k->length == 6 && memcmp(keyBytes, "sticky", 6) == 0) flag = 'y';
   if (flag) {
-    if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == flag) return XT_TRUE;
+    if (f) {
+      const char *flags = xt_string_bytes(f);
+      for (uint32_t i = 0; i < f->length; i++) if (flags[i] == flag) return XT_TRUE;
+    }
     return XT_FALSE;
   }
   return XT_UNDEFINED;

package/runtime/xt_stdlib2/strings.inc

@@ -9,13 +9,16 @@ static xt_value xt_string_pad(xt_value value, xt_value lengthValue, xt_value pad
   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++) out->data[i] = pad->data[i % pad->length];
-    memcpy(out->data + needed, s->data, s->length);
+    for (size_t i = 0; i < needed; i++) mutable[i] = padBytes[i % pad->length];
+    memcpy(mutable + needed, text, s->length);
   } else {
-    memcpy(out->data, s->data, s->length);
-    for (size_t i = 0; i < needed; i++) out->data[s->length + i] = pad->data[i % pad->length];
+    memcpy(mutable, text, s->length);
+    for (size_t i = 0; i < needed; i++) mutable[s->length + i] = padBytes[i % pad->length];
   }
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
@@ -23,11 +26,12 @@ static xt_value xt_string_pad(xt_value value, xt_value lengthValue, xt_value pad
 static xt_value xt_string_trim_side(xt_value value, int start) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
+  const char *bytes = xt_string_bytes(s);
   uint32_t begin = 0;
   uint32_t end = s->length;
-  if (start) { while (begin < end && isspace((unsigned char)s->data[begin])) begin++; }
-  else { while (end > begin && isspace((unsigned char)s->data[end - 1])) end--; }
-  return xt_string_new(s->data + begin, end - begin);
+  if (start) { while (begin < end && isspace((unsigned char)bytes[begin])) begin++; }
+  else { while (end > begin && isspace((unsigned char)bytes[end - 1])) end--; }
+  return xt_string_new(bytes + begin, end - begin);
 }
 
 static xt_value xt_string_at(xt_value value, xt_value indexValue) {
@@ -36,7 +40,7 @@ static xt_value xt_string_at(xt_value value, xt_value indexValue) {
   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(s->data + index, 1);
+  return xt_string_new(xt_string_bytes(s) + index, 1);
 }
 
 static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
@@ -46,20 +50,23 @@ static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_v
   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;
+  const char *text = xt_string_bytes(s);
+  const char *needle = xt_string_bytes(search);
+  const char *repl = xt_string_bytes(replacement);
   size_t capacity = s->length + replacement->length * 4 + 16;
   char *out = (char *)malloc(capacity);
   if (!out) abort();
   size_t length = 0;
   uint32_t i = 0;
   while (i < s->length) {
-    if (i + search->length <= s->length && memcmp(s->data + i, search->data, search->length) == 0) {
+    if (i + search->length <= s->length && memcmp(text + i, needle, search->length) == 0) {
       if (length + replacement->length + 2 > capacity) { capacity = (length + replacement->length + 2) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-      memcpy(out + length, replacement->data, replacement->length);
+      memcpy(out + length, repl, replacement->length);
       length += replacement->length;
       i += search->length;
     } else {
       if (length + 2 > capacity) { capacity *= 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-      out[length++] = s->data[i++];
+      out[length++] = text[i++];
     }
   }
   xt_value result = xt_string_new(out, length);
@@ -106,17 +113,19 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     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(s->data + i, needle->data, (size_t)nlen) == 0) return xt_number((double)i);
+      if (memcmp(text + i, need, (size_t)nlen) == 0) return xt_number((double)i);
     }
     return xt_number(-1);
   }
   if (strcmp(method, "localeCompare") == 0) {
     xt_string *a = xt_as_string(target);
     xt_string *b = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
-    int cmp = strcmp(a ? a->data : "", b ? b->data : "");
+    int cmp = strcmp(a ? xt_string_bytes(a) : "", b ? xt_string_bytes(b) : "");
     return xt_number(cmp < 0 ? -1 : cmp > 0 ? 1 : 0);
   }
   if (strcmp(method, "codePointAt") == 0) {
@@ -124,7 +133,7 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     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)s->data[index]);
+    return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
   }
   if (strcmp(method, "valueOf") == 0 || strcmp(method, "toString") == 0) return target;
   *handled = 0;

package/runtime/xt_symbol.c

@@ -98,7 +98,7 @@ xt_value xt_symbol_to_string(xt_value value) {
   char *buffer = (char *)malloc(8 + length);
   if (!buffer) abort();
   memcpy(buffer, "Symbol(", 7);
-  if (description) memcpy(buffer + 7, description->data, length);
+  if (description) memcpy(buffer + 7, xt_string_bytes(description), length);
   buffer[7 + length] = ')';
   xt_value result = xt_string_new(buffer, 8 + length);
   free(buffer);

package/runtime/xt_values/comparison.inc

@@ -33,7 +33,7 @@ xt_value xt_lt(xt_value a, xt_value b) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
     size_t n = x->length < y->length ? x->length : y->length;
-    int cmp = memcmp(x->data, y->data, n);
+    int cmp = memcmp(xt_string_bytes(x), xt_string_bytes(y), n);
     if (cmp == 0) return xt_bool(x->length < y->length);
     return xt_bool(cmp < 0);
   }
@@ -48,7 +48,7 @@ xt_value xt_le(xt_value a, xt_value b) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
     size_t n = x->length < y->length ? x->length : y->length;
-    int cmp = memcmp(x->data, y->data, n);
+    int cmp = memcmp(xt_string_bytes(x), xt_string_bytes(y), n);
     if (cmp == 0) return xt_bool(x->length <= y->length);
     return xt_bool(cmp < 0);
   }

package/runtime/xt_values/constructors.inc

@@ -10,19 +10,22 @@ xt_value xt_number(double d) { return xt_from_double(d); }
 xt_string *xt_string_alloc(size_t length) {
   xt_string *s = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   s->length = (uint32_t)length;
+  /* Keep the terminator in the allocation: many consumers hand `flat` to libc. */
   s->capacity = (uint32_t)length + 1;
-  s->data = (char *)malloc(s->capacity);
-  if (!s->data) {
+  s->flat = (char *)malloc(s->capacity);
+  if (!s->flat) {
     fprintf(stderr, "xbintsc: out of memory allocating string\n");
     abort();
   }
-  s->data[length] = '\0';
+  s->flat[length] = '\0';
+  s->left = NULL;
+  s->right = NULL;
   return s;
 }
 
 xt_value xt_string_new(const char *data, size_t len) {
   xt_string *s = xt_string_alloc(len);
-  if (len > 0) memcpy(s->data, data, len);
+  if (len > 0) memcpy(s->flat, data, len);
   return XT_FROM_PTR(XT_TAG_STRING, s);
 }
 
@@ -30,9 +33,11 @@ xt_value xt_string_from_cstr(const char *data) { return xt_string_new(data, strl
 
 xt_string *xt_as_string(xt_value v);
 
+char *xt_string_mutable(xt_string *s) { return s ? s->flat : NULL; }
+
 const char *xt_string_data(xt_value value) {
   xt_string *s = xt_as_string(value);
-  return s ? s->data : NULL;
+  return s ? xt_string_bytes(s) : NULL;
 }
 
 int32_t xt_string_length_value(xt_value value) {

package/runtime/xt_values/conversions.inc

@@ -24,8 +24,9 @@ double xt_to_number(xt_value v) {
   if (XT_IS_BIGINT(v)) return xt_bigint_to_double_value(v);
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    const char *begin = s->data;
-    const char *end = s->data + s->length;
+    const char *bytes = xt_string_bytes(s);
+    const char *begin = bytes;
+    const char *end = bytes + s->length;
     while (begin < end && isspace((unsigned char)*begin)) begin++;
     while (end > begin && isspace((unsigned char)end[-1])) end--;
     size_t length = (size_t)(end - begin);
@@ -83,7 +84,7 @@ xt_value xt_to_string(xt_value v) {
         out = (char *)realloc(out, capacity);
       }
       if (i > 0) out[length++] = ',';
-      memcpy(out + length, str->data, str->length);
+      memcpy(out + length, xt_string_bytes(str), str->length);
       length += str->length;
       out[length] = '\0';
     }

package/runtime/xt_values/strings.inc

@@ -2,6 +2,12 @@
 /* Strings                                                                   */
 /* ------------------------------------------------------------------------- */
 
+/* Concatenations up to this many bytes are copied eagerly. The copy is cheaper
+ * than a cons node for the short strings that dominate everyday code, and a
+ * loop that keeps appending crosses the threshold quickly, after which every
+ * append is O(1). */
+#define XT_STRING_CONS_THRESHOLD 32
+
 xt_string *xt_as_string(xt_value v) {
   if (XT_IS_STRING(v)) return (xt_string *)XT_GET_PTR(v);
   return NULL;
@@ -9,14 +15,82 @@ xt_string *xt_as_string(xt_value v) {
 
 int32_t xt_string_length(xt_string *s) { return (int32_t)s->length; }
 
+const char *xt_string_bytes(xt_string *s) {
+  if (!s) return NULL;
+  if (s->flat) return s->flat;
+
+  /* The tree is traversed depth-first without recursion: a loop that appends
+   * 100k times produces a 100k-deep left spine, which would overflow the C
+   * stack. Right children are pushed so the leftmost leaf is emitted first. */
+  size_t total = (size_t)s->length;
+  char *out = (char *)malloc(total + 1);
+  if (!out) {
+    fprintf(stderr, "xbintsc: out of memory flattening string\n");
+    abort();
+  }
+
+  size_t capacity = 64;
+  size_t count = 0;
+  xt_string **stack = (xt_string **)malloc(sizeof(xt_string *) * capacity);
+  if (!stack) {
+    fprintf(stderr, "xbintsc: out of memory flattening string\n");
+    abort();
+  }
+  stack[count++] = s;
+
+  size_t offset = 0;
+  while (count > 0) {
+    xt_string *node = stack[--count];
+    if (node->flat) {
+      memcpy(out + offset, node->flat, node->length);
+      offset += node->length;
+      continue;
+    }
+    if (count + 2 > capacity) {
+      while (count + 2 > capacity) capacity *= 2;
+      xt_string **grown = (xt_string **)realloc(stack, sizeof(xt_string *) * capacity);
+      if (!grown) {
+        fprintf(stderr, "xbintsc: out of memory flattening string\n");
+        abort();
+      }
+      stack = grown;
+    }
+    if (node->right) stack[count++] = node->right;
+    if (node->left) stack[count++] = node->left;
+  }
+  free(stack);
+
+  out[offset] = '\0';
+  s->flat = out;
+  s->capacity = (uint32_t)(total + 1);
+  s->left = NULL;
+  s->right = NULL;
+  return s->flat;
+}
+
 static xt_value xt_string_concat(xt_string *a, xt_string *b) {
+  if (a->length == 0) return XT_FROM_PTR(XT_TAG_STRING, b);
+  if (b->length == 0) return XT_FROM_PTR(XT_TAG_STRING, a);
   size_t total = (size_t)a->length + (size_t)b->length;
-  xt_string *out = xt_string_alloc(total);
-  memcpy(out->data, a->data, a->length);
-  memcpy(out->data + a->length, b->data, b->length);
+  if (total <= XT_STRING_CONS_THRESHOLD) {
+    xt_string *out = xt_string_alloc(total);
+    memcpy(out->flat, xt_string_bytes(a), a->length);
+    memcpy(out->flat + a->length, xt_string_bytes(b), b->length);
+    return XT_FROM_PTR(XT_TAG_STRING, out);
+  }
+  xt_string *out = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
+  out->length = (uint32_t)total;
+  out->capacity = 0;
+  out->flat = NULL;
+  out->left = a;
+  out->right = b;
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
 int xt_string_equals(xt_string *a, xt_string *b) {
-  return a->length == b->length && memcmp(a->data, b->data, a->length) == 0;
+  /* Interned literals (property names above all) are shared, so identity is the
+   * common case and skips the length, flattening and byte comparison entirely. */
+  if (a == b) return 1;
+  if (a->length != b->length) return 0;
+  return memcmp(xt_string_bytes(a), xt_string_bytes(b), a->length) == 0;
 }