xbintsc 0.5.6 → 0.5.21

package/runtime/ext_node/fs/fs_ops.c

@@ -33,6 +33,22 @@ xt_value xt_node_exists(int32_t argc, xt_value *argv) {
    `readdirSync(path, { withFileTypes: true })` reuse the same closures. */
 static void xt_fs_define_stat_method(xt_value object, const char *name, unsigned int mode);
 
+/* Build the Node `Dirent`-shaped object from an already-known mode. The async
+   promise layer collects the mode on its worker so it does not have to `stat`
+   the entry again on the main thread. */
+xt_value xt_node_dirent_named(const char *name, unsigned int mode) {
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("name"), xt_string_from_cstr(name));
+  xt_fs_define_stat_method(object, "isFile", mode);
+  xt_fs_define_stat_method(object, "isDirectory", mode);
+  xt_fs_define_stat_method(object, "isSymbolicLink", mode);
+  xt_fs_define_stat_method(object, "isFIFO", mode);
+  xt_fs_define_stat_method(object, "isSocket", mode);
+  xt_fs_define_stat_method(object, "isBlockDevice", mode);
+  xt_fs_define_stat_method(object, "isCharacterDevice", mode);
+  return object;
+}
+
 /* Build the Node `Dirent`-shaped object (`name` plus stat predicates) for a
    single directory entry. Types come from `lstat`, matching Node's `d_type`
    based `Dirent` (a symlink reports `isSymbolicLink()` true). */
@@ -46,17 +62,7 @@ xt_value xt_node_dirent_result(const char *dir, const char *name) {
     if (xt_fs_lstat_fn(full, &info) == 0) mode = (unsigned int)info.st_mode;
     free(full);
   }
-
-  xt_value object = xt_object_new();
-  xt_object_set(object, xt_string_from_cstr("name"), xt_string_from_cstr(name));
-  xt_fs_define_stat_method(object, "isFile", mode);
-  xt_fs_define_stat_method(object, "isDirectory", mode);
-  xt_fs_define_stat_method(object, "isSymbolicLink", mode);
-  xt_fs_define_stat_method(object, "isFIFO", mode);
-  xt_fs_define_stat_method(object, "isSocket", mode);
-  xt_fs_define_stat_method(object, "isBlockDevice", mode);
-  xt_fs_define_stat_method(object, "isCharacterDevice", mode);
-  return object;
+  return xt_node_dirent_named(name, mode);
 }
 
 /* Entries accumulate in an `xt_array`, not a raw `xt_value` buffer: the
@@ -149,24 +155,7 @@ static int xt_fs_recursive(xt_value options) {
 }
 
 static int xt_fs_mkdir_recursive(const char *path, int mode) {
-  size_t length = strlen(path);
-  char *copy = (char *)malloc(length + 1);
-  if (!copy) return -1;
-  memcpy(copy, path, length + 1);
-
-  while (length > 1 && copy[length - 1] == '/') copy[--length] = '\0';
-  for (size_t i = 1; i <= length; i++) {
-    if (copy[i] != '/' && copy[i] != '\0') continue;
-    char saved = copy[i];
-    copy[i] = '\0';
-    if (xt_fs_mkdir_mode(copy, mode) != 0 && errno != EEXIST) {
-      free(copy);
-      return -1;
-    }
-    copy[i] = saved;
-  }
-  free(copy);
-  return 0;
+  return xt_fs_mkdir_parents(path, mode);
 }
 
 xt_value xt_node_mkdir(int32_t argc, xt_value *argv) {

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

@@ -2,6 +2,7 @@
 
 xt_value xt_node_stat_result(const xt_fs_stat_t *info);
 xt_value xt_node_dirent_result(const char *dir, const char *name);
+xt_value xt_node_dirent_named(const char *name, unsigned int mode);
 
 /* -- synchronous fs builtins (one translation unit per group) ------------- */
 
