/* Typed arrays / Buffer: ONE runtime representation (ScrBytes — see the
 * header contract). An ScrBytes either OWNS its storage or is a VIEW into
 * an owner's (backing set, chain depth exactly 1): DataView, subarray(),
 * and Buffer's slice() all alias JS-exactly; only the plain typed arrays'
 * slice() copies. Coercions are JS-exact
 * (ToUint8/ToUint32 modular truncation, double→float rounding); the
 * encoding conversions (utf8 with WHATWG replacement, hex, base64) match
 * Node's output exactly — 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"
#endif

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(__SSE2__)
#include <emmintrin.h>
#elif defined(__ARM_NEON) && defined(__aarch64__)
#include <arm_neon.h>
#endif

static bool scr_td_label_space(unsigned char c) {
  return c == 9 || c == 10 || c == 12 || c == 13 || c == 32;
}

/* The encoding id of a label that String() converted (borrowed), or
 * Node's RangeError ERR_ENCODING_NOT_SUPPORTED. */
static double scr_td_lookup(ScrStr *text) {
  size_t start = 0, end = text->len;
  while (start < end && scr_td_label_space((unsigned char)text->data[start])) start++;
  while (end > start && scr_td_label_space((unsigned char)text->data[end - 1])) end--;
  for (size_t i = 0; i < sizeof scr_td_labels / sizeof scr_td_labels[0]; i++) {
    const char *candidate = scr_td_labels[i].label;
    if (strlen(candidate) != end - start) continue;
    bool matches = true;
    for (size_t j = start; j < end; j++) {
      unsigned char c = (unsigned char)text->data[j];
      if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
      if (c != (unsigned char)candidate[j - start]) { matches = false; break; }
    }
    if (matches) return scr_td_labels[i].encoding;
  }
  static const char prefix[] = "The \"";
  static const char suffix[] = "\" encoding is not supported";
  size_t length = sizeof prefix - 1 + text->len + sizeof suffix - 1;
  char *message = malloc(length + 1);
  if (!message) scr_trap("scriptc: out of memory\n");
  memcpy(message, prefix, sizeof prefix - 1);
  memcpy(message + sizeof prefix - 1, text->data, text->len);
  memcpy(message + sizeof prefix - 1 + text->len, suffix, sizeof suffix);
  scr_throw_error_msg_code(SCR_ERR_RANGE, message, length, "ERR_ENCODING_NOT_SUPPORTED");
  free(message);
  return -1;
}

double scr_text_decoder_encoding(const ScrDyn *label) {
  if (!label || label->kind == SCR_DYN_UNDEF) return -1;
  ScrStr *text = scr_dyn_string_coerce_js(label);
  if (!text) return -1;
  double result = scr_td_lookup(text);
  scr_str_release(text);
  return result;
}

/* TextDecoder's options argument, as Node's validateObject with
 * kValidateObjectAllowObjectsAndNull checks it: null, objects, arrays and
 * functions pass, as does undefined, which the parameter default replaces
 * with an empty object; another primitive throws ERR_INVALID_ARG_TYPE. */
static bool scr_td_options_ok(const ScrDyn *options) {
  switch (options->kind) {
    case SCR_DYN_BOOL:
    case SCR_DYN_NUM:
    case SCR_DYN_STR:
    case SCR_DYN_SYMBOL:
    case SCR_DYN_BIGINT:
      scr_dyn_arg_type_fail("options", "of type object", options);
      return false;
    default:
      return true;
  }
}

/* options[name] with JS truthiness; undefined and null options read as
 * false. A getter's exception stays pending. */
bool scr_text_decoder_flag(const ScrDyn *options, const ScrStr *name) {
  if (options->kind == SCR_DYN_UNDEF || options->kind == SCR_DYN_NULL) return false;
  ScrDyn *value;
  if (options->kind == SCR_DYN_TYPED_REF) {
    /* A compiled record or class instance: its own fields, else its view. */
    value = scr_dyn_typed_ref_own_get(options, name);
    if (!value && !scr_exc_pending()) {
      ScrDyn *view = scr_dyn_typed_ref_materialize(options);
      if (!view) return false;
      value = scr_dyn_obj_read(view, name->data, name->len);
      scr_dyn_release(view);
    }
  } else {
    value = scr_dyn_obj_read(options, name->data, name->len);
  }
  if (!value) return false;
  bool truthy = scr_dyn_truthy(value);
  scr_dyn_release(value);
  return truthy;
}

/* decode(input, options): the options check, then options.stream. */
bool scr_text_decode_stream_option(const ScrDyn *options) {
  if (!scr_td_options_ok(options)) return false;
  ScrStr *name = scr_str_new("stream", 6);
  bool stream = scr_text_decoder_flag(options, name);
  scr_str_release(name);
  return stream;
}

/* new TextDecoder(label, options) with options outside an object literal,
 * in Node's order: String(label) (an undefined label is utf-8), the
 * options check, then the label lookup. */
double scr_text_decoder_encoding_options(const ScrDyn *label, const ScrDyn *options) {
  ScrStr *text = label->kind == SCR_DYN_UNDEF ? NULL : scr_dyn_string_coerce_js(label);
  if (!text && label->kind != SCR_DYN_UNDEF) return -1;
  if (!scr_td_options_ok(options)) {
    if (text) scr_str_release(text);
    return -1;
  }
  if (!text) return -1;
  double result = scr_td_lookup(text);
  scr_str_release(text);
  return result;
}

static const char *scr_td_encoding_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",
  };
  return encoding < 0 ? "utf-8" : names[(unsigned)encoding];
}

ScrStr *scr_text_decoder_name(double encoding) {
  const char *name = scr_td_encoding_name(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; }
#endif

static void scr_bytes_oom(void) {
  scr_trap("scriptc: out of memory\n");
}

uint16_t scr_f16_from_f64(double value) {
  uint64_t bits;
  memcpy(&bits, &value, sizeof bits);
  uint16_t sign = (uint16_t)((bits >> 48) & 0x8000);
  uint64_t magnitude = bits & UINT64_C(0x7fffffffffffffff);
  if (magnitude >= UINT64_C(0x7ff0000000000000)) {
    if (magnitude == UINT64_C(0x7ff0000000000000)) return sign | 0x7c00;
    return sign | 0x7e00 | (uint16_t)((magnitude >> 42) & 0x3ff);
  }
  int exponent = (int)(magnitude >> 52) - 1023;
  if (exponent > 15) return sign | 0x7c00;
  uint64_t fraction = magnitude & ((UINT64_C(1) << 52) - 1);
  uint64_t significand = exponent == -1023 ? fraction : fraction | (UINT64_C(1) << 52);
  if (exponent == -1023) exponent = -1022;
  int biased = exponent + 15;
  /* Normal results keep 10 of the 52 fraction bits; subnormal results
   * shift further, by how far the exponent is below the normal range. */
  int shift = biased >= 1 ? 42 : 42 + (1 - biased);
  if (shift >= 54) return sign;
  uint64_t q = significand >> shift;
  uint64_t rest = significand & ((UINT64_C(1) << shift) - 1);
  uint64_t half = UINT64_C(1) << (shift - 1);
  if (rest > half || (rest == half && (q & 1))) q++;
  if (biased < 1) return sign | (uint16_t)q; /* a carry into 0x400 is the smallest normal */
  if (q == 2048) {
    q = 1024;
    biased++;
  }
  if (biased >= 31) return sign | 0x7c00;
  return sign | (uint16_t)(biased << 10) | (uint16_t)(q & 0x3ff);
}

double scr_f16_to_f64(uint16_t h) {
  uint64_t sign = (uint64_t)(h >> 15) << 63;
  unsigned exponent = (h >> 10) & 0x1f, fraction = h & 0x3ff;
  uint64_t bits;
  if (exponent == 0) {
    double v = (double)fraction * 5.9604644775390625e-8; /* fraction * 2^-24, exact */
    memcpy(&bits, &v, sizeof bits);
    bits |= sign;
  } else if (exponent == 31) {
    bits = sign | UINT64_C(0x7ff0000000000000) | ((uint64_t)fraction << 42);
  } else {
    bits = sign | ((uint64_t)(exponent - 15 + 1023) << 52) | ((uint64_t)fraction << 42);
  }
  double out;
  memcpy(&out, &bits, sizeof out);
  return out;
}

size_t scr_bytes_elem_size(ScrBytesElem elem) {
  switch (elem) {
    case SCR_BYTES_U8: case SCR_BYTES_U8C: case SCR_BYTES_I8: return 1;
    case SCR_BYTES_U16: case SCR_BYTES_I16: case SCR_BYTES_F16: return 2;
    case SCR_BYTES_U32: case SCR_BYTES_I32: case SCR_BYTES_F32: return 4;
    case SCR_BYTES_F64: return 8;
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64: case SCR_BYTES_U64: return 8;
#endif
  }
  scr_trap("scriptc: invalid typed array element kind\n");
}

const char *scr_bytes_elem_name(ScrBytesElem elem) {
  switch (elem) {
    case SCR_BYTES_U8: return "Uint8Array";
    case SCR_BYTES_U8C: return "Uint8ClampedArray";
    case SCR_BYTES_I8: return "Int8Array";
    case SCR_BYTES_U16: return "Uint16Array";
    case SCR_BYTES_I16: return "Int16Array";
    case SCR_BYTES_U32: return "Uint32Array";
    case SCR_BYTES_I32: return "Int32Array";
    case SCR_BYTES_F16: return "Float16Array";
    case SCR_BYTES_F32: return "Float32Array";
    case SCR_BYTES_F64: return "Float64Array";
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64: return "BigInt64Array";
    case SCR_BYTES_U64: return "BigUint64Array";
#endif
  }
  scr_trap("scriptc: invalid typed array element kind\n");
}

#ifdef SCR_JS_OBJECT_MODEL
bool scr_bytes_elem_is_bigint(ScrBytesElem elem) {
  return elem == SCR_BYTES_I64 || elem == SCR_BYTES_U64;
}
#endif

/* Appends Node's inspect of an ArrayBuffer at indentation level `indent`:
 * the first 100 bytes as hex pairs, on one line when it fits the 80-column
 * break length (reduceToSingleString), one entry per line otherwise. */
static void scr_bytes_inspect_array_buffer(ScrJsonBuf *jb, const ScrBytes *owner, size_t indent) {
  static const char digits[] = "0123456789abcdef";
  size_t len = owner->len * scr_bytes_elem_size(owner->elem);
  size_t shown = len < 100 ? len : 100;
  ScrJsonBuf contents;
  scr_jb_init(&contents);
  scr_jb_puts(&contents, "[Uint8Contents]: <");
  for (size_t i = 0; i < shown; i++) {
    uint8_t byte;
    scr_bytes_read(owner, i, &byte, 1);
    if (i) scr_jb_putc(&contents, ' ');
    scr_jb_putc(&contents, digits[byte >> 4]);
    scr_jb_putc(&contents, digits[byte & 15]);
  }
  if (len > shown) {
    char more[48];
    snprintf(more, sizeof more, " ... %zu more byte%s", len - shown, len - shown > 1 ? "s" : "");
    scr_jb_puts(&contents, more);
  }
  scr_jb_putc(&contents, '>');
  ScrStr *first = scr_jb_finish(&contents);
  char second[40];
  int second_len = snprintf(second, sizeof second, "[byteLength]: %zu", len);
  /* isBelowBreakLength with two entries, start = 2 + indentation + "ArrayBuffer {" + 10. */
  size_t total = 2 + (2 + indent + 13 + 10) + first->len + (size_t)second_len;
  if (total <= 80) {
    scr_jb_puts(jb, "ArrayBuffer { ");
    scr_jb_put_str(jb, first);
    scr_jb_puts(jb, ", ");
    scr_jb_puts(jb, second);
    scr_jb_puts(jb, " }");
  } else {
    scr_jb_puts(jb, "ArrayBuffer {\n");
    for (size_t i = 0; i < indent + 2; i++) scr_jb_putc(jb, ' ');
    scr_jb_put_str(jb, first);
    scr_jb_puts(jb, ",\n");
    for (size_t i = 0; i < indent + 2; i++) scr_jb_putc(jb, ' ');
    scr_jb_puts(jb, second);
    scr_jb_putc(jb, '\n');
    for (size_t i = 0; i < indent; i++) scr_jb_putc(jb, ' ');
    scr_jb_putc(jb, '}');
  }
  scr_str_release(first);
}

/* ERR_INVALID_ARG_VALUE for an empty ArrayBufferView: Node's inspect of the
 * view (a Buffer, an empty typed array, or a DataView with its buffer), cut
 * to 128 characters followed by "...". The fs ladders print the same text
 * under their own message ("...is empty and cannot be written. Received "),
 * so this is shared. */
ScrStr *scr_dyn_empty_view_inspect(const ScrDyn *value) {
  const ScrBytes *view = value->v.bytes;
  ScrJsonBuf jb;
  scr_jb_init(&jb);
  if (value->buffer) {
    scr_jb_puts(&jb, "<Buffer >");
  } else if (!view->is_data_view) {
    scr_jb_puts(&jb, scr_bytes_elem_name(view->elem));
    scr_jb_puts(&jb, "(0) []");
  } else {
    const ScrBytes *owner = view->backing ? view->backing : view;
    char line[64];
    snprintf(line, sizeof line, "DataView {\n  [byteLength]: 0,\n  [byteOffset]: %zu,\n  [buffer]: ",
             (size_t)(view->data - owner->data));
    scr_jb_puts(&jb, line);
    scr_bytes_inspect_array_buffer(&jb, owner, 2);
    scr_jb_puts(&jb, "\n}");
  }
  ScrStr *inspected = scr_jb_finish(&jb);
  if (inspected->len <= 128) return inspected;
  ScrJsonBuf out;
  scr_jb_init(&out);
  ScrStr *head = scr_str_new(inspected->data, 128);
  scr_jb_put_str(&out, head);
  scr_str_release(head);
  scr_jb_puts(&out, "...");
  scr_str_release(inspected);
  return scr_jb_finish(&out);
}

double scr_bytes_to_u8_clamp(double value) {
  if (!(value > 0)) return 0;
  if (value >= 255) return 255;
  double lower = floor(value);
  double fraction = value - lower;
  return fraction > 0.5 || (fraction == 0.5 && ((unsigned)lower & 1)) ? lower + 1 : lower;
}

/* ── lifecycle ─────────────────────────────────────────────────────────── */

/* The storage of this instance's owners, which are created and released on
 * its thread (their reference counts are not atomic), and of the
 * SharedArrayBuffer storage of the process, which any thread may release. */
static SCR_TL size_t scr_array_buffers_local;
static size_t scr_array_buffers_shared;

double scr_array_buffers_held(bool shared) {
  return shared ? (double)__atomic_load_n(&scr_array_buffers_shared, __ATOMIC_RELAXED)
                : (double)scr_array_buffers_local;
}

void scr_array_buffers_sub(bool shared, size_t n) {
  if (shared) __atomic_fetch_sub(&scr_array_buffers_shared, n, __ATOMIC_RELAXED);
  else scr_array_buffers_local -= n;
}

void scr_array_buffers_share(size_t n) {
  scr_array_buffers_local -= n;
  __atomic_fetch_add(&scr_array_buffers_shared, n, __ATOMIC_RELAXED);
}

/* An owner of `len` elements of `elem` over malloc storage `data`, counting
 * `held` bytes of it in scr_array_buffers_held. */
__attribute__((always_inline)) static inline ScrBytes *
scr_bytes_own(uint8_t *data, size_t len, ScrBytesElem elem, size_t held) {
  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 = 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->untransferable = false;
  b->shared = NULL;
  b->properties = NULL;
  b->properties_traced = false;
  scr_bytes_set_held(b, held);
  scr_array_buffers_local += held;
#ifdef SCR_RC_AUDIT
  scr_live_bytes++;
#endif
  return b;
}

/* 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) {
  return scr_bytes_own(data, len, SCR_BYTES_U8, len);
}

/* 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();
  return scr_bytes_own(data, len, elem, len * width);
}

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();
  return scr_bytes_own(data, len, elem, len * width);
}

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
   * view operations may add zero to the data pointer. */
  if (data) {
    free(b->data);
    b->data = data;
    b->external = true;
  }
  b->len = length;
  scr_bytes_set_held(b, 0);
  return b;
}

ScrBytes *scr_bytes_new(ScrBytesElem elem, double n) {
  /* ToIndex: NaN → 0, truncate toward zero; a negative or > 2^53-1 result
   * throws Node's RangeError ("Invalid typed array length: -1"). A
   * fractional 3.5 is length 3 — ToIndex never compares back. */
  double t = (n != n) ? 0 : trunc(n);
  if (!(t >= 0) || t > 9007199254740991.0 || t > (double)(SIZE_MAX / 8)) {
    char num[32];
    size_t numlen = scr_f64_to_str(t, num);
    char msg[80];
    int mlen = snprintf(msg, sizeof msg, "Invalid typed array length: %.*s",
                        (int)numlen, num);
    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
    return NULL;
  }
  return scr_bytes_alloc(elem, (size_t)t);
}

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_private(SCR_BYTES_U8, len);
  if (len != 0) memcpy(b->data, data, len);
  return b;
}

/* Raw bytes of a view: shared storage through relaxed atomic copies
 * (scr_shared_load / scr_shared_store), other storage directly. */
static void scr_bytes_raw_in(const ScrBytes *b, void *dst, const uint8_t *src, size_t n) {
  if (b->shared) scr_shared_load(dst, src, n);
  else if (n) memcpy(dst, src, n);
}

static void scr_bytes_raw_out(ScrBytes *b, uint8_t *dst, const void *src, size_t n) {
  if (b->shared) scr_shared_store(dst, src, n);
  else if (n) memmove(dst, src, n);
}

/* A private buffer for n bytes that a shared writer fills before
 * publishing them with scr_bytes_raw_out. */
static uint8_t *scr_bytes_scratch(size_t n) {
  uint8_t *scratch = malloc(n ? n : 1);
  if (!scratch) scr_bytes_oom();
  return scratch;
}

ScrBytes *scr_bytes_copy(const ScrBytes *src) {
  ScrBytes *b = scr_bytes_alloc_private(src->elem, src->len);
  scr_bytes_raw_in(src, b->data, src->data, src->len * scr_bytes_elem_size(src->elem));
  return b;
}

ScrBytes *scr_bytes_raw_view(ScrBytes *bytes) {
  if (bytes->elem == SCR_BYTES_U8) return scr_bytes_retain(bytes);
  return scr_dataview_new(bytes, scr_bytes_byte_offset(bytes), true, scr_bytes_byte_len(bytes));
}

ScrBytes *scr_bytes_as_buffer(ScrBytes *bytes) {
  bytes->is_buffer = true;
  bytes->is_data_view = false;
  return scr_bytes_retain(bytes);
}

/* Nothing on an existing path calls this. */
bool scr_bytes_is_buffer(const ScrBytes *bytes) { return bytes->is_buffer; }

void scr_bytes_copy_brand(ScrBytes *dst, const ScrBytes *src) {
  if (dst->elem == SCR_BYTES_U8 && src->elem == SCR_BYTES_U8) dst->is_buffer = src->is_buffer;
}

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_inline(b);
    if (b->properties) scr_dyn_release(b->properties);
    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) {
      scr_array_buffers_local -= scr_bytes_held(b);
      free(b->data);
    }
#ifdef SCR_RC_AUDIT
    scr_live_bytes--;
#endif
    free(b);
  }
}

void *scr_bytes_retain_v(void *b) { return scr_bytes_retain((ScrBytes *)b); }
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) {
  if (dst->elem != src->elem || dst->len != src->len) {
    scr_trap("scriptc: typed array snapshot shape changed\n");
  }
  size_t n = dst->len * scr_bytes_elem_size(dst->elem);
  if (!dst->shared && !src->shared) {
    memcpy(dst->data, src->data, n);
    return;
  }
  uint8_t *scratch = scr_bytes_scratch(n);
  scr_bytes_raw_in(src, scratch, src->data, n);
  scr_bytes_raw_out(dst, dst->data, scratch, n);
  free(scratch);
}

double scr_bytes_byte_len(const ScrBytes *b) {
  return (double)(b->len * scr_bytes_elem_size(b->elem));
}

#ifdef SCR_JS_OBJECT_MODEL
/* The mutable-buffers registry's table (scr_js_buffers.c, the optional
 * unit a `mutableBuffers` program links). NULL until scr_js_buffers_arm
 * installs it, so a program without the fact pays one pointer test in front
 * of the view hooks below and links no registry at all. */
SCR_TL const ScrJsBufferOps *scr_js_buffer_ops;

#endif

#ifdef SCR_JS_OBJECT_MODEL
/* Records a view in the registry when the program may move buffers. */
static void scr_js_buffer_register(ScrBytes *view, bool tracking) {
  const ScrJsBufferOps *ops = scr_js_buffer_ops;
  if (ops && view->backing) ops->view_register(view, tracking);
}

/* Whether an owner reserves a maxByteLength, so a length-tracking view may
 * end on a partial element (Node allows it and floors the element count). */
static bool scr_js_owner_resizable(const ScrBytes *owner) {
  const ScrJsBufferOps *ops = scr_js_buffer_ops;
  return ops && ops->owner_resizable(owner);
}
#endif

#ifdef SCR_JS_OBJECT_MODEL
/* The element accessors below guard %TypedArray%.prototype methods with
 * this check (defined beside the DataView helpers); the guards precede it. */
static bool scr_js_typed_method_ok(const ScrBytes *b, const char *method);
#endif

/* ── element access ────────────────────────────────────────────────────
 * Invalid writes are ignored. Typed numeric reads cannot represent
 * undefined, so invalid reads trap; checked reads return undefined. */

static size_t scr_bytes_check_index(const ScrBytes *b, double i) {
  if (!(i >= 0) || i != trunc(i) || i >= (double)b->len) {
    char buf[32];
    scr_f64_to_str(i, buf);
    scr_trap_fmt("scriptc: RangeError: typed array index %s out of bounds (length %zu)\n",
                 buf, b->len);
  }
  return (size_t)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) {
  return scr_numeric_to_u32(v);
}

/* An element's value from its bytes. */
static double scr_bytes_decode(ScrBytesElem elem, const uint8_t *p) {
  switch (elem) {
    case SCR_BYTES_U8: case SCR_BYTES_U8C:
      return (double)p[0];
    case SCR_BYTES_I8: {
      int8_t v;
      memcpy(&v, p, 1);
      return (double)v;
    }
    case SCR_BYTES_U16: {
      uint16_t v;
      memcpy(&v, p, 2);
      return (double)v;
    }
    case SCR_BYTES_I16: {
      int16_t v;
      memcpy(&v, p, 2);
      return (double)v;
    }
    case SCR_BYTES_U32: {
      uint32_t v;
      memcpy(&v, p, 4);
      return (double)v;
    }
    case SCR_BYTES_F16: {
      uint16_t v;
      memcpy(&v, p, 2);
      return scr_f16_to_f64(v);
    }
    case SCR_BYTES_F32: {
      float v;
      memcpy(&v, p, 4);
      return (double)v;
    }
    case SCR_BYTES_F64: {
      double v;
      memcpy(&v, p, 8);
      return v;
    }
    case SCR_BYTES_I32: {
      int32_t v;
      memcpy(&v, p, 4);
      return (double)v;
    }
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64: case SCR_BYTES_U64:
      /* No double holds a BigInt element: the dynamic tier reads these
       * through scr_bytes_get_bigint, and compiled code cannot name them. */
      scr_trap("scriptc: numeric read of a BigInt typed array\n");
#endif
  }
  return 0; /* unreachable */
}

/* An element's bytes for v, with the element type's JS conversion. */
static void scr_bytes_encode(ScrBytesElem elem, uint8_t *p, double v) {
  switch (elem) {
    case SCR_BYTES_U8: case SCR_BYTES_I8:
      p[0] = (uint8_t)scr_bytes_to_u32(v);
      break;
    case SCR_BYTES_U8C:
      p[0] = (uint8_t)scr_bytes_to_u8_clamp(v);
      break;
    case SCR_BYTES_U16: case SCR_BYTES_I16: {
      uint16_t u = (uint16_t)scr_bytes_to_u32(v);
      memcpy(p, &u, 2);
      break;
    }
    case SCR_BYTES_U32: case SCR_BYTES_I32: {
      /* ToInt32 is ToUint32 reinterpreted signed (same 2^32 residue). */
      uint32_t u = scr_bytes_to_u32(v);
      memcpy(p, &u, 4);
      break;
    }
    case SCR_BYTES_F16: {
      uint16_t h = scr_f16_from_f64(v);
      memcpy(p, &h, 2);
      break;
    }
    case SCR_BYTES_F32: {
      float f = (float)v; /* round-to-nearest-even, exactly Float32Array */
      memcpy(p, &f, 4);
      break;
    }
    case SCR_BYTES_F64:
      memcpy(p, &v, 8);
      break;
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64: case SCR_BYTES_U64:
      /* Element stores of a BigInt view are ToBigInt in scr_bytes_set_bigint;
       * no double ever reaches one. */
      scr_trap("scriptc: numeric write to a BigInt typed array\n");
#endif
  }
}

/* Shared elements are read and written as one relaxed atomic access of the
 * element's width. Atomics operations on the same elements use atomic
 * instructions without a lock, and an ordinary access of an aligned element
 * never tears (ECMA-262 shared memory model). Views of shared storage are
 * aligned to their element size. */
