xbintsc 0.3.15 → 0.3.16

package/runtime/ext_node/fs/parts/encoding.inc

@@ -0,0 +1,186 @@
+/* -- encoding helpers ----------------------------------------------------- */
+
+static const char xt_fs_base64_alphabet[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* Accepts a bare encoding string or an options object with `encoding`. */
+static inline const char *xt_fs_encoding(xt_value options) {
+  if (XT_IS_STRING(options)) return xt_string_data(options);
+  if (XT_IS_OBJECT(options)) {
+    xt_value encoding = xt_object_get_cstr(options, "encoding");
+    if (XT_IS_STRING(encoding)) return xt_string_data(encoding);
+  }
+  return NULL;
+}
+
+static inline int xt_fs_is_hex(const char *encoding) {
+  return encoding && strcmp(encoding, "hex") == 0;
+}
+
+static inline int xt_fs_is_base64(const char *encoding) {
+  return encoding && strcmp(encoding, "base64") == 0;
+}
+
+static inline int xt_fs_is_base64url(const char *encoding) {
+  return encoding && strcmp(encoding, "base64url") == 0;
+}
+
+static inline int xt_fs_is_utf16(const char *encoding) {
+  return encoding && (strcmp(encoding, "utf16le") == 0 || strcmp(encoding, "ucs2") == 0 ||
+                      strcmp(encoding, "ucs-2") == 0 || strcmp(encoding, "utf-16le") == 0);
+}
+
+static inline xt_value xt_fs_encode_hex(const unsigned char *data, size_t length) {
+  static const char digits[] = "0123456789abcdef";
+  char *buffer = (char *)malloc(length * 2 + 1);
+  if (!buffer) return xt_undefined();
+  for (size_t i = 0; i < length; i++) {
+    buffer[i * 2] = digits[data[i] >> 4];
+    buffer[i * 2 + 1] = digits[data[i] & 0x0f];
+  }
+  xt_value result = xt_string_new(buffer, length * 2);
+  free(buffer);
+  return result;
+}
+
+static inline xt_value xt_fs_encode_base64(const unsigned char *data, size_t length) {
+  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)data[i] << 16) | ((uint32_t)data[i + 1] << 8) | (uint32_t)data[i + 2];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[n & 63];
+    i += 3;
+  }
+  if (length - i == 1) {
+    uint32_t n = (uint32_t)data[i] << 16;
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = '=';
+    buffer[j++] = '=';
+  } else if (length - i == 2) {
+    uint32_t n = ((uint32_t)data[i] << 16) | ((uint32_t)data[i + 1] << 8);
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = '=';
+  }
+  xt_value result = xt_string_new(buffer, j);
+  free(buffer);
+  return result;
+}
+
+/* Encode bytes for `readFileSync` according to `encoding` (default raw UTF-8). */
+static inline xt_value xt_fs_encode_base64url(const unsigned char *data, size_t length) {
+  size_t outLength = ((length + 2) / 3) * 4 + 1;
+  char *buffer = (char *)malloc(outLength);
+  if (!buffer) return xt_undefined();
+  size_t i = 0, j = 0;
+  while (i + 2 < length) {
+    uint32_t n = ((uint32_t)data[i] << 16) | ((uint32_t)data[i + 1] << 8) | (uint32_t)data[i + 2];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 6) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[n & 63];
+    i += 3;
+  }
+  if (length - i == 1) {
+    uint32_t n = (uint32_t)data[i] << 16;
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+  } else if (length - i == 2) {
+    uint32_t n = ((uint32_t)data[i] << 16) | ((uint32_t)data[i + 1] << 8);
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 18) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 12) & 63];
+    buffer[j++] = xt_fs_base64_alphabet[(n >> 6) & 63];
+  }
+  for (size_t k = 0; k < j; k++) {
+    if (buffer[k] == '+') buffer[k] = '-';
+    else if (buffer[k] == '/') buffer[k] = '_';
+  }
+  xt_value result = xt_string_new(buffer, j);
+  free(buffer);
+  return result;
+}
+
+static inline xt_value xt_fs_encode_bytes(const unsigned char *data, size_t length, const char *encoding) {
+  if (xt_fs_is_hex(encoding)) return xt_fs_encode_hex(data, length);
+  if (xt_fs_is_base64(encoding)) return xt_fs_encode_base64(data, length);
+  if (xt_fs_is_base64url(encoding)) return xt_fs_encode_base64url(data, length);
+  return xt_string_new((const char *)data, length);
+}
+
+static inline int xt_fs_base64_value(char c) {
+  if (c >= 'A' && c <= 'Z') return c - 'A';
+  if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+  if (c >= '0' && c <= '9') return c - '0' + 52;
+  if (c == '+' || c == '-') return 62;
+  if (c == '/' || c == '_') return 63;
+  return -1;
+}
+
+static inline int xt_fs_hex_value(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;
+}
+
+/*
+ * Decode text for `writeFileSync` according to `encoding`. Returns a malloc'd
+ * byte buffer (never NULL unless allocation failed) and stores its length in
+ * `*outLength`; the caller frees it.
+ */
+static inline unsigned char *xt_fs_decode_text(const char *text, size_t length, const char *encoding, size_t *outLength) {
+  unsigned char *bytes = NULL;
+  if (xt_fs_is_base64(encoding) || xt_fs_is_base64url(encoding)) {
+    size_t capacity = (length / 4 + 1) * 3;
+    bytes = (unsigned char *)malloc(capacity + 1);
+    if (!bytes) return NULL;
+    size_t written = 0;
+    int accumulator = 0, bits = 0;
+    for (size_t i = 0; i < length; i++) {
+      if (text[i] == '=') break;
+      int value = xt_fs_base64_value(text[i]);
+      if (value < 0) continue;
+      accumulator = (accumulator << 6) | value;
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        bytes[written++] = (unsigned char)((accumulator >> bits) & 0xff);
+      }
+    }
+    bytes[written] = '\0';
+    *outLength = written;
+    return bytes;
+  }
+  if (xt_fs_is_hex(encoding)) {
+    bytes = (unsigned char *)malloc(length / 2 + 1);
+    if (!bytes) return NULL;
+    size_t written = 0;
+    int high = -1;
+    for (size_t i = 0; i < length; i++) {
+      int value = xt_fs_hex_value(text[i]);
+      if (value < 0) continue;
+      if (high < 0) {
+        high = value;
+      } else {
+        bytes[written++] = (unsigned char)((high << 4) | value);
+        high = -1;
+      }
+    }
+    bytes[written] = '\0';
+    *outLength = written;
+    return bytes;
+  }
+  bytes = (unsigned char *)malloc(length + 1);
+  if (!bytes) return NULL;
+  if (length > 0) memcpy(bytes, text, length);
+  bytes[length] = '\0';
+  *outLength = length;
+  return bytes;
+}