@@ -64,6 +65,39 @@ xt_value xt_node_watch(int32_t argc, xt_value *argv);
 xt_value xt_node_watch_file(int32_t argc, xt_value *argv);
 xt_value xt_node_unwatch_file(int32_t argc, xt_value *argv);
 
+/* async_api.c — promise-returning counterparts, backed by the async I/O pool */
+xt_value xt_node_p_read_file(int32_t argc, xt_value *argv);
+xt_value xt_node_p_write_file(int32_t argc, xt_value *argv);
+xt_value xt_node_p_append_file(int32_t argc, xt_value *argv);
+xt_value xt_node_p_mkdir(int32_t argc, xt_value *argv);
+xt_value xt_node_p_readdir(int32_t argc, xt_value *argv);
+xt_value xt_node_p_rm(int32_t argc, xt_value *argv);
+xt_value xt_node_p_unlink(int32_t argc, xt_value *argv);
+xt_value xt_node_p_rmdir(int32_t argc, xt_value *argv);
+xt_value xt_node_p_rename(int32_t argc, xt_value *argv);
+xt_value xt_node_p_copy_file(int32_t argc, xt_value *argv);
+xt_value xt_node_p_cp(int32_t argc, xt_value *argv);
+xt_value xt_node_p_realpath(int32_t argc, xt_value *argv);
+xt_value xt_node_p_stat(int32_t argc, xt_value *argv);
+xt_value xt_node_p_lstat(int32_t argc, xt_value *argv);
+xt_value xt_node_p_statfs(int32_t argc, xt_value *argv);
+xt_value xt_node_p_access(int32_t argc, xt_value *argv);
+xt_value xt_node_p_open(int32_t argc, xt_value *argv);
+xt_value xt_node_p_chmod(int32_t argc, xt_value *argv);
+xt_value xt_node_p_lchmod(int32_t argc, xt_value *argv);
+xt_value xt_node_p_chown(int32_t argc, xt_value *argv);
+xt_value xt_node_p_lchown(int32_t argc, xt_value *argv);
+xt_value xt_node_p_truncate(int32_t argc, xt_value *argv);
+xt_value xt_node_p_utimes(int32_t argc, xt_value *argv);
+xt_value xt_node_p_lutimes(int32_t argc, xt_value *argv);
+xt_value xt_node_p_link(int32_t argc, xt_value *argv);
+xt_value xt_node_p_symlink(int32_t argc, xt_value *argv);
+xt_value xt_node_p_readlink(int32_t argc, xt_value *argv);
+xt_value xt_node_p_mkdtemp(int32_t argc, xt_value *argv);
+xt_value xt_node_p_opendir(int32_t argc, xt_value *argv);
+xt_value xt_node_p_glob(int32_t argc, xt_value *argv);
+xt_value xt_node_p_watch(int32_t argc, xt_value *argv);
+
 /* constants.c */
 xt_value xt_fs_constants(void);
 xt_value xt_fs_promises(void);

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

@@ -84,3 +84,69 @@ typedef struct stat xt_fs_stat_t;
 #define XT_FS_READ read
 #define XT_FS_WRITE write
 #endif
