@scriptc/cli-darwin-x64 0.2.1 → 0.2.2

package/dist/lib/runtime-sources/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "scriptc native runtime sources and vendored dependencies",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

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

@@ -0,0 +1,5 @@
+/* Portable AbortController/AbortSignal use the same implementation as native
+ * fetch, without its network transport, Web Streams, or global fetch setup. */
+#undef SCR_DYNAMIC
+#define SCR_FETCH_SIGNAL_ONLY 1
+#include "scr_fetch.c"

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

@@ -1259,8 +1259,10 @@ static void scr_fiber_finish(ScrFiber *self) {
      * (moved from the fiber's cell into the promise). */
     scr_promise_reject_from_cell(p, &self->exc);
   }
-  /* Fulfillment payload was stored by the trampoline before finishing. */
-  scr_promise_settle_wake(p);
+  /* A returned checked promise may still be resolving after its function
+   * body finishes. Its resolver owns settlement and must not wake awaiters
+   * until adoption completes (WASI continuations cannot park a C stack). */
+  if (p->state != SCR_PROM_PENDING) scr_promise_settle_wake(p);
   self->done = true;
 }
 
@@ -2146,6 +2148,7 @@ void scr_fs_rename_thunk0(ScrClosure *cb, ScrError *err) {
  * the emitted callback adapter. */
 typedef struct ScrCryptoBytesOp {
   ScrBytes *value;
+  ScrError *error;
   ScrClosure *cb;
   ScrCryptoBytesFn fn;
   struct ScrCryptoBytesOp *next;
@@ -2161,6 +2164,7 @@ static void scr_crypto_bytes_shutdown(void) {
     ScrCryptoBytesOp *op = scr_crypto_bytes_head;
     scr_crypto_bytes_head = op->next;
     scr_bytes_release(op->value);
+    scr_error_release(op->error);
     scr_closure_release(op->cb);
     free(op);
   }
@@ -2178,16 +2182,18 @@ static bool scr_crypto_bytes_dispatch(void) {
   scr_crypto_bytes_head = op->next;
   if (scr_crypto_bytes_head == NULL) scr_crypto_bytes_tail = &scr_crypto_bytes_head;
   scr_crypto_bytes_pending_count--;
-  op->fn(op->cb, op->value); /* adapter consumes value */
+  op->fn(op->cb, op->error, op->value); /* adapter consumes value */
+  scr_error_release(op->error);
   scr_closure_release(op->cb);
   free(op);
   return true;
 }
 
-void scr_crypto_defer_bytes(ScrBytes *value, ScrClosure *cb, ScrCryptoBytesFn fn) {
+void scr_crypto_defer_bytes(ScrBytes *value, ScrError *error, ScrClosure *cb, ScrCryptoBytesFn fn) {
   if (!scr_crypto_bytes_cleanup_registered) {
     if (atexit(scr_crypto_bytes_shutdown) != 0) {
       scr_bytes_release(value);
+      scr_error_release(error);
       scr_closure_release(cb);
       scr_trap("scriptc: could not register crypto callback cleanup\n");
     }
@@ -2196,10 +2202,12 @@ void scr_crypto_defer_bytes(ScrBytes *value, ScrClosure *cb, ScrCryptoBytesFn fn
   ScrCryptoBytesOp *op = malloc(sizeof *op);
   if (!op) {
     scr_bytes_release(value);
+    scr_error_release(error);
     scr_closure_release(cb);
     scr_trap("scriptc: out of memory\n");
   }
   op->value = value;
+  op->error = error;
   op->cb = cb;
   op->fn = fn;
   op->next = NULL;

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

@@ -421,6 +421,24 @@ typedef struct {
   ScrDyn *onf, *onr, *onfin; /* owned or NULL */
 } ScrDynThenPack;
 
+typedef struct {
+  ScrPromise *src, *dst;
+  ScrDyn *result;
+} ScrDynFinallyPack;
+
+static void scr_dyn_finally_entry(ScrFiber *self, void *opaque) {
+  (void)self;
+  ScrDynFinallyPack *pack = opaque;
+  ScrDyn *result = scr_await_dyn(pack->result->v.promise);
+  if (scr_exc_pending()) scr_promise_reject_pending(pack->dst);
+  else scr_promise_adapt_copy(pack->dst, pack->src);
+  scr_dyn_release(result);
+  scr_dyn_release(pack->result);
+  scr_promise_release(pack->src);
+  scr_promise_release(pack->dst);
+  free(pack);
+}
+
 static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
   (void)self;
   ScrDynThenPack *a = (ScrDynThenPack *)ap;
@@ -428,7 +446,7 @@ static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
   bool rejected = scr_exc_pending();
   ScrCaught *c = rejected ? scr_exc_take() : NULL;
   ScrDyn *handler = a->onfin ? a->onfin : (rejected ? a->onr : a->onf);
-  if (handler != NULL && handler->kind == SCR_DYN_FUNC) {
+  if (handler != NULL && scr_dyn_is_callable(handler)) {
     ScrDyn *arg = NULL;
     if (a->onfin == NULL) arg = rejected ? scr_caught_to_dyn(c) : scr_dyn_retain(v);
     ScrDyn *r = scr_dyn_call(handler, arg ? &arg : NULL, arg ? 1 : 0, "handler");
@@ -437,30 +455,27 @@ static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
       /* The handler threw: dst rejects with that. */
       scr_promise_reject_pending(a->dst);
     } else if (a->onfin != NULL) {
-      /* finally: the callback's value is dropped and the source
-       * settlement passes through (JS — a finally callback returning a
-       * promise would delay adoption; that refinement waits for a use). */
-      scr_dyn_release(r);
-      if (rejected) {
-        scr_rethrow(c);
-        scr_promise_reject_pending(a->dst);
-      } else {
-        scr_promise_fulfill_ref(a->dst, scr_dyn_retain(v), scr_dyn_retain_v, scr_dyn_release_v, NULL);
+      /* finally returns PromiseResolve(result).then(valueThunk), which
+       * the outer reaction adopts. Even an undefined result takes those
+       * jobs before propagating the original fulfillment or rejection. */
+      if (r->kind != SCR_DYN_PROMISE) {
+        ScrPromise *result = scr_promise_new();
+        scr_promise_fulfill_ref(result, r, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+        r = scr_dyn_new_promise(result);
+        scr_promise_release(result);
       }
+      ScrPromise *passthrough = scr_promise_new();
+      ScrDynFinallyPack *pack = malloc(sizeof *pack);
+      if (!pack) scr_ad_oom();
+      pack->src = scr_promise_retain(a->src);
+      pack->dst = scr_promise_retain(passthrough);
+      pack->result = r;
+      ScrPromise *waiter = scr_async_spawn_after(r->v.promise, scr_dyn_finally_entry, pack);
+      scr_promise_release(waiter);
+      scr_promise_resolve_dyn(a->dst, scr_dyn_new_promise(passthrough));
+      scr_promise_release(passthrough);
     } else {
-      /* Adopt dyn-promise results (JS's resolve walk). */
-      while (r != NULL && r->kind == SCR_DYN_PROMISE) {
-        ScrDyn *inner = scr_await_dyn(r->v.promise);
-        scr_dyn_release(r);
-        r = inner;
-        if (scr_exc_pending()) {
-          scr_promise_reject_pending(a->dst);
-          break;
-        }
-      }
-      if (r != NULL) {
-        scr_promise_fulfill_ref(a->dst, r, scr_dyn_retain_v, scr_dyn_release_v, NULL);
-      }
+      scr_promise_resolve_dyn(a->dst, r);
     }
   } else if (rejected) {
     scr_rethrow(c);
@@ -492,7 +507,7 @@ ScrDyn *scr_dyn_promise_then(ScrPromise *src, ScrDyn *onf, ScrDyn *onr, ScrDyn *
   a->onr = onr ? scr_dyn_retain(onr) : NULL;
   a->onfin = onfin ? scr_dyn_retain(onfin) : NULL;
   ScrDyn *boxed = scr_dyn_new_promise(a->dst);
-  ScrPromise *waiter = scr_async_spawn(scr_dyn_then_entry, a);
+  ScrPromise *waiter = scr_async_spawn_after(src, scr_dyn_then_entry, a);
   scr_promise_release(waiter); /* the entry never rejects; nobody awaits it */
   return boxed;
 }
@@ -504,8 +519,10 @@ typedef struct {
 static void scr_dyn_resolve_entry(ScrFiber *self, void *opaque) {
   (void)self;
   ScrDynResolvePack *pack = opaque;
+#ifndef __wasi__
   /* Promise resolution schedules a job before attaching its reaction. */
   scr_await_hop();
+#endif
   ScrDyn *value = scr_await_dyn(pack->value->v.promise);
   if (scr_exc_pending()) scr_promise_reject_pending(pack->destination);
   else scr_promise_resolve_dyn(pack->destination, value);
@@ -514,6 +531,19 @@ static void scr_dyn_resolve_entry(ScrFiber *self, void *opaque) {
   free(pack);
 }
 
+#ifdef __wasi__
+static void scr_dyn_resolve_job(ScrClosure *closure) {
+  ScrPromise *destination = scr_box_get_ref(closure->caps[0]);
+  ScrDyn *value = scr_box_get_ref(closure->caps[1]);
+  ScrDynResolvePack *pack = malloc(sizeof *pack);
+  if (!pack) scr_ad_oom();
+  pack->destination = destination;
+  pack->value = value;
+  ScrPromise *waiter = scr_async_spawn_after(value->v.promise, scr_dyn_resolve_entry, pack);
+  scr_promise_release(waiter);
+}
+#endif
+
 /* The destination is borrowed; value moves in. An async function may
  * return a native promise hidden behind any/unknown without an explicit
  * await, so its completion must use resolution rather than fulfillment. */
@@ -529,12 +559,21 @@ void scr_promise_resolve_dyn(ScrPromise *destination, ScrDyn *value) {
     scr_dyn_release(value);
     return;
   }
+#ifdef __wasi__
+  ScrClosure *job = scr_closure_new((void *)scr_dyn_resolve_job, 2);
+  job->caps[0] = scr_box_new_obj(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v);
+  scr_box_set_ref(job->caps[0], scr_promise_retain(destination));
+  job->caps[1] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+  scr_box_set_ref(job->caps[1], value);
+  scr_queue_microtask(job);
+#else
   ScrDynResolvePack *pack = malloc(sizeof *pack);
   if (!pack) scr_ad_oom();
   pack->destination = scr_promise_retain(destination);
   pack->value = value;
   ScrPromise *waiter = scr_async_spawn(scr_dyn_resolve_entry, pack);
   scr_promise_release(waiter);
+#endif
 }
 
 /* `await v` where v is a CHECKED-DYNAMIC value: a dyn promise adopts
@@ -548,6 +587,13 @@ ScrDyn *scr_await_dyn_value(ScrDyn *v) {
   return scr_dyn_retain(v);
 }
 
+/* The WASI emitter has already suspended on the value's actual promise,
+ * or taken the non-promise microtask hop. Extraction must never suspend a
+ * runtime-authored C frame. */
+ScrDyn *scr_await_dyn_value_settled(ScrDyn *value) {
+  return value->kind == SCR_DYN_PROMISE ? scr_await_dyn(value->v.promise) : scr_dyn_retain(value);
+}
+
 /* ── process warnings (emitWarning + the 'warning' event) ─────────────
  * Gated with the rest of this TU (a deprecation-emitting unit's gate
  * must imply the dynAsync link). Listeners are dyn functions; emission
@@ -834,6 +880,54 @@ ScrPromise *scr_dyn_promise_of(const ScrDyn *d) {
   return d->kind == SCR_DYN_PROMISE ? d->v.promise : NULL;
 }
 
+static void scr_dyn_all_result(ScrPromise *destination, ScrPromise *source) {
+  ScrArr *values = scr_promise_payload_ref(source);
+  ScrDyn *result = scr_dyn_new_arr();
+  for (size_t i = 0; i < values->len; i++) scr_dyn_arr_push(result, scr_arr_get_ref(values, (double)i));
+  scr_arr_release(values);
+  scr_promise_fulfill_ref(destination, result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+}
+
+ScrPromise *scr_dyn_promise_all(const ScrDyn *entries) {
+  ScrArr *promises = scr_arr_new_ref(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v, entries->v.arr.len);
+  ScrArr *values = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, entries->v.arr.len);
+  for (size_t i = 0; i < entries->v.arr.len; i++) {
+    ScrDyn *value = entries->v.arr.items[i];
+    ScrPromise *source;
+    if (value->kind == SCR_DYN_PROMISE) source = scr_promise_retain(value->v.promise);
+    else {
+      source = scr_promise_new();
+      if (value->kind == SCR_DYN_OBJ || value->kind == SCR_DYN_FUNC || value->kind == SCR_DYN_PROXY) {
+        ScrStr *key = scr_str_new("then", 4);
+        ScrDyn *then = value->kind == SCR_DYN_PROXY ? scr_dyn_proxy_get(value, key)
+          : value->kind == SCR_DYN_FUNC ? scr_dyn_fn_get(value, "then", 4) : scr_dyn_obj_read(value, "then", 4);
+        scr_str_release(key);
+        if (then && then->kind == SCR_DYN_FUNC) {
+          static const char message[] = "Promise.all over custom thenables is not supported yet";
+          scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+        }
+        scr_dyn_release(then);
+      }
+      if (scr_exc_pending()) scr_promise_reject_pending(source);
+      else scr_promise_fulfill_ref(source, scr_dyn_retain(value), scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+    }
+    /* Each element contributes a reaction job, even an already fulfilled
+     * plain value. The aggregate preserves input order and Node's hops. */
+    scr_promise_mark_handled(source);
+    ScrDyn *reaction = scr_dyn_promise_then(source, NULL, NULL, NULL);
+    scr_arr_push_ref(promises, scr_promise_retain(reaction->v.promise));
+    scr_dyn_release(reaction);
+    scr_promise_release(source);
+  }
+  ScrPromise *all = scr_promise_all(promises, values, scr_promise_all_store_ref);
+  ScrPromise *result = scr_promise_new();
+  scr_promise_race_add(result, all, scr_dyn_all_result);
+  scr_promise_release(all);
+  scr_arr_release(values);
+  scr_arr_release(promises);
+  return result;
+}
+
 /* The checked native WebCrypto digest entry keeps promise and ArrayBuffer results native. */
 static ScrDyn *scr_crypto_digest_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
   (void)closure;

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

@@ -57,6 +57,21 @@ double scr_text_decoder_encoding(const ScrDyn *label) {
   return -1;
 }
 
+ScrStr *scr_text_decoder_name(double encoding) {
+  static const char *names[] = {
+    "ibm866", "iso-8859-2", "iso-8859-3", "iso-8859-4", "iso-8859-5",
+    "iso-8859-6", "iso-8859-7", "iso-8859-8", "iso-8859-10", "iso-8859-13",
+    "iso-8859-14", "iso-8859-15", "iso-8859-16", "koi8-r", "koi8-u",
+    "macintosh", "windows-874", "windows-1250", "windows-1251", "windows-1252",
+    "windows-1253", "windows-1254", "windows-1255", "windows-1256", "windows-1257",
+    "windows-1258", "x-mac-cyrillic", "x-user-defined", "utf-16le", "utf-16be",
+    "gb18030", "big5", "euc-jp", "iso-2022-jp", "shift_jis", "euc-kr",
+    "iso-8859-8-i", "gbk",
+  };
+  const char *name = encoding < 0 ? "utf-8" : names[(unsigned)encoding];
+  return scr_str_new(name, strlen(name));
+}
+
 #ifdef SCR_RC_AUDIT
 static SCR_TL long scr_live_bytes = 0;
 long scr_bytes_live_count(void) { return scr_live_bytes; }
@@ -1675,6 +1690,8 @@ static ScrStr *scr_td_iso_2022_jp_decode(const ScrBytes *b, bool fatal) {
 
 ScrStr *scr_text_decode_legacy_options(const ScrBytes *b, double encoding_value, bool fatal, bool ignore_bom) {
   unsigned encoding = (unsigned)encoding_value;
+  if (encoding == 36) encoding = 7; /* ISO-8859-8-I */
+  if (encoding == 37) encoding = SCR_TD_GB18030; /* GBK */
   if (encoding < SCR_TD_SINGLE_COUNT) return scr_td_single_byte(b, encoding, fatal);
   switch (encoding) {
     case SCR_TD_X_USER_DEFINED: return scr_td_x_user_defined(b, fatal);
@@ -1712,6 +1729,7 @@ static size_t scr_td_utf8_tail(const uint8_t *bytes, size_t n) {
 
 ScrStr *scr_text_decode_stream(ScrDyn *state, const ScrBytes *input,
     double encoding, bool fatal, bool ignore_bom, bool stream) {
+  if (encoding == 36) encoding = 7; /* ISO-8859-8-I is a single-byte decoder. */
   ScrDyn *saved = scr_dyn_obj_read(state, "pending", 7);
   size_t pending = saved->kind == SCR_DYN_BYTES ? saved->v.bytes->len : 0;
   if (input->len > SIZE_MAX - pending) scr_bytes_oom();
@@ -1785,6 +1803,214 @@ static uint32_t scr_bytes_next_cp(const uint8_t *in, size_t *ip) {
   return cp;
 }
 
+/* encodeInto consumes complete Unicode scalars while counting UTF-16 units.
+ * Borrow the destination so writes through a subarray retain their aliasing. */
+ScrDyn *scr_text_encode_into(const ScrDyn *source, const ScrDyn *destination) {
+  if (source->kind != SCR_DYN_STR) {
+    scr_dyn_arg_type_fail("src", "of type string", source);
+    return NULL;
+  }
+  if (destination->kind != SCR_DYN_BYTES || destination->v.bytes->elem != SCR_BYTES_U8 || destination->v.bytes->is_data_view) {
+    scr_dyn_arg_type_fail("dest", "an instance of Uint8Array", destination);
+    return NULL;
+  }
+  const ScrStr *text = source->v.str;
+  ScrBytes *dest = destination->v.bytes;
+  size_t read = 0, written = 0;
+  while (written < text->len) {
+    size_t end = written;
+    uint32_t cp = scr_bytes_next_cp((const uint8_t *)text->data, &end);
+    if (end > dest->len) break;
+    read += cp > 0xffff ? 2 : 1;
+    written = end;
+  }
+  if (written) memcpy(dest->data, text->data, written);
+  ScrDyn *result = scr_dyn_new_obj();
+  scr_dyn_obj_set(result, "read", 4, scr_dyn_new_num((double)read));
+  scr_dyn_obj_set(result, "written", 7, scr_dyn_new_num((double)written));
+  return result;
+}
+
+static ScrBytes *scr_buffer_validation_input(const ScrDyn *input) {
+  if ((input->kind == SCR_DYN_BYTES && !input->v.bytes->is_data_view) || scr_array_buffer_is(input)) {
+    return scr_bytes_buffer_source(input);
+  }
+  scr_dyn_arg_type_fail("input", "an instance of ArrayBuffer, Buffer, or TypedArray", input);
+  return NULL;
+}
+
+static bool scr_buffer_utf8_valid(const uint8_t *data, size_t len) {
+  size_t i = 0;
+  while (i < len) {
+    unsigned byte = data[i++], count;
+    unsigned low = 0x80, high = 0xbf;
+    if (byte < 0x80) continue;
+    if (byte >= 0xc2 && byte <= 0xdf) count = 1;
+    else if (byte >= 0xe0 && byte <= 0xef) {
+      count = 2;
+      if (byte == 0xe0) low = 0xa0;
+      if (byte == 0xed) high = 0x9f;
+    } else if (byte >= 0xf0 && byte <= 0xf4) {
+      count = 3;
+      if (byte == 0xf0) low = 0x90;
+      if (byte == 0xf4) high = 0x8f;
+    } else return false;
+    if (count > len - i || data[i] < low || data[i] > high) return false;
+    i++;
+    for (unsigned j = 1; j < count; j++, i++) if (data[i] < 0x80 || data[i] > 0xbf) return false;
+  }
+  return true;
+}
+
+bool scr_buffer_is_ascii(const ScrDyn *input) {
+  ScrBytes *bytes = scr_buffer_validation_input(input);
+  if (!bytes) return false;
+  bool result = true;
+  for (size_t i = 0; i < bytes->len; i++) if (bytes->data[i] > 0x7f) { result = false; break; }
+  scr_bytes_release(bytes);
+  return result;
+}
+
+bool scr_buffer_is_utf8(const ScrDyn *input) {
+  ScrBytes *bytes = scr_buffer_validation_input(input);
+  if (!bytes) return false;
+  bool result = scr_buffer_utf8_valid(bytes->data, bytes->len);
+  scr_bytes_release(bytes);
+  return result;
+}
+
+/* Node's ICU wrapper recognizes Buffer encoding aliases. Empty inputs return
+ * before resolving either encoding. The four actual converter families are
+ * implemented here without adding an ICU dependency to a native binary. */
+enum { SCR_TC_UTF8, SCR_TC_ASCII, SCR_TC_LATIN1, SCR_TC_UTF16 };
+
+static int scr_transcode_encoding(const ScrDyn *value) {
+  if (value->kind == SCR_DYN_NULL || value->kind == SCR_DYN_UNDEF ||
+      (value->kind == SCR_DYN_STR && value->v.str->len == 0)) return SCR_TC_UTF8;
+  if (value->kind != SCR_DYN_STR) return -1;
+  const ScrStr *name = value->v.str;
+  static const struct { const char *name; int encoding; } aliases[] = {
+    {"utf8", SCR_TC_UTF8}, {"utf-8", SCR_TC_UTF8}, {"ascii", SCR_TC_ASCII},
+    {"latin1", SCR_TC_LATIN1}, {"binary", SCR_TC_LATIN1},
+    {"utf16le", SCR_TC_UTF16}, {"utf-16le", SCR_TC_UTF16},
+    {"ucs2", SCR_TC_UTF16}, {"ucs-2", SCR_TC_UTF16},
+  };
+  for (size_t i = 0; i < sizeof aliases / sizeof aliases[0]; i++) {
+    if (strlen(aliases[i].name) != name->len) continue;
+    bool match = true;
+    for (size_t j = 0; j < name->len; j++) {
+      unsigned char c = (unsigned char)name->data[j];
+      if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
+      if (c != (unsigned char)aliases[i].name[j]) { match = false; break; }
+    }
+    if (match) return aliases[i].encoding;
+  }
+  return -1;
+}
+
+static ScrBytes *scr_transcode_error(bool invalid_data) {
+  const char *code = invalid_data ? "U_INVALID_CHAR_FOUND" : "U_ILLEGAL_ARGUMENT_ERROR";
+  char message[100];
+  int length = snprintf(message, sizeof message, "Unable to transcode Buffer [%s]", code);
+  ScrStr *text = scr_str_new(message, (size_t)length);
+  ScrError *error = scr_error_new(SCR_ERR_ERROR, text);
+  scr_str_release(text);
+  scr_error_set_code(error, code);
+  scr_throw_obj(error, &scr_error_retain_v, &scr_error_release_v, scr_error_trace_arg());
+  return NULL;
+}
+
+/* ICU's pinned substitute callback skips unmappable default-ignorable code
+ * points. Mappable Latin-1 characters (including soft hyphen) still survive. */
+static bool scr_transcode_ignorable(uint32_t cp) {
+  return cp == 0xad || cp == 0x34f || cp == 0x61c || cp == 0x115f || cp == 0x1160 ||
+    (cp >= 0x17b4 && cp <= 0x17b5) || (cp >= 0x180b && cp <= 0x180f) ||
+    (cp >= 0x200b && cp <= 0x200f) || (cp >= 0x202a && cp <= 0x202e) ||
+    (cp >= 0x2060 && cp <= 0x206f) || cp == 0x3164 ||
+    (cp >= 0xfe00 && cp <= 0xfe0f) || cp == 0xfeff || cp == 0xffa0 ||
+    (cp >= 0xfff0 && cp <= 0xfff8) || (cp >= 0x1bca0 && cp <= 0x1bca3) ||
+    (cp >= 0x1d173 && cp <= 0x1d17a) || (cp >= 0xe0000 && cp <= 0xe0fff);
+}
+
+static size_t scr_transcode_put(uint8_t *out, size_t index, uint32_t cp, int encoding) {
+  if (encoding == SCR_TC_ASCII || encoding == SCR_TC_LATIN1) {
+    unsigned limit = encoding == SCR_TC_ASCII ? 0x7f : 0xff;
+    if (cp <= limit) out[index++] = (uint8_t)cp;
+    else if (!scr_transcode_ignorable(cp)) out[index++] = '?';
+  } else if (encoding == SCR_TC_UTF16) {
+    if (cp > 0xffff) {
+      uint32_t high = 0xd800 + ((cp - 0x10000) >> 10);
+      out[index++] = (uint8_t)high;
+      out[index++] = (uint8_t)(high >> 8);
+      cp = 0xdc00 + ((cp - 0x10000) & 0x3ff);
+    }
+    out[index++] = (uint8_t)cp;
+    out[index++] = (uint8_t)(cp >> 8);
+  } else if (cp < 0x80) out[index++] = (uint8_t)cp;
+  else if (cp < 0x800) {
+    out[index++] = 0xc0 | (cp >> 6); out[index++] = 0x80 | (cp & 63);
+  } else if (cp < 0x10000) {
+    out[index++] = 0xe0 | (cp >> 12); out[index++] = 0x80 | ((cp >> 6) & 63); out[index++] = 0x80 | (cp & 63);
+  } else {
+    out[index++] = 0xf0 | (cp >> 18); out[index++] = 0x80 | ((cp >> 12) & 63);
+    out[index++] = 0x80 | ((cp >> 6) & 63); out[index++] = 0x80 | (cp & 63);
+  }
+  return index;
+}
+
+ScrBytes *scr_buffer_transcode(const ScrDyn *source, const ScrDyn *from, const ScrDyn *to) {
+  if (source->kind != SCR_DYN_BYTES || source->v.bytes->elem != SCR_BYTES_U8 || source->v.bytes->is_data_view) {
+    scr_dyn_arg_type_fail("source", "an instance of Buffer or Uint8Array", source);
+    return NULL;
+  }
+  const ScrBytes *input = source->v.bytes;
+  size_t len = input->len;
+  if (!len) { ScrBytes *empty = scr_bytes_alloc(SCR_BYTES_U8, 0); empty->is_buffer = true; return empty; }
+  int from_encoding = scr_transcode_encoding(from), to_encoding = scr_transcode_encoding(to);
+  if (from_encoding < 0 || to_encoding < 0) return scr_transcode_error(false);
+  if (len > (SIZE_MAX - 4) / 4) scr_bytes_oom();
+  ScrBytes *result = scr_bytes_alloc(SCR_BYTES_U8, len * 4 + 4);
+  result->is_buffer = true;
+  size_t written = 0;
+  if (from_encoding == SCR_TC_UTF8) {
+    if (to_encoding == SCR_TC_UTF16 && !scr_buffer_utf8_valid(input->data, len)) {
+      scr_bytes_release(result); return scr_transcode_error(true);
+    }
+    ScrStr *text = scr_str_from_utf8_lossy(input->data, len);
+    for (size_t i = 0; i < text->len;) {
+      uint32_t cp = scr_bytes_next_cp((const uint8_t *)text->data, &i);
+      written = scr_transcode_put(result->data, written, cp, to_encoding);
+    }
+    scr_str_release(text);
+  } else if (from_encoding == SCR_TC_UTF16) {
+    size_t end = to_encoding == SCR_TC_UTF16 ? len : len & ~(size_t)1;
+    if (to_encoding == SCR_TC_UTF8 && end == 0) { scr_bytes_release(result); return scr_transcode_error(true); }
+    for (size_t i = 0; i < end;) {
+      uint32_t cp = 0xfffd;
+      bool invalid = false;
+      if (i + 1 < end) {
+        cp = input->data[i] | ((uint32_t)input->data[i + 1] << 8);
+        i += 2;
+        if (cp >= 0xd800 && cp <= 0xdbff) {
+          uint32_t next = i + 1 < end ? input->data[i] | ((uint32_t)input->data[i + 1] << 8) : 0;
+          if (next >= 0xdc00 && next <= 0xdfff) { cp = 0x10000 + ((cp - 0xd800) << 10) + next - 0xdc00; i += 2; }
+          else { cp = 0xfffd; invalid = true; }
+        } else if (cp >= 0xdc00 && cp <= 0xdfff) { cp = 0xfffd; invalid = true; }
+      } else { i++; invalid = true; }
+      if (invalid && to_encoding == SCR_TC_UTF8) { scr_bytes_release(result); return scr_transcode_error(true); }
+      written = scr_transcode_put(result->data, written, cp, to_encoding);
+    }
+  } else {
+    for (size_t i = 0; i < len; i++) {
+      uint32_t cp = input->data[i];
+      if (from_encoding == SCR_TC_ASCII && cp > 0x7f && to_encoding != SCR_TC_UTF16) cp = 0xfffd;
+      written = scr_transcode_put(result->data, written, cp, to_encoding);
+    }
+  }
+  result->len = written;
+  return result;
+}
+
 static bool scr_enc_is(const ScrStr *enc, const char *name) {
   size_t n = strlen(name);
   return enc->len == n && memcmp(enc->data, name, n) == 0;

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

@@ -469,21 +469,60 @@ 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 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;
+  bool vector = !strcmp(op, "readv") || !strcmp(op, "writev");
+  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;
+  if (!scr_fs_cb_chk(callback, fileCallback || vector ? "cb" : "callback")) { scr_arr_release(vectors); return NULL; }
   size_t count = 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");
+  bool descriptor = vector || newControl || !strcmp(op, "close") || !strcmp(op, "fstat") || !strcmp(op, "fsync") || !strcmp(op, "read") || !strcmp(op, "write");
   ScrStr *path = descriptor ? NULL : scr_fs_cb_path(ARG(0), !strcmp(op, "mkdtemp") ? "prefix" : "path");
   if (!descriptor && !path) 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 +574,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);
@@ -624,8 +671,8 @@ static ScrDyn *scr_fs_cb_invoke(ScrStr *member, ScrDyn *const *args, size_t argc
   } 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

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);
 }