xbintsc 0.2.8 → 0.3.1

package/runtime/ext_node/net/parts/read-loop.inc

@@ -0,0 +1,58 @@
+/* -- socket read loop ----------------------------------------------------- */
+
+static void xt_net_socket_read(void *userdata, int events) {
+  (void)events;
+  xt_value socket = *(xt_value *)userdata;
+  int fd = xt_net_fd(socket);
+  if (fd < 0) return;
+
+  unsigned char buffer[65536];
+#if defined(_WIN32)
+  int count = recv(fd, (char *)buffer, (int)sizeof(buffer), 0);
+#else
+  ssize_t count = recv(fd, buffer, sizeof(buffer), 0);
+#endif
+  if (count > 0) {
+    const char *encoding = xt_node_encoding(xt_object_get_cstr(socket, "__encoding"));
+    xt_value chunk = xt_node_encode(buffer, (size_t)count, encoding);
+    xt_node_emit1(socket, "data", chunk);
+    return;
+  }
+  if (count == 0) {
+    xt_loop_remove(fd);
+    xt_close_socket(fd);
+    xt_node_set(socket, "__fd", xt_number(-1));
+    xt_node_set(socket, "__closed", xt_bool(1));
+    xt_node_emit0(socket, "end");
+    xt_node_emit0(socket, "close");
+    return;
+  }
+  if (xt_net_would_block()) return;
+  xt_loop_remove(fd);
+  xt_close_socket(fd);
+  xt_node_set(socket, "__fd", xt_number(-1));
+  xt_node_set(socket, "__closed", xt_bool(1));
+  xt_value error = xt_string_from_cstr("ECONNRESET");
+  xt_node_emit1(socket, "error", error);
+  xt_node_emit0(socket, "close");
+}
+
+static xt_value xt_net_socket_from_fd(int fd, const struct sockaddr *peer, xt_socklen_t peerLength) {
+  xt_value socket = xt_object_new_with_proto(xt_net_socket_proto());
+  xt_node_set(socket, "__fd", xt_number((double)fd));
+  xt_node_set(socket, "__connected", xt_bool(1));
+  xt_node_set(socket, "__readable", xt_array_new(0, NULL));
+
+  char host[NI_MAXHOST];
+  char service[NI_MAXSERV];
+  if (peer && getnameinfo(peer, peerLength, host, sizeof(host), service, sizeof(service),
+                          NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
+    xt_node_set(socket, "remoteAddress", xt_string_from_cstr(host));
+    xt_node_set(socket, "remotePort", xt_number((double)atoi(service)));
+    xt_node_set(socket, "remoteFamily", xt_string_from_cstr(strchr(host, ':') ? "IPv6" : "IPv4"));
+  }
+
+  xt_net_set_nonblocking(fd);
+  xt_loop_add(fd, XT_IO_READ, xt_net_socket_read, xt_net_box(socket));
+  return socket;
+}

package/runtime/ext_node/net/parts/server.inc

@@ -0,0 +1,131 @@
+/* -- server --------------------------------------------------------------- */
+
+static void xt_net_server_accept(void *userdata, int events) {
+  (void)events;
+  xt_value server = *(xt_value *)userdata;
+  int listenFd = xt_net_fd(server);
+  if (listenFd < 0) return;
+  for (;;) {
+    struct sockaddr_storage storage;
+    xt_socklen_t length = sizeof(storage);
+    int fd = accept(listenFd, (struct sockaddr *)&storage, &length);
+    if (fd < 0) break;
+    xt_value socket = xt_net_socket_from_fd(fd, (struct sockaddr *)&storage, length);
+    xt_node_emit1(server, "connection", socket);
+  }
+}
+
+/* Parse the many listen() signatures into a port + host. */
+static void xt_net_parse_listen(int32_t argc, xt_value *argv, int *port, const char **host, xt_value *callback) {
+  *port = 0;
+  *host = "0.0.0.0";
+  *callback = XT_UNDEFINED;
+  int index = 0;
+  if (argc > 0 && XT_IS_OBJECT(argv[0])) {
+    xt_value portValue = xt_object_get_cstr(argv[0], "port");
+    if (!xt_truthy(xt_is_nullish(portValue))) *port = (int)xt_to_number(portValue);
+    xt_value hostValue = xt_object_get_cstr(argv[0], "host");
+    if (XT_IS_STRING(hostValue)) *host = xt_string_data(hostValue);
+    index = 1;
+  } else if (argc > 0 && XT_IS_NUMBER(argv[0])) {
+    *port = (int)xt_to_number(argv[0]);
+    index = 1;
+    if (argc > 1 && XT_IS_STRING(argv[1])) {
+      *host = xt_string_data(argv[1]);
+      index = 2;
+    }
+  }
+  for (int32_t i = index; i < argc; i++) {
+    if (XT_IS_FUNCTION(argv[i])) *callback = argv[i];
+  }
+}
+
+static xt_value xt_net_server_listen(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int port = 0;
+  const char *host = "0.0.0.0";
+  xt_value callback = XT_UNDEFINED;
+  xt_net_parse_listen(argc, argv, &port, &host, &callback);
+
+  char service[16];
+  snprintf(service, sizeof(service), "%d", port);
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags = AI_PASSIVE;
+  struct addrinfo *result = NULL;
+  if (getaddrinfo(host, service, &hints, &result) != 0) {
+    if (XT_IS_FUNCTION(callback)) {
+      xt_value error = xt_string_from_cstr("EADDRNOTAVAIL");
+      xt_call_with_this(callback, xt_undefined(), 1, &error);
+    }
+    return thisValue;
+  }
+
+  int listenFd = -1;
+  for (struct addrinfo *info = result; info; info = info->ai_next) {
+    int fd = socket(info->ai_family, info->ai_socktype, info->ai_protocol);
+    if (fd < 0) continue;
+    int yes = 1;
+    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&yes, sizeof(yes));
+    if (bind(fd, info->ai_addr, info->ai_addrlen) == 0 && listen(fd, 511) == 0) {
+      listenFd = fd;
+      break;
+    }
+    xt_close_socket(fd);
+  }
+  freeaddrinfo(result);
+
+  if (listenFd < 0) {
+    if (XT_IS_FUNCTION(callback)) {
+      xt_value error = xt_string_from_cstr("EADDRINUSE");
+      xt_call_with_this(callback, xt_undefined(), 1, &error);
+    }
+    return thisValue;
+  }
+
+  xt_net_set_nonblocking(listenFd);
+  xt_node_set(thisValue, "__fd", xt_number((double)listenFd));
+  xt_node_set(thisValue, "__listening", xt_bool(1));
+  xt_loop_add(listenFd, XT_IO_READ, xt_net_server_accept, xt_net_box(thisValue));
+
+  xt_node_emit0(thisValue, "listening");
+  if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  return thisValue;
+}
+
+static xt_value xt_net_server_close(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int fd = xt_net_fd(thisValue);
+  if (fd >= 0) {
+    xt_loop_remove(fd);
+    xt_close_socket(fd);
+  }
+  xt_node_set(thisValue, "__fd", xt_number(-1));
+  xt_node_set(thisValue, "__listening", xt_bool(0));
+  xt_value callback = XT_IS_FUNCTION(xt_arg(argc, argv, 0)) ? xt_arg(argc, argv, 0) : XT_UNDEFINED;
+  xt_node_emit0(thisValue, "close");
+  if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  return thisValue;
+}
+
+static xt_value xt_net_server_address(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  return xt_net_socket_address(thisValue, env, argc, argv);
+}
+
+static xt_value xt_net_server_get_connections(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value callback = xt_arg(argc, argv, 0);
+  if (XT_IS_FUNCTION(callback)) {
+    xt_value count = xt_number(0);
+    xt_value args[2];
+    args[0] = xt_null();
+    args[1] = count;
+    xt_call_with_this(callback, xt_undefined(), 2, args);
+  }
+  return xt_undefined();
+}