+
+/* -- recursive directory creation ----------------------------------------- */
+/* `mkdir -p` splits a path at its separators and creates every prefix. A
+ * Windows volume prefix must be skipped: `_mkdir("C:")` is not "the C: root" but
+ * a drive-relative path that resolves against that drive's current directory,
+ * so it fails with EACCES. Creating the prefixes of `C:\...` (e.g. anything
+ * under %TEMP%) used to abort on that first component while paths on the
+ * process's current drive appeared to work. */
+
+static inline int xt_fs_is_sep(char c) {
+#if defined(_WIN32)
+  return c == '/' || c == '\\';
+#else
+  return c == '/';
+#endif
+}
+
+/* Byte index of the first directory component that may be created: 0 for a
+ * relative or POSIX path, past `C:` / `\\server\share` on Windows. */
+static inline size_t xt_fs_path_root(const char *path) {
+#if defined(_WIN32)
+  if ((path[0] == '\\' || path[0] == '/') && (path[1] == '\\' || path[1] == '/')) {
+    size_t i = 2;
+    for (int separators = 0; separators < 2 && path[i]; ) {
+      if (xt_fs_is_sep(path[i])) separators++;
+      i++;
+    }
+    return i;
+  }
+  if (path[0] != '\0' && path[1] == ':') {
+    size_t i = 2;
+    while (xt_fs_is_sep(path[i])) i++;
+    return i;
+  }
+#endif
+  return 0;
+}
+
+/* Create `path` and every missing ancestor, tolerating existing directories.
+ * Returns 0 or -1 with `errno` set by the failed `mkdir`. */
+static inline int xt_fs_mkdir_parents(const char *path, int mode) {
+  size_t length = strlen(path);
+  char *copy = (char *)malloc(length + 1);
+  if (!copy) return -1;
+  memcpy(copy, path, length + 1);
+  while (length > 1 && xt_fs_is_sep(copy[length - 1])) copy[--length] = '\0';
+
+  int status = 0;
+  size_t start = xt_fs_path_root(copy);
+  if (start < length) {
+    /* A driver prefix is already consumed; otherwise index 0 is a separator
+     * for absolute paths and the first byte for relative ones. */
+    for (size_t i = start > 0 ? start : 1; i <= length; i++) {
+      if (!xt_fs_is_sep(copy[i]) && copy[i] != '\0') continue;
+      char saved = copy[i];
+      copy[i] = '\0';
+      if (xt_fs_mkdir_mode(copy, mode) != 0 && errno != EEXIST) {
+        status = -1;
+        break;
+      }
+      copy[i] = saved;
+    }
+  }
+  free(copy);
+  return status;
+}

package/runtime/ext_node/fs/promises.c

@@ -1,244 +1,54 @@
 /*
- * Node.js `fs/promises` for xbintsc.
+ * `fs.promises` facade for xbintsc.
  *
- * xbintsc has no asynchronous I/O scheduler, so these builtins reuse the
- * synchronous `fs` implementations and wrap the result in a promise that is
- * already settled. `await`/`.then` therefore work as expected while the actual
- * work happens synchronously. A synchronous failure is turned into a rejected
- * promise instead of a thrown exception (matching Node's contract).
- *
- * `open()` resolves to a `FileHandle`-shaped object (a plain object with an
- * `fd` property and the usual methods); there is no shared prototype yet, so
- * `handle instanceof FileHandle` is not supported.
+ * The individual exports are implemented in async_api.c on top of the async I/O
+ * pool: their promises settle when a worker finishes, so awaiting them yields
+ * to timers, sockets and other suspending work. This file only builds the
+ * `fs.promises` namespace object (reachable as `fs.promises` and as the imported
+ * `fs/promises` module).
  */
 