static void scr_bytes_shared_read(const ScrBytes *b, size_t idx, uint8_t out[8]) {
  size_t width = scr_bytes_elem_size(b->elem);
  const uint8_t *p = b->data + idx * width;
  switch (width) {
    case 1: out[0] = __atomic_load_n(p, __ATOMIC_RELAXED); break;
    case 2: {
      uint16_t v = __atomic_load_n((const uint16_t *)p, __ATOMIC_RELAXED);
      memcpy(out, &v, 2);
      break;
    }
    case 4: {
      uint32_t v = __atomic_load_n((const uint32_t *)p, __ATOMIC_RELAXED);
      memcpy(out, &v, 4);
      break;
    }
    default: {
      uint64_t v = __atomic_load_n((const uint64_t *)p, __ATOMIC_RELAXED);
      memcpy(out, &v, 8);
      break;
    }
  }
}

static void scr_bytes_shared_write(ScrBytes *b, size_t idx, const uint8_t in[8]) {
  size_t width = scr_bytes_elem_size(b->elem);
  uint8_t *p = b->data + idx * width;
  switch (width) {
    case 1: __atomic_store_n(p, in[0], __ATOMIC_RELAXED); break;
    case 2: {
      uint16_t v;
      memcpy(&v, in, 2);
      __atomic_store_n((uint16_t *)p, v, __ATOMIC_RELAXED);
      break;
    }
    case 4: {
      uint32_t v;
      memcpy(&v, in, 4);
      __atomic_store_n((uint32_t *)p, v, __ATOMIC_RELAXED);
      break;
    }
    default: {
      uint64_t v;
      memcpy(&v, in, 8);
      __atomic_store_n((uint64_t *)p, v, __ATOMIC_RELAXED);
      break;
    }
  }
}

/* The element at a valid index, as a number. */
static double scr_bytes_load(const ScrBytes *b, size_t idx) {
  if (b->shared) {
    uint8_t bits[8];
    scr_bytes_shared_read(b, idx, bits);
    return scr_bytes_decode(b->elem, bits);
  }
  return scr_bytes_decode(b->elem, b->data + idx * scr_bytes_elem_size(b->elem));
}

double scr_bytes_get(const ScrBytes *b, double i) {
  return scr_bytes_load(b, scr_bytes_check_index(b, i));
}

/* The numeric view of an ordinary typed-array read: Node answers undefined
 * for an index that is not an integer in [0, length), which ToNumber turns
 * into NaN. Never touches storage out of bounds. */
double scr_bytes_get_or_nan(const ScrBytes *b, double i) {
  if (!(i >= 0) || i != trunc(i) || i >= (double)b->len) return NAN;
  return scr_bytes_get(b, i);
}

/* Store v at a valid index with the element type's JS conversion. */
static void scr_bytes_store(ScrBytes *b, size_t idx, double v) {
  if (b->shared) {
    uint8_t bits[8];
    scr_bytes_encode(b->elem, bits, v);
    scr_bytes_shared_write(b, idx, bits);
    return;
  }
  scr_bytes_encode(b->elem, b->data + idx * scr_bytes_elem_size(b->elem), v);
}

void scr_bytes_set(ScrBytes *b, double i, double v) {
  if (!(i >= 0) || i != trunc(i) || i >= (double)b->len) return;
  scr_bytes_store(b, (size_t)i, v);
}

#ifdef SCR_JS_OBJECT_MODEL
/* The BigInt element at a valid index (+1). The index rule is
 * scr_bytes_get's: this is the same element read, just not through a
 * double. */
ScrDyn *scr_bytes_get_bigint(const ScrBytes *b, double i) {
  size_t idx = scr_bytes_check_index(b, i);
  uint8_t bits[8];
  if (b->shared) scr_bytes_shared_read(b, idx, bits);
  else memcpy(bits, b->data + idx * 8, 8);
  uint64_t raw;
  memcpy(&raw, bits, 8);
  /* BigInt64Array's element is the signed two's-complement value of the
   * same bits the unsigned view reads zero-extended. scr_dyn_new_bigint
   * retains, so the constructed value itself is released here. */
  ScrBigInt *value = b->elem == SCR_BYTES_I64 ? scr_bigint_from_i64((int64_t)raw)
                                              : scr_bigint_from_u64(raw);
  ScrDyn *out = scr_dyn_new_bigint(value);
  scr_bigint_release(value);
  return out;
}

/* ToBigInt(value) as an element store of a BigInt view; the low 64 bits are
 * stored (ToBigInt64/ToBigUint64 wrap modulo 2^64). An out-of-range index is
 * ignored, as in every typed array write, but the coercion still happens. */
bool scr_bytes_set_bigint(ScrBytes *b, double i, const ScrDyn *value) {
  ScrBigInt *big = scr_dyn_bigint_coerce(value);
  if (!big) return false;
  if ((i >= 0) && i == trunc(i) && i < (double)b->len) {
    size_t idx = (size_t)i;
    uint64_t raw = scr_bigint_to_u64(big);
    if (b->shared) {
      uint8_t bits[8];
      memcpy(bits, &raw, 8);
      scr_bytes_shared_write(b, idx, bits);
    } else {
      memcpy(b->data + idx * 8, &raw, 8);
    }
  }
  scr_bigint_release(big);
  return true;
}

static size_t scr_bytes_rel_index(double i, size_t len);

/* fill(value, start, end) over a BigInt view: the caller has already run
 * ToBigInt, which the spec orders before start and end are read. The element
 * kind is fixed by the view, so one coercion serves every element. */
ScrBytes *scr_bytes_fill_bigint(ScrBytes *b, ScrBigInt *value, double start, double end) {
  uint64_t raw = scr_bigint_to_u64(value);
  size_t from = scr_bytes_rel_index(start, b->len);
  size_t to = scr_bytes_rel_index(end, b->len);
  for (size_t i = from; i < to; i++) {
    if (b->shared) {
      uint8_t bits[8];
      memcpy(bits, &raw, 8);
      scr_bytes_shared_write(b, i, bits);
    } else memcpy(b->data + i * 8, &raw, 8);
  }
  return scr_bytes_retain(b);
}

#endif

/* Compiled code validates the index against the view's length, which never
 * changes, before it takes these shared-view paths. */
int32_t scr_bytes_shared_get_int(const ScrBytes *b, size_t i) {
  if (b->elem == SCR_BYTES_F32 || b->elem == SCR_BYTES_F64)
    scr_trap("scriptc: integer read of a float typed array\n");
  /* Uint32 elements read as their bit pattern, every other kind exactly. */
  double v = scr_bytes_load(b, i);
  return b->elem == SCR_BYTES_U32 ? (int32_t)(uint32_t)v : (int32_t)v;
}

double scr_bytes_shared_get_f64(const ScrBytes *b, size_t i) {
  return scr_bytes_load(b, i);
}

void scr_bytes_shared_set(ScrBytes *b, size_t i, double v) {
  scr_bytes_store(b, i, v);
}

/* Element stores for a double value, one per destination kind. Loads and
 * stores use memcpy so views and external storage need no stronger alignment
 * or aliasing promise. */
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_F16: {
      SCR_WRITE_NUMBERS(uint16_t, scr_f16_from_f64(src[i]));
    }
    case SCR_BYTES_F32: {
      SCR_WRITE_NUMBERS(float, (float)src[i]);
    }
    case SCR_BYTES_F64: {
      memcpy(dst, src, count * sizeof(double));
      return;
    }
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64: case SCR_BYTES_U64:
      /* Element stores of a BigInt view are ToBigInt in scr_bytes_set_bigint;
       * no double ever reaches one. */
      scr_trap("scriptc: numeric write to a BigInt typed array\n");
#endif
  }
#undef SCR_WRITE_NUMBERS
}

/* The kinds whose conversion is an integer truncation modulo the element
 * width. The BigInt kinds are excluded: they never convert through a double. */
static bool scr_bytes_integer_kind(ScrBytesElem elem) {
  switch (elem) {
    case SCR_BYTES_U8:
    case SCR_BYTES_U8C:
    case SCR_BYTES_I8:
    case SCR_BYTES_U16:
    case SCR_BYTES_I16:
    case SCR_BYTES_U32:
    case SCR_BYTES_I32:
      return true;
    case SCR_BYTES_F16:
    case SCR_BYTES_F32:
    case SCR_BYTES_F64:
      return false;
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64:
    case SCR_BYTES_U64:
      return false;
#endif
  }
  return false;
}

/* Whether a raw byte copy of the source span produces exactly the elements
 * the value-wise conversion stores. For an integer destination the store is
 * the source value's ToUint32 truncated to the destination's width, and a
 * same-width integer source already is that truncation (the read is exact
 * and the round trip through the double reproduces the same bits). A
 * Uint8ClampedArray destination instead clamps, which keeps a same-width
 * source's bits only when every source value is in 0..255 already: itself
 * and Uint8Array. An Int8Array's -1 clamps to 0 but is 0xFF as bits, and a
 * wider source can exceed 255. */
static bool scr_bytes_copy_kinds(ScrBytesElem dst, ScrBytesElem src) {
  if (!scr_bytes_integer_kind(dst) || !scr_bytes_integer_kind(src)) return false;
  if (scr_bytes_elem_size(dst) != scr_bytes_elem_size(src)) return false;
  if (dst == SCR_BYTES_U8C) return src == SCR_BYTES_U8 || src == SCR_BYTES_U8C;
  return true;
}

/* Uint8ClampedArray's store of an integer: every integer element kind fits
 * an int64_t, and an integer has no fraction to round. */
static inline uint8_t scr_bytes_clamp_integer(int64_t value) {
  return value > 255 ? 255 : value > 0 ? (uint8_t)value : 0;
}

/* One loop per (source kind, destination kind) pair. The source element is
 * read in its own type and the destination stored in its own type, so no
 * double-width scratch is written and read back between them. Loads and
 * stores are constant-width memcpy, so a view at an unaligned byteOffset and
 * external storage need no alignment promise.
 *
 * A float source converts as scr_bytes_write_numbers converts a double:
 * ToUint32 truncated to the destination's width, or Uint8ClampedArray's
 * round-half-to-even clamp.
 *
 * An integer source needs neither. Its element is already an integer in
 * [-2^31, 2^32), so ToUint32 of it is the value modulo 2^32 and the store is
 * that modulo the destination's width: exactly C's conversion of the source
 * integer to the unsigned type of that width (C11 6.3.1.3p2), which is also
 * the two's-complement bit pattern of the signed kinds. A Uint8ClampedArray
 * destination clamps the integer to 0..255; there is no fraction to round.
 * Float destinations convert the integer as before: every source value is
 * exact as a double. */
#define SCR_PAIR(dst_type, dst_value) \
  { \
    for (size_t i = 0; i < count; i++) { \
      src_type value; \
      memcpy(&value, src + i * sizeof value, sizeof value); \
      dst_type out = (dst_type)(dst_value); \
      memcpy(dst + i * sizeof out, &out, sizeof out); \
    } \
    return; \
  }
#define SCR_WRAP_NUMBER(type, value) ((type)scr_numeric_to_u32(value))
#define SCR_CLAMP_NUMBER(value) ((uint8_t)scr_bytes_to_u8_clamp(value))
#define SCR_WRAP_INTEGER(type, value) ((type)(value))
#define SCR_CLAMP_INTEGER(value) scr_bytes_clamp_integer(value)
#define SCR_DESTS(value, WRAP, CLAMP) \
  switch (dest_elem) { \
    case SCR_BYTES_U8: \
    case SCR_BYTES_I8: \
      SCR_PAIR(uint8_t, WRAP(uint8_t, value)); \
    case SCR_BYTES_U8C: \
      SCR_PAIR(uint8_t, CLAMP(value)); \
    case SCR_BYTES_U16: \
    case SCR_BYTES_I16: \
      SCR_PAIR(uint16_t, WRAP(uint16_t, value)); \
    case SCR_BYTES_U32: \
    case SCR_BYTES_I32: \
      SCR_PAIR(uint32_t, WRAP(uint32_t, value)); \
    case SCR_BYTES_F16: \
      SCR_PAIR(uint16_t, scr_f16_from_f64(value)); \
    case SCR_BYTES_F32: \
      SCR_PAIR(float, (float)(value)); \
    case SCR_BYTES_F64: \
      SCR_PAIR(double, value); \
    default: \
      scr_trap("scriptc: numeric conversion of a BigInt typed array\n"); \
  }
#define SCR_INTEGER_DESTS SCR_DESTS(value, SCR_WRAP_INTEGER, SCR_CLAMP_INTEGER)
#define SCR_NUMBER_DESTS(value) SCR_DESTS(value, SCR_WRAP_NUMBER, SCR_CLAMP_NUMBER)
/* 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) {
  if (count == 0) return;
  if (scr_bytes_copy_kinds(dest_elem, src_elem)) {
    memmove(dst, src, count * scr_bytes_elem_size(src_elem));
    return;
  }
  switch (src_elem) {
    case SCR_BYTES_U8:
    case SCR_BYTES_U8C: {
      typedef uint8_t src_type;
      SCR_INTEGER_DESTS;
    }
    case SCR_BYTES_I8: {
      typedef int8_t src_type;
      SCR_INTEGER_DESTS;
    }
    case SCR_BYTES_U16: {
      typedef uint16_t src_type;
      SCR_INTEGER_DESTS;
    }
    case SCR_BYTES_I16: {
      typedef int16_t src_type;
      SCR_INTEGER_DESTS;
    }
    case SCR_BYTES_U32: {
      typedef uint32_t src_type;
      SCR_INTEGER_DESTS;
    }
    case SCR_BYTES_I32: {
      typedef int32_t src_type;
      SCR_INTEGER_DESTS;
    }
    case SCR_BYTES_F16: {
      typedef uint16_t src_type;
      SCR_NUMBER_DESTS(scr_f16_to_f64(value));
    }
    case SCR_BYTES_F32: {
      typedef float src_type;
      SCR_NUMBER_DESTS(value);
    }
    case SCR_BYTES_F64: {
      typedef double src_type;
      SCR_NUMBER_DESTS(value);
    }
#ifdef SCR_JS_OBJECT_MODEL
    case SCR_BYTES_I64:
    case SCR_BYTES_U64:
      scr_trap("scriptc: numeric conversion of a BigInt typed array\n");
#endif
  }
}
#undef SCR_NUMBER_DESTS
#undef SCR_INTEGER_DESTS
#undef SCR_DESTS
#undef SCR_CLAMP_INTEGER
#undef SCR_WRAP_INTEGER
#undef SCR_CLAMP_NUMBER
#undef SCR_WRAP_NUMBER
#undef SCR_PAIR

#ifdef SCR_JS_OBJECT_MODEL
/* set()/construction between a BigInt view and a numeric one. */
static void scr_bytes_content_type_error(void) {
  static const char msg[] = "Cannot mix BigInt and other types, use explicit conversions";
  scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
}
#endif

ScrBytes *scr_bytes_convert(ScrBytesElem elem, const ScrBytes *src) {
  SCR_BYTES_SNAPSHOT(src);
  if (elem == src->elem) return scr_bytes_copy(src);
#ifdef SCR_JS_OBJECT_MODEL
  /* A typed array's content type is part of its kind: a BigInt view and a
   * numeric view cannot convert into one another (Node's "Cannot mix BigInt
   * and other types"), while the two BigInt kinds copy the same 64 bits —
   * BigInt64Array reads them signed, BigUint64Array unsigned. */
  if (scr_bytes_elem_is_bigint(elem) || scr_bytes_elem_is_bigint(src->elem)) {
    if (!scr_bytes_elem_is_bigint(elem) || !scr_bytes_elem_is_bigint(src->elem)) {
      scr_bytes_content_type_error();
      return NULL;
    }
    ScrBytes *out = scr_bytes_alloc_private(elem, src->len);
    if (src->len) memcpy(out->data, src->data, src->len * 8);
    return out;
  }
#endif
  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. */
static size_t scr_bytes_rel_index(double i, size_t len) {
  if (i != i) return 0;
  double t = trunc(i);
  if (t < 0) t += (double)len;
  if (t < 0) return 0;
  if (t > (double)len) return len;
  return (size_t)t;
}

ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, "slice")) return scr_bytes_alloc_private(b->elem, 0);
#endif
  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_private(b->elem, count);
  scr_bytes_raw_in(b, out->data, b->data + s * esize, count * esize);
  return out;
}

ScrBytes *scr_bytes_copy_within(ScrBytes *b, double target, double start, double end) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, "copyWithin")) return scr_bytes_retain(b);
#endif
  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);
  size_t count = e > s ? e - s : 0;
  if (count > b->len - t) count = b->len - t;
  size_t width = scr_bytes_elem_size(b->elem);
  if (b->shared) {
    uint8_t *scratch = scr_bytes_scratch(count * width);
    scr_shared_load(scratch, b->data + s * width, count * width);
    scr_shared_store(b->data + t * width, scratch, count * width);
    free(scratch);
  } else memmove(b->data + t * width, b->data + s * width, count * width);
  return scr_bytes_retain(b);
}

/* TypedArray.prototype.fill on non-u8 receivers: per-ELEMENT fill with
 * the element write's JS-exact coercion (ToUint32/ToInt32 wrap, f32
 * 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) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, "fill")) return scr_bytes_retain(b);
#endif
#ifdef SCR_JS_OBJECT_MODEL
  /* A BigInt view's fill value is ToBigInt (scr_bytes_fill_bigint). */
  if (scr_bytes_elem_is_bigint(b->elem)) scr_trap("scriptc: numeric write to a BigInt typed array\n");
#endif
  size_t s = scr_bytes_rel_index(start, b->len);
  size_t e = scr_bytes_rel_index(end, b->len);
  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);
    size_t bytes = (e - s) * width;
    uint8_t *dst = b->shared ? scr_bytes_scratch(bytes) : b->data + 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;
      }
    }
    if (b->shared) {
      scr_shared_store(b->data + s * width, dst, bytes);
      free(dst);
    }
  }
  return scr_bytes_retain(b);
}

/* subarray(start, end): a same-elem VIEW over the receiver's storage —
 * TypedArray.prototype.subarray and Buffer's slice()/subarray() all alias
 * in JS (mutations are visible both ways; buffer-swap through a slice is
 * the canonical Node use). Chain depth stays exactly 1: a subarray of a
 * view retains the OWNER, offsets composed here (the DataView rule).
 * Relative indices clamp like slice; never throws. */
ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end) {
#ifdef SCR_JS_OBJECT_MODEL
  /* An invalid view answers a length-0 subarray with the TypeError pending
   * (its length is already 0, so the view below is empty and safe). An
   * omitted end arrives as +Infinity: a subarray of a length-tracking view
   * that runs to the buffer's end is itself length-tracking. */
  bool tracking = false;
  if (!scr_js_bytes_live(b)) scr_js_bytes_throw_detached("%TypedArray%.prototype.subarray");
  else tracking = isinf(end) && end > 0 && scr_js_bytes_tracking(b);
#endif
  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;
  ScrBytes *owner = b->backing ? b->backing : b;
  ScrBytes *v = malloc(sizeof(ScrBytes));
  if (!v) scr_bytes_oom();
  v->rc = 1;
  v->len = count;
  v->elem = b->elem;
  v->data = b->data + s * scr_bytes_elem_size(b->elem);
  v->backing = scr_bytes_retain(owner);
  v->is_buffer = b->is_buffer;
  v->is_data_view = false;
  v->external = false;
  v->untransferable = false;
  v->shared = owner->shared;
  v->properties = NULL;
  v->properties_traced = false;
  scr_bytes_set_held(v, 0);
#ifdef SCR_RC_AUDIT
  scr_live_bytes++;
#endif
#ifdef SCR_JS_OBJECT_MODEL
  scr_js_buffer_register(v, tracking);
#endif
  return v;
}

void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(dst, "set")) return;
  /* Node validates the source view before the offset: a detached source, or
   * a fixed-length one whose buffer shrank out from under it, throws. */
  if (!scr_js_bytes_live(src)) {
    scr_js_bytes_throw_detached("%TypedArray%.prototype.set");
    return;
  }
#endif
  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;
  }
#ifdef SCR_JS_OBJECT_MODEL
  /* A BigInt view takes only a BigInt source and the two BigInt kinds share
   * their element bits, so set() between them is the same-kind byte copy. */
  if (scr_bytes_elem_is_bigint(dst->elem) || scr_bytes_elem_is_bigint(src->elem)) {
    if (!scr_bytes_elem_is_bigint(dst->elem) || !scr_bytes_elem_is_bigint(src->elem)) {
      scr_bytes_content_type_error();
      return;
    }
    size_t bytes = src->len * 8;
    uint8_t *target = dst->data + (size_t)t * 8;
    if (!bytes) return;
    if (dst->shared || src->shared) {
      uint8_t *copy = scr_bytes_scratch(bytes);
      scr_bytes_raw_in(src, copy, src->data, bytes);
      scr_bytes_raw_out(dst, target, copy, bytes);
      free(copy);
    } else memmove(target, src->data, bytes);
    return;
  }
#endif
  size_t width = scr_bytes_elem_size(dst->elem);
  if (dst->shared || src->shared) {
    SCR_BYTES_SNAPSHOT(src);
    size_t bytes = src->len * width;
    uint8_t *target = dst->data + (size_t)t * width;
    if (dst->elem == src->elem) {
      /* The same element kind copies the source's bytes, NaN payloads
       * included. A source range that overlaps the target range (views of
       * one buffer, where no snapshot was taken) is copied out first. */
      uintptr_t to = (uintptr_t)target, from = (uintptr_t)src->data;
      bool overlap = to <= from ? from - to < bytes : to - from < bytes;
      if (!overlap) {
        scr_bytes_raw_out(dst, target, src->data, bytes);
        return;
      }
      uint8_t *copy = scr_bytes_scratch(bytes);
      scr_bytes_raw_in(src, copy, src->data, bytes);
      scr_bytes_raw_out(dst, target, copy, bytes);
      free(copy);
      return;
    }
    /* Convert a private copy of the source, then publish the target range. */
    uint8_t *scratch = scr_bytes_scratch(bytes);
    scr_bytes_convert_span(scratch, dst->elem, src->data, src->elem, src->len);
    scr_bytes_raw_out(dst, target, scratch, bytes);
    free(scratch);
    return;
  }
  uint8_t *target = dst->data + (size_t)t * width;
  if (dst->elem == src->elem) {
    memmove(target, src->data, src->len * width);
    return;
  }
  if (scr_bytes_copy_kinds(dst->elem, src->elem)) {
    /* A bit-compatible pair copies the source's bytes, so an overlapping
     * source range (views of one buffer) needs no snapshot. */
    memmove(target, src->data, src->len * width);
    return;
  }
  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
 * prototype/iterator keep a catchable refusal instead of losing hooks. */
static bool scr_bytes_source_refusal(void) {
  static const char msg[] = "typed-array conversion of an opaque reference is not supported yet";
  scr_throw_error_msg_code(SCR_ERR_ERROR, msg, sizeof msg - 1, "SC2020");
  return false;
}

static bool scr_bytes_source_length(const ScrDyn *value, double *length) {
  switch (value->kind) {
  case SCR_DYN_ARR: *length = (double)value->v.arr.len; return true;
  case SCR_DYN_STR: *length = scr_str_utf16_len(value->v.str); return true;
  case SCR_DYN_OBJ: {
    ScrDyn *v = scr_dyn_obj_read(value, "length", 6);
    if (!v) return false;
    double n;
    bool ok = scr_dyn_number_coerce_js(v, &n);
    scr_dyn_release(v);
    if (!ok) return false;
    *length = !(n > 0) ? 0 : fmin(floor(n), 9007199254740991.0);
    return true;
  }
  case SCR_DYN_NULL:
  case SCR_DYN_UNDEF: {
    static const char msg[] = "Cannot convert undefined or null to object";
    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
    return false;
  }
  case SCR_DYN_NUM:
  case SCR_DYN_BOOL: *length = 0; return true;
  default: return scr_bytes_source_refusal();
  }
}

static ScrDyn *scr_bytes_source_at(const ScrDyn *value, size_t i) {
  if (value->kind == SCR_DYN_ARR) return scr_dyn_arr_at(value, (double)i);
  if (value->kind == SCR_DYN_STR) {
    ScrStr *s = scr_str_char_at(value->v.str, (double)i);
    ScrDyn *out = scr_dyn_new_str(s);
    scr_str_release(s);
    return out;
  }
  char key[32];
  int n = snprintf(key, sizeof key, "%zu", i);
  return scr_dyn_obj_read(value, key, (size_t)n);
}

static bool scr_bytes_copy_array_like(ScrBytes *dst, const ScrDyn *src, size_t offset, size_t count) {
  for (size_t i = 0; i < count; i++) {
    ScrDyn *value = scr_bytes_source_at(src, i);
    if (!value) return false;
#ifdef SCR_JS_OBJECT_MODEL
    /* A BigInt view's element store is ToBigInt, not ToNumber. */
    if (scr_bytes_elem_is_bigint(dst->elem)) {
      bool ok = scr_bytes_set_bigint(dst, (double)(offset + i), value);
      scr_dyn_release(value);
      if (!ok) return false;
      continue;
    }
#endif
    double number;
    bool ok = scr_dyn_number_coerce_js(value, &number);
    scr_dyn_release(value);
    if (!ok) return false;
    scr_bytes_set(dst, (double)(offset + i), number);
  }
  return true;
}

