@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

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) ──────────────────────────── */
@@ -199,27 +187,186 @@ static bool scr_map_key_eq(const ScrMap *m, uint64_t stored, uint64_t probe) {
  * 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) {
+typedef enum { SCR_MAP_LOOKUP_STR, SCR_MAP_LOOKUP_SPAN, SCR_MAP_LOOKUP_WORD, SCR_MAP_LOOKUP_GENERIC } ScrMapLookup;
+
+typedef struct { const char *bytes; size_t length; } ScrMapSpan;
+
+/* Choose equality once per operation. Inlining the traversal with a constant
+ * lookup kind keeps the ordinary string/word probe free of key-kind dispatch,
+ * while boxed keys retain their complete value/identity semantics. */
+static inline bool scr_map_lookup_eq(const ScrMap *m, uint64_t stored, uint64_t key,
+                                     ScrMapLookup lookup) {
+  if (lookup == SCR_MAP_LOOKUP_WORD) return stored == key;
+  if (lookup == SCR_MAP_LOOKUP_SPAN) {
+    const ScrStr *a = scr_map_slot_to_ptr(stored);
+    const ScrMapSpan *b = scr_map_slot_to_ptr(key);
+    return a->len == b->length && scr_key_equal(a->data, b->bytes, a->len);
+  }
+  if (lookup == SCR_MAP_LOOKUP_STR) {
+    const ScrStr *a = scr_map_slot_to_ptr(stored);
+    const ScrStr *b = scr_map_slot_to_ptr(key);
+    return a == b || (a->len == b->len && scr_key_equal(a->data, b->data, a->len));
+  }
+  return scr_map_key_eq(m, stored, key);
+}
+
+/* Compact tables keep a hash fingerprint beside each 24-bit entry index.
+ * Rejecting a collision here avoids loading an unrelated ordered entry.
+ * Larger tables keep full-width indices; collection size remains limited
+ * only by the allocator. Zero is empty in compact tables, so store index+1. */
+#ifndef SCR_MAP_COMPACT_BUCKETS
+#define SCR_MAP_COMPACT_BUCKETS ((size_t)1 << 24)
+#endif
+_Static_assert(SCR_MAP_COMPACT_BUCKETS >= 16 &&
+               SCR_MAP_COMPACT_BUCKETS <= ((size_t)1 << 24) &&
+               (SCR_MAP_COMPACT_BUCKETS & (SCR_MAP_COMPACT_BUCKETS - 1)) == 0,
+               "compact bucket capacity must leave room for every tagged index");
+#define SCR_MAP_INDEX_MASK UINT32_C(0x00ffffff)
+
+static bool scr_map_compact_buckets(size_t count) {
+  return count <= SCR_MAP_COMPACT_BUCKETS;
+}
+
+static size_t scr_map_bucket(const ScrMap *m, size_t slot) {
+  if (scr_map_compact_buckets(m->nbuckets)) {
+    uint32_t index = ((const uint32_t *)m->buckets)[slot] & SCR_MAP_INDEX_MASK;
+    return index ? (size_t)index - 1 : SCR_MAP_EMPTY;
+  }
+  return ((const size_t *)m->buckets)[slot];
+}
+
+static void scr_map_bucket_set(ScrMap *m, size_t slot, size_t entry, uint64_t hash) {
+  if (scr_map_compact_buckets(m->nbuckets)) {
+    ((uint32_t *)m->buckets)[slot] = (uint32_t)(entry + 1) | (uint32_t)(hash >> 32 & UINT32_C(0xff000000));
+  } else {
+    ((size_t *)m->buckets)[slot] = entry;
+  }
+}
+
+static inline __attribute__((always_inline)) size_t scr_map_probe_with(
+    const ScrMap *m, uint64_t hash, uint64_t key, ScrMapLookup lookup) {
   if (m->nbuckets == 0) return SCR_MAP_EMPTY;
   size_t mask = m->nbuckets - 1;
+  if (scr_map_compact_buckets(m->nbuckets)) {
+    const uint32_t *buckets = m->buckets;
+    uint32_t tag = (uint32_t)(hash >> 32 & UINT32_C(0xff000000));
+    for (size_t i = hash & mask;; i = (i + 1) & mask) {
+      uint32_t bucket = buckets[i];
+      if (!bucket) return i;
+      if ((bucket & ~SCR_MAP_INDEX_MASK) != tag) continue;
+      size_t b = (bucket & SCR_MAP_INDEX_MASK) - 1;
+      if (m->entries[b].hash == hash && scr_map_lookup_eq(m, m->entries[b].key, key, lookup)) return i;
+    }
+  }
+  const size_t *buckets = m->buckets;
   for (size_t i = hash & mask;; i = (i + 1) & mask) {
-    size_t b = m->buckets[i];
+    size_t b = buckets[i];
     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;
+    if (m->entries[b].hash == hash && scr_map_lookup_eq(m, m->entries[b].key, key, lookup)) 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 inline __attribute__((always_inline)) size_t scr_map_find_with(
+    const ScrMap *m, uint64_t hash, uint64_t key, ScrMapLookup lookup) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  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_lookup_eq(m, m->entries[e].key, key, lookup)) return e;
+    }
+    return SCR_MAP_EMPTY;
+  }
+  size_t slot = scr_map_probe_with(m, hash, key, lookup);
+  return slot == SCR_MAP_EMPTY ? SCR_MAP_EMPTY : scr_map_bucket(m, slot);
+}
+
+static ScrMapLookup scr_map_lookup_kind(const ScrMap *m) {
+  switch (m->key_kind) {
+  case SCR_MAP_KEY_STR: return SCR_MAP_LOOKUP_STR;
+  case SCR_MAP_KEY_F64:
+  case SCR_MAP_KEY_BOOL:
+  case SCR_MAP_KEY_REF:
+  case SCR_MAP_KEY_NULL:
+  case SCR_MAP_KEY_UNDEFINED: return SCR_MAP_LOOKUP_WORD;
+  default: return SCR_MAP_LOOKUP_GENERIC;
+  }
+}
+
+static size_t scr_map_probe(const ScrMap *m, uint64_t hash, uint64_t key) {
+  switch (scr_map_lookup_kind(m)) {
+  case SCR_MAP_LOOKUP_STR: return scr_map_probe_with(m, hash, key, SCR_MAP_LOOKUP_STR);
+  case SCR_MAP_LOOKUP_WORD: return scr_map_probe_with(m, hash, key, SCR_MAP_LOOKUP_WORD);
+  default: return scr_map_probe_with(m, hash, key, SCR_MAP_LOOKUP_GENERIC);
   }
 }
 
 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);