package/runtime/ext_node/net/parts/socket-methods.inc

@@ -0,0 +1,100 @@
+/* -- socket methods ------------------------------------------------------- */
+
+static xt_value xt_net_socket_write(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int fd = xt_net_fd(thisValue);
+  if (fd < 0) {
+    xt_value callback = xt_arg(argc, argv, argc > 1 ? 2 : 1);
+    xt_value error = xt_string_from_cstr("ERR_SOCKET_CLOSED");
+    if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 1, &error);
+    return xt_bool(0);
+  }
+  size_t length = 0;
+  unsigned char *bytes = xt_net_bytes(xt_arg(argc, argv, 0), &length);
+  xt_net_send_all(fd, bytes, length);
+  free(bytes);
+  xt_value callback = XT_IS_FUNCTION(xt_arg(argc, argv, 1)) ? xt_arg(argc, argv, 1) : xt_arg(argc, argv, 2);
+  if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  return xt_bool(1);
+}
+
+static xt_value xt_net_socket_end(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  int fd = xt_net_fd(thisValue);
+  if (fd < 0) return thisValue;
+  if (argc > 0 && !xt_truthy(xt_is_nullish(argv[0]))) {
+    xt_value writeFn = xt_object_get_cstr(thisValue, "write");
+    if (XT_IS_FUNCTION(writeFn)) xt_call_with_this(writeFn, thisValue, 1, &argv[0]);
+  }
+#if defined(_WIN32)
+  shutdown(fd, SD_SEND);
+#else
+  shutdown(fd, SHUT_WR);
+#endif
+  return thisValue;
+}
+
+static xt_value xt_net_socket_destroy(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  int fd = xt_net_fd(thisValue);
+  if (fd >= 0) {
+    xt_loop_remove(fd);
+    xt_close_socket(fd);
+  }
+  xt_node_set(thisValue, "__fd", xt_number(-1));
+  if (!xt_truthy(xt_object_get_cstr(thisValue, "__closed"))) {
+    xt_node_set(thisValue, "__closed", xt_bool(1));
+    xt_node_emit0(thisValue, "close");
+  }
+  return thisValue;
+}
+
+static xt_value xt_net_socket_set_encoding(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_node_set(thisValue, "__encoding", xt_arg(argc, argv, 0));
+  return thisValue;
+}
+
+static xt_value xt_net_socket_pause(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return thisValue;
+}
+
+static xt_value xt_net_socket_resume(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return thisValue;
+}
+
+static xt_value xt_net_socket_noop(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return thisValue;
+}
+
+static xt_value xt_net_socket_address(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  int fd = xt_net_fd(thisValue);
+  if (fd < 0) return xt_null();
+  struct sockaddr_storage storage;
+  xt_socklen_t length = sizeof(storage);
+  if (getsockname(fd, (struct sockaddr *)&storage, &length) != 0) return xt_null();
+  char host[NI_MAXHOST];
+  char service[NI_MAXSERV];
+  if (getnameinfo((struct sockaddr *)&storage, length, host, sizeof(host), service, sizeof(service),
+                  NI_NUMERICHOST | NI_NUMERICSERV) != 0)
+    return xt_null();
+  xt_value object = xt_object_new();
+  xt_node_set(object, "address", xt_string_from_cstr(host));
+  xt_node_set(object, "port", xt_number((double)atoi(service)));
+  xt_node_set(object, "family", xt_string_from_cstr(strchr(host, ':') ? "IPv6" : "IPv4"));
+  return object;
+}