package/runtime/ext_node/fs/parts/errors.inc

@@ -0,0 +1,66 @@
+/* -- errors --------------------------------------------------------------- */
+
+/* Node's `err.code` for the errno values the fs module can raise. */
+static inline const char *xt_fs_errno_name(int err) {
+  switch (err) {
+    case ENOENT: return "ENOENT";
+    case EACCES: return "EACCES";
+    case EEXIST: return "EEXIST";
+    case ENOTDIR: return "ENOTDIR";
+    case EISDIR: return "EISDIR";
+    case EPERM: return "EPERM";
+    case EINVAL: return "EINVAL";
+    case EBADF: return "EBADF";
+    case ENOSPC: return "ENOSPC";
+    case EROFS: return "EROFS";
+    case EMFILE: return "EMFILE";
+#ifdef ENOTEMPTY
+    case ENOTEMPTY: return "ENOTEMPTY";
+#endif
+#ifdef ELOOP
+    case ELOOP: return "ELOOP";
+#endif
+#ifdef ENAMETOOLONG
+    case ENAMETOOLONG: return "ENAMETOOLONG";
+#endif
+#ifdef EXDEV
+    case EXDEV: return "EXDEV";
+#endif
+    default: return "UNKNOWN";
+  }
+}
+
+/* Build a Node-shaped Error (`code`/`errno`/`syscall`/`path`/`message`). */
+static inline xt_value xt_fs_error_object(int err, const char *syscall, const char *path) {
+  const char *code = xt_fs_errno_name(err);
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "%s: %s, %s '%s'", code, strerror(err), syscall ? syscall : "",
+           path ? path : "");
+  xt_value error = xt_object_new();
+  ((xt_object *)XT_GET_PTR(error))->header.kind = XT_OBJECT_KIND_ERROR;
+  xt_object_set(error, xt_string_from_cstr("name"), xt_string_from_cstr("Error"));
+  xt_object_set(error, xt_string_from_cstr("message"), xt_string_from_cstr(buffer));
+  xt_object_set(error, xt_string_from_cstr("code"), xt_string_from_cstr(code));
+  xt_object_set(error, xt_string_from_cstr("errno"), xt_number((double)(-err)));
+  if (syscall) xt_object_set(error, xt_string_from_cstr("syscall"), xt_string_from_cstr(syscall));
+  if (path) xt_object_set(error, xt_string_from_cstr("path"), xt_string_from_cstr(path));
+  return error;
+}
+
+/* Raise `errno` (captured by the caller right after a failed syscall). */
+static inline void xt_fs_raise_errno(int err, const char *syscall, const char *path) {
+  xt_throw(xt_fs_error_object(err, syscall, path));
+}
+
+static inline void xt_fs_raise_path(const char *syscall, const char *path) {
+  xt_fs_raise_errno(errno, syscall, path);
+}
+
+/*
+ * Report a failed syscall. The fs module follows Node and *throws* a shaped
+ * Error (the runtime now has catchable exceptions), so callers must not rely
+ * on a return value after a failure.
+ */
+static inline void xt_fs_error(const char *action, const char *path) {
+  xt_fs_raise_errno(errno, action, path);
+}