-  return slot == SCR_MAP_EMPTY ? SCR_MAP_EMPTY : m->buckets[slot];
+  switch (scr_map_lookup_kind(m)) {
+  case SCR_MAP_LOOKUP_STR: return scr_map_find_with(m, hash, key, SCR_MAP_LOOKUP_STR);
+  case SCR_MAP_LOOKUP_WORD: return scr_map_find_with(m, hash, key, SCR_MAP_LOOKUP_WORD);
+  default: return scr_map_find_with(m, hash, key, SCR_MAP_LOOKUP_GENERIC);
+  }
+}
+
+static size_t scr_map_find_f64(const ScrMap *m, double key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  uint64_t k = scr_map_f64_bits(key);
+  return scr_map_find_with(m, scr_map_hash_word(k), k, SCR_MAP_LOOKUP_WORD);
+}
+
+static size_t scr_map_find_str(const ScrMap *m, const ScrStr *key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  if (m->nbuckets == 0) {
+    uint64_t k = scr_map_slot_from_ptr((void *)key);
+    for (size_t e = 0; e < m->nentries; e++) {
+      if (m->entries[e].hash && scr_map_lookup_eq(m, m->entries[e].key, k, SCR_MAP_LOOKUP_STR)) return e;
+    }
+    return SCR_MAP_EMPTY;
+  }
+  return scr_map_find_with(m, scr_map_hash_str(key), scr_map_slot_from_ptr((void *)key),
+                           SCR_MAP_LOOKUP_STR);
+}
+
+/* A transient input span follows the same hash, equality and ownership
+ * rules as a string key without allocating or copying the probe. */
+static size_t scr_map_find_span(const ScrMap *m, const char *bytes, size_t length) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
+  ScrMapSpan key = { bytes, length };
+  return scr_map_find_with(m, scr_key_hash(bytes, length), scr_map_slot_from_ptr(&key),
+                           SCR_MAP_LOOKUP_SPAN);
+}
+
+bool scr_map_get_span_f64(const ScrMap *m, const char *bytes, size_t length, double *out) {
+  size_t e = scr_map_find_span(m, bytes, length);
+  if (e == SCR_MAP_EMPTY) return false;
+  *out = scr_map_slot_to_f64(m->entries[e].val);
+  return true;
+}
+
+bool scr_map_get_span_bool(const ScrMap *m, const char *bytes, size_t length, bool *out) {
+  size_t e = scr_map_find_span(m, bytes, length);
+  if (e == SCR_MAP_EMPTY) return false;
+  *out = m->entries[e].val != 0;
+  return true;
+}
+
+void *scr_map_get_span_ref(const ScrMap *m, const char *bytes, size_t length) {
+  size_t e = scr_map_find_span(m, bytes, length);
+  return e == SCR_MAP_EMPTY ? NULL : m->val_retain(scr_map_slot_to_ptr(m->entries[e].val));
 }
 
 /* Rebuild the bucket table (size must be a power of two >= 2 * nentries):
  * only live entries are inserted, in dense order — dead markers vanish. */
 static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) {
-  size_t *buckets = malloc(nbuckets * sizeof *buckets);
+  bool compact = scr_map_compact_buckets(nbuckets);
+  size_t bytes = nbuckets * (compact ? sizeof(uint32_t) : sizeof(size_t));
+  void *buckets = malloc(bytes);
   if (!buckets) scr_map_oom();
-  for (size_t i = 0; i < nbuckets; i++) buckets[i] = SCR_MAP_EMPTY;
+  memset(buckets, compact ? 0 : 0xff, bytes);
   free(m->buckets);
   m->buckets = buckets;
   m->nbuckets = nbuckets;
@@ -228,8 +375,8 @@ static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) {
     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;
+    while (scr_map_bucket(m, i) != SCR_MAP_EMPTY) i = (i + 1) & mask;
+    scr_map_bucket_set(m, i, e, hash);
   }
 }
 
