@scriptc/cli-darwin-x64 0.2.1 → 0.2.3

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

@@ -279,13 +279,204 @@ static ScrStr *scr_fs_cb_path(const ScrDyn *value, const char *name) {
   ScrStr *path = value->kind == SCR_DYN_STR ? scr_str_retain(value->v.str)
     : scr_str_new((const char *)value->v.bytes->data, value->v.bytes->len);
   if (memchr(path->data, 0, path->len)) {
-    scr_dyn_arg_value_fail(name, "must be a string, Uint8Array, or URL without null bytes", value);
+    scr_fs_invalid_named_path(value, path, name);
     scr_str_release(path);
     return NULL;
   }
   return path;
 }
 
+static ScrStr *scr_fs_checked_path(const ScrDyn *value, const char *name) {
+  if (!scr_dyn_native_url_is(value)) return scr_fs_cb_path(value, name);
+  ScrStr *path = scr_url_checked_to_path(value);
+  if (!path) return NULL;
+  ScrDyn input = { .kind = SCR_DYN_STR, .v.str = path };
+  ScrStr *checked = scr_fs_cb_path(&input, name);
+  scr_str_release(path);
+  return checked;
+}
+
+static ScrStr *scr_fs_timestamp_path(const ScrDyn *value) {
+  return scr_fs_checked_path(value, "path");
+}
+
+/* statfs reads options.bigint without validating/coercing the options object.
+ * Undefined selects the default; null throws, and only boolean true opts in. */
+static bool scr_fs_statfs_bigint(const ScrDyn *options) {
+  if (options->kind == SCR_DYN_UNDEF) return false;
+  if (options->kind == SCR_DYN_NULL) {
+    static const char message[] = "Cannot read properties of null (reading 'bigint')";
+    scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    return false;
+  }
+  ScrDyn *value = scr_fs_cb_option(options, "bigint");
+  bool bigint = value && value->kind == SCR_DYN_BOOL && value->v.b;
+  scr_dyn_release(value);
+  return bigint;
+}
+
+ScrDyn *scr_fs_statfs_checked(const ScrDyn *input, const ScrDyn *options) {
+  ScrStr *path = scr_fs_checked_path(input, "path");
+  if (!path) return NULL;
+  bool bigint = scr_fs_statfs_bigint(options);
+  ScrDyn *result = scr_exc_pending() ? NULL : scr_fs_statfs(path, bigint);
+  scr_str_release(path);
+  return result;
+}
+
+/* validateOneOf runs before either path, even on POSIX where the type has
+ * no syscall effect. -1 means infer the target's kind on Windows. */
+static int scr_fs_symlink_type(const ScrDyn *type) {
+  if (scr_fs_dyn_absent(type)) return -1;
+  if (type->kind == SCR_DYN_STR) {
+    const ScrStr *s = type->v.str;
+    if (s->len == 4 && !memcmp(s->data, "file", 4)) return 0;
+    if (s->len == 3 && !memcmp(s->data, "dir", 3)) return 1;
+    if (s->len == 8 && !memcmp(s->data, "junction", 8)) return 2;
+  }
+  scr_dyn_arg_value_fail("type", "must be one of: 'dir', 'file', 'junction', null, undefined", type);
+  return -1;
+}
+
+void scr_fs_link_checked(const ScrDyn *existing, const ScrDyn *destination) {
+  ScrStr *from = scr_fs_checked_path(existing, "existingPath");
+  if (!from) return;
+  ScrStr *to = scr_fs_checked_path(destination, "newPath");
+  if (to) scr_fs_link(from, to);
+  scr_str_release(from); scr_str_release(to);
+}
+
+static void scr_fs_symlink_checked_core(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type, bool promise) {
+  int kind = scr_fs_symlink_type(type);
+  if (scr_exc_pending()) return;
+#ifdef _WIN32
+  if (kind == -1) {
+    // Sync/promise inference stringifies the raw destination and target before
+    // getValidatedPath. Sync stat exposes null-byte errors in the resolved path;
+    // the promise form catches inference failures and continues as a file link.
+    ScrStr *link = scr_dyn_string_coerce_js(destination);
+    ScrStr *source = !scr_exc_pending() ? scr_dyn_string_coerce_js(target) : NULL;
+    ScrStr *absolute = NULL;
+    if (link && source && !scr_exc_pending()) {
+      ScrArr *parts = scr_arr_new_ref(scr_str_retain_v, scr_str_release_v, NULL, 3);
+      scr_arr_push_ref(parts, scr_str_retain(link));
+      scr_arr_push_ref(parts, scr_str_new("..", 2));
+      scr_arr_push_ref(parts, scr_str_retain(source));
+      absolute = scr_path_win32_resolve(parts);
+      scr_arr_release(parts);
+    }
+    kind = 0;
+    if (absolute && !scr_exc_pending()) {
+      ScrDyn input = { .kind = SCR_DYN_STR, .v.str = absolute };
+      ScrStr *checked = scr_fs_cb_path(&input, "path");
+      if (checked) kind = scr_fs_symlink_infer(checked);
+      scr_str_release(checked);
+    }
+    scr_str_release(link); scr_str_release(source); scr_str_release(absolute);
+    if (scr_exc_pending()) {
+      if (!promise) return;
+      scr_caught_release(scr_exc_take());
+    }
+  }
+#else
+  (void)promise;
+#endif
+  ScrStr *from = scr_fs_checked_path(target, "target");
+  if (!from) return;
+  ScrStr *to = scr_fs_checked_path(destination, "path");
+#ifdef _WIN32
+  if (to && kind == 2 && scr_dyn_bytes_is(destination, SCR_BYTES_U8)) {
+    scr_dyn_arg_type_fail("paths[0]", "of type string", destination);
+    scr_str_release(to); to = NULL;
+  }
+#endif
+  if (to) scr_fs_symlink(from, to, kind);
+  scr_str_release(from); scr_str_release(to);
+}
+
+void scr_fs_symlink_checked(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type) {
+  scr_fs_symlink_checked_core(target, destination, type, false);
+}
+
+void scr_fs_symlink_promise_checked(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type) {
+  scr_fs_symlink_checked_core(target, destination, type, true);
+}
+
+/* getOptions accepts functions as defaults and validates signals without
+ * cancelling readlink. Unlike readFile, an aborted signal is ignored. */
+static ScrDyn *scr_fs_readlink_encoding(const ScrDyn *options) {
+  if (scr_fs_dyn_absent(options) || options->kind == SCR_DYN_FUNC) return scr_dyn_retain(scr_dyn_undefined());
+  if (options->kind != SCR_DYN_STR && options->kind != SCR_DYN_OBJ &&
+      options->kind != SCR_DYN_ARR && options->kind != SCR_DYN_TYPED_REF &&
+      options->kind != SCR_DYN_HANDLE && options->kind != SCR_DYN_BYTES) {
+    scr_dyn_arg_type_fail("options", "one of type string or object", options);
+    return NULL;
+  }
+  ScrDyn *encoding = options->kind == SCR_DYN_STR ? scr_dyn_retain((ScrDyn *)options) : scr_fs_cb_option(options, "encoding");
+  if (!encoding) return NULL;
+  bool buffer = encoding->kind == SCR_DYN_STR && encoding->v.str->len == 6 && !memcmp(encoding->v.str->data, "buffer", 6);
+  if (!buffer && scr_dyn_truthy(encoding) &&
+      (encoding->kind != SCR_DYN_STR || !scr_bytes_is_encoding(encoding->v.str))) {
+    scr_dyn_arg_value_fail("encoding", "is invalid encoding", encoding);
+    scr_dyn_release(encoding);
+    return NULL;
+  }
+  if (options->kind != SCR_DYN_STR) {
+    ScrDyn *signal = scr_fs_cb_option(options, "signal");
+    if (!signal) { scr_dyn_release(encoding); return NULL; }
+    bool valid = signal->kind == SCR_DYN_UNDEF || (signal->kind == SCR_DYN_HANDLE && signal->v.handle.tag == SCR_DYNH_ABORT_SIGNAL);
+    if (!valid) scr_dyn_prop_type_fail("options.signal", "an instance of AbortSignal", signal);
+    scr_dyn_release(signal);
+    if (!valid) { scr_dyn_release(encoding); return NULL; }
+  }
+  return encoding;
+}
+
+static ScrDyn *scr_fs_readlink_result(ScrStr *path, const ScrDyn *encoding) {
+  ScrBytes *bytes = scr_fs_readlink_bytes(path);
+  if (!bytes) return NULL;
+  ScrDyn *result;
+  if (encoding->kind == SCR_DYN_STR && encoding->v.str->len == 6 && !memcmp(encoding->v.str->data, "buffer", 6)) {
+    result = scr_dyn_new_buffer(bytes);
+  }
+  else {
+    ScrStr *codec = encoding->kind == SCR_DYN_STR && encoding->v.str->len ? scr_str_retain(encoding->v.str) : scr_str_new("utf8", 4);
+    ScrStr *text = scr_bytes_to_str(bytes, codec);
+    scr_str_release(codec);
+    result = text ? scr_dyn_new_str(text) : NULL;
+    scr_str_release(text);
+  }
+  scr_bytes_release(bytes);
+  return result;
+}
+
+ScrDyn *scr_fs_readlink_checked(const ScrDyn *input, const ScrDyn *options, bool promise) {
+  ScrDyn *encoding = scr_fs_readlink_encoding(options);
+  if (!encoding) return NULL;
+  ScrStr *path = scr_fs_checked_path(input, promise ? "oldPath" : "path");
+  ScrDyn *result = path ? scr_fs_readlink_result(path, encoding) : NULL;
+  scr_str_release(path); scr_dyn_release(encoding);
+  return result;
+}
+
+ScrDyn *scr_fs_readlink_dyn(const ScrDyn *path, const ScrDyn *options) {
+  return scr_fs_readlink_checked(path, options, false);
+}
+
+ScrStr *scr_fs_readlink_str(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_dyn(path, options);
+  ScrStr *text = result && result->kind == SCR_DYN_STR ? scr_str_retain(result->v.str) : NULL;
+  scr_dyn_release(result);
+  return text;
+}
+
+ScrBytes *scr_fs_readlink_buffer(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_dyn(path, options);
+  ScrBytes *bytes = result ? scr_dyn_bytes_unbox(result) : NULL;
+  scr_dyn_release(result);
+  return bytes;
+}
+
 static ScrDyn *scr_fs_cb_string(ScrStr *text) {
   if (!text) return NULL;
   ScrDyn *value = scr_dyn_new_str(text);
@@ -469,21 +660,132 @@ static void scr_fs_cb_schedule(const ScrDyn *callback, ScrDyn *result, const Scr
 
 static bool scr_fs_read_validate(const ScrDyn *, const ScrDyn *, const ScrDyn *, const ScrDyn *, const ScrDyn *);
 static bool scr_fs_encoding_chk(const ScrDyn *);
+static bool scr_fs_int_range_chk(const ScrDyn *, const char *, double, double, const char *);
+static bool scr_fs_mode_chk(const ScrDyn *, const char *);
+
+static bool scr_fs_callback_times(const ScrDyn *atime, const ScrDyn *mtime, bool descriptor, double *access, double *modified) {
+  *access = scr_fs_timestamp_value(atime, descriptor ? "atime" : "time");
+  if (scr_exc_pending()) return false;
+  *modified = scr_fs_timestamp_value(mtime, descriptor ? "mtime" : "time");
+  return !scr_exc_pending();
+}
+
+static ScrArr *scr_fs_cb_vectors(const ScrDyn *buffers) {
+  ScrDyn *snapshot = buffers->kind == SCR_DYN_TYPED_REF && scr_dyn_isl_is_array(buffers)
+    ? scr_dyn_typed_ref_materialize(buffers) : NULL;
+  const ScrDyn *array = snapshot ? snapshot : buffers;
+  if (array->kind != SCR_DYN_ARR) {
+    scr_dyn_arg_type_fail("buffers", "an instance of Array", buffers);
+    scr_dyn_release(snapshot);
+    return NULL;
+  }
+  ScrArr *out = scr_arr_new_ref(scr_bytes_retain_v, scr_bytes_release_v, NULL, array->v.arr.len);
+  for (size_t i = 0; i < array->v.arr.len; i++) {
+    const ScrDyn *buffer = array->v.arr.items[i];
+    if (!scr_dyn_bytes_is(buffer, SCR_BYTES_U8)) {
+      scr_dyn_arg_type_fail("buffers", "an Array of ArrayBufferView", buffers);
+      scr_arr_release(out);
+      scr_dyn_release(snapshot);
+      return NULL;
+    }
+    /* push_ref consumes the reference produced by unbox. */
+    scr_arr_push_ref(out, scr_dyn_bytes_unbox(buffer));
+  }
+  scr_dyn_release(snapshot);
+  return out;
+}
 
 static ScrDyn *scr_fs_cb_invoke(ScrStr *member, ScrDyn *const *args, size_t argc) {
   const char *op = member->data;
+  if (!strcmp(op, "statfs")) {
+    const ScrDyn *options = scr_fs_cb_arg(args, argc, 1);
+    const ScrDyn *callback = options->kind == SCR_DYN_FUNC ? options : scr_fs_cb_arg(args, argc, 2);
+    if (!scr_fs_cb_chk(callback, "cb")) return NULL;
+    ScrStr *path = scr_fs_checked_path(scr_fs_cb_arg(args, argc, 0), "path");
+    if (!path) return NULL;
+    if (options->kind == SCR_DYN_FUNC) options = scr_dyn_undefined();
+    bool bigint = scr_fs_statfs_bigint(options);
+    /* FSReqCallback captures the first read; binding.statfs reads it again. */
+    if (!scr_exc_pending()) (void)scr_fs_statfs_bigint(options);
+    if (scr_exc_pending()) { scr_str_release(path); return NULL; }
+    ScrDyn *result = scr_fs_statfs(path, bigint);
+    scr_str_release(path);
+    scr_fs_cb_schedule(callback, result, NULL);
+    return scr_dyn_retain(scr_dyn_undefined());
+  }
+  if (!strcmp(op, "link") || !strcmp(op, "symlink") || !strcmp(op, "readlink")) {
+    const ScrDyn *first = scr_fs_cb_arg(args, argc, 0);
+    const ScrDyn *second = scr_fs_cb_arg(args, argc, 1);
+    bool symbolic = !strcmp(op, "symlink"), reading = !strcmp(op, "readlink");
+    const ScrDyn *third = scr_fs_cb_arg(args, argc, 2);
+    const ScrDyn *fourth = scr_fs_cb_arg(args, argc, 3);
+    const ScrDyn *callback = symbolic && fourth->kind != SCR_DYN_UNDEF ? fourth
+      : reading && second->kind == SCR_DYN_FUNC ? second : third;
+    int kind = -1;
+    if (symbolic && fourth->kind != SCR_DYN_UNDEF) {
+      kind = scr_fs_symlink_type(third);
+      if (scr_exc_pending()) return NULL;
+    } else if (!scr_fs_cb_chk(callback, "cb")) return NULL;
+    ScrDyn *encoding = reading ? scr_fs_readlink_encoding(second) : NULL;
+    if (reading && !encoding) return NULL;
+    ScrStr *from = scr_fs_checked_path(first, symbolic ? "target" : reading ? "path" : "existingPath");
+    if (!from) { scr_dyn_release(encoding); return NULL; }
+    ScrStr *to = reading ? NULL : scr_fs_checked_path(second, symbolic ? "path" : "newPath");
+    if ((!reading && !to) || (symbolic && fourth->kind != SCR_DYN_UNDEF && !scr_fs_cb_chk(callback, "cb"))) {
+      scr_str_release(from); scr_str_release(to); scr_dyn_release(encoding); return NULL;
+    }
+#ifdef _WIN32
+    if (symbolic) {
+      if (kind == 2 && scr_dyn_bytes_is(second, SCR_BYTES_U8)) {
+        scr_dyn_arg_type_fail("paths[0]", "of type string", second);
+        scr_str_release(from); scr_str_release(to); return NULL;
+      }
+      // Callback inference passes validated paths directly to path.resolve;
+      // Buffer paths fail that probe and fall back to a file link.
+      if (kind == -1 && (scr_dyn_bytes_is(first, SCR_BYTES_U8) || scr_dyn_bytes_is(second, SCR_BYTES_U8))) kind = 0;
+    }
+#endif
+    ScrDyn *result = NULL;
+    if (reading) result = scr_fs_readlink_result(from, encoding);
+    else if (symbolic) scr_fs_symlink(from, to, kind);
+    else scr_fs_link(from, to);
+    scr_str_release(from); scr_str_release(to); scr_dyn_release(encoding);
+    scr_fs_cb_schedule(callback, result, NULL);
+    return scr_dyn_retain(scr_dyn_undefined());
+  }
+  bool vector = !strcmp(op, "readv") || !strcmp(op, "writev");
+  bool timestamp = !strcmp(op, "utimes") || !strcmp(op, "lutimes") || !strcmp(op, "futimes");
+  bool timestamp_fd = !strcmp(op, "futimes");
+  double access = 0, modified = 0;
+  // futimes converts times before checking the callback; path variants do
+  // callback and path validation first. Validation failures throw immediately.
+  if (timestamp_fd && !scr_fs_callback_times(scr_fs_cb_arg(args, argc, 1), scr_fs_cb_arg(args, argc, 2), true, &access, &modified)) return NULL;
+  bool newControl = !strcmp(op, "fdatasync") || !strcmp(op, "fchmod") || !strcmp(op, "ftruncate");
+  if ((vector || newControl) && !scr_fs_int_range_chk(scr_fs_cb_arg(args, argc, 0), "fd", 0, 2147483647.0, ">= 0 && <= 2147483647")) return NULL;
+  ScrArr *vectors = vector ? scr_fs_cb_vectors(scr_fs_cb_arg(args, argc, 1)) : NULL;
+  if (vector && !vectors) return NULL;
   bool fileCallback = !strcmp(op, "readFile") || !strcmp(op, "mkdtemp");
-  const ScrDyn *callback = argc >= (fileCallback ? 2u : 1u) ? args[argc - 1] : scr_dyn_undefined();
-  if (!scr_fs_cb_chk(callback, fileCallback ? "cb" : "callback")) return NULL;
-  size_t count = argc - 1;
+  const ScrDyn *callback = timestamp ? scr_fs_cb_arg(args, argc, 3)
+    : argc >= (fileCallback ? 2u : 1u) ? args[argc - 1] : scr_dyn_undefined();
+  if (!scr_fs_cb_chk(callback, fileCallback || vector || timestamp ? "cb" : "callback")) { scr_arr_release(vectors); return NULL; }
+  size_t count = timestamp ? argc : argc - 1;
 #define ARG(index) scr_fs_cb_arg(args, count, index)
   if (!strcmp(op, "readFile") && !scr_fs_encoding_chk(ARG(1))) return NULL;
   if (!strcmp(op, "read") && count >= 4 && !scr_fs_read_validate(ARG(0), ARG(1), ARG(2), ARG(3), ARG(4))) return NULL;
-  bool descriptor = !strcmp(op, "close") || !strcmp(op, "fstat") || !strcmp(op, "ftruncate") || !strcmp(op, "fsync") || !strcmp(op, "read") || !strcmp(op, "write");
-  ScrStr *path = descriptor ? NULL : scr_fs_cb_path(ARG(0), !strcmp(op, "mkdtemp") ? "prefix" : "path");
+  bool descriptor = timestamp_fd || vector || newControl || !strcmp(op, "close") || !strcmp(op, "fstat") || !strcmp(op, "fsync") || !strcmp(op, "read") || !strcmp(op, "write");
+  ScrStr *path = descriptor ? NULL : timestamp ? scr_fs_timestamp_path(ARG(0)) : scr_fs_cb_path(ARG(0), !strcmp(op, "mkdtemp") ? "prefix" : "path");
   if (!descriptor && !path) return NULL;
+  if (timestamp && !timestamp_fd && !scr_fs_callback_times(ARG(1), ARG(2), false, &access, &modified)) { scr_str_release(path); return NULL; }
+  if (timestamp_fd && !scr_fs_int_range_chk(ARG(0), "fd", 0, 2147483647.0, ">= 0 && <= 2147483647")) return NULL;
   double fd = descriptor ? scr_fs_cb_number(ARG(0), "fd", -1) : -1;
-  if (scr_exc_pending()) { scr_str_release(path); return NULL; }
+  if (scr_exc_pending()) { scr_str_release(path); scr_arr_release(vectors); return NULL; }
+  if (newControl && strcmp(op, "fdatasync")) {
+    const ScrDyn *value = ARG(1);
+    if (strcmp(op, "ftruncate") || value->kind != SCR_DYN_UNDEF) {
+      bool chmod = !strcmp(op, "fchmod");
+      if (chmod ? !scr_fs_mode_chk(value, "mode") : !scr_fs_int_range_chk(value, "len", -9007199254740991.0, 9007199254740991.0, ">= -9007199254740991 && <= 9007199254740991")) return NULL;
+    }
+  }
   ScrDyn *result = NULL;
   const ScrDyn *buffer = NULL;
   if (!strcmp(op, "readFile")) {
@@ -535,6 +837,14 @@ static ScrDyn *scr_fs_cb_invoke(ScrStr *member, ScrDyn *const *args, size_t argc
   else if (!strcmp(op, "fstat")) result = scr_fs_cb_stats(NULL, fd, ARG(1), false);
   else if (!strcmp(op, "close")) scr_fs_close(fd);
   else if (!strcmp(op, "fsync")) scr_fs_fsync(fd);
+  else if (!strcmp(op, "fdatasync")) scr_fs_fdatasync(fd);
+  else if (!strcmp(op, "fchmod")) scr_fs_fchmod(fd, ARG(1)->kind == SCR_DYN_STR ? (double)strtol(ARG(1)->v.str->data, NULL, 8) : ARG(1)->v.num);
+  else if (vector) {
+    double position = ARG(2)->kind == SCR_DYN_NUM ? ARG(2)->v.num : -1;
+    result = scr_dyn_new_num(!strcmp(op, "readv") ? scr_fs_readv_sync(fd, vectors, position) : scr_fs_writev_sync(fd, vectors, position));
+    scr_arr_release(vectors);
+    buffer = ARG(1);
+  }
   else if (!strcmp(op, "open")) {
     double opened = scr_fs_cb_open(path, ARG(1), scr_fs_cb_number(ARG(2), "mode", 0666), "r");
     if (!scr_exc_pending()) result = scr_dyn_new_num(opened);
@@ -599,11 +909,10 @@ static ScrDyn *scr_fs_cb_invoke(ScrStr *member, ScrDyn *const *args, size_t argc
       scr_dyn_release(ownedBuffer); scr_str_release(path);
       return scr_dyn_retain(scr_dyn_undefined());
     }
-  } else if (!strcmp(op, "copyFile") || !strcmp(op, "rename") || !strcmp(op, "link") || !strcmp(op, "symlink")) {
+  } else if (!strcmp(op, "copyFile") || !strcmp(op, "rename")) {
     ScrStr *destination = scr_fs_cb_path(ARG(1), "dest");
     if (destination) {
       if (!strcmp(op, "rename")) scr_fs_rename(path, destination);
-      else if (!strcmp(op, "link")) scr_fs_link(path, destination);
       else if (!strcmp(op, "copyFile")) {
         double flags = scr_fs_cb_number(ARG(2), "mode", 0);
         if (flags == 1 && scr_fs_exists(destination)) scr_fs_throw(EEXIST, "copyfile", destination);
@@ -612,50 +921,17 @@ static ScrDyn *scr_fs_cb_invoke(ScrStr *member, ScrDyn *const *args, size_t argc
           scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
         } else if (!scr_exc_pending()) scr_fs_copyfile(path, destination);
       }
-      else {
-#if !defined(_WIN32)
-        if (symlink(path->data, destination->data) < 0) scr_fs_throw(errno, "symlink", path);
-#else
-        scr_fs_throw(ENOSYS, "symlink", path);
-#endif
-      }
       scr_str_release(destination);
     }
   } else if (!strcmp(op, "truncate") || !strcmp(op, "ftruncate")) {
     double length = scr_fs_cb_number(ARG(1), "len", 0);
     if (!scr_exc_pending()) {
-      int rc = descriptor ? ftruncate((int)fd, (off_t)length) : truncate(path->data, (off_t)length);
-      if (rc < 0) scr_fs_throw(errno, descriptor ? "ftruncate" : "truncate", path);
+      if (descriptor) scr_fs_ftruncate(fd, length);
+      else if (truncate(path->data, (off_t)length) < 0) scr_fs_throw(errno, "truncate", path);
     }
-  } else if (!strcmp(op, "readlink")) {
-#ifndef _WIN32
-    size_t capacity = 256;
-    char *text = NULL;
-    for (;;) {
-      char *grown = realloc(text, capacity);
-      if (!grown) scr_bytes_io_oom();
-      text = grown;
-      ssize_t size = readlink(path->data, text, capacity);
-      if (size < 0) { scr_fs_throw(errno, "readlink", path); break; }
-      if ((size_t)size < capacity) { result = scr_fs_cb_string(scr_str_new(text, (size_t)size)); break; }
-      capacity *= 2;
-    }
-    free(text);
-#else
-    scr_fs_throw(ENOSYS, "readlink", path);
-#endif
-  } else if (!strcmp(op, "utimes")) {
-    double access = scr_fs_to_unix_timestamp(ARG(1)), modified = scr_fs_to_unix_timestamp(ARG(2));
-#if !defined(_WIN32)
-    struct timespec times[2] = {
-      { (time_t)floor(access), (long)((access - floor(access)) * 1000000000) },
-      { (time_t)floor(modified), (long)((modified - floor(modified)) * 1000000000) },
-    };
-    if (!scr_exc_pending() && utimensat(AT_FDCWD, path->data, times, 0) < 0) scr_fs_throw(errno, "utime", path);
-#else
-    struct utimbuf times = { (time_t)access, (time_t)modified };
-    if (!scr_exc_pending() && utime(path->data, &times) < 0) scr_fs_throw(errno, "utime", path);
-#endif
+  } else if (timestamp) {
+    if (timestamp_fd) scr_fs_futimes(fd, access, modified);
+    else scr_fs_utimes(path, access, modified, !strcmp(op, "lutimes"));
   } else if (!strcmp(op, "readdir")) {
     if (scr_fs_cb_refuse_option(ARG(1), "encoding") || scr_fs_cb_option_bool(ARG(1), "withFileTypes") || scr_fs_cb_option_bool(ARG(1), "recursive")) {
       if (!scr_exc_pending()) { const char *message = "Recursive readdir and Dirent results have no native lowering"; scr_throw_error_msg_code(SCR_ERR_ERROR, message, strlen(message), "SC2020"); }
@@ -882,10 +1158,11 @@ ScrBytes *scr_buffer_new_string_fail(const ScrDyn *got) {
  * its time arguments (fs.js's toUnixTimestamp, underscore-exported):
  * numeric STRINGS pass ToNumber's loose-equality gate (+time == time —
  * whitespace-only strings answer 0), finite numbers pass (negatives
- * answer now/1000, Node's "past times" shape), everything else throws
+ * answer now/1000, Node's "past times" shape), Dates supply milliseconds,
+ * and everything else throws
  * Node's exact ERR_INVALID_ARG_TYPE. Borrowed; the throw is pending on
  * the dummy 0 return. */
-double scr_fs_to_unix_timestamp(const ScrDyn *t) {
+double scr_fs_timestamp_value(const ScrDyn *t, const char *name) {
   if (t->kind == SCR_DYN_STR) {
     double n = scr_string_to_number(t->v.str);
     /* +time == time: NaN fails; every parsed number loosely equals its
@@ -896,14 +1173,41 @@ double scr_fs_to_unix_timestamp(const ScrDyn *t) {
     if (t->v.num < 0) {
       struct timespec ts;
       clock_gettime(CLOCK_REALTIME, &ts);
-      return ((double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1e6) / 1000.0;
+      return ((double)ts.tv_sec * 1000.0 + (double)(ts.tv_nsec / 1000000)) / 1000.0;
     }
     return t->v.num;
   }
-  scr_dyn_arg_type_fail("time", "an instance of Date or an Time in seconds", t);
+  if (scr_dyn_native_date_is(t)) return scr_dyn_native_date_value(t) / 1000.0;
+  scr_dyn_arg_type_fail(name, "an instance of Date or an Time in seconds", t);
   return 0;
 }
 
+double scr_fs_to_unix_timestamp(const ScrDyn *t) {
+  return scr_fs_timestamp_value(t, "time");
+}
+
+static void scr_fs_path_times_checked(const ScrDyn *input, const ScrDyn *atime, const ScrDyn *mtime, bool nofollow) {
+  ScrStr *path = scr_fs_timestamp_path(input);
+  if (!path) return;
+  double access, modified;
+  if (scr_fs_callback_times(atime, mtime, false, &access, &modified)) scr_fs_utimes(path, access, modified, nofollow);
+  scr_str_release(path);
+}
+
+void scr_fs_utimes_checked(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime) {
+  scr_fs_path_times_checked(path, atime, mtime, false);
+}
+
+void scr_fs_lutimes_checked(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime) {
+  scr_fs_path_times_checked(path, atime, mtime, true);
+}
+
+void scr_fs_futimes_checked(const ScrDyn *fd, const ScrDyn *atime, const ScrDyn *mtime) {
+  double access, modified;
+  if (!scr_fs_callback_times(atime, mtime, true, &access, &modified)) return;
+  if (scr_fs_int_range_chk(fd, "fd", 0, 2147483647.0, ">= 0 && <= 2147483647")) scr_fs_futimes(fd->v.num, access, modified);
+}
+
 /* ── the fs argument-validation ladders (checked-dynamic lane) ─────────
  * Each fs.*Chk libCall replicates its API's Node-order validation over
  * dyn values and throws Node's exact typed errors; when every validation

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

@@ -9,7 +9,7 @@ void scr_crypto_random_bytes_async(double size, ScrClosure *cb, ScrCryptoBytesFn
     scr_closure_release(cb);
     return;
   }
-  scr_crypto_defer_bytes(value, cb, fn);
+  scr_crypto_defer_bytes(value, NULL, cb, fn);
 }
 
 void scr_crypto_pbkdf2_async(ScrBytes *password, ScrBytes *salt,
@@ -20,5 +20,25 @@ void scr_crypto_pbkdf2_async(ScrBytes *password, ScrBytes *salt,
     scr_closure_release(cb);
     return;
   }
-  scr_crypto_defer_bytes(value, cb, fn);
+  scr_crypto_defer_bytes(value, NULL, cb, fn);
+}
+
+void scr_crypto_hkdf_async(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                           ScrBytes *info, double keylen, ScrClosure *cb, ScrCryptoBytesFn fn) {
+  ScrBytes *value = scr_crypto_hkdf_bytes(digest, ikm, salt, info, keylen);
+  if (scr_exc_pending()) { scr_closure_release(cb); return; }
+  if (value->len == 0) {
+    scr_bytes_release(value);
+    ScrStr *message = scr_str_new("Deriving bits failed", 20);
+    ScrError *error = scr_error_new(SCR_ERR_ERROR, message);
+    scr_str_release(message);
+    scr_crypto_defer_bytes(NULL, error, cb, fn);
+  } else scr_crypto_defer_bytes(value, NULL, cb, fn);
+}
+
+void scr_crypto_scrypt_async(ScrBytes *password, ScrBytes *salt, double keylen,
+                             ScrDyn *options, ScrClosure *cb, ScrCryptoBytesFn fn) {
+  ScrBytes *value = scr_crypto_scrypt(password, salt, keylen, options);
+  if (scr_exc_pending()) { scr_closure_release(cb); return; }
+  scr_crypto_defer_bytes(value, NULL, cb, fn);
 }