@scriptc/cli-darwin-arm64 0.2.4 → 0.2.6

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

@@ -7,6 +7,7 @@
  * encoding conversions (utf8 with WHATWG replacement, hex, base64) match
  * Node byte-for-byte — the differential corpus holds them to it. */
 #include "scr_runtime.h"
+#include "scr_numeric.h"
 #include "scr_text_decoder_labels.h"
 #ifdef SCR_TEXT_DECODER_LEGACY
 #include "scr_text_decoder_data.h"
@@ -116,24 +117,49 @@ double scr_bytes_to_u8_clamp(double value) {
 
 /* ── lifecycle ─────────────────────────────────────────────────────────── */
 
-static ScrBytes *scr_bytes_alloc(ScrBytesElem elem, size_t len) {
+/* Adopt private malloc storage without clearing or copying its contents. The
+ * caller transfers ownership; views keep it alive through the usual owner. */
+ScrBytes *scr_bytes_take_data(uint8_t *data, size_t len) {
+  if (!data && len) scr_trap("scriptc: NULL owned byte storage\n");
   ScrBytes *b = malloc(sizeof(ScrBytes));
   if (!b) scr_bytes_oom();
   b->rc = 1;
   b->len = len;
-  b->elem = elem;
-  b->data = calloc(len ? len : 1, scr_bytes_elem_size(elem));
+  b->elem = SCR_BYTES_U8;
+  b->data = data ? data : malloc(1);
   if (!b->data) scr_bytes_oom();
   b->backing = NULL;
   b->is_buffer = false;
   b->is_data_view = false;
   b->external = false;
+  b->shared = NULL;
 #ifdef SCR_RC_AUDIT
   scr_live_bytes++;
 #endif
   return b;
 }
 
+/* Only complete, non-observable initialization may use private storage. */
+static ScrBytes *scr_bytes_alloc_private(ScrBytesElem elem, size_t len) {
+  size_t width = scr_bytes_elem_size(elem);
+  if (len > SIZE_MAX / width) scr_bytes_oom();
+  uint8_t *data = malloc(len ? len * width : 1);
+  if (!data) scr_bytes_oom();
+  ScrBytes *b = scr_bytes_take_data(data, len);
+  b->elem = elem;
+  return b;
+}
+
+static ScrBytes *scr_bytes_alloc(ScrBytesElem elem, size_t len) {
+  size_t width = scr_bytes_elem_size(elem);
+  if (len > SIZE_MAX / width) scr_bytes_oom();
+  uint8_t *data = calloc(len ? len : 1, width);
+  if (!data) scr_bytes_oom();
+  ScrBytes *b = scr_bytes_take_data(data, len);
+  b->elem = elem;
+  return b;
+}
+
 ScrBytes *scr_bytes_from_external(void *data, size_t length) {
   ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, 0);
   /* Keep the owned empty allocation for NULL/zero-length views: existing
@@ -168,13 +194,14 @@ ScrBytes *scr_bytes_from_data(const uint8_t *data, size_t len) {
   if (data == NULL && len != 0) {
     scr_trap("scriptc: native callback passed a NULL span with nonzero length\n");
   }
-  ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, len);
+  ScrBytes *b = scr_bytes_alloc_private(SCR_BYTES_U8, len);
   if (len != 0) memcpy(b->data, data, len);
   return b;
 }
 
 ScrBytes *scr_bytes_copy(const ScrBytes *src) {
-  ScrBytes *b = scr_bytes_alloc(src->elem, src->len);
+  SCR_SHARED_GUARD(src, NULL);
+  ScrBytes *b = scr_bytes_alloc_private(src->elem, src->len);
   memcpy(b->data, src->data, src->len * scr_bytes_elem_size(src->elem));
   return b;
 }
@@ -190,19 +217,14 @@ ScrBytes *scr_bytes_as_buffer(ScrBytes *bytes) {
   return scr_bytes_retain(bytes);
 }
 
-ScrBytes *scr_bytes_convert(ScrBytesElem elem, const ScrBytes *src) {
-  if (elem == src->elem) return scr_bytes_copy(src);
-  ScrBytes *out = scr_bytes_alloc(elem, src->len);
-  for (size_t i = 0; i < src->len; i++) scr_bytes_set(out, (double)i, scr_bytes_get(src, (double)i));
-  return out;
-}
-
 void scr_bytes_release(ScrBytes *b) {
   if (!b || b->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
   if (--b->rc == 0) {
     scr_weak_dispose(b);
     if (b->backing) {
       scr_bytes_release(b->backing); /* a view: data points into the owner */
+    } else if (b->shared) {
+      scr_shared_release(b->shared);
     } else if (!b->external) {
       free(b->data);
     }
@@ -219,6 +241,7 @@ void scr_bytes_release_v(void *b) { scr_bytes_release((ScrBytes *)b); }
 double scr_bytes_len(const ScrBytes *b) { return (double)b->len; }
 
 void scr_bytes_copy_contents(ScrBytes *dst, const ScrBytes *src) {
+  SCR_SHARED_GUARD(dst, src);
   if (dst->elem != src->elem || dst->len != src->len) {
     scr_trap("scriptc: typed array snapshot shape changed\n");
   }
@@ -246,14 +269,11 @@ static size_t scr_bytes_check_index(const ScrBytes *b, double i) {
 /* ToUint32: NaN/±Infinity → 0, truncate toward zero, wrap mod 2^32.
  * ToUint8 is its low byte (2^8 divides 2^32, so the residues agree). */
 static uint32_t scr_bytes_to_u32(double v) {
-  if (v != v || isinf(v)) return 0;
-  double t = trunc(v);
-  t = fmod(t, 4294967296.0);
-  if (t < 0) t += 4294967296.0;
-  return (uint32_t)t;
+  return scr_numeric_to_u32(v);
 }
 
 double scr_bytes_get(const ScrBytes *b, double i) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t idx = scr_bytes_check_index(b, i);
   switch (b->elem) {
     case SCR_BYTES_U8: case SCR_BYTES_U8C:
@@ -298,6 +318,7 @@ double scr_bytes_get(const ScrBytes *b, double i) {
 }
 
 void scr_bytes_set(ScrBytes *b, double i, double v) {
+  SCR_SHARED_GUARD(b, NULL);
   if (!(i >= 0) || i != trunc(i) || i >= (double)b->len) return;
   size_t idx = (size_t)i;
   switch (b->elem) {
@@ -336,6 +357,87 @@ void scr_bytes_set(ScrBytes *b, double i, double v) {
   }
 }
 
+/* Dispatch once per bounded block, not once per element. Loads and stores
+ * use memcpy so views and external storage need no stronger alignment or
+ * aliasing promise. A bounded scratch block avoids a kind-pair code matrix. */
+static void scr_bytes_read_numbers(double *out, const uint8_t *src, ScrBytesElem elem, size_t count) {
+#define SCR_READ_NUMBERS(kind, type) \
+  case kind: \
+    for (size_t i = 0; i < count; i++) { \
+      type value; \
+      memcpy(&value, src + i * sizeof value, sizeof value); \
+      out[i] = (double)value; \
+    } \
+    return
+  switch (elem) {
+    case SCR_BYTES_U8C:
+    SCR_READ_NUMBERS(SCR_BYTES_U8, uint8_t);
+    SCR_READ_NUMBERS(SCR_BYTES_I8, int8_t);
+    SCR_READ_NUMBERS(SCR_BYTES_U16, uint16_t);
+    SCR_READ_NUMBERS(SCR_BYTES_I16, int16_t);
+    SCR_READ_NUMBERS(SCR_BYTES_U32, uint32_t);
+    SCR_READ_NUMBERS(SCR_BYTES_I32, int32_t);
+    SCR_READ_NUMBERS(SCR_BYTES_F32, float);
+    SCR_READ_NUMBERS(SCR_BYTES_F64, double);
+  }
+#undef SCR_READ_NUMBERS
+}
+
+static void scr_bytes_write_numbers(uint8_t *dst, ScrBytesElem elem, const double *src, size_t count) {
+#define SCR_WRITE_NUMBERS(type, expression) \
+  for (size_t i = 0; i < count; i++) { \
+    type value = (expression); \
+    memcpy(dst + i * sizeof value, &value, sizeof value); \
+  } \
+  return
+  switch (elem) {
+    case SCR_BYTES_U8: case SCR_BYTES_I8: {
+      SCR_WRITE_NUMBERS(uint8_t, (uint8_t)scr_numeric_to_u32(src[i]));
+    }
+    case SCR_BYTES_U8C: {
+      SCR_WRITE_NUMBERS(uint8_t, (uint8_t)scr_bytes_to_u8_clamp(src[i]));
+    }
+    case SCR_BYTES_U16: case SCR_BYTES_I16: {
+      SCR_WRITE_NUMBERS(uint16_t, (uint16_t)scr_numeric_to_u32(src[i]));
+    }
+    case SCR_BYTES_U32: case SCR_BYTES_I32: {
+      SCR_WRITE_NUMBERS(uint32_t, scr_numeric_to_u32(src[i]));
+    }
+    case SCR_BYTES_F32: {
+      SCR_WRITE_NUMBERS(float, (float)src[i]);
+    }
+    case SCR_BYTES_F64: {
+      memcpy(dst, src, count * sizeof(double));
+      return;
+    }
+  }
+#undef SCR_WRITE_NUMBERS
+}
+
+/* Caller guarantees disjoint spans, or snapshots the source before entry. */
+static void scr_bytes_convert_span(uint8_t *dst, ScrBytesElem dest_elem,
+                                    const uint8_t *src, ScrBytesElem src_elem, size_t count) {
+  size_t source_width = scr_bytes_elem_size(src_elem);
+  size_t dest_width = scr_bytes_elem_size(dest_elem);
+  double values[128];
+  while (count) {
+    size_t block = count < 128 ? count : 128;
+    scr_bytes_read_numbers(values, src, src_elem, block);
+    scr_bytes_write_numbers(dst, dest_elem, values, block);
+    src += block * source_width;
+    dst += block * dest_width;
+    count -= block;
+  }
+}
+
+ScrBytes *scr_bytes_convert(ScrBytesElem elem, const ScrBytes *src) {
+  SCR_SHARED_GUARD(src, NULL);
+  if (elem == src->elem) return scr_bytes_copy(src);
+  ScrBytes *out = scr_bytes_alloc_private(elem, src->len);
+  scr_bytes_convert_span(out->data, elem, src->data, src->elem, src->len);
+  return out;
+}
+
 /* ── slice (copy) / subarray (view) ────────────────────────────────────── */
 
 /* Relative index: ToIntegerOrInfinity, negatives from the end, clamped. */
@@ -349,16 +451,18 @@ static size_t scr_bytes_rel_index(double i, size_t len) {
 }
 
 ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t s = scr_bytes_rel_index(start, b->len);
   size_t e = scr_bytes_rel_index(end, b->len);
   size_t count = e > s ? e - s : 0;
   size_t esize = scr_bytes_elem_size(b->elem);
-  ScrBytes *out = scr_bytes_alloc(b->elem, count);
+  ScrBytes *out = scr_bytes_alloc_private(b->elem, count);
   memcpy(out->data, b->data + s * esize, count * esize);
   return out;
 }
 
 ScrBytes *scr_bytes_copy_within(ScrBytes *b, double target, double start, double end) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t t = scr_bytes_rel_index(target, b->len);
   size_t s = scr_bytes_rel_index(start, b->len);
   size_t e = scr_bytes_rel_index(end, b->len);
@@ -374,9 +478,26 @@ ScrBytes *scr_bytes_copy_within(ScrBytes *b, double target, double start, double
  * rounding), slice-clamped relative indices; answers the receiver +1
  * (chaining). Never throws — Buffer's throwing fill family is separate. */
 ScrBytes *scr_bytes_fill_elem(ScrBytes *b, double v, double start, double end) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t s = scr_bytes_rel_index(start, b->len);
   size_t e = scr_bytes_rel_index(end, b->len);
-  for (size_t i = s; i < e; i++) scr_bytes_set(b, (double)i, v);
+  if (e > s) {
+    size_t width = scr_bytes_elem_size(b->elem);
+    uint8_t pattern[8];
+    scr_bytes_write_numbers(pattern, b->elem, &v, 1);
+    uint8_t *dst = b->data + s * width;
+    size_t bytes = (e - s) * width;
+    if (width == 1) memset(dst, pattern[0], bytes);
+    else {
+      memcpy(dst, pattern, width);
+      size_t filled = width;
+      while (filled < bytes) {
+        size_t copy = filled < bytes - filled ? filled : bytes - filled;
+        memcpy(dst + filled, dst, copy);
+        filled += copy;
+      }
+    }
+  }
   return scr_bytes_retain(b);
 }
 
@@ -401,6 +522,7 @@ ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end) {
   v->is_buffer = b->is_buffer;
   v->is_data_view = false;
   v->external = false;
+  v->shared = owner->shared;
 #ifdef SCR_RC_AUDIT
   scr_live_bytes++;
 #endif
@@ -408,22 +530,34 @@ ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end) {
 }
 
 void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset) {
+  SCR_SHARED_GUARD(dst, src);
   double t = (offset != offset) ? 0 : trunc(offset);
   if (!(t >= 0) || (double)src->len + t > (double)dst->len) {
     static const char msg[] = "offset is out of bounds";
     scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
     return;
   }
-  if (dst->elem != src->elem) {
-    // Snapshot before writing: views can overlap even with distinct kinds.
-    ScrBytes *copy = scr_bytes_convert(dst->elem, src);
-    memcpy(dst->data + (size_t)t * scr_bytes_elem_size(dst->elem), copy->data,
-           copy->len * scr_bytes_elem_size(copy->elem));
-    scr_bytes_release(copy);
+  size_t width = scr_bytes_elem_size(dst->elem);
+  uint8_t *target = dst->data + (size_t)t * width;
+  if (dst->elem == src->elem) {
+    memmove(target, src->data, src->len * width);
     return;
   }
-  size_t esize = scr_bytes_elem_size(dst->elem);
-  memmove(dst->data + (size_t)t * esize, src->data, src->len * esize);
+  size_t source_bytes = src->len * scr_bytes_elem_size(src->elem);
+  size_t dest_bytes = src->len * width;
+  uintptr_t to = (uintptr_t)target, from = (uintptr_t)src->data;
+  bool overlap = to <= from ? from - to < dest_bytes : to - from < source_bytes;
+  if (overlap) {
+    /* Snapshot raw source bytes before cross-kind writes. Distinct external
+     * wrappers can alias even without a shared backing identity. */
+    uint8_t *copy = malloc(source_bytes ? source_bytes : 1);
+    if (!copy) scr_bytes_oom();
+    memcpy(copy, src->data, source_bytes);
+    scr_bytes_convert_span(target, dst->elem, copy, src->elem, src->len);
+    free(copy);
+  } else {
+    scr_bytes_convert_span(target, dst->elem, src->data, src->elem, src->len);
+  }
 }
 
 /* Checked-native array-like sources. Runtime objects with an unsupported
@@ -504,7 +638,7 @@ ScrBytes *scr_bytes_from_dyn(ScrBytesElem elem, const ScrDyn *value, bool from)
     return out;
   }
   if (value->kind == SCR_DYN_BYTES) return scr_bytes_convert(elem, value->v.bytes);
-  if (!from && scr_array_buffer_is(value)) return scr_array_buffer_view(elem, value, scr_dyn_undefined(), scr_dyn_undefined());
+  if (!from && scr_buffer_storage_is(value)) return scr_array_buffer_view(elem, value, scr_dyn_undefined(), scr_dyn_undefined());
   if (!from && (value->kind == SCR_DYN_NUM || value->kind == SCR_DYN_BOOL ||
                 value->kind == SCR_DYN_STR || value->kind == SCR_DYN_NULL || value->kind == SCR_DYN_UNDEF)) {
     double number;
@@ -615,6 +749,7 @@ ScrBytes *scr_dataview_new(ScrBytes *src, double byte_off, bool has_len, double
   v->is_buffer = false;
   v->is_data_view = true;
   v->external = false;
+  v->shared = owner->shared;
 #ifdef SCR_RC_AUDIT
   scr_live_bytes++;
 #endif
@@ -663,6 +798,7 @@ static size_t scr_dataview_get_size(ScrDataViewGet kind) {
 }
 
 double scr_dataview_get(const ScrBytes *b, double byte_off, ScrDataViewGet kind, bool le) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t width = scr_dataview_get_size(kind);
   /* ToIndex, then the view-relative bounds check — Node's ONE constant
    * message for every failure mode (negative, NaN is fine, too large). */
@@ -711,6 +847,7 @@ double scr_dataview_get(const ScrBytes *b, double byte_off, ScrDataViewGet kind,
 }
 
 void scr_dataview_set(ScrBytes *b, double byte_off, double value, ScrDataViewGet kind, bool le) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t width = scr_dataview_get_size(kind);
   /* ToIndex + the view-relative bounds check — the getters' ONE message. */
   double off = (byte_off != byte_off) ? 0 : trunc(byte_off);
@@ -766,79 +903,85 @@ static void scr_td_invalid(const char *encoding) {
   scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_ENCODING_INVALID_ENCODED_DATA");
 }
 
-static ScrStr *scr_bytes_decode_utf8_options(const uint8_t *in, size_t n, bool fatal) {
-  if (in == NULL && n != 0) {
-    scr_trap("scriptc: native callback passed a NULL span with nonzero length\n");
+/* Stop before the first non-ASCII byte; every word load stays in the span. */
+static size_t scr_bytes_ascii_prefix(const uint8_t *data, size_t len) {
+  size_t i = 0;
+  while (len - i >= sizeof(uint64_t)) {
+    uint64_t word;
+    memcpy(&word, data + i, sizeof word);
+    if (word & UINT64_C(0x8080808080808080)) break;
+    i += sizeof word;
   }
-  if (n > (SIZE_MAX - 1) / 3) scr_bytes_oom();
-  char *out = malloc(n * 3 + 1);
-  if (!out) scr_bytes_oom();
-  size_t o = 0;
-  uint32_t cp = 0;
-  int needed = 0;
-  uint8_t lower = 0x80, upper = 0xbf;
-  for (size_t i = 0; i <= n; i++) {
-    if (i == n) {
-      if (needed > 0) { /* EOF inside a sequence: one replacement */
-        if (fatal) { free(out); scr_td_invalid("utf-8"); return NULL; }
-        memcpy(out + o, "\xef\xbf\xbd", 3);
-        o += 3;
-      }
-      break;
-    }
-    uint8_t byte = in[i];
-    if (needed == 0) {
-      if (byte <= 0x7f) {
-        out[o++] = (char)byte;
-      } else if (byte >= 0xc2 && byte <= 0xdf) {
-        needed = 1; cp = byte & 0x1f;
-      } else if (byte >= 0xe0 && byte <= 0xef) {
-        if (byte == 0xe0) lower = 0xa0;
-        if (byte == 0xed) upper = 0x9f;
-        needed = 2; cp = byte & 0xf;
-      } else if (byte >= 0xf0 && byte <= 0xf4) {
-        if (byte == 0xf0) lower = 0x90;
-        if (byte == 0xf4) upper = 0x8f;
-        needed = 3; cp = byte & 0x7;
-      } else {
-        if (fatal) { free(out); scr_td_invalid("utf-8"); return NULL; }
-        memcpy(out + o, "\xef\xbf\xbd", 3);
-        o += 3;
-      }
-      continue;
-    }
-    if (byte < lower || byte > upper) {
-      /* Invalid continuation: replace the subpart, REPROCESS this byte. */
-      if (fatal) { free(out); scr_td_invalid("utf-8"); return NULL; }
-      memcpy(out + o, "\xef\xbf\xbd", 3);
-      o += 3;
-      needed = 0; lower = 0x80; upper = 0xbf;
-      i--;
-      continue;
-    }
-    lower = 0x80; upper = 0xbf;
-    cp = (cp << 6) | (byte & 0x3f);
-    if (--needed == 0) {
-      /* Re-encode the (valid, non-surrogate, <= 10FFFF) code point. */
-      if (cp <= 0x7f) {
-        out[o++] = (char)cp;
-      } else if (cp <= 0x7ff) {
-        out[o++] = (char)(0xc0 | (cp >> 6));
-        out[o++] = (char)(0x80 | (cp & 0x3f));
-      } else if (cp <= 0xffff) {
-        out[o++] = (char)(0xe0 | (cp >> 12));
-        out[o++] = (char)(0x80 | ((cp >> 6) & 0x3f));
-        out[o++] = (char)(0x80 | (cp & 0x3f));
-      } else {
-        out[o++] = (char)(0xf0 | (cp >> 18));
-        out[o++] = (char)(0x80 | ((cp >> 12) & 0x3f));
-        out[o++] = (char)(0x80 | ((cp >> 6) & 0x3f));
-        out[o++] = (char)(0x80 | (cp & 0x3f));
+  while (i < len && data[i] < 0x80) i++;
+  return i;
+}
+
+/* Length of the well-formed prefix. On failure, next skips exactly the
+ * maximal invalid subpart; an offending continuation is reprocessed. */
+static size_t scr_bytes_utf8_prefix(const uint8_t *data, size_t len, size_t *next) {
+  size_t i = 0;
+  while (i < len) {
+    i += scr_bytes_ascii_prefix(data + i, len - i);
+    if (i == len) break;
+    size_t start = i;
+    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 { *next = i; return start; }
+    for (unsigned j = 0; j < count; j++) {
+      if (i == len || data[i] < low || data[i] > high) {
+        *next = i;
+        return start;
       }
+      i++;
+      low = 0x80;
+      high = 0xbf;
     }
   }
-  ScrStr *s = scr_str_new(out, o);
-  free(out);
+  *next = len;
+  return len;
+}
+
+/* Measure first, then write into final string storage. Invalid input can
+ * expand, but neither valid prefixes nor retained output need a 3x buffer. */
+static size_t scr_bytes_utf8_repair(const uint8_t *in, size_t n,
+                                  size_t prefix, size_t next, char *out) {
+  size_t written = 0, offset = 0;
+  for (;;) {
+    if (prefix > SIZE_MAX - written) scr_bytes_oom();
+    if (out && prefix) memcpy(out + written, in + offset, prefix);
+    written += prefix;
+    if (prefix == n - offset) return written;
+    if (written > SIZE_MAX - 3) scr_bytes_oom();
+    if (out) memcpy(out + written, "\xef\xbf\xbd", 3);
+    written += 3;
+    offset += next;
+    prefix = scr_bytes_utf8_prefix(in + offset, n - offset, &next);
+  }
+}
+
+static ScrStr *scr_bytes_decode_utf8_options(const uint8_t *in, size_t n, bool fatal) {
+  if (in == NULL && n != 0) {
+    scr_trap("scriptc: native callback passed a NULL span with nonzero length\n");
+  }
+  if (n == 0) return scr_str_new("", 0);
+  size_t next;
+  size_t prefix = scr_bytes_utf8_prefix(in, n, &next);
+  if (prefix == n) return scr_str_new((const char *)in, n);
+  if (fatal) { scr_td_invalid("utf-8"); return NULL; }
+  size_t length = scr_bytes_utf8_repair(in, n, prefix, next, NULL);
+  ScrStr *s = scr_str_alloc_raw(length, length);
+  scr_bytes_utf8_repair(in, n, prefix, next, s->data);
+  s->data[length] = '\0';
   return s;
 }
 
@@ -855,6 +998,7 @@ ScrStr *scr_str_from_utf8_lossy(const uint8_t *bytes, size_t len) {
  * difference — a leading UTF-8 BOM is stripped (ignoreBOM defaults to
  * false in the spec; Buffer.toString keeps the BOM as U+FEFF). */
 ScrStr *scr_text_decode_options(const ScrBytes *b, bool fatal, bool ignore_bom) {
+  SCR_SHARED_GUARD(b, NULL);
   const uint8_t *in = b->data;
   size_t n = b->len;
   if (!ignore_bom && n >= 3 && in[0] == 0xef && in[1] == 0xbb && in[2] == 0xbf) {
@@ -877,7 +1021,7 @@ ScrBytes *scr_bytes_buffer_source(const ScrDyn *value) {
     ScrBytes *bytes = value->v.bytes;
     return scr_bytes_buffer_view(bytes, SCR_BYTES_U8, scr_bytes_byte_offset(bytes), true, scr_bytes_byte_len(bytes));
   }
-  if (scr_array_buffer_is(value)) {
+  if (scr_buffer_storage_is(value)) {
     return scr_array_buffer_view(SCR_BYTES_U8, value, scr_dyn_undefined(), scr_dyn_undefined());
   }
   static const char message[] = "The input argument must be an instance of SharedArrayBuffer, ArrayBuffer or ArrayBufferView.";
@@ -1048,12 +1192,14 @@ static ScrStr *scr_strdec_step(const ScrStr *enc, double pending, const ScrBytes
 
 /* decoder.write(chunk): the decoded complete prefix (+1). */
 ScrStr *scr_strdec_write(const ScrStr *enc, double pending, const ScrBytes *chunk) {
+  SCR_SHARED_GUARD(chunk, NULL);
   double hold;
   return scr_strdec_step(enc, pending, chunk, true, &hold);
 }
 
 /* The decoder state AFTER a write: the packed trailing partial sequence. */
 double scr_strdec_next(const ScrStr *enc, double pending, const ScrBytes *chunk) {
+  SCR_SHARED_GUARD(chunk, NULL);
   double hold = 0;
   scr_strdec_step(enc, pending, chunk, false, &hold);
   return hold;
@@ -1094,6 +1240,7 @@ static void scr_bytes_to_str_bounds(const ScrBytes *b, double start, double end,
  * form). Delegates to the whole-buffer decoder
  * through a stack view — no allocation, no rc traffic. */
 ScrStr *scr_bytes_to_str_range(const ScrBytes *b, const ScrStr *enc, double start, double end) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t s0, e0;
   scr_bytes_to_str_bounds(b, start, end, &s0, &e0);
   ScrBytes view = { .rc = 1, .len = e0 - s0, .elem = b->elem, .data = b->data + s0, .backing = NULL };
@@ -1109,23 +1256,30 @@ static ScrStr *scr_bytes_encode_b64(const uint8_t *in, size_t n, bool url) {
   static const char url_abc[] =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
   const char *abc = url ? url_abc : std_abc;
-  size_t outlen = (n + 2) / 3 * 4;
-  char *out = malloc(outlen + 1);
-  if (!out) scr_bytes_oom();
-  size_t o = 0;
-  for (size_t i = 0; i < n; i += 3) {
+  size_t groups = n / 3, tail = n % 3;
+  size_t suffix = tail ? (url ? tail + 1 : 4) : 0;
+  if (groups > (SIZE_MAX - suffix) / 4) scr_bytes_oom();
+  size_t outlen = groups * 4 + suffix;
+  ScrStr *s = scr_str_alloc_raw(outlen, outlen);
+  char *out = s->data;
+  size_t i = 0, o = 0;
+  for (; i < groups * 3; i += 3) {
+    unsigned v = ((unsigned)in[i] << 16) | ((unsigned)in[i + 1] << 8) | in[i + 2];
+    out[o++] = abc[v >> 18];
+    out[o++] = abc[(v >> 12) & 63];
+    out[o++] = abc[(v >> 6) & 63];
+    out[o++] = abc[v & 63];
+  }
+  if (tail) {
     unsigned v = (unsigned)in[i] << 16;
-    if (i + 1 < n) v |= (unsigned)in[i + 1] << 8;
-    if (i + 2 < n) v |= (unsigned)in[i + 2];
-    out[o++] = abc[(v >> 18) & 63];
+    if (tail == 2) v |= (unsigned)in[i + 1] << 8;
+    out[o++] = abc[v >> 18];
     out[o++] = abc[(v >> 12) & 63];
-    if (i + 1 < n) out[o++] = abc[(v >> 6) & 63];
-    else if (!url) out[o++] = '=';
-    if (i + 2 < n) out[o++] = abc[v & 63];
+    if (tail == 2) out[o++] = abc[(v >> 6) & 63];
     else if (!url) out[o++] = '=';
+    if (!url) out[o++] = '=';
   }
-  ScrStr *s = scr_str_new(out, o);
-  free(out);
+  out[outlen] = '\0';
   return s;
 }
 
@@ -1689,6 +1843,7 @@ 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) {
+  SCR_SHARED_GUARD(b, NULL);
   unsigned encoding = (unsigned)encoding_value;
   if (encoding == 36) encoding = 7; /* ISO-8859-8-I */
   if (encoding == 37) encoding = SCR_TD_GB18030; /* GBK */
@@ -1729,6 +1884,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) {
+  SCR_SHARED_GUARD(input, NULL);
   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;
@@ -1816,8 +1972,14 @@ ScrDyn *scr_text_encode_into(const ScrDyn *source, const ScrDyn *destination) {
   }
   const ScrStr *text = source->v.str;
   ScrBytes *dest = destination->v.bytes;
+  SCR_SHARED_GUARD(dest, NULL);
   size_t read = 0, written = 0;
-  while (written < text->len) {
+  size_t limit = text->len < dest->len ? text->len : dest->len;
+  while (written < limit) {
+    size_t ascii = scr_bytes_ascii_prefix((const uint8_t *)text->data + written, limit - written);
+    written += ascii;
+    read += ascii;
+    if (written == limit) break;
     size_t end = written;
     uint32_t cp = scr_bytes_next_cp((const uint8_t *)text->data, &end);
     if (end > dest->len) break;
@@ -1832,7 +1994,7 @@ ScrDyn *scr_text_encode_into(const ScrDyn *source, const ScrDyn *destination) {
 }
 
 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)) {
+  if ((input->kind == SCR_DYN_BYTES && !input->v.bytes->is_data_view) || scr_buffer_storage_is(input)) {
     return scr_bytes_buffer_source(input);
   }
   scr_dyn_arg_type_fail("input", "an instance of ArrayBuffer, Buffer, or TypedArray", input);
@@ -1840,33 +2002,15 @@ static ScrBytes *scr_buffer_validation_input(const ScrDyn *input) {
 }
 
 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;
+  size_t next;
+  return scr_bytes_utf8_prefix(data, len, &next) == len;
 }
 
 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_SHARED_GUARD(bytes, NULL);
+  bool result = scr_bytes_ascii_prefix(bytes->data, bytes->len) == bytes->len;
   scr_bytes_release(bytes);
   return result;
 }
@@ -1874,6 +2018,7 @@ bool scr_buffer_is_ascii(const ScrDyn *input) {
 bool scr_buffer_is_utf8(const ScrDyn *input) {
   ScrBytes *bytes = scr_buffer_validation_input(input);
   if (!bytes) return false;
+  SCR_SHARED_GUARD(bytes, NULL);
   bool result = scr_buffer_utf8_valid(bytes->data, bytes->len);
   scr_bytes_release(bytes);
   return result;
@@ -1964,6 +2109,7 @@ ScrBytes *scr_buffer_transcode(const ScrDyn *source, const ScrDyn *from, const S
     return NULL;
   }
   const ScrBytes *input = source->v.bytes;
+  SCR_BYTES_SNAPSHOT(input);
   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);
@@ -2021,63 +2167,66 @@ static bool scr_enc_is(const ScrStr *enc, const char *name) {
  * surrogate becomes U+FFFD — Node keeps it as a lone UTF-16 unit, which
  * UTF-8 string storage cannot hold (SEMANTICS.md divergence; stdout
  * agrees byte-for-byte because Node's own write replaces it there too). */
+/* Consume one scalar, replacing an unpaired surrogate at the storage boundary. */
+static uint32_t scr_bytes_utf16le_cp(const uint8_t *in, size_t units, size_t *u) {
+  uint32_t cu = (uint32_t)in[*u * 2] | ((uint32_t)in[*u * 2 + 1] << 8);
+  (*u)++;
+  if (cu >= 0xd800 && cu <= 0xdbff && *u < units) {
+    uint32_t lo = (uint32_t)in[*u * 2] | ((uint32_t)in[*u * 2 + 1] << 8);
+    if (lo >= 0xdc00 && lo <= 0xdfff) {
+      (*u)++;
+      return 0x10000 + ((cu - 0xd800) << 10) + (lo - 0xdc00);
+    }
+  }
+  return cu >= 0xd800 && cu <= 0xdfff ? 0xfffd : cu;
+}
+
 static ScrStr *scr_bytes_decode_utf16le(const uint8_t *in, size_t n) {
   size_t units = n / 2;
-  char *out = malloc(units * 3 + 2);
-  if (!out) scr_bytes_oom();
+  if (units > SIZE_MAX / 3) scr_bytes_oom();
+  ScrStr *s = scr_str_alloc_raw(0, units * 3);
   size_t o = 0;
-  for (size_t u = 0; u < units; u++) {
-    uint32_t cu = (uint32_t)in[u * 2] | ((uint32_t)in[u * 2 + 1] << 8);
-    if (cu >= 0xd800 && cu <= 0xdbff && u + 1 < units) {
-      uint32_t lo = (uint32_t)in[(u + 1) * 2] | ((uint32_t)in[(u + 1) * 2 + 1] << 8);
-      if (lo >= 0xdc00 && lo <= 0xdfff) {
-        o = scr_bytes_put_cp(out, o, 0x10000 + ((cu - 0xd800) << 10) + (lo - 0xdc00));
-        u++;
-        continue;
-      }
-    }
-    o = scr_bytes_put_cp(out, o, cu >= 0xd800 && cu <= 0xdfff ? 0xfffd : cu);
-  }
-  ScrStr *s = scr_str_new(out, o);
-  free(out);
+  for (size_t u = 0; u < units;) o = scr_bytes_put_cp(s->data, o, scr_bytes_utf16le_cp(in, units, &u));
+  s->len = o;
+  s->data[o] = '\0';
   return s;
 }
 
 ScrStr *scr_bytes_to_str(const ScrBytes *b, const ScrStr *enc) {
+  SCR_SHARED_GUARD(b, NULL);
   const uint8_t *in = b->data;
   size_t n = b->len; /* u8: len == byte length */
   /* Implicit native string/number coercions have no encoding argument. */
   if (!enc) return scr_bytes_decode_utf8(in, n);
   if (scr_enc_is(enc, "hex")) {
-    char *out = malloc(n * 2 + 1);
-    if (!out) scr_bytes_oom();
+    if (n > SIZE_MAX / 2) scr_bytes_oom();
+    ScrStr *s = scr_str_alloc_raw(n * 2, n * 2);
+    char *out = s->data;
     for (size_t i = 0; i < n; i++) {
       out[i * 2] = scr_hex_digits[in[i] >> 4];
       out[i * 2 + 1] = scr_hex_digits[in[i] & 0xf];
     }
-    ScrStr *s = scr_str_new(out, n * 2);
-    free(out);
+    out[n * 2] = '\0';
     return s;
   }
   if (scr_enc_is(enc, "base64")) return scr_bytes_encode_b64(in, n, false);
   if (scr_enc_is(enc, "base64url")) return scr_bytes_encode_b64(in, n, true);
   if (scr_enc_is(enc, "latin1")) {
     /* Each byte is U+00XX ("binary" normalizes here upstream). */
-    char *out = malloc(n * 2 + 1);
-    if (!out) scr_bytes_oom();
+    size_t high = 0;
+    for (size_t i = 0; i < n; i++) high += in[i] >> 7;
+    if (n > SIZE_MAX - high) scr_bytes_oom();
+    ScrStr *s = scr_str_alloc_raw(n + high, n + high);
     size_t o = 0;
-    for (size_t i = 0; i < n; i++) o = scr_bytes_put_cp(out, o, in[i]);
-    ScrStr *s = scr_str_new(out, o);
-    free(out);
+    for (size_t i = 0; i < n; i++) o = scr_bytes_put_cp(s->data, o, in[i]);
+    s->data[o] = '\0';
     return s;
   }
   if (scr_enc_is(enc, "ascii")) {
     /* Node's ascii decode masks the high bit: byte & 0x7f. */
-    char *out = malloc(n + 1);
-    if (!out) scr_bytes_oom();
-    for (size_t i = 0; i < n; i++) out[i] = (char)(in[i] & 0x7f);
-    ScrStr *s = scr_str_new(out, n);
-    free(out);
+    ScrStr *s = scr_str_alloc_raw(n, n);
+    for (size_t i = 0; i < n; i++) s->data[i] = (char)(in[i] & 0x7f);
+    s->data[n] = '\0';
     return s;
   }
   if (scr_enc_is(enc, "utf16le")) return scr_bytes_decode_utf16le(in, n);
@@ -2158,13 +2307,72 @@ static int scr_hex_val(uint8_t c) {
   return -1;
 }
 
-static int scr_b64_val(uint8_t c) {
-  if (c >= 'A' && c <= 'Z') return c - 'A';
-  if (c >= 'a' && c <= 'z') return c - 'a' + 26;
-  if (c >= '0' && c <= '9') return c - '0' + 52;
-  if (c == '+' || c == '-') return 62; /* '-': base64url, accepted like Node */
-  if (c == '/' || c == '_') return 63; /* '_': base64url */
-  return -1;
+/* Both alphabets are accepted by both Buffer base64 encoding names. */
+static const int8_t scr_b64_values[256] = {
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63,
+  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+  -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
+  -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+/* Conversion destinations are private until their initialized length is set.
+ * General typed-array allocation must remain zero-filled. */
+static ScrBytes *scr_bytes_conversion_storage(size_t capacity) {
+  uint8_t *data = malloc(capacity ? capacity : 1);
+  if (!data) scr_bytes_oom();
+  return scr_bytes_take_data(data, 0);
+}
+
+static ScrBytes *scr_bytes_decode_b64(const uint8_t *in, size_t n) {
+  ScrBytes *b = scr_bytes_conversion_storage(n / 4 * 3 + 2);
+  size_t i = 0, o = 0;
+  unsigned acc = 0, have = 0;
+  while (i < n) {
+    /* Common complete groups need neither per-character branches nor state. */
+    if (have == 0 && n - i >= 4) {
+      int a = scr_b64_values[in[i]], c = scr_b64_values[in[i + 1]];
+      int d = scr_b64_values[in[i + 2]], e = scr_b64_values[in[i + 3]];
+      if ((a | c | d | e) >= 0) {
+        unsigned v = ((unsigned)a << 18) | ((unsigned)c << 12) | ((unsigned)d << 6) | (unsigned)e;
+        b->data[o++] = (uint8_t)(v >> 16);
+        b->data[o++] = (uint8_t)(v >> 8);
+        b->data[o++] = (uint8_t)v;
+        i += 4;
+        continue;
+      }
+    }
+    uint8_t byte = in[i++];
+    if (byte == '=') break;
+    int v = scr_b64_values[byte];
+    if (v < 0) continue;
+    acc = (acc << 6) | (unsigned)v;
+    if (++have == 4) {
+      b->data[o++] = (uint8_t)(acc >> 16);
+      b->data[o++] = (uint8_t)(acc >> 8);
+      b->data[o++] = (uint8_t)acc;
+      acc = 0;
+      have = 0;
+    }
+  }
+  if (have == 2) b->data[o++] = (uint8_t)(acc >> 4);
+  else if (have == 3) {
+    b->data[o++] = (uint8_t)(acc >> 10);
+    b->data[o++] = (uint8_t)(acc >> 2);
+  }
+  b->len = o;
+  return b;
 }
 
 ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc) {
@@ -2173,7 +2381,7 @@ ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc) {
   if (scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii")) {
     /* Node writes charCodeAt(i) & 0xFF for BOTH spellings — an astral
      * code point contributes its two surrogates' low bytes. */
-    ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, n);
+    ScrBytes *b = scr_bytes_conversion_storage(n);
     size_t o = 0, i = 0;
     while (i < n) {
       uint32_t cp = scr_bytes_next_cp(in, &i);
@@ -2189,7 +2397,8 @@ ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc) {
     return b;
   }
   if (scr_enc_is(enc, "utf16le")) {
-    ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, n * 2);
+    if (n > SIZE_MAX / 2) scr_bytes_oom();
+    ScrBytes *b = scr_bytes_conversion_storage(n * 2);
     size_t o = 0, i = 0;
     while (i < n) {
       uint32_t cp = scr_bytes_next_cp(in, &i);
@@ -2208,61 +2417,70 @@ ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc) {
     b->len = o;
     return b;
   }
-  if (enc->len == 3 && memcmp(enc->data, "hex", 3) == 0) {
-    /* Node-lenient: parse pairs, stop at the first invalid pair or the
-     * odd tail (Buffer.from("a1g2", "hex") is <Buffer a1>). */
-    ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, n / 2);
-    size_t o = 0;
-    for (size_t i = 0; i + 1 < n; i += 2) {
-      int hi = scr_hex_val(in[i]);
-      int lo = scr_hex_val(in[i + 1]);
-      if (hi < 0 || lo < 0) break;
-      b->data[o++] = (uint8_t)((hi << 4) | lo);
-    }
-    b->len = o; /* never grows: shrinking the count is safe */
-    return b;
-  }
-  if (scr_enc_is(enc, "base64") || scr_enc_is(enc, "base64url")) {
-    /* Node-lenient: skip bytes outside the (standard + url-safe)
-     * alphabets — whitespace, '=', stray punctuation; decode 4-char
-     * groups, and a 2/3-char tail into 1/2 bytes. Both spellings share
-     * the decoder (Node accepts either alphabet under either name). */
-    ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, n / 4 * 3 + 2);
-    size_t o = 0;
-    unsigned acc = 0;
-    int have = 0;
-    for (size_t i = 0; i < n; i++) {
-      int v = scr_b64_val(in[i]);
-      if (v < 0) continue;
-      acc = (acc << 6) | (unsigned)v;
-      if (++have == 4) {
-        b->data[o++] = (uint8_t)(acc >> 16);
-        b->data[o++] = (uint8_t)(acc >> 8);
-        b->data[o++] = (uint8_t)acc;
-        acc = 0;
-        have = 0;
+  bool hex = scr_enc_is(enc, "hex");
+  if (hex || scr_enc_is(enc, "base64") || scr_enc_is(enc, "base64url")) {
+    /* Node interprets encoded text as the low byte of each UTF-16 unit.
+     * ASCII can borrow storage; non-ASCII must preserve that truncation. */
+    ScrBytes *narrowed = NULL;
+    if (scr_bytes_ascii_prefix(in, n) != n) {
+      ScrStr *latin1 = scr_str_new("latin1", 6);
+      narrowed = scr_bytes_from_str(s, latin1);
+      scr_str_release(latin1);
+      in = narrowed->data;
+      n = narrowed->len;
+    }
+    ScrBytes *b;
+    if (hex) {
+      /* Stop at the first invalid pair, discarding an odd tail. */
+      b = scr_bytes_conversion_storage(n / 2);
+      size_t o = 0;
+      for (size_t i = 0; i + 1 < n; i += 2) {
+        int hi = scr_hex_val(in[i]), lo = scr_hex_val(in[i + 1]);
+        if (hi < 0 || lo < 0) break;
+        b->data[o++] = (uint8_t)((hi << 4) | lo);
       }
+      b->len = o;
+    } else {
+      b = scr_bytes_decode_b64(in, n);
     }
-    if (have == 2) b->data[o++] = (uint8_t)(acc >> 4);
-    else if (have == 3) {
-      b->data[o++] = (uint8_t)(acc >> 10);
-      b->data[o++] = (uint8_t)(acc >> 2);
-    }
-    b->len = o;
+    scr_bytes_release(narrowed);
     return b;
   }
   /* utf8: ScrStr storage IS the bytes */
-  ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, n);
+  ScrBytes *b = scr_bytes_conversion_storage(n);
   memcpy(b->data, in, n);
+  b->len = n;
   return b;
 }
 
+/* Runtime encoding variables share the output conversion alias/error table.
+ * Buffer.from treats an empty encoding as utf8, even for an empty source. */
+ScrBytes *scr_bytes_from_str_checked(const ScrStr *s, const ScrStr *enc) {
+  ScrStr *normalized = enc->len ? scr_bytes_normalize_encoding(enc) : scr_str_new("utf8", 4);
+  if (!normalized) return NULL;
+  ScrBytes *out = scr_bytes_from_str(s, normalized);
+  scr_str_release(normalized);
+  return out;
+}
+
 ScrBytes *scr_bytes_from_arr(ScrBytesElem elem, const ScrArr *arr) {
-  ScrBytes *b = scr_bytes_alloc(elem, arr->len);
-  for (size_t i = 0; i < arr->len; i++) {
-    // Iteration reads holes as undefined: floating arrays store NaN and
-    // integer arrays store zero through their normal element conversion.
-    scr_bytes_set(b, (double)i, scr_arr_get_number(arr, (double)i));
+  ScrBytes *b = scr_bytes_alloc_private(elem, arr->len);
+  size_t width = scr_bytes_elem_size(elem);
+  double values[128];
+  for (size_t start = 0; start < arr->len;) {
+    size_t count = arr->len - start < 128 ? arr->len - start : 128;
+    for (size_t i = 0; i < count; i++) {
+      size_t index = start + i;
+      /* Sparse tails and explicit undefined retain ordinary iteration
+       * semantics. Numeric array slots own no conversion callbacks. */
+      if (index < arr->cap) {
+        if (arr->present[index] == SCR_ARR_VALUE)
+          memcpy(&values[i], &arr->data[index], sizeof(double));
+        else values[i] = NAN;
+      } else values[i] = scr_arr_get_number(arr, (double)index);
+    }
+    scr_bytes_write_numbers(b->data + start * width, elem, values, count);
+    start += count;
   }
   return b;
 }
@@ -2305,6 +2523,7 @@ bool scr_bytes_validate_off(const char *name, double value, double max) {
 }
 
 bool scr_bytes_equals(const ScrBytes *a, const ScrBytes *b) {
+  SCR_SHARED_GUARD(a, b);
   return a->len == b->len && memcmp(a->data, b->data, a->len) == 0;
 }
 
@@ -2314,6 +2533,7 @@ bool scr_bytes_equals(const ScrBytes *a, const ScrBytes *b) {
  * Node's exactly. */
 double scr_bytes_compare(const ScrBytes *src, const ScrBytes *target, double nargs,
                          double ts, double te, double ss, double se) {
+  SCR_SHARED_GUARD(src, target);
   size_t n = (size_t)nargs;
   if (n < 1) ts = 0;
   else if (!scr_bytes_validate_off("targetStart", ts, 9007199254740991.0)) return 0;
@@ -2342,6 +2562,7 @@ double scr_bytes_compare(const ScrBytes *src, const ScrBytes *target, double nar
  * count from the end, and a still-negative backward search answers -1),
  * and the utf16le alignment stride. */
 double scr_bytes_index_of(const ScrBytes *b, const ScrBytes *needle, double off, double align, bool fwd) {
+  SCR_SHARED_GUARD(b, needle);
   size_t len = b->len, nlen = needle->len;
   size_t step = align == 2 ? 2 : 1;
   double o = (off != off) ? (fwd ? 0 : (double)len) : trunc(off);
@@ -2372,6 +2593,7 @@ double scr_bytes_index_of(const ScrBytes *b, const ScrBytes *needle, double off,
 }
 
 double scr_bytes_index_of_num(const ScrBytes *b, double v, double off, bool fwd) {
+  SCR_SHARED_GUARD(b, NULL);
   uint8_t byte = (uint8_t)scr_bytes_to_u32(v);
   ScrBytes needle = { .rc = 1, .len = 1, .elem = SCR_BYTES_U8, .data = &byte, .backing = NULL };
   return scr_bytes_index_of(b, &needle, off, 1, fwd);
@@ -2408,16 +2630,19 @@ static ScrBytes *scr_bytes_fill_core(ScrBytes *b, const uint8_t *pat, size_t pat
 }
 
 ScrBytes *scr_bytes_fill(ScrBytes *b, const ScrBytes *pattern, double nargs, double offset, double end) {
+  SCR_SHARED_GUARD(b, pattern);
   return scr_bytes_fill_core(b, pattern->data, pattern->len, false, nargs, offset, end);
 }
 
 ScrBytes *scr_bytes_fill_num(ScrBytes *b, double v, double nargs, double offset, double end) {
+  SCR_SHARED_GUARD(b, NULL);
   uint8_t byte = (uint8_t)scr_bytes_to_u32(v);
   return scr_bytes_fill_core(b, &byte, 1, false, nargs, offset, end);
 }
 
 ScrBytes *scr_bytes_fill_str(ScrBytes *b, const ScrStr *s, const ScrStr *enc,
                              double nargs, double offset, double end) {
+  SCR_SHARED_GUARD(b, NULL);
   ScrBytes *pat = scr_bytes_from_str(s, enc);
   ScrBytes *r = scr_bytes_fill_core(b, pat->data, pat->len, true, nargs, offset, end);
   scr_bytes_release(pat);
@@ -2430,6 +2655,7 @@ ScrBytes *scr_bytes_fill_str(ScrBytes *b, const ScrStr *s, const ScrStr *enc,
  * bounded by the source length. Returns the byte count copied. */
 double scr_bytes_copy_into(const ScrBytes *src, ScrBytes *dst, double nargs,
                            double ts, double ss, double se) {
+  SCR_SHARED_GUARD(src, dst);
   size_t n = (size_t)nargs;
   ts = n < 1 ? 0 : trunc(ts);
   ss = n < 2 ? 0 : trunc(ss);
@@ -2452,6 +2678,7 @@ double scr_bytes_copy_into(const ScrBytes *src, ScrBytes *dst, double nargs,
  * (+1, chaining like fill). A length off the width is Node's constant
  * ERR_INVALID_BUFFER_SIZE RangeError. */
 ScrBytes *scr_bytes_swap(ScrBytes *b, double width) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t w = (size_t)width;
   if (b->len % w != 0) {
     char msg[64];
@@ -2477,6 +2704,7 @@ ScrBytes *scr_bytes_swap(ScrBytes *b, double width) {
  * lone lead), byte-level for the rest. Returns the bytes written. */
 double scr_bytes_write_str(ScrBytes *b, const ScrStr *s, const ScrStr *enc,
                            double offset, double len, bool has_len) {
+  SCR_SHARED_GUARD(b, NULL);
   if (!scr_bytes_validate_off("offset", offset, (double)b->len)) return 0;
   size_t o = (size_t)offset;
   size_t remaining = b->len - o;
@@ -2487,6 +2715,36 @@ double scr_bytes_write_str(ScrBytes *b, const ScrStr *s, const ScrStr *enc,
   } else {
     budget = remaining;
   }
+  /* UTF-8 already has its final representation. Copy only the requested
+   * prefix, backing off when the destination ends inside a scalar. */
+  if (scr_enc_is(enc, "utf8")) {
+    size_t k = s->len < budget ? s->len : budget;
+    if (k < s->len) {
+      while (k > 0 && ((uint8_t)s->data[k] & 0xc0) == 0x80) k--;
+    }
+    if (k) memcpy(b->data + o, s->data, k);
+    return (double)k;
+  }
+  bool utf16 = scr_enc_is(enc, "utf16le");
+  if (utf16 || scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii")) {
+    size_t i = 0, written = 0, width = utf16 ? 2 : 1;
+    while (i < s->len && budget - written >= width) {
+      uint32_t cp = scr_bytes_next_cp((const uint8_t *)s->data, &i);
+      uint32_t first = cp, second = 0;
+      if (cp > 0xffff) {
+        cp -= 0x10000;
+        first = 0xd800 + (cp >> 10);
+        second = 0xdc00 + (cp & 0x3ff);
+      }
+      b->data[o + written++] = (uint8_t)first;
+      if (utf16) b->data[o + written++] = (uint8_t)(first >> 8);
+      if (second && budget - written >= width) {
+        b->data[o + written++] = (uint8_t)second;
+        if (utf16) b->data[o + written++] = (uint8_t)(second >> 8);
+      }
+    }
+    return (double)written;
+  }
   ScrBytes *encd = scr_bytes_from_str(s, enc);
   size_t k = encd->len < budget ? encd->len : budget;
   if (k < encd->len) {
@@ -2550,7 +2808,7 @@ ScrBytes *scr_bytes_concat_len(const ScrArr *list, double total) {
       return NULL;
     }
     size_t take = part->len < b->len - o ? part->len : b->len - o;
-    memcpy(b->data + o, part->data, take);
+    scr_bytes_read(part, 0, b->data + o, take);
     o += take;
     scr_bytes_release(part);
   }
@@ -2616,7 +2874,7 @@ ScrBytes *scr_bytes_concat(const ScrArr *list) {
       scr_bytes_release(b);
       return NULL;
     }
-    memcpy(b->data + o, part->data, part->len);
+    scr_bytes_read(part, 0, b->data + o, part->len);
     o += part->len;
     scr_bytes_release(part);
   }
@@ -2747,6 +3005,7 @@ static size_t scr_bytes_num_width(ScrBytesNumKind kind) {
 }
 
 double scr_bytes_read_num(const ScrBytes *b, double offset, ScrBytesNumKind kind, bool le) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t width = scr_bytes_num_width(kind);
   if (!scr_bytes_rw_check(b, offset, width)) return 0;
   const uint8_t *p = b->data + (size_t)offset;
@@ -2781,6 +3040,7 @@ double scr_bytes_read_num(const ScrBytes *b, double offset, ScrBytesNumKind kind
 }
 
 double scr_bytes_write_num(ScrBytes *b, double value, double offset, ScrBytesNumKind kind, bool le) {
+  SCR_SHARED_GUARD(b, NULL);
   size_t width = scr_bytes_num_width(kind);
   uint64_t u;
   if (kind == SCR_BN_F32 || kind == SCR_BN_F64) {
@@ -2812,6 +3072,7 @@ double scr_bytes_write_num(ScrBytes *b, double value, double offset, ScrBytesNum
 /* readUIntLE/BE / readIntLE/BE — the variable-width family: byteLength
  * validates FIRST (1-6, its own error ladder), then the offset gate. */
 double scr_bytes_read_var(const ScrBytes *b, double offset, double byte_length, bool sign, bool le) {
+  SCR_SHARED_GUARD(b, NULL);
   if (floor(byte_length) != byte_length || byte_length < 1 || byte_length > 6) {
     scr_bytes_bounds_error(byte_length, 6, "byteLength");
     return 0;
@@ -2832,6 +3093,7 @@ double scr_bytes_read_var(const ScrBytes *b, double offset, double byte_length,
 /* writeUIntLE/BE / writeIntLE/BE: byteLength, then value, then offset —
  * Node's exact check order. Returns offset + byteLength. */
 double scr_bytes_write_var(ScrBytes *b, double value, double offset, double byte_length, bool sign, bool le) {
+  SCR_SHARED_GUARD(b, NULL);
   if (floor(byte_length) != byte_length || byte_length < 1 || byte_length > 6) {
     scr_bytes_bounds_error(byte_length, 6, "byteLength");
     return 0;
@@ -2849,6 +3111,7 @@ double scr_bytes_write_var(ScrBytes *b, double value, double offset, double byte
 }
 
 bool scr_bytes_read_u64_raw(const ScrBytes *b, double offset, bool le, uint64_t *out) {
+  SCR_SHARED_GUARD(b, NULL);
   if (!scr_bytes_rw_check(b, offset, 8)) return false;
   const uint8_t *p = b->data + (size_t)offset;
   uint64_t value = 0;
@@ -2858,6 +3121,7 @@ bool scr_bytes_read_u64_raw(const ScrBytes *b, double offset, bool le, uint64_t
 }
 
 bool scr_bytes_write_u64_raw(ScrBytes *b, double offset, bool le, uint64_t value) {
+  SCR_SHARED_GUARD(b, NULL);
   if (!scr_bytes_rw_check(b, offset, 8)) return false;
   uint8_t *p = b->data + (size_t)offset;
   for (size_t i = 0; i < 8; i++) p[le ? i : 7 - i] = (uint8_t)(value >> (8 * i));
@@ -2875,6 +3139,7 @@ static bool scr_dataview_u64_check(const ScrBytes *b, double byte_off) {
 }
 
 bool scr_dataview_read_u64_raw(const ScrBytes *b, double offset, bool le, uint64_t *out) {
+  SCR_SHARED_GUARD(b, NULL);
   double off = (offset != offset) ? 0 : trunc(offset);
   if (!scr_dataview_u64_check(b, offset)) return false;
   const uint8_t *p = b->data + (size_t)off;
@@ -2885,6 +3150,7 @@ bool scr_dataview_read_u64_raw(const ScrBytes *b, double offset, bool le, uint64
 }
 
 bool scr_dataview_write_u64_raw(ScrBytes *b, double offset, bool le, uint64_t value) {
+  SCR_SHARED_GUARD(b, NULL);
   double off = (offset != offset) ? 0 : trunc(offset);
   if (!scr_dataview_u64_check(b, offset)) return false;
   uint8_t *p = b->data + (size_t)off;