-#include "../node_common.h"
-#include "fs_common.h"
-
-/* ------------------------------------------------------------------------- */
-/* FileHandle                                                                */
-/* ------------------------------------------------------------------------- */
-
-static xt_value xt_fh_method(xt_value thisValue, xt_value (*fn)(int32_t, xt_value *), int32_t argc, xt_value *argv,
-                             int prefix) {
-  xt_value args[10];
-  int32_t count = 0;
-  if (prefix >= 1) args[count++] = xt_object_get_cstr(thisValue, "fd");
-  if (prefix >= 2) args[count++] = xt_object_get_cstr(thisValue, "fd2");
-  for (int32_t i = 0; i < argc && count < 10; i++) args[count++] = argv[i];
-  return xt_fs_promisify(fn, count, args);
-}
-
-static xt_value xt_fh_read(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_read, argc, argv, 1);
-}
-
-static xt_value xt_fh_write(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_write, argc, argv, 1);
-}
-
-static xt_value xt_fh_close(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_close, argc, argv, 1);
-}
-
-static xt_value xt_fh_stat(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_fstat, argc, argv, 1);
-}
-
-static xt_value xt_fh_truncate(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_ftruncate, argc, argv, 1);
-}
-
-static xt_value xt_fh_chmod(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_fchmod, argc, argv, 1);
-}
-
-static xt_value xt_fh_chown(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_fchown, argc, argv, 1);
-}
-
-static xt_value xt_fh_utimes(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_futimes, argc, argv, 1);
-}
-
-static xt_value xt_fh_sync(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_fsync, argc, argv, 1);
-}
-
-static xt_value xt_fh_datasync(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  return xt_fh_method(thisValue, xt_node_fdatasync, argc, argv, 1);
-}
-
-/* Read from the handle's current position to EOF; caller frees. */
-static unsigned char *xt_fh_slurp(int fd, size_t *outLength) {
-  size_t capacity = 8192;
-  size_t length = 0;
-  unsigned char *bytes = (unsigned char *)malloc(capacity);
-  if (!bytes) return NULL;
-  for (;;) {
-    if (length == capacity) {
-      capacity *= 2;
-      unsigned char *grown = (unsigned char *)realloc(bytes, capacity);
-      if (!grown) {
-        free(bytes);
-        return NULL;
-      }
-      bytes = grown;
-    }
-    ssize_t bytesRead = XT_FS_READ(fd, bytes + length, capacity - length);
-    if (bytesRead < 0) {
-      free(bytes);
-      return NULL;
-    }
-    if (bytesRead == 0) break;
-    length += (size_t)bytesRead;
-  }
-  *outLength = length;
-  return bytes;
-}
-
-static xt_value xt_fh_read_all(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  int fd = (int)xt_to_number(xt_object_get_cstr(thisValue, "fd"));
-  const char *encoding = argc > 0 ? xt_fs_encoding(argv[0]) : NULL;
-  size_t length = 0;
-  unsigned char *bytes = xt_fh_slurp(fd, &length);
-  if (!bytes) return xt_promise_reject(xt_fs_error_object(errno, "read", NULL));
-  xt_value result = xt_fs_encode_bytes(bytes, length, encoding);
-  free(bytes);
-  return xt_promise_resolve(result);
-}
-
-static xt_value xt_fh_write_all(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  xt_value args[2];
-  args[0] = xt_object_get_cstr(thisValue, "fd");
-  args[1] = argc > 0 ? argv[0] : XT_UNDEFINED;
-  return xt_fs_promisify(xt_node_write, 2, args);
-}
-
-static xt_value xt_fh_new(xt_value fdValue) {
-  xt_value handle = xt_object_new();
-  xt_node_set(handle, "fd", fdValue);
-  xt_node_define_method(handle, "read", (void *)xt_fh_read);
-  xt_node_define_method(handle, "write", (void *)xt_fh_write);
-  xt_node_define_method(handle, "readFile", (void *)xt_fh_read_all);
-  xt_node_define_method(handle, "writeFile", (void *)xt_fh_write_all);
-  xt_node_define_method(handle, "appendFile", (void *)xt_fh_write_all);
-  xt_node_define_method(handle, "close", (void *)xt_fh_close);
-  xt_node_define_method(handle, "stat", (void *)xt_fh_stat);
-  xt_node_define_method(handle, "truncate", (void *)xt_fh_truncate);
-  xt_node_define_method(handle, "chmod", (void *)xt_fh_chmod);
-  xt_node_define_method(handle, "chown", (void *)xt_fh_chown);
-  xt_node_define_method(handle, "utimes", (void *)xt_fh_utimes);
-  xt_node_define_method(handle, "sync", (void *)xt_fh_sync);
-  xt_node_define_method(handle, "datasync", (void *)xt_fh_datasync);
-  return handle;
-}
-
-/* ------------------------------------------------------------------------- */
-/* Promise wrappers                                                          */
-/* ------------------------------------------------------------------------- */
-
-#define XT_FS_PROMISE(name, fn)                                                                    \
-  xt_value name(int32_t argc, xt_value *argv) { return xt_fs_promisify((fn), argc, argv); }
-
-XT_FS_PROMISE(xt_node_p_read_file, xt_node_read_text_file)
-XT_FS_PROMISE(xt_node_p_write_file, xt_node_write_file)
-XT_FS_PROMISE(xt_node_p_append_file, xt_node_append_file)
-XT_FS_PROMISE(xt_node_p_mkdir, xt_node_mkdir)
-XT_FS_PROMISE(xt_node_p_readdir, xt_node_read_dir)
-XT_FS_PROMISE(xt_node_p_rm, xt_node_rm)
-XT_FS_PROMISE(xt_node_p_unlink, xt_node_unlink)
-XT_FS_PROMISE(xt_node_p_rmdir, xt_node_rmdir)
-XT_FS_PROMISE(xt_node_p_rename, xt_node_rename)
-XT_FS_PROMISE(xt_node_p_copy_file, xt_node_copy_file)
-XT_FS_PROMISE(xt_node_p_realpath, xt_node_realpath)
-XT_FS_PROMISE(xt_node_p_stat, xt_node_stat)
-XT_FS_PROMISE(xt_node_p_lstat, xt_node_lstat)
-XT_FS_PROMISE(xt_node_p_access, xt_node_access)
-XT_FS_PROMISE(xt_node_p_cp, xt_node_cp)
-XT_FS_PROMISE(xt_node_p_chmod, xt_node_chmod)
-XT_FS_PROMISE(xt_node_p_chown, xt_node_chown)
-XT_FS_PROMISE(xt_node_p_lchmod, xt_node_lchmod)
-XT_FS_PROMISE(xt_node_p_lchown, xt_node_lchown)
-XT_FS_PROMISE(xt_node_p_truncate, xt_node_truncate)
-XT_FS_PROMISE(xt_node_p_utimes, xt_node_utimes)
-XT_FS_PROMISE(xt_node_p_lutimes, xt_node_lutimes)
-XT_FS_PROMISE(xt_node_p_link, xt_node_link)
-XT_FS_PROMISE(xt_node_p_symlink, xt_node_symlink)
-XT_FS_PROMISE(xt_node_p_readlink, xt_node_readlink)
-XT_FS_PROMISE(xt_node_p_mkdtemp, xt_node_mkdtemp)
-XT_FS_PROMISE(xt_node_p_statfs, xt_node_statfs)
-XT_FS_PROMISE(xt_node_p_opendir, xt_node_opendir)
-XT_FS_PROMISE(xt_node_p_glob, xt_node_glob)
-XT_FS_PROMISE(xt_node_p_watch, xt_node_watch)
-
-xt_value xt_node_p_open(int32_t argc, xt_value *argv) {
-  void *frame = xt_try_enter();
-  if (xt_try_setjmp(frame) == 0) {
-    xt_value fdValue = xt_node_open(argc, argv);
-    xt_try_leave(frame);
-    return xt_promise_resolve(xt_fh_new(fdValue));
-  }
-  xt_value exception = xt_try_exception(frame);
-  xt_try_leave(frame);
-  return xt_promise_reject(exception);
-}
-
-/* ------------------------------------------------------------------------- */
-/* `fs.promises` facade                                                      */
-/* ------------------------------------------------------------------------- */
+#include "async_job.h"
 
