@scriptc/cli-darwin-x64 0.2.2 → 0.2.3

package/dist/lib/runtime-sources/src/scr_lib.c

@@ -27,6 +27,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#if defined(__linux__)
+#include <sys/vfs.h>
+#elif defined(__APPLE__) || defined(__FreeBSD__)
+#include <sys/mount.h>
+#elif !defined(_WIN32) && !defined(__wasi__)
+#include <sys/statvfs.h>
+#endif
 #include <time.h>
 
 #ifdef _WIN32
@@ -55,6 +62,8 @@
 
 static WCHAR *scr_fs_win_wide(const ScrStr *path);
 static int scr_fs_win_errno(DWORD error);
+static bool scr_stats_is_link_tag(DWORD tag);
+static bool scr_stats_link_target(HANDLE h, DWORD tag, double *size_out, ScrStr **text_out);
 
 static ScrStr *scr_fs_win_utf8(const WCHAR *text, size_t length) {
   if (length > INT_MAX) { SetLastError(ERROR_FILENAME_EXCED_RANGE); return NULL; }
@@ -869,10 +878,12 @@ ScrDyn *scr_util_parse_env(const ScrDyn *content) {
   return scr_env_parse_content(content->v.str, true);
 }
 
-static void scr_env_invalid_path(const ScrDyn *value, const ScrStr *path) {
+void scr_fs_invalid_named_path(const ScrDyn *value, const ScrStr *path, const char *name) {
   ScrJsonBuf b;
   scr_jb_init(&b);
-  scr_jb_puts(&b, "The argument 'path' must be a string, Uint8Array, or URL without null bytes. Received ");
+  scr_jb_puts(&b, "The argument '");
+  scr_jb_puts(&b, name);
+  scr_jb_puts(&b, "' must be a string, Uint8Array, or URL without null bytes. Received ");
   if (value->kind == SCR_DYN_BYTES) {
     const ScrBytes *bytes = value->v.bytes;
     if (value->buffer) {
@@ -916,6 +927,10 @@ static void scr_env_invalid_path(const ScrDyn *value, const ScrStr *path) {
   scr_str_release(message);
 }
 
+void scr_fs_invalid_path(const ScrDyn *value, const ScrStr *path) {
+  scr_fs_invalid_named_path(value, path, "path");
+}
+
 void scr_process_load_env_file(const ScrDyn *value) {
   ScrStr *path;
   if (value->kind == SCR_DYN_UNDEF || value->kind == SCR_DYN_NULL) path = scr_str_new("./.env", 6);
@@ -928,7 +943,7 @@ void scr_process_load_env_file(const ScrDyn *value) {
   }
   if (!path) return;
   if (memchr(path->data, 0, path->len)) {
-    scr_env_invalid_path(value, path);
+    scr_fs_invalid_path(value, path);
     scr_str_release(path);
     return;
   }
@@ -2501,7 +2516,45 @@ void scr_fs_mkdir_mode(ScrStr *path, double mode) {
   if (scr_sys_mkdir(path->data, (mode_t)mode) != 0) scr_fs_throw(errno, "mkdir", path);
 }
 
+#ifdef _WIN32
+/* The CRT's stat follows junctions. Recognize real link reparse records
+ * before unlink/rm dispatch so a tree walk never descends into their targets.
+ * Return 1 for a removed link, 0 for an ordinary entry, -1 on failure. */
+static int scr_fs_win_remove_link(const char *path, size_t len) {
+  ScrStr *text = scr_str_new(path, len);
+  WCHAR *wide = scr_fs_win_wide(text);
+  scr_str_release(text);
+  if (!wide) { errno = scr_fs_win_errno(GetLastError()); return -1; }
+  DWORD attributes = GetFileAttributesW(wide);
+  if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_REPARSE_POINT)) { free(wide); return 0; }
+  HANDLE h = CreateFileW(wide, FILE_READ_ATTRIBUTES,
+    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
+    FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
+  if (h == INVALID_HANDLE_VALUE) { DWORD error = GetLastError(); free(wide); errno = scr_fs_win_errno(error); return -1; }
+  FILE_ATTRIBUTE_TAG_INFO tagged;
+  if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tagged, sizeof tagged)) {
+    DWORD error = GetLastError(); CloseHandle(h); free(wide); errno = scr_fs_win_errno(error); return -1;
+  }
+  double size;
+  bool link = scr_stats_is_link_tag(tagged.ReparseTag);
+  // Mount-point tags also represent mounted volumes. Only junction payloads
+  // are links; keep the existing ordinary-directory behavior for volumes.
+  if (link && tagged.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) link = scr_stats_link_target(h, tagged.ReparseTag, &size, NULL);
+  CloseHandle(h);
+  if (!link) { free(wide); return 0; }
+  BOOL ok = attributes & FILE_ATTRIBUTE_DIRECTORY ? RemoveDirectoryW(wide) : DeleteFileW(wide);
+  DWORD error = ok ? 0 : GetLastError();
+  free(wide);
+  if (!ok) { errno = scr_fs_win_errno(error); return -1; }
+  return 1;
+}
+#endif
+
 void scr_fs_unlink(ScrStr *path) {
+#ifdef _WIN32
+  int link = scr_fs_win_remove_link(path->data, path->len);
+  if (link != 0) { if (link < 0) scr_fs_throw(errno, "unlink", path); return; }
+#endif
   if (unlink(path->data) != 0) scr_fs_throw(errno, "unlink", path);
 }
 
@@ -2665,6 +2718,80 @@ void scr_fs_ftruncate(double fd, double length) {
 #endif
 }
 
+#ifdef _WIN32
+static bool scr_fs_set_times(HANDLE handle, double access, double modified) {
+  FILETIME atime, mtime, now;
+  if (isinf(access) || isinf(modified)) GetSystemTimeAsFileTime(&now);
+  double values[2] = { access, modified };
+  FILETIME *files[2] = { &atime, &mtime };
+  for (size_t i = 0; i < 2; i++) {
+    if (isnan(values[i])) { files[i] = NULL; continue; }
+    if (isinf(values[i])) { *files[i] = now; continue; }
+    double ticks = values[i] * 10000000.0 + 116444736000000000.0;
+    if (ticks < -9223372036854775808.0 || ticks >= 9223372036854775808.0) {
+      SetLastError(ERROR_INVALID_PARAMETER);
+      return false;
+    }
+    int64_t time = (int64_t)ticks;
+    files[i]->dwLowDateTime = (DWORD)(uint64_t)time;
+    files[i]->dwHighDateTime = (DWORD)((uint64_t)time >> 32);
+  }
+  return SetFileTime(handle, NULL, files[0], files[1]) != 0;
+}
+
+static DWORD scr_fs_set_path_times(WCHAR *path, double atime, double mtime, bool nofollow) {
+  DWORD flags = FILE_FLAG_BACKUP_SEMANTICS | (nofollow ? FILE_FLAG_OPEN_REPARSE_POINT : 0);
+  HANDLE handle = CreateFileW(path, FILE_WRITE_ATTRIBUTES,
+    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, flags, NULL);
+  if (handle == INVALID_HANDLE_VALUE) return GetLastError();
+  DWORD error = scr_fs_set_times(handle, atime, mtime) ? 0 : GetLastError();
+  CloseHandle(handle);
+  return error;
+}
+#else
+/* Match the pinned libuv conversion: microsecond truncation, normalized
+ * negative fractions, and the special current/unchanged time sentinels. */
+static bool scr_fs_timespec(double time, struct timespec *out) {
+  if (isinf(time)) { *out = (struct timespec){ 0, UTIME_NOW }; return true; }
+  if (isnan(time)) { *out = (struct timespec){ 0, UTIME_OMIT }; return true; }
+  if (time < -9223372036854775808.0 || time >= 9223372036854775808.0) return false;
+  out->tv_sec = (time_t)time;
+  out->tv_nsec = (long)((time - (double)out->tv_sec) * 1000000000.0);
+  out->tv_nsec -= out->tv_nsec % 1000;
+  if (out->tv_nsec < 0) { out->tv_nsec += 1000000000; out->tv_sec--; }
+  return true;
+}
+#endif
+
+void scr_fs_utimes(ScrStr *path, double atime, double mtime, bool nofollow) {
+  const char *op = nofollow ? "lutime" : "utime";
+#ifdef _WIN32
+  WCHAR *wide = scr_fs_win_wide(path);
+  if (!wide) { scr_fs_throw(scr_fs_win_errno(GetLastError()), op, path); return; }
+  DWORD error = scr_fs_set_path_times(wide, atime, mtime, nofollow);
+  if (nofollow && (error == ERROR_SYMLINK_NOT_SUPPORTED || error == ERROR_NOT_A_REPARSE_POINT))
+    error = scr_fs_set_path_times(wide, atime, mtime, false);
+  free(wide);
+  if (error) scr_fs_throw(scr_fs_win_errno(error), op, path);
+#else
+  struct timespec times[2];
+  if (!scr_fs_timespec(atime, &times[0]) || !scr_fs_timespec(mtime, &times[1])) { scr_fs_throw(EINVAL, op, path); return; }
+  if (utimensat(AT_FDCWD, path->data, times, nofollow ? AT_SYMLINK_NOFOLLOW : 0) != 0) scr_fs_throw(errno, op, path);
+#endif
+}
+
+void scr_fs_futimes(double fd, double atime, double mtime) {
+#ifdef _WIN32
+  HANDLE handle = (HANDLE)_get_osfhandle((int)fd);
+  if (handle == INVALID_HANDLE_VALUE) { scr_fs_throw_nopath(EBADF, "futime"); return; }
+  if (!scr_fs_set_times(handle, atime, mtime)) scr_fs_throw_nopath(scr_fs_win_errno(GetLastError()), "futime");
+#else
+  struct timespec times[2];
+  if (!scr_fs_timespec(atime, &times[0]) || !scr_fs_timespec(mtime, &times[1])) { scr_fs_throw_nopath(EINVAL, "futime"); return; }
+  if (futimens((int)fd, times) != 0) scr_fs_throw_nopath(errno, "futime");
+#endif
+}
+
 /* fs.closeSync(fd) — close(2); failure throws Node's path-less fs error
  * shape ("EBADF: bad file descriptor, close"). */
 
@@ -3165,18 +3292,15 @@ void scr_fs_link(ScrStr *source, ScrStr *dest) {
   WCHAR *from = scr_fs_win_wide(source);
   WCHAR *to = scr_fs_win_wide(dest);
   if (!from || !to) {
+    DWORD error = GetLastError();
     free(from); free(to);
-    scr_fs_throw2(EINVAL, "link", source, dest);
+    scr_fs_throw2(scr_fs_win_errno(error), "link", source, dest);
     return;
   }
   BOOL ok = CreateHardLinkW(to, from, NULL);
   DWORD error = ok ? 0 : GetLastError();
   free(from); free(to);
-  if (!ok) {
-    int code = error == ERROR_ALREADY_EXISTS || error == ERROR_FILE_EXISTS ? EEXIST :
-      error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND ? ENOENT : EACCES;
-    scr_fs_throw2(code, "link", source, dest);
-  }
+  if (!ok) scr_fs_throw2(scr_fs_win_errno(error), "link", source, dest);
 #else
   if (link(source->data, dest->data) != 0) scr_fs_throw2(errno, "link", source, dest);
 #endif
@@ -3347,6 +3471,10 @@ void scr_fs_rename(ScrStr *oldpath, ScrStr *newpath) {
 static int scr_rm_unlink(const char *path, size_t len);
 
 void scr_fs_rm(ScrStr *path) {
+#ifdef _WIN32
+  int link = scr_fs_win_remove_link(path->data, path->len);
+  if (link != 0) { if (link < 0) scr_fs_throw(errno, "unlink", path); return; }
+#endif
   /* Node's rmSync: lstat first (a missing path reports the lstat syscall),
    * refuse directories (Node requires `recursive`, which the scriptc
    * surface doesn't declare — the message wording diverges from Node's
@@ -3501,6 +3629,10 @@ static int scr_rm_unlink(const char *path, size_t len) {
 /* Post-order tree removal for rmSync's recursive form. Stops at (and
  * records) the first failure, with the failing path and syscall name. */
 static void scr_rm_tree_e(const char *path, size_t len, ScrRmFail *f) {
+#ifdef _WIN32
+  int link = scr_fs_win_remove_link(path, len);
+  if (link != 0) { if (link < 0) scr_rm_fail_set(f, errno, "unlink", path, len); return; }
+#endif
   struct stat st;
   if (lstat(path, &st) != 0) {
     scr_rm_fail_set(f, errno, "lstat", path, len);
@@ -3541,6 +3673,10 @@ static void scr_rm_tree_e(const char *path, size_t len, ScrRmFail *f) {
  * force's ENOENT swallow, the non-recursive directory rejection, and the
  * tree walk — failures recorded in `f`, never thrown. */
 static void scr_fs_rm_attempt(ScrStr *path, bool recursive, bool force, ScrRmFail *f) {
+#ifdef _WIN32
+  int link = scr_fs_win_remove_link(path->data, path->len);
+  if (link != 0) { if (link < 0) scr_rm_fail_set(f, errno, "unlink", path->data, path->len); return; }
+#endif
   struct stat st;
   if (lstat(path->data, &st) != 0) {
     if (force && errno == ENOENT) return; /* Node: force swallows ENOENT */
@@ -3994,7 +4130,7 @@ typedef struct {
 /* Node/libuv reports a Windows link's target-text length as st_size. The
  * ordinary handle information does not carry that value, so read the reparse
  * payload while the no-follow handle is live. */
-static bool scr_stats_link_size(HANDLE h, DWORD tag, double *size_out) {
+static bool scr_stats_link_target(HANDLE h, DWORD tag, double *size_out, ScrStr **text_out) {
   union {
     ScrStatsReparseData align;
     unsigned char bytes[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
@@ -4039,6 +4175,7 @@ static bool scr_stats_link_size(HANDLE h, DWORD tag, double *size_out) {
     /* WSL's LX symlink payload is a version word followed by UTF-8 bytes. */
     if (data->data_len < sizeof(ULONG)) return false;
     *size_out = (double)(data->data_len - sizeof(ULONG));
+    if (text_out) *text_out = scr_str_new((const char *)data->body.generic.bytes + sizeof(ULONG), data->data_len - sizeof(ULONG));
     return true;
   } else {
     /* App execution links carry a counted UTF-16 string list; the third
@@ -4067,6 +4204,10 @@ static bool scr_stats_link_size(HANDLE h, DWORD tag, double *size_out) {
     double size = scr_stats_utf16_len(target, len);
     if (size < 0) return false;
     *size_out = size;
+    if (text_out) {
+      *text_out = scr_fs_win_utf8(target, len);
+      if (!*text_out) return false;
+    }
     return true;
   }
 
@@ -4092,6 +4233,10 @@ static bool scr_stats_link_size(HANDLE h, DWORD tag, double *size_out) {
   double size = scr_stats_utf16_len(target, len);
   if (size < 0) return false;
   *size_out = size;
+  if (text_out) {
+    *text_out = scr_fs_win_utf8(target, len);
+    if (!*text_out) return false;
+  }
   return true;
 }
 
@@ -4105,8 +4250,21 @@ static ScrStats *scr_stats_of_path(const ScrStr *path, const char *op,
   HANDLE h = CreateFileW(wide, FILE_READ_ATTRIBUTES,
                          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                          NULL, OPEN_EXISTING, flags, NULL);
+  if (h == INVALID_HANDLE_VALUE) {
+    DWORD error = GetLastError();
+    DWORD attributes = GetFileAttributesW(wide);
+    free(wide);
+    /* CRT stat can report the link entry when its target cannot be opened,
+     * hiding dangling links and Windows file/directory type mismatches.
+     * libuv preserves the failed follow operation for reparse points. */
+    if (!no_follow && attributes != INVALID_FILE_ATTRIBUTES &&
+        (attributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
+      scr_fs_throw(scr_fs_win_errno(error), op, path);
+      return NULL;
+    }
+    return scr_stats_crt_fallback(path, op);
+  }
   free(wide);
-  if (h == INVALID_HANDLE_VALUE) return scr_stats_crt_fallback(path, op);
 
   DWORD file_type = GetFileType(h);
   if (file_type != FILE_TYPE_DISK) {
@@ -4130,7 +4288,7 @@ static ScrStats *scr_stats_of_path(const ScrStr *path, const char *op,
       CloseHandle(h);
       return scr_stats_of_path(path, op, false);
     }
-    if (!scr_stats_link_size(h, tagged.ReparseTag, &link_size)) {
+    if (!scr_stats_link_target(h, tagged.ReparseTag, &link_size, NULL)) {
       /* A mount-point tag may name a mounted volume rather than a junction.
        * libuv treats those (and malformed/unsupported link payloads) as
        * ordinary reparse points and retries with the final component
@@ -4207,6 +4365,215 @@ static ScrStats *scr_stats_of(const struct stat *st) {
 }
 #endif
 
+/* Symbolic link targets are stored verbatim on POSIX. Windows junctions
+ * instead carry an absolute NT path in a bounded mount-point reparse record. */
+#ifdef _WIN32
+static DWORD scr_fs_win_junction(const WCHAR *target, const WCHAR *destination) {
+  size_t len = wcslen(target);
+  /* libuv permits drive-absolute junctions, not UNC mount targets. */
+  size_t skip = len >= 4 && !wcsncmp(target, L"\\\\?\\", 4) ? 4 : 0;
+  const WCHAR *plain = target + skip;
+  size_t chars = len - skip;
+  if (chars < 3 || !((plain[0] >= L'A' && plain[0] <= L'Z') || (plain[0] >= L'a' && plain[0] <= L'z')) || plain[1] != L':' || plain[2] != L'\\') return ERROR_INVALID_PARAMETER;
+  size_t fixed = offsetof(ScrStatsReparseData, body.mount.path);
+  size_t total = fixed + (4 + chars + 1 + chars + 1) * sizeof(WCHAR);
+  if (total > MAXIMUM_REPARSE_DATA_BUFFER_SIZE) return ERROR_FILENAME_EXCED_RANGE;
+  ScrStatsReparseData *data = calloc(1, total);
+  if (!data) return ERROR_NOT_ENOUGH_MEMORY;
+  data->tag = IO_REPARSE_TAG_MOUNT_POINT;
+  data->data_len = (USHORT)(total - offsetof(ScrStatsReparseData, body));
+  data->body.mount.substitute_offset = 0;
+  data->body.mount.substitute_len = (USHORT)((4 + chars) * sizeof(WCHAR));
+  data->body.mount.print_offset = (USHORT)((4 + chars + 1) * sizeof(WCHAR));
+  data->body.mount.print_len = (USHORT)(chars * sizeof(WCHAR));
+  memcpy(data->body.mount.path, L"\\??\\", 4 * sizeof(WCHAR));
+  memcpy(data->body.mount.path + 4, plain, chars * sizeof(WCHAR));
+  memcpy(data->body.mount.path + 4 + chars + 1, plain, chars * sizeof(WCHAR));
+  DWORD error = 0, used;
+  bool created = CreateDirectoryW(destination, NULL) != 0;
+  HANDLE h = INVALID_HANDLE_VALUE;
+  if (!created) error = GetLastError();
+  else {
+    h = CreateFileW(destination, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+                    FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
+    if (h == INVALID_HANDLE_VALUE) error = GetLastError();
+    else if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, data, (DWORD)total, NULL, 0, &used, NULL)) error = GetLastError();
+  }
+  if (h != INVALID_HANDLE_VALUE) CloseHandle(h);
+  if (error && created) RemoveDirectoryW(destination);
+  free(data);
+  return error;
+}
+#endif
+
+#ifdef _WIN32
+/* libuv keeps this fallback for later calls once Windows rejects the flag. */
+static DWORD scr_fs_symlink_usermode_flag = 0x2; /* ALLOW_UNPRIVILEGED_CREATE */
+#endif
+
+int scr_fs_symlink_infer(ScrStr *absolute) {
+#ifdef _WIN32
+  WCHAR *probe = scr_fs_win_wide(absolute);
+  DWORD attributes = probe ? GetFileAttributesW(probe) : INVALID_FILE_ATTRIBUTES;
+  free(probe);
+  return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
+#else
+  (void)absolute;
+  return 0;
+#endif
+}
+
+void scr_fs_symlink(ScrStr *target, ScrStr *destination, int kind) {
+#ifdef _WIN32
+  ScrArr *parts = scr_arr_new_ref(scr_str_retain_v, scr_str_release_v, NULL, 3);
+  scr_arr_push_ref(parts, scr_str_retain(destination));
+  scr_arr_push_ref(parts, scr_str_new("..", 2));
+  scr_arr_push_ref(parts, scr_str_retain(target));
+  ScrStr *absolute = scr_path_win32_resolve(parts);
+  scr_arr_release(parts);
+  if (kind == -1) kind = scr_fs_symlink_infer(absolute);
+  ScrStr *stored;
+  if (kind == 2) stored = scr_path_win32_to_namespaced_path(absolute);
+  else if (scr_path_win32_is_absolute(target)) stored = scr_path_win32_to_namespaced_path(target);
+  else {
+    char *text = malloc(target->len ? target->len : 1);
+    if (!text) scr_trap("scriptc: out of memory\n");
+    for (size_t i = 0; i < target->len; i++) text[i] = target->data[i] == '/' ? '\\' : target->data[i];
+    stored = scr_str_new(text, target->len);
+    free(text);
+  }
+  scr_str_release(absolute);
+  /* Node's binding namespaces the link path before passing it to libuv. */
+  ScrStr *link_path = scr_path_win32_to_namespaced_path(destination);
+  WCHAR *from = scr_fs_win_wide(stored), *to = scr_fs_win_wide(link_path);
+  DWORD error = !from || !to ? GetLastError() : 0;
+  if (!error && kind == 2) error = scr_fs_win_junction(from, to);
+  else if (!error) {
+    DWORD flags = (kind == 1 ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0) | scr_fs_symlink_usermode_flag;
+    if (!CreateSymbolicLinkW(to, from, flags)) {
+      error = GetLastError();
+      if (error == ERROR_INVALID_PARAMETER && scr_fs_symlink_usermode_flag) {
+        scr_fs_symlink_usermode_flag = 0;
+        error = CreateSymbolicLinkW(to, from, flags & ~0x2u) ? 0 : GetLastError();
+      }
+    }
+  }
+  free(from); free(to); scr_str_release(stored); scr_str_release(link_path);
+  if (error) scr_fs_throw2(scr_fs_win_errno(error), "symlink", target, destination);
+#else
+  (void)kind;
+  if (symlink(target->data, destination->data) != 0) scr_fs_throw2(errno, "symlink", target, destination);
+#endif
+}
+
+/* Keep the unsigned libuv statfs representation before selecting Number or
+ * BigInt. Free-space counts are live snapshots, not cached volume metadata. */
+ScrDyn *scr_fs_statfs(ScrStr *path, bool bigint) {
+  uint64_t fields[7];
+#if defined(_WIN32)
+  ScrStr *syscall_path = scr_path_win32_to_namespaced_path(path);
+  WCHAR *wide = scr_fs_win_wide(syscall_path);
+  scr_str_release(syscall_path);
+  if (!wide) { scr_fs_throw(scr_fs_win_errno(GetLastError()), "statfs", path); return NULL; }
+  DWORD sectors, bytes, free_clusters, total_clusters;
+  BOOL ok = GetDiskFreeSpaceW(wide, &sectors, &bytes, &free_clusters, &total_clusters);
+  DWORD error = ok ? 0 : GetLastError();
+  if (!ok && error == ERROR_DIRECTORY) {
+    /* libuv retries a file path's parent once, preserving the original path
+     * in errors. GetFullPathName also expands relative and drive paths. */
+    DWORD size = GetFullPathNameW(wide, 0, NULL, NULL);
+    WCHAR *absolute = size ? malloc((size_t)size * sizeof *absolute) : NULL;
+    if (size && !absolute) scr_trap("scriptc: out of memory\n");
+    WCHAR *part = NULL;
+    DWORD length = absolute ? GetFullPathNameW(wide, size, absolute, &part) : 0;
+    if (length && length < size) {
+      if (part) *part = L'\0';
+      ok = GetDiskFreeSpaceW(absolute, &sectors, &bytes, &free_clusters, &total_clusters);
+      if (!ok) error = GetLastError();
+    }
+    free(absolute);
+  }
+  free(wide);
+  if (!ok) { scr_fs_throw(scr_fs_win_errno(error), "statfs", path); return NULL; }
+  fields[0] = 0;
+  fields[1] = (DWORD)(bytes * sectors);
+  fields[2] = total_clusters;
+  fields[3] = fields[4] = free_clusters;
+  fields[5] = fields[6] = 0;
+#elif defined(__wasi__)
+  (void)path; (void)bigint;
+  static const char message[] = "Filesystem capacity queries have no native WASI syscall";
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+  return NULL;
+#else
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+  struct statfs snapshot;
+  if (statfs(path->data, &snapshot) != 0) { scr_fs_throw(errno, "statfs", path); return NULL; }
+  fields[0] = (uint64_t)snapshot.f_type;
+#else
+  struct statvfs snapshot;
+  if (statvfs(path->data, &snapshot) != 0) { scr_fs_throw(errno, "statfs", path); return NULL; }
+  fields[0] = 0;
+#endif
+  fields[1] = (uint64_t)snapshot.f_bsize;
+  fields[2] = (uint64_t)snapshot.f_blocks;
+  fields[3] = (uint64_t)snapshot.f_bfree;
+  fields[4] = (uint64_t)snapshot.f_bavail;
+  fields[5] = (uint64_t)snapshot.f_files;
+  fields[6] = (uint64_t)snapshot.f_ffree;
+#endif
+  static const char *names[] = { "type", "bsize", "blocks", "bfree", "bavail", "files", "ffree" };
+  ScrDyn *result = scr_dyn_new_obj();
+  for (size_t i = 0; i < 7; i++) {
+    ScrDyn *value;
+    if (bigint) {
+      ScrBigInt *number = scr_bigint_from_u64(fields[i]);
+      value = scr_dyn_new_bigint(number);
+      scr_bigint_release(number);
+    } else value = scr_dyn_new_num((double)fields[i]);
+    scr_dyn_obj_set(result, names[i], strlen(names[i]), value);
+  }
+  return result;
+}
+
+ScrBytes *scr_fs_readlink_bytes(ScrStr *path) {
+#ifdef _WIN32
+  WCHAR *wide = scr_fs_win_wide(path);
+  if (!wide) { scr_fs_throw(scr_fs_win_errno(GetLastError()), "readlink", path); return NULL; }
+  HANDLE h = CreateFileW(wide, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
+                        FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+  free(wide);
+  if (h == INVALID_HANDLE_VALUE) { scr_fs_throw(scr_fs_win_errno(GetLastError()), "readlink", path); return NULL; }
+  FILE_ATTRIBUTE_TAG_INFO tagged;
+  ScrStr *text = NULL;
+  double size;
+  bool ok = GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tagged, sizeof tagged) &&
+    scr_stats_link_target(h, tagged.ReparseTag, &size, &text);
+  CloseHandle(h);
+  if (!ok || !text) { scr_str_release(text); scr_fs_throw(EINVAL, "readlink", path); return NULL; }
+  ScrBytes *bytes = scr_bytes_from_data((const uint8_t *)text->data, text->len);
+  scr_str_release(text);
+  return bytes;
+#else
+  size_t capacity = 256;
+  uint8_t *text = NULL;
+  for (;;) {
+    uint8_t *grown = realloc(text, capacity);
+    if (!grown) { free(text); scr_trap("scriptc: out of memory\n"); }
+    text = grown;
+    ssize_t size = readlink(path->data, (char *)text, capacity);
+    if (size < 0) { int error = errno; free(text); scr_fs_throw(error, "readlink", path); return NULL; }
+    if ((size_t)size < capacity) {
+      ScrBytes *bytes = scr_bytes_from_data(text, (size_t)size);
+      free(text);
+      return bytes;
+    }
+    if (capacity > SIZE_MAX / 2) { free(text); scr_fs_throw(ENAMETOOLONG, "readlink", path); return NULL; }
+    capacity *= 2;
+  }
+#endif
+}
+
 ScrStats *scr_fs_stat(ScrStr *path) {
 #ifdef _WIN32
   return scr_stats_of_path(path, "stat", false);

package/dist/lib/runtime-sources/src/scr_map.c

@@ -649,6 +649,14 @@ void scr_map_dyn_set(ScrMap *map, const ScrDyn *key, const ScrDyn *value, bool s
   scr_map_release_key(map, key_slot);
 }
 
+ScrArr *scr_set_to_arr_dyn(const ScrMap *map) {
+  ScrArr *out = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, map->nlive);
+  for (size_t i = 0; i < map->nentries; i++) {
+    if (scr_map_iter_live(map, (double)i)) scr_arr_push_ref(out, scr_map_dyn_key(map, (double)i));
+  }
+  return out;
+}
+
 void *scr_map_iter_val_ref(const ScrMap *m, double i) {
   return m->val_retain(scr_map_slot_to_ptr(scr_map_iter_at(m, i)->val)); /* +1 */
 }

package/dist/lib/runtime-sources/src/scr_node_builtin.c

@@ -1,11 +1,89 @@
 /* Native builtin export objects. The compiler supplies the existing static
  * callable implementations; this unit owns lookup, identity, and mutations. */
 #include "scr_runtime.h"
+#include "scr_system_errors.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 
+typedef struct { int value; const char *name; const char *message; } ScrSystemError;
+#define SCR_SYSTEM_ERROR(name, message) { SCR_NODE_UV__##name, #name, message },
+static const ScrSystemError scr_system_errors[] = {
+  SCR_NODE_UV_ERRNO_MAP(SCR_SYSTEM_ERROR)
+};
+#undef SCR_SYSTEM_ERROR
+
+static bool scr_system_error_number(const ScrDyn *error, double *number) {
+  if (!error || error->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail("err", "of type number", error ? error : scr_dyn_undefined());
+    return false;
+  }
+  double n = error->v.num;
+  if (!(isfinite(n) && n < 0 && trunc(n) == n && n >= -9007199254740991.0)) {
+    char received[48];
+    scr_num_received(n, received);
+    if (n == 0 && signbit(n)) strcpy(received, "-0");
+    ScrJsonBuf buffer;
+    scr_jb_init(&buffer);
+    scr_jb_puts(&buffer, "The value of \"err\" is out of range. It must be a negative integer. Received ");
+    scr_jb_puts(&buffer, received);
+    ScrStr *message = scr_jb_finish(&buffer);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, message->data, message->len, "ERR_OUT_OF_RANGE");
+    scr_str_release(message);
+    return false;
+  }
+  *number = n;
+  return true;
+}
+
+static ScrStr *scr_system_error_lookup(double number, bool message) {
+  /* Node's name helper looks up the original safe integer. Its message
+   * binding uses V8's saturating Int32 extraction instead. */
+  double lookup = message && number < -2147483648.0 ? -2147483648.0 : number;
+  for (size_t i = 0; i < sizeof scr_system_errors / sizeof scr_system_errors[0]; i++) {
+    if (lookup == scr_system_errors[i].value) {
+      const char *text = message ? scr_system_errors[i].message : scr_system_errors[i].name;
+      return scr_str_new(text, strlen(text));
+    }
+  }
+  ScrJsonBuf buffer;
+  scr_jb_init(&buffer);
+  scr_jb_puts(&buffer, "Unknown system error ");
+  ScrStr *rendered = scr_f64_to_scrstr(lookup);
+  scr_jb_put_str(&buffer, rendered);
+  scr_str_release(rendered);
+  return scr_jb_finish(&buffer);
+}
+
+ScrStr *scr_util_system_error_name(const ScrDyn *error) {
+  double number;
+  return scr_system_error_number(error, &number) ? scr_system_error_lookup(number, false) : NULL;
+}
+
+ScrStr *scr_util_system_error_message(const ScrDyn *error) {
+  double number;
+  return scr_system_error_number(error, &number) ? scr_system_error_lookup(number, true) : NULL;
+}
+
+ScrDyn *scr_util_system_error_entries(void) {
+  ScrDyn *entries = scr_dyn_new_arr();
+  for (size_t i = 0; i < sizeof scr_system_errors / sizeof scr_system_errors[0]; i++) {
+    const ScrSystemError *error = &scr_system_errors[i];
+    ScrDyn *entry = scr_dyn_new_arr(), *pair = scr_dyn_new_arr();
+    ScrStr *name = scr_str_new(error->name, strlen(error->name));
+    ScrStr *message = scr_str_new(error->message, strlen(error->message));
+    scr_dyn_arr_push(pair, scr_dyn_new_str(name));
+    scr_dyn_arr_push(pair, scr_dyn_new_str(message));
+    scr_str_release(name);
+    scr_str_release(message);
+    scr_dyn_arr_push(entry, scr_dyn_new_num(error->value));
+    scr_dyn_arr_push(entry, pair);
+    scr_dyn_arr_push(entries, entry);
+  }
+  return entries;
+}
+
 static SCR_TL ScrDyn *scr_global_known;
 static SCR_TL ScrDyn *scr_global_own;
 static SCR_TL bool scr_global_cleanup_registered;