@scriptc/cli-darwin-x64 0.2.4 → 0.2.5

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,13 +117,16 @@ 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;
@@ -134,6 +138,27 @@ static ScrBytes *scr_bytes_alloc(ScrBytesElem elem, size_t len) {
   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 +193,13 @@ 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);
+  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,13 +215,6 @@ 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) {
@@ -246,11 +264,7 @@ 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) {
@@ -336,6 +350,86 @@ 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) {
+  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. */
@@ -353,7 +447,7 @@ ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end) {
   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;
 }
@@ -376,7 +470,23 @@ ScrBytes *scr_bytes_copy_within(ScrBytes *b, double target, double start, double
 ScrBytes *scr_bytes_fill_elem(ScrBytes *b, double v, double start, double end) {
   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);
 }
 
@@ -414,16 +524,27 @@ void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset) {
     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
@@ -766,79 +887,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;
 }
 
@@ -1109,23 +1236,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;
 }
 
@@ -1817,7 +1951,12 @@ ScrDyn *scr_text_encode_into(const ScrDyn *source, const ScrDyn *destination) {
   const ScrStr *text = source->v.str;
   ScrBytes *dest = destination->v.bytes;
   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;
@@ -1840,33 +1979,14 @@ 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; }
+  bool result = scr_bytes_ascii_prefix(bytes->data, bytes->len) == bytes->len;
   scr_bytes_release(bytes);
   return result;
 }
@@ -2021,25 +2141,28 @@ 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;
 }
 
@@ -2049,35 +2172,34 @@ ScrStr *scr_bytes_to_str(const ScrBytes *b, const ScrStr *enc) {
   /* 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 +2280,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 +2354,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 +2370,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 +2390,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;
 }
@@ -2487,6 +2678,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) {