xbintsc 0.5.6 → 0.5.21

package/runtime/xt_stdlib2/date.inc

@@ -4,11 +4,111 @@ int xt_is_date(xt_value value) {
   return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_DATE;
 }
 
+/* Parse `YYYY-MM-DD`, optionally followed by `T`/space and
+ * `HH:MM[:SS[.mmm]]`, then `Z`, `+HH:MM`/`-HH:MM` (or the HHMM spelling).
+ * A date-only value is UTC; a date-time without an offset is local time, which
+ * is what ECMAScript specifies. Returns milliseconds since the epoch, or NaN
+ * for anything outside this subset. */
+static int xt_date_digits(const char *text, int count, int *out) {
+  int value = 0;
+  for (int i = 0; i < count; i++) {
+    if (text[i] < '0' || text[i] > '9') return 0;
+    value = value * 10 + (text[i] - '0');
+  }
+  *out = value;
+  return 1;
+}
+
+static double xt_date_parse_text(const char *text) {
+  size_t length = strlen(text);
+  size_t i = 0;
+  int year = 0, month = 0, day = 0;
+  if (length < 10 || !xt_date_digits(text, 4, &year) || text[4] != '-' ||
+      !xt_date_digits(text + 5, 2, &month) || text[7] != '-' ||
+      !xt_date_digits(text + 8, 2, &day)) {
+    return NAN;
+  }
+  i = 10;
+  int hour = 0, minute = 0, second = 0, millis = 0;
+  int hasTime = 0;
+  if (i < length && (text[i] == 'T' || text[i] == ' ')) {
+    hasTime = 1;
+    i++;
+    if (i + 5 > length || !xt_date_digits(text + i, 2, &hour) || text[i + 2] != ':' ||
+        !xt_date_digits(text + i + 3, 2, &minute)) {
+      return NAN;
+    }
+    i += 5;
+    if (i + 3 <= length && text[i] == ':') {
+      if (!xt_date_digits(text + i + 1, 2, &second)) return NAN;
+      i += 3;
+    }
+    if (i + 4 <= length && text[i] == '.') {
+      if (!xt_date_digits(text + i + 1, 3, &millis)) return NAN;
+      i += 4;
+    }
+  }
+  int utc = !hasTime;
+  int offsetSeconds = 0;
+  if (i < length) {
+    if (text[i] == 'Z') {
+      utc = 1;
+      i++;
+    } else if (text[i] == '+' || text[i] == '-') {
+      int sign = text[i] == '-' ? -1 : 1;
+      i++;
+      int offsetHour = 0, offsetMinute = 0;
+      if (i + 5 <= length && xt_date_digits(text + i, 2, &offsetHour) && text[i + 2] == ':' &&
+          xt_date_digits(text + i + 3, 2, &offsetMinute)) {
+        i += 5;
+      } else if (i + 4 <= length && xt_date_digits(text + i, 2, &offsetHour) &&
+                 xt_date_digits(text + i + 2, 2, &offsetMinute)) {
+        i += 4;
+      } else {
+        return NAN;
+      }
+      if (offsetHour > 23 || offsetMinute > 59) return NAN;
+      offsetSeconds = sign * (offsetHour * 3600 + offsetMinute * 60);
+      utc = 1;
+    } else {
+      return NAN;
+    }
+  }
+  if (i != length) return NAN;
+  if (month < 1 || month > 12 || day < 1 || day > 31 ||
+      hour > 23 || minute > 59 || second > 59) {
+    return NAN;
+  }
+  struct tm tm;
+  memset(&tm, 0, sizeof(tm));
+  tm.tm_year = year - 1900;
+  tm.tm_mon = month - 1;
+  tm.tm_mday = day;
+  tm.tm_hour = hour;
+  tm.tm_min = minute;
+  tm.tm_sec = second;
+  time_t seconds;
+  if (utc) {
+    seconds = xt_timegm(&tm);
+  } else {
+    tm.tm_isdst = -1;
+    seconds = mktime(&tm);
+    if (seconds == (time_t)-1) return NAN;
+  }
+  if (utc && offsetSeconds != 0) seconds -= offsetSeconds;
+  return (double)seconds * 1000.0 + (double)millis;
+}
+
 xt_value xt_date_ctor(int32_t argc, xt_value *argv) {
   xt_date *date = (xt_date *)xt_alloc(sizeof(xt_date), XT_OBJECT_KIND_DATE);
   if (argc == 0) date->time = (double)time(NULL) * 1000.0;
-  else if (argc == 1) date->time = XT_IS_STRING(argv[0]) ? 0.0 : xt_to_number(argv[0]);
-  else {
+  else if (argc == 1) {
+    if (XT_IS_STRING(argv[0])) {
+      date->time = xt_date_parse_text(xt_string_data(argv[0]));
+    } else {
+      date->time = xt_to_number(argv[0]);
+    }
+  } else {
     struct tm tm;
     memset(&tm, 0, sizeof(tm));
     tm.tm_year = xt_to_int32(argv[0]) - 1900;
@@ -27,7 +127,11 @@ xt_value xt_date_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, "now") == 0) return xt_number((double)time(NULL) * 1000.0);
-  if (strcmp(fn, "parse") == 0) return xt_number(0);
+  if (strcmp(fn, "parse") == 0) {
+    xt_value input = xt_arg_at(argc, argv, 0);
+    if (!XT_IS_STRING(input)) return xt_number(NAN);
+    return xt_number(xt_date_parse_text(xt_string_data(input)));
+  }
   if (strcmp(fn, "UTC") == 0) {
     struct tm tm;
     memset(&tm, 0, sizeof(tm));
@@ -68,6 +172,10 @@ static xt_value xt_date_method(xt_value target, const char *method, int32_t argc
   if (strcmp(name, "getSeconds") == 0) return xt_number(tm.tm_sec);
   if (strcmp(name, "getMilliseconds") == 0) return xt_number(fmod(date->time, 1000.0));
   if (strcmp(method, "toISOString") == 0) {
+    if (isnan(date->time)) {
+      xt_value message = xt_string_from_cstr("Invalid time value");
+      xt_throw(xt_range_error_ctor(1, &message));
+    }
     char buffer[64];
     snprintf(buffer, sizeof(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", tm.tm_year + 1900, tm.tm_mon + 1,
              tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, (int)fmod(date->time, 1000.0));

package/runtime/xt_stdlib2/error.inc

@@ -112,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"));

package/runtime/xt_stdlib2/json.inc

@@ -133,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, int indent, int depth, xt_value *out);
+static void xt_json_stringify_value(xt_value value, xt_value indent, int depth, xt_value *out);
 
-static void xt_json_indent(xt_value *out, int indent, int depth) {
-  if (indent <= 0) return;
+/* 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 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, 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);
+}
+
+/* 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, int indent, int depth, xt_value *out) {
+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(","));
@@ -185,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; }
@@ -237,19 +340,207 @@ static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_va
     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_utf16_length((xt_string *)XT_GET_PTR(space));
-  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

@@ -60,7 +60,7 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
       int32_t code = xt_to_int32(argv[i]);
       if (code < 0 || code > 0x10FFFF) {
         free(out);
-        xt_throw(xt_string_from_cstr("RangeError: Invalid code point"));
+        xt_throw(xt_error_from_message("RangeError: Invalid code point"));
         return XT_UNDEFINED;
       }
       length += xt_utf8_encode((uint32_t)code, out + length);