@scriptc/cli-darwin-x64 0.2.1 → 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; }
@@ -729,6 +738,239 @@ void scr_env_unset(const ScrStr *name) {
 #endif
 }
 
+static ScrStr *scr_fs_read_file_core(ScrStr *path, bool env_file);
+
+/* Node's dotenv parser trims ASCII space/tab/newline and removes every CR,
+ * including CR inside quoted values. Quoted values can span lines; only
+ * double quotes expand backslash-n. Preserve the pinned parser's ordering
+ * of empty-value and export-prefix handling, including its unusual forms. */
+static bool scr_env_space(char c) { return c == ' ' || c == '\t' || c == '\n'; }
+
+static void scr_env_trim(const char *text, size_t *start, size_t *end) {
+  while (*start < *end && scr_env_space(text[*start])) (*start)++;
+  while (*end > *start && scr_env_space(text[*end - 1])) (*end)--;
+}
+
+static void scr_env_store(ScrDyn *out, const char *text, size_t ks, size_t ke,
+                          size_t vs, size_t ve, bool expand) {
+  ScrJsonBuf value;
+  scr_jb_init(&value);
+  for (size_t i = vs; i < ve; i++) {
+    if (expand && text[i] == '\\' && i + 1 < ve && text[i + 1] == 'n') {
+      scr_jb_putc(&value, '\n');
+      i++;
+    } else scr_jb_putc(&value, text[i]);
+  }
+  ScrStr *s = scr_jb_finish(&value);
+  scr_dyn_obj_set(out, text + ks, ke - ks, scr_dyn_new_str(s));
+  scr_str_release(s);
+}
+
+static int scr_env_entry_order(const void *left, const void *right) {
+  const ScrDynEntry *a = *(const ScrDynEntry *const *)left;
+  const ScrDynEntry *b = *(const ScrDynEntry *const *)right;
+  size_t n = a->key_len < b->key_len ? a->key_len : b->key_len;
+  int cmp = memcmp(a->key, b->key, n);
+  return cmp ? cmp : (a->key_len > b->key_len) - (a->key_len < b->key_len);
+}
+
+static ScrDyn *scr_env_parse_content(const ScrStr *input, bool ordinary) {
+  char *text = malloc(input->len + 1);
+  if (!text) scr_trap("scriptc: out of memory\n");
+  size_t end = 0;
+  for (size_t i = 0; i < input->len; i++) if (input->data[i] != '\r') text[end++] = input->data[i];
+  text[end] = '\0';
+  size_t pos = 0;
+  scr_env_trim(text, &pos, &end);
+  ScrDyn *entries = scr_dyn_new_obj_null_proto();
+  while (pos < end) {
+    if (text[pos] == '\n' || text[pos] == '#') {
+      while (pos < end && text[pos] != '\n') pos++;
+      if (pos < end) pos++;
+      continue;
+    }
+    size_t equal = pos;
+    while (equal < end && text[equal] != '=' && text[equal] != '\n') equal++;
+    if (equal == end) break;
+    if (text[equal] == '\n') {
+      pos = equal + 1;
+      scr_env_trim(text, &pos, &end);
+      continue;
+    }
+    size_t ks = pos, ke = equal;
+    scr_env_trim(text, &ks, &ke);
+    pos = equal + 1;
+    if (pos == end || text[pos] == '\n') {
+      scr_env_store(entries, text, ks, ke, pos, pos, false);
+      continue;
+    }
+    scr_env_trim(text, &pos, &end);
+    if (ks == ke) continue;
+    if (ke - ks >= 7 && memcmp(text + ks, "export ", 7) == 0) {
+      ks += 7;
+      scr_env_trim(text, &ks, &ke);
+    }
+    if (pos == end) {
+      scr_env_store(entries, text, ks, ke, pos, pos, false);
+      break;
+    }
+    char quote = text[pos];
+    if (quote == '\'' || quote == '"' || quote == '`') {
+      size_t closing = pos + 1;
+      while (closing < end && text[closing] != quote) closing++;
+      if (closing < end) {
+        scr_env_store(entries, text, ks, ke, pos + 1, closing, quote == '"');
+        pos = closing + 1;
+        while (pos < end && text[pos] != '\n') pos++;
+        if (pos < end) pos++;
+        continue;
+      }
+      size_t newline = pos;
+      while (newline < end && text[newline] != '\n') newline++;
+      scr_env_store(entries, text, ks, ke, pos, newline, false);
+      pos = newline < end ? newline + 1 : end;
+    } else {
+      size_t newline = pos;
+      while (newline < end && text[newline] != '\n') newline++;
+      size_t vs = pos, ve = pos;
+      while (ve < newline && text[ve] != '#') ve++;
+      scr_env_trim(text, &vs, &ve);
+      scr_env_store(entries, text, ks, ke, vs, ve, false);
+      pos = newline < end ? newline + 1 : end;
+    }
+    scr_env_trim(text, &pos, &end);
+  }
+  free(text);
+  /* Node's std::map orders UTF-8 keys before installing object properties.
+   * Ordinary objects ignore string-valued __proto__ assignments; loading
+   * the native environment retains that name as an ordinary variable. */
+  size_t count = entries->v.obj.len;
+  const ScrDynEntry **sorted = count ? malloc(count * sizeof(*sorted)) : NULL;
+  if (count && !sorted) scr_trap("scriptc: out of memory\n");
+  for (size_t i = 0; i < count; i++) sorted[i] = &entries->v.obj.entries[i];
+  if (count > 1) qsort(sorted, count, sizeof(*sorted), scr_env_entry_order);
+  ScrDyn *result = ordinary ? scr_dyn_new_obj() : scr_dyn_new_obj_null_proto();
+  for (size_t i = 0; i < count; i++) {
+    const ScrDynEntry *entry = sorted[i];
+    if (ordinary && entry->key_len == 9 && memcmp(entry->key, "__proto__", 9) == 0) continue;
+    if (!ordinary) {
+      scr_dyn_obj_set(result, entry->key, entry->key_len, scr_dyn_retain(entry->value));
+      continue;
+    }
+    /* Convert sorted entries to JS strings after parsing. */
+    ScrStr *key = scr_str_from_utf8_lossy((const uint8_t *)entry->key, entry->key_len);
+    const ScrStr *raw = entry->value->v.str;
+    ScrStr *value = scr_str_from_utf8_lossy((const uint8_t *)raw->data, raw->len);
+    scr_dyn_obj_set(result, key->data, key->len, scr_dyn_new_str(value));
+    scr_str_release(key);
+    scr_str_release(value);
+  }
+  free(sorted);
+  scr_dyn_release(entries);
+  return result;
+}
+
+ScrDyn *scr_util_parse_env(const ScrDyn *content) {
+  if (content->kind != SCR_DYN_STR) {
+    scr_dyn_arg_type_fail("content", "of type string", content);
+    return NULL;
+  }
+  return scr_env_parse_content(content->v.str, true);
+}
+
+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 '");
+  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) {
+      scr_jb_puts(&b, "<Buffer");
+      for (size_t i = 0; i < bytes->len; i++) {
+        char hex[4];
+        snprintf(hex, sizeof hex, " %02x", bytes->data[i]);
+        scr_jb_puts(&b, hex);
+      }
+      scr_jb_putc(&b, '>');
+    } else {
+      char length[48];
+      snprintf(length, sizeof length, "Uint8Array(%zu) [ ", bytes->len);
+      scr_jb_puts(&b, length);
+      for (size_t i = 0; i < bytes->len; i++) {
+        char number[8];
+        snprintf(number, sizeof number, "%s%u", i ? ", " : "", bytes->data[i]);
+        scr_jb_puts(&b, number);
+      }
+      scr_jb_puts(&b, " ]");
+    }
+  } else {
+    char quote = memchr(path->data, '\'', path->len) ? '"' : '\'';
+    scr_jb_putc(&b, quote);
+    for (size_t i = 0; i < path->len; i++) {
+      unsigned char c = (unsigned char)path->data[i];
+      if (c == (unsigned char)quote || c == '\\') { scr_jb_putc(&b, '\\'); scr_jb_putc(&b, (char)c); }
+      else if (c == '\n') scr_jb_puts(&b, "\\n");
+      else if (c == '\r') scr_jb_puts(&b, "\\r");
+      else if (c == '\t') scr_jb_puts(&b, "\\t");
+      else if (c < 0x20 || c == 0x7f) {
+        char escape[5];
+        snprintf(escape, sizeof escape, "\\x%02X", c);
+        scr_jb_puts(&b, escape);
+      } else scr_jb_putc(&b, (char)c);
+    }
+    scr_jb_putc(&b, quote);
+  }
+  ScrStr *message = scr_jb_finish(&b);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, message->data, message->len, "ERR_INVALID_ARG_VALUE");
+  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);
+  else if (value->kind == SCR_DYN_STR) path = scr_str_retain(value->v.str);
+  else if (scr_dyn_native_url_is(value)) path = scr_url_to_path(value->v.handle.ptr);
+  else if (scr_dyn_bytes_is(value, SCR_BYTES_U8)) path = scr_str_new((const char *)value->v.bytes->data, value->v.bytes->len);
+  else {
+    scr_dyn_arg_type_fail("path", "of type string or an instance of Buffer or URL", value);
+    return;
+  }
+  if (!path) return;
+  if (memchr(path->data, 0, path->len)) {
+    scr_fs_invalid_path(value, path);
+    scr_str_release(path);
+    return;
+  }
+  ScrStr *content = scr_fs_read_file_core(path, true);
+  scr_str_release(path);
+  if (!content) return;
+  ScrDyn *entries = scr_env_parse_content(content, false);
+  scr_str_release(content);
+  for (size_t i = 0; i < entries->v.obj.len; i++) {
+    const ScrDynEntry *entry = &entries->v.obj.entries[i];
+    /* Node normalizes each raw sorted entry immediately before checking
+     * the environment. Distinct invalid byte keys can normalize alike;
+     * the first absent name wins, rather than the last parsed entry. */
+    ScrStr *key = scr_str_from_utf8_lossy((const uint8_t *)entry->key, entry->key_len);
+    ScrStr *existing = scr_env_get(key);
+    if (!existing) {
+      const ScrStr *raw = entry->value->v.str;
+      ScrStr *value = scr_str_from_utf8_lossy((const uint8_t *)raw->data, raw->len);
+      scr_env_set(key, value);
+      scr_str_release(value);
+    }
+    scr_str_release(existing);
+    scr_str_release(key);
+  }
+  scr_dyn_release(entries);
+}
+
 /* The whole environment as one fresh string[] of alternating
  * [k0, v0, k1, v1, ...] entries in environ order — the raw material of the
  * compiler's process.env snapshot record (insertion order = environ order,
@@ -2019,13 +2261,15 @@ void scr_fs_throw(int e, const char *op, const ScrStr *path) {
   const char *name = scr_errno_name(e, namebuf, sizeof namebuf);
   const char *text = scr_errno_text(e);
   char pathbuf[PATH_MAX];
-  const char *shown = scr_fs_err_path(path, pathbuf);
+  const char *shown = path ? scr_fs_err_path(path, pathbuf) : "";
   size_t cap = strlen(name) + strlen(text) + strlen(op) + strlen(shown) + 8;
   char *msg = malloc(cap);
   if (!msg) {
     scr_trap("scriptc: out of memory\n");
   }
-  int len = snprintf(msg, cap, "%s: %s, %s '%s'", name, text, op, shown);
+  int len = path
+    ? snprintf(msg, cap, "%s: %s, %s '%s'", name, text, op, shown)
+    : snprintf(msg, cap, "%s: %s, %s", name, text, op);
   /* A real Error instance (name "Error", message = Node's text) — what a
    * typed catch's `e instanceof Error` + `e.message` observes in Node —
    * with `code` stamped to the errno name (the exotic-errno fallback
@@ -2055,7 +2299,7 @@ static FILE *scr_fs_fopen(const ScrStr *path, const char *mode) {
 #endif
 }
 
-ScrStr *scr_fs_read_file(ScrStr *path) {
+static ScrStr *scr_fs_read_file_core(ScrStr *path, bool env_file) {
   FILE *f = scr_fs_fopen(path, "rb");
   if (!f) {
     scr_fs_throw(errno, "open", path);
@@ -2083,7 +2327,16 @@ ScrStr *scr_fs_read_file(ScrStr *path) {
     int e = errno;
     fclose(f);
     free(buf);
-    scr_fs_throw(e, "read", path);
+    if (env_file) {
+      ScrJsonBuf b;
+      scr_jb_init(&b);
+      scr_jb_puts(&b, "Contents of '");
+      scr_jb_put_str(&b, path);
+      scr_jb_puts(&b, "' should be a valid string.");
+      ScrStr *message = scr_jb_finish(&b);
+      scr_throw_error_msg_code(SCR_ERR_TYPE, message->data, message->len, "ERR_INVALID_ARG_TYPE");
+      scr_str_release(message);
+    } else scr_fs_throw(e, "read", path);
     return NULL;
   }
   fclose(f);
@@ -2092,6 +2345,11 @@ ScrStr *scr_fs_read_file(ScrStr *path) {
   return s;
 }
 
+ScrStr *scr_fs_read_file(ScrStr *path) {
+  return scr_fs_read_file_core(path, false);
+}
+
+
 static ScrStr *scr_fs_realpath_common(ScrStr *path, const char *op) {
 #ifdef _WIN32
   WCHAR *wide = scr_fs_win_wide(path);
@@ -2258,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);
 }
 
@@ -2353,6 +2649,20 @@ double scr_fs_open_numeric(ScrStr *path, double flags, double mode) {
 }
 
 static void scr_fs_throw_nopath(int e, const char *op);
+static bool scr_fs_write_fd_valid(double fd);
+
+double scr_fs_open_native(ScrStr *path, double flags, double mode) {
+#ifdef _WIN32
+  WCHAR *wide = scr_fs_win_wide(path);
+  if (!wide) { scr_fs_throw(scr_fs_win_errno(GetLastError()), "open", path); return 0; }
+  int fd = _wopen(wide, (int)flags | O_BINARY, (int)mode);
+  free(wide);
+#else
+  int fd = open(path->data, (int)flags | O_BINARY, (mode_t)mode);
+#endif
+  if (fd < 0) { scr_fs_throw(errno, "open", path); return 0; }
+  return (double)fd;
+}
 
 void scr_fs_fchmod(double fd, double mode) {
 #ifdef _WIN32
@@ -2374,6 +2684,114 @@ void scr_fs_fsync(double fd) {
 #endif
 }
 
+void scr_fs_fdatasync(double fd) {
+  if (!scr_fs_write_fd_valid(fd)) return;
+#if defined(_WIN32)
+  if (_commit((int)fd) != 0) scr_fs_throw_nopath(errno, "fdatasync");
+#elif defined(__APPLE__)
+  /* macOS/libuv implements fdatasync with fsync. */
+  if (fsync((int)fd) != 0) scr_fs_throw_nopath(errno, "fdatasync");
+#else
+  if (fdatasync((int)fd) != 0) scr_fs_throw_nopath(errno, "fdatasync");
+#endif
+}
+
+void scr_fs_ftruncate(double fd, double length) {
+  if (!scr_fs_write_fd_valid(fd)) return;
+  char received[48], msg[192];
+  scr_num_received(length, received);
+  if (!(isfinite(length) && trunc(length) == length) ||
+      length < -9007199254740991.0 || length > 9007199254740991.0) {
+    const char *bound = isfinite(length) && trunc(length) == length
+      ? ">= -9007199254740991 && <= 9007199254740991" : "an integer";
+    int n = snprintf(msg, sizeof msg,
+      "The value of \"len\" is out of range. It must be %s. Received %s", bound, received);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)n, "ERR_OUT_OF_RANGE");
+    return;
+  }
+  if (length < 0) length = 0;
+#ifdef _WIN32
+  int error = (int)_chsize_s((int)fd, (__int64)length);
+  if (error) scr_fs_throw_nopath(error, "ftruncate");
+#else
+  if (ftruncate((int)fd, (off_t)length) != 0) scr_fs_throw_nopath(errno, "ftruncate");
+#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"). */
 