package/runtime/ext_node/fs/parts/flags.inc

@@ -0,0 +1,39 @@
+/* -- open-flag parsing ---------------------------------------------------- */
+
+#if defined(_WIN32)
+#define XT_FS_BINARY_FLAG _O_BINARY
+#define XT_FS_RDONLY _O_RDONLY
+#define XT_FS_WRONLY _O_WRONLY
+#define XT_FS_RDWR _O_RDWR
+#define XT_FS_CREAT _O_CREAT
+#define XT_FS_TRUNC _O_TRUNC
+#define XT_FS_APPEND _O_APPEND
+#define XT_FS_EXCL _O_EXCL
+#else
+#define XT_FS_BINARY_FLAG 0
+#define XT_FS_RDONLY O_RDONLY
+#define XT_FS_WRONLY O_WRONLY
+#define XT_FS_RDWR O_RDWR
+#define XT_FS_CREAT O_CREAT
+#define XT_FS_TRUNC O_TRUNC
+#define XT_FS_APPEND O_APPEND
+#define XT_FS_EXCL O_EXCL
+#endif
+
+/* Translate a Node flag string (`"r"`, `"w+"`, `"a"`, ...) or number. */
+static inline int xt_fs_parse_flags(xt_value value) {
+  if (XT_IS_STRING(value)) {
+    const char *flag = xt_string_data(value);
+    if (!flag) return XT_FS_RDONLY | XT_FS_BINARY_FLAG;
+    int plus = strchr(flag, '+') != NULL;
+    int excl = strchr(flag, 'x') != NULL;
+    int base;
+    if (flag[0] == 'a') base = XT_FS_APPEND | XT_FS_CREAT;
+    else if (flag[0] == 'w') base = XT_FS_CREAT | XT_FS_TRUNC;
+    else base = 0; /* 'r' and the numeric path below */
+    base |= (plus || flag[0] == 'w' || flag[0] == 'a') ? XT_FS_RDWR : XT_FS_RDONLY;
+    if (excl) base |= XT_FS_EXCL;
+    return base | XT_FS_BINARY_FLAG;
+  }
+  return (int)xt_to_number(value) | XT_FS_BINARY_FLAG;
+}

