@scriptc/cli-darwin-arm64 0.2.1 → 0.2.3

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

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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_array.c

@@ -796,6 +796,11 @@ static bool scr_arr_read_value(const ScrArr *a, double i, uint64_t *slot) {
   return state == SCR_ARR_VALUE;
 }
 
+void *scr_arr_peek_ref(const ScrArr *a, double i) {
+  uint64_t slot;
+  return scr_arr_read_value(a, i, &slot) ? scr_slot_to_ptr(slot) : NULL;
+}
+
 double scr_arr_get_number(const ScrArr *a, double i) {
   /* Keep this hot numeric-only entry self-contained: routing it through
    * scr_arr_read_value adds an out-of-line call at -O2 on native targets. */

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

@@ -1481,6 +1481,32 @@ void scr_assert_unwanted_rejection(ScrError *err, ScrStr *msg, bool has_msg) {
   scr_assert_fail_msg(ab_take(&b));
 }
 
+void scr_assert_unwanted_error(ScrStr *actual_message, bool rejection, ScrStr *msg, bool has_msg) {
+  ScrAssertBuf b = {0};
+  ab_cstr(&b, rejection ? "Got unwanted rejection" : "Got unwanted exception");
+  if (has_msg && msg->len) {
+    ab_cstr(&b, ": ");
+    ab_str(&b, msg);
+  } else ab_char(&b, '.');
+  ab_cstr(&b, "\nActual message: \"");
+  ab_str(&b, actual_message);
+  ab_char(&b, '"');
+  scr_assert_fail_msg(ab_take(&b));
+}
+
+/* Node calls validation functions with a fresh object receiver and accepts
+ * only the boolean true. A callback exception remains the pending exception. */
+bool scr_assert_no_error_predicate(ScrDyn *predicate, ScrDyn *actual) {
+  ScrDyn *receiver = scr_dyn_new_obj();
+  scr_dyn_this_push_dyn(receiver);
+  ScrDyn *result = scr_dyn_call(predicate, &actual, 1, "expected");
+  scr_dyn_this_pop();
+  scr_dyn_release(receiver);
+  bool matched = result && result->kind == SCR_DYN_BOOL && result->v.b;
+  scr_dyn_release(result);
+  return matched;
+}
+
 /* ── assert.ifError ───────────────────────────────────────────────────
  * Node throws for ANY value but null/undefined (falsy included); the
  * frontend routes null/undefined to a no-op and everything else here.

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;
 }
 
@@ -1756,6 +1758,50 @@ ScrPromise *scr_fsp_chmod(ScrStr *path, double mode) {
   return scr_promise_settled_void();
 }
 
+ScrPromise *scr_fsp_utimes(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime) {
+  scr_fs_utimes_checked(path, atime, mtime);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_fsp_link(const ScrDyn *existing, const ScrDyn *destination) {
+  scr_fs_link_checked(existing, destination);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_fsp_symlink(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type) {
+  scr_fs_symlink_promise_checked(target, destination, type);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_fsp_readlink_dyn(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_checked(path, options, true);
+  return scr_promise_settled_ref(result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+}
+
+ScrPromise *scr_fsp_statfs(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_statfs_checked(path, options);
+  return scr_promise_settled_ref(result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+}
+
+ScrPromise *scr_fsp_readlink_str(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_checked(path, options, true);
+  ScrStr *text = result && result->kind == SCR_DYN_STR ? scr_str_retain(result->v.str) : NULL;
+  scr_dyn_release(result);
+  return scr_promise_settled_str(text);
+}
+
+ScrPromise *scr_fsp_readlink_buffer(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_checked(path, options, true);
+  ScrBytes *bytes = result ? scr_dyn_bytes_unbox(result) : NULL;
+  scr_dyn_release(result);
+  return scr_promise_settled_ref(bytes, scr_bytes_retain_v, scr_bytes_release_v, NULL);
+}
+
+ScrPromise *scr_fsp_lutimes(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime) {
+  scr_fs_lutimes_checked(path, atime, mtime);
+  return scr_promise_settled_void();
+}
+
 ScrPromise *scr_fsp_readdir(ScrStr *path) {
   ScrArr *names = scr_fs_readdir(path);
   return scr_promise_settled_ref(names, &scr_arr_retain_v, &scr_arr_release_v, NULL);
@@ -2146,6 +2192,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 +2208,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 +2226,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 +2246,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;