ScrBytes *scr_bytes_from_dyn(ScrBytesElem elem, const ScrDyn *value, bool from) {
  if (from && (value->kind == SCR_DYN_NULL || value->kind == SCR_DYN_UNDEF)) {
    const char *msg = value->kind == SCR_DYN_NULL
        ? "object null is not iterable (cannot read property Symbol(Symbol.iterator))"
        : "undefined is not iterable (cannot read property Symbol(Symbol.iterator))";
    scr_throw_error_msg(SCR_ERR_TYPE, msg, strlen(msg));
    return NULL;
  }
  if (value->kind == SCR_DYN_TYPED_REF) {
    ScrDyn *view = scr_dyn_typed_ref_materialize(value);
    // Class snapshots omit prototypes, so do not interpret them as plain objects.
    ScrBytes *out = NULL;
    if (view->kind == SCR_DYN_BYTES || view->kind == SCR_DYN_ARR) out = scr_bytes_from_dyn(elem, view, from);
    else scr_bytes_source_refusal();
    scr_dyn_release(view);
    return out;
  }
  if (value->kind == SCR_DYN_BYTES) return scr_bytes_convert(elem, value->v.bytes);
  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 ||
                value->kind == SCR_DYN_SYMBOL || value->kind == SCR_DYN_BIGINT)) {
    /* ToIndex: a Symbol or BigInt length throws ToNumber's TypeError. */
    double number;
    if (!scr_dyn_number_coerce_js(value, &number)) return NULL;
    return scr_bytes_new(elem, number);
  }
  // Constructors drain array iterators before element coercion. Node's .from
  // fast path reads ordinary array elements during conversion instead. Strings
  // supplied to .from iterate by code point (set reads UTF-16 code units).
  // An object with a Symbol.iterator method iterates; others are array-like.
  ScrDyn *method = scr_dyn_iterator_method(value);
  if (method) {
    ScrDyn *items = scr_dyn_iterate_with(value, method);
    scr_dyn_release(method);
    if (!items) return NULL;
    ScrBytes *out = scr_bytes_new(elem, (double)items->v.arr.len);
    if (out && !scr_bytes_copy_array_like(out, items, 0, out->len)) {
      scr_bytes_release(out);
      out = NULL;
    }
    scr_dyn_release(items);
    return out;
  }
  if (scr_exc_pending()) return NULL;
  if ((!from && value->kind == SCR_DYN_ARR) || (from && value->kind == SCR_DYN_STR)) {
    ScrDyn *items = scr_dyn_iter_pack(value, NULL);
    if (!items) return NULL;
    ScrBytes *out = scr_bytes_new(elem, (double)items->v.arr.len);
    if (out && !scr_bytes_copy_array_like(out, items, 0, out->len)) {
      scr_bytes_release(out);
      out = NULL;
    }
    scr_dyn_release(items);
    return out;
  }
  double length;
  if (!scr_bytes_source_length(value, &length)) return NULL;
  if (length >= 9007199254740991.0 || length >= (double)(SIZE_MAX / scr_bytes_elem_size(elem))) {
    static const char msg[] = "Array buffer allocation failed";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return NULL;
  }
  ScrBytes *out = scr_bytes_new(elem, length);
  if (out && !scr_bytes_copy_array_like(out, value, 0, out->len)) {
    scr_bytes_release(out);
    return NULL;
  }
  return out;
}

void scr_bytes_set_from_dyn(ScrBytes *dst, const ScrDyn *src, double offset) {
  double t = isnan(offset) ? 0 : trunc(offset);
  if (!(t >= 0)) {
    static const char msg[] = "offset is out of bounds";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return;
  }
  if (src->kind == SCR_DYN_TYPED_REF) {
    ScrDyn *view = scr_dyn_typed_ref_materialize(src);
    if (view->kind == SCR_DYN_BYTES || view->kind == SCR_DYN_ARR) scr_bytes_set_from_dyn(dst, view, t);
    else scr_bytes_source_refusal();
    scr_dyn_release(view);
    return;
  }
  if (src->kind == SCR_DYN_BYTES) {
    scr_bytes_set_from(dst, src->v.bytes, t);
    return;
  }
  double length;
  if (!scr_bytes_source_length(src, &length)) return;
  if (t > (double)dst->len || length > (double)dst->len - t) {
    static const char msg[] = "offset is out of bounds";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return;
  }
  scr_bytes_copy_array_like(dst, src, (size_t)t, (size_t)length);
}

/* ── DataView (the ONE view kind — see the header contract) ────────────── */

double scr_bytes_byte_offset(const ScrBytes *b) {
  return b->backing ? (double)(size_t)(b->data - b->backing->data) : 0;
}

#ifdef SCR_JS_OBJECT_MODEL
/* Whether code that Node refuses on a detached or out-of-bounds view may
 * proceed (the registry answers; a program without it never detaches). */
bool scr_js_bytes_live(const ScrBytes *b) {
  const ScrJsBufferOps *ops = scr_js_buffer_ops;
  return !ops || !ops->view_invalid(b);
}

void scr_js_bytes_throw_detached(const char *label) {
  char message[160];
  int length = snprintf(message, sizeof message,
                        "Cannot perform %s on a detached ArrayBuffer", label);
  scr_throw_error_msg(SCR_ERR_TYPE, message, (size_t)length);
}

/* Whether `b`'s length follows its owner (a view built without a length
 * over a resizable buffer); a subarray that runs to the end of one stays
 * tracking. */
bool scr_js_bytes_tracking(const ScrBytes *b) {
  const ScrJsBufferOps *ops = scr_js_buffer_ops;
  return ops && ops->view_tracks(b);
}

/* The typed-array method guard: Node's message names the method. */
static bool scr_js_typed_method_ok(const ScrBytes *b, const char *method) {
  if (scr_js_bytes_live(b)) return true;
  char label[96];
  int length = snprintf(label, sizeof label, "%%TypedArray%%.prototype.%s", method);
  scr_js_bytes_throw_detached(label);
  (void)length;
  return false;
}

/* `.byteLength` / `.byteOffset` of a view whose owner may move: a DataView
 * throws when it is detached or out of bounds, a typed array answers 0. */
double scr_js_bytes_byte_length(const ScrBytes *b) {
  if (b->is_data_view && !scr_js_bytes_live(b)) {
    scr_js_bytes_throw_detached("get DataView.prototype.byteLength");
    return 0;
  }
  return scr_bytes_byte_len(b);
}

double scr_js_bytes_byte_offset(const ScrBytes *b) {
  if (b->is_data_view && !scr_js_bytes_live(b)) {
    scr_js_bytes_throw_detached("get DataView.prototype.byteOffset");
    return 0;
  }
  return scr_bytes_byte_offset(b);
}
#endif

ScrBytes *scr_dataview_new(ScrBytes *src, double byte_off, bool has_len, double byte_len) {
  /* `x.buffer` names the ONE buffer behind x — for a view src that is its
   * owner's storage, so indices stay buffer-relative exactly like JS. */
  ScrBytes *owner = src->backing ? src->backing : src;
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_bytes_live(owner)) {
    scr_js_bytes_throw_detached("DataView constructor");
    return NULL;
  }
#endif
  double buf_bytes = (double)(owner->len * scr_bytes_elem_size(owner->elem));
  /* ToIndex on the offset; every bad value takes Node's ONE message
   * (negative, > 2^53-1, Infinity, and past-the-end alike). */
  double off = (byte_off != byte_off) ? 0 : trunc(byte_off);
  if (!(off >= 0) || off > 9007199254740991.0 || off > buf_bytes) {
    char num[32];
    size_t numlen = scr_f64_to_str(off, num);
    char msg[96];
    int mlen = snprintf(msg, sizeof msg, "Start offset %.*s is outside the bounds of the buffer",
                        (int)numlen, num);
    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
    return NULL;
  }
  double len;
  if (has_len) {
    len = (byte_len != byte_len) ? 0 : trunc(byte_len);
    if (!(len >= 0) || len > 9007199254740991.0 || off + len > buf_bytes) {
      char num[32];
      size_t numlen = scr_f64_to_str(len, num);
      char msg[64];
      int mlen = snprintf(msg, sizeof msg, "Invalid DataView length %.*s", (int)numlen, num);
      scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
      return NULL;
    }
  } else {
    len = buf_bytes - off;
  }
  ScrBytes *v = malloc(sizeof(ScrBytes));
  if (!v) scr_bytes_oom();
  v->rc = 1;
  v->len = (size_t)len; /* elem u8 — len IS the byte length */
  v->elem = SCR_BYTES_U8;
  v->data = owner->data + (size_t)off;
  v->backing = scr_bytes_retain(owner);
  v->is_buffer = false;
  v->is_data_view = true;
  v->external = false;
  v->untransferable = false;
  v->shared = owner->shared;
  v->properties = NULL;
  v->properties_traced = false;
  scr_bytes_set_held(v, 0);
#ifdef SCR_RC_AUDIT
  scr_live_bytes++;
#endif
#ifdef SCR_JS_OBJECT_MODEL
  scr_js_buffer_register(v, !has_len);
#endif
  return v;
}

ScrBytes *scr_bytes_buffer_view(ScrBytes *src, ScrBytesElem elem,
                               double offset, bool has_len, double length) {
  ScrBytes *owner = src->backing ? src->backing : src;
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_bytes_live(owner)) {
    scr_js_bytes_throw_detached("Construct");
    return NULL;
  }
#endif
  size_t width = scr_bytes_elem_size(elem);
  double available = scr_bytes_byte_len(owner);
  double off = isnan(offset) ? 0 : trunc(offset);
  double count = isnan(length) ? 0 : trunc(length);
  if (off < 0 || off > 9007199254740991.0 || off > available ||
      fmod(off, (double)width) != 0 ||
      (has_len && (count < 0 || count > 9007199254740991.0 || count > (available - off) / (double)width)) ||
      (!has_len &&
#ifdef SCR_JS_OBJECT_MODEL
       !scr_js_owner_resizable(owner) &&
#endif
       fmod(available - off, (double)width) != 0)) {
    static const char msg[] = "Invalid typed array buffer range";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return NULL;
  }
  ScrBytes *view = scr_dataview_new(owner, off, true,
      has_len ? count * (double)width : available - off);
  if (!view) return NULL;
  view->elem = elem;
  view->len /= width;
  view->is_data_view = false;
  /* The initial registration (inside scr_dataview_new) recorded a byte
   * view; this one states the element kind and the tracking flag. */
#ifdef SCR_JS_OBJECT_MODEL
  scr_js_buffer_register(view, !has_len);
#endif
  return view;
}

#ifdef SCR_JS_OBJECT_MODEL
/* The getter/setter suffix Node's detached-view message names. */
static const char *scr_dataview_kind_name(ScrDataViewGet kind) {
  switch (kind) {
    case SCR_DV_U8: return "Uint8";
    case SCR_DV_I8: return "Int8";
    case SCR_DV_U16: return "Uint16";
    case SCR_DV_I16: return "Int16";
    case SCR_DV_U32: return "Uint32";
    case SCR_DV_I32: return "Int32";
    case SCR_DV_F32: return "Float32";
    case SCR_DV_F64: return "Float64";
    case SCR_DV_F16: return "Float16";
    case SCR_DV_BIGU64: return "BigUint64";
    case SCR_DV_BIGI64: return "BigInt64";
  }
  return "Uint8";
}

/* Node refuses a DataView getter or setter on a detached or out-of-bounds
 * view before it coerces the offset. */
static bool scr_dataview_live(const ScrBytes *b, ScrDataViewGet kind, bool set) {
  if (scr_js_bytes_live(b)) return true;
  char label[64];
  snprintf(label, sizeof label, "DataView.prototype.%s%s", set ? "set" : "get",
           scr_dataview_kind_name(kind));
  scr_js_bytes_throw_detached(label);
  return false;
}
#endif

static size_t scr_dataview_get_size(ScrDataViewGet kind) {
  switch (kind) {
    case SCR_DV_U8:
    case SCR_DV_I8:
      return 1;
    case SCR_DV_U16:
    case SCR_DV_I16:
    case SCR_DV_F16:
      return 2;
    case SCR_DV_U32:
    case SCR_DV_I32:
    case SCR_DV_F32:
      return 4;
    default:
      return 8;
  }
}

double scr_dataview_get(const ScrBytes *b, double byte_off, ScrDataViewGet kind, bool le) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_dataview_live(b, kind, false)) return 0;
#endif
  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). */
  double off = (byte_off != byte_off) ? 0 : trunc(byte_off);
  if (!(off >= 0) || off > 9007199254740991.0 || off + (double)width > (double)b->len) {
    static const char msg[] = "Offset is outside the bounds of the DataView";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return 0;
  }
  uint8_t p[8];
  scr_bytes_raw_in(b, p, b->data + (size_t)off, width);
  /* Assemble host-independently; le false is the JS big-endian default. */
  uint64_t u = 0;
  for (size_t i = 0; i < width; i++) {
    u |= (uint64_t)p[le ? i : width - 1 - i] << (8 * i);
  }
  switch (kind) {
    case SCR_DV_U8:
    case SCR_DV_U16:
    case SCR_DV_U32:
      return (double)u;
    case SCR_DV_I8:
      return (double)(int8_t)u;
    case SCR_DV_I16:
      return (double)(int16_t)u;
    case SCR_DV_I32:
      return (double)(int32_t)u;
    case SCR_DV_F16:
      return scr_f16_to_f64((uint16_t)u);
    case SCR_DV_F32: {
      uint32_t bits = (uint32_t)u;
      float f;
      memcpy(&f, &bits, 4);
      return (double)f;
    }
    case SCR_DV_F64: {
      double d;
      memcpy(&d, &u, 8);
      return d;
    }
    case SCR_DV_BIGU64:
      /* Number(view.getBigUint64(...)): u64 → double rounds to nearest
       * even — the same conversion Number(bigint) performs. */
      return (double)u;
    case SCR_DV_BIGI64:
      return (double)(int64_t)u;
  }
  return 0; /* unreachable */
}

void scr_dataview_set(ScrBytes *b, double byte_off, double value, ScrDataViewGet kind, bool le) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_dataview_live(b, kind, true)) return;
#endif
  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);
  if (!(off >= 0) || off > 9007199254740991.0 || off + (double)width > (double)b->len) {
    static const char msg[] = "Offset is outside the bounds of the DataView";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return;
  }
  /* Coerce to the stored bit pattern. The integer kinds share ToUint32's
   * 2^32 residue (signed/unsigned store the same bits; narrower widths
   * take the low bytes — 2^width divides 2^32, so the residues agree);
   * F32 rounds double→float to nearest even, exactly the spec. */
  uint64_t u = 0;
  switch (kind) {
    case SCR_DV_U8:
    case SCR_DV_I8:
    case SCR_DV_U16:
    case SCR_DV_I16:
    case SCR_DV_U32:
    case SCR_DV_I32:
      u = (uint64_t)scr_bytes_to_u32(value);
      break;
    case SCR_DV_F16:
      u = scr_f16_from_f64(value);
      break;
    case SCR_DV_F32: {
      float f = (float)value;
      uint32_t bits;
      memcpy(&bits, &f, 4);
      u = bits;
      break;
    }
    case SCR_DV_F64:
      memcpy(&u, &value, 8);
      break;
    default:
      return; /* BigInt setters use scr_dataview_write_u64_raw. */
  }
  /* Scatter host-independently; le false is the JS big-endian default. */
  uint8_t p[8];
  for (size_t i = 0; i < width; i++) {
    p[le ? i : width - 1 - i] = (uint8_t)(u >> (8 * i));
  }
  scr_bytes_raw_out(b, b->data + (size_t)off, p, width);
}

/* ── encodings (u8 only — the compiler routes only u8 receivers here) ──── */

static const char scr_hex_digits[] = "0123456789abcdef";

/* WHATWG UTF-8 decode with U+FFFD replacement per maximal invalid subpart
 * — what Buffer.prototype.toString("utf8") does. Output re-encodes as
 * (now valid) UTF-8: worst case 3 bytes per input byte. */
static void scr_td_invalid(const char *encoding) {
  char message[160];
  int n = snprintf(message, sizeof message, "The encoded data was not valid for encoding %s", encoding);
  scr_throw_error_msg_code(SCR_ERR_TYPE, message, (size_t)n, "ERR_ENCODING_INVALID_ENCODED_DATA");
}

/* 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) {
  return scr_bytes_ascii_span((const char *)data, len);
}

/* 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;
    }
  }
  *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;
}

static ScrStr *scr_bytes_decode_utf8(const uint8_t *in, size_t n) {
  return scr_bytes_decode_utf8_options(in, n, false);
}

ScrStr *scr_str_from_utf8_lossy(const uint8_t *bytes, size_t len) {
  return scr_bytes_decode_utf8(bytes, len);
}

/* The WHATWG decode above for bytes already read into string storage (file
 * contents): well-formed input, by far the common case, keeps its storage
 * and records whether it is all ASCII, so the read needs neither an
 * intermediate buffer nor a copy. Only malformed input is repaired into a
 * new string. Consumes the uniquely owned `raw`; returns +1. */
ScrStr *scr_str_adopt_utf8_lossy(ScrStr *raw, size_t ascii) {
  const uint8_t *in = (const uint8_t *)raw->data;
  size_t n = raw->len;
  if (ascii > n) ascii = n;
  ascii += scr_bytes_ascii_prefix(in + ascii, n - ascii);
  if (ascii == n) {
    scr_str_note_ascii(raw);
    return raw;
  }
  size_t next;
  size_t prefix = ascii + scr_bytes_utf8_prefix(in + ascii, n - ascii, &next);
  if (prefix == n) return raw;
  next += ascii;
  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';
  scr_str_release(raw);
  return s;
}

/* Whether a validated runtime encoding name decodes as UTF-8: Node's ASCII
 * case-insensitive "utf8" / "utf-8" spellings. */
bool scr_bytes_encoding_is_utf8(const ScrStr *enc) {
  if (enc->len != 4 && enc->len != 5) return false;
  char name[5];
  for (size_t i = 0; i < enc->len; i++) {
    char c = enc->data[i];
    name[i] = c >= 'A' && c <= 'Z' ? (char)(c + ('a' - 'A')) : c;
  }
  return enc->len == 4 ? memcmp(name, "utf8", 4) == 0 : memcmp(name, "utf-8", 5) == 0;
}

/* WHATWG TextDecoder.decode (utf-8, default options): the SAME maximal-
 * subpart replacement decode as toString("utf8") above, with one
 * 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_BYTES_SNAPSHOT(b);
  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) {
    in += 3;
    n -= 3;
  }
  return scr_bytes_decode_utf8_options(in, n, fatal);
}

ScrBytes *scr_bytes_buffer_source(const ScrDyn *value) {
  if (value->kind == SCR_DYN_TYPED_REF) {
    ScrDyn *materialized = scr_dyn_typed_ref_materialize(value);
    if (!materialized) return NULL;
    ScrBytes *result = scr_bytes_buffer_source(materialized);
    scr_dyn_release(materialized);
    return result;
  }
  if (value->kind == SCR_DYN_UNDEF) return scr_bytes_new(SCR_BYTES_U8, 0);
  if (value->kind == SCR_DYN_BYTES) {
    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_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.";
  scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "ERR_INVALID_ARG_TYPE");
  return NULL;
}

/* TextDecoder.decode's input: an ArrayBuffer, SharedArrayBuffer or view
 * as a u8 view of its bytes, and undefined as no bytes. Any other value
 * throws Node's ERR_INVALID_ARG_TYPE, whose text depends on the decoder:
 * the single-byte decoders and a utf-8 decode that continues or starts a
 * stream (`stream`, or bytes `state` holds from one) describe the value
 * they received; a whole utf-8 decode names the "list" argument; the
 * utf-16 and multi-byte decoders name "input". */
ScrBytes *scr_text_decoder_input(const ScrDyn *value, double encoding, const ScrDyn *state, bool stream) {
  if (value->kind == SCR_DYN_TYPED_REF) {
    ScrDyn *materialized = scr_dyn_typed_ref_materialize(value);
    if (!materialized) return NULL;
    ScrBytes *result = scr_text_decoder_input(materialized, encoding, state, stream);
    scr_dyn_release(materialized);
    return result;
  }
  if (value->kind == SCR_DYN_UNDEF || value->kind == SCR_DYN_BYTES || scr_buffer_storage_is(value))
    return scr_bytes_buffer_source(value);
  bool partial = stream;
  if (!partial && encoding < 0 && state->kind == SCR_DYN_OBJ) {
    ScrDyn *saved = scr_dyn_obj_read(state, "pending", 7);
    partial = saved->kind == SCR_DYN_BYTES && saved->v.bytes->len > 0;
    scr_dyn_release(saved);
  }
  /* Ids below 28 (through x-user-defined) and 36 (iso-8859-8-i) are the
   * single-byte decoders. */
  bool single_byte = encoding >= 0 && (encoding < 28 || encoding == 36);
  if (single_byte || (encoding < 0 && partial)) {
    scr_dyn_arg_type_fail("input", "an instance of ArrayBuffer or ArrayBufferView", value);
    return NULL;
  }
  static const char list[] = "The \"list\" argument must be an instance of SharedArrayBuffer, ArrayBuffer or ArrayBufferView.";
  static const char input[] = "The \"input\" argument must be an instance of SharedArrayBuffer, ArrayBuffer or ArrayBufferView.";
  if (encoding < 0) scr_throw_error_msg_code(SCR_ERR_TYPE, list, sizeof list - 1, "ERR_INVALID_ARG_TYPE");
  else scr_throw_error_msg_code(SCR_ERR_TYPE, input, sizeof input - 1, "ERR_INVALID_ARG_TYPE");
  return NULL;
}

ScrStr *scr_text_decode_buffer_source(const ScrDyn *value) {
  ScrBytes *view = scr_bytes_buffer_source(value);
  if (!view) return NULL;
  ScrStr *out = scr_text_decode(view);
  scr_bytes_release(view);
  return out;
}

ScrStr *scr_text_decode(const ScrBytes *b) {
  return scr_text_decode_options(b, false, false);
}

/* ── node:string_decoder, the utf8 StringDecoder ─────────────────────────
 * The decoder VALUE is a one-field record holding the pending partial
 * sequence PACKED into an f64 (count in the low byte, then up to three
 * raw bytes — at most 3 pend, so 32 bits): the compiler's interned
 * %strdec helpers thread it through these three pure functions. The
 * algorithm is Node's utf8 StringDecoder pinned by oracle (corpus 1474):
 * write() decodes pending+chunk minus the trailing INCOMPLETE sequence
 * (the decode above — invalid bytes become U+FFFD immediately, only a
 * truncated valid lead buffers), end() flushes the buffered partial as
 * its replacement chars. */

/* Encoding helpers defined beside toString below (the strdec steps share
 * them). */
static ScrStr *scr_bytes_encode_b64(const uint8_t *in, size_t n, bool url);
static ScrStr *scr_bytes_decode_utf16le(const uint8_t *in, size_t n);
static bool scr_enc_is(const ScrStr *enc, const char *name);

static size_t scr_strdec_unpack(double pending, uint8_t out[3]) {
  uint32_t p = (uint32_t)pending;
  size_t n = p & 0xff;
  if (n > 3) n = 3;
  out[0] = (uint8_t)((p >> 8) & 0xff);
  out[1] = (uint8_t)((p >> 16) & 0xff);
  out[2] = (uint8_t)((p >> 24) & 0xff);
  return n;
}

static double scr_strdec_pack(const uint8_t *bytes, size_t n) {
  uint32_t p = (uint32_t)n;
  if (n > 0) p |= (uint32_t)bytes[0] << 8;
  if (n > 1) p |= (uint32_t)bytes[1] << 16;
  if (n > 2) p |= (uint32_t)bytes[2] << 24;
  return (double)p;
}

/* Node's utf8CheckIncomplete over the COMBINED tail: the length (0-3) of
 * a trailing truncated-but-valid sequence prefix. Bare continuations and
 * invalid leads are NOT incomplete — they decode (to U+FFFD) now. */
static size_t scr_strdec_tail(const uint8_t *buf, size_t n) {
  size_t scan = n < 3 ? n : 3;
  for (size_t back = 1; back <= scan; back++) {
    uint8_t b = buf[n - back];
    if ((b & 0xc0) == 0x80) continue; /* continuation: keep walking */
    size_t need = 0;
    if ((b & 0xe0) == 0xc0) need = 2;
    else if ((b & 0xf0) == 0xe0) need = 3;
    else if ((b & 0xf8) == 0xf0) need = 4;
    else return 0; /* ascii or invalid lead: nothing buffers */
    return back < need ? back : 0; /* complete: decode now */
  }
  return 0; /* 3 continuations (or empty): invalid, decode now */
}

/* The combined pending+chunk buffer (malloc'd; *out_n set). */
static uint8_t *scr_strdec_combined(double pending, const ScrBytes *chunk, size_t *out_n) {
  uint8_t pend[3];
  size_t np = scr_strdec_unpack(pending, pend);
  size_t n = np + chunk->len;
  uint8_t *buf = malloc(n > 0 ? n : 1);
  if (!buf) scr_bytes_oom();
  memcpy(buf, pend, np);
  memcpy(buf + np, chunk->data, chunk->len);
  *out_n = n;
  return buf;
}

/* The utf16le step, Node's utf16Text/fillLast: a pending partial fills
 * first (an odd byte completes its unit; a held LEAD surrogate completes
 * its pair — 4 bytes total), then the rest holds back an odd tail byte
 * (with NO surrogate check — Node's own quirk emits a lead surrogate
 * before an odd boundary) or a trailing lead surrogate's 2 bytes. The
 * emitted bytes decode JOINTLY, so pair halves split across the fill
 * boundary reassemble exactly like Node's string concatenation. */
static ScrStr *scr_strdec_u16(double pending, const ScrBytes *chunk, bool want_str, double *out_hold) {
  uint8_t held[3];
  size_t k = scr_strdec_unpack(pending, held);
  const uint8_t *c = chunk->data;
  size_t cn = chunk->len;
  uint8_t complete[4];
  size_t comp_n = 0;
  if (k > 0) {
    size_t total = k == 1 ? 2 : 4; /* 1 = odd byte; 2 or 3 = lead-surrogate hold */
    size_t need = total - k;
    if (cn < need) {
      uint8_t nh[3];
      memcpy(nh, held, k);
      memcpy(nh + k, c, cn);
      *out_hold = scr_strdec_pack(nh, k + cn);
      return want_str ? scr_str_new("", 0) : NULL;
    }
    memcpy(complete, held, k);
    memcpy(complete + k, c, need);
    comp_n = total;
    c += need;
    cn -= need;
  }
  size_t keep = cn;
  if (cn % 2 == 1) {
    keep = cn - 1;
  } else if (cn >= 2) {
    uint32_t last = (uint32_t)c[cn - 2] | ((uint32_t)c[cn - 1] << 8);
    if (last >= 0xd800 && last <= 0xdbff) keep = cn - 2;
  }
  *out_hold = scr_strdec_pack(c + keep, cn - keep);
  if (!want_str) return NULL;
  size_t n = comp_n + keep;
  uint8_t *buf = malloc(n > 0 ? n : 1);
  if (!buf) scr_bytes_oom();
  memcpy(buf, complete, comp_n);
  memcpy(buf + comp_n, c, keep);
  ScrStr *s = scr_bytes_decode_utf16le(buf, n);
  free(buf);
  return s;
}