package/runtime/ext_node/fs/parts/platform.inc

@@ -0,0 +1,86 @@
+/* -- platform shims ------------------------------------------------------- */
+
+#if defined(_WIN32)
+#include <direct.h>
+#include <fcntl.h>
+#include <io.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+/* Stat results are filled from Win32 directly. The CRT's `_stat` converts the
+ * FILETIME through the *local* time zone before producing `time_t`, so a time
+ * near the Unix epoch (e.g. `utimesSync(path, 1000, 2000)`) maps to 1969 on a
+ * machine west of UTC and the CRT reports an unrepresentable `st_mtime` (-1).
+ * Reading the Win32 FILETIME and converting it to Unix seconds in UTC like
+ * libuv/Node keeps the values exact and timezone independent. */
+typedef struct {
+  long long st_size;
+  unsigned int st_mode;
+  unsigned int st_uid;
+  unsigned int st_gid;
+  unsigned int st_dev;
+  unsigned long long st_ino;
+  unsigned int st_nlink;
+  unsigned int st_rdev;
+  long long st_mtime; /* seconds since the Unix epoch */
+  long long st_atime;
+  long long st_ctime;
+} xt_fs_stat_t;
+
+int xt_fs_win_stat(const char *path, xt_fs_stat_t *out);
+int xt_fs_win_lstat(const char *path, xt_fs_stat_t *out);
+int xt_fs_win_fstat(int fd, xt_fs_stat_t *out);
+#define xt_fs_stat_fn xt_fs_win_stat
+#define xt_fs_lstat_fn xt_fs_win_lstat
+#define xt_fs_fstat_fn xt_fs_win_fstat
+#define xt_fs_access _access
+#define xt_fs_mkdir_mode(path, mode) _mkdir(path)
+#define xt_fs_mkdir_one(path) _mkdir(path)
+#define xt_fs_rmdir_one(path) _rmdir(path)
+#define XT_FS_OPEN _open
+#define XT_FS_CLOSE _close
+#define XT_FS_READ _read
+#define XT_FS_WRITE _write
+
+#ifndef S_ISREG
+#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
+#endif
+#ifndef S_ISLNK
+#define S_ISLNK(m) 0
+#endif
+#ifndef S_ISFIFO
+#define S_ISFIFO(m) 0
+#endif
+#ifndef S_ISSOCK
+#define S_ISSOCK(m) 0
+#endif
+#ifndef S_ISBLK
+#define S_ISBLK(m) 0
+#endif
+#ifndef S_ISCHR
+#define S_ISCHR(m) (((m) & _S_IFMT) == _S_IFCHR)
+#endif
+#ifndef F_OK
+#define F_OK 0
+#endif
+#else
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+typedef struct stat xt_fs_stat_t;
+#define xt_fs_stat_fn stat
+#define xt_fs_lstat_fn lstat
+#define xt_fs_access access
+#define xt_fs_mkdir_mode(path, mode) mkdir((path), (mode))
+#define xt_fs_mkdir_one(path) mkdir(path, 0777)
+#define xt_fs_rmdir_one(path) rmdir(path)
+#define XT_FS_OPEN open
+#define XT_FS_CLOSE close
+#define XT_FS_READ read
+#define XT_FS_WRITE write
+#endif

package/runtime/ext_node/fs/parts/promisify.inc