-#define XT_FS_PROMISES_FACADE(name, object)                                                        \
-  static xt_value xt_fs_promises_facade_##name(xt_value thisValue, xt_value env, int32_t argc,     \
-                                               xt_value *argv) {                                   \
-    (void)thisValue;                                                                               \
-    (void)env;                                                                                     \
-    return name(argc, argv);                                                                       \
+#define XT_FS_PROMISES_FACADE(name)                                                               \
+  static xt_value xt_fs_promises_facade_##name(xt_value thisValue, xt_value env, int32_t argc,    \
+                                               xt_value *argv) {                                  \
+    (void)thisValue;                                                                              \
+    (void)env;                                                                                    \
+    return name(argc, argv);                                                                      \
   }
 
-XT_FS_PROMISES_FACADE(xt_node_p_read_file, _)
-XT_FS_PROMISES_FACADE(xt_node_p_write_file, _)
-XT_FS_PROMISES_FACADE(xt_node_p_append_file, _)
-XT_FS_PROMISES_FACADE(xt_node_p_mkdir, _)
-XT_FS_PROMISES_FACADE(xt_node_p_readdir, _)
-XT_FS_PROMISES_FACADE(xt_node_p_rm, _)
-XT_FS_PROMISES_FACADE(xt_node_p_unlink, _)
-XT_FS_PROMISES_FACADE(xt_node_p_rmdir, _)
-XT_FS_PROMISES_FACADE(xt_node_p_rename, _)
-XT_FS_PROMISES_FACADE(xt_node_p_copy_file, _)
-XT_FS_PROMISES_FACADE(xt_node_p_realpath, _)
-XT_FS_PROMISES_FACADE(xt_node_p_stat, _)
-XT_FS_PROMISES_FACADE(xt_node_p_lstat, _)
-XT_FS_PROMISES_FACADE(xt_node_p_access, _)
-XT_FS_PROMISES_FACADE(xt_node_p_cp, _)
-XT_FS_PROMISES_FACADE(xt_node_p_chmod, _)
-XT_FS_PROMISES_FACADE(xt_node_p_chown, _)
-XT_FS_PROMISES_FACADE(xt_node_p_lchmod, _)
-XT_FS_PROMISES_FACADE(xt_node_p_lchown, _)
-XT_FS_PROMISES_FACADE(xt_node_p_truncate, _)
-XT_FS_PROMISES_FACADE(xt_node_p_utimes, _)
-XT_FS_PROMISES_FACADE(xt_node_p_lutimes, _)
-XT_FS_PROMISES_FACADE(xt_node_p_link, _)
-XT_FS_PROMISES_FACADE(xt_node_p_symlink, _)
-XT_FS_PROMISES_FACADE(xt_node_p_readlink, _)
-XT_FS_PROMISES_FACADE(xt_node_p_mkdtemp, _)
-XT_FS_PROMISES_FACADE(xt_node_p_statfs, _)
-XT_FS_PROMISES_FACADE(xt_node_p_opendir, _)
-XT_FS_PROMISES_FACADE(xt_node_p_glob, _)
-XT_FS_PROMISES_FACADE(xt_node_p_watch, _)
-XT_FS_PROMISES_FACADE(xt_node_p_open, _)
+XT_FS_PROMISES_FACADE(xt_node_p_read_file)
+XT_FS_PROMISES_FACADE(xt_node_p_write_file)
+XT_FS_PROMISES_FACADE(xt_node_p_append_file)
+XT_FS_PROMISES_FACADE(xt_node_p_mkdir)
+XT_FS_PROMISES_FACADE(xt_node_p_readdir)
+XT_FS_PROMISES_FACADE(xt_node_p_rm)
+XT_FS_PROMISES_FACADE(xt_node_p_unlink)
+XT_FS_PROMISES_FACADE(xt_node_p_rmdir)
+XT_FS_PROMISES_FACADE(xt_node_p_rename)
+XT_FS_PROMISES_FACADE(xt_node_p_copy_file)
+XT_FS_PROMISES_FACADE(xt_node_p_realpath)
+XT_FS_PROMISES_FACADE(xt_node_p_stat)
+XT_FS_PROMISES_FACADE(xt_node_p_lstat)
+XT_FS_PROMISES_FACADE(xt_node_p_access)
+XT_FS_PROMISES_FACADE(xt_node_p_cp)
+XT_FS_PROMISES_FACADE(xt_node_p_chmod)
+XT_FS_PROMISES_FACADE(xt_node_p_chown)
+XT_FS_PROMISES_FACADE(xt_node_p_lchmod)
+XT_FS_PROMISES_FACADE(xt_node_p_lchown)
+XT_FS_PROMISES_FACADE(xt_node_p_truncate)
+XT_FS_PROMISES_FACADE(xt_node_p_utimes)
+XT_FS_PROMISES_FACADE(xt_node_p_lutimes)
+XT_FS_PROMISES_FACADE(xt_node_p_link)
+XT_FS_PROMISES_FACADE(xt_node_p_symlink)
+XT_FS_PROMISES_FACADE(xt_node_p_readlink)
+XT_FS_PROMISES_FACADE(xt_node_p_mkdtemp)
+XT_FS_PROMISES_FACADE(xt_node_p_statfs)
+XT_FS_PROMISES_FACADE(xt_node_p_opendir)
+XT_FS_PROMISES_FACADE(xt_node_p_glob)
+XT_FS_PROMISES_FACADE(xt_node_p_watch)
+XT_FS_PROMISES_FACADE(xt_node_p_open)
 
 xt_value xt_fs_promises(void) {
   static xt_value cached = 0;

package/runtime/rt.h

@@ -132,6 +132,8 @@ xt_value xt_function_get_prototype(xt_value fn);
 xt_value xt_function_set_generator(xt_value fn);
 /** Mark a closure as an `async` function so calling it starts a coroutine. */
 xt_value xt_function_set_async(xt_value fn);
+/** Mark a closure as an `async function*` (generator + async iterator). */
+xt_value xt_function_set_async_generator(xt_value fn);
 
 /* -- conversions ---------------------------------------------------------- */
 int xt_truthy(xt_value v);
@@ -259,6 +261,8 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv);
 xt_value xt_fetch(int32_t argc, xt_value *argv);
 /** Construct a `TypeError` with one message argument (used by `fetch`). */
 xt_value xt_type_error_ctor(int32_t argc, xt_value *argv);