@@ -248,12 +395,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 +413,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)) {
@@ -367,23 +518,28 @@ ScrMap *scr_map_retain(ScrMap *m) {
   return m;
 }
 
+static void scr_map_destroy(void *object) {
+  ScrMap *m = object;
+  scr_weak_dispose(m);
+  for (size_t e = 0; e < m->nentries; e++) {
+    if (!m->entries[e].hash) continue;
+    scr_map_release_key(m, m->entries[e].key);
+    scr_map_release_val(m, m->entries[e].val);
+  }
+  free(m->entries);
+  free(m->buckets);
+#ifdef SCR_RC_AUDIT
+  scr_live_maps--;
+#endif
+  if (m->key_trace || m->val_trace) scr_cyc_free(m);
+  else free(m);
+}
+
 void scr_map_release(ScrMap *m) {
   if (!m || m->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
   if (--m->rc == 0) {
-    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].hash) continue;
-      scr_map_release_key(m, m->entries[e].key);
-      scr_map_release_val(m, m->entries[e].val);
-    }
-    free(m->entries);
-    free(m->buckets);
-#ifdef SCR_RC_AUDIT
-    scr_live_maps--;
-#endif
-    if (m->key_trace || m->val_trace) scr_cyc_free(m);
-    else free(m);
+    scr_rc_destroy(m, scr_map_destroy);
   } else if (m->key_trace || m->val_trace) {
     scr_cyc_on_release(m); /* possible cycle root; may collect — m is done */
   }
@@ -411,19 +567,21 @@ void scr_map_clear(ScrMap *m) {
      * after the clear append past them and ARE visited (Node-exact). */
     m->nentries = 0;
   }