/* The base64/base64url step: complete 3-byte groups encode now, the
 * 1-2-byte remainder buffers (the combined walk is Node's fillLast+text
 * exactly — base64 of a concatenation splits at group boundaries). */
static ScrStr *scr_strdec_b64(double pending, const ScrBytes *chunk, bool url, bool want_str, double *out_hold) {
  size_t n;
  uint8_t *buf = scr_strdec_combined(pending, chunk, &n);
  size_t tail = n % 3;
  *out_hold = scr_strdec_pack(buf + (n - tail), tail);
  ScrStr *s = want_str ? scr_bytes_encode_b64(buf, n - tail, url) : NULL;
  free(buf);
  return s;
}

/* One dispatcher computes the decoded string (when wanted) and the new
 * packed pending for a write. latin1/ascii/hex are stateless (write IS
 * toString); utf8 keeps the oracle-pinned combined walk. */
static ScrStr *scr_strdec_step(const ScrStr *enc, double pending, const ScrBytes *chunk,
                               bool want_str, double *out_hold) {
  if (scr_enc_is(enc, "utf16le")) return scr_strdec_u16(pending, chunk, want_str, out_hold);
  if (scr_enc_is(enc, "base64")) return scr_strdec_b64(pending, chunk, false, want_str, out_hold);
  if (scr_enc_is(enc, "base64url")) return scr_strdec_b64(pending, chunk, true, want_str, out_hold);
  if (scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii") || scr_enc_is(enc, "hex")) {
    *out_hold = 0;
    return want_str ? scr_bytes_to_str(chunk, enc) : NULL;
  }
  size_t n;
  uint8_t *buf = scr_strdec_combined(pending, chunk, &n);
  size_t tail = scr_strdec_tail(buf, n);
  *out_hold = scr_strdec_pack(buf + (n - tail), tail);
  ScrStr *s = want_str ? scr_bytes_decode_utf8(buf, n - tail) : NULL;
  free(buf);
  return s;
}

/* decoder.write(chunk): the decoded complete prefix (+1). */
ScrStr *scr_strdec_write(const ScrStr *enc, double pending, const ScrBytes *chunk) {
  SCR_BYTES_SNAPSHOT(chunk);
  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_BYTES_SNAPSHOT(chunk);
  double hold = 0;
  scr_strdec_step(enc, pending, chunk, false, &hold);
  return hold;
}

/* decoder.end(): the buffered partial flushes — utf8's truncated sequence
 * becomes its replacement chars (the maximal-subpart rule), base64's
 * remainder encodes (padded; unpadded for base64url), utf16le's held
 * bytes decode as they stand (an odd byte drops; a held lead surrogate
 * stays lone), and the stateless encodings flush
 * nothing. +1. */
ScrStr *scr_strdec_end(const ScrStr *enc, double pending) {
  uint8_t pend[3];
  size_t np = scr_strdec_unpack(pending, pend);
  if (scr_enc_is(enc, "base64")) return scr_bytes_encode_b64(pend, np, false);
  if (scr_enc_is(enc, "base64url")) return scr_bytes_encode_b64(pend, np, true);
  if (scr_enc_is(enc, "utf16le")) return scr_bytes_decode_utf16le(pend, np);
  if (scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii") || scr_enc_is(enc, "hex")) {
    return scr_str_new("", 0);
  }
  return scr_bytes_decode_utf8(pend, np);
}

static void scr_bytes_to_str_bounds(const ScrBytes *b, double start, double end,
                                    size_t *s0_out, size_t *e0_out) {
  size_t len = b->len;
  /* Clamped before the conversion: NaN and values at or below 0 are 0,
   * values at or past the length (Infinity included) are the length. */
  size_t s0 = !(start > 0) ? 0 : start >= (double)len ? len : (size_t)start;
  size_t e0 = !(end > 0) ? 0 : end >= (double)len ? len : (size_t)end;
  if (e0 < s0) e0 = s0;
  *s0_out = s0;
  *e0_out = e0;
}

/* toString(enc, start, end): Node slices then decodes — start/end clamp
 * to [0, len] with start > end collapsing to empty and negative ends
 * clamping to 0 (Node's slice-then-decode; an OMITTED end never reaches
 * here — the emitter supplies the receiver's length for the 2-arg
 * 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_BYTES_SNAPSHOT(b);
  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 };
  return scr_bytes_to_str(&view, enc);
}

/* The base64 encoder behind toString("base64") and toString("base64url"):
 * the url flavor swaps the alphabet's last two chars for -_ and drops the
 * padding, exactly Node. */
static ScrStr *scr_bytes_encode_b64(const uint8_t *in, size_t n, bool url) {
  static const char std_abc[] =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  static const char url_abc[] =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
  const char *abc = url ? url_abc : std_abc;
  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 (tail == 2) v |= (unsigned)in[i + 1] << 8;
    out[o++] = abc[v >> 18];
    out[o++] = abc[(v >> 12) & 63];
    if (tail == 2) out[o++] = abc[(v >> 6) & 63];
    else if (!url) out[o++] = '=';
    if (!url) out[o++] = '=';
  }
  out[outlen] = '\0';
  scr_str_note_ascii(s);
  return s;
}

/* Append one code point as UTF-8 (the caller sized the buffer). */
static size_t scr_bytes_put_cp(char *out, size_t o, uint32_t cp) {
  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) {
    if (cp >= 0xd800 && cp <= 0xdfff) scr_wtf8_note(); /* a lone UTF-16 unit */
    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));
  }
  return o;
}

/* ── WHATWG/Node TextDecoder legacy encodings ──────────────────────────
 *
 * The frontend only calls this entry with a compile-time encoding id. The
 * lookup data is generated from the repository's pinned Node 24 oracle, so
 * the resulting binary has no ICU/iconv dependency and behaves identically
 * on Darwin, Linux, and Windows. UTF-8 keeps its older dedicated entry above:
 * programs using only the default decoder do not retain these legacy tables.
 */
#ifdef SCR_TEXT_DECODER_LEGACY

enum {
  SCR_TD_X_USER_DEFINED = SCR_TD_SINGLE_COUNT,
  SCR_TD_UTF16LE,
  SCR_TD_UTF16BE,
  SCR_TD_GB18030,
  SCR_TD_BIG5,
  SCR_TD_EUC_JP,
  SCR_TD_ISO_2022_JP,
  SCR_TD_SHIFT_JIS,
  SCR_TD_EUC_KR,
};

typedef struct {
  char *data;
  size_t len;
  bool failed;
} ScrTdOut;

static ScrTdOut scr_td_out_new(size_t input_len) {
  if (input_len > (SIZE_MAX - 8) / 3) scr_bytes_oom();
  ScrTdOut out = { malloc(input_len * 3 + 8), 0, false };
  if (!out.data) scr_bytes_oom();
  return out;
}

static void scr_td_put(ScrTdOut *out, uint32_t cp) {
  out->len = scr_bytes_put_cp(out->data, out->len, cp);
}

static void scr_td_error(ScrTdOut *out) {
  out->failed = true;
  scr_td_put(out, 0xfffd);
}

/* NULL when a fatal decoder met invalid data: the caller throws, naming
 * the decoder's encoding. */
static ScrStr *scr_td_finish(ScrTdOut *out, bool fatal) {
  if (fatal && out->failed) { free(out->data); return NULL; }
  ScrStr *str = scr_str_new(out->data, out->len);
  free(out->data);
  return str;
}

