@scriptc/cli-darwin-arm64 0.2.4 → 0.2.5

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

@@ -2299,34 +2299,125 @@ static FILE *scr_fs_fopen(const ScrStr *path, const char *mode) {
 #endif
 }
 
+/* File sizes are hints, never EOF. Pseudo-files, pipes and concurrently
+ * changing files still read to EOF; descriptor reads keep their position
+ * and ownership. Limit individual reads for the CRT and small ssize_t. */
+typedef struct {
+  ScrStr *text;
+  uint8_t *bytes;
+  size_t len, cap;
+} ScrFileRead;
+
+static size_t scr_file_read_hint(FILE *stream, int fd) {
+  if (stream) fd = fileno(stream);
+#ifdef _WIN32
+  struct _stat64 st;
+  if (_fstat64(fd, &st) != 0 || !S_ISREG(st.st_mode) || st.st_size <= 0) return 4096;
+  int64_t position = stream ? 0 : _lseeki64(fd, 0, SEEK_CUR);
+#else
+  struct stat st;
+  if (fstat(fd, &st) != 0 || !S_ISREG(st.st_mode) || st.st_size <= 0) return 4096;
+  off_t position = stream ? 0 : lseek(fd, 0, SEEK_CUR);
+#endif
+  if (position < 0 || position >= st.st_size) return 4096;
+  uintmax_t remaining = (uintmax_t)st.st_size - (uintmax_t)position;
+  /* A bounded initial allocation also tolerates sparse files that shrink
+   * between metadata and the first read without reserving their full size. */
+  size_t limit = 64 * 1024 * 1024;
+  return remaining > limit ? limit : (size_t)remaining;
+}
+
+static uint8_t *scr_file_read_data(ScrFileRead *out) {
+  return out->text ? (uint8_t *)out->text->data : out->bytes;
+}
+
+static void scr_file_read_grow(ScrFileRead *out) {
+  size_t limit = SIZE_MAX - sizeof(ScrStr) - 1;
+  if (out->cap >= limit) scr_trap("scriptc: file too large\n");
+  size_t cap = out->cap > limit / 2 ? limit : out->cap * 2;
+  if (out->text) {
+    out->text->len = out->len;
+    out->text = scr_str_regrow(out->text, cap);
+  } else {
+    uint8_t *grown = realloc(out->bytes, cap);
+    if (!grown) scr_trap("scriptc: out of memory\n");
+    out->bytes = grown;
+  }
+  out->cap = cap;
+}
+
+/* Fill the final allocation. At a full capacity, probe one byte before
+ * growing so an exact-size regular file never doubles its retained space. */
+static int scr_file_read_all(FILE *stream, int fd, bool text, ScrFileRead *out) {
+  *out = (ScrFileRead){0};
+  out->cap = scr_file_read_hint(stream, fd);
+  if (text) {
+    out->text = scr_str_alloc_raw(0, out->cap);
+    out->cap = out->text->cap;
+    out->text->data[0] = '\0';
+  } else {
+    out->bytes = malloc(out->cap);
+    if (!out->bytes) scr_trap("scriptc: out of memory\n");
+  }
+  for (;;) {
+    uint8_t extra;
+    bool full = out->len == out->cap;
+    size_t room = full ? 1 : out->cap - out->len;
+    if (room > 512 * 1024) room = 512 * 1024;
+    uint8_t *dest = full ? &extra : scr_file_read_data(out) + out->len;
+    size_t count;
+    int error = 0;
+    if (stream) {
+      count = fread(dest, 1, room, stream);
+      if (ferror(stream)) error = errno ? errno : EIO;
+    } else {
+      ssize_t n = read(fd, dest, room);
+      if (n < 0) { count = 0; error = errno; }
+      else count = (size_t)n;
+    }
+    if (count) {
+      if (full) {
+        scr_file_read_grow(out);
+        scr_file_read_data(out)[out->len] = extra;
+      }
+      out->len += count;
+    }
+    if (error == EINTR) {
+      if (stream) clearerr(stream);
+      continue;
+    }
+    if (error) {
+      /* Raw strings must be safe for the normal cache-aware destructor. */
+      if (out->text) { out->text->len = out->len; out->text->data[out->len] = '\0'; }
+      scr_str_release(out->text);
+      free(out->bytes);
+      *out = (ScrFileRead){0};
+      return error;
+    }
+    if (!count) break;
+  }
+  if (out->text) { out->text->len = out->len; out->text->data[out->len] = '\0'; }
+  // Do not retain a large hint after truncation or a tiny pipe result.
+  if (out->cap > 256 && out->len < out->cap / 2) {
+    if (out->text) out->text = scr_str_regrow(out->text, out->len);
+    else {
+      uint8_t *trimmed = realloc(out->bytes, out->len ? out->len : 1);
+      if (trimmed) out->bytes = trimmed;
+    }
+  }
+  return 0;
+}
+
 static ScrStr *scr_fs_read_file_core(ScrStr *path, bool env_file) {
   FILE *f = scr_fs_fopen(path, "rb");
   if (!f) {
     scr_fs_throw(errno, "open", path);
     return NULL;
   }
-  size_t cap = 4096, len = 0;
-  char *buf = malloc(cap);
-  if (!buf) {
-    scr_trap("scriptc: out of memory\n");
-  }
-  for (;;) {
-    if (cap - len < 2048) {
-      cap *= 2;
-      char *grown = realloc(buf, cap);
-      if (!grown) {
-        scr_trap("scriptc: out of memory\n");
-      }
-      buf = grown;
-    }
-    size_t n = fread(buf + len, 1, cap - len, f);
-    len += n;
-    if (n == 0) break;
-  }
-  if (ferror(f)) {
-    int e = errno;
-    fclose(f);
-    free(buf);
+  ScrFileRead out;
+  int error = scr_file_read_all(f, -1, true, &out);
+  fclose(f);
+  if (error) {
     if (env_file) {
       ScrJsonBuf b;
       scr_jb_init(&b);
@@ -2336,13 +2427,20 @@ static ScrStr *scr_fs_read_file_core(ScrStr *path, bool env_file) {
       ScrStr *message = scr_jb_finish(&b);
       scr_throw_error_msg_code(SCR_ERR_TYPE, message->data, message->len, "ERR_INVALID_ARG_TYPE");
       scr_str_release(message);
-    } else scr_fs_throw(e, "read", path);
+    } else scr_fs_throw(error, "read", path);
     return NULL;
   }
+  return out.text;
+}
+
+ScrBytes *scr_fs_read_file_bytes(ScrStr *path) {
+  FILE *f = scr_fs_fopen(path, "rb");
+  if (!f) { scr_fs_throw(errno, "open", path); return NULL; }
+  ScrFileRead out;
+  int error = scr_file_read_all(f, -1, false, &out);
   fclose(f);
-  ScrStr *s = scr_str_new(buf, len);
-  free(buf);
-  return s;
+  if (error) { scr_fs_throw(error, "read", path); return NULL; }
+  return scr_bytes_take_data(out.bytes, out.len);
 }
 
 ScrStr *scr_fs_read_file(ScrStr *path) {
@@ -3799,57 +3897,18 @@ static void scr_fs_throw_nopath(int e, const char *op) {
   scr_throw_error_msg_code(SCR_ERR_ERROR, msg, (size_t)len, name);
 }
 
-/* read(2) loop to EOF from the CURRENT position — Node's
- * readFileSync(fd) semantics for pipes and files alike (the stdin
- * pattern: readFileSync(0, "utf8")). Returns the malloc'd buffer and
- * its length, or NULL with the exception pending. */
-static char *scr_read_fd_all(double fd, size_t *out_len) {
-  size_t cap = 4096, len = 0;
-  char *buf = malloc(cap);
-  if (!buf) {
-    scr_trap("scriptc: out of memory\n");
-  }
-  for (;;) {
-    if (cap - len < 2048) {
-      cap *= 2;
-      char *grown = realloc(buf, cap);
-      if (!grown) {
-        scr_trap("scriptc: out of memory\n");
-      }
-      buf = grown;
-    }
-    ssize_t n = read((int)fd, buf + len, cap - len);
-    if (n < 0) {
-      if (errno == EINTR) continue;
-      int e = errno;
-      free(buf);
-      scr_fs_throw_nopath(e, "read");
-      return NULL;
-    }
-    if (n == 0) break;
-    len += (size_t)n;
-  }
-  *out_len = len;
-  return buf;
-}
-
 ScrStr *scr_fs_read_fd(double fd) {
-  size_t len;
-  char *buf = scr_read_fd_all(fd, &len);
-  if (!buf) return NULL;
-  ScrStr *s = scr_str_new(buf, len);
-  free(buf);
-  return s;
+  ScrFileRead out;
+  int error = scr_file_read_all(NULL, (int)fd, true, &out);
+  if (error) { scr_fs_throw_nopath(error, "read"); return NULL; }
+  return out.text;
 }
 
 ScrBytes *scr_fs_read_fd_bytes(double fd) {
-  size_t len;
-  char *buf = scr_read_fd_all(fd, &len);
-  if (!buf) return NULL;
-  ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)len);
-  if (len > 0) memcpy(b->data, buf, len);
-  free(buf);
-  return b;
+  ScrFileRead out;
+  int error = scr_file_read_all(NULL, (int)fd, false, &out);
+  if (error) { scr_fs_throw_nopath(error, "read"); return NULL; }
+  return scr_bytes_take_data(out.bytes, out.len);
 }
 
 /* ── Atomics.wait: the synchronous-sleep idiom ───────────────────────

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

@@ -15,6 +15,7 @@
  * keep the lean 1-word header and never touch the collector.
  */
 #include "scr_runtime.h"