-  for (size_t i = 0; i < m->nbuckets; i++) m->buckets[i] = SCR_MAP_EMPTY;
+  if (m->nbuckets) {
+    bool compact = scr_map_compact_buckets(m->nbuckets);
+    memset(m->buckets, compact ? 0 : 0xff,
+           m->nbuckets * (compact ? sizeof(uint32_t) : sizeof(size_t)));
+  }
 }
 
 /* ── has / delete ──────────────────────────────────────────────────────── */
 
 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_hash_word(k), k) != SCR_MAP_EMPTY;
+  return scr_map_find_f64(m, key) != SCR_MAP_EMPTY;
 }
 
 bool scr_map_has_str(const ScrMap *m, const ScrStr *key) {
-  uint64_t k = scr_map_slot_from_ptr((void *)key);
-  return scr_map_find(m, scr_map_hash_str(key), k) != SCR_MAP_EMPTY;
+  return scr_map_find_str(m, key) != SCR_MAP_EMPTY;
 }
 
 static bool scr_map_delete_found(ScrMap *m, size_t e) {
@@ -436,19 +594,21 @@ 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_hash_word(k), k));
+  return scr_map_delete_found(m, scr_map_find_f64(m, key));
 }
 
 bool scr_map_delete_str(ScrMap *m, const ScrStr *key) {
-  uint64_t k = scr_map_slot_from_ptr((void *)key);
-  return scr_map_delete_found(m, scr_map_find(m, scr_map_hash_str(key), k));
+  return scr_map_delete_found(m, scr_map_find_str(m, key));
 }
 
 /* REF keys: identity hashing over the pointer bits (see the header's
  * SCR_MAP_KEY_REF note). Probes never retain; storage does. */
 static size_t scr_map_find_ref(const ScrMap *m, const void *key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
   uint64_t k = scr_map_slot_from_ptr((void *)key);
+  if (m->key_kind == SCR_MAP_KEY_REF) {
+    return scr_map_find_with(m, scr_map_hash_word(k), k, SCR_MAP_LOOKUP_WORD);
+  }
   return scr_map_find(m, scr_map_hash_key(m, k), k);
 }
 
@@ -469,7 +629,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) : scr_map_bucket(m, slot);
   if (e != SCR_MAP_EMPTY) {
     uint64_t old = m->entries[e].val;
     m->entries[e].val = val; /* unlink before releasing (cycle collector) */
@@ -480,10 +640,10 @@ 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;
+    while (scr_map_bucket(m, slot) != SCR_MAP_EMPTY) slot = (slot + 1) & mask;
   }
   size_t idx = m->nentries++;
   m->entries[idx].key = key;
@@ -510,7 +670,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) scr_map_bucket_set(m, slot, idx, hash);
 }
 
 static void scr_map_set_f64_key(ScrMap *m, double key, uint64_t val) {
@@ -567,15 +727,6 @@ ScrMap *scr_set_new_ref(void *(*elem_retain)(void *), void (*elem_release)(void
 
 /* ── get ───────────────────────────────────────────────────────────────── */
 
-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_hash_word(k), k);
-}
-
-static size_t scr_map_find_str(const ScrMap *m, const ScrStr *key) {
-  return scr_map_find(m, scr_map_hash_str(key), scr_map_slot_from_ptr((void *)key));
-}
-
 bool scr_map_get_f64_f64(const ScrMap *m, double key, double *out) {
   size_t e = scr_map_find_f64(m, key);
   if (e == SCR_MAP_EMPTY) return false;
@@ -638,8 +789,9 @@ void *scr_map_get_ref_ref(const ScrMap *m, const void *key) {
 
 /* Boolean keys use unboxed 0/1 slots and the same probe path. */
 static size_t scr_map_find_bool(const ScrMap *m, bool key) {
+  if (m->nlive == 0) return SCR_MAP_EMPTY;
   uint64_t slot = key ? 1 : 0;
-  return scr_map_find(m, scr_map_hash_word(slot), slot);
+  return scr_map_find_with(m, scr_map_hash_word(slot), slot, SCR_MAP_LOOKUP_WORD);
 }
 
 bool scr_map_has_bool(const ScrMap *m, bool key) {
@@ -792,6 +944,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 +1043,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();
-    }
-    size_t j = nidx++;
-    while (j > 0 && idx[j - 1].v > v) {
-      idx[j] = idx[j - 1];
-      j--;
+    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();
     }
-    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;
 }