static ScrStr *scr_td_single_byte(const ScrBytes *b, unsigned encoding, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  for (size_t i = 0; i < b->len; i++) {
    uint8_t byte = b->data[i];
    uint32_t cp = byte < 0x80 ? byte : scr_td_single[encoding][byte - 0x80];
    if (cp == 0xfffd) scr_td_error(&out); else scr_td_put(&out, cp);
  }
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_x_user_defined(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  for (size_t i = 0; i < b->len; i++) {
    uint8_t byte = b->data[i];
    scr_td_put(&out, byte < 0x80 ? byte : 0xf780 + byte - 0x80);
  }
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_utf16(const ScrBytes *b, bool be, bool fatal, bool ignore_bom) {
  const uint8_t *in = b->data;
  size_t n = b->len;
  /* TextDecoder's BOM handling strips only the BOM matching the selected
   * endian decoder. The opposite BOM decodes to U+FFFE and remains. */
  if (!ignore_bom && n >= 2 && ((!be && in[0] == 0xff && in[1] == 0xfe) ||
                 (be && in[0] == 0xfe && in[1] == 0xff))) {
    in += 2;
    n -= 2;
  }
  ScrTdOut out = scr_td_out_new(n);
  size_t i = 0;
  while (i + 1 < n) {
    uint32_t cu = be ? ((uint32_t)in[i] << 8) | in[i + 1]
                     : (uint32_t)in[i] | ((uint32_t)in[i + 1] << 8);
    i += 2;
    if (cu >= 0xd800 && cu <= 0xdbff) {
      if (i + 1 < n) {
        uint32_t lo = be ? ((uint32_t)in[i] << 8) | in[i + 1]
                         : (uint32_t)in[i] | ((uint32_t)in[i + 1] << 8);
        if (lo >= 0xdc00 && lo <= 0xdfff) {
          i += 2;
          scr_td_put(&out, 0x10000 + ((cu - 0xd800) << 10) + (lo - 0xdc00));
          continue;
        }
      } else if (i < n) {
        /* ICU treats a lead surrogate plus one final byte as one malformed
         * UTF-16 subsequence. Consume that byte here so the odd-tail path
         * below does not emit a second replacement. */
        i++;
      }
      scr_td_error(&out);
      continue;
    }
    if (cu >= 0xdc00 && cu <= 0xdfff) scr_td_error(&out);
    else scr_td_put(&out, cu);
  }
  if (i < n) scr_td_error(&out); /* odd trailing byte */
  return scr_td_finish(&out, fatal);
}

static uint32_t scr_td_gb_range(uint32_t pointer) {
  size_t lo = 0;
  size_t hi = sizeof scr_td_gb_ranges / sizeof scr_td_gb_ranges[0];
  while (lo < hi) {
    size_t mid = lo + (hi - lo) / 2;
    const ScrTdGbRange *range = &scr_td_gb_ranges[mid];
    if (pointer < range->start) hi = mid;
    else if (pointer > range->end) lo = mid + 1;
    else return range->code_point + pointer - range->start;
  }
  return 0;
}

/* A tiny prepend stack models the Encoding Standard's I/O queue restore.
 * The gb18030 decoder is the only legacy decoder which can restore three
 * bytes after discovering a malformed four-byte sequence. */
static ScrStr *scr_td_gb18030_decode(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  uint8_t first = 0, second = 0, third = 0;
  uint8_t replay[3];
  size_t replay_len = 0;
  size_t i = 0;
  while (i < b->len || replay_len > 0) {
    uint8_t byte = replay_len ? replay[--replay_len] : b->data[i++];
    if (third) {
      uint32_t cp = 0;
      bool valid_fourth = byte >= 0x30 && byte <= 0x39;
      if (valid_fourth) {
        uint32_t pointer = (((uint32_t)(first - 0x81) * 10 + second - 0x30) * 126 +
                            third - 0x81) * 10 + byte - 0x30;
        cp = scr_td_gb_range(pointer);
      }
      uint8_t old_second = second, old_third = third;
      first = second = third = 0;
      if (cp) {
        scr_td_put(&out, cp);
      } else {
        scr_td_error(&out);
        /* A structurally valid four-byte sequence with an unmapped pointer
         * is consumed as one error. Only a malformed fourth byte restores
         * the preceding payload bytes to Node's input queue. */
        if (!valid_fourth) {
          replay[replay_len++] = byte;
          replay[replay_len++] = old_third;
          replay[replay_len++] = old_second;
        }
      }
      continue;
    }
    if (second) {
      if (byte >= 0x81 && byte <= 0xfe) {
        third = byte;
      } else {
        uint8_t old_second = second;
        first = second = 0;
        scr_td_error(&out);
        replay[replay_len++] = byte;
        replay[replay_len++] = old_second;
      }
      continue;
    }
    if (first) {
      if (byte >= 0x30 && byte <= 0x39) {
        second = byte;
        continue;
      }
      uint8_t lead = first;
      first = 0;
      uint32_t cp = 0;
      bool valid_trail = (byte >= 0x40 && byte <= 0x7e) ||
                         (byte >= 0x80 && byte <= 0xfe);
      if (valid_trail) {
        unsigned offset = byte < 0x7f ? 0x40 : 0x41;
        cp = scr_td_gb18030[(lead - 0x81) * 190 + byte - offset];
      }
      if (cp) scr_td_put(&out, cp);
      else {
        scr_td_error(&out);
        /* Non-ASCII invalid trails are consumed; ASCII is restored. */
        if (!valid_trail && byte < 0x80) replay[replay_len++] = byte;
      }
      continue;
    }
    if (byte < 0x80) scr_td_put(&out, byte);
    else if (byte == 0x80) scr_td_put(&out, 0x20ac);
    else if (byte >= 0x81 && byte <= 0xfe) first = byte;
    else scr_td_error(&out);
  }
  if (first || second || third) scr_td_error(&out);
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_big5_decode(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  uint8_t lead = 0;
  for (size_t i = 0; i < b->len; i++) {
    uint8_t byte = b->data[i];
    if (lead) {
      uint32_t cp = 0;
      if ((byte >= 0x40 && byte <= 0x7e) || (byte >= 0xa1 && byte <= 0xfe)) {
        unsigned offset = byte < 0x7f ? 0x40 : 0x62;
        cp = scr_td_big5[(lead - 0x81) * 157 + byte - offset];
      }
      lead = 0;
      if (cp) scr_td_put(&out, cp);
      else {
        scr_td_error(&out);
        /* 0xff has a standalone ICU/Node mapping and is restored too. */
        if (byte < 0x80 || byte == 0xff) i--;
      }
      continue;
    }
    if (byte < 0x80 || byte == 0x80) scr_td_put(&out, byte);
    else if (byte >= 0x81 && byte <= 0xfe) lead = byte;
    else if (byte == 0xff) scr_td_put(&out, 0xf8f8); /* ICU/Node mapping */
    else scr_td_error(&out);
  }
  if (lead) scr_td_error(&out);
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_euc_jp_decode(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  uint8_t lead = 0;
  bool jis0212 = false;
  for (size_t i = 0; i < b->len; i++) {
    uint8_t byte = b->data[i];
    if (lead == 0x8e && byte >= 0xa1 && byte <= 0xdf) {
      lead = 0;
      scr_td_put(&out, 0xff61 + byte - 0xa1);
      continue;
    }
    /* Node's pinned ICU EUC-JP converter exposes three NEC extensions just
     * above the half-width katakana trail range. */
    if (lead == 0x8e && byte >= 0xe0 && byte <= 0xe2) {
      static const uint16_t extensions[] = { 0x00a2, 0x00a3, 0x00ac };
      lead = 0;
      scr_td_put(&out, extensions[byte - 0xe0]);
      continue;
    }
    if (lead == 0x8f && byte >= 0xa1 && byte <= 0xfe) {
      jis0212 = true;
      lead = byte;
      continue;
    }
    if (lead) {
      uint8_t old_lead = lead;
      lead = 0;
      uint32_t cp = 0;
      bool valid_trail = old_lead >= 0xa1 && old_lead <= 0xfe &&
                         byte >= 0xa1 && byte <= 0xfe;
      if (valid_trail) {
        unsigned pointer = (old_lead - 0xa1) * 94 + byte - 0xa1;
        cp = jis0212 ? scr_td_jis0212[pointer] : scr_td_jis0208[pointer];
      }
      /* When the third byte of an 0x8f JIS-0212 sequence is malformed,
       * ICU reports the prefix and restores both following bytes. Model the
       * saved second byte as the next ordinary EUC-JP lead. */
      if (jis0212 && !valid_trail) {
        jis0212 = false;
        lead = old_lead;
        scr_td_error(&out);
        i--;
        continue;
      }
      jis0212 = false;
      if (cp) scr_td_put(&out, cp);
      else {
        scr_td_error(&out);
        /* C0/C1 bytes are restored; 0xa0 and 0xff are consumed with the
         * malformed sequence rather than producing a second error. The
         * 0x8e extension converter additionally restores 0xe5..0xfe. */
        if (byte < 0xa0 || (old_lead == 0x8e && byte >= 0xe5 && byte <= 0xfe)) i--;
      }
      continue;
    }
    if (byte < 0xa0 && byte != 0x8e && byte != 0x8f) scr_td_put(&out, byte);
    else if (byte == 0x8e || byte == 0x8f || (byte >= 0xa1 && byte <= 0xfe)) lead = byte;
    else scr_td_error(&out);
  }
  if (lead) scr_td_error(&out);
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_shift_jis_decode(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  uint8_t lead = 0;
  for (size_t i = 0; i < b->len; i++) {
    uint8_t byte = b->data[i];
    if (lead) {
      uint32_t cp = 0;
      bool valid_trail = (byte >= 0x40 && byte <= 0x7e) ||
                         (byte >= 0x80 && byte <= 0xfc);
      if (valid_trail) {
        unsigned offset = byte < 0x7f ? 0x40 : 0x41;
        unsigned lead_offset = lead < 0xa0 ? 0x81 : 0xc1;
        unsigned pointer = (lead - lead_offset) * 188 + byte - offset;
        cp = scr_td_shift_jis[pointer];
      }
      lead = 0;
      if (cp) scr_td_put(&out, cp);
      else {
        scr_td_error(&out);
        if (!valid_trail) i--;
      }
      continue;
    }
    /* ICU's ibm-943_P15A-2003 converter (Node's Shift_JIS backend) has
     * three historical C0/DEL swaps which its TextDecoder exposes. */
    if (byte == 0x1a) scr_td_put(&out, 0x1c);
    else if (byte == 0x1c) scr_td_put(&out, 0x7f);
    else if (byte == 0x7f) scr_td_put(&out, 0x1a);
    else if (byte < 0x80) scr_td_put(&out, byte);
    else if (byte >= 0xa1 && byte <= 0xdf) scr_td_put(&out, 0xff61 + byte - 0xa1);
    else if ((byte >= 0x81 && byte <= 0x9f) || (byte >= 0xe0 && byte <= 0xfc)) lead = byte;
    else scr_td_error(&out);
  }
  if (lead) scr_td_error(&out);
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_euc_kr_decode(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  uint8_t lead = 0;
  for (size_t i = 0; i < b->len; i++) {
    uint8_t byte = b->data[i];
    if (lead) {
      uint32_t cp = 0;
      if (lead >= 0xa1 && lead <= 0xfe && byte >= 0xa1 && byte <= 0xfe) {
        cp = scr_td_euc_kr[(lead - 0xa1) * 94 + byte - 0xa1];
      }
      lead = 0;
      if (cp) scr_td_put(&out, cp);
      else {
        scr_td_error(&out);
        if (byte < 0xa0) i--;
      }
      continue;
    }
    if (byte < 0xa0 && byte != 0x8e && byte != 0x8f) scr_td_put(&out, byte);
    else if (byte >= 0xa1 && byte <= 0xfe) lead = byte;
    else scr_td_error(&out);
  }
  if (lead) scr_td_error(&out);
  return scr_td_finish(&out, fatal);
}

enum ScrTdIsoState {
  SCR_TD_ISO_ASCII,
  SCR_TD_ISO_ROMAN,
  SCR_TD_ISO_KATAKANA,
  SCR_TD_ISO_LEAD,
  SCR_TD_ISO_TRAIL,
  SCR_TD_ISO_ESCAPE_START,
  SCR_TD_ISO_ESCAPE,
};

static ScrStr *scr_td_iso_2022_jp_decode(const ScrBytes *b, bool fatal) {
  ScrTdOut out = scr_td_out_new(b->len);
  enum ScrTdIsoState state = SCR_TD_ISO_ASCII;
  enum ScrTdIsoState output_state = SCR_TD_ISO_ASCII;
  uint8_t lead = 0;
  int replay = -1;
  bool output_flag = false;
  size_t i = 0;
  bool at_eof = false;
  while (!at_eof) {
    int item;
    if (replay >= 0) {
      item = replay;
      replay = -1;
    } else {
      item = i < b->len ? b->data[i++] : -1;
    }
    uint8_t byte = item < 0 ? 0 : (uint8_t)item;
    /* ICU treats CR/LF as line boundaries while a non-ASCII designation is
     * active: emit the separator and resume in ASCII. A pending JIS lead is
     * different (TRAIL state below) — there the line break completes an
     * ill-formed pair and remains a replacement, matching Node. */
    if (item >= 0 && (byte == 0x0a || byte == 0x0d) &&
        (state == SCR_TD_ISO_KATAKANA || state == SCR_TD_ISO_LEAD)) {
      output_flag = false;
      state = output_state = SCR_TD_ISO_ASCII;
      scr_td_put(&out, byte);
      continue;
    }
    switch (state) {
      case SCR_TD_ISO_ASCII:
      case SCR_TD_ISO_ROMAN:
      case SCR_TD_ISO_KATAKANA:
        if (item < 0) { at_eof = true; break; }
        if (byte == 0x1b) { state = SCR_TD_ISO_ESCAPE_START; break; }
        if (state == SCR_TD_ISO_ROMAN && byte == 0x5c) {
          output_flag = false; scr_td_put(&out, 0x00a5); break;
        }
        if (state == SCR_TD_ISO_ROMAN && byte == 0x7e) {
          output_flag = false; scr_td_put(&out, 0x203e); break;
        }
        if (state == SCR_TD_ISO_KATAKANA && byte >= 0x21 && byte <= 0x5f) {
          output_flag = false; scr_td_put(&out, 0xff61 + byte - 0x21); break;
        }
        if (state != SCR_TD_ISO_KATAKANA && byte < 0x80 && byte != 0x0e && byte != 0x0f) {
          output_flag = false; scr_td_put(&out, byte); break;
        }
        output_flag = false; scr_td_error(&out); break;

      case SCR_TD_ISO_LEAD:
        if (item < 0) { at_eof = true; break; }
        if (byte == 0x1b) { state = SCR_TD_ISO_ESCAPE_START; break; }
        if (byte >= 0x21 && byte <= 0x7e) {
          output_flag = false; lead = byte; state = SCR_TD_ISO_TRAIL; break;
        }
        /* ICU's fixed-width JIS converter folds two adjacent non-starter
         * bytes into one malformed subsequence. A valid lead, ESC, and the
         * SO/SI controls begin their own item and must remain queued; CR/LF
         * following an invalid byte is payload here rather than the line
         * reset handled above. */
        if (byte != 0x0e && byte != 0x0f && i < b->len) {
          uint8_t next = b->data[i];
          bool starts_item = next == 0x0e || next == 0x0f || next == 0x1b ||
                             (next >= 0x21 && next <= 0x7e);
          if (!starts_item) i++;
        }
        output_flag = false; scr_td_error(&out); break;

      case SCR_TD_ISO_TRAIL:
        if (item < 0) { state = SCR_TD_ISO_LEAD; scr_td_error(&out); at_eof = true; break; }
        if (byte == 0x1b) { state = SCR_TD_ISO_ESCAPE_START; scr_td_error(&out); break; }
        state = SCR_TD_ISO_LEAD;
        if (byte >= 0x21 && byte <= 0x7e) {
          uint32_t cp = scr_td_jis0208[(lead - 0x21) * 94 + byte - 0x21];
          if (cp) scr_td_put(&out, cp); else scr_td_error(&out);
        } else {
          scr_td_error(&out);
          /* SO/SI are standalone illegal items in ICU's JIS state rather
           * than trails consumed with the pending lead. Replay them so they
           * each contribute their own replacement. */
          if (byte == 0x0e || byte == 0x0f) i--;
        }
        break;

      case SCR_TD_ISO_ESCAPE_START:
        if (item >= 0 && (byte == 0x24 || byte == 0x25 || byte == 0x26 ||
                          byte == 0x28 || byte == 0x2e)) {
          lead = byte; state = SCR_TD_ISO_ESCAPE; break;
        }
        /* ICU recognizes ESC O as a complete but unsupported single-shift
         * escape, consuming the O with the replacement. */
        if (item >= 0 && byte == 0x4f) {
          output_flag = false; state = output_state; scr_td_error(&out); break;
        }
        if (item >= 0) i--;
        output_flag = false; state = output_state; scr_td_error(&out);
        if (item < 0) at_eof = true;
        break;

      case SCR_TD_ISO_ESCAPE: {
        enum ScrTdIsoState next = (enum ScrTdIsoState)-1;
        if (item >= 0 && lead == 0x28 && byte == 0x42) next = SCR_TD_ISO_ASCII;
        else if (item >= 0 && lead == 0x28 && (byte == 0x48 || byte == 0x4a)) next = SCR_TD_ISO_ROMAN;
        else if (item >= 0 && lead == 0x28 && byte == 0x49) next = SCR_TD_ISO_KATAKANA;
        else if (item >= 0 && lead == 0x24 && (byte == 0x40 || byte == 0x42)) next = SCR_TD_ISO_LEAD;
        if ((int)next >= 0) {
          state = output_state = next;
          bool repeated = output_flag;
          output_flag = !repeated;
          if (repeated) scr_td_error(&out);
          break;
        }
        /* Some ICU designation families need one more final byte. A known
         * final consumes the whole four-byte escape as one error; an unknown
         * final restores both payload bytes and leaves that final queued. */
        bool extended_prefix =
          (lead == 0x24 && (byte == 0x28 || byte == 0x29 || byte == 0x2a || byte == 0x2b)) ||
          (lead == 0x25 && byte == 0x2f);
        if (extended_prefix) {
          if (i == b->len) {
            output_flag = false; state = output_state; scr_td_error(&out);
            break;
          }
          uint8_t final = b->data[i];
          bool known_final =
            (lead == 0x24 && byte == 0x28 &&
              ((final >= 0x40 && final <= 0x45) || (final >= 0x47 && final <= 0x4d))) ||
            (lead == 0x24 && byte == 0x29 &&
              (final == 0x41 || final == 0x43 || final == 0x45 || final == 0x47)) ||
            (lead == 0x24 && byte == 0x2a && final == 0x48) ||
            (lead == 0x24 && byte == 0x2b && final >= 0x49 && final <= 0x4d) ||
            (lead == 0x25 && byte == 0x2f &&
              ((final >= 0x40 && final <= 0x41) || (final >= 0x43 && final <= 0x46)));
          if (known_final) {
            i++;
            output_flag = false; state = output_state; scr_td_error(&out);
            break;
          }
        }
        /* ICU consumes the complete unsupported designations it recognizes,
         * while other malformed payloads are restored to the input queue. */
        bool consume_error =
          (lead == 0x24 && byte == 0x41) ||
          (lead == 0x28 && ((byte >= 0x40 && byte <= 0x47) || byte == 0x4b || byte == 0x52)) ||
          (lead == 0x25 && byte == 0x42) ||
          (lead == 0x2e && (byte == 0x41 || byte == 0x46));
        if (item >= 0 && lead == 0x26 && byte == 0x40) {
          state = output_state = SCR_TD_ISO_LEAD;
          bool repeated = output_flag;
          output_flag = !repeated;
          if (repeated) scr_td_error(&out);
          break;
        }
        if (item < 0 || consume_error) {
          output_flag = false; state = output_state; scr_td_error(&out);
          if (item < 0) at_eof = true;
          break;
        }
        i--;
        /* The first escape payload byte is restored before the current
         * byte. Replay it through the full prior state machine: in JIS
         * mode it can become the lead paired with the current byte. */
        replay = lead;
        output_flag = false; state = output_state; scr_td_error(&out);
        break;
      }
    }
  }
  return scr_td_finish(&out, fatal);
}

static ScrStr *scr_td_legacy_decode(const ScrBytes *b, unsigned encoding, bool fatal, bool ignore_bom) {
  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);
    case SCR_TD_UTF16LE: return scr_td_utf16(b, false, fatal, ignore_bom);
    case SCR_TD_UTF16BE: return scr_td_utf16(b, true, fatal, ignore_bom);
    case SCR_TD_GB18030: return scr_td_gb18030_decode(b, fatal);
    case SCR_TD_BIG5: return scr_td_big5_decode(b, fatal);
    case SCR_TD_EUC_JP: return scr_td_euc_jp_decode(b, fatal);
    case SCR_TD_ISO_2022_JP: return scr_td_iso_2022_jp_decode(b, fatal);
    case SCR_TD_SHIFT_JIS: return scr_td_shift_jis_decode(b, fatal);
    case SCR_TD_EUC_KR: return scr_td_euc_kr_decode(b, fatal);
    default: return scr_str_new("", 0); /* compiler invariant */
  }
}

/* A fatal decoder's invalid data throws Node's TypeError, which names the
 * decoder's encoding (iso-8859-8-i and gbk keep their own names). */
ScrStr *scr_text_decode_legacy_options(const ScrBytes *b, double encoding_value, bool fatal, bool ignore_bom) {
  SCR_BYTES_SNAPSHOT(b);
  ScrStr *result = scr_td_legacy_decode(b, (unsigned)encoding_value, fatal, ignore_bom);
  if (!result) scr_td_invalid(scr_td_encoding_name(encoding_value));
  return result;
}
ScrStr *scr_text_decode_legacy(const ScrBytes *b, double encoding_value) {
  return scr_text_decode_legacy_options(b, encoding_value, false, false);
}
#endif /* SCR_TEXT_DECODER_LEGACY */

/* Streaming decoders retain only an incomplete character and whether the
 * initial BOM has been handled. The state object belongs to the codec's
 * private record, so aliases and closure captures share the same decoder. */
static size_t scr_td_utf8_tail(const uint8_t *bytes, size_t n) {
  size_t tail = scr_strdec_tail(bytes, n);
  if (!tail) return 0;
  uint8_t lead = bytes[n - tail];
  if (lead < 0xc2 || lead > 0xf4) return 0;
  if (tail > 1) {
    uint8_t second = bytes[n - tail + 1];
    if ((lead == 0xe0 && second < 0xa0) || (lead == 0xed && second > 0x9f) ||
        (lead == 0xf0 && second < 0x90) || (lead == 0xf4 && second > 0x8f)) return 0;
  }
  return tail;
}

ScrStr *scr_text_decode_stream(ScrDyn *state, const ScrBytes *input,
    double encoding, bool fatal, bool ignore_bom, bool stream) {
  SCR_BYTES_SNAPSHOT(input);
  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();
  ScrBytes *combined = scr_bytes_new(SCR_BYTES_U8, (double)(pending + input->len));
  if (pending) memcpy(combined->data, saved->v.bytes->data, pending);
  if (input->len) memcpy(combined->data + pending, input->data, input->len);
  scr_dyn_release(saved);
  ScrDyn *bom = scr_dyn_obj_read(state, "bom", 3);
  bool seen_bom = scr_dyn_truthy(bom);
  scr_dyn_release(bom);
  size_t hold = stream && encoding < 0 ? scr_td_utf8_tail(combined->data, combined->len) : 0;
#ifdef SCR_TEXT_DECODER_LEGACY
  if (stream && ((unsigned)encoding == SCR_TD_UTF16LE || (unsigned)encoding == SCR_TD_UTF16BE)) {
    size_t complete = combined->len & ~(size_t)1;
    hold = combined->len - complete;
    if (complete >= 2) {
      const uint8_t *last = combined->data + complete - 2;
      uint16_t unit = (unsigned)encoding == SCR_TD_UTF16BE
        ? ((uint16_t)last[0] << 8) | last[1] : last[0] | ((uint16_t)last[1] << 8);
      if (unit >= 0xd800 && unit <= 0xdbff) hold += 2;
    }
  }
  if (stream && encoding >= SCR_TD_GB18030) {
    scr_bytes_release(combined);
    static const char message[] = "Streaming TextDecoder for this legacy encoding has no native lowering";
    scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
    return NULL;
  }
#endif
  size_t complete = combined->len - hold;
  ScrBytes *tail = scr_bytes_new(SCR_BYTES_U8, (double)hold);
  if (hold) memcpy(tail->data, combined->data + complete, hold);
  scr_dyn_obj_set(state, "pending", 7, scr_dyn_new_bytes(tail));
  scr_bytes_release(tail);
  scr_dyn_obj_set(state, "bom", 3, scr_dyn_new_bool(stream && (seen_bom || complete > 0)));
  combined->len = complete;
  ScrStr *result;
  if (encoding < 0) result = scr_text_decode_options(combined, fatal, ignore_bom || seen_bom);
#ifdef SCR_TEXT_DECODER_LEGACY
  else result = scr_text_decode_legacy_options(combined, encoding, fatal, ignore_bom || seen_bom);
#else
  else { result = NULL; scr_trap("legacy TextDecoder requires its runtime pack variant"); }
#endif
  scr_bytes_release(combined);
  return result;
}

/* Decode the next code point from the n bytes of an ScrStr's storage.
 * Storage is WTF-8, except where raw outside bytes become a string
 * unchecked (HTTP header values). A byte that does not start a complete,
 * well-formed sequence stands for U+0000..U+00FF, as each byte of such a
 * header does in Node, and advances by one; nothing is read past n. */
static uint32_t scr_bytes_next_cp(const uint8_t *in, size_t n, size_t *ip) {
  size_t i = *ip;
  uint8_t b = in[i];
  *ip = i + 1;
  if (b < 0x80) return b;
  size_t len = b >= 0xc2 && b <= 0xdf ? 2 : b >= 0xe0 && b <= 0xef ? 3 : b >= 0xf0 && b <= 0xf4 ? 4 : 0;
  if (len == 0 || n - i < len) return b;
  uint8_t lo = b == 0xe0 ? 0xa0 : b == 0xf0 ? 0x90 : 0x80;
  uint8_t hi = b == 0xf4 ? 0x8f : 0xbf;
  if (in[i + 1] < lo || in[i + 1] > hi) return b;
  for (size_t k = 2; k < len; k++)
    if ((in[i + k] & 0xc0) != 0x80) return b;
  uint32_t cp = b & (0x7f >> len);
  for (size_t k = 1; k < len; k++) cp = (cp << 6) | (in[i + k] & 0x3f);
  *ip = i + len;
  return cp;
}

/* encodeInto consumes complete Unicode scalars while counting UTF-16 units.
 * Borrow the destination so writes through a subarray retain their aliasing.
 * Both entry points share this walk: the checked-dynamic one below, and the
 * statically typed one the compiler emits for a string into a Uint8Array. */
static void scr_text_encode_into_core(const ScrStr *text, ScrBytes *dest, size_t *read, size_t *written) {
  size_t nread = 0, nwritten = 0;
  size_t limit = text->len < dest->len ? text->len : dest->len;
  while (nwritten < limit) {
    size_t ascii = scr_bytes_ascii_prefix((const uint8_t *)text->data + nwritten, limit - nwritten);
    nwritten += ascii;
    nread += ascii;
    if (nwritten == limit) break;
    size_t end = nwritten;
    uint32_t cp = scr_bytes_next_cp((const uint8_t *)text->data, text->len, &end);
    if (end > dest->len) break;
    nread += cp > 0xffff ? 2 : 1;
    nwritten = end;
  }
  if (nwritten) {
    uint8_t *out = dest->shared ? scr_bytes_scratch(nwritten) : dest->data;
    memcpy(out, text->data, nwritten);
    if (!text->ascii) scr_wtf8_to_utf8((char *)out, nwritten);
    if (dest->shared) {
      scr_shared_store(dest->data, out, nwritten);
      free(out);
    }
  }
  *read = nread;
  *written = nwritten;
}

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;
  }
  size_t read = 0, written = 0;
  scr_text_encode_into_core(source->v.str, destination->v.bytes, &read, &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;
}

/* The typed form: the call site's string and Uint8Array arrive as their own
 * representations, so nothing is boxed into a ScrDyn and the result goes
 * straight into the two slots the compiler allocated. */
void scr_text_encode_into_str(const ScrStr *text, ScrBytes *dest, double *read, double *written) {
  /* The compiler lowers this form only for a statically typed Uint8Array
   * destination; a DataView or a narrower element type is unreachable. */
  if (dest->elem != SCR_BYTES_U8 || dest->is_data_view)
    scr_trap("TextEncoder.encodeInto requires a Uint8Array destination");
  size_t nread = 0, nwritten = 0;
  scr_text_encode_into_core(text, dest, &nread, &nwritten);
  *read = (double)nread;
  *written = (double)nwritten;
}

static ScrBytes *scr_buffer_validation_input(const ScrDyn *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);
  return NULL;
}

static bool scr_buffer_utf8_valid(const uint8_t *data, size_t len) {
  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;
  ScrBytes *view = bytes;
  SCR_BYTES_SNAPSHOT(view);
  bool result = scr_bytes_ascii_prefix(view->data, view->len) == view->len;
  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;
  ScrBytes *view = bytes;
  SCR_BYTES_SNAPSHOT(view);
  bool result = scr_buffer_utf8_valid(view->data, view->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;
  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);
  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, text->len, &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;
}

/* toString("utf16le"): LE code-unit pairs (an odd tail byte drops, like
 * Node). Valid surrogate pairs combine into their code point; a LONE
 * surrogate stays a lone UTF-16 unit, as in Node. */
/* Consume one code point or unpaired surrogate. */
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;
}

/* Four units below 0x80 copy as four bytes (one word holds them), and
 * other units outside the surrogate range are written inline; surrogates
 * take scr_bytes_utf16le_cp. The string has one UTF-16 unit per input
 * unit, which is recorded so its length needs no walk. */
static ScrStr *scr_bytes_decode_utf16le(const uint8_t *in, size_t n) {
  size_t units = n / 2;
  if (units > SIZE_MAX / 3) scr_bytes_oom();
  ScrStr *s = scr_str_alloc_raw(0, units * 3);
  uint8_t *out = (uint8_t *)s->data;
  size_t o = 0, u = 0;
  while (u < units) {
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    if (units - u >= 4) {
      uint64_t w;
      memcpy(&w, in + u * 2, 8);
      if (!(w & UINT64_C(0xff80ff80ff80ff80))) {
        out[o] = (uint8_t)w;
        out[o + 1] = (uint8_t)(w >> 16);
        out[o + 2] = (uint8_t)(w >> 32);
        out[o + 3] = (uint8_t)(w >> 48);
        o += 4;
        u += 4;
        continue;
      }
    }
#endif
    uint32_t cu = (uint32_t)in[u * 2] | ((uint32_t)in[u * 2 + 1] << 8);
    if (cu >= 0x800 && (cu < 0xd800 || cu > 0xdfff)) {
      /* Three bytes in one four-byte store; the next write (or the
       * terminator) replaces the fourth. */
      uint8_t seq[4] = {(uint8_t)(0xe0 | (cu >> 12)), (uint8_t)(0x80 | ((cu >> 6) & 0x3f)),
                        (uint8_t)(0x80 | (cu & 0x3f)), 0};
      memcpy(out + o, seq, 4);
      o += 3;
      u++;
    } else if (cu < 0x80) {
      out[o++] = (uint8_t)cu;
      u++;
    } else if (cu < 0x800) {
      out[o] = (uint8_t)(0xc0 | (cu >> 6));
      out[o + 1] = (uint8_t)(0x80 | (cu & 0x3f));
      o += 2;
      u++;
    } else {
      o = scr_bytes_put_cp(s->data, o, scr_bytes_utf16le_cp(in, units, &u));
    }
  }
  s->len = o;
  s->data[o] = '\0';
  if (o == units) scr_str_note_ascii(s);
  else scr_str_note_utf16_len(s, units);
  return s;
}

/* The UTF-8 bytes of U+0000..U+00FF: the byte itself below 0x80 (the
 * second entry is overwritten by the next write), else a two-byte
 * sequence. */
static const uint8_t scr_latin1_utf8[256][2] = {
    {0x00, 0x00}, {0x01, 0x00}, {0x02, 0x00}, {0x03, 0x00}, {0x04, 0x00}, {0x05, 0x00}, {0x06, 0x00}, {0x07, 0x00},
    {0x08, 0x00}, {0x09, 0x00}, {0x0a, 0x00}, {0x0b, 0x00}, {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
    {0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00}, {0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00},
    {0x18, 0x00}, {0x19, 0x00}, {0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
    {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00}, {0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00},
    {0x28, 0x00}, {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00}, {0x2e, 0x00}, {0x2f, 0x00},
    {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
    {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0x00}, {0x3b, 0x00}, {0x3c, 0x00}, {0x3d, 0x00}, {0x3e, 0x00}, {0x3f, 0x00},
    {0x40, 0x00}, {0x41, 0x00}, {0x42, 0x00}, {0x43, 0x00}, {0x44, 0x00}, {0x45, 0x00}, {0x46, 0x00}, {0x47, 0x00},
    {0x48, 0x00}, {0x49, 0x00}, {0x4a, 0x00}, {0x4b, 0x00}, {0x4c, 0x00}, {0x4d, 0x00}, {0x4e, 0x00}, {0x4f, 0x00},
    {0x50, 0x00}, {0x51, 0x00}, {0x52, 0x00}, {0x53, 0x00}, {0x54, 0x00}, {0x55, 0x00}, {0x56, 0x00}, {0x57, 0x00},
    {0x58, 0x00}, {0x59, 0x00}, {0x5a, 0x00}, {0x5b, 0x00}, {0x5c, 0x00}, {0x5d, 0x00}, {0x5e, 0x00}, {0x5f, 0x00},
    {0x60, 0x00}, {0x61, 0x00}, {0x62, 0x00}, {0x63, 0x00}, {0x64, 0x00}, {0x65, 0x00}, {0x66, 0x00}, {0x67, 0x00},
    {0x68, 0x00}, {0x69, 0x00}, {0x6a, 0x00}, {0x6b, 0x00}, {0x6c, 0x00}, {0x6d, 0x00}, {0x6e, 0x00}, {0x6f, 0x00},
    {0x70, 0x00}, {0x71, 0x00}, {0x72, 0x00}, {0x73, 0x00}, {0x74, 0x00}, {0x75, 0x00}, {0x76, 0x00}, {0x77, 0x00},
    {0x78, 0x00}, {0x79, 0x00}, {0x7a, 0x00}, {0x7b, 0x00}, {0x7c, 0x00}, {0x7d, 0x00}, {0x7e, 0x00}, {0x7f, 0x00},
    {0xc2, 0x80}, {0xc2, 0x81}, {0xc2, 0x82}, {0xc2, 0x83}, {0xc2, 0x84}, {0xc2, 0x85}, {0xc2, 0x86}, {0xc2, 0x87},
    {0xc2, 0x88}, {0xc2, 0x89}, {0xc2, 0x8a}, {0xc2, 0x8b}, {0xc2, 0x8c}, {0xc2, 0x8d}, {0xc2, 0x8e}, {0xc2, 0x8f},
    {0xc2, 0x90}, {0xc2, 0x91}, {0xc2, 0x92}, {0xc2, 0x93}, {0xc2, 0x94}, {0xc2, 0x95}, {0xc2, 0x96}, {0xc2, 0x97},
    {0xc2, 0x98}, {0xc2, 0x99}, {0xc2, 0x9a}, {0xc2, 0x9b}, {0xc2, 0x9c}, {0xc2, 0x9d}, {0xc2, 0x9e}, {0xc2, 0x9f},
    {0xc2, 0xa0}, {0xc2, 0xa1}, {0xc2, 0xa2}, {0xc2, 0xa3}, {0xc2, 0xa4}, {0xc2, 0xa5}, {0xc2, 0xa6}, {0xc2, 0xa7},
    {0xc2, 0xa8}, {0xc2, 0xa9}, {0xc2, 0xaa}, {0xc2, 0xab}, {0xc2, 0xac}, {0xc2, 0xad}, {0xc2, 0xae}, {0xc2, 0xaf},
    {0xc2, 0xb0}, {0xc2, 0xb1}, {0xc2, 0xb2}, {0xc2, 0xb3}, {0xc2, 0xb4}, {0xc2, 0xb5}, {0xc2, 0xb6}, {0xc2, 0xb7},
    {0xc2, 0xb8}, {0xc2, 0xb9}, {0xc2, 0xba}, {0xc2, 0xbb}, {0xc2, 0xbc}, {0xc2, 0xbd}, {0xc2, 0xbe}, {0xc2, 0xbf},
    {0xc3, 0x80}, {0xc3, 0x81}, {0xc3, 0x82}, {0xc3, 0x83}, {0xc3, 0x84}, {0xc3, 0x85}, {0xc3, 0x86}, {0xc3, 0x87},
    {0xc3, 0x88}, {0xc3, 0x89}, {0xc3, 0x8a}, {0xc3, 0x8b}, {0xc3, 0x8c}, {0xc3, 0x8d}, {0xc3, 0x8e}, {0xc3, 0x8f},
    {0xc3, 0x90}, {0xc3, 0x91}, {0xc3, 0x92}, {0xc3, 0x93}, {0xc3, 0x94}, {0xc3, 0x95}, {0xc3, 0x96}, {0xc3, 0x97},
    {0xc3, 0x98}, {0xc3, 0x99}, {0xc3, 0x9a}, {0xc3, 0x9b}, {0xc3, 0x9c}, {0xc3, 0x9d}, {0xc3, 0x9e}, {0xc3, 0x9f},
    {0xc3, 0xa0}, {0xc3, 0xa1}, {0xc3, 0xa2}, {0xc3, 0xa3}, {0xc3, 0xa4}, {0xc3, 0xa5}, {0xc3, 0xa6}, {0xc3, 0xa7},
    {0xc3, 0xa8}, {0xc3, 0xa9}, {0xc3, 0xaa}, {0xc3, 0xab}, {0xc3, 0xac}, {0xc3, 0xad}, {0xc3, 0xae}, {0xc3, 0xaf},
    {0xc3, 0xb0}, {0xc3, 0xb1}, {0xc3, 0xb2}, {0xc3, 0xb3}, {0xc3, 0xb4}, {0xc3, 0xb5}, {0xc3, 0xb6}, {0xc3, 0xb7},
    {0xc3, 0xb8}, {0xc3, 0xb9}, {0xc3, 0xba}, {0xc3, 0xbb}, {0xc3, 0xbc}, {0xc3, 0xbd}, {0xc3, 0xbe}, {0xc3, 0xbf},
};

/* Each byte is U+00XX ("binary" normalizes here upstream): a byte below
 * 0x80 is one UTF-8 byte and any other byte is two. Eight bytes without a
 * high bit copy as one word; other bytes take their two table bytes and
 * advance by their length, without branches (the terminator slot holds
 * the last spare byte). */
/* The number of bytes from 0x80: eight per step, each step adding its
 * high bits into byte lanes that are summed every 255 steps. */
static size_t scr_bytes_count_high(const uint8_t *in, size_t n) {
  const uint64_t ones = UINT64_C(0x0101010101010101);
  const uint64_t pairs = UINT64_C(0x00ff00ff00ff00ff);
  size_t high = 0, i = 0;
  while (n - i >= 8) {
    size_t steps = (n - i) / 8 < 255 ? (n - i) / 8 : 255;
    uint64_t lanes = 0;
    for (size_t end = i + steps * 8; i < end; i += 8) {
      uint64_t w;
      memcpy(&w, in + i, 8);
      lanes += (w >> 7) & ones;
    }
    lanes = (lanes & pairs) + ((lanes >> 8) & pairs);
    high += (size_t)((lanes * UINT64_C(0x0001000100010001)) >> 48);
  }
  for (; i < n; i++) high += in[i] >> 7;
  return high;
}

static ScrStr *scr_bytes_latin1_text(const uint8_t *in, size_t n) {
  size_t high = scr_bytes_count_high(in, n);
  if (n > SIZE_MAX - high) scr_bytes_oom();
  ScrStr *s = scr_str_alloc_raw(n + high, n + high);
  uint8_t *out = (uint8_t *)s->data;
  if (high == 0) {
    memcpy(out, in, n);
    out[n] = '\0';
    scr_str_note_ascii(s);
    return s;
  }
  const uint64_t top = UINT64_C(0x8080808080808080);
  size_t i = 0, o = 0;
  while (n - i >= 8) {
    uint64_t w;
    memcpy(&w, in + i, 8);
    if (!(w & top)) {
      memcpy(out + o, &w, 8);
      i += 8;
      o += 8;
      continue;
    }
    for (size_t end = i + 8; i < end; i++) {
      memcpy(out + o, scr_latin1_utf8[in[i]], 2);
      o += 1 + (in[i] >> 7);
    }
  }
  for (; i < n; i++) {
    memcpy(out + o, scr_latin1_utf8[in[i]], 2);
    o += 1 + (in[i] >> 7);
  }
  out[o] = '\0';
  scr_str_note_utf16_len(s, n);
  return s;
}

ScrStr *scr_bytes_to_str(const ScrBytes *b, const ScrStr *enc) {
  SCR_BYTES_SNAPSHOT(b);
  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")) {
    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];
    }
    out[n * 2] = '\0';
    scr_str_note_ascii(s);
    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")) return scr_bytes_latin1_text(in, n);
  if (scr_enc_is(enc, "ascii")) {
    /* Node's ascii decode masks the high bit: byte & 0x7f. */
    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);
  /* utf8 (the compiler completes an omitted encoding to "utf8") */
  return scr_bytes_decode_utf8(in, n);
}

/* Buffer.toString with a runtime-valued encoding. Literal call sites fold
 * this same alias table in the frontend; variables arrive here, where Node
 * also accepts ASCII case variants and rejects unknown names catchably. */
static bool scr_enc_eq_ci(const ScrStr *raw, const char *name) {
  size_t n = strlen(name);
  if (raw->len != n) return false;
  for (size_t i = 0; i < n; i++) {
    char c = raw->data[i];
    if (c >= 'A' && c <= 'Z') c = (char)(c + ('a' - 'A'));
    if (c != name[i]) return false;
  }
  return true;
}

/* The canonical spelling of a Buffer encoding name in any ASCII case, or
 * NULL for a name Node's tables do not hold. */
static const char *scr_enc_alias(const ScrStr *raw) {
  static const struct { const char *from; const char *to; } map[] = {
    {"utf8", "utf8"}, {"utf-8", "utf8"}, {"hex", "hex"},
    {"base64", "base64"}, {"base64url", "base64url"},
    {"latin1", "latin1"}, {"binary", "latin1"}, {"ascii", "ascii"},
    {"utf16le", "utf16le"}, {"utf-16le", "utf16le"},
    {"ucs2", "utf16le"}, {"ucs-2", "utf16le"},
  };
  for (size_t i = 0; i < sizeof map / sizeof map[0]; i++) {
    if (scr_enc_eq_ci(raw, map[i].from)) return map[i].to;
  }
  return NULL;
}

ScrStr *scr_bytes_normalize_encoding(const ScrStr *raw) {
  const char *to = scr_enc_alias(raw);
  if (to) return scr_str_new(to, strlen(to));
  static const char prefix[] = "Unknown encoding: ";
  const size_t prefix_len = sizeof prefix - 1;
  if (raw->len > SIZE_MAX - prefix_len) scr_bytes_oom();
  const size_t msg_len = prefix_len + raw->len;
  char *msg = malloc(msg_len);
  if (!msg) scr_bytes_oom();
  memcpy(msg, prefix, prefix_len);
  memcpy(msg + prefix_len, raw->data, raw->len);
  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, msg_len,
                           "ERR_UNKNOWN_ENCODING");
  free(msg);
  return NULL;
}

/* Node's normalizeEncoding: an empty name reads as utf8; any other name
 * normalizes as getEncodingOps does, unknown names throwing
 * ERR_UNKNOWN_ENCODING. */
ScrStr *scr_bytes_normalize_encoding_empty_utf8(const ScrStr *raw) {
  if (raw->len == 0) return scr_str_new("utf8", 4);
  return scr_bytes_normalize_encoding(raw);
}

/* Buffer.byteLength's encoding read: an unknown name counts as utf8
 * instead of throwing. A NULL name — a call site whose encoding argument is
 * known not to be a string — is the same utf8 fallback. */
ScrStr *scr_bytes_normalize_encoding_or_utf8(const ScrStr *raw) {
  if (raw == NULL) return scr_str_new("utf8", 4);
  const char *to = scr_enc_alias(raw);
  if (to) return scr_str_new(to, strlen(to));
  return scr_str_new("utf8", 4);
}

/* new StringDecoder(encoding) with an encoding known only at run time:
 * Node's normalizeEncoding. undefined, null and "" are utf8; a Buffer
 * encoding name in any ASCII case answers its canonical name (+1); any
 * other string throws ERR_UNKNOWN_ENCODING (NULL). Encodings that may not
 * be strings go through scr_strdec_encoding_value (scr_inspect.c). */
ScrStr *scr_strdec_encoding(const ScrDyn *enc) {
  if (enc->kind == SCR_DYN_UNDEF || enc->kind == SCR_DYN_NULL) return scr_str_new("utf8", 4);
  if (enc->kind != SCR_DYN_STR) {
    static const char message[] = "new StringDecoder with an encoding that is not a string has no lowering";
    scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
    return NULL;
  }
  if (enc->v.str->len == 0) return scr_str_new("utf8", 4);
  return scr_bytes_normalize_encoding(enc->v.str);
}

ScrStr *scr_bytes_to_str_checked(const ScrBytes *b, const ScrStr *enc) {
  /* Node returns before resolving the encoding when there are no bytes
   * to decode, so even an unknown runtime name answers the empty string. */
  if (b->len == 0) return scr_str_new("", 0);
  ScrStr *normalized = scr_bytes_normalize_encoding(enc);
  if (!normalized) return NULL;
  ScrStr *out = scr_bytes_to_str(b, normalized);
  scr_str_release(normalized);
  return out;
}

ScrStr *scr_bytes_to_str_checked_range(const ScrBytes *b, const ScrStr *enc,
                                       double start, double end) {
  /* The range is selected before Node resolves the encoding. A clamped
   * empty window therefore answers "" even for an unknown name. */
  size_t s0, e0;
  scr_bytes_to_str_bounds(b, start, end, &s0, &e0);
  if (s0 == e0) return scr_str_new("", 0);
  ScrStr *normalized = scr_bytes_normalize_encoding(enc);
  if (!normalized) return NULL;
  ScrStr *out = scr_bytes_to_str_range(b, normalized, start, end);
  scr_str_release(normalized);
  return out;
}

/* Hex digit values, -1 for any other byte. */
static const int8_t scr_hex_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, -1, -1, -1, -1, -1,
   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
  -1, 10, 11, 12, 13, 14, 15, -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, 10, 11, 12, 13, 14, 15, -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, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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,
};