+#include "scr_key.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -46,27 +47,14 @@ static uint64_t scr_map_f64_bits(double k) {
   return bits;
 }
 
-static uint64_t scr_map_fnv1a(const unsigned char *bytes, size_t n) {
-  uint64_t h = UINT64_C(0xcbf29ce484222325);
-  for (size_t i = 0; i < n; i++) {
-    h ^= bytes[i];
-    h *= UINT64_C(0x100000001b3);
-  }
-  return h;
-}
-
 static uint64_t scr_map_hash_str(const ScrStr *k) {
-  return scr_map_fnv1a((const unsigned char *)k->data, k->len);
+  return scr_key_hash(k->data, k->len);
 }
 
 /* Mix the complete normalized number or identity word. Float exponents
  * and aligned pointers need high bits to reach the low bucket-index bits. */
 static uint64_t scr_map_hash_word(uint64_t value) {
-  value ^= value >> 30;
-  value *= UINT64_C(0xbf58476d1ce4e5b9);
-  value ^= value >> 27;
-  value *= UINT64_C(0x94d049bb133111eb);
-  return value ^ (value >> 31);
+  return scr_key_mix(value);
 }
 
 /* ── slot packing (8-byte slots, like ScrArr) ──────────────────────────── */
@@ -209,8 +197,19 @@ static size_t scr_map_probe(const ScrMap *m, uint64_t hash, uint64_t key) {
   }
 }
 