@@ -0,0 +1,15 @@
+/* -- promise wrapper ------------------------------------------------------ */
+
+/* A promise wrapper over a synchronous builtin: an immediately settled
+ * promise that is rejected (rather than throwing) when the builtin raises. */
+static inline xt_value xt_fs_promisify(xt_value (*fn)(int32_t, xt_value *), int32_t argc, xt_value *argv) {
+  void *frame = xt_try_enter();
+  if (xt_try_setjmp(frame) == 0) {
+    xt_value result = fn(argc, argv);
+    xt_try_leave(frame);
+    return xt_promise_resolve(result);
+  }
+  xt_value exception = xt_try_exception(frame);
+  xt_try_leave(frame);
+  return xt_promise_reject(exception);
+}

package/runtime/ext_node/fs/parts/time.inc

@@ -0,0 +1,9 @@
+/* -- time helpers --------------------------------------------------------- */
+
+/* Node accepts a Date or a number of seconds; Date stores milliseconds. */
+static inline double xt_fs_time_seconds(xt_value value) {
+  if (XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_DATE) {
+    return ((xt_date *)XT_GET_PTR(value))->time / 1000.0;
+  }
+  return xt_to_number(value);
+}

package/runtime/rt.h

@@ -241,6 +241,39 @@ void xt_loop_remove(int fd);
 void xt_run_event_loop(void);
 int xt_loop_has_work(void);
 
+/**
+ * Run one iteration of the reactor, waiting up to `timeout_ms` for readiness
+ * (`< 0` blocks until an event arrives, `0` polls without sleeping), and then
+ * fire any timers that have come due. The wait is shortened to the nearest
+ * timer deadline so a timer-only program still sleeps. Returns the number of
+ * active watchers (descriptors plus timers) still registered, or a negative
+ * value when the wait itself failed.
+ *
+ * Hosts that own their main loop (a GUI toolkit, an embedder, ...) call this
+ * periodically instead of `xt_run_event_loop` so timers, sockets and promise
+ * microtasks keep draining between their own events. When there is no work it
+ * returns immediately, so a host with no I/O is unaffected.
+ */
+int xt_loop_poll(int timeout_ms);
+
+/**
+ * A host-provided main loop. When set, `xt_run_event_loop` delegates to it
+ * instead of blocking on `select(2)`. This lets an extension drive the process
+ * main loop (e.g. a window toolkit on the UI thread) while still pumping the
+ * reactor through `xt_loop_poll`. Call with `NULL` to restore the default.
+ */
+typedef void (*xt_main_loop_fn)(void);
+void xt_loop_set_main(xt_main_loop_fn fn);
+
+/* -- timers --------------------------------------------------------------- */
+/* The JS timer globals, implemented on top of the reactor above. Each returns
+ * a numeric id (or `undefined` for the `clear*` pair); callbacks are ordinary
+ * closure values and extra arguments after the delay are forwarded to them. */
+xt_value xt_set_timeout(int32_t argc, xt_value *argv);
+xt_value xt_clear_timeout(int32_t argc, xt_value *argv);
+xt_value xt_set_interval(int32_t argc, xt_value *argv);
+xt_value xt_clear_interval(int32_t argc, xt_value *argv);
+
 /* -- global functions ------------------------------------------------------ */
 xt_value xt_parse_int(int32_t argc, xt_value *argv);
 xt_value xt_parse_float(int32_t argc, xt_value *argv);

package/runtime/xt_builtins.c

