xbintsc 0.3.13 → 0.3.15

package/runtime/ext_node/fs/promises.c

@@ -2,68 +2,283 @@
  * Node.js `fs/promises` for xbintsc.
  *
  * xbintsc has no asynchronous I/O scheduler, so these builtins reuse the
- * synchronous `fs` implementations and wrap the result in an immediately
- * settled promise. `await`/`.then` therefore work exactly as expected while
- * the actual work happens synchronously.
+ * 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.
  */
 
 #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                                                      */
+/* ------------------------------------------------------------------------- */
+
+#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);                                                                       \
+  }
+
+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, _)
 
-#include <errno.h>
-#include <string.h>
-#if defined(_WIN32)
-#include <io.h>
-#ifndef F_OK
-#define F_OK 0
-#endif
-#define xt_node_access _access
-#else
-#include <unistd.h>
-#define xt_node_access access
-#endif
-
-/* Synchronous implementations provided by the sibling `fs` translation units. */
-extern xt_value xt_node_read_text_file(int32_t argc, xt_value *argv);
-extern xt_value xt_node_write_file(int32_t argc, xt_value *argv);
-extern xt_value xt_node_append_file(int32_t argc, xt_value *argv);
-extern xt_value xt_node_mkdir(int32_t argc, xt_value *argv);
-extern xt_value xt_node_read_dir(int32_t argc, xt_value *argv);
-extern xt_value xt_node_rm(int32_t argc, xt_value *argv);
-extern xt_value xt_node_unlink(int32_t argc, xt_value *argv);
-extern xt_value xt_node_rmdir(int32_t argc, xt_value *argv);
-extern xt_value xt_node_rename(int32_t argc, xt_value *argv);
-extern xt_value xt_node_copy_file(int32_t argc, xt_value *argv);
-extern xt_value xt_node_realpath(int32_t argc, xt_value *argv);
-extern xt_value xt_node_stat(int32_t argc, xt_value *argv);
-extern xt_value xt_node_lstat(int32_t argc, xt_value *argv);
-
-static xt_value xt_node_promises_wrap(int32_t argc, xt_value *argv, xt_value (*fn)(int32_t, xt_value *)) {
-  return xt_promise_resolve(fn(argc, argv));
-}
-
-xt_value xt_node_p_read_file(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_read_text_file); }
-xt_value xt_node_p_write_file(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_write_file); }
-xt_value xt_node_p_append_file(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_append_file); }
-xt_value xt_node_p_mkdir(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_mkdir); }
-xt_value xt_node_p_readdir(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_read_dir); }
-xt_value xt_node_p_rm(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_rm); }
-xt_value xt_node_p_unlink(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_unlink); }
-xt_value xt_node_p_rmdir(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_rmdir); }
-xt_value xt_node_p_rename(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_rename); }
-xt_value xt_node_p_copy_file(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_copy_file); }
-xt_value xt_node_p_realpath(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_realpath); }
-xt_value xt_node_p_stat(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_stat); }
-xt_value xt_node_p_lstat(int32_t argc, xt_value *argv) { return xt_node_promises_wrap(argc, argv, xt_node_lstat); }
-
-xt_value xt_node_p_access(int32_t argc, xt_value *argv) {
-  if (argc < 1) return xt_promise_resolve(xt_undefined());
-  const char *path = xt_string_data(xt_to_string(argv[0]));
-  if (!path) return xt_promise_resolve(xt_undefined());
-  if (xt_node_access(path, F_OK) == 0) return xt_promise_resolve(xt_undefined());
-  xt_value error = xt_object_new();
-  xt_node_set(error, "code", xt_string_from_cstr("ENOENT"));
-  xt_node_set(error, "errno", xt_number(-2));
-  xt_node_set(error, "path", xt_string_from_cstr(path));
-  xt_node_set(error, "message", xt_string_from_cstr("ENOENT: no such file or directory"));
-  return xt_promise_reject(error);
+xt_value xt_fs_promises(void) {
+  static xt_value cached = 0;
+  if (XT_IS_OBJECT(cached)) return cached;
+  xt_value object = xt_object_new();
+#define XT_FS_PROMISE_METHOD(jsName, name)                                                         \
+  xt_node_define_method(object, jsName, (void *)xt_fs_promises_facade_##name)
+  XT_FS_PROMISE_METHOD("readFile", xt_node_p_read_file);
+  XT_FS_PROMISE_METHOD("writeFile", xt_node_p_write_file);
+  XT_FS_PROMISE_METHOD("appendFile", xt_node_p_append_file);
+  XT_FS_PROMISE_METHOD("mkdir", xt_node_p_mkdir);
+  XT_FS_PROMISE_METHOD("readdir", xt_node_p_readdir);
+  XT_FS_PROMISE_METHOD("rm", xt_node_p_rm);
+  XT_FS_PROMISE_METHOD("unlink", xt_node_p_unlink);
+  XT_FS_PROMISE_METHOD("rmdir", xt_node_p_rmdir);
+  XT_FS_PROMISE_METHOD("rename", xt_node_p_rename);
+  XT_FS_PROMISE_METHOD("copyFile", xt_node_p_copy_file);
+  XT_FS_PROMISE_METHOD("realpath", xt_node_p_realpath);
+  XT_FS_PROMISE_METHOD("stat", xt_node_p_stat);
+  XT_FS_PROMISE_METHOD("lstat", xt_node_p_lstat);
+  XT_FS_PROMISE_METHOD("access", xt_node_p_access);
+  XT_FS_PROMISE_METHOD("cp", xt_node_p_cp);
+  XT_FS_PROMISE_METHOD("chmod", xt_node_p_chmod);
+  XT_FS_PROMISE_METHOD("chown", xt_node_p_chown);
+  XT_FS_PROMISE_METHOD("lchmod", xt_node_p_lchmod);
+  XT_FS_PROMISE_METHOD("lchown", xt_node_p_lchown);
+  XT_FS_PROMISE_METHOD("truncate", xt_node_p_truncate);
+  XT_FS_PROMISE_METHOD("utimes", xt_node_p_utimes);
+  XT_FS_PROMISE_METHOD("lutimes", xt_node_p_lutimes);
+  XT_FS_PROMISE_METHOD("link", xt_node_p_link);
+  XT_FS_PROMISE_METHOD("symlink", xt_node_p_symlink);
+  XT_FS_PROMISE_METHOD("readlink", xt_node_p_readlink);
+  XT_FS_PROMISE_METHOD("mkdtemp", xt_node_p_mkdtemp);
+  XT_FS_PROMISE_METHOD("statfs", xt_node_p_statfs);
+  XT_FS_PROMISE_METHOD("opendir", xt_node_p_opendir);
+  XT_FS_PROMISE_METHOD("glob", xt_node_p_glob);
+  XT_FS_PROMISE_METHOD("watch", xt_node_p_watch);
+  XT_FS_PROMISE_METHOD("open", xt_node_p_open);
+#undef XT_FS_PROMISE_METHOD
+  xt_object_set(object, xt_string_from_cstr("constants"), xt_fs_constants());
+  cached = object;
+  return cached;
 }

package/runtime/ext_node/fs/read_file.c

@@ -7,9 +7,13 @@
  *
  * `readFileSync(path[, options])` reads a file and returns its contents as a
  * string. `options` may be an encoding string or an object with an `encoding`
- * property; `"utf8"` (the default), `"ascii"`, `"latin1"` and `"binary"` return
- * the raw bytes, while `"hex"` and `"base64"` return encoded strings. There is
- * no `Buffer` type yet, so binary reads always come back as text.
+ * property; `"utf8"` (the default), `"ascii"`, `"latin1"` and `"binary"`
+ * return the raw bytes, while `"hex"`, `"base64"` and `"base64url"` return
+ * encoded strings.
+ *
+ * Deviation: Node returns a `Buffer` when no encoding is given. xbintsc has no
+ * dedicated binary value type, so the default result is a UTF-8 string (raw
+ * byte values are preserved for ASCII/latin1 content).
  */
 
 #include "rt.h"
@@ -23,7 +27,7 @@ xt_value xt_node_read_text_file(int32_t argc, xt_value *argv) {
 
   FILE *file = fopen(path, "rb");
   if (!file) {
-    fprintf(stderr, "xbintsc: cannot open '%s'\n", path);
+    xt_fs_error("open", path);
     return xt_undefined();
   }
   fseek(file, 0, SEEK_END);

package/runtime/ext_node/fs/watch.c

@@ -0,0 +1,52 @@
+/*
+ * `fs.watch` / `fs.watchFile` / `fs.unwatchFile` for xbintsc.
+ *
+ * The runtime has no event loop or timers, so file-change notifications can
+ * never fire. These builtins still return Node-shaped watcher objects (an
+ * emitter with a `close()` method) so that feature-detection and cleanup code
+ * keeps working; no `change`/`rename` events are delivered. This is a
+ * documented deviation.
+ */
+
+#include "../node_common.h"
+#include "fs_common.h"
+
+static xt_value xt_fs_watch_close(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_undefined();
+}
+
+static xt_value xt_fs_watch_make(xt_value filename, const char *listenerName) {
+  xt_value watcher = xt_object_new();
+  xt_node_install_emitter(watcher);
+  xt_node_define_method(watcher, "close", (void *)xt_fs_watch_close);
+  if (XT_IS_STRING(filename)) xt_node_set(watcher, "path", filename);
+  if (listenerName) xt_node_set(watcher, "kind", xt_string_from_cstr(listenerName));
+  return watcher;
+}
+
+xt_value xt_node_watch(int32_t argc, xt_value *argv) {
+  xt_value filename = argc > 0 ? argv[0] : XT_UNDEFINED;
+  for (int32_t i = 1; i < argc; i++) {
+    if (XT_IS_FUNCTION(argv[i])) {
+      xt_value watcher = xt_fs_watch_make(filename, NULL);
+      xt_node_listeners(watcher, "change", 1);
+      return watcher;
+    }
+  }
+  return xt_fs_watch_make(filename, NULL);
+}
+
+xt_value xt_node_watch_file(int32_t argc, xt_value *argv) {
+  xt_value filename = argc > 0 ? argv[0] : XT_UNDEFINED;
+  return xt_fs_watch_make(filename, "file");
+}
+
+xt_value xt_node_unwatch_file(int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  return xt_undefined();
+}

package/runtime/ext_node/fs/write_file.c

@@ -2,9 +2,14 @@
  * Node.js `fs.writeFileSync` / `fs.appendFileSync` for xbintsc.
  *
  * `writeFileSync(path, data[, options])` truncates the file before writing;
- * `appendFileSync(path, data[, options])` appends. `data` is converted to a
- * string with the usual JS rules and `options` selects an encoding:
- * `"hex"`/`"base64"` decode the string, everything else writes its UTF-8 bytes.
+ * `appendFileSync(path, data[, options])` appends. `data` may be a string or a
+ * `Buffer`; strings are converted with `options.encoding` (`"hex"`/`"base64"`/
+ * `"base64url"` decode, everything else writes its UTF-8 bytes).
+ *
+ * Deviation: `options.mode` and `options.flag` are accepted but not applied
+ * (the file is always created with the process default mode and opened in the
+ * `"w"`/`"a"` binary mode). `TypedArray`/`DataView` inputs are not supported.
+ * Failures throw a Node-shaped `Error`.
  */
 
 #include "rt.h"
@@ -16,19 +21,23 @@ static xt_value xt_node_write_common(int32_t argc, xt_value *argv, const char *m
   const char *path = xt_string_data(pathValue);
   if (!path) return xt_undefined();
 
-  xt_value dataValue = xt_to_string(argv[1]);
-  const char *text = xt_string_data(dataValue);
-  int32_t length = xt_string_length_value(dataValue);
-  if (!text || length < 0) return xt_undefined();
-
-  const char *encoding = argc > 2 ? xt_fs_encoding(argv[2]) : NULL;
   size_t byteLength = 0;
-  unsigned char *bytes = xt_fs_decode_text(text, (size_t)length, encoding, &byteLength);
+  unsigned char *bytes;
+  if (xt_node_is_buffer(argv[1])) {
+    bytes = xt_node_buffer_bytes(argv[1], &byteLength);
+  } else {
+    xt_value dataValue = xt_to_string(argv[1]);
+    const char *text = xt_string_data(dataValue);
+    int32_t length = xt_string_length_value(dataValue);
+    if (!text || length < 0) return xt_undefined();
+    const char *encoding = argc > 2 ? xt_fs_encoding(argv[2]) : NULL;
+    bytes = xt_fs_decode_text(text, (size_t)length, encoding, &byteLength);
+  }
   if (!bytes) return xt_undefined();
 
   FILE *file = fopen(path, mode);
   if (!file) {
-    fprintf(stderr, "xbintsc: cannot open '%s'\n", path);
+    xt_fs_error("open", path);
     free(bytes);
     return xt_undefined();
   }

package/runtime/ext_node/stream/stream.c

@@ -145,6 +145,17 @@ static xt_value xt_stream_method_is_paused(xt_value thisValue, xt_value env, int
 
 static xt_value xt_stream_transform_flush(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv);
 
+/* No-op write callback used when `end(chunk)` forwards the chunk to `write`:
+ * the caller's `write` hook may invoke its completion callback, which must not
+ * be the user's `end` callback and must not be missing. */
+static xt_value xt_stream_noop(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_undefined();
+}
+
 static xt_value xt_stream_method_write(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   xt_value chunk = xt_arg(argc, argv, 0);
@@ -168,10 +179,12 @@ static xt_value xt_stream_method_write(xt_value thisValue, xt_value env, int32_t
 
   xt_value writeFn = xt_object_get_cstr(thisValue, "__write");
   if (XT_IS_FUNCTION(writeFn)) {
+    xt_value writeCallback =
+        XT_IS_FUNCTION(callback) ? callback : xt_closure_new((void *)xt_stream_noop, 0, NULL);
     xt_value args[3];
     args[0] = chunk;
     args[1] = encoding;
-    args[2] = callback;
+    args[2] = writeCallback;
     xt_call_with_this(writeFn, thisValue, 3, args);
   }
 
@@ -190,7 +203,11 @@ static xt_value xt_stream_method_end(xt_value thisValue, xt_value env, int32_t a
   xt_value callback = XT_UNDEFINED;
   if (argc >= 1 && !xt_truthy(xt_is_nullish(chunk))) {
     xt_value writeFn = xt_object_get_cstr(thisValue, "write");
-    if (XT_IS_FUNCTION(writeFn)) xt_call_with_this(writeFn, thisValue, 1, &chunk);
+    if (XT_IS_FUNCTION(writeFn)) {
+      xt_value noop = xt_closure_new((void *)xt_stream_noop, 0, NULL);
+      xt_value writeArgs[3] = {chunk, xt_undefined(), noop};
+      xt_call_with_this(writeFn, thisValue, 3, writeArgs);
+    }
   }
   for (int32_t i = 0; i < argc; i++) {
     if (XT_IS_FUNCTION(argv[i])) callback = argv[i];

package/runtime/rt.h

@@ -17,6 +17,14 @@
 #include <stddef.h>
 #include <stdint.h>
 
+/* POSIX `ssize_t` is not exposed by the MSVC/UCRT headers clang uses on
+ * Windows (every Unix libc defines it). Alias the Windows pointer-sized signed
+ * integer so the runtime's POSIX shims compile unchanged. */
+#if defined(_WIN32) && !defined(_SSIZE_T_DEFINED)
+typedef intptr_t ssize_t;
+#define _SSIZE_T_DEFINED
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif

package/runtime/rt_internal.h

@@ -224,31 +224,18 @@ typedef struct xt_try_frame {
   struct xt_try_frame *prev;
   xt_value exception;
 } xt_try_frame;
-/* Call `_setjmp` the way the active `<setjmp.h>` declares it. The two Windows
- * C runtimes differ:
+/* Save a try frame with clang's `_setjmp` built-in.
  *
- *  - MSVC/UCRT declares `_setjmp(jmp_buf)` with one visible argument and lets
- *    clang treat it as a built-in that injects the caller's frame address
- *    (`@llvm.frameaddress(0)`) as a hidden second argument. Writing the frame
- *    by hand is a compile error ("too many arguments to function call").
- *  - MinGW-w64 (the vendored llvm-mingw toolchain) declares
- *    `_setjmp(jmp_buf, void *frame)` itself, so the frame must be passed
- *    explicitly -- exactly what its own `setjmp` macro does.
- *
- * The generated IR emits the two-argument form, because it is already IR and
- * clang will not rewrite it. On Windows ARM64 it names `_setjmpex` (and the
- * entry stack pointer from `llvm.sponentry`) instead, matching clang's own
- * lowering there. `_setjmp`/`_setjmpex` (rather than the `setjmp` macro) is
- * used so it pairs with the plain `longjmp` in `xt_throw`. */
-#if defined(_WIN32) && !defined(__MINGW32__)
-#define xt_try_setjmp(framePtr) _setjmp(((xt_try_frame *)(framePtr))->buf)
-#elif defined(_WIN32) && defined(__aarch64__)
-#define xt_try_setjmp(framePtr) _setjmpex(((xt_try_frame *)(framePtr))->buf, __builtin_sponentry())
-#elif defined(_WIN32)
-#define xt_try_setjmp(framePtr) _setjmp(((xt_try_frame *)(framePtr))->buf, __builtin_frame_address(0))
-#else
+ * The generated IR passes the frame explicitly because it is already IR and
+ * clang will not rewrite it. This C helper instead calls `_setjmp(buf)` and lets
+ * clang supply the frame: on Windows x64 it injects the caller's frame address
+ * (`@llvm.frameaddress(0)`) into `_JUMP_BUFFER.Frame` so `longjmp` can feed it
+ * to `RtlUnwind`; on Windows ARM64, where the UCRT has no `_setjmp`, it lowers
+ * the call to `_setjmpex` with the entry stack pointer (`@llvm.sponentry`). On
+ * Linux/macOS `_setjmp` takes only the buffer and pairs with `longjmp`.
+ * `_setjmp` is used rather than the exported `setjmp` symbol, whose Windows ABI
+ * is an incompatible two-argument routine. */
 #define xt_try_setjmp(framePtr) _setjmp(((xt_try_frame *)(framePtr))->buf)
-#endif
 void *xt_try_mark(void);
 void xt_try_restore(void *mark);
 

package/runtime/xt_ext.h

@@ -20,7 +20,6 @@
  * runtime directory on the include path:
  *
  *     clang++ -O2 -fPIC -I<runtime> -c mathx.cpp -o mathx.o
- *     ar rcs libmathx.a mathx.o
  */
 #ifndef XT_EXT_H
 #define XT_EXT_H

package/runtime/xt_io.c

@@ -14,9 +14,9 @@
  * bogus target (`STATUS_BAD_FUNCTION_TABLE`, 0xC00000FF). Windows ARM64 has
  * no `_setjmp` at all: the generated IR uses `_setjmpex(buf, entry-sp)` with
  * the stack pointer on entry (`@llvm.sponentry`), exactly as clang lowers a C
- * `setjmp` there. The C runtime (see `xt_try_setjmp`) calls whatever the
- * active `<setjmp.h>` declares — one argument on MSVC (clang injects the
- * frame) and two on MinGW-w64. `_setjmp`/`_setjmpex` are used rather than the
+ * `setjmp` there. The C runtime (see `xt_try_setjmp`) calls clang's
+ * `_setjmp` built-in so it gets the same frame injection (lowered to
+ * `_setjmpex` on ARM64). `_setjmp`/`_setjmpex` are used rather than the
  * exported `setjmp` symbol, whose Windows ABI is an incompatible two-argument
  * routine; on Linux/macOS `_setjmp` takes only the buffer and pairs with
  * `longjmp` (the XSI `_longjmp` does not exist on Windows).
@@ -52,6 +52,26 @@ static xt_try_frame *g_try_top = NULL;
 int32_t xt_program_argc = 0;
 char **xt_program_argv = NULL;
 
+#if defined(_WIN32)
+/*
+ * The UCRT validates its low-level I/O arguments and, when one is out of
+ * range, calls the invalid-parameter handler. The default handler terminates
+ * the process through `_invoke_watson`, which fast-fails with exit status
+ * 0xC0000409. That makes POSIX-style calls such as `close(9999)` abort instead
+ * of reporting `EBADF`. Install a no-op handler so the CRT returns its normal
+ * error code (and sets `errno`) instead of crashing.
+ */
+static void __cdecl xt_noop_invalid_parameter_handler(const wchar_t *expression, const wchar_t *function_name,
+                                                      const wchar_t *file_name, unsigned int line_number,
+                                                      uintptr_t reserved) {
+  (void)expression;
+  (void)function_name;
+  (void)file_name;
+  (void)line_number;
+  (void)reserved;
+}
+#endif
+
 void xt_set_program_args(int32_t argc, char **argv) {
 #if defined(_WIN32)
   /* Keep stdout/stderr in binary mode so `\n` is not translated to `\r\n`,
@@ -59,6 +79,7 @@ void xt_set_program_args(int32_t argc, char **argv) {
      sockets (the generated `main` calls this before running the program). */
   _setmode(_fileno(stdout), _O_BINARY);
   _setmode(_fileno(stderr), _O_BINARY);
+  _set_invalid_parameter_handler(xt_noop_invalid_parameter_handler);
   WSADATA wsaData;
   WSAStartup(MAKEWORD(2, 2), &wsaData);
 #endif

package/runtime/xt_stdlib2/helpers.inc

@@ -1,8 +1,6 @@
 /*
- * `timegm` and `gmtime_r` are POSIX extensions that Windows' CRT does not
- * provide. MinGW-w64 (the bundled Windows toolchain) is affected too: its
- * <time.h> only exposes `gmtime_r` when `_POSIX_C_SOURCE` is set and has no
- * `timegm` at all, so wrap the MSVC-style equivalents for every `_WIN32` build.
+ * `timegm` and `gmtime_r` are POSIX extensions that the MSVC/UCRT headers do
+ * not provide, so wrap the MSVC-style equivalents for every `_WIN32` build.
  */
 #if defined(_WIN32)
 static time_t xt_timegm(struct tm *tm) { return (time_t)_mkgmtime64(tm); }