xbintsc 0.5.6 → 0.5.20

package/runtime/xt_url.c

@@ -0,0 +1,375 @@
+/*
+ * xbintsc runtime — URLSearchParams.
+ *
+ * The query string is stored as an array of [key, value] pairs under an
+ * internal `__entries` property. Methods are closures on the instance, so the
+ * same object model as the rest of the runtime applies. Values are stored
+ * decoded and encoded with application/x-www-form-urlencoded rules when
+ * serialized (`+` for spaces, percent escapes for everything else).
+ */
+
+#include "rt_internal.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int xt_url_unreserved(unsigned char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
+         c == '*' || c == '-' || c == '.' || c == '_';
+}
+
+static xt_value xt_url_encode(xt_value value) {
+  xt_value text = xt_to_string(value);
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  size_t capacity = string->length * 3 + 1;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t written = 0;
+  for (uint32_t i = 0; i < string->length; i++) {
+    unsigned char c = (unsigned char)bytes[i];
+    if (c == ' ') {
+      out[written++] = '+';
+    } else if (xt_url_unreserved(c)) {
+      out[written++] = (char)c;
+    } else {
+      static const char hex[] = "0123456789ABCDEF";
+      out[written++] = '%';
+      out[written++] = hex[c >> 4];
+      out[written++] = hex[c & 0x0f];
+    }
+  }
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+static int xt_url_hex(char c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+static xt_value xt_url_decode(const char *data, size_t length) {
+  char *out = (char *)malloc(length == 0 ? 1 : length);
+  if (!out) abort();
+  size_t written = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = data[i];
+    if (c == '+') {
+      out[written++] = ' ';
+    } else if (c == '%' && i + 2 < length) {
+      int high = xt_url_hex(data[i + 1]);
+      int low = xt_url_hex(data[i + 2]);
+      if (high >= 0 && low >= 0) {
+        out[written++] = (char)((high << 4) | low);
+        i += 2;
+      } else {
+        out[written++] = c;
+      }
+    } else {
+      out[written++] = c;
+    }
+  }
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+static xt_value xt_url_entries(xt_value params) {
+  xt_value entries = xt_get(params, xt_string_from_cstr("__entries"));
+  if (!XT_IS_ARRAY(entries)) {
+    entries = xt_array_new(0, NULL);
+    xt_object_set(params, xt_string_from_cstr("__entries"), entries);
+  }
+  return entries;
+}
+
+static void xt_url_set_size(xt_value params) {
+  xt_array *entries = xt_as_array(xt_url_entries(params));
+  xt_object_set(params, xt_string_from_cstr("size"), xt_number((double)entries->length));
+}
+
+static void xt_url_append_pair(xt_value entries, xt_value key, xt_value value) {
+  xt_value pair = xt_array_new(0, NULL);
+  xt_array_push(pair, key);
+  xt_array_push(pair, value);
+  xt_array_push(entries, pair);
+}
+
+static xt_value xt_url_string_at(xt_value text, size_t start, size_t length) {
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  return xt_string_new(bytes + start, length);
+}
+
+/* Split a query string on `&`, then each item on the first `=`; decode both
+ * halves and append them. A leading `?` is ignored. */
+static void xt_url_parse_into(xt_value params, xt_value input) {
+  xt_value text = xt_to_string(input);
+  xt_string *string = xt_as_string(text);
+  const char *bytes = xt_string_bytes(string);
+  size_t length = string->length;
+  size_t start = (length > 0 && bytes[0] == '?') ? 1 : 0;
+  xt_value entries = xt_url_entries(params);
+  while (start <= length) {
+    size_t end = start;
+    while (end < length && bytes[end] != '&') end++;
+    if (end > start) {
+      size_t equals = start;
+      while (equals < end && bytes[equals] != '=') equals++;
+      xt_value key = xt_url_decode(bytes + start, equals - start);
+      xt_value value = equals < end ? xt_url_decode(bytes + equals + 1, end - equals - 1)
+                                    : xt_string_from_cstr("");
+      xt_url_append_pair(entries, key, value);
+    }
+    if (end >= length) break;
+    start = end + 1;
+  }
+  xt_url_set_size(params);
+}
+
+static void xt_url_ctor_from_value(xt_value params, xt_value source) {
+  if (source == XT_UNDEFINED) return;
+  if (XT_IS_STRING(source)) {
+    xt_url_parse_into(params, source);
+    return;
+  }
+  if (XT_IS_ARRAY(source)) {
+    xt_value entries = xt_url_entries(params);
+    xt_array *pairs = xt_as_array(source);
+    for (uint32_t i = 0; i < pairs->length; i++) {
+      xt_array *pair = xt_as_array(pairs->items[i]);
+      if (pair && pair->length >= 1) {
+        xt_value value = pair->length >= 2 ? pair->items[1] : xt_string_from_cstr("");
+        xt_url_append_pair(entries, xt_to_string(pair->items[0]), xt_to_string(value));
+      }
+    }
+    xt_url_set_size(params);
+    return;
+  }
+  if (XT_IS_OBJECT(source)) {
+    xt_value existing = xt_get(source, xt_string_from_cstr("__entries"));
+    if (XT_IS_ARRAY(existing)) {
+      xt_value entries = xt_url_entries(params);
+      xt_array *pairs = xt_as_array(existing);
+      for (uint32_t i = 0; i < pairs->length; i++) {
+        xt_array *pair = xt_as_array(pairs->items[i]);
+        if (pair && pair->length >= 2) xt_url_append_pair(entries, pair->items[0], pair->items[1]);
+      }
+      xt_url_set_size(params);
+      return;
+    }
+    xt_value keys = xt_object_keys(source);
+    xt_array *list = xt_as_array(keys);
+    if (!list) return;
+    xt_value entries = xt_url_entries(params);
+    for (uint32_t i = 0; i < list->length; i++) {
+      xt_value key = list->items[i];
+      xt_url_append_pair(entries, xt_to_string(key), xt_to_string(xt_object_get(source, key)));
+    }
+    xt_url_set_size(params);
+  }
+}
+
+/* -- methods -------------------------------------------------------------- */
+
+static xt_value xt_url_method_append(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value entries = xt_url_entries(thisValue);
+  xt_url_append_pair(entries, xt_to_string(xt_arg_at(argc, argv, 0)),
+                     xt_to_string(xt_arg_at(argc, argv, 1)));
+  xt_url_set_size(thisValue);
+  return XT_UNDEFINED;
+}
+
+static int xt_url_key_equals(xt_value pair, xt_value key) {
+  xt_array *items = xt_as_array(pair);
+  return items && items->length >= 2 && xt_value_equals(items->items[0], key);
+}
+
+static xt_value xt_url_method_get(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) {
+    if (xt_url_key_equals(entries->items[i], key)) return ((xt_array *)XT_GET_PTR(entries->items[i]))->items[1];
+  }
+  return XT_NULL;
+}
+
+static xt_value xt_url_method_get_all(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value result = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < entries->length; i++) {
+    if (xt_url_key_equals(entries->items[i], key)) {
+      xt_array_push(result, ((xt_array *)XT_GET_PTR(entries->items[i]))->items[1]);
+    }
+  }
+  return result;
+}
+
+static xt_value xt_url_method_has(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) {
+    if (xt_url_key_equals(entries->items[i], key)) return XT_TRUE;
+  }
+  return XT_FALSE;
+}
+
+static xt_value xt_url_method_delete(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  uint32_t write = 0;
+  for (uint32_t read = 0; read < entries->length; read++) {
+    if (!xt_url_key_equals(entries->items[read], key)) entries->items[write++] = entries->items[read];
+  }
+  entries->length = write;
+  xt_url_set_size(thisValue);
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_set(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value key = xt_to_string(xt_arg_at(argc, argv, 0));
+  xt_value value = xt_to_string(xt_arg_at(argc, argv, 1));
+  xt_value entriesValue = xt_url_entries(thisValue);
+  xt_array *entries = xt_as_array(entriesValue);
+  uint32_t write = 0;
+  int replaced = 0;
+  for (uint32_t read = 0; read < entries->length; read++) {
+    if (xt_url_key_equals(entries->items[read], key)) {
+      if (!replaced) {
+        ((xt_array *)XT_GET_PTR(entries->items[read]))->items[1] = value;
+        entries->items[write++] = entries->items[read];
+        replaced = 1;
+      }
+      continue;
+    }
+    entries->items[write++] = entries->items[read];
+  }
+  entries->length = write;
+  if (!replaced) xt_url_append_pair(entriesValue, key, value);
+  xt_url_set_size(thisValue);
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_sort(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 1; i < entries->length; i++) {
+    xt_value current = entries->items[i];
+    xt_array *currentPair = xt_as_array(current);
+    uint32_t j = i;
+    while (j > 0) {
+      xt_array *previousPair = xt_as_array(entries->items[j - 1]);
+      if (strcmp(xt_string_bytes(xt_as_string(previousPair->items[0])),
+                 xt_string_bytes(xt_as_string(currentPair->items[0]))) <= 0)
+        break;
+      entries->items[j] = entries->items[j - 1];
+      j--;
+    }
+    entries->items[j] = current;
+  }
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_to_string(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value out = xt_string_from_cstr("");
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (!pair || pair->length < 2) continue;
+    if (i > 0) out = xt_add(out, xt_string_from_cstr("&"));
+    out = xt_add(out, xt_url_encode(pair->items[0]));
+    out = xt_add(out, xt_string_from_cstr("="));
+    out = xt_add(out, xt_url_encode(pair->items[1]));
+  }
+  return out;
+}
+
+static xt_value xt_url_method_for_each(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) return XT_UNDEFINED;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (!pair || pair->length < 2) continue;
+    xt_value args[3] = {pair->items[1], pair->items[0], thisValue};
+    xt_closure_call(callback, 3, args);
+  }
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_url_method_keys(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value result = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (pair && pair->length >= 1) xt_array_push(result, pair->items[0]);
+  }
+  return result;
+}
+
+static xt_value xt_url_method_values(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  xt_value result = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < entries->length; i++) {
+    xt_array *pair = xt_as_array(entries->items[i]);
+    if (pair && pair->length >= 2) xt_array_push(result, pair->items[1]);
+  }
+  return result;
+}
+
+static xt_value xt_url_method_entries(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value result = xt_array_new(0, NULL);
+  xt_array *entries = xt_as_array(xt_url_entries(thisValue));
+  for (uint32_t i = 0; i < entries->length; i++) xt_array_push(result, entries->items[i]);
+  return result;
+}
+
+static void xt_url_install(xt_value params, const char *name, void *fn) {
+  xt_object_set(params, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+xt_value xt_url_search_params_ctor(int32_t argc, xt_value *argv) {
+  xt_value params = xt_object_new();
+  xt_object_set(params, xt_string_from_cstr("__entries"), xt_array_new(0, NULL));
+  xt_object_set(params, xt_string_from_cstr("size"), xt_number(0));
+  xt_url_install(params, "append", (void *)xt_url_method_append);
+  xt_url_install(params, "delete", (void *)xt_url_method_delete);
+  xt_url_install(params, "get", (void *)xt_url_method_get);
+  xt_url_install(params, "getAll", (void *)xt_url_method_get_all);
+  xt_url_install(params, "has", (void *)xt_url_method_has);
+  xt_url_install(params, "set", (void *)xt_url_method_set);
+  xt_url_install(params, "sort", (void *)xt_url_method_sort);
+  xt_url_install(params, "toString", (void *)xt_url_method_to_string);
+  xt_url_install(params, "forEach", (void *)xt_url_method_for_each);
+  xt_url_install(params, "keys", (void *)xt_url_method_keys);
+  xt_url_install(params, "values", (void *)xt_url_method_values);
+  xt_url_install(params, "entries", (void *)xt_url_method_entries);
+  xt_url_ctor_from_value(params, xt_arg_at(argc, argv, 0));
+  return params;
+}

package/runtime/xt_values/arithmetic.inc

@@ -3,7 +3,7 @@
 /* ------------------------------------------------------------------------- */
 
 static void xt_throw_mixed_bigint(void) {
-  xt_throw(xt_string_from_cstr("TypeError: Cannot mix BigInt and other types, use explicit conversions"));
+  xt_throw(xt_error_from_message("TypeError: Cannot mix BigInt and other types, use explicit conversions"));
 }
 
 /* ToPrimitive for the operators: arrays/objects/functions stringify (their
@@ -143,7 +143,7 @@ xt_value xt_shr(xt_value a, xt_value b) {
 
 xt_value xt_ushr(xt_value a, xt_value b) {
   if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
-    xt_throw(xt_string_from_cstr("TypeError: BigInts have no unsigned right shift, use >> instead"));
+    xt_throw(xt_error_from_message("TypeError: BigInts have no unsigned right shift, use >> instead"));
     return XT_UNDEFINED;
   }
   return xt_number((double)(uint32_t)((uint32_t)xt_to_int32(a) >> (xt_to_int32(b) & 31)));

package/runtime/xt_values/conversions.inc

@@ -94,7 +94,7 @@ xt_value xt_to_string(xt_value v) {
   }
   if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function () { [native code] }");
   if (xt_is_symbol(v)) {
-    xt_throw(xt_string_from_cstr("TypeError: Cannot convert a Symbol value to a string"));
+    xt_throw(xt_error_from_message("TypeError: Cannot convert a Symbol value to a string"));
   }
   if (XT_IS_OBJECT(v) &&
       ((xt_object *)XT_GET_PTR(v))->header.kind == XT_OBJECT_KIND_ERROR) {

package/runtime/xt_weak.c

@@ -0,0 +1,281 @@
+/*
+ * xbintsc runtime — weak collections.
+ *
+ * `WeakMap`, `WeakSet` and `WeakRef` are the only values whose references the
+ * mark-sweep collector must *not* follow unconditionally. Their keys (and the
+ * target of a WeakRef) are excluded from the ordinary trace; instead the
+ * collector runs an ephemeron fixed point after marking:
+ *
+ *     repeat
+ *       for every live WeakMap entry whose key is marked:
+ *         mark the value
+ *     until nothing new is marked
+ *
+ * A value is therefore retained only while its key is otherwise reachable, and
+ * a key/value cycle that is only reachable through the WeakMap is collected.
+ * WeakRef targets that stay unmarked after that fixed point are cleared.
+ *
+ * WeakMap/WeakSet entries are removed at sweep time, so a later `has()` never
+ * observes a key whose object has been collected.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static int xt_is_weak_target(xt_value value) {
+  return XT_IS_OBJECT(value) || XT_IS_ARRAY(value) || XT_IS_FUNCTION(value);
+}
+
+static void xt_weak_key_error(void) {
+  xt_throw(xt_error_from_message("TypeError: Invalid value used as weak map key"));
+}
+
+int xt_is_weak_map(xt_value value) {
+  return XT_IS_OBJECT(value) &&
+         ((xt_header *)XT_GET_PTR(value))->kind == XT_OBJECT_KIND_WEAK_MAP;
+}
+
+int xt_is_weak_set(xt_value value) {
+  return XT_IS_OBJECT(value) &&
+         ((xt_header *)XT_GET_PTR(value))->kind == XT_OBJECT_KIND_WEAK_SET;
+}
+
+int xt_is_weak_ref(xt_value value) {
+  return XT_IS_OBJECT(value) &&
+         ((xt_header *)XT_GET_PTR(value))->kind == XT_OBJECT_KIND_WEAK_REF;
+}
+
+/* -- WeakMap -------------------------------------------------------------- */
+
+static int32_t xt_weak_map_index(xt_weak_map *map, xt_value key) {
+  for (uint32_t i = 0; i < map->count; i++) {
+    if (xt_value_equals(map->keys[i], key)) return (int32_t)i;
+  }
+  return -1;
+}
+
+static void xt_weak_map_set(xt_weak_map *map, xt_value key, xt_value value) {
+  int32_t index = xt_weak_map_index(map, key);
+  if (index >= 0) {
+    map->values[index] = value;
+    return;
+  }
+  if (map->count >= map->capacity) {
+    uint32_t capacity = map->capacity == 0 ? 8 : map->capacity * 2;
+    map->keys = (xt_value *)realloc(map->keys, sizeof(xt_value) * capacity);
+    map->values = (xt_value *)realloc(map->values, sizeof(xt_value) * capacity);
+    if (!map->keys || !map->values) abort();
+    map->capacity = capacity;
+  }
+  map->keys[map->count] = key;
+  map->values[map->count] = value;
+  map->count++;
+}
+
+static int xt_weak_map_delete(xt_weak_map *map, xt_value key) {
+  int32_t index = xt_weak_map_index(map, key);
+  if (index < 0) return 0;
+  for (uint32_t i = (uint32_t)index + 1; i < map->count; i++) {
+    map->keys[i - 1] = map->keys[i];
+    map->values[i - 1] = map->values[i];
+  }
+  map->count--;
+  return 1;
+}
+
+xt_value xt_weak_map_ctor(int32_t argc, xt_value *argv) {
+  xt_weak_map *map = (xt_weak_map *)xt_alloc(sizeof(xt_weak_map), XT_OBJECT_KIND_WEAK_MAP);
+  map->keys = NULL;
+  map->values = NULL;
+  map->count = 0;
+  map->capacity = 0;
+  xt_value iterable = xt_arg_at(argc, argv, 0);
+  if (XT_IS_ARRAY(iterable)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(iterable);
+    for (uint32_t i = 0; i < array->length; i++) {
+      xt_array *pair = xt_as_array(array->items[i]);
+      if (!pair || pair->length < 2) {
+        xt_throw(xt_error_from_message("TypeError: Iterator value is not an entry object"));
+        return XT_UNDEFINED;
+      }
+      if (!xt_is_weak_target(pair->items[0])) {
+        xt_weak_key_error();
+        return XT_UNDEFINED;
+      }
+      xt_weak_map_set(map, pair->items[0], pair->items[1]);
+    }
+  }
+  return XT_FROM_PTR(XT_TAG_OBJECT, map);
+}
+
+/* -- WeakSet -------------------------------------------------------------- */
+
+static int32_t xt_weak_set_index(xt_weak_set *set, xt_value value) {
+  for (uint32_t i = 0; i < set->count; i++) {
+    if (xt_value_equals(set->values[i], value)) return (int32_t)i;
+  }
+  return -1;
+}
+
+static void xt_weak_set_add(xt_weak_set *set, xt_value value) {
+  if (xt_weak_set_index(set, value) >= 0) return;
+  if (set->count >= set->capacity) {
+    uint32_t capacity = set->capacity == 0 ? 8 : set->capacity * 2;
+    set->values = (xt_value *)realloc(set->values, sizeof(xt_value) * capacity);
+    if (!set->values) abort();
+    set->capacity = capacity;
+  }
+  set->values[set->count++] = value;
+}
+
+static int xt_weak_set_delete(xt_weak_set *set, xt_value value) {
+  int32_t index = xt_weak_set_index(set, value);
+  if (index < 0) return 0;
+  for (uint32_t i = (uint32_t)index + 1; i < set->count; i++) {
+    set->values[i - 1] = set->values[i];
+  }
+  set->count--;
+  return 1;
+}
+
+xt_value xt_weak_set_ctor(int32_t argc, xt_value *argv) {
+  xt_weak_set *set = (xt_weak_set *)xt_alloc(sizeof(xt_weak_set), XT_OBJECT_KIND_WEAK_SET);
+  set->values = NULL;
+  set->count = 0;
+  set->capacity = 0;
+  xt_value iterable = xt_arg_at(argc, argv, 0);
+  if (XT_IS_ARRAY(iterable)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(iterable);
+    for (uint32_t i = 0; i < array->length; i++) {
+      if (!xt_is_weak_target(array->items[i])) {
+        xt_weak_key_error();
+        return XT_UNDEFINED;
+      }
+      xt_weak_set_add(set, array->items[i]);
+    }
+  }
+  return XT_FROM_PTR(XT_TAG_OBJECT, set);
+}
+
+/* -- WeakRef -------------------------------------------------------------- */
+
+xt_value xt_weak_ref_ctor(int32_t argc, xt_value *argv) {
+  xt_value target = xt_arg_at(argc, argv, 0);
+  if (!xt_is_weak_target(target)) {
+    xt_throw(xt_error_from_message("TypeError: WeakRef target must be an object"));
+    return XT_UNDEFINED;
+  }
+  xt_weak_ref *ref = (xt_weak_ref *)xt_alloc(sizeof(xt_weak_ref), XT_OBJECT_KIND_WEAK_REF);
+  ref->target = target;
+  return XT_FROM_PTR(XT_TAG_OBJECT, ref);
+}
+
+xt_value xt_weak_method(xt_value target, const char *method, int32_t argc, xt_value *argv,
+                        int *handled) {
+  *handled = 1;
+  if (xt_is_weak_map(target)) {
+    xt_weak_map *map = (xt_weak_map *)XT_GET_PTR(target);
+    xt_value key = xt_arg_at(argc, argv, 0);
+    if (strcmp(method, "set") == 0) {
+      if (!xt_is_weak_target(key)) {
+        xt_weak_key_error();
+        return XT_UNDEFINED;
+      }
+      xt_weak_map_set(map, key, xt_arg_at(argc, argv, 1));
+      return target;
+    }
+    if (strcmp(method, "get") == 0) {
+      if (!xt_is_weak_target(key)) return XT_UNDEFINED;
+      int32_t index = xt_weak_map_index(map, key);
+      return index >= 0 ? map->values[index] : XT_UNDEFINED;
+    }
+    if (strcmp(method, "has") == 0) {
+      return xt_bool(xt_is_weak_target(key) && xt_weak_map_index(map, key) >= 0);
+    }
+    if (strcmp(method, "delete") == 0) {
+      return xt_bool(xt_is_weak_target(key) && xt_weak_map_delete(map, key));
+    }
+  } else if (xt_is_weak_set(target)) {
+    xt_weak_set *set = (xt_weak_set *)XT_GET_PTR(target);
+    xt_value value = xt_arg_at(argc, argv, 0);
+    if (strcmp(method, "add") == 0) {
+      if (!xt_is_weak_target(value)) {
+        xt_weak_key_error();
+        return XT_UNDEFINED;
+      }
+      xt_weak_set_add(set, value);
+      return target;
+    }
+    if (strcmp(method, "has") == 0) {
+      return xt_bool(xt_is_weak_target(value) && xt_weak_set_index(set, value) >= 0);
+    }
+    if (strcmp(method, "delete") == 0) {
+      return xt_bool(xt_is_weak_target(value) && xt_weak_set_delete(set, value));
+    }
+  } else if (xt_is_weak_ref(target)) {
+    if (strcmp(method, "deref") == 0) return ((xt_weak_ref *)XT_GET_PTR(target))->target;
+  }
+  *handled = 0;
+  return XT_UNDEFINED;
+}
+
+/* -- collector integration ------------------------------------------------ */
+
+static int xt_weak_heap_value(xt_value value) {
+  return XT_IS_STRING(value) || XT_IS_OBJECT(value) || XT_IS_ARRAY(value) ||
+         XT_IS_FUNCTION(value) || XT_IS_BIGINT(value);
+}
+
+int xt_weak_gc_process_once(void) {
+  int changed = 0;
+  for (xt_header *header = xt_gc_heap_head(); header; header = header->gc_next) {
+    if ((header->flags & XT_GC_MARK) == 0) continue;
+    if (header->kind != XT_OBJECT_KIND_WEAK_MAP) continue;
+    xt_weak_map *map = (xt_weak_map *)header;
+    for (uint32_t i = 0; i < map->count; i++) {
+      if (!xt_gc_value_is_marked(map->keys[i])) continue;
+      xt_value value = map->values[i];
+      if (!xt_weak_heap_value(value)) continue;
+      if (xt_gc_value_is_marked(value)) continue;
+      xt_gc_mark_value(value);
+      changed = 1;
+    }
+  }
+  return changed;
+}
+
+void xt_weak_gc_clear(void) {
+  for (xt_header *header = xt_gc_heap_head(); header; header = header->gc_next) {
+    if ((header->flags & XT_GC_MARK) == 0) continue;
+    if (header->kind != XT_OBJECT_KIND_WEAK_REF) continue;
+    xt_weak_ref *ref = (xt_weak_ref *)header;
+    if (!xt_gc_value_is_marked(ref->target)) ref->target = XT_UNDEFINED;
+  }
+}
+
+void xt_weak_gc_compact(void) {
+  for (xt_header *header = xt_gc_heap_head(); header; header = header->gc_next) {
+    if ((header->flags & XT_GC_MARK) == 0) continue;
+    if (header->kind == XT_OBJECT_KIND_WEAK_MAP) {
+      xt_weak_map *map = (xt_weak_map *)header;
+      uint32_t write = 0;
+      for (uint32_t read = 0; read < map->count; read++) {
+        if (!xt_gc_value_is_marked(map->keys[read])) continue;
+        map->keys[write] = map->keys[read];
+        map->values[write] = map->values[read];
+        write++;
+      }
+      map->count = write;
+    } else if (header->kind == XT_OBJECT_KIND_WEAK_SET) {
+      xt_weak_set *set = (xt_weak_set *)header;
+      uint32_t write = 0;
+      for (uint32_t read = 0; read < set->count; read++) {
+        if (!xt_gc_value_is_marked(set->values[read])) continue;
+        set->values[write++] = set->values[read];
+      }
+      set->count = write;
+    }
+  }
+}