xbintsc 0.3.8 → 0.3.10

package/runtime/ext_node/crypto/crypto.c

@@ -14,6 +14,7 @@
 
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 /* -- SHA-256 -------------------------------------------------------------- */
@@ -128,6 +129,115 @@ static void sha256_hash(const uint8_t *data, size_t length, uint8_t *out) {
   sha256_final(&ctx, out);
 }
 
+/* -- SHA-1 ---------------------------------------------------------------- */
+
+typedef struct {
+  uint32_t state[5];
+  uint64_t bitlen;
+  uint8_t buffer[64];
+  size_t buffer_length;
+} sha1_ctx;
+
+#define SHA1_ROTL(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+static void sha1_init(sha1_ctx *ctx) {
+  ctx->state[0] = 0x67452301;
+  ctx->state[1] = 0xefcdab89;
+  ctx->state[2] = 0x98badcfe;
+  ctx->state[3] = 0x10325476;
+  ctx->state[4] = 0xc3d2e1f0;
+  ctx->bitlen = 0;
+  ctx->buffer_length = 0;
+}
+
+static void sha1_compress(sha1_ctx *ctx, const uint8_t *block) {
+  uint32_t w[80];
+  for (int i = 0; i < 16; i++) {
+    w[i] = ((uint32_t)block[i * 4] << 24) | ((uint32_t)block[i * 4 + 1] << 16) |
+           ((uint32_t)block[i * 4 + 2] << 8) | ((uint32_t)block[i * 4 + 3]);
+  }
+  for (int i = 16; i < 80; i++) {
+    w[i] = SHA1_ROTL(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
+  }
+  uint32_t a = ctx->state[0], b = ctx->state[1], c = ctx->state[2], d = ctx->state[3];
+  uint32_t e = ctx->state[4];
+  for (int i = 0; i < 80; i++) {
+    uint32_t f, k;
+    if (i < 20) {
+      f = (b & c) | ((~b) & d);
+      k = 0x5a827999;
+    } else if (i < 40) {
+      f = b ^ c ^ d;
+      k = 0x6ed9eba1;
+    } else if (i < 60) {
+      f = (b & c) | (b & d) | (c & d);
+      k = 0x8f1bbcdc;
+    } else {
+      f = b ^ c ^ d;
+      k = 0xca62c1d6;
+    }
+    uint32_t temp = SHA1_ROTL(a, 5) + f + e + k + w[i];
+    e = d;
+    d = c;
+    c = SHA1_ROTL(b, 30);
+    b = a;
+    a = temp;
+  }
+  ctx->state[0] += a;
+  ctx->state[1] += b;
+  ctx->state[2] += c;
+  ctx->state[3] += d;
+  ctx->state[4] += e;
+}
+
+static void sha1_update(sha1_ctx *ctx, const uint8_t *data, size_t length) {
+  for (size_t i = 0; i < length; i++) {
+    ctx->buffer[ctx->buffer_length++] = data[i];
+    if (ctx->buffer_length == 64) {
+      sha1_compress(ctx, ctx->buffer);
+      ctx->bitlen += 512;
+      ctx->buffer_length = 0;
+    }
+  }
+}
+
+static void sha1_final(sha1_ctx *ctx, uint8_t *out) {
+  size_t i = ctx->buffer_length;
+  ctx->buffer[i++] = 0x80;
+  if (i > 56) {
+    while (i < 64) ctx->buffer[i++] = 0;
+    sha1_compress(ctx, ctx->buffer);
+    i = 0;
+  }
+  while (i < 56) ctx->buffer[i++] = 0;
+  ctx->bitlen += (uint64_t)ctx->buffer_length * 8;
+  for (int j = 0; j < 8; j++) ctx->buffer[56 + j] = (uint8_t)(ctx->bitlen >> (56 - j * 8));
+  sha1_compress(ctx, ctx->buffer);
+  for (int j = 0; j < 5; j++) {
+    out[j * 4] = (uint8_t)(ctx->state[j] >> 24);
+    out[j * 4 + 1] = (uint8_t)(ctx->state[j] >> 16);
+    out[j * 4 + 2] = (uint8_t)(ctx->state[j] >> 8);
+    out[j * 4 + 3] = (uint8_t)(ctx->state[j]);
+  }
+}
+
+/* Compute `algorithm` over `data`; returns the digest length, or 0 when the
+ * algorithm is unsupported. */
+static size_t xt_hash_compute(const char *algorithm, const uint8_t *data, size_t length, uint8_t *out) {
+  if (algorithm && (strcmp(algorithm, "sha1") == 0 || strcmp(algorithm, "sha-1") == 0)) {
+    sha1_ctx ctx;
+    sha1_init(&ctx);
+    sha1_update(&ctx, data, length);
+    sha1_final(&ctx, out);
+    return 20;
+  }
+  if (!algorithm || strcmp(algorithm, "sha256") == 0 || strcmp(algorithm, "sha-256") == 0) {
+    sha256_hash(data, length, out);
+    return 32;
+  }
+  return 0;
+}
+
 /* -- node:crypto surface -------------------------------------------------- */
 
 static xt_value hash_data(xt_value hash) {
@@ -136,6 +246,82 @@ static xt_value hash_data(xt_value hash) {
   return data;
 }
 
+static const char *hash_algorithm(xt_value hash) {
+  xt_value algorithm = xt_object_get(hash, xt_string_from_cstr("_algorithm"));
+  const char *name = algorithm ? xt_string_data(xt_to_string(algorithm)) : NULL;
+  return name ? name : "sha256";
+}
+
+static const char *hash_encoding(xt_value hash, int argc, xt_value *argv) {
+  if (argc > 0 && !xt_truthy(xt_is_nullish(argv[0]))) {
+    const char *explicitEncoding = xt_string_data(xt_to_string(argv[0]));
+    if (explicitEncoding) return explicitEncoding;
+  }
+  xt_value encoding = xt_object_get(hash, xt_string_from_cstr("_outEncoding"));
+  const char *name = encoding ? xt_string_data(xt_to_string(encoding)) : NULL;
+  return name ? name : "hex";
+}
+
+/* Encode `length` digest bytes into an xt string using `encoding`. */
+static xt_value hash_encode(const uint8_t *digest, size_t length, const char *encoding) {
+  if (!encoding || strcmp(encoding, "hex") == 0) {
+    static const char digits[] = "0123456789abcdef";
+    char *hex = (char *)malloc(length * 2 + 1);
+    if (!hex) return xt_undefined();
+    for (size_t i = 0; i < length; i++) {
+      hex[i * 2] = digits[digest[i] >> 4];
+      hex[i * 2 + 1] = digits[digest[i] & 0xf];
+    }
+    hex[length * 2] = 0;
+    xt_value result = xt_string_from_cstr(hex);
+    free(hex);
+    return result;
+  }
+  if (strcmp(encoding, "base64") == 0) {
+    static const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    size_t outLength = ((length + 2) / 3) * 4;
+    char *buffer = (char *)malloc(outLength + 1);
+    if (!buffer) return xt_undefined();
+    size_t i = 0, j = 0;
+    while (i + 2 < length) {
+      uint32_t n = ((uint32_t)digest[i] << 16) | ((uint32_t)digest[i + 1] << 8) | (uint32_t)digest[i + 2];
+      buffer[j++] = alphabet[(n >> 18) & 63];
+      buffer[j++] = alphabet[(n >> 12) & 63];
+      buffer[j++] = alphabet[(n >> 6) & 63];
+      buffer[j++] = alphabet[n & 63];
+      i += 3;
+    }
+    if (length - i == 1) {
+      uint32_t n = (uint32_t)digest[i] << 16;
+      buffer[j++] = alphabet[(n >> 18) & 63];
+      buffer[j++] = alphabet[(n >> 12) & 63];
+      buffer[j++] = '=';
+      buffer[j++] = '=';
+    } else if (length - i == 2) {
+      uint32_t n = ((uint32_t)digest[i] << 16) | ((uint32_t)digest[i + 1] << 8);
+      buffer[j++] = alphabet[(n >> 18) & 63];
+      buffer[j++] = alphabet[(n >> 12) & 63];
+      buffer[j++] = alphabet[(n >> 6) & 63];
+      buffer[j++] = '=';
+    }
+    xt_value result = xt_string_new(buffer, j);
+    free(buffer);
+    return result;
+  }
+  return xt_string_new((const char *)digest, length);
+}
+
+/* Compute the digest of everything accumulated so far. */
+static xt_value hash_finish(xt_value hash, int argc, xt_value *argv) {
+  xt_value data = hash_data(hash);
+  const char *text = xt_string_data(xt_to_string(data));
+  if (!text) text = "";
+  uint8_t digest[64];
+  size_t length = xt_hash_compute(hash_algorithm(hash), (const uint8_t *)text, strlen(text), digest);
+  if (length == 0) return xt_string_from_cstr("");
+  return hash_encode(digest, length, hash_encoding(hash, argc, argv));
+}
+
 static xt_value xt_hash_update(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   if (XT_IS_OBJECT(thisValue) && argc > 0) {
@@ -147,22 +333,48 @@ static xt_value xt_hash_update(xt_value thisValue, xt_value env, int32_t argc, x
 
 static xt_value xt_hash_digest(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
-  const char *text = xt_string_data(xt_to_string(hash_data(thisValue)));
-  if (!text) text = "";
-  uint8_t out[32];
-  sha256_hash((const uint8_t *)text, strlen(text), out);
-  const char *encoding = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "hex";
-  if (!encoding || strcmp(encoding, "hex") == 0) {
-    static const char digits[] = "0123456789abcdef";
-    char hex[65];
-    for (int i = 0; i < 32; i++) {
-      hex[i * 2] = digits[out[i] >> 4];
-      hex[i * 2 + 1] = digits[out[i] & 0xf];
+  return hash_finish(thisValue, argc, argv);
+}
+
+static xt_value xt_hash_set_encoding(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (XT_IS_OBJECT(thisValue) && argc > 0) {
+    xt_set(thisValue, xt_string_from_cstr("_outEncoding"), xt_to_string(argv[0]));
+  }
+  return thisValue;
+}
+
+static xt_value xt_hash_write(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (XT_IS_OBJECT(thisValue) && argc > 0 && !xt_truthy(xt_is_nullish(argv[0]))) {
+    xt_value combined = xt_add(hash_data(thisValue), xt_to_string(argv[0]));
+    xt_set(thisValue, xt_string_from_cstr("_data"), combined);
+  }
+  return xt_bool(1);
+}
+
+static xt_value xt_hash_end(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (XT_IS_OBJECT(thisValue)) {
+    xt_value chunk = xt_arg(argc, argv, 0);
+    if (argc > 0 && !xt_truthy(xt_is_nullish(chunk))) {
+      xt_value combined = xt_add(hash_data(thisValue), xt_to_string(chunk));
+      xt_set(thisValue, xt_string_from_cstr("_data"), combined);
     }
-    hex[64] = 0;
-    return xt_string_from_cstr(hex);
+    xt_set(thisValue, xt_string_from_cstr("_result"), hash_finish(thisValue, 0, NULL));
+    xt_set(thisValue, xt_string_from_cstr("_ended"), xt_bool(1));
   }
-  return xt_string_from_cstr("");
+  return thisValue;
+}
+
+static xt_value xt_hash_read(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  if (!XT_IS_OBJECT(thisValue)) return xt_undefined();
+  xt_value result = xt_object_get(thisValue, xt_string_from_cstr("_result"));
+  if (xt_truthy(xt_is_nullish(result))) return xt_undefined();
+  return result;
 }
 
 xt_value xt_crypto_create_hash(int32_t argc, xt_value *argv) {
@@ -173,5 +385,9 @@ xt_value xt_crypto_create_hash(int32_t argc, xt_value *argv) {
   xt_set(hash, xt_string_from_cstr("_data"), xt_string_from_cstr(""));
   xt_set(hash, xt_string_from_cstr("update"), xt_closure_new((void *)xt_hash_update, 0, NULL));
   xt_set(hash, xt_string_from_cstr("digest"), xt_closure_new((void *)xt_hash_digest, 0, NULL));
+  xt_set(hash, xt_string_from_cstr("setEncoding"), xt_closure_new((void *)xt_hash_set_encoding, 0, NULL));
+  xt_set(hash, xt_string_from_cstr("write"), xt_closure_new((void *)xt_hash_write, 0, NULL));
+  xt_set(hash, xt_string_from_cstr("end"), xt_closure_new((void *)xt_hash_end, 0, NULL));
+  xt_set(hash, xt_string_from_cstr("read"), xt_closure_new((void *)xt_hash_read, 0, NULL));
   return hash;
 }

package/runtime/ext_node/fs/streams.c

@@ -0,0 +1,31 @@
+/*
+ * `fs.createReadStream` / `fs.createWriteStream` for xbintsc.
+ *
+ * xbintsc has no asynchronous file streaming, so these factories return small
+ * descriptor objects understood by `stream/promises`'s `pipeline`: they carry
+ * the target `_path` (and a `_kind` tag) and the pipeline reads/writes the file
+ * in one shot. They also behave well enough as EventEmitters for simple
+ * synchronous `on("data")` usage (see `stream.c`).
+ */
+
+#include "rt.h"
+#include "../node_common.h"
+
+static xt_value xt_node_stream_descriptor(const char *kind, const char *path) {
+  xt_value stream = xt_object_new();
+  xt_node_set(stream, "_kind", xt_string_from_cstr(kind));
+  xt_node_set(stream, "_path", xt_string_from_cstr(path));
+  return stream;
+}
+
+xt_value xt_node_create_read_stream(int32_t argc, xt_value *argv) {
+  const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : NULL;
+  if (!path) return xt_undefined();
+  return xt_node_stream_descriptor("readStream", path);
+}
+
+xt_value xt_node_create_write_stream(int32_t argc, xt_value *argv) {
+  const char *path = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : NULL;
+  if (!path) return xt_undefined();
+  return xt_node_stream_descriptor("writeStream", path);
+}

package/runtime/ext_node/stream/pipeline.c

@@ -0,0 +1,147 @@
+/*
+ * `stream/promises` `pipeline` for xbintsc.
+ *
+ * Synchronous drain: read the source descriptor's file, apply each transform
+ * (currently gzip), then write the destination descriptor's file. Returns an
+ * already-resolved promise so `await pipeline(...)` works at the top level.
+ *
+ * Sources and destinations are the descriptor objects produced by
+ * `fs.createReadStream` / `fs.createWriteStream`; a transform is the descriptor
+ * produced by `zlib.createGzip`.
+ */
+
+#include "../node_common.h"
+
+#include <string.h>
+
+/* -- gzip (stored blocks) ------------------------------------------------- */
+
+static uint32_t xt_pipeline_crc32(const unsigned char *data, size_t length) {
+  uint32_t crc = 0xffffffffu;
+  for (size_t i = 0; i < length; i++) {
+    crc ^= data[i];
+    for (int bit = 0; bit < 8; bit++) {
+      uint32_t mask = (uint32_t)(-(int32_t)(crc & 1));
+      crc = (crc >> 1) ^ (0xedb88320u & mask);
+    }
+  }
+  return crc ^ 0xffffffffu;
+}
+
+static void xt_pipeline_le32(unsigned char *out, uint32_t value) {
+  out[0] = (unsigned char)(value & 0xff);
+  out[1] = (unsigned char)((value >> 8) & 0xff);
+  out[2] = (unsigned char)((value >> 16) & 0xff);
+  out[3] = (unsigned char)((value >> 24) & 0xff);
+}
+
+/* Wrap `data` in a gzip container using DEFLATE stored blocks. */
+static int xt_pipeline_gzip(const unsigned char *data, size_t length, unsigned char **out, size_t *outLength) {
+  size_t blocks = length / 65535 + 1;
+  size_t capacity = 10 + length + blocks * 5 + 8;
+  unsigned char *buffer = (unsigned char *)malloc(capacity);
+  if (!buffer) return 0;
+  size_t pos = 0;
+  buffer[pos++] = 0x1f;
+  buffer[pos++] = 0x8b;
+  buffer[pos++] = 0x08; /* CM: deflate */
+  buffer[pos++] = 0x00; /* FLG */
+  buffer[pos++] = 0x00; /* MTIME */
+  buffer[pos++] = 0x00;
+  buffer[pos++] = 0x00;
+  buffer[pos++] = 0x00;
+  buffer[pos++] = 0x00; /* XFL */
+  buffer[pos++] = 0xff; /* OS: unknown */
+
+  size_t offset = 0;
+  do {
+    size_t chunk = length - offset;
+    if (chunk > 65535) chunk = 65535;
+    int final = offset + chunk >= length;
+    buffer[pos++] = (unsigned char)(final ? 0x01 : 0x00);
+    buffer[pos++] = (unsigned char)(chunk & 0xff);
+    buffer[pos++] = (unsigned char)((chunk >> 8) & 0xff);
+    uint16_t inverse = (uint16_t)~chunk;
+    buffer[pos++] = (unsigned char)(inverse & 0xff);
+    buffer[pos++] = (unsigned char)((inverse >> 8) & 0xff);
+    if (chunk > 0) memcpy(buffer + pos, data + offset, chunk);
+    pos += chunk;
+    offset += chunk;
+  } while (offset < length);
+
+  xt_pipeline_le32(buffer + pos, xt_pipeline_crc32(data, length));
+  pos += 4;
+  xt_pipeline_le32(buffer + pos, (uint32_t)length);
+  pos += 4;
+  *out = buffer;
+  *outLength = pos;
+  return 1;
+}
+
+/* -- descriptor helpers --------------------------------------------------- */
+
+static const char *xt_pipeline_prop(xt_value object, const char *key) {
+  if (!XT_IS_OBJECT(object)) return NULL;
+  return xt_string_data(xt_to_string(xt_node_get(object, key)));
+}
+
+static int xt_pipeline_read_file(const char *path, unsigned char **data, size_t *length) {
+  FILE *file = fopen(path, "rb");
+  if (!file) return 0;
+  fseek(file, 0, SEEK_END);
+  long size = ftell(file);
+  fseek(file, 0, SEEK_SET);
+  if (size < 0) {
+    fclose(file);
+    return 0;
+  }
+  unsigned char *buffer = (unsigned char *)malloc((size_t)size + 1);
+  if (!buffer) {
+    fclose(file);
+    return 0;
+  }
+  size_t read = fread(buffer, 1, (size_t)size, file);
+  fclose(file);
+  buffer[read] = 0;
+  *data = buffer;
+  *length = read;
+  return 1;
+}
+
+static int xt_pipeline_write_file(const char *path, const unsigned char *data, size_t length) {
+  FILE *file = fopen(path, "wb");
+  if (!file) return 0;
+  size_t written = length > 0 ? fwrite(data, 1, length, file) : 0;
+  fclose(file);
+  return written == length;
+}
+
+/* -- pipeline ------------------------------------------------------------- */
+
+xt_value xt_node_stream_pipeline(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(xt_undefined());
+  const char *sourcePath = xt_pipeline_prop(argv[0], "_path");
+  const char *destPath = xt_pipeline_prop(argv[argc - 1], "_path");
+  if (!sourcePath || !destPath) return xt_promise_resolve(xt_undefined());
+
+  unsigned char *data = NULL;
+  size_t length = 0;
+  if (!xt_pipeline_read_file(sourcePath, &data, &length)) return xt_promise_resolve(xt_undefined());
+
+  for (int32_t i = 1; i < argc - 1; i++) {
+    const char *kind = xt_pipeline_prop(argv[i], "_kind");
+    if (kind && strcmp(kind, "gzip") == 0) {
+      unsigned char *compressed = NULL;
+      size_t compressedLength = 0;
+      if (xt_pipeline_gzip(data, length, &compressed, &compressedLength)) {
+        free(data);
+        data = compressed;
+        length = compressedLength;
+      }
+    }
+  }
+
+  xt_pipeline_write_file(destPath, data, length);
+  free(data);
+  return xt_promise_resolve(xt_undefined());
+}

package/runtime/ext_node/stream/stream.c

@@ -56,6 +56,24 @@ static xt_value xt_stream_deliver(xt_value stream, xt_value chunk) {
   return xt_bool(1);
 }
 
+/* Attaching a `data` listener drains anything `push`/`Readable.from` buffered
+ * before the listener existed, so no chunk is silently lost. */
+static xt_value xt_stream_method_on(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  xt_value result = xt_node_on_impl(thisValue, env, argc, argv);
+  const char *event = xt_node_cstr(xt_arg(argc, argv, 0));
+  if (event && strcmp(event, "data") == 0 && xt_stream_has_data_listener(thisValue)) {
+    xt_value buffer = xt_stream_buffer(thisValue);
+    int32_t count = (int32_t)xt_to_number(xt_array_length(buffer));
+    if (count > 0) {
+      xt_node_set(thisValue, "__readable", xt_array_new(0, NULL));
+      for (int32_t i = 0; i < count; i++) {
+        xt_node_emit1(thisValue, "data", xt_array_get(buffer, xt_number((double)i)));
+      }
+    }
+  }
+  return result;
+}
+
 static xt_value xt_stream_method_push(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   xt_value chunk = xt_arg(argc, argv, 0);
@@ -331,6 +349,8 @@ static xt_value xt_stream_proto(void) {
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
+  xt_node_define_method(proto, "on", (void *)xt_stream_method_on);
+  xt_node_define_method(proto, "addListener", (void *)xt_stream_method_on);
   xt_node_define_method(proto, "push", (void *)xt_stream_method_push);
   xt_node_define_method(proto, "unshift", (void *)xt_stream_method_unshift);
   xt_node_define_method(proto, "read", (void *)xt_stream_method_read);

package/runtime/ext_node/test/test.c

@@ -0,0 +1,102 @@
+/*
+ * Node.js `node:test` module for xbintsc.
+ *
+ * A compact, synchronous TAP runner. `test(name, fn)` runs the callback
+ * immediately, catching a thrown `AssertionError` (or any error) and emitting
+ * `ok` / `not ok` lines. A summary is printed once, at process exit, via
+ * `atexit`, and a failed run exits with status 1 like Node's runner.
+ *
+ * `import test from "node:test"` binds the callable default export
+ * (`xt_node_test`); `test.skip`, `test.todo` and the hook helpers are provided
+ * as no-op/wrapper variants.
+ */
+
+#include "../node_common.h"
+
+#include <string.h>
+
+static int xt_test_count = 0;
+static int xt_test_pass = 0;
+static int xt_test_fail = 0;
+static int xt_test_started = 0;
+static int xt_test_reported = 0;
+
+static void xt_test_report(void) {
+  if (xt_test_reported) return;
+  xt_test_reported = 1;
+  if (!xt_test_started) return;
+  fflush(stdout);
+  printf("1..%d\n", xt_test_count);
+  printf("# tests %d\n", xt_test_count);
+  printf("# pass %d\n", xt_test_pass);
+  if (xt_test_fail > 0) printf("# fail %d\n", xt_test_fail);
+  fflush(stdout);
+  if (xt_test_fail > 0) exit(1);
+}
+
+static void xt_test_begin(void) {
+  if (xt_test_started) return;
+  xt_test_started = 1;
+  printf("TAP version 13\n");
+  atexit(xt_test_report);
+}
+
+static const char *xt_test_name(int32_t argc, xt_value *argv) {
+  xt_value name = xt_arg(argc, argv, 0);
+  const char *text = name == XT_UNDEFINED ? NULL : xt_string_data(xt_to_string(name));
+  return text ? text : "<anonymous>";
+}
+
+xt_value xt_node_test(int32_t argc, xt_value *argv) {
+  xt_test_begin();
+  const char *name = xt_test_name(argc, argv);
+  xt_value fn = xt_arg(argc, argv, 1);
+  int index = ++xt_test_count;
+  printf("# Subtest: %s\n", name);
+  if (!XT_IS_FUNCTION(fn)) {
+    xt_test_pass += 1;
+    printf("ok %d - %s\n", index, name);
+    return xt_undefined();
+  }
+  void *frame = xt_try_enter();
+  if (xt_try_setjmp(frame) == 0) {
+    xt_closure_call(fn, 0, NULL);
+    xt_try_leave(frame);
+    xt_test_pass += 1;
+    printf("ok %d - %s\n", index, name);
+  } else {
+    xt_value error = xt_try_exception(frame);
+    xt_try_leave(frame);
+    xt_test_fail += 1;
+    printf("not ok %d - %s\n", index, name);
+    xt_value text = XT_IS_OBJECT(error) ? xt_error_to_string(error) : xt_to_string(error);
+    const char *message = xt_string_data(text);
+    printf("  ---\n  error: '%s'\n  ...\n", message ? message : "unknown error");
+  }
+  return xt_undefined();
+}
+
+xt_value xt_node_test_skip(int32_t argc, xt_value *argv) {
+  xt_test_begin();
+  const char *name = xt_test_name(argc, argv);
+  int index = ++xt_test_count;
+  xt_test_pass += 1;
+  printf("ok %d - %s # SKIP\n", index, name);
+  return xt_undefined();
+}
+
+xt_value xt_node_test_todo(int32_t argc, xt_value *argv) {
+  xt_test_begin();
+  const char *name = xt_test_name(argc, argv);
+  int index = ++xt_test_count;
+  xt_test_pass += 1;
+  printf("ok %d - %s # TODO\n", index, name);
+  return xt_undefined();
+}
+
+/* `before`/`after`/`beforeEach`/`afterEach` are accepted and ignored. */
+xt_value xt_node_test_hook(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  return xt_undefined();
+}