xbintsc 0.3.87 → 0.5.20

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;
 }
 
@@ -108,6 +112,30 @@ xt_value xt_error_constructor(xt_value nameValue) {
   return closure;
 }
 
+/* Build the value thrown by the runtime for an internal "Name: message"
+ * string. JavaScript code can observe anything thrown, so internal failures
+ * must be real Error instances (`instanceof Error`, `.name`, `.message`,
+ * `.stack`), exactly like `new TypeError("...")`; a bare string would make
+ * `catch` blocks silently misbehave. User `throw` expressions never go
+ * through this helper. */
+xt_value xt_error_from_message(const char *message) {
+  const char *separator = strstr(message, ": ");
+  if (separator != NULL) {
+    size_t nameLength = (size_t)(separator - message);
+    char name[24];
+    if (nameLength > 0 && nameLength < sizeof(name)) {
+      memcpy(name, message, nameLength);
+      name[nameLength] = '\0';
+      if (xt_error_is_family(name)) {
+        xt_value argument = xt_string_from_cstr(separator + 2);
+        return xt_make_error(name, 1, &argument);
+      }
+    }
+  }
+  xt_value argument = xt_string_from_cstr(message);
+  return xt_make_error("Error", 1, &argument);
+}
+
 xt_value xt_error_to_string(xt_value error) {
   xt_value name = xt_object_get(error, xt_string_from_cstr("name"));
   xt_value message = xt_object_get(error, xt_string_from_cstr("message"));
@@ -162,6 +190,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`, ...). */

package/runtime/xt_stdlib2/json.inc

@@ -36,14 +36,31 @@ static xt_value xt_json_parse_string(xt_json_cursor *c) {
           else if (h >= 'a' && h <= 'f') code |= (unsigned)(h - 'a' + 10);
           else if (h >= 'A' && h <= 'F') code |= (unsigned)(h - 'A' + 10);
         }
+        /* A high surrogate followed by `\u` and a low surrogate denotes one
+         * supplementary code point, exactly like a JavaScript string. */
+        if (code >= 0xD800 && code <= 0xDBFF && c->pos + 5 < c->length &&
+            c->data[c->pos] == '\\' && c->data[c->pos + 1] == 'u') {
+          unsigned low = 0;
+          int valid = 1;
+          for (int i = 0; i < 4; i++) {
+            char h = c->data[c->pos + 2 + (size_t)i];
+            low <<= 4;
+            if (h >= '0' && h <= '9') low |= (unsigned)(h - '0');
+            else if (h >= 'a' && h <= 'f') low |= (unsigned)(h - 'a' + 10);
+            else if (h >= 'A' && h <= 'F') low |= (unsigned)(h - 'A' + 10);
+            else valid = 0;
+          }
+          if (valid && low >= 0xDC00 && low <= 0xDFFF) {
+            code = 0x10000 + ((code - 0xD800) << 10) + (low - 0xDC00);
+            c->pos += 6;
+          }
+        }
         if (code >= 0x80) {
           char tmp[4];
-          int bytes = 0;
-          if (code < 0x800) { tmp[bytes++] = (char)(0xC0 | (code >> 6)); tmp[bytes++] = (char)(0x80 | (code & 0x3F)); }
-          else { tmp[bytes++] = (char)(0xE0 | (code >> 12)); tmp[bytes++] = (char)(0x80 | ((code >> 6) & 0x3F)); tmp[bytes++] = (char)(0x80 | (code & 0x3F)); }
-          if (length + (size_t)bytes + 1 > capacity) { capacity = (length + (size_t)bytes + 1) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-          memcpy(out + length, tmp, (size_t)bytes);
-          length += (size_t)bytes;
+          size_t bytes = xt_utf8_encode(code, tmp);
+          if (length + bytes + 1 > capacity) { capacity = (length + bytes + 1) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
+          memcpy(out + length, tmp, bytes);
+          length += bytes;
           continue;
         }
         ch = (char)code;
@@ -116,50 +133,152 @@ static xt_value xt_json_parse_value(xt_json_cursor *c) {
   return xt_json_parse_number(c);
 }
 
+/* Reviver walk: rebuild each container bottom-up, then pass the value to the
+ * user callback with its holder as `this`. Returning undefined deletes an
+ * object property / array element, exactly like the specification. */
+static xt_value xt_json_revive(xt_value holder, xt_value key, xt_value reviver) {
+  xt_value value = xt_get(holder, key);
+  if (XT_IS_ARRAY(value)) {
+    xt_array *array = xt_as_array(value);
+    for (uint32_t i = 0; i < array->length; i++) {
+      /* Reviver keys are strings even for array indices. */
+      char keyBuffer[16];
+      snprintf(keyBuffer, sizeof(keyBuffer), "%u", i);
+      xt_value index = xt_string_from_cstr(keyBuffer);
+      xt_value updated = xt_json_revive(value, index, reviver);
+      if (updated == XT_UNDEFINED) xt_delete(value, index);
+      else xt_set(value, index, updated);
+    }
+  } else if (XT_IS_OBJECT(value)) {
+    xt_value keys = xt_object_keys(value);
+    xt_array *list = xt_as_array(keys);
+    if (list) {
+      for (uint32_t i = 0; i < list->length; i++) {
+        xt_value childKey = list->items[i];
+        xt_value updated = xt_json_revive(value, childKey, reviver);
+        if (updated == XT_UNDEFINED) xt_delete(value, childKey);
+        else xt_object_set(value, childKey, updated);
+      }
+    }
+  }
+  xt_value args[2] = {key, value};
+  return xt_call_with_this(reviver, holder, 2, args);
+}
+
 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 = {xt_string_bytes(s), s->length, 0};
-  return xt_json_parse_value(&cursor);
+  xt_value parsed = xt_json_parse_value(&cursor);
+  xt_value reviver = xt_arg_at(argc, argv, 1);
+  if (!XT_IS_FUNCTION(reviver)) return parsed;
+  xt_value holder = xt_object_new();
+  xt_object_set(holder, xt_string_from_cstr(""), parsed);
+  return xt_json_revive(holder, xt_string_from_cstr(""), reviver);
+}
+
+static void xt_json_stringify_value(xt_value value, xt_value indent, int depth, xt_value *out);
+
+/* The indentation unit for the `space` argument: up to 10 spaces for a
+ * number, or the first 10 UTF-16 code units of a string (any characters,
+ * not just spaces), matching JSON.stringify. An empty string means compact. */
+static xt_value xt_json_space_unit(xt_value space) {
+  if (XT_IS_NUMBER(space)) {
+    int count = xt_to_int32(space);
+    if (count < 0) count = 0;
+    if (count > 10) count = 10;
+    char spaces[10];
+    memset(spaces, ' ', (size_t)count);
+    return xt_string_new(spaces, (size_t)count);
+  }
+  if (XT_IS_STRING(space)) {
+    xt_string *s = xt_as_string(space);
+    const char *bytes = xt_string_bytes(s);
+    size_t offset = 0;
+    size_t end = 0;
+    uint32_t units = 0;
+    while (offset < s->length && units < 10) {
+      size_t width = 0;
+      uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+      units += code >= 0x10000 ? 2 : 1;
+      offset += width;
+      if (units <= 10) end = offset;
+    }
+    return xt_string_new(bytes, end);
+  }
+  return xt_string_from_cstr("");
 }
 
-static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_value *out);
+static int xt_json_indented(xt_value unit) {
+  return XT_IS_STRING(unit) && xt_as_string(unit)->length > 0;
+}
 
-static void xt_json_indent(xt_value *out, int indent, int depth) {
-  if (indent <= 0) return;
+static void xt_json_indent(xt_value *out, xt_value unit, int depth) {
+  if (!xt_json_indented(unit)) return;
   *out = xt_add(*out, xt_string_from_cstr("\n"));
-  for (int i = 0; i < indent * depth; i++) *out = xt_add(*out, xt_string_from_cstr(" "));
+  for (int i = 0; i < depth; i++) *out = xt_add(*out, unit);
 }
 
-static void xt_json_stringify_array(xt_value value, int indent, int depth, xt_value *out) {
+/* Containers on the current serialization path. A repeated pointer is a cycle;
+ * serializing it would recurse until the native stack overflowed (a hard crash,
+ * not the TypeError the platform throws). */
+static xt_value *xt_json_path = NULL;
+static uint32_t xt_json_path_count = 0;
+static uint32_t xt_json_path_capacity = 0;
+
+static void xt_json_enter(xt_value value) {
+  for (uint32_t i = 0; i < xt_json_path_count; i++) {
+    if (xt_json_path[i] == value) {
+      xt_value message = xt_string_from_cstr("Converting circular structure to JSON");
+      xt_throw(xt_type_error_ctor(1, &message));
+    }
+  }
+  if (xt_json_path_count >= xt_json_path_capacity) {
+    uint32_t capacity = xt_json_path_capacity == 0 ? 16 : xt_json_path_capacity * 2;
+    xt_value *path = (xt_value *)realloc(xt_json_path, sizeof(xt_value) * capacity);
+    if (!path) abort();
+    xt_json_path = path;
+    xt_json_path_capacity = capacity;
+  }
+  xt_json_path[xt_json_path_count++] = value;
+}
+
+static void xt_json_leave(void) {
+  if (xt_json_path_count > 0) xt_json_path_count--;
+}
+
+static void xt_json_stringify_array(xt_value value, xt_value indent, int depth, xt_value *out) {
   xt_array *array = xt_as_array(value);
   if (!array || array->length == 0) { *out = xt_add(*out, xt_string_from_cstr("[]")); return; }
   *out = xt_add(*out, xt_string_from_cstr("["));
+  xt_json_enter(value);
   for (uint32_t i = 0; i < array->length; i++) {
     if (i > 0) *out = xt_add(*out, xt_string_from_cstr(","));
     xt_json_indent(out, indent, depth + 1);
     xt_json_stringify_value(array->items[i], indent, depth + 1, out);
   }
   xt_json_indent(out, indent, depth);
+  xt_json_leave();
   *out = xt_add(*out, xt_string_from_cstr("]"));
 }
 
-static void xt_json_stringify_object(xt_value value, int indent, int depth, xt_value *out) {
+static void xt_json_stringify_object(xt_value value, xt_value indent, int depth, xt_value *out) {
   xt_value keys = xt_object_keys(value);
   xt_array *array = xt_as_array(keys);
   if (!array) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
   int any = 0;
   for (uint32_t i = 0; i < array->length; i++) {
-    xt_value item = xt_object_get(value, array->items[i]);
+    xt_value item = xt_get(value, array->items[i]);
     if (item != XT_UNDEFINED && !XT_IS_FUNCTION(item) && !xt_is_symbol(item)) { any = 1; break; }
   }
   if (!any) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
   *out = xt_add(*out, xt_string_from_cstr("{"));
+  xt_json_enter(value);
   int written = 0;
   for (uint32_t i = 0; i < array->length; i++) {
     xt_value key = array->items[i];
-    xt_value item = xt_object_get(value, key);
+    xt_value item = xt_get(value, key);
     /* `undefined`, functions and symbols are omitted from objects. */
     if (item == XT_UNDEFINED || XT_IS_FUNCTION(item) || xt_is_symbol(item)) continue;
     if (written > 0) *out = xt_add(*out, xt_string_from_cstr(","));
@@ -168,20 +287,21 @@ static void xt_json_stringify_object(xt_value value, int indent, int depth, xt_v
     *out = xt_add(*out, xt_string_from_cstr("\""));
     *out = xt_add(*out, key);
     *out = xt_add(*out, xt_string_from_cstr("\":"));
-    if (indent > 0) *out = xt_add(*out, xt_string_from_cstr(" "));
+    if (xt_json_indented(indent)) *out = xt_add(*out, xt_string_from_cstr(" "));
     xt_json_stringify_value(item, indent, depth + 1, out);
   }
   xt_json_indent(out, indent, depth);
+  xt_json_leave();
   *out = xt_add(*out, xt_string_from_cstr("}"));
 }
 
-static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_value *out) {
+static void xt_json_stringify_value(xt_value value, xt_value indent, int depth, xt_value *out) {
   if (value == XT_UNDEFINED || value == XT_NULL || XT_IS_FUNCTION(value) || xt_is_symbol(value)) {
     *out = xt_add(*out, xt_string_from_cstr("null"));
     return;
   }
   if (XT_IS_BIGINT(value)) {
-    xt_throw(xt_string_from_cstr("TypeError: Do not know how to serialize a BigInt"));
+    xt_throw(xt_error_from_message("TypeError: Do not know how to serialize a BigInt"));
     return;
   }
   if (XT_IS_BOOL(value)) { *out = xt_add(*out, value == XT_TRUE ? xt_string_from_cstr("true") : xt_string_from_cstr("false")); return; }
@@ -195,32 +315,232 @@ static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_va
     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 = 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"));
-      else if (ch == '\r') *out = xt_add(*out, xt_string_from_cstr("\\r"));
-      else if (ch == '\t') *out = xt_add(*out, xt_string_from_cstr("\\t"));
-      else *out = xt_add(*out, xt_string_new(&ch, 1));
+    size_t offset = 0;
+    while (offset < s->length) {
+      size_t width = 0;
+      uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+      const char *escape = NULL;
+      char buffer[8];
+      if (code == '"') escape = "\\\"";
+      else if (code == '\\') escape = "\\\\";
+      else if (code == '\b') escape = "\\b";
+      else if (code == '\f') escape = "\\f";
+      else if (code == '\n') escape = "\\n";
+      else if (code == '\r') escape = "\\r";
+      else if (code == '\t') escape = "\\t";
+      else if (code < 0x20 || (code >= 0xD800 && code <= 0xDFFF)) {
+        snprintf(buffer, sizeof(buffer), "\\u%04x", (unsigned)code);
+        escape = buffer;
+      }
+      if (escape) *out = xt_add(*out, xt_string_from_cstr(escape));
+      else *out = xt_add(*out, xt_string_new(bytes + offset, width));
+      offset += width;
     }
     *out = xt_add(*out, xt_string_from_cstr("\""));
     return;
   }
   if (XT_IS_ARRAY(value)) { xt_json_stringify_array(value, indent, depth, out); return; }
-  if (XT_IS_OBJECT(value)) { xt_json_stringify_object(value, indent, depth, out); return; }
+  if (XT_IS_OBJECT(value)) {
+    /* Map/Set/Date/RegExp/Promise/generators are not property-bag objects;
+     * handing them to xt_json_stringify_object reads their fields as a property
+     * table and crashed with an access violation. JSON sees no enumerable own
+     * properties on the first group and calls Date.prototype.toJSON. */
+    xt_object *object = (xt_object *)XT_GET_PTR(value);
+    switch (object->header.kind) {
+      case XT_OBJECT_KIND_MAP:
+      case XT_OBJECT_KIND_SET:
+      case XT_OBJECT_KIND_REGEXP:
+      case XT_OBJECT_KIND_PROMISE:
+      case XT_OBJECT_KIND_GENERATOR:
+      case XT_OBJECT_KIND_ITERATOR:
+      case XT_OBJECT_KIND_ASYNC:
+        *out = xt_add(*out, xt_string_from_cstr("{}"));
+        return;
+      case XT_OBJECT_KIND_DATE: {
+        xt_value time = xt_call_method(value, xt_string_from_cstr("getTime"), 0, NULL);
+        if (isnan(xt_to_number(time))) {
+          *out = xt_add(*out, xt_string_from_cstr("null"));
+          return;
+        }
+        xt_value text = xt_call_method(value, xt_string_from_cstr("toJSON"), 0, NULL);
+        xt_json_stringify_value(text, indent, depth, out);
+        return;
+      }
+      default:
+        break;
+    }
+    xt_json_stringify_object(value, indent, depth, out);
+    return;
+  }
   *out = xt_add(*out, xt_string_from_cstr("null"));
 }
 
+/* -- replacer-aware stringify -------------------------------------------- */
+/*
+ * The replacer overload needs the holder and key of every value, so it gets a
+ * separate walk instead of complicating the fast path. It also calls `toJSON`
+ * and filters object keys through an array replacer.
+ */
+typedef struct {
+  xt_value replacer;
+  xt_value indent;
+  xt_value *path;
+  uint32_t path_count;
+  uint32_t path_capacity;
+} xt_json_replacer_context;
+
+static void xt_json_replacer_enter(xt_json_replacer_context *ctx, xt_value value) {
+  for (uint32_t i = 0; i < ctx->path_count; i++) {
+    if (ctx->path[i] == value) {
+      xt_value message = xt_string_from_cstr("Converting circular structure to JSON");
+      xt_throw(xt_type_error_ctor(1, &message));
+    }
+  }
+  if (ctx->path_count >= ctx->path_capacity) {
+    uint32_t capacity = ctx->path_capacity == 0 ? 16 : ctx->path_capacity * 2;
+    xt_value *path = (xt_value *)realloc(ctx->path, sizeof(xt_value) * capacity);
+    if (!path) abort();
+    ctx->path = path;
+    ctx->path_capacity = capacity;
+  }
+  ctx->path[ctx->path_count++] = value;
+}
+
+static void xt_json_replacer_leave(xt_json_replacer_context *ctx) {
+  if (ctx->path_count > 0) ctx->path_count--;
+}
+
+static void xt_json_replacer_indent(xt_json_replacer_context *ctx, int depth, xt_value *out) {
+  xt_json_indent(out, ctx->indent, depth);
+}
+
+static int xt_json_replacer_allows(xt_value replacer, xt_value key) {
+  if (!XT_IS_ARRAY(replacer)) return 1;
+  xt_array *allowed = xt_as_array(replacer);
+  for (uint32_t i = 0; i < allowed->length; i++) {
+    xt_value item = allowed->items[i];
+    if (!XT_IS_STRING(item) && !XT_IS_NUMBER(item)) continue;
+    xt_value text = xt_to_string(item);
+    xt_string *a = xt_as_string(text);
+    xt_string *b = xt_as_string(key);
+    if (a && b && xt_string_equals(a, b)) return 1;
+  }
+  return 0;
+}
+
+static int xt_json_replacer_write(xt_json_replacer_context *ctx, xt_value holder, xt_value key,
+                                  int depth, xt_value *out);
+
+static int xt_json_replacer_container(xt_json_replacer_context *ctx, xt_value value, int depth,
+                                      xt_value *out) {
+  xt_json_replacer_enter(ctx, value);
+  if (XT_IS_ARRAY(value)) {
+    xt_array *array = xt_as_array(value);
+    *out = xt_add(*out, xt_string_from_cstr("["));
+    for (uint32_t i = 0; i < array->length; i++) {
+      if (i > 0) *out = xt_add(*out, xt_string_from_cstr(","));
+      xt_json_replacer_indent(ctx, depth + 1, out);
+      char keyBuffer[16];
+      snprintf(keyBuffer, sizeof(keyBuffer), "%u", i);
+      xt_value temporary = xt_string_from_cstr("");
+      int wrote = xt_json_replacer_write(ctx, value, xt_string_from_cstr(keyBuffer), depth + 1,
+                                         &temporary);
+      *out = xt_add(*out, wrote ? temporary : xt_string_from_cstr("null"));
+    }
+    xt_json_replacer_indent(ctx, depth, out);
+    xt_json_replacer_leave(ctx);
+    *out = xt_add(*out, xt_string_from_cstr("]"));
+    return 1;
+  }
+
+  xt_value keys = xt_object_keys(value);
+  xt_array *list = xt_as_array(keys);
+  *out = xt_add(*out, xt_string_from_cstr("{"));
+  int written = 0;
+  if (list) {
+    for (uint32_t i = 0; i < list->length; i++) {
+      xt_value childKey = list->items[i];
+      if (!xt_json_replacer_allows(ctx->replacer, childKey)) continue;
+      xt_value temporary = xt_string_from_cstr("");
+      int wrote = xt_json_replacer_write(ctx, value, childKey, depth + 1, &temporary);
+      if (!wrote) continue;
+      if (written > 0) *out = xt_add(*out, xt_string_from_cstr(","));
+      written++;
+      xt_json_replacer_indent(ctx, depth + 1, out);
+      *out = xt_add(*out, xt_string_from_cstr("\""));
+      *out = xt_add(*out, childKey);
+      *out = xt_add(*out, xt_string_from_cstr("\":"));
+      if (xt_json_indented(ctx->indent)) *out = xt_add(*out, xt_string_from_cstr(" "));
+      *out = xt_add(*out, temporary);
+    }
+  }
+  xt_json_replacer_indent(ctx, depth, out);
+  xt_json_replacer_leave(ctx);
+  *out = xt_add(*out, xt_string_from_cstr("}"));
+  return 1;
+}
+
+static int xt_json_replacer_write(xt_json_replacer_context *ctx, xt_value holder, xt_value key,
+                                  int depth, xt_value *out) {
+  xt_value value = xt_get(holder, key);
+  if (XT_IS_FUNCTION(ctx->replacer)) {
+    xt_value args[2] = {key, value};
+    value = xt_call_with_this(ctx->replacer, holder, 2, args);
+  }
+  if (xt_is_date(value)) {
+    value = xt_call_method(value, xt_string_from_cstr("toJSON"), 1, &key);
+  } else if (XT_IS_ARRAY(value) ||
+             (XT_IS_OBJECT(value) &&
+              (((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_OBJECT ||
+               ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_ERROR))) {
+    xt_value toJSON = XT_IS_ARRAY(value) ? xt_get(value, xt_string_from_cstr("toJSON"))
+                                         : xt_object_get(value, xt_string_from_cstr("toJSON"));
+    if (XT_IS_FUNCTION(toJSON)) {
+      xt_value args[1] = {key};
+      value = xt_call_with_this(toJSON, value, 1, args);
+    }
+  }
+  if (value == XT_UNDEFINED || XT_IS_FUNCTION(value) || xt_is_symbol(value)) return 0;
+  if (XT_IS_BIGINT(value)) {
+    xt_value message = xt_string_from_cstr("Do not know how to serialize a BigInt");
+    xt_throw(xt_type_error_ctor(1, &message));
+  }
+  if (XT_IS_ARRAY(value)) return xt_json_replacer_container(ctx, value, depth, out);
+  if (XT_IS_OBJECT(value)) {
+    int kind = ((xt_object *)XT_GET_PTR(value))->header.kind;
+    if (kind == XT_OBJECT_KIND_MAP || kind == XT_OBJECT_KIND_SET ||
+        kind == XT_OBJECT_KIND_REGEXP || kind == XT_OBJECT_KIND_PROMISE ||
+        kind == XT_OBJECT_KIND_GENERATOR || kind == XT_OBJECT_KIND_ITERATOR ||
+        kind == XT_OBJECT_KIND_ASYNC) {
+      *out = xt_add(*out, xt_string_from_cstr("{}"));
+      return 1;
+    }
+    return xt_json_replacer_container(ctx, value, depth, out);
+  }
+  xt_json_stringify_value(value, ctx->indent, depth, out);
+  return 1;
+}
+
 xt_value xt_json_stringify(int32_t argc, xt_value *argv) {
-  int indent = 0;
-  xt_value space = xt_arg_at(argc, argv, 1);
-  if (XT_IS_NUMBER(space)) indent = xt_to_int32(space);
-  else if (XT_IS_STRING(space)) indent = (int)((xt_string *)XT_GET_PTR(space))->length;
-  if (indent < 0) indent = 0;
-  if (indent > 10) indent = 10;
   xt_value value = xt_arg_at(argc, argv, 0);
   if (value == XT_UNDEFINED || XT_IS_FUNCTION(value) || xt_is_symbol(value)) return XT_UNDEFINED;
+  /* Signature: stringify(value, replacer, space). The replacer is argv[1] and
+   * the indentation is argv[2]; reading argv[1] as `space` silently ignored
+   * `JSON.stringify(value, null, 2)`. */
+  xt_value indent = xt_json_space_unit(xt_arg_at(argc, argv, 2));
+  xt_value replacer = xt_arg_at(argc, argv, 1);
+  if (XT_IS_FUNCTION(replacer) || XT_IS_ARRAY(replacer)) {
+    xt_json_replacer_context context = {replacer, indent, NULL, 0, 0};
+    xt_value wrapper = xt_object_new();
+    xt_object_set(wrapper, xt_string_from_cstr(""), value);
+    xt_value out = xt_string_from_cstr("");
+    int wrote = xt_json_replacer_write(&context, wrapper, xt_string_from_cstr(""), 0, &out);
+    free(context.path);
+    return wrote ? out : XT_UNDEFINED;
+  }
+  /* A caught circular-structure error longjmps past xt_json_leave; start every
+   * top-level serialization with a clean path. */
+  xt_json_path_count = 0;
   xt_value out = xt_string_from_cstr("");
   xt_json_stringify_value(value, indent, 0, &out);
   return out;

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

@@ -41,24 +41,33 @@ xt_value xt_number_static(xt_value name, int32_t argc, xt_value *argv) {
 xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
-  if (strcmp(fn, "fromCharCode") == 0 || strcmp(fn, "fromCodePoint") == 0) {
-    xt_string *out = xt_string_alloc((size_t)argc * 4 + 1);
-    char *mutable = xt_string_mutable(out);
+  if (strcmp(fn, "fromCharCode") == 0) {
+    /* `fromCharCode` takes UTF-16 code units (modulo 65536) and joins adjacent
+     * high/low surrogates into one code point, like JavaScript. */
+    if (argc <= 0) return xt_string_from_cstr("");
+    uint16_t *units = (uint16_t *)malloc(sizeof(uint16_t) * (size_t)argc);
+    if (!units) abort();
+    for (int32_t i = 0; i < argc; i++) units[i] = (uint16_t)(xt_to_int32(argv[i]) & 0xFFFF);
+    xt_value result = xt_string_from_units(units, (size_t)argc);
+    free(units);
+    return result;
+  }
+  if (strcmp(fn, "fromCodePoint") == 0) {
+    char *out = (char *)malloc((size_t)argc * 4 + 1);
+    if (!out) abort();
     size_t length = 0;
     for (int32_t i = 0; i < argc; i++) {
-      unsigned code = (unsigned)xt_to_int32(argv[i]);
-      char buffer[4];
-      int bytes = 0;
-      if (code < 0x80) buffer[bytes++] = (char)code;
-      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(mutable + length, buffer, (size_t)bytes);
-      length += (size_t)bytes;
+      int32_t code = xt_to_int32(argv[i]);
+      if (code < 0 || code > 0x10FFFF) {
+        free(out);
+        xt_throw(xt_error_from_message("RangeError: Invalid code point"));
+        return XT_UNDEFINED;
+      }
+      length += xt_utf8_encode((uint32_t)code, out + length);
     }
-    mutable[length] = '\0';
-    out->length = (uint32_t)length;
-    return XT_FROM_PTR(XT_TAG_STRING, out);
+    xt_value result = xt_string_new(out, length);
+    free(out);
+    return result;
   }
   if (strcmp(fn, "raw") == 0) {
     xt_value strings = xt_arg_at(argc, argv, 0);