@@ -2771,6 +3189,73 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length,
   return (double)n;
 }
 
+/* Gather/scatter one contiguous window around ONE kernel operation. Multiple
+ * scalar calls would change short I/O and pipe atomicity. This portable seam
+ * also preserves positioned I/O on targets without preadv/pwritev. */
+double scr_fs_read_zero(double fd, double position) {
+  if (!scr_fs_write_fd_valid(fd)) return 0;
+  uint8_t dummy;
+  ssize_t n = position < 0 ? read((int)fd, &dummy, 0)
+    : scr_fs_pread((int)fd, &dummy, 0, position);
+  if (n < 0) scr_fs_throw_nopath(errno, "read");
+  return 0;
+}
+
+static double scr_fs_vector_sync(double fd, ScrArr *buffers, double position,
+                                 bool writing) {
+  size_t count = (size_t)scr_arr_len(buffers);
+  if (writing && count == 0) return 0;
+  if (!scr_fs_write_fd_valid(fd)) return 0;
+  if (count == 0) { scr_fs_throw_nopath(EINVAL, "read"); return 0; }
+  size_t length = 0;
+  for (size_t i = 0; i < count; i++) {
+    ScrBytes *buf = scr_arr_get_ref(buffers, (double)i);
+    size_t n = buf->len;
+    scr_bytes_release(buf);
+    if (n > SIZE_MAX - length) scr_trap("scriptc: vector I/O size overflow\n");
+    length += n;
+  }
+  uint8_t *data = malloc(length ? length : 1);
+  if (!data) scr_trap("scriptc: out of memory\n");
+  if (writing) {
+    size_t at = 0;
+    for (size_t i = 0; i < count; i++) {
+      ScrBytes *buf = scr_arr_get_ref(buffers, (double)i);
+      if (buf->len) memcpy(data + at, buf->data, buf->len);
+      at += buf->len;
+      scr_bytes_release(buf);
+    }
+  }
+  ScrBytes window = {SIZE_MAX, length, SCR_BYTES_U8, data, NULL};
+  position = isfinite(position) && position >= 0 && position <= 9007199254740991.0
+    ? trunc(position) : -1;
+  double transferred = writing
+    ? scr_fs_write_sync(fd, &window, 0, (double)length, position)
+    : length == 0 ? scr_fs_read_zero(fd, position)
+      : scr_fs_read_sync(fd, &window, 0, (double)length, position);
+  if (!writing && !scr_exc_pending()) {
+    size_t at = 0, remaining = (size_t)transferred;
+    for (size_t i = 0; i < count && remaining; i++) {
+      ScrBytes *buf = scr_arr_get_ref(buffers, (double)i);
+      size_t n = buf->len < remaining ? buf->len : remaining;
+      if (n) memcpy(buf->data, data + at, n);
+      at += n;
+      remaining -= n;
+      scr_bytes_release(buf);
+    }
+  }
+  free(data);
+  return transferred;
+}
+
+double scr_fs_readv_sync(double fd, ScrArr *buffers, double position) {
+  return scr_fs_vector_sync(fd, buffers, position, false);
+}
+
+double scr_fs_writev_sync(double fd, ScrArr *buffers, double position) {
+  return scr_fs_vector_sync(fd, buffers, position, true);
+}
+
 void scr_fs_close(double fd) {
   if (close((int)fd) != 0) {
     int e = errno;
@@ -2807,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
@@ -2989,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
@@ -3143,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);
@@ -3183,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 */
@@ -3636,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];
@@ -3681,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
@@ -3709,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;
   }
 