package/runtime/ext_node/net/parts/static-api.inc

@@ -0,0 +1,93 @@
+/* -- connect / static API ------------------------------------------------- */
+
+static int xt_net_connect_fd(const char *host, int port) {
+  char service[16];
+  snprintf(service, sizeof(service), "%d", port);
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  struct addrinfo *result = NULL;
+  if (getaddrinfo(host, service, &hints, &result) != 0) return -1;
+  int fd = -1;
+  for (struct addrinfo *info = result; info; info = info->ai_next) {
+    int candidate = socket(info->ai_family, info->ai_socktype, info->ai_protocol);
+    if (candidate < 0) continue;
+    if (connect(candidate, info->ai_addr, info->ai_addrlen) == 0) {
+      fd = candidate;
+      break;
+    }
+    xt_close_socket(candidate);
+  }
+  freeaddrinfo(result);
+  return fd;
+}
+
+xt_value xt_node_net_connect(int32_t argc, xt_value *argv) {
+  int port = 0;
+  const char *host = "127.0.0.1";
+  xt_value callback = XT_UNDEFINED;
+  int index = 0;
+  if (argc > 0 && XT_IS_OBJECT(argv[0])) {
+    xt_value portValue = xt_object_get_cstr(argv[0], "port");
+    if (!xt_truthy(xt_is_nullish(portValue))) port = (int)xt_to_number(portValue);
+    xt_value hostValue = xt_object_get_cstr(argv[0], "host");
+    if (XT_IS_STRING(hostValue)) host = xt_string_data(hostValue);
+    index = 1;
+  } else if (argc > 0 && XT_IS_NUMBER(argv[0])) {
+    port = (int)xt_to_number(argv[0]);
+    index = 1;
+    if (argc > 1 && XT_IS_STRING(argv[1])) {
+      host = xt_string_data(argv[1]);
+      index = 2;
+    }
+  }
+  for (int32_t i = index; i < argc; i++) {
+    if (XT_IS_FUNCTION(argv[i])) callback = argv[i];
+  }
+
+  int fd = xt_net_connect_fd(host, port);
+  if (fd < 0) {
+    xt_value socket = xt_net_socket_ctor(0, NULL);
+    xt_value error = xt_string_from_cstr("ECONNREFUSED");
+    if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 1, &error);
+    else xt_node_emit1(socket, "error", error);
+    return socket;
+  }
+
+  struct sockaddr_storage storage;
+  xt_socklen_t length = sizeof(storage);
+  getpeername(fd, (struct sockaddr *)&storage, &length);
+  xt_value socket = xt_net_socket_from_fd(fd, (struct sockaddr *)&storage, length);
+  xt_node_set(socket, "__connecting", xt_bool(0));
+  xt_node_emit0(socket, "connect");
+  xt_node_emit0(socket, "ready");
+  if (XT_IS_FUNCTION(callback)) xt_call_with_this(callback, xt_undefined(), 0, NULL);
+  return socket;
+}
+
+xt_value xt_net_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, "createServer") == 0) {
+    xt_value server = xt_net_server_ctor(0, NULL);
+    for (int32_t i = 0; i < argc; i++) {
+      if (XT_IS_FUNCTION(argv[i])) {
+        xt_array_push(xt_node_listeners(server, "connection", 1), argv[i]);
+        break;
+      }
+    }
+    return server;
+  }
+  if (strcmp(fn, "connect") == 0 || strcmp(fn, "createConnection") == 0) return xt_node_net_connect(argc, argv);
+  if (strcmp(fn, "isIP") == 0 || strcmp(fn, "isIPv4") == 0 || strcmp(fn, "isIPv6") == 0) {
+    const char *input = xt_string_data(xt_to_string(xt_arg(argc, argv, 0)));
+    if (!input) return xt_number(0);
+    if (strcmp(fn, "isIPv4") == 0) return xt_bool(strchr(input, '.') && !strchr(input, ':'));
+    if (strcmp(fn, "isIPv6") == 0) return xt_bool(strchr(input, ':') != NULL);
+    if (strchr(input, ':')) return xt_number(6);
+    if (strchr(input, '.')) return xt_number(4);
+    return xt_number(0);
+  }
+  return xt_undefined();
+}