@@ -301,6 +301,10 @@ XT_BUILTIN_TRAMPOLINE(xt_builtin_value_encodeURIComponent, xt_encode_uri_compone
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_encodeURI, xt_encode_uri)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_decodeURIComponent, xt_decode_uri_component)
 XT_BUILTIN_TRAMPOLINE(xt_builtin_value_decodeURI, xt_decode_uri)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_setTimeout, xt_set_timeout)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_clearTimeout, xt_clear_timeout)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_setInterval, xt_set_interval)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_clearInterval, xt_clear_interval)
 
 xt_value xt_in(xt_value key, xt_value value) {
   if (XT_IS_OBJECT(value)) return xt_object_has(value, key);

package/runtime/xt_containers/access.inc

@@ -0,0 +1,168 @@
+/* ------------------------------------------------------------------------- */
+/* Generic member access                                                     */
+/* ------------------------------------------------------------------------- */
+
+/*
+ * Reading a property of `null` / `undefined` is a TypeError in JavaScript.
+ * Short-circuiting `?.` guards forbid reaching this point for a nullish
+ * receiver, so a non-optional access on a nullish base is a genuine bug in
+ * the compiled program (e.g. `o?.a.b` where `o.a` is null).
+ */
+static void xt_throw_read_of_nullish(xt_value target, xt_value key) {
+  const char *base = target == XT_NULL ? "null" : "undefined";
+  char keybuf[128];
+  xt_string *k = XT_IS_STRING(key) ? xt_as_string(key) : xt_as_string(xt_to_string(key));
+  uint32_t n = k->length < sizeof(keybuf) - 1 ? k->length : (uint32_t)(sizeof(keybuf) - 1);
+  memcpy(keybuf, k->data, n);
+  keybuf[n] = 0;
+  char message[256];
+  snprintf(message, sizeof(message),
+           "TypeError: Cannot read properties of %s (reading '%s')", base, keybuf);
+  xt_throw(xt_string_from_cstr(message));
+}
+
+xt_value xt_get(xt_value target, xt_value key) {
+  if (target == XT_UNDEFINED || target == XT_NULL) xt_throw_read_of_nullish(target, key);
+  if (XT_IS_ARRAY(target)) {
+    /* `arr.length` must read the array's length, never an element. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0)
+        return xt_number((double)((xt_array *)XT_GET_PTR(target))->length);
+      /* Named (non-index) properties such as `raw`/`index`/`input`. */
+      uint32_t ignored = 0;
+      if (!xt_key_is_array_index(k, &ignored)) {
+        xt_value extra = xt_array_extra((xt_array *)XT_GET_PTR(target), 0);
+        if (extra != XT_UNDEFINED) {
+          xt_value value = xt_object_get(extra, key);
+          if (value != XT_UNDEFINED) return value;
+        }
+        /* Fall back to first-class built-in methods (`arr.map`). */
+        return xt_method_value(target, key);
+      }
+      return xt_array_get(target, key);
+    }
+    /* Symbol-keyed properties live in the side object too. */
+    if (xt_is_symbol(key)) {
+      xt_value extra = xt_array_extra((xt_array *)XT_GET_PTR(target), 0);
+      if (extra != XT_UNDEFINED) {
+        xt_value value = xt_object_get(extra, key);
+        if (value != XT_UNDEFINED) return value;
+      }
+      return xt_method_value(target, key);
+    }
+    return xt_array_get(target, key);
+  }
+  if (XT_IS_FUNCTION(target)) {
+    /* Functions expose own `name` / `length` (arity) properties. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+        int32_t arity = ((xt_function *)XT_GET_PTR(target))->arity;
+        return xt_number(arity >= 0 ? (double)arity : 0.0);
+      }
+      if (k->length == 4 && memcmp(k->data, "name", 4) == 0) {
+        xt_string *name = ((xt_function *)XT_GET_PTR(target))->name;
+        return name ? XT_FROM_PTR(XT_TAG_STRING, name) : xt_string_from_cstr("");
+      }
+    }
+    {
+      xt_value value = xt_object_get(target, key);
+      if (value != XT_UNDEFINED) return value;
+      return xt_method_value(target, key);
+    }
+  }
+  if (XT_IS_OBJECT(target)) {
+    /* Map/Set expose `.size`; promises, dates and regexps have their own
+     * getters implemented in the standard library. */
+    xt_object *obj = (xt_object *)XT_GET_PTR(target);
+    if (obj->header.kind == XT_OBJECT_KIND_SYMBOL) {
+      if (XT_IS_STRING(key)) {
+        xt_string *k = xt_as_string(key);
+        if (k->length == 11 && memcmp(k->data, "description", 11) == 0) {
+          return xt_symbol_description(target);
+        }
+      }
+      return xt_method_value(target, key);
+    }
+    if (obj->header.kind == XT_OBJECT_KIND_MAP || obj->header.kind == XT_OBJECT_KIND_SET) {
+      if (XT_IS_STRING(key)) {
+        xt_string *k = xt_as_string(key);
+        if (k->length == 4 && memcmp(k->data, "size", 4) == 0) {
+          int32_t size = obj->header.kind == XT_OBJECT_KIND_MAP ? xt_map_size(target) : xt_set_size(target);
+          return xt_number((double)size);
+        }
+      }
+    }
+    if (obj->header.kind == XT_OBJECT_KIND_REGEXP) {
+      xt_value regexpValue = xt_regexp_get_property(target, key);
+      if (regexpValue != XT_UNDEFINED) return regexpValue;
+    }
+    if (obj->header.kind == XT_OBJECT_KIND_ERROR && XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 5 && memcmp(k->data, "stack", 5) == 0) {
+        xt_value own = xt_object_get(target, key);
+        return own != XT_UNDEFINED ? own : xt_error_to_string(target);
+      }
+    }
+    {
+      xt_value value = xt_object_get(target, key);
+      if (value != XT_UNDEFINED) return value;
+      return xt_method_value(target, key);
+    }
+  }
+  if (XT_IS_STRING(target)) {
+    /* Property access on a string: `.length`, numeric indexing and built-in
+     * methods. */
+    xt_string *s = xt_as_string(target);
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return xt_number((double)s->length);
+      uint32_t index = 0;
+      if (xt_key_is_array_index(k, &index) && index < s->length) {
+        return xt_string_new(s->data + index, 1);
+      }
+      return xt_method_value(target, key);
+    }
+    if (XT_IS_NUMBER(key)) {
+      int32_t index = xt_to_int32(key);
+      if (index >= 0 && (uint32_t)index < s->length) return xt_string_new(s->data + index, 1);
+    }
+    return XT_UNDEFINED;
+  }
+  if (XT_IS_STRING(key) &&
+      (XT_IS_NUMBER(target) || XT_IS_BIGINT(target) || target == XT_TRUE || target == XT_FALSE)) {
+    return xt_method_value(target, key);
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_set(xt_value target, xt_value key, xt_value value) {
+  if (XT_IS_ARRAY(target)) {
+    /* Assigning `arr.length` truncates or extends the array. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+        xt_array *array = (xt_array *)XT_GET_PTR(target);
+        int32_t n = xt_to_int32(value);
+        if (n < 0) n = 0;
+        xt_array_reserve(array, (uint32_t)n);
+        for (uint32_t j = array->length; j < (uint32_t)n; j++) array->items[j] = XT_UNDEFINED;
+        array->length = (uint32_t)n;
+        return value;
+      }
+      uint32_t ignored = 0;
+      if (!xt_key_is_array_index(k, &ignored)) {
+        return xt_object_set(xt_array_extra((xt_array *)XT_GET_PTR(target), 1), key, value);
+      }
+      return xt_array_set(target, key, value);
+    }
+    if (xt_is_symbol(key)) {
+      return xt_object_set(xt_array_extra((xt_array *)XT_GET_PTR(target), 1), key, value);
+    }
+    return xt_array_set(target, key, value);
+  }
+  if (XT_IS_FUNCTION(target)) return xt_object_set(target, key, value);
+  if (XT_IS_OBJECT(target)) return xt_object_set(target, key, value);
+  return value;
+}