Diffusion Ant (type-hints-typescript) Code

fs.c
899dad6b8a9etype-hints-typescript

fs.c
View Options

			#include <compat.h> // IWYU pragma: keep

			#include <uv.h>
			#include <stdio.h>
			#include <stdlib.h>
			#include <string.h>
			#include <stdbool.h>
			#include <sys/stat.h>
			#include <fcntl.h>
			#include <uthash.h>
			#include <utarray.h>
			#include <errno.h>

			#include "ant.h"
			#include "ptr.h"
			#include "utf8.h"
			#include "utils.h"
			#include "base64.h"
			#include "errors.h"
			#include "watch.h"
			#include "internal.h"
			#include "runtime.h"
			#include "descriptors.h"

			#include "gc/roots.h"
			#include "gc/modules.h"
			#include "silver/engine.h"

			#include "modules/fs.h"
			#include "modules/date.h"
			#include "modules/buffer.h"
			#include "modules/events.h"
			#include "modules/stream.h"
			#include "modules/symbol.h"
			#include "modules/url.h"

			typedef enum {
			FS_ENC_NONE = 0,
			FS_ENC_UTF8,
			FS_ENC_UTF16LE,
			FS_ENC_LATIN1,
			FS_ENC_BASE64,
			FS_ENC_BASE64URL,
			FS_ENC_HEX,
			FS_ENC_ASCII,
			} fs_encoding_t;

			typedef enum {
			FS_OP_READ,
			FS_OP_WRITE,
			FS_OP_UNLINK,
			FS_OP_MKDIR,
			FS_OP_RMDIR,
			FS_OP_STAT,
			FS_OP_READ_BYTES,
			FS_OP_EXISTS,
			FS_OP_READDIR,
			FS_OP_ACCESS,
			FS_OP_REALPATH,
			FS_OP_WRITE_FD,
			FS_OP_READ_FD,
			FS_OP_OPEN,
			FS_OP_CLOSE,
			FS_OP_MKDTEMP,
			FS_OP_CHMOD,
			FS_OP_RENAME
			} fs_op_type_t;

			typedef struct fs_request_s {
			uv_fs_t uv_req;
			ant_t *js;
			ant_value_t promise;
			ant_value_t target_buffer;
			ant_value_t callback_fn;

			char *path;
			char *path2;
			char *data;
			char *error_msg;
			size_t data_len;
			size_t buf_offset;

			fs_op_type_t op_type;
			fs_encoding_t encoding;
			uv_file fd;

			int completed;
			int failed;
			int recursive;
			int error_code;
			int with_file_types;
			} fs_request_t;

			typedef enum {
			FS_WATCH_MODE_EVENT = 0,
			FS_WATCH_MODE_STAT
			} fs_watch_mode_t;

			typedef union {
			uv_fs_event_t event;
			uv_fs_poll_t poll;
			} fs_watcher_handle_t;

			typedef struct fs_watcher_s {
			ant_t *js;
			ant_value_t obj;
			ant_value_t callback;
			fs_watcher_handle_t handle;
			uv_stat_t last_stat;

			struct fs_watcher_s *next_active;
			char *path;

			bool last_stat_valid;
			bool in_active_list;
			bool closing;
			bool handle_closed;
			bool finalized;
			bool persistent;

			fs_watch_mode_t mode;
			} fs_watcher_t;

			typedef struct {
			bool persistent;
			bool recursive;
			ant_value_t listener;
			} fs_watch_options_t;

			typedef struct {
			bool persistent;
			unsigned int interval_ms;
			ant_value_t listener;
			} fs_watchfile_options_t;

			typedef struct {
			mode_t mode;
			double size, uid, gid;
			double atime_ms, mtime_ms, ctime_ms, birthtime_ms;
			} fs_stat_fields_t;

			static ant_value_t g_dirent_proto = 0;
			static ant_value_t g_fswatcher_proto = 0;
			static ant_value_t g_fswatcher_ctor = 0;
			static ant_value_t g_filehandle_proto = 0;
			static ant_value_t g_readstream_proto = 0;
			static ant_value_t g_readstream_ctor = 0;
			static ant_value_t g_writestream_proto = 0;
			static ant_value_t g_writestream_ctor = 0;

			static fs_watcher_t *active_watchers = NULL;
			static UT_array *pending_requests = NULL;

			enum {
			FS_WATCHER_NATIVE_TAG = 0x46535754u, // FSWT
			FS_FILEHANDLE_NATIVE_TAG = 0x46534648u // FSFH
			};

			static fs_watcher_t *fs_watcher_data(ant_value_t value) {
			if (!js_check_native_tag(value, FS_WATCHER_NATIVE_TAG)) return NULL;
			return (fs_watcher_t *)js_get_native_ptr(value);
			}

			static void fs_add_active_watcher(fs_watcher_t *watcher) {
			if (!watcher \|\| watcher->in_active_list) return;
			watcher->next_active = active_watchers;
			active_watchers = watcher;
			watcher->in_active_list = true;
			}

			static void fs_remove_active_watcher(fs_watcher_t *watcher) {
			fs_watcher_t **it = NULL;
			if (!watcher \|\| !watcher->in_active_list) return;

			for (it = &active_watchers; it; it = &(it)->next_active) {
			if (*it != watcher) continue;
			*it = watcher->next_active;
			watcher->next_active = NULL;
			watcher->in_active_list = false;
			return;
			}
			}

			static ant_value_t fs_call_value(
			ant_t *js,
			ant_value_t fn,
			ant_value_t this_val,
			ant_value_t *args,
			int nargs
			) {
			ant_value_t saved_this = js->this_val;
			ant_value_t result = js_mkundef();

			js->this_val = this_val;
			if (vtype(fn) == T_CFUNC) result = js_as_cfunc(fn)(js, args, nargs);
			else result = sv_vm_call(js->vm, js, fn, this_val, args, nargs, NULL, false);
			js->this_val = saved_this;

			return result;
			}

			static int parse_open_flags(ant_t *js, ant_value_t arg);
			static ant_value_t fs_coerce_path(ant_t *js, ant_value_t arg);

			static ant_value_t fs_mk_errno_error(
			ant_t *js, int err_num,
			const char syscall, const char path, const char *dest
			);

			static ant_value_t fs_mk_uv_error(
			ant_t *js, int uv_code,
			const char syscall, const char path, const char *dest
			);

			static bool fs_parse_mode(ant_t js, ant_value_t arg, mode_t out) {
			if (vtype(arg) == T_NUM) {
			double mode = js_getnum(arg);
			if (mode < 0) return false;
			*out = (mode_t)mode;
			return true;
			}

			if (vtype(arg) != T_STR) return false;

			size_t len = 0;
			const char *str = js_getstr(js, arg, &len);
			if (!str) return false;

			size_t start = 0;
			if (len > 2 && str[0] == '0' && (str[1] == 'o' \|\| str[1] == 'O')) start = 2;
			if (start == len) return false;

			mode_t mode = 0;
			for (size_t i = start; i < len; i++) {
			if (str[i] < '0' \|\| str[i] > '7') return false;
			mode = (mode_t)((mode << 3) + (str[i] - '0'));
			}

			*out = mode;
			return true;
			}

			static ant_value_t fs_stream_error(ant_t js, ant_value_t stream_obj, const char op, int uv_code) {
			ant_value_t props = js_mkobj(js);
			ant_value_t path_val = js_get(js, stream_obj, "path");
			const char *code = uv_err_name(uv_code);

			if (code) js_set(js, props, "code", js_mkstr(js, code, strlen(code)));
			js_set(js, props, "errno", js_mknum((double)uv_code));
			if (vtype(path_val) == T_STR) js_set(js, props, "path", path_val);
			return js_mkerr_props(js, JS_ERR_TYPE, props, "%s failed: %s", op, uv_strerror(uv_code));
			}

			static ant_value_t fs_stream_push_chunk(ant_t *js, ant_value_t stream_obj, ant_value_t chunk) {
			return stream_readable_push(js, stream_obj, chunk, js_mkundef());
			}

			static ant_value_t fs_stream_callback(ant_t *js, ant_value_t callback, ant_value_t value) {
			if (!is_callable(callback)) return js_mkundef();
			return fs_call_value(js, callback, js_mkundef(), &value, 1);
			}

			static int fs_stream_close_fd_sync(ant_t *js, ant_value_t stream_obj) {
			ant_value_t fd_val = js_get(js, stream_obj, "fd");
			uv_fs_t req;
			int result = 0;

			if (vtype(fd_val) != T_NUM) {
			js_set(js, stream_obj, "pending", js_false);
			js_set(js, stream_obj, "closed", js_true);
			return 0;
			}

			result = uv_fs_close(uv_default_loop(), &req, (uv_file)js_getnum(fd_val), NULL);
			uv_fs_req_cleanup(&req);

			js_set(js, stream_obj, "fd", js_mknull());
			js_set(js, stream_obj, "pending", js_false);
			js_set(js, stream_obj, "closed", js_true);

			return result;
			}

			static int fs_stream_open_fd_sync(ant_t *js, ant_value_t stream_obj) {
			ant_value_t fd_val = js_get(js, stream_obj, "fd");
			ant_value_t path_val = js_get(js, stream_obj, "path");
			ant_value_t mode_val = js_get(js, stream_obj, "mode");
			ant_value_t flags_val = js_get_slot(stream_obj, SLOT_FS_FLAGS);

			size_t path_len = 0;
			const char *path = NULL;
			char *path_copy = NULL;
			uv_fs_t req;

			int flags = 0;
			int mode = 0666;
			int result = 0;

			if (vtype(fd_val) == T_NUM) return (int)js_getnum(fd_val);
			if (vtype(path_val) != T_STR) return UV_EINVAL;

			path = js_getstr(js, path_val, &path_len);
			if (!path) return UV_EINVAL;

			path_copy = strndup(path, path_len);
			if (!path_copy) return UV_ENOMEM;

			flags = (vtype(flags_val) == T_NUM) ? (int)js_getnum(flags_val) : O_RDONLY;
			if (vtype(mode_val) == T_NUM) mode = (int)js_getnum(mode_val);

			result = uv_fs_open(uv_default_loop(), &req, path_copy, flags, mode, NULL);
			uv_fs_req_cleanup(&req);
			free(path_copy);

			if (result < 0) return result;

			js_set(js, stream_obj, "fd", js_mknum((double)result));
			js_set(js, stream_obj, "pending", js_false);
			js_set(js, stream_obj, "closed", js_false);

			ant_value_t open_arg = js_mknum((double)result);
			eventemitter_emit_args(js, stream_obj, "open", &open_arg, 1);
			eventemitter_emit_args(js, stream_obj, "ready", NULL, 0);

			return result;
			}

			static ant_value_t fs_stream_destroy(ant_t js, ant_value_t args, int nargs) {
			ant_value_t stream_obj = js_getthis(js);
			ant_value_t err = nargs > 0 ? args[0] : js_mknull();
			ant_value_t callback = nargs > 1 ? args[1] : js_mkundef();
			int result = fs_stream_close_fd_sync(js, stream_obj);

			if (result < 0 && (is_null(err) \|\| is_undefined(err)))
			err = fs_stream_error(js, stream_obj, "close", result);
			if (is_undefined(err)) err = js_mknull();

			return fs_stream_callback(js, callback, err);
			}

			static ant_value_t fs_stream_close(ant_t js, ant_value_t args, int nargs) {
			ant_value_t stream_obj = js_getthis(js);

			if (nargs > 0 && is_callable(args[0])) {
			eventemitter_add_listener(js, stream_obj, "close", args[0], true);
			if (js_truthy(js, js_get(js, stream_obj, "closed")))
			fs_call_value(js, args[0], js_mkundef(), NULL, 0);
			}

			if (!js_truthy(js, js_get(js, stream_obj, "destroyed"))) {
			ant_value_t destroy_fn = js_getprop_fallback(js, stream_obj, "destroy");
			if (is_callable(destroy_fn)) fs_call_value(js, destroy_fn, stream_obj, NULL, 0);
			}

			return stream_obj;
			}

			static ant_value_t fs_readstream__read(ant_t js, ant_value_t args, int nargs) {
			ant_value_t stream_obj = js_getthis(js);
			ant_value_t pos_val = js_get(js, stream_obj, "pos");
			ant_value_t end_val = js_get(js, stream_obj, "end");
			ant_value_t bytes_read_val = js_get(js, stream_obj, "bytesRead");

			int fd = fs_stream_open_fd_sync(js, stream_obj);
			int64_t pos = (vtype(pos_val) == T_NUM) ? (int64_t)js_getnum(pos_val) : 0;
			int64_t end = (vtype(end_val) == T_NUM) ? (int64_t)js_getnum(end_val) : -1;

			size_t want = 16384;
			bool reached_eof = false;

			if (fd < 0) {
			ant_value_t err = fs_stream_error(js, stream_obj, "open", fd);
			ant_value_t destroy_fn = js_getprop_fallback(js, stream_obj, "destroy");
			if (is_callable(destroy_fn)) fs_call_value(js, destroy_fn, stream_obj, &err, 1);
			return js_mkundef();
			}

			if (nargs > 0 && vtype(args[0]) == T_NUM && js_getnum(args[0]) > 0)
			want = (size_t)js_getnum(args[0]);

			if (end >= 0) {
			if (pos > end) {
			if (js_truthy(js, js_get(js, stream_obj, "autoClose"))) fs_stream_close_fd_sync(js, stream_obj);
			return fs_stream_push_chunk(js, stream_obj, js_mknull());
			}
			if ((int64_t)want > (end - pos + 1)) want = (size_t)(end - pos + 1);
			}

			ArrayBufferData *ab = create_array_buffer_data(want);
			if (!ab) {
			ant_value_t err = js_mkerr(js, "Failed to allocate ReadStream buffer");
			ant_value_t destroy_fn = js_getprop_fallback(js, stream_obj, "destroy");
			if (is_callable(destroy_fn)) fs_call_value(js, destroy_fn, stream_obj, &err, 1);
			return js_mkundef();
			}

			uv_fs_t req;
			uv_buf_t buf = uv_buf_init((char *)ab->data, (unsigned int)want);
			int result = uv_fs_read(uv_default_loop(), &req, fd, &buf, 1, pos, NULL);
			uv_fs_req_cleanup(&req);

			if (result < 0) {
			ant_value_t err = fs_stream_error(js, stream_obj, "read", result);
			ant_value_t destroy_fn = js_getprop_fallback(js, stream_obj, "destroy");
			free_array_buffer_data(ab);
			if (is_callable(destroy_fn)) fs_call_value(js, destroy_fn, stream_obj, &err, 1);
			return js_mkundef();
			}

			if (result == 0) {
			free_array_buffer_data(ab);
			if (js_truthy(js, js_get(js, stream_obj, "autoClose")))
			(void)fs_stream_close_fd_sync(js, stream_obj);
			return fs_stream_push_chunk(js, stream_obj, js_mknull());
			}

			ant_value_t chunk = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, (size_t)result, "Buffer");
			if (vtype(chunk) == T_ERR) {
			free_array_buffer_data(ab);
			return chunk;
			}

			if (result < (int)want) reached_eof = true;
			if (end >= 0 && (pos + result - 1) >= end) reached_eof = true;

			js_set(js, stream_obj, "pos", js_mknum((double)(pos + result)));
			js_set(js, stream_obj, "bytesRead", js_mknum(
			(vtype(bytes_read_val) == T_NUM
			? js_getnum(bytes_read_val) : 0.0) + (double)result
			));

			fs_stream_push_chunk(js, stream_obj, chunk);

			if (reached_eof) {
			if (js_truthy(js, js_get(js, stream_obj, "autoClose"))) fs_stream_close_fd_sync(js, stream_obj);
			return fs_stream_push_chunk(js, stream_obj, js_mknull());
			}

			return js_mkundef();
			}

			static ant_value_t fs_writestream__write(ant_t js, ant_value_t args, int nargs) {
			ant_value_t stream_obj = js_getthis(js);
			ant_value_t callback = nargs > 2 ? args[2] : js_mkundef();
			ant_value_t pos_val = js_get(js, stream_obj, "pos");
			ant_value_t bytes_written_val = js_get(js, stream_obj, "bytesWritten");

			const uint8_t *bytes = NULL;
			size_t len = 0;

			int fd = fs_stream_open_fd_sync(js, stream_obj);
			int64_t pos = (vtype(pos_val) == T_NUM) ? (int64_t)js_getnum(pos_val) : -1;
			size_t offset = 0;

			if (fd < 0) return fs_stream_callback(js, callback, fs_stream_error(js, stream_obj, "open", fd));

			if (vtype(args[0]) == T_STR) {
			bytes = (const uint8_t *)js_getstr(js, args[0], &len);
			} else if (!buffer_source_get_bytes(js, args[0], &bytes, &len)) {
			return fs_stream_callback(js, callback, js_mkerr(js, "WriteStream chunk must be a string or ArrayBufferView"));
			}

			while (offset < len) {
			uv_fs_t req;
			uv_buf_t buf = uv_buf_init((char *)(bytes + offset), (unsigned int)(len - offset));
			int result = uv_fs_write(uv_default_loop(), &req, fd, &buf, 1, pos, NULL);
			uv_fs_req_cleanup(&req);

			if (result < 0) {
			if (js_truthy(js, js_get(js, stream_obj, "autoClose"))) fs_stream_close_fd_sync(js, stream_obj);
			return fs_stream_callback(js, callback, fs_stream_error(js, stream_obj, "write", result));
			}
			if (result == 0) {
			if (js_truthy(js, js_get(js, stream_obj, "autoClose"))) fs_stream_close_fd_sync(js, stream_obj);
			return fs_stream_callback(js, callback, js_mkerr(js, "write failed: short write"));
			}

			offset += (size_t)result;
			if (pos >= 0) pos += result;
			}

			if (pos >= 0) js_set(js, stream_obj, "pos", js_mknum((double)pos));
			js_set(js, stream_obj, "bytesWritten", js_mknum(
			(vtype(bytes_written_val) == T_NUM
			? js_getnum(bytes_written_val) : 0.0) + (double)offset
			));

			return fs_stream_callback(js, callback, js_mknull());
			}

			static ant_value_t fs_writestream__final(ant_t js, ant_value_t args, int nargs) {
			ant_value_t stream_obj = js_getthis(js);
			ant_value_t callback = nargs > 0 ? args[0] : js_mkundef();
			ant_value_t value = js_mknull();

			if (js_truthy(js, js_get(js, stream_obj, "autoClose"))) {
			int result = fs_stream_close_fd_sync(js, stream_obj);
			if (result < 0) value = fs_stream_error(js, stream_obj, "close", result);
			}

			return fs_stream_callback(js, callback, value);
			}

			static ant_value_t fs_create_readstream_impl(ant_t *js, ant_value_t path_arg, ant_value_t options_arg, ant_value_t proto) {
			ant_value_t path_val = fs_coerce_path(js, path_arg);
			ant_value_t options = is_object_type(options_arg) ? options_arg : js_mkobj(js);
			ant_value_t stream_options = js_mkobj(js);

			ant_value_t hwm = js_get(js, options, "highWaterMark");
			ant_value_t flags_raw = js_get(js, options, "flags");
			ant_value_t fd_val = js_get(js, options, "fd");
			ant_value_t start_val = js_get(js, options, "start");
			ant_value_t end_val = js_get(js, options, "end");
			ant_value_t mode_val = js_get(js, options, "mode");

			ant_value_t auto_close_val = js_get(js, options, "autoClose");
			ant_value_t emit_close_val = js_get(js, options, "emitClose");
			ant_value_t stream_obj = 0;

			int flags = parse_open_flags(js, is_undefined(flags_raw) ? js_mkstr(js, "r", 1) : flags_raw);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "ReadStream path must be a string");
			if (vtype(hwm) == T_NUM && js_getnum(hwm) > 0) js_set(js, stream_options, "highWaterMark", hwm);

			stream_obj = stream_construct_readable(js, proto, stream_options);
			if (is_err(stream_obj)) return stream_obj;

			js_set(js, stream_obj, "_read", js_mkfun(fs_readstream__read));
			js_set(js, stream_obj, "_destroy", js_mkfun(fs_stream_destroy));
			js_set(js, stream_obj, "path", path_val);
			js_set(js, stream_obj, "flags", is_undefined(flags_raw) ? js_mkstr(js, "r", 1) : flags_raw);
			js_set(js, stream_obj, "mode", vtype(mode_val) == T_NUM ? mode_val : js_mknum(0666));
			js_set(js, stream_obj, "fd", vtype(fd_val) == T_NUM ? fd_val : js_mkundef());
			js_set(js, stream_obj, "pending", js_bool(vtype(fd_val) != T_NUM));
			js_set(js, stream_obj, "closed", js_false);
			js_set(js, stream_obj, "autoClose", is_undefined(auto_close_val) ? js_true : js_bool(js_truthy(js, auto_close_val)));
			js_set(js, stream_obj, "emitClose", is_undefined(emit_close_val) ? js_true : js_bool(js_truthy(js, emit_close_val)));
			js_set(js, stream_obj, "bytesRead", js_mknum(0));
			js_set(js, stream_obj, "start", vtype(start_val) == T_NUM ? start_val : js_mkundef());
			js_set(js, stream_obj, "end", vtype(end_val) == T_NUM ? end_val : js_mkundef());
			js_set(js, stream_obj, "pos", js_mknum(vtype(start_val) == T_NUM ? js_getnum(start_val) : 0.0));
			js_set_slot(stream_obj, SLOT_FS_FLAGS, js_mknum((double)flags));

			return stream_obj;
			}

			static ant_value_t fs_create_writestream_impl(ant_t *js, ant_value_t path_arg, ant_value_t options_arg, ant_value_t proto) {
			ant_value_t path_val = fs_coerce_path(js, path_arg);
			ant_value_t options = is_object_type(options_arg) ? options_arg : js_mkobj(js);
			ant_value_t stream_options = js_mkobj(js);

			ant_value_t flags_raw = js_get(js, options, "flags");
			ant_value_t fd_val = js_get(js, options, "fd");
			ant_value_t start_val = js_get(js, options, "start");
			ant_value_t mode_val = js_get(js, options, "mode");
			ant_value_t auto_close_val = js_get(js, options, "autoClose");
			ant_value_t emit_close_val = js_get(js, options, "emitClose");
			ant_value_t hwm = js_get(js, options, "highWaterMark");
			ant_value_t stream_obj = 0;

			int flags = parse_open_flags(js, is_undefined(flags_raw) ? js_mkstr(js, "w", 1) : flags_raw);
			double start_pos = (vtype(start_val) == T_NUM) ? js_getnum(start_val) : ((flags & O_APPEND) ? -1.0 : 0.0);

			if (vtype(path_val) != T_STR) return js_mkerr(js, "WriteStream path must be a string");
			if (vtype(hwm) == T_NUM && js_getnum(hwm) > 0) js_set(js, stream_options, "highWaterMark", hwm);

			stream_obj = stream_construct_writable(js, proto, stream_options);
			if (is_err(stream_obj)) return stream_obj;

			js_set(js, stream_obj, "_write", js_mkfun(fs_writestream__write));
			js_set(js, stream_obj, "_final", js_mkfun(fs_writestream__final));
			js_set(js, stream_obj, "_destroy", js_mkfun(fs_stream_destroy));
			js_set(js, stream_obj, "path", path_val);
			js_set(js, stream_obj, "flags", is_undefined(flags_raw) ? js_mkstr(js, "w", 1) : flags_raw);
			js_set(js, stream_obj, "mode", vtype(mode_val) == T_NUM ? mode_val : js_mknum(0666));
			js_set(js, stream_obj, "fd", vtype(fd_val) == T_NUM ? fd_val : js_mkundef());
			js_set(js, stream_obj, "pending", js_bool(vtype(fd_val) != T_NUM));
			js_set(js, stream_obj, "closed", js_false);
			js_set(js, stream_obj, "autoClose", is_undefined(auto_close_val) ? js_true : js_bool(js_truthy(js, auto_close_val)));
			js_set(js, stream_obj, "emitClose", is_undefined(emit_close_val) ? js_true : js_bool(js_truthy(js, emit_close_val)));
			js_set(js, stream_obj, "bytesWritten", js_mknum(0));
			js_set(js, stream_obj, "start", vtype(start_val) == T_NUM ? start_val : js_mkundef());
			js_set(js, stream_obj, "pos", js_mknum(start_pos));
			js_set_slot(stream_obj, SLOT_FS_FLAGS, js_mknum((double)flags));

			return stream_obj;
			}

			static ant_value_t js_readstream_ctor(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "ReadStream() requires a path argument");
			return fs_create_readstream_impl(js, args[0], nargs > 1 ? args[1] : js_mkundef(), g_readstream_proto);
			}

			static ant_value_t js_writestream_ctor(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "WriteStream() requires a path argument");
			return fs_create_writestream_impl(js, args[0], nargs > 1 ? args[1] : js_mkundef(), g_writestream_proto);
			}

			static ant_value_t builtin_fs_createReadStream(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "createReadStream() requires a path argument");
			return fs_create_readstream_impl(js, args[0], nargs > 1 ? args[1] : js_mkundef(), g_readstream_proto);
			}

			static ant_value_t builtin_fs_createWriteStream(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "createWriteStream() requires a path argument");
			return fs_create_writestream_impl(js, args[0], nargs > 1 ? args[1] : js_mkundef(), g_writestream_proto);
			}

			static void fs_init_stream_constructors(ant_t *js) {
			if (g_readstream_ctor && g_writestream_ctor) return;

			stream_init_constructors(js);

			g_readstream_proto = js_mkobj(js);
			js_set_proto_init(g_readstream_proto, stream_readable_prototype(js));
			js_set(js, g_readstream_proto, "close", js_mkfun(fs_stream_close));
			js_set_sym(js, g_readstream_proto, get_toStringTag_sym(), js_mkstr(js, "ReadStream", 10));
			g_readstream_ctor = js_make_ctor(js, js_readstream_ctor, g_readstream_proto, "ReadStream", 10);
			js_set_proto_init(g_readstream_ctor, stream_readable_constructor(js));

			g_writestream_proto = js_mkobj(js);
			js_set_proto_init(g_writestream_proto, stream_writable_prototype(js));
			js_set(js, g_writestream_proto, "close", js_mkfun(fs_stream_close));
			js_set_sym(js, g_writestream_proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11));
			g_writestream_ctor = js_make_ctor(js, js_writestream_ctor, g_writestream_proto, "WriteStream", 11);
			js_set_proto_init(g_writestream_ctor, stream_writable_constructor(js));
			}

			static ant_value_t fs_make_date(ant_t *js, double ms) {
			ant_value_t obj = js_mkobj(js);
			ant_value_t date_proto = js_get_ctor_proto(js, "Date", 4);
			if (is_object_type(date_proto)) js_set_proto_init(obj, date_proto);
			js_set_slot(obj, SLOT_DATA, tov(ms));
			js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_DATE));
			return obj;
			}

			static ant_value_t fs_stats_object_new(ant_t js, const fs_stat_fields_t f) {
			ant_value_t stat_obj = js_mkobj(js);
			ant_value_t proto = js_get_ctor_proto(js, "Stats", 5);

			if (is_object_type(proto) \|\| is_special_object(proto))
			js_set_proto_init(stat_obj, proto);

			js_set_slot(stat_obj, SLOT_DATA, js_mknum((double)f->mode));
			js_set(js, stat_obj, "size", js_mknum(f->size));
			js_set(js, stat_obj, "mode", js_mknum((double)f->mode));
			js_set(js, stat_obj, "uid", js_mknum(f->uid));
			js_set(js, stat_obj, "gid", js_mknum(f->gid));

			js_set(js, stat_obj, "atimeMs", js_mknum(f->atime_ms));
			js_set(js, stat_obj, "mtimeMs", js_mknum(f->mtime_ms));
			js_set(js, stat_obj, "ctimeMs", js_mknum(f->ctime_ms));
			js_set(js, stat_obj, "birthtimeMs", js_mknum(f->birthtime_ms));

			js_set(js, stat_obj, "atime", fs_make_date(js, f->atime_ms));
			js_set(js, stat_obj, "mtime", fs_make_date(js, f->mtime_ms));
			js_set(js, stat_obj, "ctime", fs_make_date(js, f->ctime_ms));
			js_set(js, stat_obj, "birthtime", fs_make_date(js, f->birthtime_ms));

			return stat_obj;
			}

			static double uv_ts_to_ms(uv_timespec_t ts) {
			return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1e6;
			}

			static double posix_ts_to_ms(struct timespec ts) {
			return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1e6;
			}

			#ifdef _WIN32
			#define POSIX_ATIME_MS(st) ((double)(st)->st_atime * 1000.0)
			#define POSIX_MTIME_MS(st) ((double)(st)->st_mtime * 1000.0)
			#define POSIX_CTIME_MS(st) ((double)(st)->st_ctime * 1000.0)
			#define POSIX_BIRTH_MS(st) 0.0
			#elif defined(__APPLE__)
			#define POSIX_ATIME_MS(st) posix_ts_to_ms((st)->st_atimespec)
			#define POSIX_MTIME_MS(st) posix_ts_to_ms((st)->st_mtimespec)
			#define POSIX_CTIME_MS(st) posix_ts_to_ms((st)->st_ctimespec)
			#define POSIX_BIRTH_MS(st) posix_ts_to_ms((st)->st_birthtimespec)
			#elif defined(__linux__)
			#define POSIX_ATIME_MS(st) posix_ts_to_ms((st)->st_atim)
			#define POSIX_MTIME_MS(st) posix_ts_to_ms((st)->st_mtim)
			#define POSIX_CTIME_MS(st) posix_ts_to_ms((st)->st_ctim)
			#define POSIX_BIRTH_MS(st) 0.0
			#else
			#define POSIX_ATIME_MS(st) posix_ts_to_ms((st)->st_atim)
			#define POSIX_MTIME_MS(st) posix_ts_to_ms((st)->st_mtim)
			#define POSIX_CTIME_MS(st) posix_ts_to_ms((st)->st_ctim)
			#define POSIX_BIRTH_MS(st) 0.0
			#endif

			static const fs_stat_fields_t fs_stat_fields_zero = {0};

			static ant_value_t fs_stats_object_from_uv(ant_t js, const uv_stat_t st) {
			if (!st) return fs_stats_object_new(js, &fs_stat_fields_zero);
			return fs_stats_object_new(js, &(fs_stat_fields_t){
			.mode = (mode_t)st->st_mode,
			.size = (double)st->st_size,
			.uid = (double)st->st_uid,
			.gid = (double)st->st_gid,
			.atime_ms = uv_ts_to_ms(st->st_atim),
			.mtime_ms = uv_ts_to_ms(st->st_mtim),
			.ctime_ms = uv_ts_to_ms(st->st_ctim),
			.birthtime_ms = uv_ts_to_ms(st->st_birthtim),
			});
			}

			static ant_value_t fs_stats_object_from_posix(ant_t js, const struct stat st) {
			if (!st) return fs_stats_object_new(js, &fs_stat_fields_zero);
			return fs_stats_object_new(js, &(fs_stat_fields_t){
			.mode = st->st_mode,
			.size = (double)st->st_size,
			.uid = (double)st->st_uid,
			.gid = (double)st->st_gid,
			.atime_ms = POSIX_ATIME_MS(st),
			.mtime_ms = POSIX_MTIME_MS(st),
			.ctime_ms = POSIX_CTIME_MS(st),
			.birthtime_ms = POSIX_BIRTH_MS(st),
			});
			}

			static bool fs_stat_path_sync(const char path, uv_stat_t out) {
			uv_fs_t req;
			int rc = 0;

			if (!path \|\| !out) return false;
			memset(out, 0, sizeof(*out));

			rc = uv_fs_stat(NULL, &req, path, NULL);
			if (rc < 0) {
			uv_fs_req_cleanup(&req);
			return false;
			}

			*out = req.statbuf;
			uv_fs_req_cleanup(&req);
			return true;
			}

			static const char fs_watch_basename(const char path) {
			const char *name = NULL;

			if (!path \|\| !*path) return NULL;
			name = strrchr(path, '/');
			#ifdef _WIN32
			{
			const char *alt = strrchr(path, '\\');
			if (!name \|\| (alt && alt > name)) name = alt;
			}
			#endif
			return name ? name + 1 : path;
			}

			static ant_value_t fs_watch_error(ant_t js, int status, const char path) {
			ant_value_t props = js_mkobj(js);
			const char *code = uv_err_name(status);
			js_set(js, props, "code", js_mkstr(js, code, strlen(code)));

			return js_mkerr_props(
			js, JS_ERR_TYPE,
			props, "%s: %s",
			path ? path : "watch",
			uv_strerror(status)
			);
			}

			static void fs_watcher_free(fs_watcher_t *watcher) {
			if (!watcher) return;
			free(watcher->path);
			free(watcher);
			}

			static uv_handle_t fs_watcher_uv_handle(fs_watcher_t watcher) {
			if (!watcher) return NULL;
			if (watcher->mode == FS_WATCH_MODE_STAT) return (uv_handle_t *)&watcher->handle.poll;
			return (uv_handle_t *)&watcher->handle.event;
			}

			static void fs_watcher_on_handle_closed(uv_handle_t *handle) {
			fs_watcher_t watcher = (fs_watcher_t )handle->data;

			if (!watcher) return;
			watcher->handle_closed = true;
			watcher->closing = false;
			if (watcher->finalized) fs_watcher_free(watcher);
			}

			static void fs_watcher_close_native(fs_watcher_t *watcher) {
			uv_handle_t *handle = NULL;

			if (!watcher) return;
			if (watcher->closing \|\| watcher->handle_closed) return;

			handle = fs_watcher_uv_handle(watcher);
			if (!handle) return;

			fs_remove_active_watcher(watcher);
			if (watcher->mode == FS_WATCH_MODE_STAT) uv_fs_poll_stop(&watcher->handle.poll);
			else ant_watch_stop(&watcher->handle.event);
			watcher->closing = true;
			uv_close(handle, fs_watcher_on_handle_closed);
			}

			static void fs_watcher_emit_error(fs_watcher_t *watcher, int status) {
			ant_value_t args[1];

			if (!watcher \|\| vtype(watcher->obj) != T_OBJ) return;
			args[0] = fs_watch_error(watcher->js, status, watcher->path);
			eventemitter_emit_args(watcher->js, watcher->obj, "error", args, 1);
			}

			static void fs_watcher_emit_change(fs_watcher_t watcher, const char filename, int events) {
			ant_value_t args[2];
			const char *event_name = "change";
			const char *name = filename;

			if (!watcher \|\| vtype(watcher->obj) != T_OBJ) return;
			if ((events & UV_RENAME) != 0) event_name = "rename";
			if (!name \|\| !*name) name = fs_watch_basename(watcher->path);

			args[0] = js_mkstr(watcher->js, event_name, strlen(event_name));
			args[1] = name ? js_mkstr(watcher->js, name, strlen(name)) : js_mkundef();
			eventemitter_emit_args(watcher->js, watcher->obj, "change", args, 2);
			}

			static void fs_watcher_invoke_watchfile_stats(
			fs_watcher_t *watcher,
			const uv_stat_t *curr,
			const uv_stat_t *prev
			) {
			uv_stat_t curr_stat;
			uv_stat_t prev_stat;
			ant_value_t args[2];

			if (!watcher \|\| !is_callable(watcher->callback)) return;

			memset(&curr_stat, 0, sizeof(curr_stat));
			memset(&prev_stat, 0, sizeof(prev_stat));
			if (curr) curr_stat = *curr;
			if (prev) prev_stat = *prev;

			watcher->last_stat = curr_stat;
			watcher->last_stat_valid = curr != NULL;

			args[0] = fs_stats_object_from_uv(watcher->js, &curr_stat);
			args[1] = fs_stats_object_from_uv(watcher->js, &prev_stat);
			fs_call_value(watcher->js, watcher->callback, js_mkundef(), args, 2);
			}

			static void fs_watcher_on_event(
			uv_fs_event_t *handle,
			const char *filename,
			int events,
			int status
			) {
			fs_watcher_t watcher = (fs_watcher_t )handle->data;

			if (!watcher) return;
			if (status < 0) {
			fs_watcher_emit_error(watcher, status);
			return;
			}

			if ((events & (UV_CHANGE \| UV_RENAME)) == 0) return;
			fs_watcher_emit_change(watcher, filename, events);
			}

			static void fs_watcher_on_poll(
			uv_fs_poll_t *handle,
			int status,
			const uv_stat_t *prev,
			const uv_stat_t *curr
			) {
			fs_watcher_t watcher = (fs_watcher_t )handle->data;
			uv_stat_t missing = {0};

			if (!watcher) return;
			if (status < 0 && status != UV_ENOENT) return;
			if (status == UV_ENOENT) {
			if (watcher->last_stat_valid) fs_watcher_invoke_watchfile_stats(watcher, &missing, &watcher->last_stat);
			else fs_watcher_invoke_watchfile_stats(watcher, &missing, &missing);
			return;
			}

			fs_watcher_invoke_watchfile_stats(watcher, curr, prev);
			}

			static ant_value_t js_fswatcher_close(ant_t js, ant_value_t args, int nargs) {
			fs_watcher_t *watcher = fs_watcher_data(js->this_val);

			if (!watcher) return js->this_val;
			fs_watcher_close_native(watcher);
			return js->this_val;
			}

			static ant_value_t js_fswatcher_ref(ant_t js, ant_value_t args, int nargs) {
			fs_watcher_t *watcher = fs_watcher_data(js->this_val);
			uv_handle_t *handle = NULL;

			if (!watcher \|\| watcher->handle_closed) return js->this_val;
			handle = fs_watcher_uv_handle(watcher);
			if (handle) uv_ref(handle);
			watcher->persistent = true;
			return js->this_val;
			}

			static ant_value_t js_fswatcher_unref(ant_t js, ant_value_t args, int nargs) {
			fs_watcher_t *watcher = fs_watcher_data(js->this_val);
			uv_handle_t *handle = NULL;

			if (!watcher \|\| watcher->handle_closed) return js->this_val;
			handle = fs_watcher_uv_handle(watcher);
			if (handle) uv_unref(handle);
			watcher->persistent = false;
			return js->this_val;
			}

			static ant_value_t js_fswatcher_ctor(ant_t js, ant_value_t args, int nargs) {
			return js_mkerr_typed(js, JS_ERR_TYPE, "FSWatcher cannot be constructed directly");
			}

			static void fs_watcher_finalize(ant_t js, ant_object_t obj) {
			fs_watcher_t *watcher = NULL;
			if (!obj) return;

			watcher = (fs_watcher_t *)obj->native.ptr;
			obj->native.ptr = NULL;
			if (!watcher) return;

			watcher->finalized = true;
			fs_watcher_close_native(watcher);
			if (watcher->handle_closed) fs_watcher_free(watcher);
			}

			static void fs_init_watch_constructors(ant_t *js) {
			ant_value_t events = 0;
			ant_value_t ee_ctor = 0;
			ant_value_t ee_proto = 0;

			if (g_fswatcher_proto && g_fswatcher_ctor) return;

			events = events_library(js);
			ee_ctor = js_get(js, events, "EventEmitter");
			ee_proto = js_get(js, ee_ctor, "prototype");

			g_fswatcher_proto = js_mkobj(js);
			js_set_proto_init(g_fswatcher_proto, ee_proto);

			js_set(js, g_fswatcher_proto, "close", js_mkfun(js_fswatcher_close));
			js_set(js, g_fswatcher_proto, "ref", js_mkfun(js_fswatcher_ref));
			js_set(js, g_fswatcher_proto, "unref", js_mkfun(js_fswatcher_unref));

			js_set_sym(js, g_fswatcher_proto, get_toStringTag_sym(), js_mkstr(js, "FSWatcher", 9));
			g_fswatcher_ctor = js_make_ctor(js, js_fswatcher_ctor, g_fswatcher_proto, "FSWatcher", 9);
			}

			static bool fs_parse_watch_options(ant_t js, ant_value_t args, int nargs, fs_watch_options_t *out) {
			ant_value_t options = js_mkundef();
			ant_value_t persistent_val = js_mkundef();

			if (!out) return false;

			memset(out, 0, sizeof(*out));
			out->persistent = true;
			out->listener = js_mkundef();

			if (nargs > 1) {
			if (is_callable(args[1])) out->listener = args[1];
			else options = args[1];
			}

			if (nargs > 2 && is_callable(args[2])) out->listener = args[2];
			if (vtype(options) == T_UNDEF \|\| vtype(options) == T_NULL \|\| vtype(options) == T_STR) return true;
			if (vtype(options) != T_OBJ) return false;

			persistent_val = js_get(js, options, "persistent");
			if (vtype(persistent_val) != T_UNDEF) out->persistent = js_truthy(js, persistent_val);
			out->recursive = js_truthy(js, js_get(js, options, "recursive"));
			return true;
			}

			static bool fs_parse_watchfile_options(
			ant_t *js,
			ant_value_t *args,
			int nargs,
			fs_watchfile_options_t *out
			) {
			ant_value_t options = js_mkundef();
			ant_value_t persistent_val = js_mkundef();

			if (!out) return false;

			memset(out, 0, sizeof(*out));
			out->persistent = true;
			out->interval_ms = 5007;
			out->listener = js_mkundef();

			if (nargs > 1) {
			if (is_callable(args[1])) {
			out->listener = args[1];
			return true;
			}
			options = args[1];
			}

			if (nargs > 2 && is_callable(args[2])) out->listener = args[2];
			if (!is_callable(out->listener)) return false;
			if (vtype(options) == T_UNDEF \|\| vtype(options) == T_NULL) return true;
			if (vtype(options) != T_OBJ) return false;

			persistent_val = js_get(js, options, "persistent");
			if (vtype(persistent_val) != T_UNDEF) out->persistent = js_truthy(js, persistent_val);
			{
			ant_value_t interval_val = js_get(js, options, "interval");
			if (vtype(interval_val) == T_NUM && js_getnum(interval_val) > 0)
			out->interval_ms = (unsigned int)js_getnum(interval_val);
			}
			return true;
			}

			static fs_watcher_t fs_watcher_new(ant_t js, fs_watch_mode_t mode) {
			fs_watcher_t watcher = calloc(1, sizeof(watcher));

			if (!watcher) return NULL;
			watcher->js = js;
			watcher->obj = js_mkundef();
			watcher->callback = js_mkundef();
			watcher->persistent = true;
			watcher->mode = mode;

			return watcher;
			}

			static int fs_watcher_start_event(fs_watcher_t watcher, const char path, bool persistent, bool recursive) {
			unsigned int flags = 0;

			if (!watcher \|\| !path) return UV_EINVAL;
			#ifdef UV_FS_EVENT_RECURSIVE
			if (recursive) flags \|= UV_FS_EVENT_RECURSIVE;
			#else
			(void)recursive;
			#endif

			watcher->persistent = persistent;
			return ant_watch_start(
			uv_default_loop(),
			&watcher->handle.event,
			path, fs_watcher_on_event,
			watcher, flags, &watcher->path
			);
			}

			static int fs_watcher_start_poll(fs_watcher_t watcher, const char path, bool persistent, unsigned int interval_ms) {
			int rc = 0;

			if (!watcher \|\| !path) return UV_EINVAL;

			watcher->path = ant_watch_resolve_path(path);
			if (!watcher->path) return UV_ENOMEM;

			rc = uv_fs_poll_init(uv_default_loop(), &watcher->handle.poll);
			if (rc != 0) goto fail;

			watcher->handle.poll.data = watcher;
			rc = uv_fs_poll_start(&watcher->handle.poll, fs_watcher_on_poll, watcher->path, interval_ms);
			if (rc != 0) goto fail;

			watcher->persistent = persistent;
			return 0;

			fail:
			free(watcher->path);
			watcher->path = NULL;
			return rc;
			}

			static ant_value_t fs_watcher_make_object(ant_t js, fs_watcher_t watcher) {
			ant_value_t obj = 0;

			if (!watcher) return js_mkerr(js, "Out of memory");
			fs_init_watch_constructors(js);

			obj = js_mkobj(js);
			js_set_proto_init(obj, g_fswatcher_proto);
			js_set_native_ptr(obj, watcher);
			js_set_native_tag(obj, FS_WATCHER_NATIVE_TAG);
			js_set_finalizer(obj, fs_watcher_finalize);
			watcher->obj = obj;

			return obj;
			}

			static void fs_request_fail(fs_request_t *req, int uv_code) {
			req->failed = 1;
			req->error_code = uv_code;
			if (req->error_msg) free(req->error_msg);
			req->error_msg = strdup(uv_strerror(uv_code));
			}

			static ant_value_t fs_coerce_file_url_path(ant_t *js, ant_value_t arg) {
			ant_value_t href = js_getprop_fallback(js, arg, "href");
			if (vtype(href) != T_STR) return js_mkundef();

			const char *href_str = js_getstr(js, href, NULL);
			if (!href_str) return js_mkundef();

			url_state_t parsed = {0};
			if (parse_url_to_state(href_str, NULL, &parsed) != 0) return js_mkundef();

			ant_value_t path = js_mkundef();
			if (parsed.protocol && strcmp(parsed.protocol, "file:") == 0) {
			char *decoded = url_decode_component(parsed.pathname);
			if (decoded) {
			path = js_mkstr(js, decoded, strlen(decoded));
			free(decoded);
			}}

			url_state_clear(&parsed);
			return path;
			}

			static ant_value_t fs_coerce_path(ant_t *js, ant_value_t arg) {
			if (vtype(arg) == T_STR) return arg;
			if (!is_object_type(arg)) return js_mkundef();

			ant_value_t path = fs_coerce_file_url_path(js, arg);
			if (!is_undefined(path)) return path;

			path = js_get(js, arg, "pathname");
			if (vtype(path) == T_STR) return path;

			return js_mkundef();
			}

			static int fs_remove_path_recursive(const char *path, bool recursive, bool force) {
			uv_fs_t req;

			int result = uv_fs_lstat(NULL, &req, path, NULL);
			if (result < 0) {
			uv_fs_req_cleanup(&req);
			return (force && result == UV_ENOENT) ? 0 : result;
			}

			uv_stat_t statbuf = req.statbuf;
			uv_fs_req_cleanup(&req);

			if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
			result = uv_fs_unlink(NULL, &req, path, NULL);
			uv_fs_req_cleanup(&req);
			return (force && result == UV_ENOENT) ? 0 : result;
			}

			if (!recursive) return UV_EISDIR;
			result = uv_fs_scandir(NULL, &req, path, 0, NULL);

			if (result < 0) {
			uv_fs_req_cleanup(&req);
			return (force && result == UV_ENOENT) ? 0 : result;
			}

			for (;;) {
			uv_dirent_t entry;
			result = uv_fs_scandir_next(&req, &entry);
			if (result == UV_EOF) break;
			if (result < 0) {
			uv_fs_req_cleanup(&req);
			return result;
			}

			size_t path_len = strlen(path);
			size_t name_len = strlen(entry.name);

			bool needs_sep = path_len > 0 && path[path_len - 1] != '/';
			char *child = malloc(path_len + (needs_sep ? 1u : 0u) + name_len + 1u);
			if (!child) {
			uv_fs_req_cleanup(&req);
			return UV_ENOMEM;
			}

			memcpy(child, path, path_len);
			if (needs_sep) child[path_len++] = '/';
			memcpy(child + path_len, entry.name, name_len + 1u);

			result = fs_remove_path_recursive(child, true, force);
			free(child);
			if (result < 0) {
			uv_fs_req_cleanup(&req);
			return result;
			}
			}

			uv_fs_req_cleanup(&req);
			result = uv_fs_rmdir(NULL, &req, path, NULL);
			uv_fs_req_cleanup(&req);
			return (force && result == UV_ENOENT) ? 0 : result;
			}

			static bool fs_parse_rm_options(ant_t js, ant_value_t options, bool recursive_out, bool *force_out) {
			if (recursive_out) *recursive_out = false;
			if (force_out) *force_out = false;

			if (vtype(options) == T_UNDEF \|\| vtype(options) == T_NULL) return true;
			if (vtype(options) != T_OBJ) return false;

			if (recursive_out) *recursive_out = js_truthy(js, js_get(js, options, "recursive"));
			if (force_out) *force_out = js_truthy(js, js_get(js, options, "force"));
			return true;
			}

			static ant_value_t fs_rm_impl(ant_t js, ant_value_t args, int nargs, bool return_promise) {
			ant_value_t promise = 0;
			ant_value_t path_val;
			size_t path_len = 0;
			const char *path = NULL;
			bool recursive = false;
			bool force = false;
			int result;

			if (return_promise) promise = js_mkpromise(js);
			if (nargs < 1) {
			ant_value_t err = js_mkerr(js, "rm() requires a path argument");
			if (!return_promise) return err;
			js_reject_promise(js, promise, err);
			return promise;
			}

			path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) {
			ant_value_t err = js_mkerr(js, "rm() path must be a string");
			if (!return_promise) return err;
			js_reject_promise(js, promise, err);
			return promise;
			}

			path = js_getstr(js, path_val, &path_len);
			if (!path) {
			ant_value_t err = js_mkerr(js, "Failed to get path string");
			if (!return_promise) return err;
			js_reject_promise(js, promise, err);
			return promise;
			}

			if (!fs_parse_rm_options(js, nargs >= 2 ? args[1] : js_mkundef(), &recursive, &force)) {
			ant_value_t err = js_mkerr_typed(js, JS_ERR_TYPE, "rm() options must be an object");
			if (!return_promise) return err;
			js_reject_promise(js, promise, err);
			return promise;
			}

			result = fs_remove_path_recursive(path, recursive, force);
			if (result < 0) {
			ant_value_t err = js_mkerr(js, "%s", uv_strerror(result));
			if (!return_promise) return err;
			js_reject_promise(js, promise, err);
			return promise;
			}

			if (!return_promise) return js_mkundef();
			js_resolve_promise(js, promise, js_mkundef());
			return promise;
			}

			static fs_encoding_t parse_encoding(ant_t *js, ant_value_t arg) {
			size_t len;
			const char *str = NULL;

			if (vtype(arg) == T_STR) str = js_getstr(js, arg, &len);
			else if (vtype(arg) == T_OBJ) {
			ant_value_t enc = js_get(js, arg, "encoding");
			if (vtype(enc) == T_STR) str = js_getstr(js, enc, &len);
			}

			if (!str) return FS_ENC_NONE;

			if (len == 4 && memcmp(str, "utf8", 4) == 0) return FS_ENC_UTF8;
			if (len == 5 && memcmp(str, "utf-8", 5) == 0) return FS_ENC_UTF8;
			if (len == 7 && memcmp(str, "utf16le", 7) == 0) return FS_ENC_UTF16LE;
			if (len == 4 && memcmp(str, "ucs2", 4) == 0) return FS_ENC_UTF16LE;
			if (len == 5 && memcmp(str, "ucs-2", 5) == 0) return FS_ENC_UTF16LE;
			if (len == 6 && memcmp(str, "latin1", 6) == 0) return FS_ENC_LATIN1;
			if (len == 6 && memcmp(str, "binary", 6) == 0) return FS_ENC_LATIN1;
			if (len == 6 && memcmp(str, "base64", 6) == 0) return FS_ENC_BASE64;
			if (len == 9 && memcmp(str, "base64url", 9) == 0) return FS_ENC_BASE64URL;
			if (len == 3 && memcmp(str, "hex", 3) == 0) return FS_ENC_HEX;
			if (len == 5 && memcmp(str, "ascii", 5) == 0) return FS_ENC_ASCII;

			return FS_ENC_NONE;
			}

			static ant_value_t encode_data(ant_t js, const char data, size_t len, fs_encoding_t enc) {
			switch (enc) {
			case FS_ENC_UTF8:
			case FS_ENC_LATIN1:
			case FS_ENC_ASCII: return js_mkstr(js, data, len);

			case FS_ENC_HEX: {
			char out = malloc(len 2);
			if (!out) return js_mkerr(js, "Out of memory");
			for (size_t i = 0; i < len; i++) {
			out[i * 2] = hex_char((unsigned char)data[i] >> 4);
			out[i * 2 + 1] = hex_char(data[i]);
			}
			ant_value_t result = js_mkstr(js, out, len * 2);
			free(out); return result;
			}

			case FS_ENC_BASE64: {
			size_t out_len;
			char out = ant_base64_encode((const uint8_t )data, len, &out_len);
			if (!out) return js_mkerr(js, "Out of memory");
			ant_value_t result = js_mkstr(js, out, out_len);
			free(out); return result;
			}

			case FS_ENC_BASE64URL: {
			size_t out_len;
			char out = ant_base64_encode((const uint8_t )data, len, &out_len);
			if (!out) return js_mkerr(js, "Out of memory");
			for (size_t i = 0; i < out_len; i++) {
			if (out[i] == '+') out[i] = '-';
			else if (out[i] == '/') out[i] = '_';
			}
			while (out_len > 0 && out[out_len - 1] == '=') out_len--;
			ant_value_t result = js_mkstr(js, out, out_len);
			free(out); return result;
			}

			case FS_ENC_UTF16LE: {
			const unsigned char s = (const unsigned char )data;
			char out = malloc((len / 2) 4);
			if (!out) return js_mkerr(js, "Out of memory");
			size_t j = 0;
			for (size_t i = 0; i + 1 < len; i += 2) {
			uint32_t cp = s[i] \| (s[i + 1] << 8);
			bool is_hi = cp >= 0xD800 && cp <= 0xDBFF && i + 3 < len;
			uint32_t lo = is_hi ? s[i + 2] \| (s[i + 3] << 8) : 0;
			bool is_pair = is_hi && lo >= 0xDC00 && lo <= 0xDFFF;
			if (is_pair) { cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00); i += 2; }
			j += utf8_encode(cp, out + j);
			}
			ant_value_t result = js_mkstr(js, out, j);
			free(out); return result;
			}

			default: return js_mkstr(js, data, len);
			}
			}

			static void free_fs_request(fs_request_t *req) {
			if (!req) return;

			if (req->path) free(req->path);
			if (req->path2) free(req->path2);
			if (req->data) free(req->data);
			if (req->error_msg) free(req->error_msg);

			uv_fs_req_cleanup(&req->uv_req);
			free(req);
			}

			static ant_value_t fs_rejected_promise(ant_t *js, ant_value_t err) {
			ant_value_t promise = js_mkpromise(js);
			js_reject_promise(js, promise, err);
			return promise;
			}

			static ant_value_t fs_resolved_promise(ant_t *js, ant_value_t value) {
			ant_value_t promise = js_mkpromise(js);
			js_resolve_promise(js, promise, value);
			return promise;
			}

			static ant_value_t fs_filehandle_require_this(ant_t *js) {
			ant_value_t this_obj = js_getthis(js);
			if (!is_object_type(this_obj) \|\| !js_check_native_tag(this_obj, FS_FILEHANDLE_NATIVE_TAG))
			return js_mkerr_typed(js, JS_ERR_TYPE, "FileHandle method called on incompatible receiver");
			return this_obj;
			}

			static ant_value_t fs_filehandle_fd_value(ant_t *js, ant_value_t handle_obj) {
			ant_value_t fd_val = js_get_slot(handle_obj, SLOT_DATA);
			if (vtype(fd_val) != T_NUM) fd_val = js_get(js, handle_obj, "fd");
			return fd_val;
			}

			static ant_value_t fs_filehandle_get_fd(ant_t *js, ant_value_t handle_obj) {
			ant_value_t fd_val = fs_filehandle_fd_value(js, handle_obj);
			if (vtype(fd_val) != T_NUM \|\| js_getnum(fd_val) < 0)
			return js_mkerr_typed(js, JS_ERR_TYPE, "FileHandle is closed");
			return fd_val;
			}

			static void fs_filehandle_mark_closed(ant_t *js, ant_value_t handle_obj) {
			js_set_slot(handle_obj, SLOT_DATA, js_mkundef());
			js_set(js, handle_obj, "fd", js_mknum(-1));
			}

			static ant_value_t builtin_fs_filehandle_close(ant_t js, ant_value_t args, int nargs) {
			ant_value_t handle_obj = fs_filehandle_require_this(js);
			if (is_err(handle_obj)) return fs_rejected_promise(js, handle_obj);

			ant_value_t fd_val = fs_filehandle_fd_value(js, handle_obj);
			if (vtype(fd_val) != T_NUM \|\| js_getnum(fd_val) < 0)
			return fs_resolved_promise(js, js_mkundef());

			uv_fs_t req;
			int result = uv_fs_close(uv_default_loop(), &req, (uv_file)(int)js_getnum(fd_val), NULL);
			uv_fs_req_cleanup(&req);
			if (result < 0) return fs_rejected_promise(js, fs_mk_uv_error(js, result, "close", NULL, NULL));

			fs_filehandle_mark_closed(js, handle_obj);
			return fs_resolved_promise(js, js_mkundef());
			}

			static ant_value_t builtin_fs_filehandle_stat(ant_t js, ant_value_t args, int nargs) {
			ant_value_t handle_obj = fs_filehandle_require_this(js);
			if (is_err(handle_obj)) return fs_rejected_promise(js, handle_obj);

			ant_value_t fd_val = fs_filehandle_get_fd(js, handle_obj);
			if (is_err(fd_val)) return fs_rejected_promise(js, fd_val);

			uv_fs_t req;
			int result = uv_fs_fstat(NULL, &req, (uv_file)(int)js_getnum(fd_val), NULL);
			if (result < 0) {
			ant_value_t err = fs_mk_uv_error(js, result, "fstat", NULL, NULL);
			uv_fs_req_cleanup(&req);
			return fs_rejected_promise(js, err);
			}

			ant_value_t stat_obj = fs_stats_object_from_uv(js, &req.statbuf);
			uv_fs_req_cleanup(&req);
			return fs_resolved_promise(js, stat_obj);
			}

			static ant_value_t builtin_fs_filehandle_sync(ant_t js, ant_value_t args, int nargs) {
			ant_value_t handle_obj = fs_filehandle_require_this(js);
			if (is_err(handle_obj)) return fs_rejected_promise(js, handle_obj);

			ant_value_t fd_val = fs_filehandle_get_fd(js, handle_obj);
			if (is_err(fd_val)) return fs_rejected_promise(js, fd_val);

			uv_fs_t req;
			int result = uv_fs_fsync(uv_default_loop(), &req, (uv_file)(int)js_getnum(fd_val), NULL);
			uv_fs_req_cleanup(&req);
			if (result < 0) return fs_rejected_promise(js, fs_mk_uv_error(js, result, "fsync", NULL, NULL));

			return fs_resolved_promise(js, js_mkundef());
			}

			static ant_value_t builtin_fs_filehandle_read(ant_t js, ant_value_t args, int nargs) {
			ant_value_t handle_obj = fs_filehandle_require_this(js);
			if (is_err(handle_obj)) return fs_rejected_promise(js, handle_obj);

			ant_value_t fd_val = fs_filehandle_get_fd(js, handle_obj);
			if (is_err(fd_val)) return fs_rejected_promise(js, fd_val);
			if (nargs < 1) return fs_rejected_promise(js, js_mkerr(js, "FileHandle.read() requires a buffer argument"));

			TypedArrayData *ta_data = buffer_get_typedarray_data(args[0]);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return fs_rejected_promise(js, js_mkerr(js, "FileHandle.read() buffer must be a Buffer or TypedArray"));

			size_t buf_len = ta_data->byte_length;
			size_t offset = 0;
			size_t length = buf_len;
			int64_t position = -1;

			if (nargs >= 2 && vtype(args[1]) == T_NUM) offset = (size_t)js_getnum(args[1]);
			if (nargs >= 3 && vtype(args[2]) == T_NUM) length = (size_t)js_getnum(args[2]);
			if (nargs >= 4 && vtype(args[3]) == T_NUM) position = (int64_t)js_getnum(args[3]);

			if (offset > buf_len) return fs_rejected_promise(js, js_mkerr(js, "offset is out of bounds"));
			if (offset + length > buf_len) return fs_rejected_promise(js, js_mkerr(js, "length extends beyond buffer"));

			uint8_t *buf_data = ta_data->buffer->data + ta_data->byte_offset;
			uv_buf_t buf = uv_buf_init((char *)(buf_data + offset), (unsigned int)length);

			uv_fs_t req;
			int result = uv_fs_read(uv_default_loop(), &req, (uv_file)(int)js_getnum(fd_val), &buf, 1, position, NULL);
			uv_fs_req_cleanup(&req);
			if (result < 0) return fs_rejected_promise(js, fs_mk_uv_error(js, result, "read", NULL, NULL));

			ant_value_t out = js_mkobj(js);
			js_set(js, out, "bytesRead", js_mknum((double)result));
			js_set(js, out, "buffer", args[0]);

			return fs_resolved_promise(js, out);
			}

			static ant_value_t builtin_fs_filehandle_write(ant_t js, ant_value_t args, int nargs) {
			ant_value_t handle_obj = fs_filehandle_require_this(js);
			if (is_err(handle_obj)) return fs_rejected_promise(js, handle_obj);

			ant_value_t fd_val = fs_filehandle_get_fd(js, handle_obj);
			if (is_err(fd_val)) return fs_rejected_promise(js, fd_val);
			if (nargs < 1) return fs_rejected_promise(js, js_mkerr(js, "FileHandle.write() requires a data argument"));

			const char *write_data = NULL;
			size_t write_len = 0;
			int64_t position = -1;

			if (vtype(args[0]) == T_STR) {
			write_data = js_getstr(js, args[0], &write_len);
			if (!write_data) return fs_rejected_promise(js, js_mkerr(js, "Failed to get string"));
			if (nargs >= 2 && vtype(args[1]) == T_NUM) position = (int64_t)js_getnum(args[1]);
			} else {
			TypedArrayData *ta_data = buffer_get_typedarray_data(args[0]);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return fs_rejected_promise(js, js_mkerr(js, "FileHandle.write() data must be a Buffer, TypedArray, DataView, or string"));

			uint8_t *buf_data = ta_data->buffer->data + ta_data->byte_offset;
			size_t buf_len = ta_data->byte_length;
			size_t offset = 0;
			size_t length = buf_len;

			if (nargs >= 2) {
			if (vtype(args[1]) == T_OBJ) {
			ant_value_t off_val = js_get(js, args[1], "offset");
			ant_value_t len_val = js_get(js, args[1], "length");
			ant_value_t pos_val = js_get(js, args[1], "position");
			if (vtype(off_val) == T_NUM) offset = (size_t)js_getnum(off_val);
			if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val);
			else length = buf_len - offset;
			if (vtype(pos_val) == T_NUM) position = (int64_t)js_getnum(pos_val);
			} else if (vtype(args[1]) == T_NUM) {
			offset = (size_t)js_getnum(args[1]);
			length = buf_len - offset;
			if (nargs >= 3 && vtype(args[2]) == T_NUM) length = (size_t)js_getnum(args[2]);
			if (nargs >= 4 && vtype(args[3]) == T_NUM) position = (int64_t)js_getnum(args[3]);
			}}

			if (offset > buf_len) return fs_rejected_promise(js, js_mkerr(js, "offset is out of bounds"));
			if (offset + length > buf_len) return fs_rejected_promise(js, js_mkerr(js, "length extends beyond buffer"));
			write_data = (const char *)(buf_data + offset);
			write_len = length;
			}

			uv_buf_t buf = uv_buf_init((char *)write_data, (unsigned int)write_len);
			uv_fs_t req;
			int result = uv_fs_write(uv_default_loop(), &req, (uv_file)(int)js_getnum(fd_val), &buf, 1, position, NULL);
			uv_fs_req_cleanup(&req);
			if (result < 0) return fs_rejected_promise(js, fs_mk_uv_error(js, result, "write", NULL, NULL));

			ant_value_t out = js_mkobj(js);
			js_set(js, out, "bytesWritten", js_mknum((double)result));
			js_set(js, out, "buffer", args[0]);

			return fs_resolved_promise(js, out);
			}

			static ant_value_t builtin_fs_filehandle_writeFile(ant_t js, ant_value_t args, int nargs) {
			ant_value_t handle_obj = fs_filehandle_require_this(js);
			if (is_err(handle_obj)) return fs_rejected_promise(js, handle_obj);

			ant_value_t fd_val = fs_filehandle_get_fd(js, handle_obj);
			if (is_err(fd_val)) return fs_rejected_promise(js, fd_val);
			if (nargs < 1) return fs_rejected_promise(js, js_mkerr(js, "FileHandle.writeFile() requires data"));

			const char *data = NULL;
			size_t len = 0;

			if (vtype(args[0]) == T_STR) {
			data = js_getstr(js, args[0], &len);
			if (!data) return fs_rejected_promise(js, js_mkerr(js, "Failed to get string"));
			} else {
			TypedArrayData *ta_data = buffer_get_typedarray_data(args[0]);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return fs_rejected_promise(js, js_mkerr(js, "FileHandle.writeFile() data must be a Buffer, TypedArray, DataView, or string"));
			data = (const char *)(ta_data->buffer->data + ta_data->byte_offset);
			len = ta_data->byte_length;
			}

			size_t written = 0;
			while (written < len) {
			uv_buf_t buf = uv_buf_init((char *)(data + written), (unsigned int)(len - written));
			uv_fs_t req;
			int result = uv_fs_write(uv_default_loop(), &req, (uv_file)(int)js_getnum(fd_val), &buf, 1, -1, NULL);
			uv_fs_req_cleanup(&req);
			if (result < 0) return fs_rejected_promise(js, fs_mk_uv_error(js, result, "write", NULL, NULL));
			if (result == 0) return fs_rejected_promise(js, js_mkerr(js, "short write"));
			written += (size_t)result;
			}

			return fs_resolved_promise(js, js_mkundef());
			}

			static void fs_init_filehandle_proto(ant_t *js) {
			if (is_object_type(g_filehandle_proto)) return;
			g_filehandle_proto = js_mkobj(js);
			js_set_native_tag(g_filehandle_proto, FS_FILEHANDLE_NATIVE_TAG);
			js_set(js, g_filehandle_proto, "close", js_mkfun(builtin_fs_filehandle_close));
			js_set(js, g_filehandle_proto, "stat", js_mkfun(builtin_fs_filehandle_stat));
			js_set(js, g_filehandle_proto, "sync", js_mkfun(builtin_fs_filehandle_sync));
			js_set(js, g_filehandle_proto, "read", js_mkfun(builtin_fs_filehandle_read));
			js_set(js, g_filehandle_proto, "write", js_mkfun(builtin_fs_filehandle_write));
			js_set(js, g_filehandle_proto, "writeFile", js_mkfun(builtin_fs_filehandle_writeFile));
			js_set_sym(js, g_filehandle_proto, get_toStringTag_sym(), js_mkstr(js, "FileHandle", 10));
			}

			static ant_value_t fs_make_filehandle(ant_t *js, int fd) {
			fs_init_filehandle_proto(js);
			ant_value_t handle = js_mkobj(js);

			js_set_native_tag(handle, FS_FILEHANDLE_NATIVE_TAG);
			js_set_proto_init(handle, g_filehandle_proto);
			js_set_slot(handle, SLOT_DATA, js_mknum((double)fd));
			js_set(js, handle, "fd", js_mknum((double)fd));

			return handle;
			}

			static void remove_pending_request(fs_request_t *req) {
			if (!req \|\| !pending_requests) return;
			unsigned int len = utarray_len(pending_requests);

			for (unsigned int i = 0; i < len; i++) {
			if ((fs_request_t*)utarray_eltptr(pending_requests, i) != req) continue;
			utarray_erase(pending_requests, i, 1); break;
			}
			}

			static ant_value_t fs_read_to_uint8array(ant_t js, const char data, size_t len) {
			ArrayBufferData *ab = create_array_buffer_data(len);
			if (!ab) return js_mkundef();
			memcpy(ab->data, data, len);
			ant_value_t result = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, len, "Buffer");
			if (vtype(result) == T_ERR) free_array_buffer_data(ab);
			return result;
			}

			static void complete_request(fs_request_t *req) {
			if (req->failed) {
			const char *err_msg = req->error_msg
			? req->error_msg
			: "Unknown error";

			ant_value_t props = js_mkobj(req->js);
			ant_value_t reject_value;

			if (req->error_code) {
			const char *code = uv_err_name(req->error_code);
			js_set(req->js, props, "code", js_mkstr(req->js, code, strlen(code)));
			js_set(req->js, props, "errno", js_mknum((double)req->error_code));
			if (req->path) js_set(req->js, props, "path", js_mkstr(req->js, req->path, strlen(req->path)));
			if (req->path2) js_set(req->js, props, "dest", js_mkstr(req->js, req->path2, strlen(req->path2)));
			reject_value = js_mkerr_props(req->js, JS_ERR_TYPE, props, "%s", err_msg);
			} else reject_value = js_mkerr(req->js, "%s", err_msg);

			if (is_err(reject_value)) {
			reject_value = req->js->thrown_exists ? req->js->thrown_value : js_mkundef();
			if (!req->js->thrown_exists)
			reject_value = js_mkstr(req->js, err_msg, strlen(err_msg));
			req->js->thrown_exists = false;
			req->js->thrown_value = js_mkundef();
			}
			js_reject_promise(req->js, req->promise, reject_value);
			} else {
			ant_value_t result = js_mkundef();
			if (req->op_type == FS_OP_READ && req->data) {
			if (req->encoding != FS_ENC_NONE)
			result = encode_data(req->js, req->data, req->data_len, req->encoding);
			else result = fs_read_to_uint8array(req->js, req->data, req->data_len);
			} else if (req->op_type == FS_OP_READ_BYTES && req->data)
			result = js_mkstr(req->js, req->data, req->data_len);
			else if (req->op_type == FS_OP_REALPATH && req->data)
			result = js_mkstr(req->js, req->data, req->data_len);
			else if (req->op_type == FS_OP_MKDTEMP && req->data)
			result = js_mkstr(req->js, req->data, req->data_len);
			js_resolve_promise(req->js, req->promise, result);
			}

			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_read_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->data_len = uv_req->result;
			uv_fs_t close_req;

			uv_fs_close(uv_default_loop(), &close_req, req->fd, NULL);
			uv_fs_req_cleanup(&close_req);

			req->completed = 1;
			complete_request(req);
			}

			static void on_open_for_read(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->fd = (int)uv_req->result;
			uv_fs_req_cleanup(uv_req);

			uv_fs_t stat_req;
			int stat_result = uv_fs_fstat(uv_default_loop(), &stat_req, req->fd, NULL);

			if (stat_result < 0) {
			fs_request_fail(req, stat_result);
			req->completed = 1;
			uv_fs_t close_req;
			uv_fs_close(uv_default_loop(), &close_req, req->fd, NULL);
			uv_fs_req_cleanup(&close_req);
			complete_request(req);
			return;
			}

			size_t file_size = stat_req.statbuf.st_size;
			uv_fs_req_cleanup(&stat_req);

			size_t alloc_size = (req->op_type == FS_OP_READ) ? file_size + 1 : file_size;
			req->data = malloc(alloc_size);
			if (!req->data) {
			req->failed = 1;
			req->error_msg = strdup("Out of memory");
			req->completed = 1;
			uv_fs_t close_req;
			uv_fs_close(uv_default_loop(), &close_req, req->fd, NULL);
			uv_fs_req_cleanup(&close_req);
			complete_request(req);
			return;
			}

			uv_buf_t buf = uv_buf_init(req->data, (unsigned int)file_size);
			int read_result = uv_fs_read(uv_default_loop(), uv_req, req->fd, &buf, 1, 0, on_read_complete);

			if (read_result < 0) {
			fs_request_fail(req, read_result);
			req->completed = 1;
			uv_fs_t close_req;
			uv_fs_close(uv_default_loop(), &close_req, req->fd, NULL);
			uv_fs_req_cleanup(&close_req);
			complete_request(req);
			return;
			}
			}

			static void on_write_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			}

			uv_fs_t close_req;
			uv_fs_close(uv_default_loop(), &close_req, req->fd, NULL);
			uv_fs_req_cleanup(&close_req);

			req->completed = 1;
			complete_request(req);
			}

			static void on_open_for_write(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->fd = (int)uv_req->result;
			uv_fs_req_cleanup(uv_req);

			uv_buf_t buf = uv_buf_init(req->data, (unsigned int)req->data_len);
			int write_result = uv_fs_write(uv_default_loop(), uv_req, req->fd, &buf, 1, 0, on_write_complete);

			if (write_result < 0) {
			fs_request_fail(req, write_result);
			req->completed = 1;
			uv_fs_t close_req;
			uv_fs_close(uv_default_loop(), &close_req, req->fd, NULL);
			uv_fs_req_cleanup(&close_req);
			complete_request(req);
			return;
			}
			}

			static void on_unlink_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			}

			uv_fs_req_cleanup(uv_req);
			req->completed = 1;
			complete_request(req);
			}

			static void on_rename_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			}

			uv_fs_req_cleanup(uv_req);
			req->completed = 1;
			complete_request(req);
			}

			static int mkdirp(const char *path, mode_t mode) {
			int result = -1;
			char *tmp = strdup(path);
			if (!tmp) goto done;

			size_t len = strlen(tmp);
			if (len > 0 && tmp[len - 1] == '/') tmp[len - 1] = '\0';

			for (char p = tmp + 1; p; p++) {
			if (*p != '/') continue;
			*p = '\0';
			#ifdef _WIN32
			_mkdir(tmp);
			#else
			mkdir(tmp, mode);
			#endif
			*p = '/';
			}

			#ifdef _WIN32
			result = _mkdir(tmp);
			#else
			result = mkdir(tmp, mode);
			#endif
			if (result != 0 && errno == EEXIST) result = 0;

			free(tmp);
			done:
			return result;
			}

			static void on_mkdir_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			if (!req->recursive \|\| uv_req->result != UV_EEXIST) {
			fs_request_fail(req, (int)uv_req->result);
			}}

			uv_fs_req_cleanup(uv_req);
			req->completed = 1;
			complete_request(req);
			}

			static void on_rmdir_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			}

			uv_fs_req_cleanup(uv_req);
			req->completed = 1;
			complete_request(req);
			}

			static void on_stat_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			ant_value_t stat_obj = fs_stats_object_from_uv(req->js, &uv_req->statbuf);

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, stat_obj);
			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_realpath_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0 \|\| !uv_req->ptr) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->data = strdup((const char *)uv_req->ptr);
			if (!req->data) {
			req->failed = 1;
			req->error_msg = strdup("Out of memory");
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->data_len = strlen(req->data);
			req->completed = 1;
			complete_request(req);
			}

			static ant_value_t create_dirent_object(ant_t js, const char name, size_t name_len, uv_dirent_type_t type) {
			ant_value_t obj = js_newobj(js);
			js_set_proto(obj, g_dirent_proto);
			js_set(js, obj, "name", js_mkstr(js, name, name_len));
			js_set_slot(obj, SLOT_DATA, tov((double)type));
			return obj;
			}

			static void on_mkdtemp_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			uv_fs_req_cleanup(uv_req);
			return;
			}

			req->data = strdup(uv_req->path);
			if (!req->data) {
			req->failed = 1;
			req->error_msg = strdup("Out of memory");
			req->completed = 1;
			complete_request(req);
			uv_fs_req_cleanup(uv_req);
			return;
			}

			req->data_len = strlen(req->data);
			req->completed = 1;
			uv_fs_req_cleanup(uv_req);
			complete_request(req);
			}

			static void on_exists_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;
			ant_value_t result = js_bool(uv_req->result >= 0);

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, result);
			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_access_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_mkundef());
			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_chmod_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_mkundef());
			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_readdir_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			ant_value_t arr = js_mkarr(req->js);
			uv_dirent_t dirent;

			while (uv_fs_scandir_next(uv_req, &dirent) != UV_EOF) {
			if (req->with_file_types) {
			ant_value_t entry = create_dirent_object(req->js, dirent.name, strlen(dirent.name), dirent.type);
			js_arr_push(req->js, arr, entry);
			} else {
			ant_value_t name = js_mkstr(req->js, dirent.name, strlen(dirent.name));
			js_arr_push(req->js, arr, name);
			}}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, arr);
			remove_pending_request(req);
			free_fs_request(req);
			}

			static ant_value_t builtin_fs_readFileSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readFileSync() requires a path argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "readFileSync() path must be a string or URL");

			size_t path_len;
			char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			FILE *file = fopen(path_cstr, "rb");
			if (!file) {
			ant_value_t err = fs_mk_errno_error(js, errno, "open", path_cstr, NULL);
			free(path_cstr);
			return err;
			}

			fseek(file, 0, SEEK_END);
			long file_size = ftell(file);
			fseek(file, 0, SEEK_SET);

			if (file_size < 0) {
			fclose(file);
			free(path_cstr);
			return js_mkerr(js, "Failed to get file size");
			}

			char *data = malloc(file_size + 1);
			if (!data) {
			fclose(file);
			free(path_cstr);
			return js_mkerr(js, "Out of memory");
			}

			size_t bytes_read = fread(data, 1, file_size, file);
			fclose(file);
			free(path_cstr);

			if (bytes_read != (size_t)file_size) {
			free(data);
			return js_mkerr(js, "Failed to read entire file");
			}

			fs_encoding_t enc = (nargs > 1) ? parse_encoding(js, args[1]) : FS_ENC_NONE;
			ant_value_t result = (enc != FS_ENC_NONE)
			? encode_data(js, data, file_size, enc)
			: fs_read_to_uint8array(js, data, file_size);

			free(data);
			return result;
			}

			static ant_value_t builtin_fs_readBytesSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readBytesSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytesSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			FILE *file = fopen(path_cstr, "rb");
			if (!file) {
			ant_value_t err = fs_mk_errno_error(js, errno, "open", path_cstr, NULL);
			free(path_cstr);
			return err;
			}

			fseek(file, 0, SEEK_END);
			long file_size = ftell(file);
			fseek(file, 0, SEEK_SET);

			if (file_size < 0) {
			fclose(file);
			free(path_cstr);
			return js_mkerr(js, "Failed to get file size");
			}

			char *data = malloc(file_size);
			if (!data) {
			fclose(file);
			free(path_cstr);
			return js_mkerr(js, "Out of memory");
			}

			size_t bytes_read = fread(data, 1, file_size, file);
			fclose(file);
			free(path_cstr);

			if (bytes_read != (size_t)file_size) {
			free(data);
			return js_mkerr(js, "Failed to read entire file");
			}

			ant_value_t result = js_mkstr(js, data, file_size);
			free(data);

			return result;
			}

			static ant_value_t builtin_fs_readFile(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readFile() requires a path argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "readFile() path must be a string or URL");

			size_t path_len;
			char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_READ;
			req->encoding = (nargs > 1) ? parse_encoding(js, args[1]) : FS_ENC_NONE;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_open(uv_default_loop(), &req->uv_req, req->path, O_RDONLY, 0, on_open_for_read);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_readBytes(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readBytes() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytes() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_READ_BYTES;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_open(uv_default_loop(), &req->uv_req, req->path, O_RDONLY, 0, on_open_for_read);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t fs_write_file_sync_impl(
			ant_t *js,
			ant_value_t *args,
			int nargs,
			const char *fn_name,
			const char *mode
			) {
			if (nargs < 2) return js_mkerr(js, "%s() requires path and data arguments", fn_name);
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "%s() path must be a string", fn_name);
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "%s() data must be a string", fn_name);

			size_t path_len, data_len;
			char *path = js_getstr(js, args[0], &path_len);
			char *data = js_getstr(js, args[1], &data_len);
			if (!path \|\| !data) return js_mkerr(js, "Failed to get arguments");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			FILE *file = fopen(path_cstr, mode);
			if (!file) {
			ant_value_t err = fs_mk_errno_error(js, errno, "open", path_cstr, NULL);
			free(path_cstr);
			return err;
			}

			size_t bytes_written = fwrite(data, 1, data_len, file);
			fclose(file);
			free(path_cstr);

			if (bytes_written != data_len) {
			return js_mkerr(js, "Failed to write entire file");
			}

			return js_mkundef();
			}

			static ant_value_t builtin_fs_writeFileSync(ant_t js, ant_value_t args, int nargs) {
			return fs_write_file_sync_impl(js, args, nargs, "writeFileSync", "wb");
			}

			static ant_value_t builtin_fs_copyFileSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "copyFileSync() requires src and dest arguments");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "copyFileSync() src must be a string");
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "copyFileSync() dest must be a string");

			size_t src_len, dest_len;
			char *src = js_getstr(js, args[0], &src_len);
			char *dest = js_getstr(js, args[1], &dest_len);

			if (!src \|\| !dest) return js_mkerr(js, "Failed to get arguments");

			char *src_cstr = strndup(src, src_len);
			char *dest_cstr = strndup(dest, dest_len);
			if (!src_cstr \|\| !dest_cstr) {
			free(src_cstr);
			free(dest_cstr);
			return js_mkerr(js, "Out of memory");
			}

			FILE *in = fopen(src_cstr, "rb");
			if (!in) {
			ant_value_t err = fs_mk_errno_error(js, errno, "copyfile", src_cstr, dest_cstr);
			free(src_cstr); free(dest_cstr);
			return err;
			}

			FILE *out = fopen(dest_cstr, "wb");
			if (!out) {
			ant_value_t err = fs_mk_errno_error(js, errno, "copyfile", src_cstr, dest_cstr);
			fclose(in);
			free(src_cstr); free(dest_cstr);
			return err;
			}

			char buf[8192];
			size_t n;

			while ((n = fread(buf, 1, sizeof(buf), in)) > 0) {
			if (fwrite(buf, 1, n, out) != n) {
			ant_value_t err = fs_mk_errno_error(js, errno ? errno : EIO, "copyfile", src_cstr, dest_cstr);
			fclose(in); fclose(out);
			free(src_cstr); free(dest_cstr);
			return err;
			}}

			fclose(in); fclose(out);
			free(src_cstr); free(dest_cstr);

			return js_mkundef();
			}

			typedef struct {
			bool recursive;
			bool force;
			bool error_on_exist;
			} fs_cp_options_t;

			static void fs_parse_cp_options(ant_t js, ant_value_t value, fs_cp_options_t opts) {
			opts->recursive = false;
			opts->force = true;
			opts->error_on_exist = false;

			if (vtype(value) != T_OBJ) return;

			ant_value_t recursive = js_get(js, value, "recursive");
			ant_value_t force = js_get(js, value, "force");
			ant_value_t error_on_exist = js_get(js, value, "errorOnExist");

			if (!is_undefined(recursive)) opts->recursive = js_truthy(js, recursive);
			if (!is_undefined(force)) opts->force = js_truthy(js, force);
			if (!is_undefined(error_on_exist)) opts->error_on_exist = js_truthy(js, error_on_exist);
			}

			static char fs_join_path(const char base, const char *name) {
			size_t base_len = strlen(base);
			size_t name_len = strlen(name);
			bool need_sep = base_len > 0 && base[base_len - 1] != '/';
			size_t total_len = base_len + (need_sep ? 1 : 0) + name_len;

			char *joined = calloc(total_len + 1, 1);
			if (!joined) return NULL;

			memcpy(joined, base, base_len);
			if (need_sep) joined[base_len++] = '/';
			memcpy(joined + base_len, name, name_len);
			joined[total_len] = '\0';
			return joined;
			}

			static ant_value_t fs_copy_file_sync_impl(
			ant_t *js,
			const char *src_cstr,
			const char *dest_cstr,
			const fs_cp_options_t *opts,
			const char *op_name
			) {
			struct stat dest_st;
			if (!opts->force && stat(dest_cstr, &dest_st) == 0) {
			if (opts->error_on_exist) return fs_mk_errno_error(js, EEXIST, op_name, src_cstr, dest_cstr);
			return js_mkundef();
			}

			FILE *in = fopen(src_cstr, "rb");
			if (!in) return fs_mk_errno_error(js, errno, op_name, src_cstr, dest_cstr);

			FILE *out = fopen(dest_cstr, "wb");
			if (!out) {
			ant_value_t err = fs_mk_errno_error(js, errno, op_name, src_cstr, dest_cstr);
			fclose(in);
			return err;
			}

			char buf[8192];
			size_t n = 0;
			while ((n = fread(buf, 1, sizeof(buf), in)) > 0) {
			if (fwrite(buf, 1, n, out) != n) {
			ant_value_t err = fs_mk_errno_error(js, errno ? errno : EIO, op_name, src_cstr, dest_cstr);
			fclose(in);
			fclose(out);
			return err;
			}}

			fclose(in);
			fclose(out);

			return js_mkundef();
			}

			static ant_value_t builtin_fs_copyFile(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "copyFile() requires src and dest arguments");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "copyFile() src must be a string");
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "copyFile() dest must be a string");

			size_t src_len = 0, dest_len = 0;
			const char *src = js_getstr(js, args[0], &src_len);
			const char *dest = js_getstr(js, args[1], &dest_len);
			if (!src \|\| !dest) return js_mkerr(js, "Failed to get arguments");

			char *src_cstr = strndup(src, src_len);
			char *dest_cstr = strndup(dest, dest_len);
			if (!src_cstr \|\| !dest_cstr) {
			free(src_cstr);
			free(dest_cstr);
			return js_mkerr(js, "Out of memory");
			}

			fs_cp_options_t opts = {
			.recursive = false,
			.force = true,
			.error_on_exist = false,
			};

			ant_value_t promise = js_mkpromise(js);
			ant_value_t result = fs_copy_file_sync_impl(js, src_cstr, dest_cstr, &opts, "copyFile");
			free(src_cstr);
			free(dest_cstr);

			if (is_err(result)) js_reject_promise(js, promise, result);
			else js_resolve_promise(js, promise, js_mkundef());

			return promise;
			}

			static ant_value_t fs_copy_path_sync_impl(
			ant_t *js,
			const char *src_cstr,
			const char *dest_cstr,
			const fs_cp_options_t *opts,
			const char *op_name
			) {
			struct stat src_st;
			if (stat(src_cstr, &src_st) != 0) return fs_mk_errno_error(js, errno, op_name, src_cstr, dest_cstr);

			if ((src_st.st_mode & S_IFMT) == S_IFDIR) {
			if (!opts->recursive) {
			return js_mkerr(js, "%s() recursive option is required to copy directories", op_name);
			}

			struct stat dest_st;
			if (stat(dest_cstr, &dest_st) != 0) {
			if (errno != ENOENT) return fs_mk_errno_error(js, errno, op_name, src_cstr, dest_cstr);
			#ifdef _WIN32
			if (_mkdir(dest_cstr) != 0) return fs_mk_errno_error(js, errno, op_name, src_cstr, dest_cstr);
			#else
			if (mkdir(dest_cstr, (mode_t)(src_st.st_mode & 0777)) != 0) {
			return fs_mk_errno_error(js, errno, op_name, src_cstr, dest_cstr);
			}
			#endif
			} else if ((dest_st.st_mode & S_IFMT) != S_IFDIR) {
			return fs_mk_errno_error(js, EEXIST, op_name, src_cstr, dest_cstr);
			}

			uv_fs_t req;
			int rc = uv_fs_scandir(NULL, &req, src_cstr, 0, NULL);
			if (rc < 0) {
			ant_value_t err = fs_mk_uv_error(js, rc, "scandir", src_cstr, dest_cstr);
			uv_fs_req_cleanup(&req);
			return err;
			}

			uv_dirent_t dirent;
			ant_value_t result = js_mkundef();
			while (uv_fs_scandir_next(&req, &dirent) != UV_EOF) {
			if (
			strcmp(dirent.name, ".") == 0 \|\|
			strcmp(dirent.name, "..") == 0
			) continue;

			char *child_src = fs_join_path(src_cstr, dirent.name);
			char *child_dest = fs_join_path(dest_cstr, dirent.name);
			if (!child_src \|\| !child_dest) {
			free(child_src);
			free(child_dest);
			result = js_mkerr(js, "Out of memory");
			break;
			}

			result = fs_copy_path_sync_impl(js, child_src, child_dest, opts, op_name);
			free(child_src);
			free(child_dest);
			if (is_err(result)) break;
			}

			uv_fs_req_cleanup(&req);
			return result;
			}

			return fs_copy_file_sync_impl(js, src_cstr, dest_cstr, opts, op_name);
			}

			static ant_value_t fs_cp_sync_common(
			ant_t *js,
			ant_value_t *args,
			int nargs,
			const char *fn_name
			) {
			if (nargs < 2) return js_mkerr(js, "%s() requires src and dest arguments", fn_name);
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "%s() src must be a string", fn_name);
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "%s() dest must be a string", fn_name);

			size_t src_len = 0, dest_len = 0;
			const char *src = js_getstr(js, args[0], &src_len);
			const char *dest = js_getstr(js, args[1], &dest_len);
			if (!src \|\| !dest) return js_mkerr(js, "Failed to get arguments");

			fs_cp_options_t opts;
			fs_parse_cp_options(js, nargs >= 3 ? args[2] : js_mkundef(), &opts);

			char *src_cstr = strndup(src, src_len);
			char *dest_cstr = strndup(dest, dest_len);
			if (!src_cstr \|\| !dest_cstr) {
			free(src_cstr);
			free(dest_cstr);
			return js_mkerr(js, "Out of memory");
			}

			ant_value_t result = fs_copy_path_sync_impl(js, src_cstr, dest_cstr, &opts, fn_name);
			free(src_cstr);
			free(dest_cstr);
			return result;
			}

			static ant_value_t builtin_fs_cpSync(ant_t js, ant_value_t args, int nargs) {
			return fs_cp_sync_common(js, args, nargs, "cpSync");
			}

			static ant_value_t builtin_fs_cp(ant_t js, ant_value_t args, int nargs) {
			ant_value_t promise = js_mkpromise(js);
			ant_value_t result = fs_cp_sync_common(js, args, nargs, "cp");
			if (is_err(result)) js_reject_promise(js, promise, result);
			else js_resolve_promise(js, promise, js_mkundef());
			return promise;
			}

			static ant_value_t builtin_fs_renameSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "renameSync() requires oldPath and newPath arguments");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "renameSync() oldPath must be a string");
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "renameSync() newPath must be a string");

			size_t old_len, new_len;
			char *old_path = js_getstr(js, args[0], &old_len);
			char *new_path = js_getstr(js, args[1], &new_len);

			if (!old_path \|\| !new_path) return js_mkerr(js, "Failed to get arguments");

			char *old_cstr = strndup(old_path, old_len);
			char *new_cstr = strndup(new_path, new_len);
			if (!old_cstr \|\| !new_cstr) {
			free(old_cstr);
			free(new_cstr);
			return js_mkerr(js, "Out of memory");
			}

			int result = rename(old_cstr, new_cstr);

			if (result != 0) {
			ant_value_t err = fs_mk_errno_error(js, errno, "rename", old_cstr, new_cstr);
			free(old_cstr);
			free(new_cstr);
			return err;
			}

			free(old_cstr);
			free(new_cstr);

			return js_mkundef();
			}

			static ant_value_t builtin_fs_rename(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "rename() requires oldPath and newPath arguments");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "rename() oldPath must be a string");
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "rename() newPath must be a string");

			size_t old_len = 0, new_len = 0;
			const char *old_path = js_getstr(js, args[0], &old_len);
			const char *new_path = js_getstr(js, args[1], &new_len);
			if (!old_path \|\| !new_path) return js_mkerr(js, "Failed to get arguments");

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_RENAME;
			req->promise = js_mkpromise(js);
			req->path = strndup(old_path, old_len);
			req->path2 = strndup(new_path, new_len);
			req->uv_req.data = req;

			if (!req->path \|\| !req->path2) {
			free_fs_request(req);
			return js_mkerr(js, "Out of memory");
			}

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_rename(uv_default_loop(), &req->uv_req, req->path, req->path2, on_rename_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static double fs_time_arg_to_seconds(ant_t *js, ant_value_t v) {
			if (is_date_instance(v)) {
			ant_value_t t = js_get_slot(js_as_obj(v), SLOT_DATA);
			return (vtype(t) == T_NUM) ? js_getnum(t) / 1000.0 : 0.0;
			}
			return js_to_number(js, v);
			}

			static ant_value_t builtin_fs_utimesSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 3) return js_mkerr(js, "utimesSync() requires path, atime, and mtime");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "utimesSync() path must be a string");

			const char *path = js_str(js, args[0]);
			double atime = fs_time_arg_to_seconds(js, args[1]);
			double mtime = fs_time_arg_to_seconds(js, args[2]);

			uv_fs_t req;
			int rc = uv_fs_utime(NULL, &req, path, atime, mtime, NULL);
			uv_fs_req_cleanup(&req);

			if (rc < 0) return js_mkerr(js, "utimesSync: %s", uv_strerror(rc));
			return js_mkundef();
			}

			static ant_value_t builtin_fs_utimes(ant_t js, ant_value_t args, int nargs) {
			return builtin_fs_utimesSync(js, args, nargs);
			}

			static ant_value_t builtin_fs_futimesSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 3) return js_mkerr(js, "futimesSync() requires fd, atime, and mtime");
			int fd = (int)js_to_number(js, args[0]);
			double atime = fs_time_arg_to_seconds(js, args[1]);
			double mtime = fs_time_arg_to_seconds(js, args[2]);

			uv_fs_t req;
			int rc = uv_fs_futime(NULL, &req, fd, atime, mtime, NULL);
			uv_fs_req_cleanup(&req);

			if (rc < 0) return js_mkerr(js, "futimesSync: %s", uv_strerror(rc));
			return js_mkundef();
			}

			static ant_value_t builtin_fs_futimes(ant_t js, ant_value_t args, int nargs) {
			return builtin_fs_futimesSync(js, args, nargs);
			}

			static ant_value_t builtin_fs_appendFileSync(ant_t js, ant_value_t args, int nargs) {
			return fs_write_file_sync_impl(js, args, nargs, "appendFileSync", "ab");
			}

			static ant_value_t builtin_fs_appendFile(ant_t js, ant_value_t args, int nargs) {
			ant_value_t promise = js_mkpromise(js);
			ant_value_t result = fs_write_file_sync_impl(js, args, nargs, "appendFile", "ab");
			if (is_err(result)) js_reject_promise(js, promise, result);
			else js_resolve_promise(js, promise, js_mkundef());
			return promise;
			}

			static ant_value_t builtin_fs_writeFile(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "writeFile() requires path and data arguments");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFile() path must be a string");
			if (vtype(args[1]) != T_STR) return js_mkerr(js, "writeFile() data must be a string");

			size_t path_len, data_len;
			char *path = js_getstr(js, args[0], &path_len);
			char *data = js_getstr(js, args[1], &data_len);

			if (!path \|\| !data) return js_mkerr(js, "Failed to get arguments");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_WRITE;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->data = malloc(data_len);
			if (!req->data) {
			free(req->path);
			free(req);
			return js_mkerr(js, "Out of memory");
			}

			memcpy(req->data, data, data_len);
			req->data_len = data_len;
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_open(uv_default_loop(), &req->uv_req, req->path, O_WRONLY \| O_CREAT \| O_TRUNC, 0644, on_open_for_write);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_unlinkSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "unlinkSync() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlinkSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");
			int result = unlink(path_cstr);

			if (result != 0) {
			ant_value_t err = fs_mk_errno_error(js, errno, "unlink", path_cstr, NULL);
			free(path_cstr);
			return err;
			}

			free(path_cstr);
			return js_mkundef();
			}

			static ant_value_t builtin_fs_unlink(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "unlink() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlink() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_UNLINK;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_unlink(uv_default_loop(), &req->uv_req, req->path, on_unlink_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_mkdirSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "mkdirSync() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdirSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int mode = 0755;
			int recursive = 0;

			if (nargs < 2) goto do_mkdir;

			switch (vtype(args[1])) {
			case T_NUM:
			mode = (int)js_getnum(args[1]);
			break;
			case T_OBJ: {
			ant_value_t opt = args[1];
			recursive = js_get(js, opt, "recursive") == js_true;
			ant_value_t mode_val = js_get(js, opt, "mode");
			if (vtype(mode_val) == T_NUM) mode = (int)js_getnum(mode_val);
			break;
			}
			}

			do_mkdir:

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			int result;
			if (recursive) {
			result = mkdirp(path_cstr, (mode_t)mode);
			} else {
			#ifdef _WIN32
			(void)mode;
			result = _mkdir(path_cstr);
			#else
			result = mkdir(path_cstr, (mode_t)mode);
			#endif
			}
			if (result != 0) {
			ant_value_t err = fs_mk_errno_error(js, errno, "mkdir", path_cstr, NULL);
			free(path_cstr);
			return err;
			}

			free(path_cstr);

			return js_mkundef();
			}

			static ant_value_t builtin_fs_mkdir(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "mkdir() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdir() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int mode = 0755;
			int recursive = 0;
			if (nargs >= 2) {
			switch (vtype(args[1])) {
			case T_NUM:
			mode = (int)js_getnum(args[1]);
			break;
			case T_OBJ: {
			ant_value_t opt = args[1];
			recursive = js_get(js, opt, "recursive") == js_true;
			ant_value_t mode_val = js_get(js, opt, "mode");
			if (vtype(mode_val) == T_NUM) mode = (int)js_getnum(mode_val);
			break;
			}}
			}

			if (recursive) {
			ant_value_t promise = js_mkpromise(js);
			char *path_cstr = strndup(path, path_len);

			if (!path_cstr) return js_mkerr(js, "Out of memory");
			int result = mkdirp(path_cstr, (mode_t)mode);

			free(path_cstr);
			if (result != 0) {
			js_reject_promise(js, promise, js_mkerr(js, "Failed to create directory: %s", strerror(errno)));
			} else js_resolve_promise(js, promise, js_mkundef());

			return promise;
			}

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_MKDIR;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->recursive = recursive;
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_mkdir(uv_default_loop(), &req->uv_req, req->path, mode, on_mkdir_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_mkdtempSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1 \|\| vtype(args[0]) != T_STR)
			return js_mkerr(js, "mkdtempSync() requires a prefix string");

			size_t prefix_len;
			const char *prefix = js_getstr(js, args[0], &prefix_len);
			if (!prefix) return js_mkerr(js, "Failed to get prefix string");

			size_t tpl_len = prefix_len + 6;
			char *tpl = malloc(tpl_len + 1);
			if (!tpl) return js_mkerr(js, "Out of memory");

			memcpy(tpl, prefix, prefix_len);
			memcpy(tpl + prefix_len, "XXXXXX", 6);
			tpl[tpl_len] = '\0';

			char *result = mkdtemp(tpl);
			if (!result) {
			free(tpl);
			return js_mkerr(js, "mkdtempSync failed: %s", strerror(errno));
			}

			ant_value_t ret = js_mkstr(js, result, strlen(result));
			free(tpl);
			return ret;
			}

			static ant_value_t builtin_fs_mkdtemp(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1 \|\| vtype(args[0]) != T_STR)
			return js_mkerr(js, "mkdtemp() requires a prefix string");

			size_t prefix_len;
			const char *prefix = js_getstr(js, args[0], &prefix_len);
			if (!prefix) return js_mkerr(js, "Failed to get prefix string");

			size_t tpl_len = prefix_len + 6;
			char *tpl = malloc(tpl_len + 1);
			if (!tpl) return js_mkerr(js, "Out of memory");

			memcpy(tpl, prefix, prefix_len);
			memcpy(tpl + prefix_len, "XXXXXX", 6);
			tpl[tpl_len] = '\0';

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) { free(tpl); return js_mkerr(js, "Out of memory"); }

			req->js = js;
			req->op_type = FS_OP_MKDTEMP;
			req->promise = js_mkpromise(js);
			req->path = tpl;
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_mkdtemp(uv_default_loop(), &req->uv_req, req->path, on_mkdtemp_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_rmdirSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "rmdirSync() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdirSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			#ifdef _WIN32
			int result = _rmdir(path_cstr);
			#else
			int result = rmdir(path_cstr);
			#endif
			if (result != 0) {
			ant_value_t err = fs_mk_errno_error(js, errno, "rmdir", path_cstr, NULL);
			free(path_cstr);
			return err;
			}

			free(path_cstr);
			return js_mkundef();
			}

			static ant_value_t builtin_fs_rmdir(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "rmdir() requires a path argument");

			if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdir() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_RMDIR;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_rmdir(uv_default_loop(), &req->uv_req, req->path, on_rmdir_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_rmSync(ant_t js, ant_value_t args, int nargs) {
			return fs_rm_impl(js, args, nargs, false);
			}

			static ant_value_t builtin_fs_rm(ant_t js, ant_value_t args, int nargs) {
			return fs_rm_impl(js, args, nargs, true);
			}

			static ant_value_t dirent_isFile(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_FILE);
			}

			static ant_value_t dirent_isDirectory(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_DIR);
			}

			static ant_value_t dirent_isSymbolicLink(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_LINK);
			}

			static ant_value_t dirent_isBlockDevice(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_BLOCK);
			}

			static ant_value_t dirent_isCharacterDevice(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_CHAR);
			}

			static ant_value_t dirent_isFIFO(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_FIFO);
			}

			static ant_value_t dirent_isSocket(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t type_val = js_get_slot(this, SLOT_DATA);
			if (vtype(type_val) != T_NUM) return js_false;
			return js_bool((int)js_getnum(type_val) == UV_DIRENT_SOCKET);
			}

			static ant_value_t stat_isFile(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t mode_val = js_get_slot(this, SLOT_DATA);

			if (vtype(mode_val) != T_NUM) return js_false;
			mode_t mode = (mode_t)js_getnum(mode_val);

			return js_bool(S_ISREG(mode));
			}

			static ant_value_t stat_isDirectory(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t mode_val = js_get_slot(this, SLOT_DATA);

			if (vtype(mode_val) != T_NUM) return js_false;
			mode_t mode = (mode_t)js_getnum(mode_val);

			return js_bool(S_ISDIR(mode));
			}

			static ant_value_t stat_isSymbolicLink(ant_t js, ant_value_t args, int nargs) {
			ant_value_t this = js_getthis(js);
			ant_value_t mode_val = js_get_slot(this, SLOT_DATA);

			if (vtype(mode_val) != T_NUM) return js_false;
			mode_t mode = (mode_t)js_getnum(mode_val);

			return js_bool(S_ISLNK(mode));
			}

			static ant_value_t create_stats_object(ant_t js, struct stat st) {
			return fs_stats_object_from_posix(js, st);
			}

			static const char *errno_to_code(int err_num) {
			switch (err_num) {
			case ENOENT: return "ENOENT";
			case EACCES: return "EACCES";
			case ENOTDIR: return "ENOTDIR";
			case ELOOP: return "ELOOP";
			case ENAMETOOLONG: return "ENAMETOOLONG";
			case EOVERFLOW: return "EOVERFLOW";
			case EROFS: return "EROFS";
			case ETXTBSY: return "ETXTBSY";
			case EEXIST: return "EEXIST";
			case ENOTEMPTY: return "ENOTEMPTY";
			case EISDIR: return "EISDIR";
			case EBUSY: return "EBUSY";
			case EINVAL: return "EINVAL";
			case EPERM: return "EPERM";
			case EIO: return "EIO";
			default: return "UNKNOWN";
			}}

			static ant_value_t fs_mk_syscall_error(
			ant_t js, const char code, double err_num,
			const char message, const char syscall,
			const char path, const char dest
			) {
			ant_value_t props = js_mkobj(js);

			if (!code) code = "UNKNOWN";
			if (!message) message = "Unknown error";

			js_set(js, props, "code", js_mkstr(js, code, strlen(code)));
			js_set(js, props, "errno", js_mknum(err_num));

			if (syscall) js_set(js, props, "syscall", js_mkstr(js, syscall, strlen(syscall)));
			if (path) js_set(js, props, "path", js_mkstr(js, path, strlen(path)));
			if (dest) js_set(js, props, "dest", js_mkstr(js, dest, strlen(dest)));

			if (path && dest) return js_mkerr_props(
			js, JS_ERR_GENERIC,
			props, "%s: %s, %s '%s' -> '%s'",
			code, message, syscall, path, dest
			);

			if (path) return js_mkerr_props(
			js, JS_ERR_GENERIC,
			props, "%s: %s, %s '%s'",
			code, message, syscall, path
			);

			return js_mkerr_props(
			js, JS_ERR_GENERIC,
			props, "%s: %s, %s",
			code, message, syscall
			);
			}

			static ant_value_t fs_mk_errno_error(
			ant_t *js, int err_num,
			const char syscall, const char path, const char *dest
			) {
			int uv_code = uv_translate_sys_error(err_num);
			if (uv_code == 0) uv_code = -err_num;

			return fs_mk_syscall_error(
			js, errno_to_code(err_num),
			(double)uv_code,
			uv_strerror(uv_code),
			syscall, path, dest
			);
			}

			static ant_value_t fs_mk_uv_error(
			ant_t *js, int uv_code,
			const char syscall, const char path, const char *dest
			) {
			return fs_mk_syscall_error(
			js, uv_err_name(uv_code),
			(double)uv_code,
			uv_strerror(uv_code),
			syscall, path, dest
			);
			}

			static ant_value_t builtin_fs_statSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "statSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "statSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			struct stat st;
			int result = stat(path_cstr, &st);

			if (result != 0) {
			ant_value_t err = fs_mk_errno_error(js, errno, "stat", path_cstr, NULL);
			free(path_cstr); return err;
			}

			free(path_cstr);
			return create_stats_object(js, &st);
			}

			static ant_value_t builtin_fs_stat(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "stat() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "stat() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_STAT;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_stat(uv_default_loop(), &req->uv_req, req->path, on_stat_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_lstatSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "lstatSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "lstatSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			uv_fs_t req;
			int result = uv_fs_lstat(NULL, &req, path_cstr, NULL);

			if (result < 0) {
			ant_value_t err = fs_mk_uv_error(js, result, "lstat", path_cstr, NULL);
			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return err;
			}

			ant_value_t stat_obj = fs_stats_object_from_uv(js, &req.statbuf);
			uv_fs_req_cleanup(&req);
			free(path_cstr);

			return stat_obj;
			}

			static ant_value_t builtin_fs_lstat(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "lstat() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "lstat() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_STAT;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_lstat(uv_default_loop(), &req->uv_req, req->path, on_stat_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_fstatSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "fstatSync() requires an fd argument");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "fstatSync() fd must be a number");

			uv_file fd = (uv_file)(int)js_getnum(args[0]);
			uv_fs_t req;
			int result = uv_fs_fstat(NULL, &req, fd, NULL);

			if (result < 0) {
			ant_value_t err = fs_mk_uv_error(js, result, "fstat", NULL, NULL);
			uv_fs_req_cleanup(&req);
			return err;
			}

			ant_value_t stat_obj = fs_stats_object_from_uv(js, &req.statbuf);
			uv_fs_req_cleanup(&req);
			return stat_obj;
			}

			static ant_value_t builtin_fs_fstat(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "fstat() requires an fd argument");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "fstat() fd must be a number");

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_STAT;
			req->promise = js_mkpromise(js);
			req->fd = (uv_file)(int)js_getnum(args[0]);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_fstat(uv_default_loop(), &req->uv_req, req->fd, on_stat_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_existsSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "existsSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "existsSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			struct stat st;
			int result = stat(path_cstr, &st);
			free(path_cstr);

			return js_bool(result == 0);
			}

			static ant_value_t builtin_fs_exists(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "exists() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "exists() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_EXISTS;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_stat(uv_default_loop(), &req->uv_req, req->path, on_exists_complete);

			if (result < 0) {
			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_false);
			remove_pending_request(req);
			free_fs_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_accessSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "accessSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "accessSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int mode = F_OK;
			if (nargs >= 2 && vtype(args[1]) == T_NUM) {
			mode = (int)js_getnum(args[1]);
			}

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");
			int result = access(path_cstr, mode);

			if (result != 0) {
			ant_value_t err = fs_mk_errno_error(js, errno, "access", path_cstr, NULL);
			free(path_cstr); return err;
			}

			free(path_cstr);
			return js_mkundef();
			}

			static ant_value_t builtin_fs_chmodSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "chmodSync() requires a path argument");
			if (nargs < 2) return js_mkerr(js, "chmodSync() requires a mode argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "chmodSync() path must be a string or URL");

			mode_t mode = 0;
			if (!fs_parse_mode(js, args[1], &mode)) {
			return js_mkerr(js, "chmodSync() mode must be a number or octal string");
			}

			size_t path_len = 0;
			char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			uv_fs_t req;
			int result = uv_fs_chmod(uv_default_loop(), &req, path_cstr, mode, NULL);

			if (result < 0) {
			ant_value_t err = fs_mk_uv_error(js, result, "chmod", path_cstr, NULL);
			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return err;
			}

			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return js_mkundef();
			}

			static ant_value_t builtin_fs_chmod(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "chmod() requires a path argument");
			if (nargs < 2) return js_mkerr(js, "chmod() requires a mode argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "chmod() path must be a string or URL");

			mode_t mode = 0;
			if (!fs_parse_mode(js, args[1], &mode)) {
			return js_mkerr(js, "chmod() mode must be a number or octal string");
			}

			size_t path_len = 0;
			char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_CHMOD;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			if (!req->path) {
			free_fs_request(req);
			return js_mkerr(js, "Out of memory");
			}

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_chmod(uv_default_loop(), &req->uv_req, req->path, mode, on_chmod_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_access(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "access() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "access() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int mode = F_OK;
			if (nargs >= 2 && vtype(args[1]) == T_NUM) {
			mode = (int)js_getnum(args[1]);
			}


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_ACCESS;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_access(uv_default_loop(), &req->uv_req, req->path, mode, on_access_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_realpathSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "realpathSync() requires a path argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "realpathSync() path must be a string");

			size_t path_len = 0;
			const char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *resolved = realpath(path, NULL);
			if (!resolved) return js_mkerr(js, "realpathSync failed for '%s'", path);

			ant_value_t result = js_mkstr(js, resolved, strlen(resolved));
			free(resolved);
			return result;
			}

			static ant_value_t builtin_fs_realpath(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "realpath() requires a path argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "realpath() path must be a string");

			size_t path_len = 0;
			const char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_REALPATH;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			if (!req->path) {
			free_fs_request(req);
			return js_mkerr(js, "Out of memory");
			}

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_realpath(uv_default_loop(), &req->uv_req, req->path, on_realpath_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_readlinkSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readlinkSync() requires a path argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "readlinkSync() path must be a string");

			size_t path_len = 0;
			const char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			uv_fs_t req;
			int result = uv_fs_readlink(NULL, &req, path_cstr, NULL);

			if (result < 0 \|\| !req.ptr) {
			ant_value_t err = fs_mk_uv_error(js, result, "readlink", path_cstr, NULL);
			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return err;
			}

			ant_value_t link = js_mkstr(js, (const char )req.ptr, strlen((const char )req.ptr));
			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return link;
			}

			static ant_value_t builtin_fs_readlink(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readlink() requires a path argument");

			ant_value_t path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr(js, "readlink() path must be a string");

			size_t path_len = 0;
			const char *path = js_getstr(js, path_val, &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_REALPATH;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			if (!req->path) {
			free_fs_request(req);
			return js_mkerr(js, "Out of memory");
			}

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_readlink(uv_default_loop(), &req->uv_req, req->path, on_realpath_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_readdirSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readdirSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdirSync() path must be a string");

			bool with_file_types = false;
			if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
			ant_value_t wft = js_get(js, args[1], "withFileTypes");
			with_file_types = js_truthy(js, wft);
			}

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			uv_fs_t req;
			int result = uv_fs_scandir(NULL, &req, path_cstr, 0, NULL);

			if (result < 0) {
			ant_value_t err = fs_mk_uv_error(js, result, "scandir", path_cstr, NULL);
			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return err;
			}

			free(path_cstr);

			ant_value_t arr = js_mkarr(js);
			uv_dirent_t dirent;

			while (uv_fs_scandir_next(&req, &dirent) != UV_EOF) {
			if (with_file_types) {
			ant_value_t entry = create_dirent_object(js, dirent.name, strlen(dirent.name), dirent.type);
			js_arr_push(js, arr, entry);
			} else {
			ant_value_t name = js_mkstr(js, dirent.name, strlen(dirent.name));
			js_arr_push(js, arr, name);
			}}

			uv_fs_req_cleanup(&req);
			return arr;
			}

			static ant_value_t builtin_fs_readdir(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "readdir() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdir() path must be a string");

			bool with_file_types = false;
			if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
			ant_value_t wft = js_get(js, args[1], "withFileTypes");
			with_file_types = js_truthy(js, wft);
			}

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");


			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_READDIR;
			req->with_file_types = with_file_types;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_scandir(uv_default_loop(), &req->uv_req, req->path, 0, on_readdir_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static void on_write_fd_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_mknum((double)uv_req->result));
			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_read_fd_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			if (is_callable(req->callback_fn)) {
			ant_value_t err = js_mkerr(req->js, "read failed: %s", uv_strerror((int)uv_req->result));
			ant_value_t cb_args[1] = { err };
			fs_call_value(req->js, req->callback_fn, js_mkundef(), cb_args, 1);
			remove_pending_request(req);
			free_fs_request(req);
			return;
			}
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			ssize_t bytes_read = uv_req->result;

			if (req->data && bytes_read > 0) {
			TypedArrayData *ta = buffer_get_typedarray_data(req->target_buffer);
			if (ta && ta->buffer && ta->buffer->data) {
			uint8_t *dest = ta->buffer->data + ta->byte_offset + req->buf_offset;
			memcpy(dest, req->data, (size_t)bytes_read);
			}
			}

			if (is_callable(req->callback_fn)) {
			ant_value_t cb_args[3] = { js_mknull(), js_mknum((double)bytes_read), req->target_buffer };
			fs_call_value(req->js, req->callback_fn, js_mkundef(), cb_args, 3);
			remove_pending_request(req);
			free_fs_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_mknum((double)bytes_read));
			remove_pending_request(req);
			free_fs_request(req);
			}

			static ant_value_t builtin_fs_read_fd(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "read() requires fd and buffer arguments");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "read() fd must be a number");

			int fd = (int)js_getnum(args[0]);

			ant_value_t buf_arg = args[1];
			TypedArrayData *ta_data = buffer_get_typedarray_data(buf_arg);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return js_mkerr(js, "read() buffer argument must be a Buffer or TypedArray");

			size_t buf_len = ta_data->byte_length;
			size_t offset = 0;
			size_t length = buf_len;
			int64_t position = -1;

			ant_value_t callback = js_mkundef();
			int data_nargs = nargs;
			if (nargs >= 3 && is_callable(args[nargs - 1])) {
			callback = args[nargs - 1];
			data_nargs = nargs - 1;
			}

			if (data_nargs >= 3 && vtype(args[2]) == T_NUM) offset = (size_t)js_getnum(args[2]);
			if (data_nargs >= 4 && vtype(args[3]) == T_NUM) length = (size_t)js_getnum(args[3]);
			if (data_nargs >= 5 && vtype(args[4]) == T_NUM) position = (int64_t)js_getnum(args[4]);

			if (offset > buf_len) return js_mkerr(js, "read() offset out of bounds");
			if (offset + length > buf_len) return js_mkerr(js, "read() length extends beyond buffer");

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_READ_FD;
			req->promise = js_mkpromise(js);
			req->fd = fd;
			req->target_buffer = buf_arg;
			req->buf_offset = offset;
			req->data_len = length;
			req->callback_fn = callback;
			req->data = malloc(length > 0 ? length : 1);
			if (!req->data) {
			free(req);
			return js_mkerr(js, "Out of memory");
			}
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);

			uv_buf_t buf = uv_buf_init(req->data, (unsigned int)length);
			int result = uv_fs_read(uv_default_loop(), &req->uv_req, req->fd, &buf, 1, position, on_read_fd_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_readSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "readSync() requires fd and buffer arguments");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "readSync() fd must be a number");

			int fd = (int)js_getnum(args[0]);

			TypedArrayData *ta_data = buffer_get_typedarray_data(args[1]);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return js_mkerr(js, "readSync() second argument must be a Buffer, TypedArray, or DataView");

			uint8_t *buf_data = ta_data->buffer->data + ta_data->byte_offset;
			size_t buf_len = ta_data->byte_length;
			size_t offset = 0;
			size_t length = buf_len;
			int64_t position = -1;

			if (nargs >= 3) {
			if (vtype(args[2]) == T_OBJ) {
			ant_value_t off_val = js_get(js, args[2], "offset");
			ant_value_t len_val = js_get(js, args[2], "length");
			ant_value_t pos_val = js_get(js, args[2], "position");
			if (vtype(off_val) == T_NUM) offset = (size_t)js_getnum(off_val);
			if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val);
			else length = buf_len - offset;
			if (vtype(pos_val) == T_NUM) position = (int64_t)js_getnum(pos_val);
			} else if (vtype(args[2]) == T_NUM) {
			offset = (size_t)js_getnum(args[2]);
			length = buf_len - offset;
			if (nargs >= 4 && vtype(args[3]) == T_NUM) length = (size_t)js_getnum(args[3]);
			if (nargs >= 5 && vtype(args[4]) == T_NUM) position = (int64_t)js_getnum(args[4]);
			}}

			if (offset > buf_len) return js_mkerr(js, "offset is out of bounds");
			if (offset + length > buf_len) return js_mkerr(js, "length extends beyond buffer");

			uv_fs_t req;
			uv_buf_t buf = uv_buf_init((char *)(buf_data + offset), (unsigned int)length);
			int result = uv_fs_read(uv_default_loop(), &req, fd, &buf, 1, position, NULL);
			uv_fs_req_cleanup(&req);

			if (result < 0) return js_mkerr(js, "readSync failed: %s", uv_strerror(result));
			return js_mknum((double)result);
			}

			static ant_value_t builtin_fs_writeSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "writeSync() requires fd and data arguments");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "writeSync() fd must be a number");

			int fd = (int)js_getnum(args[0]);

			if (vtype(args[1]) == T_STR) {
			size_t str_len;
			const char *str = js_getstr(js, args[1], &str_len);
			if (!str) return js_mkerr(js, "Failed to get string");

			int64_t position = -1;
			if (nargs >= 3 && vtype(args[2]) == T_NUM)
			position = (int64_t)js_getnum(args[2]);

			uv_fs_t req;
			uv_buf_t buf = uv_buf_init((char *)str, (unsigned int)str_len);
			int result = uv_fs_write(uv_default_loop(), &req, fd, &buf, 1, position, NULL);
			uv_fs_req_cleanup(&req);

			if (result < 0) return js_mkerr(js, "writeSync failed: %s", uv_strerror(result));
			return js_mknum((double)result);
			}

			TypedArrayData *ta_data = buffer_get_typedarray_data(args[1]);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return js_mkerr(js, "writeSync() second argument must be a Buffer, TypedArray, DataView, or string");

			uint8_t *buf_data = ta_data->buffer->data + ta_data->byte_offset;
			size_t buf_len = ta_data->byte_length;
			size_t offset = 0;
			size_t length = buf_len;
			int64_t position = -1;

			if (nargs >= 3) {
			if (vtype(args[2]) == T_OBJ) {
			ant_value_t off_val = js_get(js, args[2], "offset");
			ant_value_t len_val = js_get(js, args[2], "length");
			ant_value_t pos_val = js_get(js, args[2], "position");
			if (vtype(off_val) == T_NUM) offset = (size_t)js_getnum(off_val);
			if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val);
			else length = buf_len - offset;
			if (vtype(pos_val) == T_NUM) position = (int64_t)js_getnum(pos_val);
			} else if (vtype(args[2]) == T_NUM) {
			offset = (size_t)js_getnum(args[2]);
			length = buf_len - offset;
			if (nargs >= 4 && vtype(args[3]) == T_NUM) length = (size_t)js_getnum(args[3]);
			if (nargs >= 5 && vtype(args[4]) == T_NUM) position = (int64_t)js_getnum(args[4]);
			}
			}

			if (offset > buf_len) return js_mkerr(js, "offset is out of bounds");
			if (offset + length > buf_len) return js_mkerr(js, "length extends beyond buffer");

			uv_fs_t req;
			uv_buf_t buf = uv_buf_init((char *)(buf_data + offset), (unsigned int)length);
			int result = uv_fs_write(uv_default_loop(), &req, fd, &buf, 1, position, NULL);
			uv_fs_req_cleanup(&req);

			if (result < 0) return js_mkerr(js, "writeSync failed: %s", uv_strerror(result));
			return js_mknum((double)result);
			}

			static ant_value_t builtin_fs_write_fd(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "write() requires fd and data arguments");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "write() fd must be a number");

			int fd = (int)js_getnum(args[0]);
			const char *write_data;
			size_t write_len;
			int64_t position = -1;

			if (vtype(args[1]) == T_STR) {
			size_t str_len;
			const char *str = js_getstr(js, args[1], &str_len);
			if (!str) return js_mkerr(js, "Failed to get string");

			if (nargs >= 3 && vtype(args[2]) == T_NUM)
			position = (int64_t)js_getnum(args[2]);

			write_data = str;
			write_len = str_len;
			} else {
			TypedArrayData *ta_data = buffer_get_typedarray_data(args[1]);
			if (!ta_data \|\| !ta_data->buffer \|\| !ta_data->buffer->data)
			return js_mkerr(js, "write() second argument must be a Buffer, TypedArray, DataView, or string");

			uint8_t *buf_data = ta_data->buffer->data + ta_data->byte_offset;
			size_t buf_len = ta_data->byte_length;
			size_t offset = 0;
			size_t length = buf_len;

			if (nargs >= 3) {
			if (vtype(args[2]) == T_OBJ) {
			ant_value_t off_val = js_get(js, args[2], "offset");
			ant_value_t len_val = js_get(js, args[2], "length");
			ant_value_t pos_val = js_get(js, args[2], "position");
			if (vtype(off_val) == T_NUM) offset = (size_t)js_getnum(off_val);
			if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val);
			else length = buf_len - offset;
			if (vtype(pos_val) == T_NUM) position = (int64_t)js_getnum(pos_val);
			} else if (vtype(args[2]) == T_NUM) {
			offset = (size_t)js_getnum(args[2]);
			length = buf_len - offset;
			if (nargs >= 4 && vtype(args[3]) == T_NUM) length = (size_t)js_getnum(args[3]);
			if (nargs >= 5 && vtype(args[4]) == T_NUM) position = (int64_t)js_getnum(args[4]);
			}}

			if (offset > buf_len) return js_mkerr(js, "offset is out of bounds");
			if (offset + length > buf_len) return js_mkerr(js, "length extends beyond buffer");

			write_data = (const char *)(buf_data + offset);
			write_len = length;
			}

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_WRITE_FD;
			req->promise = js_mkpromise(js);
			req->fd = fd;
			req->data = malloc(write_len);
			if (!req->data) {
			free(req);
			return js_mkerr(js, "Out of memory");
			}
			memcpy(req->data, write_data, write_len);
			req->data_len = write_len;
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);

			uv_buf_t buf = uv_buf_init(req->data, (unsigned int)req->data_len);
			int result = uv_fs_write(uv_default_loop(), &req->uv_req, req->fd, &buf, 1, position, on_write_fd_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_writevSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "writevSync() requires fd and buffers arguments");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "writevSync() fd must be a number");

			int fd = (int)js_getnum(args[0]);
			ant_offset_t arr_len = js_arr_len(js, args[1]);
			if (arr_len == 0) return js_mknum(0);

			int64_t position = -1;
			if (nargs >= 3 && vtype(args[2]) == T_NUM)
			position = (int64_t)js_getnum(args[2]);

			uv_buf_t *bufs = calloc((size_t)arr_len, sizeof(uv_buf_t));
			if (!bufs) return js_mkerr(js, "Out of memory");

			for (ant_offset_t i = 0; i < arr_len; i++) {
			ant_value_t item = js_arr_get(js, args[1], i);
			TypedArrayData *ta = buffer_get_typedarray_data(item);
			if (!ta \|\| !ta->buffer \|\| !ta->buffer->data) {
			free(bufs);
			return js_mkerr(js, "writevSync() buffers must contain ArrayBufferViews");
			}
			bufs[i] = uv_buf_init((char *)(ta->buffer->data + ta->byte_offset), (unsigned int)ta->byte_length);
			}

			uv_fs_t req;
			int result = uv_fs_write(uv_default_loop(), &req, fd, bufs, (unsigned int)arr_len, position, NULL);
			uv_fs_req_cleanup(&req);
			free(bufs);

			if (result < 0) return js_mkerr(js, "writevSync failed: %s", uv_strerror(result));
			return js_mknum((double)result);
			}

			static ant_value_t builtin_fs_writev_fd(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 2) return js_mkerr(js, "writev() requires fd and buffers arguments");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "writev() fd must be a number");

			int fd = (int)js_getnum(args[0]);
			ant_offset_t arr_len = js_arr_len(js, args[1]);

			if (arr_len == 0) {
			ant_value_t promise = js_mkpromise(js);
			js_resolve_promise(js, promise, js_mknum(0));
			return promise;
			}

			int64_t position = -1;
			if (nargs >= 3 && vtype(args[2]) == T_NUM)
			position = (int64_t)js_getnum(args[2]);

			size_t total_len = 0;
			for (ant_offset_t i = 0; i < arr_len; i++) {
			ant_value_t item = js_arr_get(js, args[1], i);
			TypedArrayData *ta = buffer_get_typedarray_data(item);
			if (!ta \|\| !ta->buffer \|\| !ta->buffer->data)
			return js_mkerr(js, "writev() buffers must contain ArrayBufferViews");
			total_len += ta->byte_length;
			}

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->data = malloc(total_len);
			if (!req->data) {
			free(req);
			return js_mkerr(js, "Out of memory");
			}

			size_t off = 0;
			for (ant_offset_t i = 0; i < arr_len; i++) {
			ant_value_t item = js_arr_get(js, args[1], i);
			TypedArrayData *ta = buffer_get_typedarray_data(item);
			memcpy(req->data + off, ta->buffer->data + ta->byte_offset, ta->byte_length);
			off += ta->byte_length;
			}

			req->js = js;
			req->op_type = FS_OP_WRITE_FD;
			req->promise = js_mkpromise(js);
			req->fd = fd;
			req->data_len = total_len;
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);

			uv_buf_t buf = uv_buf_init(req->data, (unsigned int)total_len);
			int result = uv_fs_write(uv_default_loop(), &req->uv_req, req->fd, &buf, 1, position, on_write_fd_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static int parse_open_flags(ant_t *js, ant_value_t arg) {
			if (vtype(arg) == T_NUM) return (int)js_getnum(arg);
			if (vtype(arg) != T_STR) return O_RDONLY;

			size_t len;
			const char *str = js_getstr(js, arg, &len);
			if (!str) return O_RDONLY;

			if (len == 1 && str[0] == 'r') return O_RDONLY;
			if (len == 2 && memcmp(str, "r+", 2) == 0) return O_RDWR;
			if (len == 1 && str[0] == 'w') return O_WRONLY \| O_CREAT \| O_TRUNC;
			if (len == 2 && memcmp(str, "wx", 2) == 0) return O_WRONLY \| O_CREAT \| O_TRUNC \| O_EXCL;
			if (len == 2 && memcmp(str, "w+", 2) == 0) return O_RDWR \| O_CREAT \| O_TRUNC;
			if (len == 3 && memcmp(str, "wx+", 3) == 0) return O_RDWR \| O_CREAT \| O_TRUNC \| O_EXCL;
			if (len == 1 && str[0] == 'a') return O_WRONLY \| O_CREAT \| O_APPEND;
			if (len == 2 && memcmp(str, "ax", 2) == 0) return O_WRONLY \| O_CREAT \| O_APPEND \| O_EXCL;
			if (len == 2 && memcmp(str, "a+", 2) == 0) return O_RDWR \| O_CREAT \| O_APPEND;
			if (len == 3 && memcmp(str, "ax+", 3) == 0) return O_RDWR \| O_CREAT \| O_APPEND \| O_EXCL;

			return O_RDONLY;
			}

			static ant_value_t builtin_fs_openSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "openSync() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "openSync() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int flags = (nargs >= 2) ? parse_open_flags(js, args[1]) : O_RDONLY;
			int mode = (nargs >= 3 && vtype(args[2]) == T_NUM) ? (int)js_getnum(args[2]) : 0666;

			char *path_cstr = strndup(path, path_len);
			if (!path_cstr) return js_mkerr(js, "Out of memory");

			uv_fs_t req;
			int result = uv_fs_open(uv_default_loop(), &req, path_cstr, flags, mode, NULL);

			if (result < 0) {
			ant_value_t err = fs_mk_uv_error(js, result, "open", path_cstr, NULL);
			uv_fs_req_cleanup(&req);
			free(path_cstr);
			return err;
			}

			uv_fs_req_cleanup(&req);
			free(path_cstr);

			return js_mknum((double)result);
			}

			static ant_value_t builtin_fs_closeSync(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "closeSync() requires a fd argument");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "closeSync() fd must be a number");

			int fd = (int)js_getnum(args[0]);

			uv_fs_t req;
			int result = uv_fs_close(uv_default_loop(), &req, fd, NULL);
			uv_fs_req_cleanup(&req);

			if (result < 0) return js_mkerr(js, "closeSync failed: %s", uv_strerror(result));
			return js_mkundef();
			}

			static void on_open_fd_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_mknum((double)uv_req->result));
			remove_pending_request(req);
			free_fs_request(req);
			}

			static void on_open_filehandle_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(
			req->js, req->promise,
			fs_make_filehandle(req->js, (int)uv_req->result)
			);

			remove_pending_request(req);
			free_fs_request(req);
			}

			static ant_value_t builtin_fs_open_fd(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "open() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "open() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int flags = (nargs >= 2) ? parse_open_flags(js, args[1]) : O_RDONLY;
			int mode = (nargs >= 3 && vtype(args[2]) == T_NUM) ? (int)js_getnum(args[2]) : 0666;

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_OPEN;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_open(uv_default_loop(), &req->uv_req, req->path, flags, mode, on_open_fd_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_open_filehandle(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "open() requires a path argument");
			if (vtype(args[0]) != T_STR) return js_mkerr(js, "open() path must be a string");

			size_t path_len;
			char *path = js_getstr(js, args[0], &path_len);
			if (!path) return js_mkerr(js, "Failed to get path string");

			int flags = (nargs >= 2) ? parse_open_flags(js, args[1]) : O_RDONLY;
			int mode = (nargs >= 3 && vtype(args[2]) == T_NUM) ? (int)js_getnum(args[2]) : 0666;

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_OPEN;
			req->promise = js_mkpromise(js);
			req->path = strndup(path, path_len);
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_open(
			uv_default_loop(), &req->uv_req, req->path,
			flags, mode, on_open_filehandle_complete
			);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static void on_close_fd_complete(uv_fs_t *uv_req) {
			fs_request_t req = (fs_request_t )uv_req->data;

			if (uv_req->result < 0) {
			fs_request_fail(req, (int)uv_req->result);
			req->completed = 1;
			complete_request(req);
			return;
			}

			req->completed = 1;
			js_resolve_promise(req->js, req->promise, js_mkundef());
			remove_pending_request(req);
			free_fs_request(req);
			}

			static ant_value_t builtin_fs_close_fd(ant_t js, ant_value_t args, int nargs) {
			if (nargs < 1) return js_mkerr(js, "close() requires a fd argument");
			if (vtype(args[0]) != T_NUM) return js_mkerr(js, "close() fd must be a number");

			int fd = (int)js_getnum(args[0]);

			fs_request_t *req = calloc(1, sizeof(fs_request_t));
			if (!req) return js_mkerr(js, "Out of memory");

			req->js = js;
			req->op_type = FS_OP_CLOSE;
			req->promise = js_mkpromise(js);
			req->fd = fd;
			req->uv_req.data = req;

			utarray_push_back(pending_requests, &req);
			int result = uv_fs_close(uv_default_loop(), &req->uv_req, req->fd, on_close_fd_complete);

			if (result < 0) {
			fs_request_fail(req, result);
			req->completed = 1;
			complete_request(req);
			}

			return req->promise;
			}

			static ant_value_t builtin_fs_watch(ant_t js, ant_value_t args, int nargs) {
			ant_value_t path_val = 0;
			ant_value_t watcher_obj = 0;
			fs_watch_options_t opts;
			fs_watcher_t *watcher = NULL;
			uv_handle_t *handle = NULL;

			const char *path = NULL;
			size_t path_len = 0;
			int rc = 0;

			if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "watch() requires a path argument");
			if (!fs_parse_watch_options(js, args, nargs, &opts))
			return js_mkerr_typed(js, JS_ERR_TYPE, "watch() options must be a string, object, or callback");

			path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr_typed(js, JS_ERR_TYPE, "watch() path must be a string or URL");

			path = js_getstr(js, path_val, &path_len);
			if (!path \|\| path_len == 0) return js_mkerr(js, "watch() path must not be empty");

			watcher = fs_watcher_new(js, FS_WATCH_MODE_EVENT);
			if (!watcher) return js_mkerr(js, "Out of memory");

			watcher_obj = fs_watcher_make_object(js, watcher);
			if (is_err(watcher_obj)) {
			fs_watcher_free(watcher);
			return watcher_obj;
			}

			rc = fs_watcher_start_event(watcher, path, opts.persistent, opts.recursive);
			if (rc != 0) {
			js_set_native_ptr(watcher_obj, NULL);
			fs_watcher_free(watcher);
			return fs_watch_error(js, rc, path);
			}

			fs_add_active_watcher(watcher);
			if (!opts.persistent) {
			handle = fs_watcher_uv_handle(watcher);
			if (handle) uv_unref(handle);
			}
			if (is_callable(opts.listener))
			eventemitter_add_listener(js, watcher_obj, "change", opts.listener, false);
			return watcher_obj;
			}

			static ant_value_t builtin_fs_watchFile(ant_t js, ant_value_t args, int nargs) {
			ant_value_t path_val = 0;
			fs_watchfile_options_t opts;

			fs_watcher_t *watcher = NULL;
			uv_handle_t *handle = NULL;

			const char *path = NULL;
			size_t path_len = 0;
			int rc = 0;

			if (nargs < 2)
			return js_mkerr_typed(js, JS_ERR_TYPE, "watchFile() requires a path and listener");
			if (!fs_parse_watchfile_options(js, args, nargs, &opts))
			return js_mkerr_typed(js, JS_ERR_TYPE, "watchFile() requires a listener callback");

			path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkerr_typed(js, JS_ERR_TYPE, "watchFile() path must be a string or URL");

			path = js_getstr(js, path_val, &path_len);
			if (!path \|\| path_len == 0) return js_mkerr(js, "watchFile() path must not be empty");

			watcher = fs_watcher_new(js, FS_WATCH_MODE_STAT);
			if (!watcher) return js_mkerr(js, "Out of memory");

			watcher->callback = opts.listener;
			watcher->last_stat_valid = fs_stat_path_sync(path, &watcher->last_stat);

			rc = fs_watcher_start_poll(watcher, path, opts.persistent, opts.interval_ms);
			if (rc != 0) {
			fs_watcher_free(watcher);
			return fs_watch_error(js, rc, path);
			}

			fs_add_active_watcher(watcher);
			if (!opts.persistent) {
			handle = fs_watcher_uv_handle(watcher);
			if (handle) uv_unref(handle);
			}
			return js_mkundef();
			}

			static ant_value_t builtin_fs_unwatchFile(ant_t js, ant_value_t args, int nargs) {
			ant_value_t path_val = 0;
			ant_value_t listener = js_mkundef();

			char *resolved = NULL;
			fs_watcher_t *watcher = NULL;
			fs_watcher_t *next = NULL;

			const char *path = NULL;
			size_t path_len = 0;

			if (nargs < 1) return js_mkundef();

			path_val = fs_coerce_path(js, args[0]);
			if (vtype(path_val) != T_STR) return js_mkundef();

			path = js_getstr(js, path_val, &path_len);
			if (!path \|\| path_len == 0) return js_mkundef();
			if (nargs > 1 && is_callable(args[1])) listener = args[1];

			resolved = ant_watch_resolve_path(path);
			if (!resolved) return js_mkundef();

			for (watcher = active_watchers; watcher; watcher = next) {
			next = watcher->next_active;
			if (watcher->mode != FS_WATCH_MODE_STAT) continue;
			if (!watcher->path \|\| strcmp(watcher->path, resolved) != 0) continue;
			if (is_callable(listener) && watcher->callback != listener) continue;
			fs_watcher_close_native(watcher);
			}

			free(resolved);
			return js_mkundef();
			}

			void init_fs_module(void) {
			utarray_new(pending_requests, &ut_ptr_icd);

			ant_t *js = rt->js;
			ant_value_t glob = js->global;

			ant_value_t stats_ctor = js_mkobj(js);
			ant_value_t stats_proto = js_mkobj(js);

			js_set(js, stats_proto, "isFile", js_mkfun(stat_isFile));
			js_set(js, stats_proto, "isDirectory", js_mkfun(stat_isDirectory));
			js_set(js, stats_proto, "isSymbolicLink", js_mkfun(stat_isSymbolicLink));
			js_set_sym(js, stats_proto, get_toStringTag_sym(), js_mkstr(js, "Stats", 5));

			js_mkprop_fast(js, stats_ctor, "prototype", 9, stats_proto);
			js_mkprop_fast(js, stats_ctor, "name", 4, js_mkstr(js, "Stats", 5));
			js_set_descriptor(js, stats_ctor, "name", 4, 0);

			js_set(js, glob, "Stats", js_obj_to_func(stats_ctor));

			g_dirent_proto = js_mkobj(js);
			js_set(js, g_dirent_proto, "isFile", js_mkfun(dirent_isFile));
			js_set(js, g_dirent_proto, "isDirectory", js_mkfun(dirent_isDirectory));
			js_set(js, g_dirent_proto, "isSymbolicLink", js_mkfun(dirent_isSymbolicLink));
			js_set(js, g_dirent_proto, "isBlockDevice", js_mkfun(dirent_isBlockDevice));
			js_set(js, g_dirent_proto, "isCharacterDevice", js_mkfun(dirent_isCharacterDevice));
			js_set(js, g_dirent_proto, "isFIFO", js_mkfun(dirent_isFIFO));
			js_set(js, g_dirent_proto, "isSocket", js_mkfun(dirent_isSocket));
			js_set_sym(js, g_dirent_proto, get_toStringTag_sym(), js_mkstr(js, "Dirent", 6));
			gc_register_root(&g_dirent_proto);
			}

			static ant_value_t fs_callback_success_handler(ant_t js, ant_value_t args, int nargs) {
			ant_value_t ctx = js_get_slot(js_getcurrentfunc(js), SLOT_DATA);
			ant_value_t callback = js_get_slot(ctx, SLOT_DATA);

			if (!is_callable(callback)) return js_mkundef();

			if (js_truthy(js, js_get(js, ctx, "existsStyle"))) {
			ant_value_t cb_args[1] = { nargs > 0 ? args[0] : js_false };
			fs_call_value(js, callback, js_mkundef(), cb_args, 1);
			return js_mkundef();
			}

			ant_value_t cb_args[2] = { js_mknull(), nargs > 0 ? args[0] : js_mkundef() };
			fs_call_value(js, callback, js_mkundef(), cb_args, 2);
			return js_mkundef();
			}

			static ant_value_t fs_callback_error_handler(ant_t js, ant_value_t args, int nargs) {
			ant_value_t ctx = js_get_slot(js_getcurrentfunc(js), SLOT_DATA);
			ant_value_t callback = js_get_slot(ctx, SLOT_DATA);
			ant_value_t cb_args[1];

			if (!is_callable(callback)) return js_mkundef();

			if (js_truthy(js, js_get(js, ctx, "existsStyle"))) {
			cb_args[0] = js_false;
			fs_call_value(js, callback, js_mkundef(), cb_args, 1);
			return js_mkundef();
			}

			cb_args[0] = nargs > 0 ? args[0] : js_mkundef();
			fs_call_value(js, callback, js_mkundef(), cb_args, 1);
			return js_mkundef();
			}

			static void fs_callback_emit_success(
			ant_t *js,
			ant_value_t callback,
			bool exists_style,
			ant_value_t value
			) {
			if (exists_style) {
			ant_value_t cb_args[1] = { value };
			fs_call_value(js, callback, js_mkundef(), cb_args, 1);
			return;
			}

			ant_value_t cb_args[2] = { js_mknull(), value };
			fs_call_value(js, callback, js_mkundef(), cb_args, 2);
			}

			static void fs_callback_emit_error(
			ant_t *js,
			ant_value_t callback,
			bool exists_style,
			ant_value_t error
			) {
			ant_value_t cb_args[1];

			cb_args[0] = exists_style ? js_false : error;
			fs_call_value(js, callback, js_mkundef(), cb_args, 1);
			}

			static ant_value_t fs_callback_attach_promise(
			ant_t *js,
			ant_value_t promise,
			ant_value_t callback,
			bool exists_style
			) {
			GC_ROOT_SAVE(root_mark, js);
			ant_value_t success_fn = js_mkundef();
			ant_value_t error_fn = js_mkundef();

			GC_ROOT_PIN(js, promise);
			GC_ROOT_PIN(js, callback);

			ant_value_t success_ctx = js_mkobj(js);
			GC_ROOT_PIN(js, success_ctx);
			ant_value_t error_ctx = js_mkobj(js);
			GC_ROOT_PIN(js, error_ctx);

			js_set_slot(success_ctx, SLOT_DATA, callback);
			js_set_slot(error_ctx, SLOT_DATA, callback);
			if (exists_style) {
			js_set(js, success_ctx, "existsStyle", js_true);
			js_set(js, error_ctx, "existsStyle", js_true);
			}

			success_fn = js_heavy_mkfun(js, fs_callback_success_handler, success_ctx);
			GC_ROOT_PIN(js, success_fn);
			error_fn = js_heavy_mkfun(js, fs_callback_error_handler, error_ctx);
			GC_ROOT_PIN(js, error_fn);

			js_promise_then(js, promise, success_fn, error_fn);
			GC_ROOT_RESTORE(js, root_mark);
			return js_mkundef();
			}

			static ant_value_t fs_callback_wrapper_call(ant_t js, ant_value_t args, int nargs) {
			GC_ROOT_SAVE(root_mark, js);
			ant_value_t wrapper = js_getcurrentfunc(js);
			ant_value_t config = js_get_slot(wrapper, SLOT_DATA);
			ant_value_t original = js_get_slot(config, SLOT_DATA);

			ant_value_t callback = js_mkundef();
			ant_value_t result = js_mkundef();
			ant_value_t this_arg = js_getthis(js);
			ant_value_t ex = js_mkundef();

			bool exists_style = false;
			int call_nargs = nargs;

			GC_ROOT_PIN(js, original);
			GC_ROOT_PIN(js, this_arg);

			exists_style = js_truthy(js, js_get(js, config, "existsStyle"));
			if (nargs > 0 && is_callable(args[nargs - 1])) {
			callback = args[nargs - 1];
			GC_ROOT_PIN(js, callback);
			call_nargs--;
			}

			result = fs_call_value(js, original, this_arg, args, call_nargs);
			GC_ROOT_PIN(js, result);

			if (!is_callable(callback)) {
			GC_ROOT_RESTORE(js, root_mark);
			return result;
			}

			if (is_err(result) \|\| js->thrown_exists) {
			ex = js->thrown_exists ? js->thrown_value : result;
			GC_ROOT_PIN(js, ex);
			js->thrown_exists = false;
			js->thrown_value = js_mkundef();
			js->thrown_stack = js_mkundef();
			fs_callback_emit_error(js, callback, exists_style, ex);
			GC_ROOT_RESTORE(js, root_mark);
			return js_mkundef();
			}

			if (vtype(result) != T_PROMISE) {
			fs_callback_emit_success(js, callback, exists_style, result);
			GC_ROOT_RESTORE(js, root_mark);
			return js_mkundef();
			}

			ant_value_t attach_result = fs_callback_attach_promise(js, result, callback, exists_style);
			GC_ROOT_RESTORE(js, root_mark);
			return attach_result;
			}

			static ant_value_t fs_make_callback_wrapper(ant_t *js, ant_value_t original, bool exists_style) {
			ant_value_t config = js_mkobj(js);

			js_set_slot(config, SLOT_DATA, original);
			if (exists_style) js_set(js, config, "existsStyle", js_true);
			return js_heavy_mkfun(js, fs_callback_wrapper_call, config);
			}

			static void fs_set_promise_methods(ant_t *js, ant_value_t lib) {
			js_set(js, lib, "appendFile", js_mkfun(builtin_fs_appendFile));
			js_set(js, lib, "cp", js_mkfun(builtin_fs_cp));
			js_set(js, lib, "copyFile", js_mkfun(builtin_fs_copyFile));
			js_set(js, lib, "readFile", js_mkfun(builtin_fs_readFile));
			js_set(js, lib, "open", js_mkfun(builtin_fs_open_filehandle));
			js_set(js, lib, "close", js_mkfun(builtin_fs_close_fd));
			js_set(js, lib, "writeFile", js_mkfun(builtin_fs_writeFile));
			js_set(js, lib, "write", js_mkfun(builtin_fs_write_fd));
			js_set(js, lib, "writev", js_mkfun(builtin_fs_writev_fd));
			js_set(js, lib, "rename", js_mkfun(builtin_fs_rename));
			js_set(js, lib, "rm", js_mkfun(builtin_fs_rm));
			js_set(js, lib, "unlink", js_mkfun(builtin_fs_unlink));
			js_set(js, lib, "mkdir", js_mkfun(builtin_fs_mkdir));
			js_set(js, lib, "mkdtemp", js_mkfun(builtin_fs_mkdtemp));
			js_set(js, lib, "rmdir", js_mkfun(builtin_fs_rmdir));
			js_set(js, lib, "stat", js_mkfun(builtin_fs_stat));
			js_set(js, lib, "lstat", js_mkfun(builtin_fs_lstat));
			js_set(js, lib, "fstat", js_mkfun(builtin_fs_fstat));
			js_set(js, lib, "utimes", js_mkfun(builtin_fs_utimes));
			js_set(js, lib, "futimes", js_mkfun(builtin_fs_futimes));
			js_set(js, lib, "exists", js_mkfun(builtin_fs_exists));
			js_set(js, lib, "access", js_mkfun(builtin_fs_access));
			js_set(js, lib, "chmod", js_mkfun(builtin_fs_chmod));
			js_set(js, lib, "readdir", js_mkfun(builtin_fs_readdir));
			js_set(js, lib, "realpath", js_mkfun(builtin_fs_realpath));
			js_set(js, lib, "readlink", js_mkfun(builtin_fs_readlink));
			}

			static void fs_set_callback_compatible_methods(ant_t *js, ant_value_t lib) {
			ant_value_t realpath = fs_make_callback_wrapper(js, js_mkfun(builtin_fs_realpath), false);

			js_set(js, lib, "appendFile", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_appendFile), false));
			js_set(js, lib, "cp", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_cp), false));
			js_set(js, lib, "copyFile", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_copyFile), false));
			js_set(js, lib, "readFile", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_readFile), false));
			js_set(js, lib, "open", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_open_fd), false));
			js_set(js, lib, "close", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_close_fd), false));
			js_set(js, lib, "writeFile", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_writeFile), false));
			js_set(js, lib, "write", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_write_fd), false));
			js_set(js, lib, "writev", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_writev_fd), false));
			js_set(js, lib, "rename", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_rename), false));
			js_set(js, lib, "rm", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_rm), false));
			js_set(js, lib, "unlink", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_unlink), false));
			js_set(js, lib, "mkdir", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_mkdir), false));
			js_set(js, lib, "mkdtemp", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_mkdtemp), false));
			js_set(js, lib, "rmdir", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_rmdir), false));
			js_set(js, lib, "stat", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_stat), false));
			js_set(js, lib, "lstat", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_lstat), false));
			js_set(js, lib, "fstat", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_fstat), false));
			js_set(js, lib, "utimes", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_utimes), false));
			js_set(js, lib, "futimes", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_futimes), false));
			js_set(js, lib, "exists", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_exists), true));
			js_set(js, lib, "access", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_access), false));
			js_set(js, lib, "chmod", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_chmod), false));
			js_set(js, lib, "readdir", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_readdir), false));
			js_set(js, lib, "readlink", fs_make_callback_wrapper(js, js_mkfun(builtin_fs_readlink), false));

			js_set(js, realpath, "native", realpath);
			js_set(js, lib, "realpath", realpath);
			}

			static ant_value_t fs_make_constants(ant_t *js) {
			ant_value_t constants = js_newobj(js);
			js_set(js, constants, "F_OK", js_mknum(F_OK));
			js_set(js, constants, "R_OK", js_mknum(R_OK));
			js_set(js, constants, "W_OK", js_mknum(W_OK));
			js_set(js, constants, "X_OK", js_mknum(X_OK));
			js_set(js, constants, "O_RDONLY", js_mknum(O_RDONLY));
			js_set(js, constants, "O_WRONLY", js_mknum(O_WRONLY));
			js_set(js, constants, "O_RDWR", js_mknum(O_RDWR));
			js_set(js, constants, "O_CREAT", js_mknum(O_CREAT));
			js_set(js, constants, "O_EXCL", js_mknum(O_EXCL));
			js_set(js, constants, "O_TRUNC", js_mknum(O_TRUNC));
			js_set(js, constants, "O_APPEND", js_mknum(O_APPEND));
			#ifdef O_SYMLINK
			js_set(js, constants, "O_SYMLINK", js_mknum(O_SYMLINK));
			#endif
			#ifdef O_NOFOLLOW
			js_set(js, constants, "O_NOFOLLOW", js_mknum(O_NOFOLLOW));
			#endif
			#ifdef S_IFMT
			js_set(js, constants, "S_IFMT", js_mknum(S_IFMT));
			#endif
			#ifdef S_IFREG
			js_set(js, constants, "S_IFREG", js_mknum(S_IFREG));
			#endif
			#ifdef S_IFDIR
			js_set(js, constants, "S_IFDIR", js_mknum(S_IFDIR));
			#endif
			#ifdef S_IFLNK
			js_set(js, constants, "S_IFLNK", js_mknum(S_IFLNK));
			#endif
			return constants;
			}

			static ant_value_t builtin_fs_promises_getter(ant_t js, ant_value_t args, int nargs) {
			ant_value_t getter_fn = js_getcurrentfunc(js);
			ant_value_t cached = js_get_slot(getter_fn, SLOT_DATA);
			if (is_object_type(cached)) return cached;

			ant_value_t promises = fs_promises_library(js);
			js_set_slot(getter_fn, SLOT_DATA, promises);
			return promises;
			}

			ant_value_t fs_library(ant_t *js) {
			ant_value_t lib = js_mkobj(js);
			ant_value_t realpath_sync = js_heavy_mkfun(js, builtin_fs_realpathSync, js_mkundef());

			fs_set_callback_compatible_methods(js, lib);
			fs_init_watch_constructors(js);
			fs_init_stream_constructors(js);

			js_set(js, lib, "read", js_mkfun(builtin_fs_read_fd));
			js_set(js, lib, "readFileSync", js_mkfun(builtin_fs_readFileSync));
			js_set(js, lib, "readSync", js_mkfun(builtin_fs_readSync));
			js_set(js, lib, "stream", js_mkfun(builtin_fs_readBytes));
			js_set(js, lib, "createReadStream", js_mkfun(builtin_fs_createReadStream));
			js_set(js, lib, "createWriteStream", js_mkfun(builtin_fs_createWriteStream));
			js_set(js, lib, "openSync", js_mkfun(builtin_fs_openSync));
			js_set(js, lib, "closeSync", js_mkfun(builtin_fs_closeSync));
			js_set(js, lib, "writeFileSync", js_mkfun(builtin_fs_writeFileSync));
			js_set(js, lib, "writeSync", js_mkfun(builtin_fs_writeSync));
			js_set(js, lib, "writevSync", js_mkfun(builtin_fs_writevSync));
			js_set(js, lib, "appendFileSync", js_mkfun(builtin_fs_appendFileSync));
			js_set(js, lib, "cpSync", js_mkfun(builtin_fs_cpSync));
			js_set(js, lib, "copyFileSync", js_mkfun(builtin_fs_copyFileSync));
			js_set(js, lib, "renameSync", js_mkfun(builtin_fs_renameSync));
			js_set(js, lib, "rmSync", js_mkfun(builtin_fs_rmSync));
			js_set(js, lib, "unlinkSync", js_mkfun(builtin_fs_unlinkSync));
			js_set(js, lib, "mkdirSync", js_mkfun(builtin_fs_mkdirSync));
			js_set(js, lib, "mkdtempSync", js_mkfun(builtin_fs_mkdtempSync));
			js_set(js, lib, "rmdirSync", js_mkfun(builtin_fs_rmdirSync));
			js_set(js, lib, "statSync", js_mkfun(builtin_fs_statSync));
			js_set(js, lib, "lstatSync", js_mkfun(builtin_fs_lstatSync));
			js_set(js, lib, "fstatSync", js_mkfun(builtin_fs_fstatSync));
			js_set(js, lib, "utimesSync", js_mkfun(builtin_fs_utimesSync));
			js_set(js, lib, "futimesSync", js_mkfun(builtin_fs_futimesSync));
			js_set(js, lib, "existsSync", js_mkfun(builtin_fs_existsSync));
			js_set(js, lib, "accessSync", js_mkfun(builtin_fs_accessSync));
			js_set(js, lib, "chmodSync", js_mkfun(builtin_fs_chmodSync));
			js_set(js, lib, "readdirSync", js_mkfun(builtin_fs_readdirSync));
			js_set(js, lib, "realpathSync", realpath_sync);
			js_set(js, lib, "readlinkSync", js_mkfun(builtin_fs_readlinkSync));
			js_set(js, lib, "watch", js_mkfun(builtin_fs_watch));
			js_set(js, lib, "watchFile", js_mkfun(builtin_fs_watchFile));
			js_set(js, lib, "unwatchFile", js_mkfun(builtin_fs_unwatchFile));
			js_set(js, lib, "FSWatcher", g_fswatcher_ctor);
			js_set(js, lib, "ReadStream", g_readstream_ctor);
			js_set(js, lib, "WriteStream", g_writestream_ctor);
			js_set(js, realpath_sync, "native", realpath_sync);

			js_set_getter_desc(
			js, lib,
			"promises", 8,
			js_heavy_mkfun(js, builtin_fs_promises_getter, js_mkundef()),
			JS_DESC_E \| JS_DESC_C
			);

			js_set(js, lib, "constants", fs_make_constants(js));
			js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "fs", 2));

			return lib;
			}

			ant_value_t fs_promises_library(ant_t *js) {
			ant_value_t lib = js_mkobj(js);

			fs_set_promise_methods(js, lib);
			js_set(js, lib, "constants", fs_make_constants(js));

			js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "fs/promises", 11));
			return lib;
			}

			ant_value_t fs_constants_library(ant_t *js) {
			ant_value_t constants = fs_make_constants(js);
			js_set(js, constants, "default", constants);
			js_set_slot_wb(js, constants, SLOT_DEFAULT, constants);
			js_set_sym(js, constants, get_toStringTag_sym(), js_mkstr(js, "constants", 9));
			return constants;
			}

			int has_pending_fs_ops(void) {
			return pending_requests && utarray_len(pending_requests) > 0;
			}

			void gc_mark_fs(ant_t *js, gc_mark_fn mark) {
			fs_watcher_t *watcher = NULL;

			if (g_fswatcher_proto) mark(js, g_fswatcher_proto);
			if (g_fswatcher_ctor) mark(js, g_fswatcher_ctor);
			if (g_filehandle_proto) mark(js, g_filehandle_proto);
			if (g_readstream_proto) mark(js, g_readstream_proto);
			if (g_readstream_ctor) mark(js, g_readstream_ctor);
			if (g_writestream_proto) mark(js, g_writestream_proto);
			if (g_writestream_ctor) mark(js, g_writestream_ctor);
			if (!pending_requests) return;

			unsigned int len = utarray_len(pending_requests);
			for (unsigned int i = 0; i < len; i++) {
			fs_request_t reqp = (fs_request_t )utarray_eltptr(pending_requests, i);
			if (reqp && *reqp) {
			mark(js, (*reqp)->promise);
			if (is_object_type((reqp)->target_buffer)) mark(js, (reqp)->target_buffer);
			if (is_callable((reqp)->callback_fn)) mark(js, (reqp)->callback_fn);
			}}

			for (watcher = active_watchers; watcher; watcher = watcher->next_active) {
			if (vtype(watcher->obj) == T_OBJ) mark(js, watcher->obj);
			if (vtype(watcher->callback) != T_UNDEF) mark(js, watcher->callback);
			}
			}

Owner Packages

No Owners

ant/src/modules/fs.c899dad6b8a9etype-hints-typescript

fs.cView Options

Owner Packages

ant/src/modules/fs.c
899dad6b8a9etype-hints-typescript

fs.c
View Options