/* Where scr_bytes_encode_str writes: room bytes at `at` in the current pool
 * slab, or (at == NULL, or more than room needed) fresh private storage.
 * `cap` is how many bytes the caller takes. The latin1/ascii encoder writes
 * one byte per code unit and can stop early, so with cap < room it writes
 * into `at` and stops after cap bytes: a truncated write neither allocates
 * nor writes past the caller's room. Every other encoder needs room for its
 * whole output, and callers that take everything pass cap == SIZE_MAX. */
typedef struct {
  uint8_t *at;
  size_t room;
  size_t cap;
  ScrBytes header; /* the temporary view handed to the encoders */
} ScrBytesSink;

/* Conversion destinations are private until their initialized length is set.
 * General typed-array allocation must remain zero-filled. */
static ScrBytes *scr_bytes_conversion_storage_in(ScrBytesSink *sink, size_t capacity) {
  if (sink && sink->at && capacity <= sink->room) {
    sink->header = (ScrBytes){.rc = 1, .len = 0, .elem = SCR_BYTES_U8, .data = sink->at};
    return &sink->header;
  }
  uint8_t *data = malloc(capacity ? capacity : 1);
  if (!data) scr_bytes_oom();
  return scr_bytes_own(data, 0, SCR_BYTES_U8, capacity);
}

static ScrBytes *scr_bytes_conversion_storage(size_t capacity) {
  return scr_bytes_conversion_storage_in(NULL, capacity);
}

/* scr_b64_values, each value shifted into its place in a four-character
 * group's 24 bits; a character outside both alphabets sets bit 24. */
#define SCR_B64_VALUE(c)                                                       \
  ((c) >= 'A' && (c) <= 'Z'   ? (c) - 'A'                                     \
   : (c) >= 'a' && (c) <= 'z' ? (c) - 'a' + 26                                \
   : (c) >= '0' && (c) <= '9' ? (c) - '0' + 52                                \
   : (c) == '+' || (c) == '-' ? 62                                            \
   : (c) == '/' || (c) == '_' ? 63                                            \
                              : -1)
#define SCR_B64_AT(c, shift)                                                   \
  (SCR_B64_VALUE(c) < 0 ? UINT32_C(0x1000000) : (uint32_t)SCR_B64_VALUE(c) << (shift))
#define SCR_B64_4(c, s) SCR_B64_AT(c, s), SCR_B64_AT(c + 1, s), SCR_B64_AT(c + 2, s), SCR_B64_AT(c + 3, s)
#define SCR_B64_16(c, s) SCR_B64_4(c, s), SCR_B64_4(c + 4, s), SCR_B64_4(c + 8, s), SCR_B64_4(c + 12, s)
#define SCR_B64_64(c, s) SCR_B64_16(c, s), SCR_B64_16(c + 16, s), SCR_B64_16(c + 32, s), SCR_B64_16(c + 48, s)
#define SCR_B64_256(s) SCR_B64_64(0, s), SCR_B64_64(64, s), SCR_B64_64(128, s), SCR_B64_64(192, s)
static const uint32_t scr_b64_shifted[4][256] = {
    {SCR_B64_256(18)}, {SCR_B64_256(12)}, {SCR_B64_256(6)}, {SCR_B64_256(0)}};

/* One group's 24 bits as three bytes, in a four-byte store whose last byte
 * the next store overwrites (the destination holds two spare bytes). */
static inline void scr_b64_put_group(uint8_t *out, uint32_t bits) {
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  uint32_t word = __builtin_bswap32(bits << 8);
#else
  uint32_t word = bits << 8;
#endif
  memcpy(out, &word, 4);
}

static ScrBytes *scr_bytes_decode_b64(ScrBytesSink *sink, const uint8_t *in, size_t n) {
  ScrBytes *b = scr_bytes_conversion_storage_in(sink, n / 4 * 3 + 2);
  /* A local copy: a byte store could otherwise change b->data. */
  uint8_t *out = b->data;
  const uint32_t(*t)[256] = scr_b64_shifted;
  size_t i = 0, o = 0;
  unsigned acc = 0, have = 0;
  while (i < n) {
    /* Complete groups, two per step: each character's shifted value comes
     * from a table and one bit test covers all eight. The second store
     * ends at o + 6, within the destination while eight characters remain. */
    if (have == 0) {
      while (n - i >= 8) {
        uint32_t first = t[0][in[i]] | t[1][in[i + 1]] | t[2][in[i + 2]] | t[3][in[i + 3]];
        uint32_t second = t[0][in[i + 4]] | t[1][in[i + 5]] | t[2][in[i + 6]] | t[3][in[i + 7]];
        if ((first | second) & UINT32_C(0x1000000)) break;
        scr_b64_put_group(out + o, first);
        scr_b64_put_group(out + o + 3, second);
        o += 6;
        i += 8;
      }
      if (i == n) break; /* the groups ended the input */
    }
    /* 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;
        out[o++] = (uint8_t)(v >> 16);
        out[o++] = (uint8_t)(v >> 8);
        out[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) {
      out[o++] = (uint8_t)(acc >> 16);
      out[o++] = (uint8_t)(acc >> 8);
      out[o++] = (uint8_t)acc;
      acc = 0;
      have = 0;
    }
  }
  if (have == 2) out[o++] = (uint8_t)(acc >> 4);
  else if (have == 3) {
    out[o++] = (uint8_t)(acc >> 10);
    out[o++] = (uint8_t)(acc >> 2);
  }
  b->len = o;
  return b;
}

/* The latin1/ascii encoding of string storage, written to dst: the low byte
 * of each UTF-16 unit, in order, and the byte count is returned. `limited`
 * caps the write at `cap` bytes; it is a literal at each call site, so a
 * full encode carries no budget check in its loop.
 *
 * Node writes charCodeAt(i) & 0xFF for BOTH spellings — an astral code point
 * contributes its two surrogates' low bytes. The ASCII prefix copies.
 * Elsewhere eight ASCII bytes copy as one word. In eight bytes holding two
 * or more high bytes, all of them in two-byte sequences, every continuation
 * byte's output byte (the code point's low byte, from the continuation and
 * its lead) is computed in one word; each byte is then stored without
 * branches, a continuation replacing the byte its lead wrote. A lead in a
 * word's last byte stays pending: its continuation, if the next byte is one,
 * replaces it the same way. Any other byte decodes with scr_bytes_next_cp.
 *
 * Every byte written is one code unit's low byte, so a limited write stops
 * there (Node's truncation, which can split a surrogate pair). */
__attribute__((always_inline)) static inline size_t scr_latin1_into(uint8_t *dst,
                                                                    const uint8_t *in, size_t n,
                                                                    bool limited, size_t cap,
                                                                    bool ascii) {
  const uint64_t top = UINT64_C(0x8080808080808080);
  /* An ASCII prefix (all of an ASCII string) is its own encoding. A limited
   * write scans no further than its budget: the bytes past it are not
   * written, so the scan is bounded by the caller's room, not by n. */
  size_t scan = limited && cap < n ? cap : n;
  size_t o = ascii ? scan : scr_bytes_ascii_prefix(in, scan);
  if (limited && o > cap) o = cap;
  size_t i = o;
  memcpy(dst, in, o);
  /* in[i - 1] is a two-byte lead (0xC2..0xDF) the word path wrote as
   * dst[o - 1], and in[i] is not yet known to continue it. */
  bool pending = false;
  while (i < n) {
    if (n - i >= 8 && (!limited || cap - o >= 8)) {
      uint64_t w;
      memcpy(&w, in + i, 8);
      uint64_t high = w & top;
      if (!high) {
        memcpy(dst + o, &w, 8);
        i += 8;
        o += 8;
        pending = false;
        continue;
      }
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
      /* Byte k of the input is bits 8k..8k+7 of w; bit 8k+7 of w << j
       * is bit 7 - j of byte k. */
      uint64_t cont = w & ~(w << 1) & top;           /* 10xxxxxx */
      uint64_t lead = w & (w << 1) & ~(w << 2) & top; /* 110xxxxx */
      /* 0xC0 and 0xC1 (bits 4..1 clear) only begin overlong forms. */
      uint64_t overlong = lead & ~((w << 3) | (w << 4) | (w << 5) | (w << 6));
      if ((high & (high - 1)) && high == (cont | lead) && !overlong &&
          cont == ((lead << 8) | (pending ? 0x80u : 0u))) {
        uint64_t prev = (w << 8) | (pending ? in[i - 1] : 0u);
        uint64_t low = ((prev & UINT64_C(0x0303030303030303)) << 6) |
                       (w & UINT64_C(0x3f3f3f3f3f3f3f3f));
        uint64_t mask = (cont >> 7) * 0xff;
        uint64_t out = (w & ~mask) | (low & mask);
        for (unsigned k = 0; k < 8; k++) {
          o -= (size_t)(cont >> (8 * k + 7)) & 1;
          dst[o++] = (uint8_t)(out >> (8 * k));
        }
        i += 8;
        pending = (lead >> 63) != 0;
        continue;
      }
#endif
    }
    unsigned c = in[i];
    if (pending && c >> 6 == 2) {
      /* The rest of the two-byte sequence whose lead ended a word. */
      dst[o - 1] = (uint8_t)(((in[i - 1] & 3u) << 6) | (c & 0x3f));
      i++;
      pending = false;
      continue;
    }
    pending = false;
    if (limited && o >= cap) break;
    if (c < 0x80) {
      dst[o++] = (uint8_t)c;
      i++;
      continue;
    }
    uint32_t cp = scr_bytes_next_cp(in, n, &i);
    if (cp > 0xffff) {
      cp -= 0x10000;
      dst[o++] = (uint8_t)(0xd800 + (cp >> 10));
      if (limited && o >= cap) break; /* the pair's second unit is past the budget */
      dst[o++] = (uint8_t)(0xdc00 + (cp & 0x3ff));
    } else {
      dst[o++] = (uint8_t)cp;
    }
  }
  /* Never grows past n: multi-byte code points shrink. */
  return o;
}

/* Encodes s into sink's pool room when its upper bound fits there, else into
 * fresh private storage. The result's len is the bytes written; a pool
 * result is &sink->header, never released. */
static ScrBytes *scr_bytes_encode_str(ScrBytesSink *sink, const ScrStr *s, const ScrStr *enc) {
  const uint8_t *in = (const uint8_t *)s->data;
  size_t n = s->len;
  if (scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii")) {
    if (sink && sink->at && sink->cap < n) {
      /* The caller has room for `cap` bytes and takes exactly those: write
       * them in place, and stop, instead of encoding the rest. */
      sink->header = (ScrBytes){.rc = 1, .len = 0, .elem = SCR_BYTES_U8, .data = sink->at};
      sink->header.len = scr_latin1_into(sink->at, in, n, true, sink->cap, s->ascii);
      return &sink->header;
    }
    /* A local copy: a byte store could otherwise change b->data. */
    ScrBytes *b = scr_bytes_conversion_storage_in(sink, n);
    b->len = scr_latin1_into(b->data, in, n, false, 0, s->ascii);
    return b;
  }
  if (scr_enc_is(enc, "utf16le")) {
    if (n > SIZE_MAX / 2) scr_bytes_oom();
    ScrBytes *b = scr_bytes_conversion_storage_in(sink, n * 2);
    size_t o = 0, i = 0;
    while (i < n) {
      uint32_t cp = scr_bytes_next_cp(in, n, &i);
      if (cp > 0xffff) {
        cp -= 0x10000;
        uint32_t hi = 0xd800 + (cp >> 10), lo = 0xdc00 + (cp & 0x3ff);
        b->data[o++] = (uint8_t)hi;
        b->data[o++] = (uint8_t)(hi >> 8);
        b->data[o++] = (uint8_t)lo;
        b->data[o++] = (uint8_t)(lo >> 8);
      } else {
        b->data[o++] = (uint8_t)cp;
        b->data[o++] = (uint8_t)(cp >> 8);
      }
    }
    b->len = o;
    return b;
  }
  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_str_known_ascii(s) && scr_bytes_ascii_prefix(in, n) != n) {
      ScrStr *latin1 = scr_str_new("latin1", 6);
      narrowed = scr_bytes_encode_str(NULL, 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_in(sink, n / 2);
      uint8_t *dst = b->data;
      size_t pairs = n / 2, o = 0;
      for (; o < pairs; o++) {
        int hi = scr_hex_values[in[2 * o]], lo = scr_hex_values[in[2 * o + 1]];
        if ((hi | lo) < 0) break;
        dst[o] = (uint8_t)((hi << 4) | lo);
      }
      b->len = o;
    } else {
      b = scr_bytes_decode_b64(sink, in, n);
    }
    scr_bytes_release(narrowed);
    return b;
  }
  /* utf8: ScrStr storage IS the bytes, once lone surrogates become U+FFFD
   * (same length) */
  ScrBytes *b = scr_bytes_conversion_storage_in(sink, n);
  memcpy(b->data, in, n);
  if (!s->ascii) scr_wtf8_to_utf8((char *)b->data, n);
  b->len = n;
  return b;
}

ScrBytes *scr_bytes_from_str(const ScrStr *s, const ScrStr *enc) {
  return scr_bytes_encode_str(NULL, s, enc);
}

/* ── the Buffer pool ────────────────────────────────────────────────────
 * Node's lib/buffer.js: Buffer.poolSize starts at 64 KiB, and the first
 * slab exists from startup with that size. A pooled request (size <
 * Buffer.poolSize >>> 1) that does not fit the current slab's remainder
 * starts a new slab of Buffer.poolSize bytes; a slab created later uses the
 * value at that time. Views start at 8-byte aligned offsets. The pool holds
 * one reference to the current slab and each view another, so a slab is
 * freed once it is replaced and its last view is released (Node keeps a
 * slab alive the same way). */
#define SCR_BUFFER_POOL_DEFAULT 65536.0
size_t scr_num_received(double v, char out[48]);
static SCR_TL double scr_pool_setting = SCR_BUFFER_POOL_DEFAULT;
static SCR_TL ScrBytes *scr_pool_slab;
static SCR_TL size_t scr_pool_offset;
static SCR_TL bool scr_pool_started;
static SCR_TL bool scr_pool_registered; /* scr_buffer_pool_reset runs at context exit */

/* Buffer.poolSize >>> 1, kept with the setting. */
static SCR_TL size_t scr_pool_half = 32768;

SCR_TL void (*scr_buffer_pool_refresh_hook)(void) = NULL;
SCR_TL void (*scr_buffer_pool_publish_hook)(double size) = NULL;

double scr_buffer_pool_size(void) {
  if (scr_buffer_pool_refresh_hook) scr_buffer_pool_refresh_hook();
  return scr_pool_setting;
}

void scr_buffer_pool_apply(double size) {
  scr_pool_setting = size;
  double t = isfinite(size) ? fmod(trunc(size), 4294967296.0) : 0;
  if (t < 0) t += 4294967296.0;
  scr_pool_half = (size_t)((uint32_t)t >> 1);
}

void scr_buffer_set_pool_size(double size) {
  scr_buffer_pool_apply(size);
  if (scr_buffer_pool_publish_hook) scr_buffer_pool_publish_hook(size);
}

static size_t scr_pool_threshold(void) {
  if (scr_buffer_pool_refresh_hook) scr_buffer_pool_refresh_hook();
  return scr_pool_half;
}

/* Bytes left in the slab. Aligning can move the offset past the end of a
 * slab whose size is not a multiple of 8; nothing is left then. */
static size_t scr_pool_room(void) {
  if (!scr_pool_slab || scr_pool_offset >= scr_pool_slab->len) return 0;
  return scr_pool_slab->len - scr_pool_offset;
}

/* Replaces the slab with one of `size` bytes (Node's createPool). false
 * with a pending RangeError when size is not a valid typed array length. */
static bool scr_pool_create(double size) {
  ScrBytes *slab = scr_bytes_new(SCR_BYTES_U8, size);
  if (!slab) return false;
  slab->untransferable = true;
  if (!scr_pool_registered) {
    scr_atexit(scr_buffer_pool_reset);
    scr_pool_registered = true;
  }
  scr_bytes_release(scr_pool_slab);
  scr_pool_slab = slab;
  scr_pool_offset = 0;
  scr_pool_started = true;
  return true;
}

/* Ensures the current slab holds `reserve` more bytes (Node's `size >
 * poolSize - poolOffset` test before createPool). Node creates the first
 * slab at startup with the default size, so a request it holds goes there
 * even after Buffer.poolSize changed, and one it does not hold replaces it
 * with a slab of the current Buffer.poolSize. Callers write `reserve`
 * bytes at the pool offset, so the room is checked again after every new
 * slab: a pooled request is below Buffer.poolSize >>> 1, which a slab of
 * Buffer.poolSize bytes always holds, and anything else is an internal
 * error rather than a write past the slab. */
static bool scr_pool_reserve(size_t reserve) {
  if (scr_pool_started && reserve <= scr_pool_room()) return true;
  bool startup = !scr_pool_started && (double)reserve <= SCR_BUFFER_POOL_DEFAULT;
  if (!scr_pool_create(startup ? SCR_BUFFER_POOL_DEFAULT : scr_pool_setting)) return false;
  if (reserve > scr_pool_room()) scr_trap("scriptc: internal error: Buffer pool slab smaller than its reservation\n");
  return true;
}

/* A +1 Buffer view of `len` bytes at the pool offset, which then advances
 * past it to the next 8-byte boundary (Node's alignPool). */
static ScrBytes *scr_pool_take(size_t len) {
  ScrBytes *v = malloc(sizeof(ScrBytes));
  if (!v) scr_bytes_oom();
  v->rc = 1;
  v->len = len;
  v->elem = SCR_BYTES_U8;
  v->data = scr_pool_slab->data + scr_pool_offset;
  v->backing = scr_bytes_retain(scr_pool_slab);
  v->is_buffer = true;
  v->is_data_view = false;
  v->external = false;
  v->untransferable = false;
  v->shared = NULL;
  v->properties = NULL;
  v->properties_traced = false;
  scr_bytes_set_held(v, 0);
#ifdef SCR_RC_AUDIT
  scr_live_bytes++;
#endif
  scr_pool_offset += len;
  if (scr_pool_offset & 7) scr_pool_offset = (scr_pool_offset | 7) + 1;
  return v;
}

/* An empty Buffer (Node's new FastBuffer()): its own zero-length buffer. */
static ScrBytes *scr_buffer_empty(void) {
  ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, 0);
  b->is_buffer = true;
  return b;
}

/* validateNumber(size, 'size', 0, kMaxLength). */
static bool scr_buffer_check_size(double size) {
  if (size >= 0 && size <= 9007199254740991.0) return true;
  char recv[48], msg[160];
  scr_num_received(size, recv);
  int len = snprintf(msg, sizeof msg,
                     "The value of \"size\" is out of range. It must be >= 0 && <= 9007199254740991. "
                     "Received %s",
                     recv);
  scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
  return false;
}

ScrBytes *scr_buffer_alloc(double size) {
  if (!scr_buffer_check_size(size)) return NULL;
  /* Sizes past 2^31 keep scr_bytes_new's typed array length rules. */
  ScrBytes *b = size < 2147483648.0 ? scr_bytes_alloc(SCR_BYTES_U8, (size_t)size)
                                    : scr_bytes_new(SCR_BYTES_U8, size);
  if (b) b->is_buffer = true;
  return b;
}

ScrBytes *scr_buffer_alloc_unsafe_slow(double size) { return scr_buffer_alloc(size); }

/* Node's allocate(size) for a validated size. */
static ScrBytes *scr_buffer_allocate(double size) {
  if (!(size >= 1)) return scr_buffer_empty();
  if (size < (double)scr_pool_threshold()) {
    size_t n = (size_t)size;
    if (!scr_pool_reserve(n)) return NULL;
    return scr_pool_take(n);
  }
  return scr_buffer_alloc(size);
}

ScrBytes *scr_buffer_alloc_unsafe(double size) {
  if (!scr_buffer_check_size(size)) return NULL;
  return scr_buffer_allocate(size);
}

/* Node's fromArrayLike: the values of a typed array or number[] (ToUint8). */
ScrBytes *scr_buffer_from_bytes(const ScrBytes *src) {
  size_t n = src->len;
  if (n == 0) return scr_buffer_empty();
#ifdef SCR_JS_OBJECT_MODEL
  /* A BigInt view has no numeric elements to read: Buffer.from answers Node's
   * content-type error rather than zero elements. */
  if (scr_bytes_elem_is_bigint(src->elem)) {
    scr_bytes_content_type_error();
    return NULL;
  }
#endif
  if (n < scr_pool_threshold()) {
    if (!scr_pool_reserve(n)) return NULL;
    ScrBytes *v = scr_pool_take(n);
    if (src->elem == SCR_BYTES_U8 || src->elem == SCR_BYTES_U8C || src->elem == SCR_BYTES_I8) {
      scr_bytes_raw_in(src, v->data, src->data, n);
    } else {
      for (size_t i = 0; i < n; i++) v->data[i] = (uint8_t)scr_to_uint32(scr_bytes_get(src, (double)i));
    }
    return v;
  }
  ScrBytes *b = scr_bytes_convert(SCR_BYTES_U8, src);
  b->is_buffer = true;
  return b;
}

static void scr_bytes_fill_from_arr(uint8_t *out, ScrBytesElem elem, const ScrArr *arr);

ScrBytes *scr_buffer_from_arr(const ScrArr *arr) {
  size_t n = arr->len;
  if (n == 0) return scr_buffer_empty();
  if (n < scr_pool_threshold()) {
    /* Converting numbers runs no user code, so the values are written
     * straight into the slab. */
    if (!scr_pool_reserve(n)) return NULL;
    ScrBytes *v = scr_pool_take(n);
    scr_bytes_fill_from_arr(v->data, SCR_BYTES_U8, arr);
    return v;
  }
  ScrBytes *b = scr_bytes_from_arr(SCR_BYTES_U8, arr);
  b->is_buffer = true;
  return b;
}

double scr_bytes_byte_length_str(ScrStr *s, const ScrStr *enc);

