xbintsc 0.5.6 → 0.5.21

package/runtime/ext_node/child_process/child_process.c

@@ -23,6 +23,7 @@
 #include <fcntl.h>
 #include <io.h>
 #include <process.h>
+#include <windows.h>
 #else
 #include <poll.h>
 #include <sys/wait.h>
@@ -69,38 +70,115 @@ static xt_value make_result(double status, const char *out, const char *err) {
 
 #if defined(_WIN32)
 
-static char *read_temp(FILE *file) {
-  fflush(file);
-  if (_fseeki64(file, 0, SEEK_END) != 0) return NULL;
-  long long size = _ftelli64(file);
-  if (size < 0) return NULL;
-  _fseeki64(file, 0, SEEK_SET);
-  char *buffer = (char *)malloc((size_t)size + 1);
-  if (!buffer) return NULL;
-  size_t read = fread(buffer, 1, (size_t)size, file);
-  buffer[read] = 0;
-  return buffer;
-}
-
 /*
- * MSVC's `_spawnvp` builds the child command line from argv without quoting
- * argv[0]. When the executable path contains a space — the default install
- * location is "C:\Program Files\…" — the child sees the path split into several
- * arguments ("Files\Microsoft", "Visual", …). Quote argv[0] ourselves. Returns
- * NULL when no quoting is needed (the caller keeps the original pointer).
+ * `spawnSync` captures stdout/stderr through anonymous pipes. Temporary files
+ * are deliberately not used: `tmpfile()` creates its file in the root of the
+ * current drive on the UCRT, which fails with "Permission denied" on machines
+ * where that directory is not writable, and a restricted temp directory makes
+ * every `spawnSync` fail as well. Pipes also avoid the pipe-buffer deadlock the
+ * old temp-file design was working around, because one reader thread drains
+ * each stream while the child runs.
  */
-static char *quote_argv0(char **child_argv) {
-  const char *arg = child_argv[0];
-  if (arg == NULL || strchr(arg, ' ') == NULL) return NULL;
-  size_t length = strlen(arg);
-  char *quoted = (char *)malloc(length + 3);
-  if (!quoted) return NULL;
-  quoted[0] = '"';
-  memcpy(quoted + 1, arg, length);
-  quoted[length + 1] = '"';
-  quoted[length + 2] = 0;
-  child_argv[0] = quoted;
-  return quoted;
+typedef struct {
+  HANDLE read;
+  char *data;
+  size_t length;
+  size_t capacity;
+} CapturePipe;
+
+static void capture_append(CapturePipe *pipe, const char *chunk, size_t count) {
+  if (pipe->length + count + 1 > pipe->capacity) {
+    size_t next = pipe->capacity ? pipe->capacity * 2 : 4096;
+    while (next < pipe->length + count + 1) next *= 2;
+    char *grown = (char *)realloc(pipe->data, next);
+    if (!grown) return;
+    pipe->data = grown;
+    pipe->capacity = next;
+  }
+  memcpy(pipe->data + pipe->length, chunk, count);
+  pipe->length += count;
+  pipe->data[pipe->length] = 0;
+}
+
+static DWORD WINAPI capture_thread(LPVOID parameter) {
+  CapturePipe *pipe = (CapturePipe *)parameter;
+  char chunk[4096];
+  DWORD got = 0;
+  while (ReadFile(pipe->read, chunk, sizeof(chunk), &got, NULL) && got > 0) {
+    capture_append(pipe, chunk, (size_t)got);
+  }
+  return 0;
+}
+
+static int create_capture_pipe(CapturePipe *pipe, HANDLE *write_end) {
+  SECURITY_ATTRIBUTES attributes;
+  HANDLE read_handle = NULL;
+  HANDLE write_handle = NULL;
+  attributes.nLength = sizeof(attributes);
+  attributes.lpSecurityDescriptor = NULL;
+  attributes.bInheritHandle = TRUE;
+  if (!CreatePipe(&read_handle, &write_handle, &attributes, 0)) return 0;
+  /* The child inherits the write end only. */
+  SetHandleInformation(read_handle, HANDLE_FLAG_INHERIT, 0);
+  pipe->read = read_handle;
+  pipe->data = NULL;
+  pipe->length = 0;
+  pipe->capacity = 0;
+  *write_end = write_handle;
+  return 1;
+}
+
+static void close_capture_pipe(CapturePipe *pipe) {
+  if (pipe->read != NULL) CloseHandle(pipe->read);
+  free(pipe->data);
+  pipe->read = NULL;
+  pipe->data = NULL;
+  pipe->length = 0;
+  pipe->capacity = 0;
+}
+
+/* Quote one argument following the CommandLineToArgvW/MSVC rules. */
+static char *append_quoted_argument(char *out, const char *argument) {
+  if (*argument != 0 && strpbrk(argument, " \t\n\v\"") == NULL) {
+    size_t length = strlen(argument);
+    memcpy(out, argument, length);
+    return out + length;
+  }
+  *out++ = '"';
+  const char *cursor = argument;
+  for (;;) {
+    size_t backslashes = 0;
+    while (*cursor == '\\') {
+      cursor++;
+      backslashes++;
+    }
+    if (*cursor == 0) {
+      for (size_t i = 0; i < backslashes * 2; i++) *out++ = '\\';
+      *out++ = '"';
+      return out;
+    }
+    if (*cursor == '"') {
+      for (size_t i = 0; i < backslashes * 2 + 1; i++) *out++ = '\\';
+    } else {
+      for (size_t i = 0; i < backslashes; i++) *out++ = '\\';
+    }
+    *out++ = *cursor++;
+  }
+}
+
+/* Build the child command line; every argv element is quoted as needed. */
+static char *build_command_line(char **child_argv, int count) {
+  size_t capacity = 1;
+  for (int i = 0; i < count; i++) capacity += strlen(child_argv[i]) * 2 + 4;
+  char *line = (char *)malloc(capacity);
+  if (!line) return NULL;
+  char *cursor = line;
+  for (int i = 0; i < count; i++) {
+    if (i > 0) *cursor++ = ' ';
+    cursor = append_quoted_argument(cursor, child_argv[i]);
+  }
+  *cursor = 0;
+  return line;
 }
 
 xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
@@ -112,60 +190,82 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
   int count = 0;
   char **child_argv = (char **)build_argv(command, args, &count);
   if (!child_argv) return make_result(-1, "", "out of memory");
-  char *quoted_command = quote_argv0(child_argv);
+  char *command_line = build_command_line(child_argv, count);
+  if (!command_line) {
+    free(child_argv);
+    return make_result(-1, "", "out of memory");
+  }
 
-  char previous[4096];
-  int had_cwd = cwd && _getcwd(previous, sizeof(previous)) != NULL;
+  STARTUPINFOA startup;
+  PROCESS_INFORMATION process;
+  ZeroMemory(&startup, sizeof(startup));
+  ZeroMemory(&process, sizeof(process));
+  startup.cb = sizeof(startup);
 
   if (option_stdio_inherit(argc > 2 ? argv[2] : XT_UNDEFINED)) {
-    if (cwd) _chdir(cwd);
-    intptr_t inherit_rc = _spawnvp(_P_WAIT, command, (const char *const *)child_argv);
-    if (had_cwd) _chdir(previous);
-    free(quoted_command);
+    BOOL created = CreateProcessA(
+      NULL, command_line, NULL, NULL, TRUE, 0, NULL, cwd, &startup, &process);
+    free(command_line);
     free(child_argv);
-    return make_result(inherit_rc < 0 ? -1 : (double)inherit_rc, "", "");
+    if (!created) return make_result(-1, "", "failed to start process");
+    WaitForSingleObject(process.hProcess, INFINITE);
+    DWORD exit_code = 0;
+    GetExitCodeProcess(process.hProcess, &exit_code);
+    CloseHandle(process.hThread);
+    CloseHandle(process.hProcess);
+    return make_result((double)exit_code, "", "");
   }
 
-  FILE *out_file = tmpfile();
-  FILE *err_file = tmpfile();
-  if (!out_file || !err_file) {
-    free(quoted_command);
+  CapturePipe out_pipe;
+  CapturePipe err_pipe;
+  ZeroMemory(&out_pipe, sizeof(out_pipe));
+  ZeroMemory(&err_pipe, sizeof(err_pipe));
+  HANDLE out_write = NULL;
+  HANDLE err_write = NULL;
+  if (!create_capture_pipe(&out_pipe, &out_write) || !create_capture_pipe(&err_pipe, &err_write)) {
+    if (out_write != NULL) CloseHandle(out_write);
+    if (err_write != NULL) CloseHandle(err_write);
+    close_capture_pipe(&out_pipe);
+    close_capture_pipe(&err_pipe);
+    free(command_line);
     free(child_argv);
-    if (out_file) fclose(out_file);
-    if (err_file) fclose(err_file);
-    return make_result(-1, "", "could not create temporary files");
+    return make_result(-1, "", "could not create pipes");
   }
+  startup.dwFlags = STARTF_USESTDHANDLES;
+  startup.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+  startup.hStdOutput = out_write;
+  startup.hStdError = err_write;
 
-  /* Flush anything the parent has already buffered on stdout/stderr before
-   * redirecting the descriptors; otherwise that pending output would be
-   * flushed into the child's capture file (and lost from the real stdout). */
-  fflush(stdout);
-  fflush(stderr);
-  int saved_out = _dup(_fileno(stdout));
-  int saved_err = _dup(_fileno(stderr));
-  _dup2(_fileno(out_file), _fileno(stdout));
-  _dup2(_fileno(err_file), _fileno(stderr));
-
-  if (cwd) _chdir(cwd);
-  intptr_t rc = _spawnvp(_P_WAIT, command, (const char *const *)child_argv);
-  if (had_cwd) _chdir(previous);
-  fflush(stdout);
-  fflush(stderr);
-  _dup2(saved_out, _fileno(stdout));
-  _dup2(saved_err, _fileno(stderr));
-  _close(saved_out);
-  _close(saved_err);
-
-  char *out = read_temp(out_file);
-  char *err = read_temp(err_file);
-  fclose(out_file);
-  fclose(err_file);
-  free(quoted_command);
+  BOOL created = CreateProcessA(
+    NULL, command_line, NULL, NULL, TRUE, 0, NULL, cwd, &startup, &process);
+  free(command_line);
   free(child_argv);
+  CloseHandle(out_write);
+  CloseHandle(err_write);
+  if (!created) {
+    close_capture_pipe(&out_pipe);
+    close_capture_pipe(&err_pipe);
+    return make_result(-1, "", "failed to start process");
+  }
+
+  CloseHandle(process.hThread);
+  HANDLE threads[2];
+  threads[0] = CreateThread(NULL, 0, capture_thread, &out_pipe, 0, NULL);
+  threads[1] = CreateThread(NULL, 0, capture_thread, &err_pipe, 0, NULL);
+  for (int i = 0; i < 2; i++) {
+    if (threads[i] != NULL) WaitForSingleObject(threads[i], INFINITE);
+  }
+  WaitForSingleObject(process.hProcess, INFINITE);
+  DWORD exit_code = 0;
+  GetExitCodeProcess(process.hProcess, &exit_code);
+  CloseHandle(process.hProcess);
+  for (int i = 0; i < 2; i++) {
+    if (threads[i] != NULL) CloseHandle(threads[i]);
+  }
 
-  xt_value result = make_result(rc < 0 ? -1 : (double)rc, out, err);
-  free(out);
-  free(err);
+  xt_value result = make_result((double)exit_code, out_pipe.data, err_pipe.data);
+  close_capture_pipe(&out_pipe);
+  close_capture_pipe(&err_pipe);
   return result;
 }
 

package/runtime/ext_node/fs/async_api.c

@@ -0,0 +1,314 @@
+/*
+ * Main-thread argument marshalling for asynchronous `fs/promises`.
+ *
+ * Each export copies whatever it needs from the JavaScript values (paths,
+ * encodings, buffers, options) into a job, then submits it. The blocking half
+ * runs on a worker; the promise is settled later on the reactor thread. This is
+ * also where the non-I/O argument parsing matches the synchronous `fs` module.
+ */
+
+#include "async_job.h"
+
+#include <errno.h>
+
+static int xt_fs_option_bool(xt_value options, const char *key, int fallback) {
+  if (!XT_IS_OBJECT(options)) return fallback;
+  xt_value value = xt_object_get_cstr(options, key);
+  if (XT_IS_UNDEFINED(value) || XT_IS_NULL(value)) return fallback;
+  return xt_truthy(value);
+}
+
+static int xt_fs_option_recursive(xt_value options) {
+  if (!xt_truthy(options)) return 0;
+  if (XT_IS_OBJECT(options)) return xt_truthy(xt_object_get_cstr(options, "recursive"));
+  return 1;
+}
+
+/* -- file contents --------------------------------------------------------- */
+
+xt_value xt_node_p_read_file(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_READ_FILE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->text = xt_fs_copy_cstr(argc > 1 ? xt_fs_encoding(argv[1]) : NULL);
+  return xt_fs_job_submit(job);
+}
+
+static xt_value xt_fs_write(int32_t argc, xt_value *argv, int append) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_WRITE_FILE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->flags = append;
+  if (xt_node_is_buffer(argv[1])) {
+    job->data = xt_node_buffer_bytes(argv[1], &job->data_length);
+  } else {
+    xt_value text = xt_to_string(argv[1]);
+    const char *data = xt_string_data(text);
+    int32_t length = xt_string_length_value(text);
+    if (data && length >= 0) {
+      const char *encoding = argc > 2 ? xt_fs_encoding(argv[2]) : NULL;
+      job->data = xt_fs_decode_text(data, (size_t)length, encoding, &job->data_length);
+    }
+  }
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_write_file(int32_t argc, xt_value *argv) { return xt_fs_write(argc, argv, 0); }
+
+xt_value xt_node_p_append_file(int32_t argc, xt_value *argv) { return xt_fs_write(argc, argv, 1); }
+
+/* -- directories ----------------------------------------------------------- */
+
+xt_value xt_node_p_mkdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_MKDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = 0777;
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  if (XT_IS_OBJECT(options) && !XT_IS_UNDEFINED(xt_object_get_cstr(options, "mode"))) {
+    job->mode = (int)xt_to_number(xt_object_get_cstr(options, "mode"));
+  }
+  job->recursive = argc > 1 && xt_fs_option_recursive(options);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_readdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_READDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  job->with_types = xt_fs_option_bool(options, "withFileTypes", 0);
+  job->recursive = xt_fs_option_bool(options, "recursive", 0);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_rm(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_RM);
+  job->path = xt_fs_take_string(argv[0]);
+  job->recursive = argc > 1 && xt_fs_option_recursive(argv[1]);
+  job->force = xt_fs_option_bool(argc > 1 ? argv[1] : XT_UNDEFINED, "force", 0);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_unlink(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_UNLINK);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_rmdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_RMDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_rename(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_RENAME);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_copy_file(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_COPY_FILE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  job->flags = argc > 2 ? (int)xt_to_number(argv[2]) : 0;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_cp(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_CP);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  xt_value options = argc > 2 ? argv[2] : XT_UNDEFINED;
+  job->recursive = xt_fs_option_bool(options, "recursive", 0);
+  job->force = xt_fs_option_bool(options, "force", 1);
+  job->error_on_exist = xt_fs_option_bool(options, "errorOnExist", 0);
+  job->dereference = xt_fs_option_bool(options, "dereference", 0);
+  job->preserve = xt_fs_option_bool(options, "preserveTimestamps", 0);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_realpath(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_REALPATH);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+/* -- metadata -------------------------------------------------------------- */
+
+static xt_value xt_fs_stat_job(xt_fs_job_kind kind, int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(kind);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_stat(int32_t argc, xt_value *argv) {
+  return xt_fs_stat_job(XT_FS_JOB_STAT, argc, argv);
+}
+
+xt_value xt_node_p_lstat(int32_t argc, xt_value *argv) {
+  return xt_fs_stat_job(XT_FS_JOB_LSTAT, argc, argv);
+}
+
+xt_value xt_node_p_statfs(int32_t argc, xt_value *argv) {
+  return xt_fs_stat_job(XT_FS_JOB_STATFS, argc, argv);
+}
+
+xt_value xt_node_p_access(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_ACCESS);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = argc > 1 ? (int)xt_to_number(argv[1]) : F_OK;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_open(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_OPEN);
+  job->path = xt_fs_take_string(argv[0]);
+  job->flags = argc > 1 ? xt_fs_parse_flags(argv[1]) : (XT_FS_RDONLY | XT_FS_BINARY_FLAG);
+  job->mode = argc > 2 ? (int)xt_to_number(argv[2]) : 0666;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_chmod(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_CHMOD);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = (int)xt_to_number(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_lchmod(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_LCHMOD);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = (int)xt_to_number(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+static xt_value xt_fs_chown_job(xt_fs_job_kind kind, int32_t argc, xt_value *argv) {
+  if (argc < 3) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(kind);
+  job->path = xt_fs_take_string(argv[0]);
+  job->uid = (int)xt_to_number(argv[1]);
+  job->gid = (int)xt_to_number(argv[2]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_chown(int32_t argc, xt_value *argv) {
+  return xt_fs_chown_job(XT_FS_JOB_CHOWN, argc, argv);
+}
+
+xt_value xt_node_p_lchown(int32_t argc, xt_value *argv) {
+  return xt_fs_chown_job(XT_FS_JOB_LCHOWN, argc, argv);
+}
+
+xt_value xt_node_p_truncate(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_TRUNCATE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->length = argc > 1 ? (long long)xt_to_number(argv[1]) : 0;
+  return xt_fs_job_submit(job);
+}
+
+static xt_value xt_fs_utimes_job(xt_fs_job_kind kind, int32_t argc, xt_value *argv) {
+  if (argc < 3) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(kind);
+  job->path = xt_fs_take_string(argv[0]);
+  job->atime = xt_fs_time_seconds(argv[1]);
+  job->mtime = xt_fs_time_seconds(argv[2]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_utimes(int32_t argc, xt_value *argv) {
+  return xt_fs_utimes_job(XT_FS_JOB_UTIMES, argc, argv);
+}
+
+xt_value xt_node_p_lutimes(int32_t argc, xt_value *argv) {
+  return xt_fs_utimes_job(XT_FS_JOB_LUTIMES, argc, argv);
+}
+
+/* -- links and temporary directories --------------------------------------- */
+
+xt_value xt_node_p_link(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_LINK);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_symlink(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_SYMLINK);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  job->text = argc > 2 ? xt_fs_take_string(argv[2]) : NULL;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_readlink(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_READLINK);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_mkdtemp(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_MKDTEMP);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+/* -- opendir / glob / watch ------------------------------------------------ */
+
+xt_value xt_node_p_opendir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_OPENDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_glob(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_GLOB);
+  xt_value pattern = argv[0];
+  if (XT_IS_ARRAY(pattern)) {
+    int32_t count = (int32_t)xt_to_number(xt_array_length(pattern));
+    if (count > 0) {
+      job->patterns = (char **)calloc((size_t)count, sizeof(char *));
+      if (!job->patterns) abort();
+      for (int32_t i = 0; i < count; i++) {
+        xt_value item = xt_array_get(pattern, xt_number((double)i));
+        if (XT_IS_STRING(item)) {
+          job->patterns[job->pattern_count++] = xt_fs_take_string(item);
+        }
+      }
+    }
+  } else {
+    job->text = xt_fs_take_string(pattern);
+  }
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  job->with_types = xt_fs_option_bool(options, "withFileTypes", 0);
+  xt_value cwd = XT_IS_OBJECT(options) ? xt_object_get_cstr(options, "cwd") : XT_UNDEFINED;
+  if (XT_IS_STRING(cwd)) job->path2 = xt_fs_take_string(cwd);
+  return xt_fs_job_submit(job);
+}
+
+/* There is no real file-watching backend yet; keep the synchronous inert
+ * watcher behind an already-settled promise. */
+xt_value xt_node_p_watch(int32_t argc, xt_value *argv) {
+  return xt_fs_promisify(xt_node_watch, argc, argv);
+}

package/runtime/ext_node/fs/async_complete.c

@@ -0,0 +1,99 @@
+/*
+ * Main-thread half of `fs/promises`: turn worker results into values.
+ *
+ * Runs on the reactor thread, so `xt_value` construction, promise settlement
+ * and the collector are all safe here. Everything the job owns is freed by
+ * `xt_fs_job_release` after this returns (except the entry table handed over to
+ * a `Dir` object).
+ */
+
+#include "async_job.h"
+
+static void xt_fs_job_resolve(xt_fs_job *job, xt_value value) {
+  xt_promise_fulfill(job->base.roots[0], value);
+}
+
+static void xt_fs_job_reject(xt_fs_job *job) {
+  xt_value error = xt_fs_error_object(job->err, job->syscall, job->error_path);
+  xt_promise_reject_value(job->base.roots[0], error);
+}
+
+static xt_value xt_fs_statfs_value(const long long *numbers) {
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("type"), xt_number((double)numbers[0]));
+  xt_object_set(object, xt_string_from_cstr("bsize"), xt_number((double)numbers[1]));
+  xt_object_set(object, xt_string_from_cstr("blocks"), xt_number((double)numbers[2]));
+  xt_object_set(object, xt_string_from_cstr("bfree"), xt_number((double)numbers[3]));
+  xt_object_set(object, xt_string_from_cstr("bavail"), xt_number((double)numbers[4]));
+  xt_object_set(object, xt_string_from_cstr("files"), xt_number((double)numbers[5]));
+  xt_object_set(object, xt_string_from_cstr("ffree"), xt_number((double)numbers[6]));
+  return object;
+}
+
+static xt_value xt_fs_readdir_value(xt_fs_job *job) {
+  xt_value list = xt_array_new(0, NULL);
+  for (size_t i = 0; i < job->entry_count; i++) {
+    xt_fs_entry *entry = &job->entries[i];
+    if (job->with_types) {
+      xt_array_push(list, xt_node_dirent_named(entry->bare ? entry->bare : entry->name, entry->mode));
+    } else {
+      xt_array_push(list, xt_string_from_cstr(entry->name));
+    }
+  }
+  return list;
+}
+
+static xt_value xt_fs_glob_value(xt_fs_job *job) {
+  xt_value list = xt_array_new(0, NULL);
+  for (size_t i = 0; i < job->entry_count; i++) {
+    xt_array_push(list, xt_string_from_cstr(job->entries[i].name));
+  }
+  return list;
+}
+
+static xt_value xt_fs_read_bytes_value(xt_fs_job *job) {
+  return xt_fs_encode_bytes(job->bytes, job->bytes_length, job->text);
+}
+
+static void xt_fs_fd_read_complete(xt_fs_job *job) {
+  xt_value buffer = job->base.roots[1];
+  uint32_t offset = (uint32_t)job->offset;
+  for (size_t i = 0; i < job->bytes_length; i++) {
+    xt_node_buffer_set(buffer, offset + (uint32_t)i, job->bytes[i]);
+  }
+  xt_fs_job_resolve(job, xt_number((double)job->bytes_length));
+}
+
+void xt_fs_job_complete(xt_async_job *base) {
+  xt_fs_job *job = (xt_fs_job *)base;
+  if (job->err) {
+    xt_fs_job_reject(job);
+    return;
+  }
+  switch (job->kind) {
+    case XT_FS_JOB_READ_FILE:
+    case XT_FS_JOB_FD_READ_FILE: xt_fs_job_resolve(job, xt_fs_read_bytes_value(job)); break;
+    case XT_FS_JOB_READDIR: xt_fs_job_resolve(job, xt_fs_readdir_value(job)); break;
+    case XT_FS_JOB_GLOB: xt_fs_job_resolve(job, xt_fs_glob_value(job)); break;
+    case XT_FS_JOB_OPENDIR: {
+      xt_value dir = xt_node_dir_from_entries(job->path, job->entries, job->entry_count);
+      job->entries = NULL;
+      job->entry_count = 0;
+      xt_fs_job_resolve(job, dir);
+      break;
+    }
+    case XT_FS_JOB_REALPATH:
+    case XT_FS_JOB_READLINK:
+    case XT_FS_JOB_MKDTEMP:
+      xt_fs_job_resolve(job, job->string ? xt_string_from_cstr(job->string) : XT_UNDEFINED);
+      break;
+    case XT_FS_JOB_STAT:
+    case XT_FS_JOB_LSTAT:
+    case XT_FS_JOB_FD_STAT: xt_fs_job_resolve(job, xt_node_stat_result(&job->stat)); break;
+    case XT_FS_JOB_STATFS: xt_fs_job_resolve(job, xt_fs_statfs_value(job->numbers)); break;
+    case XT_FS_JOB_OPEN: xt_fs_job_resolve(job, xt_fh_new(xt_number((double)job->result_fd))); break;
+    case XT_FS_JOB_FD_READ: xt_fs_fd_read_complete(job); break;
+    case XT_FS_JOB_FD_WRITE: xt_fs_job_resolve(job, xt_number((double)job->written)); break;
+    default: xt_fs_job_resolve(job, XT_UNDEFINED); break;
+  }
+}