+/** Construct a `RangeError` with one message argument. */
+xt_value xt_range_error_ctor(int32_t argc, xt_value *argv);
 
 /* -- promises / async ----------------------------------------------------- */
 xt_value xt_promise_resolve(xt_value value);
@@ -315,6 +319,12 @@ 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);
+/* `setImmediate` runs on the timer queue with a zero delay; `clearImmediate`
+ * is an alias of `clearTimeout` (ids share one namespace). */
+xt_value xt_set_immediate(int32_t argc, xt_value *argv);
+xt_value xt_clear_immediate(int32_t argc, xt_value *argv);
+/* Schedule `callback` on the promise microtask queue (same FIFO as `.then`). */
+xt_value xt_queue_microtask(int32_t argc, xt_value *argv);
 
 /* -- global functions ------------------------------------------------------ */
 xt_value xt_parse_int(int32_t argc, xt_value *argv);
@@ -328,6 +338,8 @@ xt_value xt_decode_uri(int32_t argc, xt_value *argv);
 xt_value xt_number_ctor(int32_t argc, xt_value *argv);
 xt_value xt_string_ctor(int32_t argc, xt_value *argv);
 xt_value xt_boolean_ctor(int32_t argc, xt_value *argv);
+/* Deep clone arrays/objects/Map/Set/Date/RegExp/typed arrays. */
+xt_value xt_structured_clone(int32_t argc, xt_value *argv);
 /** `key in obj` (the key is the left operand). */
 xt_value xt_in(xt_value key, xt_value obj);
 /** `delete obj[key]`; removes object properties, clears array elements. */
@@ -360,6 +372,9 @@ xt_value xt_iter_value(xt_value value, xt_value index);
 
 /* -- generic member access ------------------------------------------------ */
 xt_value xt_get(xt_value target, xt_value key);
+/** Interned shape/offset inline cache for a property read. `cache` points at
+ * two zero-initialised i64 words owned by the generated code. */
+xt_value xt_get_ic(xt_value target, xt_value key, int64_t *cache);
 xt_value xt_set(xt_value target, xt_value key, xt_value value);
 /* Materialise a first-class runtime method value (`arr.map`) as an unbound
  * closure that expects the receiver through `this`. Returns `XT_UNDEFINED` when