@@ -3734,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;
 }
 
@@ -3747,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) {
@@ -3772,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
@@ -3849,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);
@@ -4256,7 +4981,7 @@ ScrStr *scr_crypto_random_string(double n, ScrStr *enc) {
   return out;
 }
 
-/* ── incremental MD5/SHA-1/SHA-256 and HMAC ──────────────────────────
+/* ── incremental MD5/SHA-1/SHA-2 and HMAC ──────────────────────────
  * The first-class Hash/Hmac handles, fused one-shot paths, island bridge,
  * and PBKDF2 all share these contexts. Hash.copy() is a context snapshot;
  * update never buffers the full input. Differential tests pin every
@@ -4462,7 +5187,7 @@ static size_t scr_sha1_digest(const unsigned char *data, size_t len, unsigned ch
 static ScrStr *scr_digest_encode(const unsigned char *d, size_t n, const ScrStr *enc) {
   if (enc->len == 3 && memcmp(enc->data, "hex", 3) == 0) {
     static const char hex[] = "0123456789abcdef";
-    char buf[64];
+    char buf[128];
     for (size_t i = 0; i < n; i++) {
       buf[i * 2] = hex[d[i] >> 4];
       buf[i * 2 + 1] = hex[d[i] & 0x0f];
@@ -4471,7 +5196,7 @@ static ScrStr *scr_digest_encode(const unsigned char *d, size_t n, const ScrStr
   }
   /* base64, standard alphabet, '=' padded — Buffer.toString("base64"). */
   static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  char buf[48];