package/runtime/ext_node/querystring/querystring.c

@@ -0,0 +1,251 @@
+/*
+ * Node.js `querystring` module for xbintsc.
+ *
+ * Implements `parse` / `stringify` (and their `decode` / `encode` aliases)
+ * plus `escape` / `unescape`. Percent-encoding follows
+ * `encodeURIComponent`/`decodeURIComponent` semantics and, as Node does for
+ * form data, `+` decodes to a space.
+ */
+
+#include "../node_common.h"
+
+/* -- growable string buffer ---------------------------------------------- */
+
+typedef struct {
+  char *data;
+  size_t length;
+  size_t capacity;
+} qs_buf;
+
+static void qs_buf_init(qs_buf *buf) {
+  buf->capacity = 64;
+  buf->length = 0;
+  buf->data = (char *)malloc(buf->capacity);
+  if (buf->data) buf->data[0] = '\0';
+}
+
+static void qs_buf_putc(qs_buf *buf, char c) {
+  if (!buf->data) return;
+  if (buf->length + 2 > buf->capacity) {
+    while (buf->length + 2 > buf->capacity) buf->capacity *= 2;
+    buf->data = (char *)realloc(buf->data, buf->capacity);
+    if (!buf->data) return;
+  }
+  buf->data[buf->length++] = c;
+  buf->data[buf->length] = '\0';
+}
+
+static void qs_buf_puts(qs_buf *buf, const char *text, size_t length) {
+  for (size_t i = 0; i < length; i++) qs_buf_putc(buf, text[i]);
+}
+
+static xt_value qs_buf_finish(qs_buf *buf) {
+  xt_value result = buf->data ? xt_string_new(buf->data, buf->length) : xt_string_from_cstr("");
+  free(buf->data);
+  buf->data = NULL;
+  return result;
+}
+
+/* -- percent encoding ----------------------------------------------------- */
+
+static int qs_unreserved(unsigned char c) {
+  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' ||
+         c == '_' || c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' || c == ')';
+}
+
+static int qs_hex(int 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;
+}
+
+/* encodeURIComponent-style escaping of `length` bytes. */
+static xt_value qs_escape_bytes(const char *text, size_t length) {
+  static const char digits[] = "0123456789ABCDEF";
+  qs_buf buf;
+  qs_buf_init(&buf);
+  for (size_t i = 0; i < length; i++) {
+    unsigned char c = (unsigned char)text[i];
+    if (qs_unreserved(c)) {
+      qs_buf_putc(&buf, (char)c);
+    } else {
+      qs_buf_putc(&buf, '%');
+      qs_buf_putc(&buf, digits[c >> 4]);
+      qs_buf_putc(&buf, digits[c & 0x0f]);
+    }
+  }
+  return qs_buf_finish(&buf);
+}
+
+/* decodeURIComponent-style unescaping, with `+` meaning space. */
+static xt_value qs_unescape_bytes(const char *text, size_t length) {
+  char *out = (char *)malloc(length + 1);
+  if (!out) return xt_string_from_cstr("");
+  size_t written = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = text[i];
+    if (c == '+') {
+      out[written++] = ' ';
+    } else if (c == '%' && i + 2 < length && qs_hex(text[i + 1]) >= 0 && qs_hex(text[i + 2]) >= 0) {
+      out[written++] = (char)((qs_hex(text[i + 1]) << 4) | qs_hex(text[i + 2]));
+      i += 2;
+    } else {
+      out[written++] = c;
+    }
+  }
+  out[written] = '\0';
+  xt_value result = xt_string_new(out, written);
+  free(out);
+  return result;
+}
+
+/* -- options -------------------------------------------------------------- */
+
+static const char *qs_option(int32_t argc, xt_value *argv, int32_t index, const char *fallback) {
+  if (index >= argc) return fallback;
+  xt_value value = argv[index];
+  if (XT_IS_STRING(value)) {
+    const char *data = xt_string_data(value);
+    return data ? data : fallback;
+  }
+  return fallback;
+}
+
+/* -- parse ---------------------------------------------------------------- */
+
+static void qs_assign(xt_value result, xt_value key, xt_value value) {
+  if (!xt_truthy(xt_object_has_own(result, key))) {
+    xt_object_set(result, key, value);
+    return;
+  }
+  xt_value existing = xt_object_get(result, key);
+  if (XT_IS_ARRAY(existing)) {
+    xt_array_push(existing, value);
+    return;
+  }
+  xt_value array = xt_array_new(1, &existing);
+  xt_array_push(array, value);
+  xt_object_set(result, key, array);
+}
+
+static void qs_parse_pair(xt_value result, const char *pair, size_t length, const char *eq, size_t eqLength) {
+  size_t eqIndex = length;
+  if (eqLength > 0) {
+    for (size_t i = 0; i + eqLength <= length; i++) {
+      if (memcmp(pair + i, eq, eqLength) == 0) {
+        eqIndex = i;
+        break;
+      }
+    }
+  }
+  size_t keyLength = eqIndex;
+  const char *valueStart = pair + length;
+  size_t valueLength = 0;
+  if (eqIndex < length) {
+    valueStart = pair + eqIndex + eqLength;
+    valueLength = length - eqIndex - eqLength;
+  }
+  xt_value key = qs_unescape_bytes(pair, keyLength);
+  xt_value value = qs_unescape_bytes(valueStart, valueLength);
+  qs_assign(result, key, value);
+}
+
+xt_value xt_querystring_parse(int32_t argc, xt_value *argv) {
+  xt_value result = xt_object_new();
+  xt_value input = xt_arg(argc, argv, 0);
+  if (!XT_IS_STRING(input)) return result;
+  const char *text = xt_string_data(input);
+  size_t length = (size_t)xt_string_length_value(input);
+  const char *sep = qs_option(argc, argv, 1, "&");
+  const char *eq = qs_option(argc, argv, 2, "=");
+  size_t sepLength = strlen(sep);
+  size_t eqLength = strlen(eq);
+  size_t start = 0;
+  while (start <= length) {
+    size_t end = start;
+    while (end < length && !(sepLength > 0 && end + sepLength <= length && memcmp(text + end, sep, sepLength) == 0)) {
+      end++;
+    }
+    qs_parse_pair(result, text + start, end - start, eq, eqLength);
+    if (end >= length) break;
+    start = end + sepLength;
+  }
+  return result;
+}
+
+/* -- stringify ------------------------------------------------------------ */
+
+static void qs_stringify_scalar(qs_buf *buf, xt_value key, xt_value value, const char *eq) {
+  const char *keyData = xt_string_data(key);
+  size_t keyLength = (size_t)xt_string_length_value(key);
+  xt_value escapedKey = qs_escape_bytes(keyData, keyLength);
+  qs_buf_puts(buf, xt_string_data(escapedKey), (size_t)xt_string_length_value(escapedKey));
+  qs_buf_puts(buf, eq, strlen(eq));
+
+  xt_value text = value;
+  if (xt_truthy(xt_is_nullish(value))) {
+    return; /* null / undefined stringify to the empty string */
+  }
+  if (!XT_IS_STRING(text)) text = xt_to_string(text);
+  const char *data = xt_string_data(text);
+  size_t length = (size_t)xt_string_length_value(text);
+  xt_value escaped = qs_escape_bytes(data, length);
+  qs_buf_puts(buf, xt_string_data(escaped), (size_t)xt_string_length_value(escaped));
+}
+
+xt_value xt_querystring_stringify(int32_t argc, xt_value *argv) {
+  xt_value object = xt_arg(argc, argv, 0);
+  if (!XT_IS_OBJECT(object) || XT_IS_ARRAY(object)) return xt_string_from_cstr("");
+  const char *sep = qs_option(argc, argv, 1, "&");
+  const char *eq = qs_option(argc, argv, 2, "=");
+
+  qs_buf buf;
+  qs_buf_init(&buf);
+  xt_value keys = xt_object_keys(object);
+  int32_t count = (int32_t)xt_to_number(xt_array_length(keys));
+  int first = 1;
+  for (int32_t i = 0; i < count; i++) {
+    xt_value key = xt_array_get(keys, xt_number((double)i));
+    xt_value value = xt_object_get(object, key);
+    if (XT_IS_ARRAY(value)) {
+      int32_t items = (int32_t)xt_to_number(xt_array_length(value));
+      for (int32_t j = 0; j < items; j++) {
+        if (!first) qs_buf_puts(&buf, sep, strlen(sep));
+        first = 0;
+        qs_stringify_scalar(&buf, key, xt_array_get(value, xt_number((double)j)), eq);
+      }
+    } else {
+      if (!first) qs_buf_puts(&buf, sep, strlen(sep));
+      first = 0;
+      qs_stringify_scalar(&buf, key, value, eq);
+    }
+  }
+  return qs_buf_finish(&buf);
+}
+
+/* -- escape / unescape ---------------------------------------------------- */
+
+xt_value xt_querystring_escape(int32_t argc, xt_value *argv) {
+  xt_value text = xt_arg(argc, argv, 0);
+  if (!XT_IS_STRING(text)) text = xt_to_string(text);
+  return qs_escape_bytes(xt_string_data(text), (size_t)xt_string_length_value(text));
+}
+
+xt_value xt_querystring_unescape(int32_t argc, xt_value *argv) {
+  xt_value text = xt_arg(argc, argv, 0);
+  if (!XT_IS_STRING(text)) text = xt_to_string(text);
+  return qs_unescape_bytes(xt_string_data(text), (size_t)xt_string_length_value(text));
+}
+
+/* -- namespace dispatcher ------------------------------------------------- */
+
+xt_value xt_querystring_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, "parse") == 0 || strcmp(fn, "decode") == 0) return xt_querystring_parse(argc, argv);
+  if (strcmp(fn, "stringify") == 0 || strcmp(fn, "encode") == 0) return xt_querystring_stringify(argc, argv);
+  if (strcmp(fn, "escape") == 0) return xt_querystring_escape(argc, argv);
+  if (strcmp(fn, "unescape") == 0) return xt_querystring_unescape(argc, argv);
+  return xt_undefined();
+}