+#define SCR_MAP_LINEAR_LIMIT 4
+
+/* Small collections keep only their ordered entries. Cached hashes make
+ * the bounded scan cheap without allocating a separate bucket table. */
 static size_t scr_map_find(const ScrMap *m, uint64_t hash, uint64_t key) {
-  size_t slot = scr_map_probe(m, hash ? hash : 1, key);
+  hash = hash ? hash : 1;
+  if (m->nbuckets == 0) {
+    for (size_t e = 0; e < m->nentries; e++) {
+      if (m->entries[e].hash == hash && scr_map_key_eq(m, m->entries[e].key, key)) return e;
+    }
+    return SCR_MAP_EMPTY;
+  }
+  size_t slot = scr_map_probe(m, hash, key);
   return slot == SCR_MAP_EMPTY ? SCR_MAP_EMPTY : m->buckets[slot];
 }
 
@@ -248,12 +247,15 @@ static void scr_map_compact(ScrMap *m) {
  * reuse their storage) and grows otherwise; while an iteration is active it
  * ONLY grows — indices must stay stable under callback mutation. */
 static void scr_map_reserve_append(ScrMap *m) {
-  if (m->nentries < m->ecap && m->nbuckets >= 2 * (m->nentries + 1)) return;
-  if (m->iter_depth == 0 && m->nlive <= m->nentries / 2 && m->nentries > 0) {
+  if (m->nentries < m->ecap &&
+      ((m->nbuckets == 0 && m->nentries < SCR_MAP_LINEAR_LIMIT) ||
+       m->nbuckets >= 2 * (m->nentries + 1))) return;
+  if (m->iter_depth == 0 && m->nentries > 0 &&
+      (m->nbuckets == 0 ? m->nlive < m->nentries : m->nlive <= m->nentries / 2)) {
     scr_map_compact(m);
   }
   if (m->nentries == m->ecap) {
-    size_t cap = m->ecap ? m->ecap : 8;
+    size_t cap = m->ecap ? m->ecap : 4;
     while (cap < m->nentries + 1) {
       if (cap > SIZE_MAX / 2 / sizeof(ScrMapEntry)) scr_map_oom();
       cap *= 2;
@@ -263,6 +265,7 @@ static void scr_map_reserve_append(ScrMap *m) {
     m->entries = entries;
     m->ecap = cap;
   }
+  if (m->nbuckets == 0 && m->nentries < SCR_MAP_LINEAR_LIMIT) return;
   if (m->nbuckets < 2 * (m->nentries + 1)) {
     size_t nbuckets = m->nbuckets ? m->nbuckets : 16;
     while (nbuckets < 2 * (m->nentries + 1)) {
@@ -469,7 +472,7 @@ bool scr_map_delete_ref(ScrMap *m, const void *key) {
 static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
   hash = hash ? hash : 1;
   size_t slot = scr_map_probe(m, hash, key);
-  size_t e = slot == SCR_MAP_EMPTY ? SCR_MAP_EMPTY : m->buckets[slot];
+  size_t e = m->nbuckets == 0 ? scr_map_find(m, hash, key) : m->buckets[slot];
   if (e != SCR_MAP_EMPTY) {
     uint64_t old = m->entries[e].val;
     m->entries[e].val = val; /* unlink before releasing (cycle collector) */
@@ -480,7 +483,7 @@ static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
   scr_map_reserve_append(m);
   /* Growth or compaction can move the insertion bucket. Otherwise keep the
    * empty slot from the first probe instead of walking the chain twice. */
-  if (m->nentries != old_entries || m->nbuckets != old_buckets) {
+  if (m->nbuckets && (m->nentries != old_entries || m->nbuckets != old_buckets)) {
     size_t mask = m->nbuckets - 1;
     slot = hash & mask;
     while (m->buckets[slot] != SCR_MAP_EMPTY) slot = (slot + 1) & mask;
@@ -510,7 +513,7 @@ static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
   } else if (scr_map_ref_key(m->key_kind)) {
     m->key_retain(scr_map_slot_to_ptr(key)); /* key is borrowed */
   }
-  m->buckets[slot] = idx;
+  if (m->nbuckets) m->buckets[slot] = idx;
 }
 
 static void scr_map_set_f64_key(ScrMap *m, double key, uint64_t val) {
@@ -792,6 +795,7 @@ ScrMap *scr_map_clone(const ScrMap *source, bool keys_only) {
     else if (out->val_kind == SCR_MAP_VAL_REF) out->val_retain(scr_map_slot_to_ptr(copy->val));
   }
   out->nlive = count;
+  if (count <= SCR_MAP_LINEAR_LIMIT) return out;
   size_t buckets = 16;
   while (buckets < 2 * count) {
     if (buckets > SIZE_MAX / 2 / sizeof(size_t)) scr_map_oom();
@@ -890,59 +894,39 @@ void scr_set_add_all(ScrMap *set, ScrArr *values) {
 /* Canonical array index test: "0".."4294967294" — digits only, no leading
  * zero (except "0" itself), value <= 2^32 - 2. JS orders these OWN keys
  * first, ascending numerically, before every other string key. */
-static bool scr_map_key_array_index(const ScrStr *k, uint32_t *out) {
-  size_t n = k->len;
-  if (n == 0 || n > 10) return false;
-  const char *s = k->data;
-  if (s[0] == '0' && n > 1) return false;
-  uint64_t v = 0;
-  for (size_t i = 0; i < n; i++) {
-    if (s[i] < '0' || s[i] > '9') return false;
-    v = v * 10 + (uint64_t)(s[i] - '0');
-  }
-  if (v > UINT64_C(4294967294)) return false;
-  *out = (uint32_t)v;
-  return true;
+static bool scr_map_key_array_index(const ScrStr *key, uint32_t *out) {
+  return scr_key_array_index(key->data, key->len, out);
 }
 
-/* The live STRING keys of `m` in JS OWN-KEY ORDER (Object.keys over the
- * index-signature overflow): integer-like keys (canonical array indices)
- * first in ascending numeric order, then the rest in insertion order.
- * Returns a fresh ScrStr* array (+1); the map is borrowed. Insertion sort
- * over the integer-like subset — overflow maps are small, and ties are
- * impossible (keys are unique). */
+/* Enumerate numeric keys in ascending order, then other keys in insertion
+ * order. Scratch entries refer to stable map indices, not copied strings. */
 ScrArr *scr_map_keys_js_order(const ScrMap *m) {
-  size_t n = m->nentries;
   ScrArr *out = scr_arr_new(SCR_ELEM_STR, m->nlive);
-  size_t nidx = 0;
-  struct { uint32_t v; ScrStr *k; } *idx = NULL;
-  for (size_t i = 0; i < n; i++) {
+  if (m->nlive > SIZE_MAX / sizeof(ScrKeyIndex)) scr_map_oom();
+  ScrKeyIndex *indices = NULL;
+  size_t count = 0;
+  for (size_t i = 0; i < m->nentries; i++) {
     if (!m->entries[i].hash) continue;
-    ScrStr *k = (ScrStr *)scr_map_slot_to_ptr(m->entries[i].key);
-    uint32_t v;
-    if (!scr_map_key_array_index(k, &v)) continue;
-    if (nidx % 16 == 0) {
-      idx = realloc(idx, (nidx + 16) * sizeof *idx);
-      if (!idx) scr_map_oom();
+    ScrStr *key = scr_map_slot_to_ptr(m->entries[i].key);
+    uint32_t index;
+    if (!scr_map_key_array_index(key, &index)) continue;
+    if (!indices) {
+      indices = malloc(m->nlive * sizeof *indices);
+      if (!indices) scr_map_oom();
     }
-    size_t j = nidx++;
-    while (j > 0 && idx[j - 1].v > v) {
-      idx[j] = idx[j - 1];
-      j--;
-    }
-    idx[j].v = v;
-    idx[j].k = k;
+    indices[count++] = (ScrKeyIndex){index, i};
   }
-  for (size_t i = 0; i < nidx; i++) {
-    scr_arr_push_ref(out, scr_str_retain(idx[i].k));
+  scr_key_index_sort(indices, count);
+  for (size_t i = 0; i < count; i++) {
+    ScrStr *key = scr_map_slot_to_ptr(m->entries[indices[i].entry].key);
+    scr_arr_push_ref(out, scr_str_retain(key));
   }
-  free(idx);
-  for (size_t i = 0; i < n; i++) {
+  free(indices);
+  for (size_t i = 0; i < m->nentries; i++) {
     if (!m->entries[i].hash) continue;
-    ScrStr *k = (ScrStr *)scr_map_slot_to_ptr(m->entries[i].key);
-    uint32_t v;
-    if (scr_map_key_array_index(k, &v)) continue;
-    scr_arr_push_ref(out, scr_str_retain(k));
+    ScrStr *key = scr_map_slot_to_ptr(m->entries[i].key);
+    uint32_t index;
+    if (!scr_map_key_array_index(key, &index)) scr_arr_push_ref(out, scr_str_retain(key));
   }
   return out;
 }

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

@@ -14,6 +14,7 @@
  * and the 1M-double fuzz gate (packages/runtime/test/gen-number-cases.mjs).
  */
 #include "scr_runtime.h"
+#include "scr_numeric.h"
 
 #include <math.h>
 #include <stdint.h>
@@ -27,10 +28,7 @@
 /* ECMA ToUint32, shared by bitwise operators and split's limit: non-finite
  * values become zero, finite values truncate toward zero and wrap mod 2^32. */
 uint32_t scr_to_uint32(double d) {
-  if (!isfinite(d)) return 0;
-  double t = fmod(trunc(d), 4294967296.0);
-  if (t < 0) t += 4294967296.0;
-  return (uint32_t)t;
+  return scr_numeric_to_u32(d);
 }
 
 /* ── bitwise operators ─────────────────────────────────────────────────

package/dist/lib/runtime-sources/src/scr_numeric.h

@@ -0,0 +1,25 @@
+/* Internal numeric coercions shared by scalar operators and typed storage. */
+#ifndef SCR_NUMERIC_H
+#define SCR_NUMERIC_H
+#include <float.h>
+#include <stdint.h>
+#include <string.h>
+
+_Static_assert(sizeof(double) == sizeof(uint64_t) && DBL_MANT_DIG == 53 && DBL_MAX_EXP == 1024,
+               "numeric coercions require binary64 doubles");
+
+/* ToUint32 truncates toward zero and keeps the low 32 bits. Reading the
+ * binary64 exponent also handles non-finite values without floating modulo.
+ * Subnormals have magnitude below one; exponents >= 84 have no low bits. */
+static inline uint32_t scr_numeric_to_u32(double value) {
+  uint64_t bits;
+  memcpy(&bits, &value, sizeof bits);
+  unsigned exponent = (unsigned)((bits >> 52) & 0x7ff);
+  if (exponent < 1023 || exponent >= 1023 + 84) return 0;
+  unsigned shift = exponent - 1023;
+  uint64_t significand = (bits & UINT64_C(0x000fffffffffffff)) | UINT64_C(0x0010000000000000);
+  uint32_t integer = shift >= 52 ? (uint32_t)(significand << (shift - 52))
+                                : (uint32_t)(significand >> (52 - shift));
+  return bits >> 63 ? UINT32_C(0) - integer : integer;
+}
+#endif

package/dist/lib/runtime-sources/src/scr_numeric.test.c

@@ -0,0 +1,37 @@
+#include "scr_numeric.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+
+/* Independent arithmetic oracle: do not derive expectations from bit fields. */
+static uint32_t reference(double value) {
+  if (!isfinite(value)) return 0;
+  double residue = fmod(trunc(value), 4294967296.0);
+  if (residue < 0) residue += 4294967296.0;
+  return (uint32_t)residue;
+}
+
+static void check(uint64_t bits) {
+  double value;
+  memcpy(&value, &bits, sizeof value);
+  assert(scr_numeric_to_u32(value) == reference(value));
+}
+
+int main(void) {
+  uint64_t bits = UINT64_C(0x0123456789abcdef);
+  for (unsigned i = 0; i < 2000000; i++) {
+    bits ^= bits << 13;
+    bits ^= bits >> 7;
+    bits ^= bits << 17;
+    check(bits);
+  }
+  /* Both signs at every exponent, including non-finite and subnormal values. */
+  for (unsigned exponent = 0; exponent < 2048; exponent++) {
+    for (unsigned sign = 0; sign < 2; sign++) {
+      for (unsigned low = 0; low < 64; low++) {
+        check(((uint64_t)sign << 63) | ((uint64_t)exponent << 52) | low);
+      }
+    }
+  }
+  puts("numeric coercions passed");
+}

package/dist/lib/runtime-sources/src/scr_numeric.test.ts

@@ -0,0 +1,33 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { expect, test } from "vitest";
+
+const exec = promisify(execFile);
+
+test("integer coercion matches modular truncation across binary64 encodings", async () => {
+  const scratch = await mkdtemp(join(tmpdir(), "scriptc-numeric-"));
+  try {
+    const binary = join(scratch, "numeric");
+    await exec("clang", [
+      "-std=c11",
+      "-O2",
+      "-Wall",
+      "-Wextra",
+      "-fsanitize=address,undefined",
+      join(import.meta.dirname, "scr_numeric.test.c"),
+      "-o",
+      binary,
+      ...(process.platform === "linux" ? ["-lm"] : []),
+    ]);
+    const result = await exec(binary, [], {
+      env: { ...process.env, UBSAN_OPTIONS: "halt_on_error=1" },
+    });
+    expect(result.stdout).toBe("numeric coercions passed\n");
+    expect(result.stderr).toBe("");
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
+  }
+});