+  char buf[88];
   size_t o = 0;
   for (size_t i = 0; i < n; i += 3) {
     unsigned v = (unsigned)d[i] << 16;
@@ -4586,10 +5311,140 @@ static size_t scr_md5_final(const ScrMd5Ctx *source, unsigned char out[32]) {
   return 16;
 }
 
+/* SHA-384/SHA-512, FIPS 180-4. The 128-byte blocks and HMAC pads differ
+ * from SHA-256; the digest dispatcher keeps that distinction explicit. */
+typedef struct ScrSha512Ctx {
+  uint64_t h[8];
+  uint64_t bytes;
+  unsigned char tail[128];
+  size_t tail_len;
+} ScrSha512Ctx;
+
+static const uint64_t scr_sha512_k[80] = {
+  UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd), UINT64_C(0xb5c0fbcfec4d3b2f),
+  UINT64_C(0xe9b5dba58189dbbc), UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019),
+  UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118), UINT64_C(0xd807aa98a3030242),
+  UINT64_C(0x12835b0145706fbe), UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
+  UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1), UINT64_C(0x9bdc06a725c71235),
+  UINT64_C(0xc19bf174cf692694), UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3),
+  UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65), UINT64_C(0x2de92c6f592b0275),
+  UINT64_C(0x4a7484aa6ea6e483), UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
+  UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210), UINT64_C(0xb00327c898fb213f),
+  UINT64_C(0xbf597fc7beef0ee4), UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725),
+  UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70), UINT64_C(0x27b70a8546d22ffc),
+  UINT64_C(0x2e1b21385c26c926), UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
+  UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8), UINT64_C(0x81c2c92e47edaee6),
+  UINT64_C(0x92722c851482353b), UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001),
+  UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30), UINT64_C(0xd192e819d6ef5218),
+  UINT64_C(0xd69906245565a910), UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
+  UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53), UINT64_C(0x2748774cdf8eeb99),
+  UINT64_C(0x34b0bcb5e19b48a8), UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb),
+  UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3), UINT64_C(0x748f82ee5defb2fc),
+  UINT64_C(0x78a5636f43172f60), UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
+  UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9), UINT64_C(0xbef9a3f7b2c67915),
+  UINT64_C(0xc67178f2e372532b), UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207),
+  UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178), UINT64_C(0x06f067aa72176fba),
+  UINT64_C(0x0a637dc5a2c898a6), UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
+  UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493), UINT64_C(0x3c9ebe0a15c9bebc),
+  UINT64_C(0x431d67c49c100d4c), UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a),
+  UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817),
+};
+
+static uint64_t scr_sha512_rotr(uint64_t x, unsigned n) {
+  return (x >> n) | (x << (64 - n));
+}
+
+static void scr_sha512_block(uint64_t h[8], const unsigned char *data) {
+  uint64_t w[80];
+  for (size_t i = 0; i < 16; i++) {
+    w[i] = 0;
+    for (size_t b = 0; b < 8; b++) w[i] = (w[i] << 8) | data[i * 8 + b];
+  }
+  for (size_t i = 16; i < 80; i++) {
+    uint64_t s0 = scr_sha512_rotr(w[i - 15], 1) ^ scr_sha512_rotr(w[i - 15], 8) ^ (w[i - 15] >> 7);
+    uint64_t s1 = scr_sha512_rotr(w[i - 2], 19) ^ scr_sha512_rotr(w[i - 2], 61) ^ (w[i - 2] >> 6);
+    w[i] = w[i - 16] + s0 + w[i - 7] + s1;
+  }
+  uint64_t a = h[0], b = h[1], c = h[2], d = h[3];
+  uint64_t e = h[4], f = h[5], g = h[6], v = h[7];
+  for (size_t i = 0; i < 80; i++) {
+    uint64_t s1 = scr_sha512_rotr(e, 14) ^ scr_sha512_rotr(e, 18) ^ scr_sha512_rotr(e, 41);
+    uint64_t t1 = v + s1 + ((e & f) ^ (~e & g)) + scr_sha512_k[i] + w[i];
+    uint64_t s0 = scr_sha512_rotr(a, 28) ^ scr_sha512_rotr(a, 34) ^ scr_sha512_rotr(a, 39);
+    uint64_t t2 = s0 + ((a & b) ^ (a & c) ^ (b & c));
+    v = g; g = f; f = e; e = d + t1;
+    d = c; c = b; b = a; a = t1 + t2;
+  }
+  h[0] += a; h[1] += b; h[2] += c; h[3] += d;
+  h[4] += e; h[5] += f; h[6] += g; h[7] += v;
+}
+
+static void scr_sha512_init(ScrSha512Ctx *ctx, bool sha384) {
+  static const uint64_t initial512[8] = {
+    UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b),
+    UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1),
+    UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f),
+    UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179)};
+  static const uint64_t initial384[8] = {
+    UINT64_C(0xcbbb9d5dc1059ed8), UINT64_C(0x629a292a367cd507),
+    UINT64_C(0x9159015a3070dd17), UINT64_C(0x152fecd8f70e5939),
+    UINT64_C(0x67332667ffc00b31), UINT64_C(0x8eb44a8768581511),
+    UINT64_C(0xdb0c2e0d64f98fa7), UINT64_C(0x47b5481dbefa4fa4)};
+  memcpy(ctx->h, sha384 ? initial384 : initial512, sizeof ctx->h);
+  ctx->bytes = 0;
+  ctx->tail_len = 0;
+}
+
+static void scr_sha512_update(ScrSha512Ctx *ctx, const unsigned char *data, size_t len) {
+  ctx->bytes += len;
+  if (ctx->tail_len != 0) {
+    size_t take = 128 - ctx->tail_len;
+    if (take > len) take = len;
+    memcpy(ctx->tail + ctx->tail_len, data, take);
+    ctx->tail_len += take;
+    data += take;
+    len -= take;
+    if (ctx->tail_len == 128) {
+      scr_sha512_block(ctx->h, ctx->tail);
+      ctx->tail_len = 0;
+    }
+  }
+  while (len >= 128) {
+    scr_sha512_block(ctx->h, data);
+    data += 128;
+    len -= 128;
+  }
+  if (len != 0) {
+    memcpy(ctx->tail, data, len);
+    ctx->tail_len = len;
+  }
+}
+
+static size_t scr_sha512_final(const ScrSha512Ctx *source, unsigned char out[64], bool sha384) {
+  ScrSha512Ctx ctx = *source;
+  unsigned char tail[256] = {0};
+  memcpy(tail, ctx.tail, ctx.tail_len);
+  tail[ctx.tail_len] = 0x80;
+  size_t pad = ctx.tail_len < 112 ? 128 : 256;
+  uint64_t low = ctx.bytes << 3, high = ctx.bytes >> 61;
+  for (size_t b = 0; b < 8; b++) {
+    tail[pad - 1 - b] = (unsigned char)(low >> (8 * b));
+    tail[pad - 9 - b] = (unsigned char)(high >> (8 * b));
+  }
+  scr_sha512_block(ctx.h, tail);
+  if (pad == 256) scr_sha512_block(ctx.h, tail + 128);
+  size_t len = sha384 ? 48 : 64;
+  for (size_t i = 0; i < len; i++) out[i] = (unsigned char)(ctx.h[i / 8] >> (56 - 8 * (i % 8)));
+  return len;
+}
+
 typedef enum ScrDigestAlg {
   SCR_DIGEST_MD5,
   SCR_DIGEST_SHA1,
+  SCR_DIGEST_SHA224,
   SCR_DIGEST_SHA256,
+  SCR_DIGEST_SHA384,
+  SCR_DIGEST_SHA512,
 } ScrDigestAlg;
 
 typedef struct ScrDigestCtx {
@@ -4598,6 +5453,7 @@ typedef struct ScrDigestCtx {
     ScrMd5Ctx md5;
     ScrSha1Ctx sha1;
     ScrSha256Ctx sha256;
+    ScrSha512Ctx sha512;
   } state;
 } ScrDigestCtx;
 