/* Node's createFromString: an unpooled Buffer of the encoding's byte
 * length; when fewer bytes are written it views the start of that
 * ArrayBuffer. */
static ScrBytes *scr_buffer_from_str_unpooled(const ScrStr *s, const ScrStr *enc, size_t length) {
  ScrBytes *b = scr_bytes_encode_str(NULL, s, enc);
  b->is_buffer = true;
  if (b->len >= length) return b;
  /* The encoders' storage bound covers the byte length. */
  size_t actual = b->len;
  memset(b->data + actual, 0, length - actual);
  b->len = length;
  ScrBytes *view = scr_bytes_subarray(b, 0, (double)actual);
  scr_bytes_release(b);
  return view;
}

/* Node's fromString/fromStringFast for a normalized encoding name. */
ScrBytes *scr_buffer_from_str(const ScrStr *s, const ScrStr *enc) {
  if (s->len == 0) return scr_buffer_empty();
  size_t max = scr_pool_threshold();
  /* The UTF-16 length lies between len / 3 and len (each unit is one to
   * three stored bytes; an astral character's four bytes are two units).
   * Node's reservation is four bytes per unit; when four bytes per stored
   * byte already fits the threshold and the slab, the exact length cannot
   * change the outcome. */
  size_t units;
  if (s->ascii) {
    units = s->len;
  } else if (s->len < max / 4 && scr_pool_started && s->len * 4 <= scr_pool_room()) {
    units = s->len; /* an upper bound: reserve() succeeds without a new slab */
  } else {
    units = (size_t)scr_str_utf16_len((ScrStr *)s);
  }
  if (units >= max)
    return scr_buffer_from_str_unpooled(s, enc, (size_t)scr_bytes_byte_length_str((ScrStr *)s, enc));
  size_t length = units * 4;
  if (length >= max) {
    length = (size_t)scr_bytes_byte_length_str((ScrStr *)s, enc);
    if (length >= max) return scr_buffer_from_str_unpooled(s, enc, length);
  }
  if (!scr_pool_reserve(length)) return NULL;
  ScrBytesSink sink = {
      .at = scr_pool_slab->data + scr_pool_offset, .room = scr_pool_room(), .cap = SIZE_MAX};
  ScrBytes *b = scr_bytes_encode_str(&sink, s, enc);
  size_t actual = b->len;
  if (b != &sink.header) {
    /* The encoder's storage bound exceeded the room; the bytes written
     * never exceed Node's reservation, which fits. */
    memcpy(scr_pool_slab->data + scr_pool_offset, b->data, actual);
    scr_bytes_release(b);
  }
  return scr_pool_take(actual);
}

ScrBytes *scr_buffer_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_buffer_from_str(s, normalized);
  scr_str_release(normalized);
  return out;
}

static ScrBytes *scr_bytes_concat_item(const ScrArr *list, size_t i);

/* Buffer.concat(list[, totalLength]) into Node's allocate(totalLength). */
static ScrBytes *scr_buffer_concat_into(const ScrArr *list, double total) {
  ScrBytes *out = scr_buffer_allocate(total);
  if (!out) return NULL;
  size_t pos = 0;
  for (size_t i = 0; i < list->len && pos < out->len; i++) {
    ScrBytes *part = scr_bytes_concat_item(list, i);
    if (!part) {
      scr_bytes_release(out);
      return NULL;
    }
    size_t take = part->len < out->len - pos ? part->len : out->len - pos;
    scr_bytes_read(part, 0, out->data + pos, take);
    pos += take;
    scr_bytes_release(part);
  }
  if (pos < out->len) memset(out->data + pos, 0, out->len - pos);
  return out;
}

ScrBytes *scr_buffer_concat(const ScrArr *list) {
  if (list->len == 0) return scr_buffer_empty();
  size_t total = 0;
  bool borrowed = true;
  for (size_t i = 0; i < list->len; i++) {
    /* Present parts are read borrowed; copying runs no script code. */
    const ScrBytes *part = scr_arr_has(list, (double)i) ? scr_arr_peek_ref(list, (double)i) : NULL;
    if (!part) {
      borrowed = false;
      break;
    }
    total += part->len;
  }
  if (!borrowed) {
    total = 0;
    for (size_t i = 0; i < list->len; i++) {
      ScrBytes *part = scr_bytes_concat_item(list, i);
      if (!part) return NULL;
      total += part->len;
      scr_bytes_release(part);
    }
    return scr_buffer_concat_into(list, (double)total);
  }
  ScrBytes *out = scr_buffer_allocate((double)total);
  if (!out) return NULL;
  size_t pos = 0;
  for (size_t i = 0; i < list->len; i++) {
    const ScrBytes *part = scr_arr_peek_ref(list, (double)i);
    scr_bytes_read(part, 0, out->data + pos, part->len);
    pos += part->len;
  }
  return out;
}

ScrBytes *scr_buffer_concat_len(const ScrArr *list, double total) {
  /* An empty list returns before the total validates, as in Node. */
  if (list->len == 0) return scr_buffer_empty();
  if (!scr_bytes_validate_off("length", total, 9007199254740991.0)) return NULL;
  return scr_buffer_concat_into(list, total);
}

/* Moves an unpooled array-like copy into the pool when it is small enough
 * (Node's fromArrayLike). Consumes `b`. */
ScrBytes *scr_buffer_pool_adopt(ScrBytes *b) {
  size_t n = b->len;
  if (b->backing || b->shared || n == 0 || n >= scr_pool_threshold()) return b;
  if (!scr_pool_reserve(n)) {
    scr_bytes_release(b);
    return NULL;
  }
  ScrBytes *v = scr_pool_take(n);
  memcpy(v->data, b->data, n);
  scr_bytes_release(b);
  return v;
}

void scr_buffer_pool_reset(void) {
  scr_bytes_release(scr_pool_slab);
  scr_pool_slab = NULL;
  scr_pool_offset = 0;
  scr_pool_started = false;
  scr_buffer_set_pool_size(SCR_BUFFER_POOL_DEFAULT);
}

/* 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_private(elem, arr->len);
  scr_bytes_fill_from_arr(b->data, elem, arr);
  return b;
}

/* Writes arr's values, converted to `elem`, at `out` (arr->len elements). */
static void scr_bytes_fill_from_arr(uint8_t *out, ScrBytesElem elem, const ScrArr *arr) {
  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 (scr_arr_dense_state(arr, 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(out + start * width, elem, values, count);
    start += count;
  }
}

/* ── equals / compare / indexOf / fill / copy / swap / write (u8; the
 * error ladders mirror Node's validateOffset — 'an integer' first, then
 * the '>= 0 && <= max' render, ERR_OUT_OF_RANGE's Received rules — and
 * copy's C++-side ladder; pinned by corpus 1663) ─────────────────────── */

size_t scr_num_received(double v, char out[48]); /* the numeric section below */

/* validateOffset(name, 0, max): non-integers are 'an integer' (Number.
 * isInteger — ±Infinity render 'an integer' too), the rest '>= 0 && <=
 * max' (Node spells '&&' here, unlike the read/write families' 'and').
 * max < 0 means copy's no-upper-bound '>= 0' render. Exported: the
 * checked-dynamic compare/equals validators (scr_bytes_io.c) run the
 * same ladder after their own type gate. */
bool scr_bytes_validate_off(const char *name, double value, double max) {
  if (isfinite(value) && floor(value) == value && value >= 0 && (max < 0 || value <= max)) return true;
  char recv[48];
  scr_num_received(value, recv);
  char msg[160];
  int mlen;
  if (floor(value) != value || !isfinite(value)) {
    mlen = snprintf(msg, sizeof msg,
                    "The value of \"%s\" is out of range. It must be an integer. Received %s",
                    name, recv);
  } else if (max < 0) {
    mlen = snprintf(msg, sizeof msg,
                    "The value of \"%s\" is out of range. It must be >= 0. Received %s", name, recv);
  } else {
    char maxb[32];
    scr_f64_to_str(max, maxb);
    mlen = snprintf(msg, sizeof msg,
                    "The value of \"%s\" is out of range. It must be >= 0 && <= %s. Received %s",
                    name, maxb, recv);
  }
  scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
  return false;
}

bool scr_bytes_equals(const ScrBytes *a, const ScrBytes *b) {
  SCR_BYTES_SNAPSHOT(a);
  SCR_BYTES_SNAPSHOT(b);
  return a->len == b->len && memcmp(a->data, b->data, a->len) == 0;
}

/* src.compare(target, targetStart?, targetEnd?, sourceStart?, sourceEnd?)
 * — nargs counts the PRESENT index args (defaults skip validation, like
 * Node). Empty-range shortcuts and the memcmp-with-length-tiebreak are
 * Node's exactly. */
double scr_bytes_compare(const ScrBytes *src, const ScrBytes *target, double nargs,
                         double ts, double te, double ss, double se) {
  SCR_BYTES_SNAPSHOT(src);
  SCR_BYTES_SNAPSHOT(target);
  size_t n = (size_t)nargs;
  if (n < 1) ts = 0;
  else if (!scr_bytes_validate_off("targetStart", ts, 9007199254740991.0)) return 0;
  if (n < 2) te = (double)target->len;
  else if (!scr_bytes_validate_off("targetEnd", te, (double)target->len)) return 0;
  if (n < 3) ss = 0;
  else if (!scr_bytes_validate_off("sourceStart", ss, 9007199254740991.0)) return 0;
  if (n < 4) se = (double)src->len;
  else if (!scr_bytes_validate_off("sourceEnd", se, (double)src->len)) return 0;
  if (ts >= te) return ss >= se ? 0 : 1;
  if (ss >= se) return -1;
  /* Clamp the starts into range (a start past the length reads empty —
   * handled above; here both windows are non-empty). */
  size_t t0 = ts > (double)target->len ? target->len : (size_t)ts;
  size_t s0 = ss > (double)src->len ? src->len : (size_t)ss;
  size_t tn = (size_t)te - t0, sn = (size_t)se - s0;
  size_t m = sn < tn ? sn : tn;
  int c = memcmp(src->data + s0, target->data + t0, m);
  if (c != 0) return c < 0 ? -1 : 1;
  if (sn == tn) return 0;
  return sn < tn ? -1 : 1;
}

/* node_buffer.cc's IndexOfBuffer/IndexOfString for the UCS2 encoding over
 * an encoded needle: buffer.js clamps the byteOffset to the int32 range,
 * IndexOfOffset picks the start, the search runs over whole 2-byte units of
 * the haystack (an odd trailing byte of either side is ignored), and a match
 * is reported at its byte position. */
static double scr_bytes_index_of_ucs2(const ScrBytes *haystack, const ScrBytes *needle, double at, bool fwd) {
  int64_t length = (int64_t)haystack->len, needle_length = (int64_t)needle->len;
  /* NaN (an omitted or non-numeric byteOffset) searches everything. */
  if (at > 2147483647.0) at = 2147483647.0;
  else if (at < -2147483648.0) at = -2147483648.0;
  int64_t offset_i64 = at != at ? (fwd ? 0 : length) : (int64_t)trunc(at);
  int64_t opt_offset;
  if (offset_i64 < 0) {
    if (offset_i64 + length >= 0) opt_offset = length + offset_i64;
    else opt_offset = fwd || needle_length == 0 ? 0 : -1;
  } else if (offset_i64 + needle_length <= length) {
    opt_offset = offset_i64;
  } else if (needle_length == 0) {
    opt_offset = length;
  } else {
    opt_offset = fwd ? -1 : length - 1;
  }
  size_t search_end = haystack->len & ~(size_t)1;
  if (needle_length == 0) return (double)(opt_offset < (int64_t)search_end ? opt_offset : (int64_t)search_end);
  if (length == 0 || opt_offset <= -1) return -1;
  size_t offset = (size_t)opt_offset;
  if (offset >= search_end) {
    if (fwd || search_end == 0) return -1;
    offset = search_end - 1;
  }
  if ((fwd && needle->len + offset > search_end) || needle->len > search_end) return -1;
  if (search_end < 2 || needle->len < 2) return -1;
  size_t units = search_end / 2, needle_units = needle->len / 2, start = offset / 2;
  if (units < needle_units) return -1;
  size_t last = units - needle_units;
  if (fwd) {
    for (size_t p = start; p <= last; p++)
      if (!memcmp(haystack->data + 2 * p, needle->data, 2 * needle_units)) return (double)(2 * p);
    return -1;
  }
  for (size_t p = start < last ? start : last;; p--) {
    if (!memcmp(haystack->data + 2 * p, needle->data, 2 * needle_units)) return (double)(2 * p);
    if (p == 0) return -1;
  }
}

/* The shared search core: needle bytes, a coerced byteOffset (trunc; NaN
 * means 'search everything' — 0 forward, the end backward; negatives
 * count from the end, and a still-negative backward search answers -1),
 * and the alignment: 2 searches utf16le units (scr_bytes_index_of_ucs2). */
double scr_bytes_index_of(const ScrBytes *b, const ScrBytes *needle, double off, double align, bool fwd) {
  SCR_BYTES_SNAPSHOT(b);
  SCR_BYTES_SNAPSHOT(needle);
  if (align == 2) return scr_bytes_index_of_ucs2(b, needle, off, fwd);
  size_t len = b->len, nlen = needle->len;
  double o = (off != off) ? (fwd ? 0 : (double)len) : trunc(off);
  if (o < 0) {
    o += (double)len;
    if (o < 0) {
      if (!fwd) return -1;
      o = 0;
    }
  }
  if (nlen == 0) return o > (double)len ? (double)len : o; /* '' matches at the clamp */
  if (nlen > len) return -1;
  /* Candidates are the positions holding the needle's first byte; only
   * those compare the rest. */
  const uint8_t first = needle->data[0];
  if (fwd) {
    size_t start = o > (double)len ? len : (size_t)o;
    const uint8_t *at = b->data + start, *end = b->data + (len - nlen) + 1;
    while (at < end) {
      at = memchr(at, first, (size_t)(end - at));
      if (!at) return -1;
      if (nlen == 1 || memcmp(at + 1, needle->data + 1, nlen - 1) == 0) return (double)(at - b->data);
      at++;
    }
    return -1;
  }
  size_t start = o > (double)(len - nlen) ? len - nlen : (size_t)o;
  for (size_t i = start;; i--) {
    if (b->data[i] == first && (nlen == 1 || memcmp(b->data + i + 1, needle->data + 1, nlen - 1) == 0))
      return (double)i;
    if (i == 0) break;
  }
  return -1;
}

double scr_bytes_index_of_num(const ScrBytes *b, double v, double off, bool fwd) {
  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);
}

/* The first index a TypedArray search from `from` starts at
 * (ToIntegerOrInfinity, then relative to the end when negative), or false
 * when it starts past the last element. */
static bool scr_bytes_search_start(size_t len, double from, size_t *start) {
  double n = from != from ? 0 : trunc(from);
  if (n >= (double)len) return false;
  if (n < 0) n = n + (double)len < 0 ? 0 : n + (double)len;
  *start = (size_t)n;
  return true;
}

double scr_bytes_index_of_elem(const ScrBytes *b, double x, double from, bool last) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, last ? "lastIndexOf" : "indexOf")) return -1;
#endif
  /* A Buffer viewed as a Uint8Array keeps Buffer's own search: the needle
   * is taken as a byte, and a NaN byteOffset searches the whole buffer. */
  if (scr_bytes_is_buffer(b)) return scr_bytes_index_of_num(b, x, from, !last);
  SCR_BYTES_SNAPSHOT(b);
  size_t len = b->len;
  size_t size = scr_bytes_elem_size(b->elem);
  if (len == 0 || x != x) return -1;
  if (!last) {
    size_t k;
    if (!scr_bytes_search_start(len, from, &k)) return -1;
    for (; k < len; k++)
      if (scr_bytes_decode(b->elem, b->data + k * size) == x) return (double)k;
    return -1;
  }
  double n = from != from ? 0 : trunc(from);
  double k = n >= 0 ? (n < (double)len - 1 ? n : (double)len - 1) : (double)len + n;
  if (k < 0) return -1;
  for (size_t i = (size_t)k + 1; i-- > 0;)
    if (scr_bytes_decode(b->elem, b->data + i * size) == x) return (double)i;
  return -1;
}

bool scr_bytes_includes_elem(const ScrBytes *b, double x, double from) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, "includes")) return false;
#endif
  if (scr_bytes_is_buffer(b)) return scr_bytes_index_of_num(b, x, from, true) >= 0;
  SCR_BYTES_SNAPSHOT(b);
  size_t len = b->len;
  size_t size = scr_bytes_elem_size(b->elem);
  size_t k;
  if (len == 0 || !scr_bytes_search_start(len, from, &k)) return false;
  bool nan = x != x;
  for (; k < len; k++) {
    double v = scr_bytes_decode(b->elem, b->data + k * size);
    if (v == x || (nan && v != v)) return true;
  }
  return false;
}

/* fill's shared core over a normalized byte pattern. nargs counts the
 * present offset/end args. An EMPTY pattern zero-fills when zero_ok
 * (Node's '' string) and is the constant TypeError otherwise (an empty
 * Uint8Array value). Returns the receiver (+1) — fill chains. */
static ScrBytes *scr_bytes_fill_core(ScrBytes *b, const uint8_t *pat, size_t patn,
                                     bool zero_ok, double nargs, double offset, double end) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, "fill")) return scr_bytes_retain(b);
#endif
  if (patn == 0 && !zero_ok) {
    static const char msg[] = "The argument 'value' is invalid. Received <Buffer >";
    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, sizeof msg - 1, "ERR_INVALID_ARG_VALUE");
    return NULL;
  }
  size_t n = (size_t)nargs;
  if (n < 1) offset = 0;
  else if (!scr_bytes_validate_off("offset", offset, 9007199254740991.0)) return NULL;
  if (n < 2) end = (double)b->len;
  else if (!scr_bytes_validate_off("end", end, (double)b->len)) return NULL;
  if (offset < end) {
    size_t o = (size_t)offset > b->len ? b->len : (size_t)offset;
    size_t e = (size_t)end;
    uint8_t *dst = b->shared ? scr_bytes_scratch(e - o) : b->data + o;
    if (patn == 0) {
      memset(dst, 0, e - o);
    } else if (patn == 1) {
      memset(dst, pat[0], e - o);
    } else {
      /* Node's fill: the pattern's first bytes (memmove: the pattern may
       * be a view of this buffer), then the filled prefix doubled. */
      size_t len = e - o, done = patn < len ? patn : len;
      memmove(dst, pat, done);
      while (done < len) {
        size_t step = done < len - done ? done : len - done;
        memcpy(dst + done, dst, step);
        done += step;
      }
    }
    if (b->shared) {
      scr_shared_store(b->data + o, dst, e - o);
      free(dst);
    }
  }
  return scr_bytes_retain(b);
}

ScrBytes *scr_bytes_fill(ScrBytes *b, const ScrBytes *pattern, double nargs, double offset, double end) {
  SCR_BYTES_SNAPSHOT(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) {
  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) {
  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);
  return r;
}

/* src.copy(dst, targetStart?, sourceStart?, sourceEnd?): Node's C++-side
 * ladder — fractional indices TRUNCATE without an error, targetStart/sourceEnd
 * check only >= 0 (past-the-end clamps to nothing), sourceStart is
 * 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) {
  size_t n = (size_t)nargs;
  ts = n < 1 ? 0 : trunc(ts);
  ss = n < 2 ? 0 : trunc(ss);
  se = n < 3 ? (double)src->len : trunc(se);
  if (!scr_bytes_validate_off("targetStart", ts, -1)) return 0;
  if (!scr_bytes_validate_off("sourceStart", ss, (double)src->len)) return 0;
  if (!scr_bytes_validate_off("sourceEnd", se, -1)) return 0;
  if (ts >= (double)dst->len) return 0;
  size_t t0 = (size_t)ts;
  size_t s0 = (size_t)ss;
  size_t e0 = se > (double)src->len ? src->len : (size_t)se;
  if (s0 >= e0) return 0;
  size_t count = e0 - s0;
  if (count > dst->len - t0) count = dst->len - t0;
  if (src->shared || dst->shared) {
    uint8_t *scratch = scr_bytes_scratch(count);
    scr_bytes_raw_in(src, scratch, src->data + s0, count);
    scr_bytes_raw_out(dst, dst->data + t0, scratch, count);
    free(scratch);
  } else memmove(dst->data + t0, src->data + s0, count);
  return (double)count;
}

/* swap16/32/64: in-place byte reversal per group; the receiver answers
 * (+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) {
  if (b->shared) {
    /* Swap a private copy and publish every byte. */
    ScrBytes *copy = scr_bytes_snapshot(b);
    ScrBytes *swapped = scr_bytes_swap(copy, width);
    if (swapped) {
      scr_shared_store(b->data, copy->data, b->len);
      scr_bytes_release(swapped);
    }
    scr_bytes_release(copy);
    return swapped ? scr_bytes_retain(b) : NULL;
  }
  size_t w = (size_t)width;
  if (b->len % w != 0) {
    char msg[64];
    int mlen = snprintf(msg, sizeof msg, "Buffer size must be a multiple of %zu-bits", w * 8);
    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_INVALID_BUFFER_SIZE");
    return NULL;
  }
  /* One load, byte swap and store per group. */
  uint8_t *p = b->data;
  size_t len = b->len;
  if (w == 2) {
    for (size_t g = 0; g < len; g += 2) {
      uint16_t v;
      memcpy(&v, p + g, 2);
      v = __builtin_bswap16(v);
      memcpy(p + g, &v, 2);
    }
  } else if (w == 4) {
    for (size_t g = 0; g < len; g += 4) {
      uint32_t v;
      memcpy(&v, p + g, 4);
      v = __builtin_bswap32(v);
      memcpy(p + g, &v, 4);
    }
  } else {
    for (size_t g = 0; g < len; g += 8) {
      uint64_t v;
      memcpy(&v, p + g, 8);
      v = __builtin_bswap64(v);
      memcpy(p + g, &v, 8);
    }
  }
  return scr_bytes_retain(b);
}

