@scriptc/cli-darwin-arm64 0.2.3 → 0.2.5

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,17 +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_key_hash(k->data, k->len);
 }
 
-static uint64_t scr_map_hash_str(const ScrStr *k) {
-  return scr_map_fnv1a((const unsigned char *)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) {
+  return scr_key_mix(value);
 }
 
 /* ── slot packing (8-byte slots, like ScrArr) ──────────────────────────── */
@@ -98,12 +96,7 @@ static uint64_t scr_map_hash_dyn(const ScrDyn *d) {
   case SCR_DYN_NULL: value = 0; break;
   case SCR_DYN_BOOL: value = d->v.b; break;
   case SCR_DYN_NUM: value = scr_map_f64_bits(d->v.num); break;
-  case SCR_DYN_BIGINT: {
-    ScrStr *text = scr_bigint_to_string(d->v.bigint, 10);
-    uint64_t hash = scr_map_hash_str(text);
-    scr_str_release(text);
-    return hash;
-  }
+  case SCR_DYN_BIGINT: return scr_bigint_hash(d->v.bigint);
   case SCR_DYN_STR: return scr_map_hash_str(d->v.str);
   case SCR_DYN_SYMBOL: value = scr_map_slot_from_ptr(d->v.symbol.value); break;
   case SCR_DYN_FUNC: value = scr_map_slot_from_ptr(d->v.fn.class_obj ? (void *)d->v.fn.class_obj : (void *)d->v.fn.clo); break;
@@ -122,7 +115,7 @@ static uint64_t scr_map_hash_dyn(const ScrDyn *d) {
   case SCR_DYN_JSVAL: value = 0; break;
   default: value = scr_map_slot_from_ptr((void *)d); break;
   }
-  return scr_map_fnv1a((const unsigned char *)&value, sizeof value) ^ kind;
+  return scr_map_hash_word(value) ^ kind;
 }
 
 static bool scr_map_dyn_eq(const ScrDyn *a, const ScrDyn *b) {
@@ -135,16 +128,50 @@ static bool scr_map_dyn_eq(const ScrDyn *a, const ScrDyn *b) {
   return scr_dyn_strict_eq(a, b);
 }
 
+static uint64_t scr_map_hash_union(const ScrMap *m, const ScrUnion *key) {
+  ScrMapKeyKind kind = (ScrMapKeyKind)m->union_keys[key->tag];
+  switch (kind) {
+  case SCR_MAP_KEY_STR: return scr_map_hash_str(scr_union_peek(key));
+  case SCR_MAP_KEY_BIGINT: return scr_bigint_hash(scr_union_peek(key));
+  case SCR_MAP_KEY_F64: return scr_map_hash_word(scr_map_f64_bits(scr_map_slot_to_f64(key->slot)));
+  case SCR_MAP_KEY_NULL:
+  case SCR_MAP_KEY_UNDEFINED: return scr_map_hash_word((uint64_t)kind);
+  default: return scr_map_hash_word(key->slot);
+  }
+}
+
+static bool scr_map_union_eq(const ScrMap *m, const ScrUnion *a, const ScrUnion *b) {
+  ScrMapKeyKind kind = (ScrMapKeyKind)m->union_keys[a->tag];
+  if (kind != (ScrMapKeyKind)m->union_keys[b->tag]) return false;
+  switch (kind) {
+  case SCR_MAP_KEY_STR: return scr_str_eq(scr_union_peek(a), scr_union_peek(b));
+  case SCR_MAP_KEY_BIGINT: return scr_bigint_eq(scr_union_peek(a), scr_union_peek(b));
+  case SCR_MAP_KEY_F64:
+    return scr_map_f64_bits(scr_map_slot_to_f64(a->slot)) == scr_map_f64_bits(scr_map_slot_to_f64(b->slot));
+  case SCR_MAP_KEY_NULL:
+  case SCR_MAP_KEY_UNDEFINED: return true;
+  default: return a->slot == b->slot;
+  }
+}
+
 static uint64_t scr_map_hash_key(const ScrMap *m, uint64_t key) {
   if (m->key_kind == SCR_MAP_KEY_STR) return scr_map_hash_str((ScrStr *)scr_map_slot_to_ptr(key));
   if (m->key_kind == SCR_MAP_KEY_DYN) return scr_map_hash_dyn((ScrDyn *)scr_map_slot_to_ptr(key));
+  if (m->key_kind == SCR_MAP_KEY_BIGINT) return scr_bigint_hash(scr_map_slot_to_ptr(key));
+  if (m->key_kind == SCR_MAP_KEY_UNION_VALUE) return scr_map_hash_union(m, scr_map_slot_to_ptr(key));
   uint64_t identity = scr_map_identity(m, key);
-  return scr_map_fnv1a((const unsigned char *)&identity, sizeof identity);
+  return scr_map_hash_word(identity);
 }
 
 /* Stored keys are pre-normalized, so bit equality IS SameValueZero for f64
  * keys (probe keys normalize through the same function). */
 static bool scr_map_key_eq(const ScrMap *m, uint64_t stored, uint64_t probe) {
+  if (m->key_kind == SCR_MAP_KEY_UNION_VALUE) {
+    return scr_map_union_eq(m, scr_map_slot_to_ptr(stored), scr_map_slot_to_ptr(probe));
+  }
+  if (m->key_kind == SCR_MAP_KEY_BIGINT) {
+    return scr_bigint_eq(scr_map_slot_to_ptr(stored), scr_map_slot_to_ptr(probe));
+  }
   if (m->key_kind == SCR_MAP_KEY_DYN) {
     return scr_map_dyn_eq((ScrDyn *)scr_map_slot_to_ptr(stored), (ScrDyn *)scr_map_slot_to_ptr(probe));
   }
@@ -156,16 +183,34 @@ static bool scr_map_key_eq(const ScrMap *m, uint64_t stored, uint64_t probe) {
 }
 
 /* ── lookup ────────────────────────────────────────────────────────────
- * Returns the LIVE entry index holding the key, or SCR_MAP_EMPTY. Probes
- * skip tombstoned entries (their bucket slots keep chains intact). */
-static size_t scr_map_find(const ScrMap *m, uint64_t hash, uint64_t key) {
+ * Returns the matching bucket, or the empty bucket where a new key belongs.
+ * A zero entry hash marks a tombstone; cached hashes reject unrelated keys
+ * before equality and survive table growth without hashing the keys again.
+ * Remap zero to one so every live entry has a nonzero hash. */
+static size_t scr_map_probe(const ScrMap *m, uint64_t hash, uint64_t key) {
   if (m->nbuckets == 0) return SCR_MAP_EMPTY;
   size_t mask = m->nbuckets - 1;
   for (size_t i = hash & mask;; i = (i + 1) & mask) {
     size_t b = m->buckets[i];
-    if (b == SCR_MAP_EMPTY) return SCR_MAP_EMPTY;
-    if (m->entries[b].live && scr_map_key_eq(m, m->entries[b].key, key)) return b;
+    if (b == SCR_MAP_EMPTY) return i;
+    if (m->entries[b].hash == hash && scr_map_key_eq(m, m->entries[b].key, key)) return i;
+  }
+}
+
+#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) {
+  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];
 }
 
 /* Rebuild the bucket table (size must be a power of two >= 2 * nentries):
@@ -179,8 +224,8 @@ static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) {
   m->nbuckets = nbuckets;
   size_t mask = nbuckets - 1;
   for (size_t e = 0; e < m->nentries; e++) {
-    if (!m->entries[e].live) continue;
-    uint64_t hash = scr_map_hash_key(m, m->entries[e].key);
+    uint64_t hash = m->entries[e].hash;
+    if (!hash) continue;
     size_t i = hash & mask;
     while (buckets[i] != SCR_MAP_EMPTY) i = (i + 1) & mask;
     buckets[i] = e;
@@ -192,7 +237,7 @@ static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) {
 static void scr_map_compact(ScrMap *m) {
   size_t w = 0;
   for (size_t r = 0; r < m->nentries; r++) {
-    if (m->entries[r].live) m->entries[w++] = m->entries[r];
+    if (m->entries[r].hash) m->entries[w++] = m->entries[r];
   }
   m->nentries = w;
   if (m->nbuckets > 0) scr_map_rebuild_buckets(m, m->nbuckets);
@@ -202,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;
@@ -217,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)) {
@@ -229,10 +278,15 @@ static void scr_map_reserve_append(ScrMap *m) {
 
 /* ── entry release helpers ─────────────────────────────────────────────── */
 
+static bool scr_map_ref_key(ScrMapKeyKind kind) {
+  return kind == SCR_MAP_KEY_REF || kind == SCR_MAP_KEY_UNION_REF || kind == SCR_MAP_KEY_DYN ||
+         kind == SCR_MAP_KEY_BIGINT || kind == SCR_MAP_KEY_UNION_VALUE;
+}
+
 static void scr_map_release_key(ScrMap *m, uint64_t key) {
   if (m->key_kind == SCR_MAP_KEY_STR) {
     scr_str_release((ScrStr *)scr_map_slot_to_ptr(key));
-  } else if (m->key_kind == SCR_MAP_KEY_REF || m->key_kind == SCR_MAP_KEY_UNION_REF || m->key_kind == SCR_MAP_KEY_DYN) {
+  } else if (scr_map_ref_key(m->key_kind)) {
     m->key_release(scr_map_slot_to_ptr(key));
   }
 }
@@ -243,10 +297,14 @@ static void scr_map_release_val(ScrMap *m, uint64_t val) {
 
 /* ── lifecycle ─────────────────────────────────────────────────────────── */
 
+void scr_map_union_keys(ScrMap *map, const uint8_t *kinds) {
+  map->union_keys = kinds;
+}
+
 static void scr_map_trace(void *o, ScrTraceVisit visit, void *ctx) {
   ScrMap *m = (ScrMap *)o;
   for (size_t e = 0; e < m->nentries; e++) {
-    if (!m->entries[e].live) continue;
+    if (!m->entries[e].hash) continue;
     if (m->key_trace) visit(scr_map_slot_to_ptr(m->entries[e].key), ctx);
     if (m->val_trace) visit(scr_map_slot_to_ptr(m->entries[e].val), ctx);
   }
@@ -258,7 +316,7 @@ static void scr_map_gcfree(void *o) {
   ScrMap *m = (ScrMap *)o;
   scr_weak_dispose(m);
   for (size_t e = 0; e < m->nentries; e++) {
-    if (!m->entries[e].live) continue;
+    if (!m->entries[e].hash) continue;
     if (!m->key_trace) scr_map_release_key(m, m->entries[e].key);
     if (!m->val_trace) scr_map_release_val(m, m->entries[e].val);
   }
@@ -318,7 +376,7 @@ void scr_map_release(ScrMap *m) {
     scr_weak_dispose(m);
     if (m->key_trace || m->val_trace) scr_cyc_on_dead(m);
     for (size_t e = 0; e < m->nentries; e++) {
-      if (!m->entries[e].live) continue;
+      if (!m->entries[e].hash) continue;
       scr_map_release_key(m, m->entries[e].key);
       scr_map_release_val(m, m->entries[e].val);
     }
@@ -344,8 +402,8 @@ double scr_map_size(const ScrMap *m) { return (double)m->nlive; }
 
 void scr_map_clear(ScrMap *m) {
   for (size_t e = 0; e < m->nentries; e++) {
-    if (!m->entries[e].live) continue;
-    m->entries[e].live = false;
+    if (!m->entries[e].hash) continue;
+    m->entries[e].hash = 0;
     scr_map_release_key(m, m->entries[e].key);
     scr_map_release_val(m, m->entries[e].val);
   }
@@ -363,7 +421,7 @@ void scr_map_clear(ScrMap *m) {
 
 bool scr_map_has_f64(const ScrMap *m, double key) {
   uint64_t k = scr_map_f64_bits(key);
-  return scr_map_find(m, scr_map_fnv1a((const unsigned char *)&k, 8), k) != SCR_MAP_EMPTY;
+  return scr_map_find(m, scr_map_hash_word(k), k) != SCR_MAP_EMPTY;
 }
 
 bool scr_map_has_str(const ScrMap *m, const ScrStr *key) {
@@ -373,7 +431,7 @@ bool scr_map_has_str(const ScrMap *m, const ScrStr *key) {
 
 static bool scr_map_delete_found(ScrMap *m, size_t e) {
   if (e == SCR_MAP_EMPTY) return false;
-  m->entries[e].live = false; /* bucket slot stays: probe chains intact */
+  m->entries[e].hash = 0; /* bucket slot stays: probe chains intact */
   m->nlive--;
   scr_map_release_key(m, m->entries[e].key);
   scr_map_release_val(m, m->entries[e].val);
@@ -382,7 +440,7 @@ static bool scr_map_delete_found(ScrMap *m, size_t e) {
 
 bool scr_map_delete_f64(ScrMap *m, double key) {
   uint64_t k = scr_map_f64_bits(key);
-  return scr_map_delete_found(m, scr_map_find(m, scr_map_fnv1a((const unsigned char *)&k, 8), k));
+  return scr_map_delete_found(m, scr_map_find(m, scr_map_hash_word(k), k));
 }
 
 bool scr_map_delete_str(ScrMap *m, const ScrStr *key) {
@@ -412,18 +470,28 @@ bool scr_map_delete_ref(ScrMap *m, const void *key) {
  * insertion slot. */
 
 static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
-  size_t e = scr_map_find(m, hash, key);
+  hash = hash ? hash : 1;
+  size_t slot = scr_map_probe(m, hash, key);
+  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) */
     scr_map_release_val(m, old);
     return;
   }
+  size_t old_entries = m->nentries, old_buckets = m->nbuckets;
   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->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;
+  }
   size_t idx = m->nentries++;
   m->entries[idx].key = key;
   m->entries[idx].val = val;
-  m->entries[idx].live = true;
+  m->entries[idx].hash = hash;
   m->nlive++;
   if (m->key_kind == SCR_MAP_KEY_STR) {
     scr_str_retain((ScrStr *)scr_map_slot_to_ptr(key)); /* key is borrowed */
@@ -436,18 +504,21 @@ static void scr_map_set(ScrMap *m, uint64_t hash, uint64_t key, uint64_t val) {
     } else {
       m->key_retain(scr_map_slot_to_ptr(key));
     }
-  } else if (m->key_kind == SCR_MAP_KEY_REF || m->key_kind == SCR_MAP_KEY_UNION_REF) {
+  } else if (m->key_kind == SCR_MAP_KEY_UNION_VALUE &&
+             m->union_keys[((ScrUnion *)scr_map_slot_to_ptr(key))->tag] == SCR_MAP_KEY_F64 &&
+             ((ScrUnion *)scr_map_slot_to_ptr(key))->slot == UINT64_C(0x8000000000000000)) {
+    /* Normalize stored -0 without mutating the caller's immutable box. */
+    ScrUnion *u = scr_map_slot_to_ptr(key);
+    m->entries[idx].key = scr_map_slot_from_ptr(scr_union_new_f64(u->tag, 0));
+  } else if (scr_map_ref_key(m->key_kind)) {
     m->key_retain(scr_map_slot_to_ptr(key)); /* key is borrowed */
   }
-  size_t mask = m->nbuckets - 1;
-  size_t i = hash & mask;
-  while (m->buckets[i] != SCR_MAP_EMPTY) i = (i + 1) & mask;
-  m->buckets[i] = idx;
+  if (m->nbuckets) m->buckets[slot] = idx;
 }
 
 static void scr_map_set_f64_key(ScrMap *m, double key, uint64_t val) {
   uint64_t k = scr_map_f64_bits(key); /* stores +0 for -0, canonical NaN */
-  scr_map_set(m, scr_map_fnv1a((const unsigned char *)&k, 8), k, val);
+  scr_map_set(m, scr_map_hash_word(k), k, val);
 }
 
 static void scr_map_set_str_key(ScrMap *m, ScrStr *key, uint64_t val) {
@@ -501,7 +572,7 @@ ScrMap *scr_set_new_ref(void *(*elem_retain)(void *), void (*elem_release)(void
 
 static size_t scr_map_find_f64(const ScrMap *m, double key) {
   uint64_t k = scr_map_f64_bits(key);
-  return scr_map_find(m, scr_map_fnv1a((const unsigned char *)&k, 8), k);
+  return scr_map_find(m, scr_map_hash_word(k), k);
 }
 
 static size_t scr_map_find_str(const ScrMap *m, const ScrStr *key) {
@@ -568,17 +639,63 @@ void *scr_map_get_ref_ref(const ScrMap *m, const void *key) {
   return m->val_retain(scr_map_slot_to_ptr(m->entries[e].val));
 }
 
+/* Boolean keys use unboxed 0/1 slots and the same probe path. */
+static size_t scr_map_find_bool(const ScrMap *m, bool key) {
+  uint64_t slot = key ? 1 : 0;
+  return scr_map_find(m, scr_map_hash_word(slot), slot);
+}
+
+bool scr_map_has_bool(const ScrMap *m, bool key) {
+  return scr_map_find_bool(m, key) != SCR_MAP_EMPTY;
+}
+
+bool scr_map_delete_bool(ScrMap *m, bool key) {
+  return scr_map_delete_found(m, scr_map_find_bool(m, key));
+}
+
+void scr_map_set_bool_f64(ScrMap *m, bool key, double value) {
+  scr_map_set(m, scr_map_hash_word(key ? 1 : 0), key ? 1 : 0, scr_map_slot_from_f64(value));
+}
+
+void scr_map_set_bool_bool(ScrMap *m, bool key, bool value) {
+  scr_map_set(m, scr_map_hash_word(key ? 1 : 0), key ? 1 : 0, value ? 1 : 0);
+}
+
+void scr_map_set_bool_ref(ScrMap *m, bool key, void *value) {
+  scr_map_set(m, scr_map_hash_word(key ? 1 : 0), key ? 1 : 0, scr_map_slot_from_ptr(value));
+}
+
+bool scr_map_get_bool_f64(const ScrMap *m, bool key, double *out) {
+  size_t entry = scr_map_find_bool(m, key);
+  if (entry == SCR_MAP_EMPTY) return false;
+  *out = scr_map_slot_to_f64(m->entries[entry].val);
+  return true;
+}
+
+bool scr_map_get_bool_bool(const ScrMap *m, bool key, bool *out) {
+  size_t entry = scr_map_find_bool(m, key);
+  if (entry == SCR_MAP_EMPTY) return false;
+  *out = m->entries[entry].val != 0;
+  return true;
+}
+
+void *scr_map_get_bool_ref(const ScrMap *m, bool key) {
+  size_t entry = scr_map_find_bool(m, key);
+  if (entry == SCR_MAP_EMPTY) return NULL;
+  return m->val_retain(scr_map_slot_to_ptr(m->entries[entry].val));
+}
+
 /* ── iteration primitives (the forEach desugar) ────────────────────────── */
 
 double scr_map_iter_count(const ScrMap *m) { return (double)m->nentries; }
 
 bool scr_map_iter_live(const ScrMap *m, double i) {
   if (!(i >= 0) || i >= (double)m->nentries) return false;
-  return m->entries[(size_t)i].live;
+  return m->entries[(size_t)i].hash;
 }
 
 static const ScrMapEntry *scr_map_iter_at(const ScrMap *m, double i) {
-  if (!(i >= 0) || i >= (double)m->nentries || !m->entries[(size_t)i].live) {
+  if (!(i >= 0) || i >= (double)m->nentries || !m->entries[(size_t)i].hash) {
     scr_trap("scriptc: internal error: map iteration index out of range\n");
   }
   return &m->entries[(size_t)i];
@@ -588,6 +705,10 @@ double scr_map_iter_key_f64(const ScrMap *m, double i) {
   return scr_map_slot_to_f64(scr_map_iter_at(m, i)->key);
 }
 
+bool scr_map_iter_key_bool(const ScrMap *m, double i) {
+  return scr_map_iter_at(m, i)->key != 0;
+}
+
 ScrStr *scr_map_iter_key_str(const ScrMap *m, double i) {
   return scr_str_retain((ScrStr *)scr_map_slot_to_ptr(scr_map_iter_at(m, i)->key));
 }
@@ -649,6 +770,68 @@ void scr_map_dyn_set(ScrMap *map, const ScrDyn *key, const ScrDyn *value, bool s
   scr_map_release_key(map, key_slot);
 }
 
+/* Copy only live entries. The source is borrowed, contains unique keys,
+ * and runs no user code while traversed, so cached hashes remain valid. */
+ScrMap *scr_map_clone(const ScrMap *source, bool keys_only) {
+  ScrMap *out = scr_map_new_typed(source->key_kind, keys_only ? SCR_MAP_VAL_F64 : source->val_kind,
+    source->key_retain, source->key_release, source->key_trace,
+    keys_only ? NULL : source->val_retain, keys_only ? NULL : source->val_release,
+    keys_only ? NULL : source->val_trace);
+  out->union_keys = source->union_keys;
+  size_t count = source->nlive;
+  if (!count) return out;
+  if (count > SIZE_MAX / sizeof(ScrMapEntry) || count > SIZE_MAX / 2 / sizeof(size_t)) scr_map_oom();
+  out->entries = malloc(count * sizeof(ScrMapEntry));
+  if (!out->entries) scr_map_oom();
+  out->ecap = count;
+  for (size_t i = 0; i < source->nentries; i++) {
+    const ScrMapEntry *entry = &source->entries[i];
+    if (!entry->hash) continue;
+    ScrMapEntry *copy = &out->entries[out->nentries++];
+    *copy = *entry;
+    if (out->key_kind == SCR_MAP_KEY_STR) scr_str_retain(scr_map_slot_to_ptr(copy->key));
+    else if (scr_map_ref_key(out->key_kind)) out->key_retain(scr_map_slot_to_ptr(copy->key));
+    if (keys_only) copy->val = 0;
+    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();
+    buckets *= 2;
+  }
+  scr_map_rebuild_buckets(out, buckets);
+  return out;
+}
+
+/* A generic view can be backed by typed slots. Its copy must accept new
+ * JavaScript values independently of that backing's narrower adapters. */
+ScrMap *scr_map_clone_dyn(const ScrMap *source, bool keys_only) {
+  ScrMap *out = scr_map_new_typed(SCR_MAP_KEY_DYN, keys_only ? SCR_MAP_VAL_F64 : SCR_MAP_VAL_REF,
+    scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v,
+    keys_only ? NULL : scr_dyn_retain_v, keys_only ? NULL : scr_dyn_release_v,
+    keys_only ? NULL : scr_dyn_trace_v);
+  for (size_t i = 0; i < source->nentries; i++) {
+    if (!source->entries[i].hash) continue;
+    ScrDyn *key = scr_map_dyn_key(source, (double)i);
+    uint64_t value = keys_only ? 0 : scr_map_slot_from_ptr(scr_map_dyn_value(source, (double)i));
+    scr_map_set(out, scr_map_hash_dyn(key), scr_map_slot_from_ptr(key), value);
+    scr_dyn_release(key);
+  }
+  return out;
+}
+
+void scr_map_values_into(ScrMap *set, const ScrMap *source, bool checked) {
+  for (size_t i = 0; i < source->nentries; i++) {
+    if (!source->entries[i].hash) continue;
+    uint64_t value = checked ? scr_map_slot_from_ptr(scr_map_dyn_value(source, (double)i)) : source->entries[i].val;
+    if (set->key_kind == SCR_MAP_KEY_F64) value = scr_map_f64_bits(scr_map_slot_to_f64(value));
+    scr_map_set(set, scr_map_hash_key(set, value), value, 0);
+    if (checked) scr_dyn_release(scr_map_slot_to_ptr(value));
+  }
+}
+
 ScrArr *scr_set_to_arr_dyn(const ScrMap *map) {
   ScrArr *out = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, map->nlive);
   for (size_t i = 0; i < map->nentries; i++) {
@@ -683,14 +866,23 @@ void scr_map_iter_exit(ScrMap *m) {
 void scr_set_add_all(ScrMap *set, ScrArr *values) {
   size_t n = values->len;
   for (size_t i = 0; i < n; i++) {
-    if (values->elem == SCR_ELEM_STR) {
+    /* Packed values stay owned by the seed array throughout construction.
+     * Avoid taking a temporary owner only to release it after insertion.
+     * Sparse/missing positions retain the existing accessor semantics. */
+    if (i < values->cap && values->present[i] == SCR_ARR_VALUE) {
+      uint64_t key = values->data[i];
+      if (set->key_kind == SCR_MAP_KEY_F64) key = scr_map_f64_bits(scr_map_slot_to_f64(key));
+      scr_map_set(set, scr_map_hash_key(set, key), key, 0);
+    } else if (values->elem == SCR_ELEM_STR) {
       ScrStr *s = (ScrStr *)scr_arr_get_ref(values, (double)i); /* +1 */
       scr_map_set_str_f64(set, s, 0);                           /* borrows; retains stored copy */
       scr_str_release(s);
-    } else if (set->key_kind == SCR_MAP_KEY_REF || set->key_kind == SCR_MAP_KEY_UNION_REF || set->key_kind == SCR_MAP_KEY_DYN) {
+    } else if (scr_map_ref_key(set->key_kind)) {
       void *p = scr_arr_get_ref(values, (double)i); /* +1 */
       scr_map_set_ref_f64(set, p, 0);               /* borrows; retains stored copy */
       set->key_release(p);
+    } else if (set->key_kind == SCR_MAP_KEY_BOOL) {
+      scr_map_set_bool_f64(set, scr_arr_get_bool(values, (double)i), 0);
     } else {
       scr_map_set_f64_f64(set, scr_arr_get_f64(values, (double)i), 0);
     }
@@ -702,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->entries[i].live) 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();
+  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 *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++) {
-    if (!m->entries[i].live) 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));
+  free(indices);
+  for (size_t i = 0; i < m->nentries; i++) {
+    if (!m->entries[i].hash) continue;
+    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