@@ -4617,7 +5473,10 @@ static bool scr_digest_name_is(const char *name, size_t len, const char *literal
 static bool scr_digest_alg(const char *name, size_t len, ScrDigestAlg *out) {
   if (scr_digest_name_is(name, len, "md5")) *out = SCR_DIGEST_MD5;
   else if (scr_digest_name_is(name, len, "sha1")) *out = SCR_DIGEST_SHA1;
+  else if (scr_digest_name_is(name, len, "sha224")) *out = SCR_DIGEST_SHA224;
   else if (scr_digest_name_is(name, len, "sha256")) *out = SCR_DIGEST_SHA256;
+  else if (scr_digest_name_is(name, len, "sha384")) *out = SCR_DIGEST_SHA384;
+  else if (scr_digest_name_is(name, len, "sha512")) *out = SCR_DIGEST_SHA512;
   else return false;
   return true;
 }
@@ -4627,7 +5486,17 @@ static void scr_digest_init(ScrDigestCtx *ctx, ScrDigestAlg alg) {
   switch (alg) {
     case SCR_DIGEST_MD5: scr_md5_init(&ctx->state.md5); break;
     case SCR_DIGEST_SHA1: scr_sha1_init(&ctx->state.sha1); break;
+    case SCR_DIGEST_SHA224: {
+      static const uint32_t initial[8] = {
+        0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
+        0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4};
+      scr_sha256_init(&ctx->state.sha256);
+      memcpy(ctx->state.sha256.h, initial, sizeof initial);
+      break;
+    }
     case SCR_DIGEST_SHA256: scr_sha256_init(&ctx->state.sha256); break;
+    case SCR_DIGEST_SHA384: scr_sha512_init(&ctx->state.sha512, true); break;
+    case SCR_DIGEST_SHA512: scr_sha512_init(&ctx->state.sha512, false); break;
   }
 }
 
@@ -4635,15 +5504,21 @@ static void scr_digest_update(ScrDigestCtx *ctx, const unsigned char *data, size
   switch (ctx->alg) {
     case SCR_DIGEST_MD5: scr_md5_update(&ctx->state.md5, data, len); break;
     case SCR_DIGEST_SHA1: scr_sha1_update(&ctx->state.sha1, data, len); break;
+    case SCR_DIGEST_SHA224:
     case SCR_DIGEST_SHA256: scr_sha256_update(&ctx->state.sha256, data, len); break;
+    case SCR_DIGEST_SHA384:
+    case SCR_DIGEST_SHA512: scr_sha512_update(&ctx->state.sha512, data, len); break;
   }
 }
 
-static size_t scr_digest_final(const ScrDigestCtx *ctx, unsigned char out[32]) {
+static size_t scr_digest_final(const ScrDigestCtx *ctx, unsigned char out[64]) {
   switch (ctx->alg) {
     case SCR_DIGEST_MD5: return scr_md5_final(&ctx->state.md5, out);
     case SCR_DIGEST_SHA1: return scr_sha1_final(&ctx->state.sha1, out);
+    case SCR_DIGEST_SHA224: scr_sha256_final(&ctx->state.sha256, out); return 28;
     case SCR_DIGEST_SHA256: return scr_sha256_final(&ctx->state.sha256, out);
+    case SCR_DIGEST_SHA384: return scr_sha512_final(&ctx->state.sha512, out, true);
+    case SCR_DIGEST_SHA512: return scr_sha512_final(&ctx->state.sha512, out, false);
   }
   return 0;
 }
@@ -4655,9 +5530,10 @@ static void scr_crypto_zero(void *ptr, size_t len) {
 
 static void scr_hmac_init(ScrDigestCtx *inner, ScrDigestCtx *outer, ScrDigestAlg alg,
                           const unsigned char *key, size_t keylen) {
-  unsigned char kblock[64] = {0};
-  unsigned char kd[32];
-  if (keylen > sizeof kblock) {
+  unsigned char kblock[128] = {0};
+  size_t block_len = alg == SCR_DIGEST_SHA384 || alg == SCR_DIGEST_SHA512 ? 128 : 64;
+  unsigned char kd[64];
+  if (keylen > block_len) {
     ScrDigestCtx key_hash;
     scr_digest_init(&key_hash, alg);
     scr_digest_update(&key_hash, key, keylen);
@@ -4668,24 +5544,24 @@ static void scr_hmac_init(ScrDigestCtx *inner, ScrDigestCtx *outer, ScrDigestAlg
   } else if (keylen != 0) {
     memcpy(kblock, key, keylen);
   }
-  unsigned char ipad[64];
-  unsigned char opad[64];
-  for (size_t i = 0; i < 64; i++) {
+  unsigned char ipad[128];
+  unsigned char opad[128];
+  for (size_t i = 0; i < block_len; i++) {
     ipad[i] = (unsigned char)(kblock[i] ^ 0x36);
     opad[i] = (unsigned char)(kblock[i] ^ 0x5c);
   }
   scr_digest_init(inner, alg);
-  scr_digest_update(inner, ipad, sizeof ipad);
+  scr_digest_update(inner, ipad, block_len);
   scr_digest_init(outer, alg);
-  scr_digest_update(outer, opad, sizeof opad);
+  scr_digest_update(outer, opad, block_len);
   scr_crypto_zero(kblock, sizeof kblock);
-  scr_crypto_zero(ipad, sizeof ipad);
-  scr_crypto_zero(opad, sizeof opad);
+  scr_crypto_zero(ipad, block_len);
+  scr_crypto_zero(opad, block_len);
 }
 
 static size_t scr_hmac_final(const ScrDigestCtx *inner, const ScrDigestCtx *outer,
-                             unsigned char out[32]) {
-  unsigned char inner_digest[32];
+                             unsigned char out[64]) {
+  unsigned char inner_digest[64];
   size_t inner_len = scr_digest_final(inner, inner_digest);
   ScrDigestCtx final_outer = *outer;
   scr_digest_update(&final_outer, inner_digest, inner_len);
@@ -4699,7 +5575,7 @@ static size_t scr_hmac_final(const ScrDigestCtx *inner, const ScrDigestCtx *oute
  * helpers both use the incremental core. Returns zero for an unknown
  * algorithm, preserving the island's unsupported-digest probe. */
 size_t scr_crypto_digest_raw(const char *alg, const unsigned char *data, size_t len,
-                             unsigned char out[32]) {
+                             unsigned char out[64]) {
   ScrDigestAlg kind;
   if (!scr_digest_alg(alg, strlen(alg), &kind)) return 0;
   ScrDigestCtx ctx;
@@ -4709,7 +5585,7 @@ size_t scr_crypto_digest_raw(const char *alg, const unsigned char *data, size_t
 }
 
 size_t scr_crypto_hmac_raw(const char *alg, const unsigned char *key, size_t keylen,
-                           const unsigned char *data, size_t len, unsigned char out[32]) {
+                           const unsigned char *data, size_t len, unsigned char out[64]) {
   ScrDigestAlg kind;
   if (!scr_digest_alg(alg, strlen(alg), &kind)) return 0;
   ScrDigestCtx inner, outer;
@@ -4859,7 +5735,7 @@ ScrCryptoHash *scr_crypto_hash_copy(ScrCryptoHash *hash) {
   return copy;
 }
 
-static size_t scr_crypto_hash_finish(ScrCryptoHash *hash, unsigned char out[32]) {
+static size_t scr_crypto_hash_finish(ScrCryptoHash *hash, unsigned char out[64]) {
   if (hash->finalized) {
     if (hash->hmac) return 0; /* Node's repeated Hmac.digest() is empty. */
     scr_crypto_hash_finalized();
@@ -4872,7 +5748,7 @@ static size_t scr_crypto_hash_finish(ScrCryptoHash *hash, unsigned char out[32])
 }
 
 ScrStr *scr_crypto_hash_digest_string(ScrCryptoHash *hash, ScrStr *enc) {
-  unsigned char digest[32];
+  unsigned char digest[64];
   size_t n = scr_crypto_hash_finish(hash, digest);
   if (n == 0) return scr_exc_pending() ? NULL : scr_str_new("", 0);
   ScrStr *result = scr_digest_encode(digest, n, enc);
@@ -4881,7 +5757,7 @@ ScrStr *scr_crypto_hash_digest_string(ScrCryptoHash *hash, ScrStr *enc) {
 }
 
 ScrBytes *scr_crypto_hash_digest_buffer(ScrCryptoHash *hash) {
-  unsigned char digest[32];
+  unsigned char digest[64];
   size_t n = scr_crypto_hash_finish(hash, digest);
   if (n == 0) return scr_exc_pending() ? NULL : scr_bytes_new(SCR_BYTES_U8, 0);
   ScrBytes *result = scr_bytes_new(SCR_BYTES_U8, (double)n);
@@ -4897,7 +5773,7 @@ static ScrStr *scr_hash_digest_raw(const ScrStr *alg, const unsigned char *data,
     scr_crypto_hash_digest_unsupported(alg);
     return NULL;
   }
-  unsigned char d[32];
+  unsigned char d[64];
   ScrDigestCtx ctx;
   scr_digest_init(&ctx, kind);
   scr_digest_update(&ctx, data, len);
@@ -4934,7 +5810,7 @@ bool scr_crypto_timing_safe_equal(ScrBytes *left, ScrBytes *right) {
 ScrBytes *scr_crypto_random_fill(ScrBytes *bytes, double offset, double size) {
   double length = (double)(bytes->len * scr_bytes_elem_size(bytes->elem));
   if (!isfinite(offset) || floor(offset) != offset || offset < 0 || offset > length) {
-    char value[32], msg[160];
+    char value[64], msg[160];
     size_t value_len = scr_f64_to_str(offset, value);
     int n = snprintf(msg, sizeof msg,
                      "The value of \"offset\" is out of range. It must be >= 0 && <= %.0f. Received %.*s",
@@ -4944,7 +5820,7 @@ ScrBytes *scr_crypto_random_fill(ScrBytes *bytes, double offset, double size) {
   }
   double available = length - offset;
   if (!isfinite(size) || floor(size) != size || size < 0 || size > 2147483647.0) {
-    char value[32], msg[160];
+    char value[64], msg[160];
     size_t value_len = scr_f64_to_str(size, value);
     int n = snprintf(msg, sizeof msg,
                      "The value of \"size\" is out of range. It must be >= 0 && <= 2147483647. Received %.*s",
@@ -4953,7 +5829,7 @@ ScrBytes *scr_crypto_random_fill(ScrBytes *bytes, double offset, double size) {
     return NULL;
   }
   if (size > available) {
-    char value[32], msg[160];
+    char value[64], msg[160];
     double total = size + offset;
     size_t value_len = scr_f64_to_str(total, value);
     int n = snprintf(msg, sizeof msg,
@@ -4983,7 +5859,7 @@ double scr_crypto_random_int(double min, double max) {
     return 0;
   }
   if (max <= min) {
-    char min_text[32], max_text[32], msg[192];
+    char min_text[64], max_text[64], msg[192];
     size_t min_len = scr_f64_to_str(min, min_text);
     size_t max_len = scr_f64_to_str(max, max_text);
     int n = snprintf(msg, sizeof msg,
@@ -5015,7 +5891,7 @@ static ScrBytes *scr_crypto_pbkdf2_raw(const unsigned char *password, size_t pas
                                       uint32_t iterations, size_t keylen,
                                       ScrDigestAlg alg) {
   ScrDigestCtx empty;
-  unsigned char empty_digest[32];
+  unsigned char empty_digest[64];
   scr_digest_init(&empty, alg);
   size_t digest_len = scr_digest_final(&empty, empty_digest);
   scr_crypto_zero(empty_digest, sizeof empty_digest);
@@ -5030,7 +5906,7 @@ static ScrBytes *scr_crypto_pbkdf2_raw(const unsigned char *password, size_t pas
     block[salt_len + 2] = (unsigned char)(index >> 8);
     block[salt_len + 3] = (unsigned char)index;
     ScrDigestCtx inner, outer;
-    unsigned char u[32], accum[32];
+    unsigned char u[64], accum[64];
     scr_hmac_init(&inner, &outer, alg, password, password_len);
     scr_digest_update(&inner, block, salt_len + 4);
     scr_hmac_final(&inner, &outer, u);
@@ -5058,7 +5934,7 @@ ScrBytes *scr_crypto_pbkdf2(ScrBytes *password, ScrBytes *salt,
                             double iterations, double keylen, ScrStr *digest) {
   if (!isfinite(iterations) || floor(iterations) != iterations ||
       iterations < 1 || iterations > 2147483647.0) {
-    char value[32], msg[176];
+    char value[64], msg[176];
     size_t value_len = scr_f64_to_str(iterations, value);
     int n = snprintf(msg, sizeof msg,
                      "The value of \"iterations\" is out of range. It must be >= 1 && <= 2147483647. Received %.*s",
@@ -5067,7 +5943,7 @@ ScrBytes *scr_crypto_pbkdf2(ScrBytes *password, ScrBytes *salt,
     return NULL;
   }
   if (!isfinite(keylen) || floor(keylen) != keylen || keylen < 0 || keylen > 2147483647.0) {
-    char value[32], msg[176];
+    char value[64], msg[176];
     size_t value_len = scr_f64_to_str(keylen, value);
     int n = snprintf(msg, sizeof msg,
                      "The value of \"keylen\" is out of range. It must be >= 0 && <= 2147483647. Received %.*s",
@@ -5086,6 +5962,279 @@ ScrBytes *scr_crypto_pbkdf2(ScrBytes *password, ScrBytes *salt,
       (size_t)keylen, alg);
 }
 
+/* RFC 5869 HKDF and RFC 7914 scrypt share the digest core in both
+ * execution tiers. Sensitive scratch storage is cleared before release. */
+static bool scr_crypto_integer(double value, const char *name, double max) {
+  if (isfinite(value) && floor(value) == value && value >= 0 && value <= max) return true;
+  char received[64], requirement[80], message[256];
+  size_t n = scr_f64_to_str(value, received);
+  received[n] = '\0';
+  if (!isfinite(value) || floor(value) != value) {
+    snprintf(requirement, sizeof requirement, "an integer");
+  } else {
+    snprintf(requirement, sizeof requirement, ">= 0 && <= %.0f", max);
+    if (fabs(value) > 4294967296.0) {
+      char digits[40];
+      snprintf(digits, sizeof digits, "%.0f", value);
+      size_t len = strlen(digits), out = 0, start = digits[0] == '-' ? 1 : 0;
+      for (size_t i = 0; i < len; i++) {
+        if (i > start && (len - i) % 3 == 0) received[out++] = '_';
+        received[out++] = digits[i];
+      }
+      received[out] = '\0';
+    }
+  }
+  int len = snprintf(message, sizeof message,
+      "The value of \"%s\" is out of range. It must be %s. Received %s", name, requirement, received);
+  scr_throw_error_msg_code(SCR_ERR_RANGE, message, (size_t)len, "ERR_OUT_OF_RANGE");
+  return false;
+}
+
+ScrBytes *scr_crypto_hkdf_bytes(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                                ScrBytes *info, double keylen) {
+  if (!scr_crypto_integer(keylen, "length", 9007199254740991.0)) return NULL;
+  size_t info_len = info->len * scr_bytes_elem_size(info->elem);
+  if (info_len > 1024) {
+    char message[192];
+    int len = snprintf(message, sizeof message,
+        "The value of \"info\" is out of range. It must be must not contain more than 1024 bytes. Received %zu", info_len);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, message, (size_t)len, "ERR_OUT_OF_RANGE");
+    return NULL;
+  }
+  ScrDigestAlg alg;
+  if (!scr_digest_alg(digest->data, digest->len, &alg)) {
+    scr_crypto_invalid_digest(digest);
+    return NULL;
+  }
+  ScrDigestCtx inner, outer;
+  unsigned char prk[64], t[64];
+  scr_hmac_init(&inner, &outer, alg, salt->data, salt->len * scr_bytes_elem_size(salt->elem));
+  scr_digest_update(&inner, ikm->data, ikm->len * scr_bytes_elem_size(ikm->elem));
+  size_t hash_len = scr_hmac_final(&inner, &outer, prk);
+  if (keylen > 255 * hash_len) {
+    scr_crypto_zero(prk, sizeof prk);
+    scr_crypto_zero(&inner, sizeof inner);
+    scr_crypto_zero(&outer, sizeof outer);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, "Invalid key length", 18, "ERR_CRYPTO_INVALID_KEYLEN");
+    return NULL;
+  }
+  ScrBytes *result = scr_bytes_new(SCR_BYTES_U8, keylen);
+  size_t offset = 0, previous_len = 0;
+  for (unsigned counter = 1; offset < (size_t)keylen; counter++) {
+    scr_hmac_init(&inner, &outer, alg, prk, hash_len);
+    scr_digest_update(&inner, t, previous_len);
+    scr_digest_update(&inner, info->data, info_len);
+    unsigned char byte = (unsigned char)counter;
+    scr_digest_update(&inner, &byte, 1);
+    scr_hmac_final(&inner, &outer, t);
+    size_t take = (size_t)keylen - offset;
+    if (take > hash_len) take = hash_len;
+    memcpy(result->data + offset, t, take);
+    offset += take;
+    previous_len = hash_len;
+  }
+  scr_crypto_zero(prk, sizeof prk);
+  scr_crypto_zero(t, sizeof t);
+  scr_crypto_zero(&inner, sizeof inner);
+  scr_crypto_zero(&outer, sizeof outer);
+  return result;
+}
+
+ScrDyn *scr_crypto_hkdf(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                       ScrBytes *info, double keylen) {
+  ScrBytes *bytes = scr_crypto_hkdf_bytes(digest, ikm, salt, info, keylen);
+  if (!bytes) return NULL;
+  if (bytes->len == 0) {
+    scr_bytes_release(bytes);
+    scr_throw_error_msg(SCR_ERR_ERROR, "Deriving bits failed", 20);
+    return NULL;
+  }
+  ScrDyn *result = scr_array_buffer_from_bytes(bytes);
+  scr_bytes_release(bytes);
+  return result;
+}
+
+static uint32_t scr_scrypt_rotl(uint32_t x, unsigned n) {
+  return (x << n) | (x >> (32 - n));
+}
+
+/* Salsa20/8 core, RFC 7914 section 3. Unsigned arithmetic supplies the
+ * specified reduction modulo 2^32 without signed-overflow UB. */
+static void scr_scrypt_salsa(uint32_t block[16]) {
+  uint32_t x[16];
+  memcpy(x, block, sizeof x);
+  for (unsigned round = 0; round < 8; round += 2) {
+#define SCR_SALSA(a, b, c, n) x[a] ^= scr_scrypt_rotl(x[b] + x[c], n)
+    SCR_SALSA(4,0,12,7); SCR_SALSA(8,4,0,9); SCR_SALSA(12,8,4,13); SCR_SALSA(0,12,8,18);
+    SCR_SALSA(9,5,1,7); SCR_SALSA(13,9,5,9); SCR_SALSA(1,13,9,13); SCR_SALSA(5,1,13,18);
+    SCR_SALSA(14,10,6,7); SCR_SALSA(2,14,10,9); SCR_SALSA(6,2,14,13); SCR_SALSA(10,6,2,18);
+    SCR_SALSA(3,15,11,7); SCR_SALSA(7,3,15,9); SCR_SALSA(11,7,3,13); SCR_SALSA(15,11,7,18);
+    SCR_SALSA(1,0,3,7); SCR_SALSA(2,1,0,9); SCR_SALSA(3,2,1,13); SCR_SALSA(0,3,2,18);
+    SCR_SALSA(6,5,4,7); SCR_SALSA(7,6,5,9); SCR_SALSA(4,7,6,13); SCR_SALSA(5,4,7,18);
+    SCR_SALSA(11,10,9,7); SCR_SALSA(8,11,10,9); SCR_SALSA(9,8,11,13); SCR_SALSA(10,9,8,18);
+    SCR_SALSA(12,15,14,7); SCR_SALSA(13,12,15,9); SCR_SALSA(14,13,12,13); SCR_SALSA(15,14,13,18);
+#undef SCR_SALSA
+  }
+  for (size_t i = 0; i < 16; i++) block[i] += x[i];
+  scr_crypto_zero(x, sizeof x);
+}
+
+static void scr_scrypt_blockmix(uint32_t *x, uint32_t *y, size_t r) {
+  uint32_t block[16];
+  memcpy(block, x + (2 * r - 1) * 16, sizeof block);
+  for (size_t i = 0; i < 2 * r; i++) {
+    for (size_t k = 0; k < 16; k++) block[k] ^= x[i * 16 + k];
+    scr_scrypt_salsa(block);
+    size_t dest = (i / 2 + (i % 2) * r) * 16;
+    memcpy(y + dest, block, sizeof block);
+  }
+  memcpy(x, y, 128 * r);
+  scr_crypto_zero(block, sizeof block);
+}
+
+static bool scr_scrypt_params(double n, double r, double p, double maxmem, size_t *memory) {
+  uint64_t N = (uint64_t)n, R = (uint64_t)r, P = (uint64_t)p;
+  if (N < 2 || (N & (N - 1)) != 0) {
+    scr_throw_error_msg_code(SCR_ERR_RANGE, "Invalid scrypt params", 21, "ERR_CRYPTO_INVALID_SCRYPT_PARAMS");
+    return false;
+  }
+  /* Match Node's OpenSSL 3 scrypt guard, including X/Y working buffers
+   * and the initial PBKDF2 output; check every product before allocation. */
+  bool overflow = R == 0 || P == 0 || P > UINT64_C(0x3fffffff) / R;
+  if (!overflow && R <= 3 && N >= (UINT64_C(1) << (16 * R))) overflow = true;
+  uint64_t b = overflow ? 0 : 128 * R * P;
+  if (b > INT32_MAX || R > UINT64_MAX / 128 / (N + 2)) overflow = true;
+  uint64_t v = overflow ? 0 : 128 * R * (N + 2);
+  if (overflow || b > UINT64_MAX - v || b + v > (uint64_t)maxmem || b + v > SIZE_MAX) {
+    static const char message[] = "Invalid scrypt params: error:030000AC:digital envelope routines::memory limit exceeded";
+    scr_throw_error_msg_code(SCR_ERR_RANGE, message, sizeof message - 1, "ERR_CRYPTO_INVALID_SCRYPT_PARAMS");
+    return false;
+  }
+  *memory = (size_t)(b + v);
+  return true;
+}
+
+ScrBytes *scr_crypto_scrypt_derive(ScrBytes *password, ScrBytes *salt, double keylen,
+                                  double n, double r, double p, double maxmem) {
+  if (!scr_crypto_integer(keylen, "keylen", 2147483647.0) ||
+      !scr_crypto_integer(n, "N", 4294967295.0) || !scr_crypto_integer(r, "r", 4294967295.0) ||
+      !scr_crypto_integer(p, "p", 4294967295.0) || !scr_crypto_integer(maxmem, "maxmem", 9007199254740991.0)) return NULL;
+  if (n == 0) n = 16384;
+  if (r == 0) r = 8;
+  if (p == 0) p = 1;
+  if (maxmem == 0) maxmem = 33554432;
+  size_t memory;
+  if (!scr_scrypt_params(n, r, p, maxmem, &memory)) return NULL;
+  if (keylen == 0) return scr_bytes_new(SCR_BYTES_U8, 0);
+  size_t words = 32 * (size_t)r, block_len = words * sizeof(uint32_t);
+  size_t b_len = block_len * (size_t)p;
+  ScrBytes *b = scr_crypto_pbkdf2_raw(password->data, password->len * scr_bytes_elem_size(password->elem),
+      salt->data, salt->len * scr_bytes_elem_size(salt->elem), 1, b_len, SCR_DIGEST_SHA256);
+  uint32_t *work = malloc(memory - b_len);
+  if (!work) { scr_bytes_release(b); scr_trap("scriptc: out of memory\n"); }
+  uint32_t *x = work, *y = x + words, *v = y + words;
+  for (size_t part = 0; part < (size_t)p; part++) {
+    unsigned char *bytes = b->data + part * block_len;
+    for (size_t i = 0; i < words; i++) {
+      x[i] = (uint32_t)bytes[i * 4] | ((uint32_t)bytes[i * 4 + 1] << 8) |
+             ((uint32_t)bytes[i * 4 + 2] << 16) | ((uint32_t)bytes[i * 4 + 3] << 24);
+    }
+    for (size_t i = 0; i < (size_t)n; i++) {
+      memcpy(v + i * words, x, block_len);
+      scr_scrypt_blockmix(x, y, (size_t)r);
+    }
+    for (size_t i = 0; i < (size_t)n; i++) {
+      size_t j = (size_t)x[words - 16] & ((size_t)n - 1);
+      for (size_t k = 0; k < words; k++) x[k] ^= v[j * words + k];
+      scr_scrypt_blockmix(x, y, (size_t)r);
+    }
+    for (size_t i = 0; i < words; i++) {
+      for (size_t k = 0; k < 4; k++) bytes[i * 4 + k] = (unsigned char)(x[i] >> (8 * k));
+    }
+  }
+  ScrBytes *result = scr_crypto_pbkdf2_raw(password->data, password->len * scr_bytes_elem_size(password->elem),
+      b->data, b_len, 1, (size_t)keylen, SCR_DIGEST_SHA256);
+  scr_crypto_zero(b->data, b_len);
+  scr_bytes_release(b);
+  scr_crypto_zero(work, memory - b_len);
+  free(work);
+  return result;
+}
+
+static ScrDyn *scr_scrypt_read_option(ScrDyn *options, const char *name) {
+  if (options->kind != SCR_DYN_TYPED_REF) return scr_dyn_obj_read(options, name, strlen(name));
+  ScrDyn *view = scr_dyn_typed_ref_materialize(options);
+  if (!view) return NULL;
+  ScrDyn *value = scr_dyn_obj_read(view, name, strlen(name));
+  scr_dyn_release(view);
+  return value;
+}
+
+static bool scr_scrypt_option(ScrDyn *options, const char *name, double max, double *out, bool *present) {
+  ScrDyn *value = scr_scrypt_read_option(options, name);
+  if (scr_exc_pending()) return false;
+  *present = value && value->kind != SCR_DYN_UNDEF;
+  if (*present) {
+    scr_dyn_release(value);
+    value = scr_scrypt_read_option(options, name);
+    if (scr_exc_pending()) return false;
+    if (value->kind != SCR_DYN_NUM) {
+      scr_dyn_arg_type_fail(name, "number", value);
+      scr_dyn_release(value);
+      return false;
+    }
+    *out = value->v.num;
+    bool valid = scr_crypto_integer(*out, name, max);
+    scr_dyn_release(value);
+    return valid;
+  }
+  scr_dyn_release(value);
+  return true;
+}
+
+ScrBytes *scr_crypto_scrypt(ScrBytes *password, ScrBytes *salt, double keylen, ScrDyn *options) {
+  if (!scr_crypto_integer(keylen, "keylen", 2147483647.0)) return NULL;
+  double values[4] = {16384, 8, 1, 33554432};
+  if (options && scr_dyn_truthy(options)) {
+    const char *names[3] = {"N", "r", "p"};
+    const char *aliases[3] = {"cost", "blockSize", "parallelization"};
+    for (size_t i = 0; i < 3; i++) {
+      bool primary, alias;
+      if (!scr_scrypt_option(options, names[i], 4294967295.0, &values[i], &primary)) return NULL;
+      // Node reads the alias to test presence before checking the conflict.
+      ScrDyn *alias_value = scr_scrypt_read_option(options, aliases[i]);
+      if (scr_exc_pending()) return NULL;
+      alias = alias_value && alias_value->kind != SCR_DYN_UNDEF;
+      if (primary && alias) {
+        char message[160];
+        int len = snprintf(message, sizeof message, "Option \"%s\" cannot be used in combination with option \"%s\"", names[i], aliases[i]);
+        scr_dyn_release(alias_value);
+        scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)len, "ERR_INCOMPATIBLE_OPTION_PAIR");
+        return NULL;
+      }
+      if (alias) {
+        scr_dyn_release(alias_value);
+        alias_value = scr_scrypt_read_option(options, aliases[i]);
+        if (scr_exc_pending()) return NULL;
+        if (alias_value->kind != SCR_DYN_NUM) {
+          scr_dyn_arg_type_fail(aliases[i], "number", alias_value);
+          scr_dyn_release(alias_value);
+          return NULL;
+        }
+        values[i] = alias_value->v.num;
+        if (!scr_crypto_integer(values[i], aliases[i], 4294967295.0)) {
+          scr_dyn_release(alias_value);
+          return NULL;
+        }
+      }
+      scr_dyn_release(alias_value);
+    }
+    bool present;
+    if (!scr_scrypt_option(options, "maxmem", 9007199254740991.0, &values[3], &present)) return NULL;
+  }
+  return scr_crypto_scrypt_derive(password, salt, keylen, values[0], values[1], values[2], values[3]);
+}
+
 /* The composed `new crypto.X509Certificate(data).fingerprint` read, fused
  * by the compiler (no certificate handle exists). Node's .fingerprint IS
  * the SHA-1 of the certificate's DER bytes, uppercase colon-separated —