/* buf.write(string, offset?, length?, enc): encodes, clamps the byte
 * budget (offset and an explicit length validate against the buffer
 * length with Node's '&&' render; the length then clamps to the space
 * left), and truncates at a UNIT boundary — whole UTF-8 code points,
 * whole utf16le code units (a surrogate pair CAN split — Node writes the
 * 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) {
  if (b->shared) {
    /* Encode into a private copy and publish the bytes written. */
    ScrBytes *copy = scr_bytes_snapshot(b);
    double written = scr_bytes_write_str(copy, s, enc, offset, len, has_len);
    if (written > 0) scr_shared_store(b->data + (size_t)offset, copy->data + (size_t)offset, (size_t)written);
    scr_bytes_release(copy);
    return written;
  }
  if (!scr_bytes_validate_off("offset", offset, (double)b->len)) return 0;
  size_t o = (size_t)offset;
  size_t remaining = b->len - o;
  size_t budget;
  if (has_len) {
    if (!scr_bytes_validate_off("length", len, (double)b->len)) return 0;
    budget = (size_t)len > remaining ? remaining : (size_t)len;
  } else {
    budget = remaining;
  }
  /* UTF-8 already has its final representation, apart from lone
   * surrogates (U+FFFD, same length). 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);
      if (!s->ascii) scr_wtf8_to_utf8((char *)b->data + o, k);
    }
    return (double)k;
  }
  if (scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii")) {
    /* Node writes the low byte of each UTF-16 unit, in order, so an astral
     * code point contributes both surrogates' low bytes and a budget that
     * falls inside a pair splits it. That is the encoder Buffer.from uses,
     * with the budget as its output limit: the bytes written are the first
     * `budget` bytes of the whole receiver's encoding, computed in place and
     * stopping there instead of encoding the rest. */
    ScrBytesSink sink = {.at = b->data + o, .room = budget, .cap = budget};
    return (double)scr_bytes_encode_str(&sink, s, enc)->len;
  }
  if (scr_enc_is(enc, "utf16le")) {
    size_t i = 0, written = 0;
    const uint64_t high = UINT64_C(0x8080808080808080);
    while (i < s->len && budget - written >= 2) {
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
      /* utf16le of an ASCII run: zero-extend each byte to a little-endian
       * unit, sixteen per step with vector unpacks where the target has them
       * and eight per step with two word stores otherwise (the generic loop
       * below stores byte by byte, because the source and destination may
       * alias as far as the compiler knows). */
      {
        uint8_t *d = b->data + o + written;
        size_t n = 0, room = (budget - written) / 16, left = (s->len - i) / 8;
        size_t steps = room < left ? room : left;
#if defined(__SSE2__)
        const __m128i zero = _mm_setzero_si128();
        for (; n + 2 <= steps; n += 2) {
          __m128i v = _mm_loadu_si128((const __m128i *)(s->data + i + 8 * n));
          if (_mm_movemask_epi8(v)) break;
          _mm_storeu_si128((__m128i *)(d + 16 * n), _mm_unpacklo_epi8(v, zero));
          _mm_storeu_si128((__m128i *)(d + 16 * n + 16), _mm_unpackhi_epi8(v, zero));
        }
#elif defined(__ARM_NEON) && defined(__aarch64__)
        for (; n + 2 <= steps; n += 2) {
          uint8x16_t v = vld1q_u8((const uint8_t *)s->data + i + 8 * n);
          if (vmaxvq_u8(v) & 0x80) break;
          vst1q_u8(d + 16 * n, vreinterpretq_u8_u16(vmovl_u8(vget_low_u8(v))));
          vst1q_u8(d + 16 * n + 16, vreinterpretq_u8_u16(vmovl_high_u8(v)));
        }
#endif
        for (; n < steps; n++) {
          uint64_t w;
          memcpy(&w, s->data + i + 8 * n, 8);
          if (w & high) break;
          uint64_t lo = w & UINT64_C(0xffffffff), hi = w >> 32;
          lo = (lo | (lo << 16)) & UINT64_C(0x0000ffff0000ffff);
          lo = (lo | (lo << 8)) & UINT64_C(0x00ff00ff00ff00ff);
          hi = (hi | (hi << 16)) & UINT64_C(0x0000ffff0000ffff);
          hi = (hi | (hi << 8)) & UINT64_C(0x00ff00ff00ff00ff);
          memcpy(d + 16 * n, &lo, 8);
          memcpy(d + 16 * n + 8, &hi, 8);
        }
        i += 8 * n;
        written += 16 * n;
        if (n != 0) continue;
      }
#endif
      /* ASCII runs encode byte-for-unit: widen eight bytes per step while
       * the budget holds them all, else one code point below. */
      if (s->len - i >= 8 && budget - written >= 16) {
        uint64_t w;
        memcpy(&w, s->data + i, 8);
        if (!(w & high)) {
          uint8_t *d = b->data + o + written;
          for (int k = 0; k < 8; k++) {
            d[2 * k] = (uint8_t)s->data[i + k];
            d[2 * k + 1] = 0;
          }
          i += 8;
          written += 16;
          continue;
        }
      }
      uint32_t cp = scr_bytes_next_cp((const uint8_t *)s->data, s->len, &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;
      b->data[o + written++] = (uint8_t)(first >> 8);
      if (second && budget - written >= 2) {
        b->data[o + written++] = (uint8_t)second;
        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) {
    if (scr_enc_is(enc, "utf16le")) {
      k -= k % 2;
    } else if (!scr_enc_is(enc, "hex") && !scr_enc_is(enc, "base64") &&
               !scr_enc_is(enc, "base64url") && !scr_enc_is(enc, "latin1") &&
               !scr_enc_is(enc, "ascii")) {
      /* utf8: back off a split multi-byte sequence (whole chars only). */
      size_t lead = k;
      while (lead > 0 && (encd->data[lead] & 0xc0) == 0x80) lead--;
      if (lead < k) {
        uint8_t l = encd->data[lead];
        size_t need = (l & 0xf8) == 0xf0 ? 4 : (l & 0xf0) == 0xe0 ? 3 : (l & 0xe0) == 0xc0 ? 2 : 1;
        if (lead + need > k) k = lead;
      }
    }
  }
  memcpy(b->data + o, encd->data, k);
  scr_bytes_release(encd);
  return (double)k;
}

/* buf.write(string, offset?, length?, enc) with an encoding name only
 * known at run time. Node validates the offset and length before it reads
 * the name, so a bad range reports ERR_OUT_OF_RANGE even when the name is
 * unknown too; an empty name reads as utf8. */
static double scr_bytes_write_str_dyn_impl(ScrBytes *b, const ScrStr *s,
                                           const ScrStr *enc, double offset,
                                           double len, bool has_len) {
  if (!scr_bytes_validate_off("offset", offset, (double)b->len)) return 0;
  if (has_len && !scr_bytes_validate_off("length", len, (double)b->len)) return 0;
  ScrStr *normalized = scr_bytes_normalize_encoding_empty_utf8(enc);
  if (!normalized) return 0;
  double written = scr_bytes_write_str(b, s, normalized, offset, len, has_len);
  scr_str_release(normalized);
  return written;
}

double scr_bytes_write_str_dyn(ScrBytes *b, const ScrStr *s, const ScrStr *enc,
                               double offset) {
  return scr_bytes_write_str_dyn_impl(b, s, enc, offset, 0, false);
}

double scr_bytes_write_str_dyn_len(ScrBytes *b, const ScrStr *s,
                                   const ScrStr *enc, double offset,
                                   double len) {
  return scr_bytes_write_str_dyn_impl(b, s, enc, offset, len, true);
}

/* Buffer.concat(list, totalLength): the same concatenation truncated or
 * zero-padded to the validated total. */
static ScrBytes *scr_bytes_concat_item(const ScrArr *list, size_t i) {
  if (!scr_arr_has(list, (double)i)) {
    char msg[160];
    int n = snprintf(
        msg, sizeof msg,
        "The \"list[%zu]\" argument must be an instance of Buffer or Uint8Array. Received undefined",
        i);
    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, n < 0 ? 0 : (size_t)n,
                             "ERR_INVALID_ARG_TYPE");
    return NULL;
  }
  ScrBytes *part = (ScrBytes *)scr_arr_get_ref((ScrArr *)list, (double)i);
  if (!part) {
    char msg[160];
    int n = snprintf(
        msg, sizeof msg,
        "The \"list[%zu]\" argument must be an instance of Buffer or Uint8Array. Received undefined",
        i);
    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, n < 0 ? 0 : (size_t)n,
                             "ERR_INVALID_ARG_TYPE");
  }
  return part;
}

ScrBytes *scr_bytes_concat_len(const ScrArr *list, double total) {
  /* An empty list short-circuits BEFORE the total validates — Node's
   * own `if (list.length === 0) return new FastBuffer()`. */
  if (list->len == 0) return scr_bytes_alloc(SCR_BYTES_U8, 0);
  if (!scr_bytes_validate_off("length", total, 9007199254740991.0)) return NULL;
  ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, (size_t)total);
  size_t o = 0;
  for (size_t i = 0; i < list->len && o < b->len; i++) {
    ScrBytes *part = scr_bytes_concat_item(list, i);
    if (!part) {
      scr_bytes_release(b);
      return NULL;
    }
    size_t take = part->len < b->len - o ? part->len : b->len - o;
    scr_bytes_read(part, 0, b->data + o, take);
    o += take;
    scr_bytes_release(part);
  }
  return b;
}

/* Buffer.byteLength(string, enc): utf8 is the storage length (ScrStr IS
 * utf8 bytes), latin1/ascii count UTF-16 units, utf16le doubles them,
 * hex halves the length, base64/base64url use Node's padding-trimmed
 * (len * 3) >>> 2. The enc arrives NORMALIZED (the compiler folds
 * aliases). */
double scr_bytes_byte_length_str(ScrStr *s, const ScrStr *enc) {
  if (scr_enc_is(enc, "latin1") || scr_enc_is(enc, "ascii")) {
    return scr_str_utf16_len(s);
  }
  if (scr_enc_is(enc, "utf16le")) return 2 * scr_str_utf16_len(s);
  if (scr_enc_is(enc, "hex")) {
    return floor(scr_str_utf16_len(s) / 2);
  }
  if (scr_enc_is(enc, "base64") || scr_enc_is(enc, "base64url")) {
    size_t units = (size_t)scr_str_utf16_len(s);
    /* Trailing '=' padding trims (at most two) — checked on the raw
     * bytes: '=' is ASCII, so the last byte IS the last unit. */
    if (units > 0 && s->len >= 1 && s->data[s->len - 1] == '=') units--;
    if (units > 1 && s->len >= 2 && s->data[s->len - 2] == '=') units--;
    return (double)((units * 3) >> 2);
  }
  return (double)s->len; /* utf8 */
}

/* Buffer.isEncoding(name): case-insensitive over Node's alias set. */
bool scr_bytes_is_encoding(const ScrStr *s) {
  static const char *const names[] = {
      "utf8", "utf-8", "ascii", "latin1", "binary",   "base64",
      "hex",  "ucs2",  "ucs-2", "utf16le", "utf-16le", "base64url",
  };
  if (s->len < 3 || s->len > 9) return false;
  char low[10];
  for (size_t i = 0; i < s->len; i++) {
    char c = s->data[i];
    low[i] = c >= 'A' && c <= 'Z' ? (char)(c + 32) : c;
  }
  low[s->len] = 0;
  for (size_t i = 0; i < sizeof names / sizeof names[0]; i++) {
    if (strlen(names[i]) == s->len && memcmp(low, names[i], s->len) == 0) return true;
  }
  return false;
}

ScrBytes *scr_bytes_concat(const ScrArr *list) {
  size_t total = 0;
  for (size_t i = 0; i < list->len; i++) {
    ScrBytes *part = scr_bytes_concat_item(list, i);
    if (!part) return NULL;
    total += part->len;
    scr_bytes_release(part);
  }
  ScrBytes *b = scr_bytes_alloc(SCR_BYTES_U8, total);
  size_t o = 0;
  for (size_t i = 0; i < list->len; i++) {
    ScrBytes *part = scr_bytes_concat_item(list, i);
    if (!part) {
      scr_bytes_release(b);
      return NULL;
    }
    scr_bytes_read(part, 0, b->data + o, part->len);
    o += part->len;
    scr_bytes_release(part);
  }
  return b;
}

/* ── the buf.read* / buf.write* numeric families (Node's exact bounds
 * discipline; the error ladders below mirror lib/internal/buffer.js's
 * boundsError/checkInt/checkBounds exactly — pinned by corpus
 * 1660 against the live Node oracle) ───────────────────────────────── */

/* ERR_OUT_OF_RANGE's "Received" rendering: integers with |v| > 2^32 get
 * Node's addNumericalSeparator underscores applied to the plain String()
 * form — INCLUDING its quirks on exponent renderings ("1e_+21",
 * "1e+_300"); everything else is the shortest-roundtrip number. Shared
 * with the fs/net option-ladder validators (scr_num_received). */
size_t scr_num_received(double v, char out[48]) {
  /* Node renders received numbers with inspect's spelling, which keeps
   * the sign of negative zero (String(-0) would print "0"). */
  if (v == 0 && signbit(v)) {
    memcpy(out, "-0", 3);
    return 2;
  }
  char plain[32];
  size_t n = scr_f64_to_str(v, plain);
  if (!(isfinite(v) && trunc(v) == v && fabs(v) > 4294967296.0)) {
    memcpy(out, plain, n + 1);
    return n;
  }
  /* addNumericalSeparator: head of 1-3 chars (past a leading '-'), then
   * '_'-joined groups of 3 — walked over the STRING, exactly Node. */
  size_t start = plain[0] == '-' ? 1 : 0;
  size_t head = n;
  while (head >= start + 4) head -= 3;
  memcpy(out, plain, head);
  size_t o = head;
  for (size_t p = head; p < n; p += 3) {
    out[o++] = '_';
    memcpy(out + o, plain + p, 3);
    o += 3;
  }
  out[o] = 0;
  return o;
}

/* Node's boundsError: a non-integer index is "an integer" first, a
 * negative capacity (buffer shorter than the read/write width) is the
 * constant ERR_BUFFER_OUT_OF_BOUNDS text, and everything else renders
 * the ">= min and <= max" range. type NULL means "offset" (min 0);
 * "byteLength" renders min 1. All catchable RangeErrors. */
static void scr_bytes_bounds_error(double value, double length, const char *type) {
  char recv[48];
  scr_num_received(value, recv);
  char msg[160];
  int mlen;
  if (floor(value) != value) {
    mlen = snprintf(msg, sizeof msg,
                    "The value of \"%s\" is out of range. It must be an integer. Received %s",
                    type ? type : "offset", recv);
  } else if (length < 0) {
    static const char oob[] = "Attempt to access memory outside buffer bounds";
    scr_throw_error_msg_code(SCR_ERR_RANGE, oob, sizeof oob - 1, "ERR_BUFFER_OUT_OF_BOUNDS");
    return;
  } else {
    char lenbuf[32];
    scr_f64_to_str(length, lenbuf);
    mlen = snprintf(msg, sizeof msg,
                    "The value of \"%s\" is out of range. It must be >= %d and <= %s. Received %s",
                    type ? type : "offset", type ? 1 : 0, lenbuf, recv);
  }
  scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
}

/* The shared offset gate: width bytes at offset must lie inside b. */
static bool scr_bytes_rw_check(const ScrBytes *b, double offset, size_t width) {
  double cap = (double)b->len - (double)width;
  if (floor(offset) != offset || cap < 0 || offset < 0 || offset > cap) {
    scr_bytes_bounds_error(offset, cap, NULL);
    return false;
  }
  return true;
}

/* Node's checkInt for the integer writes: the VALUE range throws before
 * any offset check; widths past 4 bytes render the "2 ** N" range form
 * (checkInt's byteLength > 3 branch). NaN passes both comparisons —
 * exactly Node — and writes zeros downstream. */
static bool scr_bytes_check_int(const ScrBytes *b, double value, double offset,
                                size_t width, bool sign) {
  double max = sign ? ldexp(1.0, (int)(8 * width - 1)) - 1 : ldexp(1.0, (int)(8 * width)) - 1;
  double min = sign ? -ldexp(1.0, (int)(8 * width - 1)) : 0;
  if (value > max || value < min) {
    char recv[48];
    scr_num_received(value, recv);
    char msg[160];
    int mlen;
    if (width > 4) {
      if (sign) {
        mlen = snprintf(msg, sizeof msg,
                        "The value of \"value\" is out of range. It must be >= -(2 ** %zu) and < 2 ** %zu. Received %s",
                        8 * width - 1, 8 * width - 1, recv);
      } else {
        mlen = snprintf(msg, sizeof msg,
                        "The value of \"value\" is out of range. It must be >= 0 and < 2 ** %zu. Received %s",
                        8 * width, recv);
      }
    } else {
      char minb[32], maxb[32];
      scr_f64_to_str(min, minb);
      scr_f64_to_str(max, maxb);
      mlen = snprintf(msg, sizeof msg,
                      "The value of \"value\" is out of range. It must be >= %s and <= %s. Received %s",
                      minb, maxb, recv);
    }
    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
    return false;
  }
  return scr_bytes_rw_check(b, offset, width);
}

static size_t scr_bytes_num_width(ScrBytesNumKind kind) {
  switch (kind) {
    case SCR_BN_U8:
    case SCR_BN_I8:
      return 1;
    case SCR_BN_U16:
    case SCR_BN_I16:
      return 2;
    case SCR_BN_F64:
      return 8;
    default:
      return 4; /* u32 / i32 / f32 */
  }
}

double scr_bytes_read_num(const ScrBytes *b, double offset, ScrBytesNumKind kind, bool le) {
  size_t width = scr_bytes_num_width(kind);
  if (!scr_bytes_rw_check(b, offset, width)) return 0;
  uint8_t p[8];
  scr_bytes_raw_in(b, p, b->data + (size_t)offset, width);
  uint64_t u = 0;
  for (size_t i = 0; i < width; i++) {
    u |= (uint64_t)p[le ? i : width - 1 - i] << (8 * i);
  }
  switch (kind) {
    case SCR_BN_U8:
    case SCR_BN_U16:
    case SCR_BN_U32:
      return (double)u;
    case SCR_BN_I8:
      return (double)(int8_t)u;
    case SCR_BN_I16:
      return (double)(int16_t)u;
    case SCR_BN_I32:
      return (double)(int32_t)u;
    case SCR_BN_F32: {
      uint32_t bits = (uint32_t)u;
      float f;
      memcpy(&f, &bits, 4);
      return (double)f;
    }
    case SCR_BN_F64: {
      double d;
      memcpy(&d, &u, 8);
      return d;
    }
  }
  return 0; /* unreachable */
}

double scr_bytes_write_num(ScrBytes *b, double value, double offset, ScrBytesNumKind kind, bool le) {
  size_t width = scr_bytes_num_width(kind);
  uint64_t u;
  if (kind == SCR_BN_F32 || kind == SCR_BN_F64) {
    /* Float writes carry no value check (any double stores; the float
     * cast rounds to nearest exactly like Float32Array assignment). */
    if (!scr_bytes_rw_check(b, offset, width)) return 0;
    if (kind == SCR_BN_F32) {
      float f = (float)value;
      uint32_t bits;
      memcpy(&bits, &f, 4);
      u = bits;
    } else {
      memcpy(&u, &value, 8);
    }
  } else {
    bool sign = kind == SCR_BN_I8 || kind == SCR_BN_I16 || kind == SCR_BN_I32;
    if (!scr_bytes_check_int(b, value, offset, width, sign)) return 0;
    double t = trunc(value);
    if (t != t) t = 0; /* NaN passed the range gate: zeros, like Node */
    u = (uint64_t)(int64_t)t; /* two's complement of the truncation */
  }
  uint8_t p[8];
  for (size_t i = 0; i < width; i++) {
    p[le ? i : width - 1 - i] = (uint8_t)(u >> (8 * i));
  }
  scr_bytes_raw_out(b, b->data + (size_t)offset, p, width);
  return offset + (double)width;
}

/* 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) {
  if (floor(byte_length) != byte_length || byte_length < 1 || byte_length > 6) {
    scr_bytes_bounds_error(byte_length, 6, "byteLength");
    return 0;
  }
  size_t width = (size_t)byte_length;
  if (!scr_bytes_rw_check(b, offset, width)) return 0;
  uint8_t p[8];
  scr_bytes_raw_in(b, p, b->data + (size_t)offset, width);
  uint64_t u = 0;
  for (size_t i = 0; i < width; i++) {
    u |= (uint64_t)p[le ? i : width - 1 - i] << (8 * i);
  }
  if (sign && (u & ((uint64_t)1 << (8 * width - 1)))) {
    return (double)(int64_t)(u - ((uint64_t)1 << (8 * width)));
  }
  return (double)u;
}

/* 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) {
  if (floor(byte_length) != byte_length || byte_length < 1 || byte_length > 6) {
    scr_bytes_bounds_error(byte_length, 6, "byteLength");
    return 0;
  }
  size_t width = (size_t)byte_length;
  if (!scr_bytes_check_int(b, value, offset, width, sign)) return 0;
  double t = trunc(value);
  if (t != t) t = 0;
  uint64_t u = (uint64_t)(int64_t)t;
  uint8_t p[8];
  for (size_t i = 0; i < width; i++) {
    p[le ? i : width - 1 - i] = (uint8_t)(u >> (8 * i));
  }
  scr_bytes_raw_out(b, b->data + (size_t)offset, p, width);
  return offset + (double)width;
}

bool scr_bytes_read_u64_raw(const ScrBytes *b, double offset, bool le, uint64_t *out) {
  if (!scr_bytes_rw_check(b, offset, 8)) return false;
  uint8_t p[8];
  scr_bytes_raw_in(b, p, b->data + (size_t)offset, 8);
  uint64_t value = 0;
  for (size_t i = 0; i < 8; i++) value |= (uint64_t)p[le ? i : 7 - i] << (8 * i);
  *out = value;
  return true;
}

bool scr_bytes_write_u64_raw(ScrBytes *b, double offset, bool le, uint64_t value) {
  if (!scr_bytes_rw_check(b, offset, 8)) return false;
  uint8_t p[8];
  for (size_t i = 0; i < 8; i++) p[le ? i : 7 - i] = (uint8_t)(value >> (8 * i));
  scr_bytes_raw_out(b, b->data + (size_t)offset, p, 8);
  return true;
}

static bool scr_dataview_u64_check(const ScrBytes *b, double byte_off) {
  double off = (byte_off != byte_off) ? 0 : trunc(byte_off);
  if (!(off >= 0) || off > 9007199254740991.0 || off + 8 > (double)b->len) {
    static const char msg[] = "Offset is outside the bounds of the DataView";
    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
    return false;
  }
  return true;
}

bool scr_dataview_read_u64_raw(const ScrBytes *b, double offset, bool le, uint64_t *out) {
  double off = (offset != offset) ? 0 : trunc(offset);
  if (!scr_dataview_u64_check(b, offset)) return false;
  uint8_t p[8];
  scr_bytes_raw_in(b, p, b->data + (size_t)off, 8);
  uint64_t value = 0;
  for (size_t i = 0; i < 8; i++) value |= (uint64_t)p[le ? i : 7 - i] << (8 * i);
  *out = value;
  return true;
}

bool scr_dataview_write_u64_raw(ScrBytes *b, double offset, bool le, uint64_t value) {
  double off = (offset != offset) ? 0 : trunc(offset);
  if (!scr_dataview_u64_check(b, offset)) return false;
  uint8_t p[8];
  for (size_t i = 0; i < 8; i++) p[le ? i : 7 - i] = (uint8_t)(value >> (8 * i));
  scr_bytes_raw_out(b, b->data + (size_t)off, p, 8);
  return true;
}

ScrArr *scr_bytes_to_arr(const ScrBytes *b) {
#ifdef SCR_JS_OBJECT_MODEL
  /* An ScrArr holds doubles: a BigInt view's elements have no numeric form,
   * so the dynamic tier reads and joins them through the element accessors. */
  if (scr_bytes_elem_is_bigint(b->elem)) scr_trap("scriptc: numeric read of a BigInt typed array\n");
#endif
  ScrArr *out = scr_arr_new(SCR_ELEM_F64, b->len ? b->len : 1);
  for (size_t i = 0; i < b->len; i++) {
    scr_arr_push_f64(out, scr_bytes_get(b, (double)i));
  }
  return out;
}

ScrStr *scr_bytes_join(const ScrBytes *b, const ScrStr *separator) {
#ifdef SCR_JS_OBJECT_MODEL
  if (!scr_js_typed_method_ok(b, "join")) return scr_str_new("", 0);
#endif
  ScrArr *values = scr_bytes_to_arr(b);
  ScrStr *out = scr_arr_join(values, (ScrStr *)separator);
  scr_arr_release(values);
  return out;
}

/* ── the checked-dynamic Buffer compare/equals validators ──────────────
 * Node's argument ladders for buf.equals / buf.compare / Buffer.compare
 * over dyn-boxed arguments (the invalid-input probes: string needles,
 * '0' offsets, null/object range args). A well-typed dyn still computes
 * the real answer — validation, not a constant fence. */

/* A bytes payload or the API's own ERR_INVALID_ARG_TYPE (borrowed). */
static ScrBytes *scr_bytes_chk_u8(const ScrDyn *d, const char *argname) {
  if (!scr_dyn_bytes_is(d, SCR_BYTES_U8)) {
    scr_dyn_arg_type_fail(argname, "an instance of Buffer or Uint8Array", d);
    return NULL;
  }
  return d->v.bytes;
}

double scr_buffer_compare_chk(const ScrDyn *a, const ScrDyn *b) {
  ScrBytes *b1 = scr_bytes_chk_u8(a, "buf1");
  if (!b1) return 0;
  ScrBytes *b2 = scr_bytes_chk_u8(b, "buf2");
  if (!b2) return 0;
  return scr_bytes_compare(b1, b2, 0, 0, 0, 0, 0);
}

bool scr_bytes_equals_chk(const ScrBytes *recv, const ScrDyn *other) {
  ScrBytes *o = scr_bytes_chk_u8(other, "otherBuffer");
  if (!o) return false;
  return scr_bytes_equals(recv, o);
}

/* One offset slot: undefined takes the Node default, non-numbers throw
 * ERR_INVALID_ARG_TYPE "of type number", numbers run validateOffset. */
static bool scr_bytes_chk_off(const ScrDyn *d, const char *name, double max,
                              double dflt, double *out) {
  if (d->kind == SCR_DYN_UNDEF) {
    *out = dflt;
    return true;
  }
  if (d->kind != SCR_DYN_NUM) {
    scr_dyn_arg_type_fail(name, "of type number", d);
    return false;
  }
  *out = d->v.num;
  return scr_bytes_validate_off(name, *out, max);
}

double scr_bytes_compare_chk(const ScrBytes *src, const ScrDyn *target,
                             const ScrDyn *ts, const ScrDyn *te,
                             const ScrDyn *ss, const ScrDyn *se) {
  ScrBytes *t = scr_bytes_chk_u8(target, "target");
  if (!t) return 0;
  double tsv, tev, ssv, sev;
  if (!scr_bytes_chk_off(ts, "targetStart", 9007199254740991.0, 0, &tsv)) return 0;
  if (!scr_bytes_chk_off(te, "targetEnd", (double)t->len, (double)t->len, &tev)) return 0;
  if (!scr_bytes_chk_off(ss, "sourceStart", 9007199254740991.0, 0, &ssv)) return 0;
  if (!scr_bytes_chk_off(se, "sourceEnd", (double)src->len, (double)src->len, &sev)) return 0;
  /* Every slot validated or defaulted above; nargs 4 revalidates the
   * now-known-good numbers (a no-op) and keeps one comparison core. */
  return scr_bytes_compare(src, t, 4, tsv, tev, ssv, sev);
}

/* One streaming step through the decoder above: decoder.write over the chunk
 * and the packed state that follows it, from a single walk of pending+chunk.
 * process.stdin's setEncoding (scr_events.c) threads the state across reads
 * through this, keeping the encoding and the state as values it never
 * unpacks. Kept at the end of the unit so the functions before it keep their
 * constant-pool numbering. */
ScrStr *scr_strdec_stream_write(const ScrStr *enc, const ScrBytes *chunk, double *pending) {
  SCR_BYTES_SNAPSHOT(chunk);
  double hold = 0;
  ScrStr *text = scr_strdec_step(enc, *pending, chunk, true, &hold);
  *pending = hold;
  return text;
}

/* scr_bytes.h. At the end of the unit for the same reason: only the Node
 * island handle unit calls it, so no other program links it. */
bool scr_bytes_storage_movable(const ScrBytes *owner) {
#ifdef SCR_JS_OBJECT_MODEL
  const ScrJsBufferOps *ops = scr_js_buffer_ops;
  return ops != NULL && (ops->owner_resizable(owner) || ops->owner_detached(owner));
#else
  (void)owner;
  return false;
#endif
}

/* scr_bytes.h. Here for the same reason: the descriptor I/O unit is built
 * once, so it asks the build of this unit the program links. */
bool scr_bytes_view_usable(const ScrBytes *b) {
#ifdef SCR_JS_OBJECT_MODEL
  return scr_js_bytes_live(b);
#else
  (void)b;
  return true;
#endif
}

bool scr_bytes_view_byte_length(const ScrBytes *b, double *length) {
#ifdef SCR_JS_OBJECT_MODEL
  *length = scr_js_bytes_byte_length(b);
  return !scr_exc_pending();
#else
  *length = scr_bytes_byte_len(b);
  return true;
#endif
}
