xbintsc 0.3.13 → 0.3.14

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,15 @@
 #include <stddef.h>
 #include <stdint.h>
 
+/* POSIX `ssize_t` is not exposed by the MSVC/UCRT headers clang uses on
+ * Windows, but MinGW-w64 (the vendored toolchain) and every Unix libc define
+ * it. Alias the Windows pointer-sized signed integer so the runtime's POSIX
+ * shims compile unchanged across toolchains. */
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(_SSIZE_T_DEFINED)
+typedef intptr_t ssize_t;
+#define _SSIZE_T_DEFINED
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif

package/runtime/xt_io.c

@@ -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/src/codegen/generator/calls/access.ts

@@ -106,6 +106,21 @@ export const accessCallMethods: AccessCallMethods = {
         }
       }
     }
+    // Modules with no namespace dispatcher (`fs`, ...) can still expose value
+    // getters (`fs.constants`, `fs.promises`). Lower `fs.constants` the same
+    // way a named `import { constants } from "fs"` is lowered.
+    if (node.expression.kind === SyntaxKind.Identifier) {
+      const moduleExports = this.moduleExportsOfSymbol(
+        this.binding.symbolOfIdentifier.get(node.expression as Identifier),
+      );
+      const exported = moduleExports?.[node.name.text];
+      if (exported?.valueSymbol) {
+        this.extraDeclarations.add(`declare i64 @${exported.valueSymbol}(i32, i64*)`);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @${exported.valueSymbol}(i32 0, i64* null)`);
+        return result;
+      }
+    }
     const object = this.emitExpression(node.expression);
     return this.emitPropertyGet(object, node.name.text);
   },

package/src/codegen/generator/calls/invocation.ts

@@ -91,8 +91,14 @@ export const invocationCallMethods: InvocationCallMethods = {
       return result;
     }
     if (callee.kind === SyntaxKind.Identifier) {
-      if ((callee as Identifier).text === "super") return this.emitSuperConstructor(node);
-      const symbol = this.binding.symbolOfIdentifier.get(callee as Identifier);
+      const identifier = callee as Identifier;
+      if (identifier.text === "super") return this.emitSuperConstructor(node);
+      const symbol = this.binding.symbolOfIdentifier.get(identifier);
+      // `require("x")` is CommonJS; the ESM form is the only supported import.
+      if (!symbol && identifier.text === "require") {
+        this.reportRequireUse(node);
+        return i64(XT_UNDEFINED);
+      }
       if (symbol && symbol.kind === SymbolKind.Import) {
         const exported = this.importExports.get(symbol.id);
         if (exported) return this.emitModuleExport(node, exported);

package/src/codegen/generator/context.ts

@@ -162,8 +162,8 @@ export class GeneratorContext {
     if (!symbols.some((symbol) => this.usedAsValue(symbol))) return;
     this.diagnostics.error(
       DiagnosticCode.ModuleNotFound,
-      `module '${specifier}' is not supported: xbintsc can only import built-in platform modules and ` +
-        "relative '.ts' files; third-party npm packages (node_modules) are not implemented yet",
+      `module '${specifier}' is not supported: xbintsc can import built-in platform modules, ` +
+        "relative '.ts' files and ESM packages under node_modules; CommonJS packages are not supported",
       declaration.moduleSpecifier,
       this.sourceFile.fileName,
     );
@@ -414,6 +414,34 @@ export class GeneratorContext {
       this.sourceFile.fileName,
     );
   }
+
+  /**
+   * Report a CommonJS `require(...)` use. xbintsc has no CommonJS module
+   * runtime, so point the user at the ESM `import` form (with the requested
+   * module in the hint when it is a string literal).
+   */
+  reportRequireUse(node: Node): void {
+    const specifier = requireSpecifier(node);
+    const replacement = specifier
+      ? `use an ESM import instead, e.g. \`import value from ${JSON.stringify(specifier)}\``
+      : "use an ESM `import` statement instead";
+    this.diagnostics.error(
+      DiagnosticCode.UnsupportedFeature,
+      `CommonJS \`require()\` is not supported; ${replacement}`,
+      node,
+      this.sourceFile.fileName,
+    );
+  }
+}
+
+/** The string literal passed to `require("...")`, when there is one. */
+function requireSpecifier(node: Node): string | undefined {
+  if (node.kind !== SyntaxKind.CallExpression) return undefined;
+  const first = (node as { arguments?: readonly Node[] }).arguments?.[0];
+  if (first && first.kind === SyntaxKind.StringLiteral) {
+    return (first as unknown as { value: string }).value;
+  }
+  return undefined;
 }
 
 /** A bare module specifier (`fs`, `node:fs`, `@scope/pkg`), not a file path. */