@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

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

@@ -1,4 +1,5 @@
 #include "scr_runtime.h"
+#include "scr_key.h"
 
 #include <math.h>
 #include <stdio.h>
@@ -72,6 +73,7 @@ typedef struct ScrSidx {
   const ScrStr *s;       /* NULL = empty slot */
   size_t u16len;         /* SCR_U16_UNKNOWN until the whole current string */
   size_t cu, cb;         /* hot cursor: cb starts the char at unit cu */
+  size_t ascii_cu, ascii_cb, ascii_end; /* bounded, proven identity span */
   ScrSidxPoint *points;  /* sparse, ordered code-point-boundary anchors */
   size_t npoints, cap;   /* owned points length/capacity */
   size_t indexed_cu;     /* exact contiguous prefix indexed from byte zero */
@@ -87,17 +89,25 @@ static SCR_TL ScrSidx scr_sidx_sparse_tab[SCR_SIDX_N];
 static SCR_TL ScrSidx scr_sidx_cursor_tab[SCR_SIDX_N];
 static SCR_TL unsigned scr_sidx_sparse_clock;
 static SCR_TL unsigned scr_sidx_cursor_clock;
+static SCR_TL unsigned scr_sidx_sparse_live;
 static SCR_TL bool scr_sidx_cleanup_registered;
+/* Counts both tiers, independent of the wrapping eviction clocks. A transfer
+ * moves one active entry; only clearing or initializing changes the count. */
+static SCR_TL size_t scr_sidx_active;
 
-static void scr_sidx_clear(ScrSidx *e) {
+static void scr_sidx_clear(ScrSidx *e, unsigned *live) {
+  if (e->s) {
+    scr_sidx_active--;
+    if (live) (*live)--;
+  }
   free(e->points);
   memset(e, 0, sizeof(*e));
 }
 
 static void scr_sidx_reset_all(void) {
   for (int i = 0; i < SCR_SIDX_N; i++) {
-    scr_sidx_clear(&scr_sidx_sparse_tab[i]);
-    scr_sidx_clear(&scr_sidx_cursor_tab[i]);
+    scr_sidx_clear(&scr_sidx_sparse_tab[i], &scr_sidx_sparse_live);
+    scr_sidx_clear(&scr_sidx_cursor_tab[i], NULL);
   }
   scr_sidx_sparse_clock = 0;
   scr_sidx_cursor_clock = 0;
@@ -112,9 +122,15 @@ static void scr_sidx_register_cleanup(void) {
 
 #ifdef SCR_SIDX_TEST
 static SCR_TL size_t scr_sidx_walk_steps;
-void scr_sidx_test_reset_steps(void) { scr_sidx_walk_steps = 0; }
+static SCR_TL size_t scr_sidx_searches;
+void scr_sidx_test_reset_steps(void) {
+  scr_sidx_walk_steps = 0;
+  scr_sidx_searches = 0;
+}
 size_t scr_sidx_test_walk_steps(void) { return scr_sidx_walk_steps; }
+size_t scr_sidx_test_searches(void) { return scr_sidx_searches; }
 void scr_sidx_test_reset_cache(void) { scr_sidx_reset_all(); }
+size_t scr_sidx_test_active(void) { return scr_sidx_active; }
 size_t scr_sidx_test_entries(void) {
   size_t n = 0;
   for (int i = 0; i < SCR_SIDX_N; i++)
@@ -128,28 +144,54 @@ size_t scr_sidx_test_points(void) {
   return n;
 }
 #define SCR_SIDX_STEP() (scr_sidx_walk_steps++)
+#define SCR_SIDX_SEARCH() (scr_sidx_searches++)
 #else
 #define SCR_SIDX_STEP() ((void)0)
+#define SCR_SIDX_SEARCH() ((void)0)
 #endif
 
-static void scr_sidx_purge(const ScrStr *s) {
+/* Share cleanup across release and scratch reuse; callers inline only the
+ * empty-cache check. */
+static __attribute__((noinline)) void scr_sidx_purge_active(const ScrStr *s) {
   /* These are deliberately fixed four-entry tables, never an unbounded
    * receiver registry. Releasing an unrelated temporary therefore does at
    * most eight pointer comparisons and cannot grow with live strings. */
   for (int i = 0; i < SCR_SIDX_N; i++) {
     if (scr_sidx_sparse_tab[i].s == s)
-      scr_sidx_clear(&scr_sidx_sparse_tab[i]);
+      scr_sidx_clear(&scr_sidx_sparse_tab[i], &scr_sidx_sparse_live);
     if (scr_sidx_cursor_tab[i].s == s)
-      scr_sidx_clear(&scr_sidx_cursor_tab[i]);
+      scr_sidx_clear(&scr_sidx_cursor_tab[i], NULL);
   }
 }
 
-static void scr_sidx_init(ScrSidx *e, const ScrStr *s) {
+static void scr_sidx_purge(const ScrStr *s) {
+  if (scr_sidx_active) scr_sidx_purge_active(s);
+}
+
+static void scr_sidx_init(ScrSidx *e, const ScrStr *s, unsigned *live) {
   memset(e, 0, sizeof(*e));
   e->s = s;
+  scr_sidx_active++;
+  if (live) (*live)++;
   e->u16len = SCR_U16_UNKNOWN;
 }
 
+/* Reuse sparse-tier holes left by short-lived receivers before evicting a live index.
+ * Round-robin eviction remains bounded when every slot is occupied. */
+static ScrSidx *scr_sidx_claim(ScrSidx *table, unsigned *clock, unsigned *live) {
+  /* A full tier needs no second slot scan after the failed lookup. */
+  for (size_t offset = 0; *live < SCR_SIDX_N && offset < SCR_SIDX_N; offset++) {
+    size_t index = (*clock + offset) % SCR_SIDX_N;
+    if (!table[index].s) {
+      *clock = (unsigned)(index + 1);
+      return &table[index];
+    }
+  }
+  ScrSidx *entry = &table[(*clock)++ % SCR_SIDX_N];
+  scr_sidx_clear(entry, live);
+  return entry;
+}
+
 /* Short strings retain the historical hot cursor without contending with the
  * sparse residency. Large strings claim only the sparse tier; an in-place
  * append that crosses the threshold moves its exact cursor frontier into
@@ -170,17 +212,14 @@ static ScrSidx *scr_sidx(const ScrStr *s) {
     for (int i = 0; i < SCR_SIDX_N; i++) {
       ScrSidx *old = &scr_sidx_cursor_tab[i];
       if (old->s != s) continue;
-      ScrSidx *e = &scr_sidx_sparse_tab[
-          scr_sidx_sparse_clock++ % SCR_SIDX_N];
-      scr_sidx_clear(e);
+      ScrSidx *e = scr_sidx_claim(scr_sidx_sparse_tab, &scr_sidx_sparse_clock, &scr_sidx_sparse_live);
       *e = *old;
+      scr_sidx_sparse_live++;
       memset(old, 0, sizeof(*old)); /* ownership moved to the sparse tier */
       return e;
     }
-    ScrSidx *e =
-        &scr_sidx_sparse_tab[scr_sidx_sparse_clock++ % SCR_SIDX_N];
-    scr_sidx_clear(e);
-    scr_sidx_init(e, s);
+    ScrSidx *e = scr_sidx_claim(scr_sidx_sparse_tab, &scr_sidx_sparse_clock, &scr_sidx_sparse_live);
+    scr_sidx_init(e, s, &scr_sidx_sparse_live);
     return e;
   }
   ScrSidx *tab = scr_sidx_cursor_tab;
@@ -189,8 +228,8 @@ static ScrSidx *scr_sidx(const ScrStr *s) {
     if (tab[i].s == s) return &tab[i];
   }
   ScrSidx *e = &tab[(*clock)++ % SCR_SIDX_N];
-  scr_sidx_clear(e);
-  scr_sidx_init(e, s);
+  scr_sidx_clear(e, NULL);
+  scr_sidx_init(e, s, NULL);
   return e;
 }
 
@@ -200,6 +239,7 @@ static ScrSidx *scr_sidx(const ScrStr *s) {
  * receiver may move from the cursor tier to the sparse tier on its next
  * lookup, so invalidate either possible entry. */
 static void scr_sidx_concat_append(const ScrStr *s, size_t oldlen) {
+  if (scr_sidx_active == 0) return;
   for (int i = 0; i < SCR_SIDX_N; i++) {
     ScrSidx *entries[] = {&scr_sidx_sparse_tab[i], &scr_sidx_cursor_tab[i]};
     for (size_t j = 0; j < sizeof(entries) / sizeof(entries[0]); j++) {
@@ -373,7 +413,7 @@ ScrStr *scr_str_concat_parts(ScrStr *const *parts, size_t count) {
 }
 
 bool scr_str_eq(ScrStr *a, ScrStr *b) {
-  return a == b || (a->len == b->len && memcmp(a->data, b->data, a->len) == 0);
+  return a == b || (a->len == b->len && scr_key_equal(a->data, b->data, a->len));
 }
 
 int scr_str_cmp(ScrStr *a, ScrStr *b) {
@@ -383,62 +423,29 @@ int scr_str_cmp(ScrStr *a, ScrStr *b) {
   return a->len < b->len ? -1 : (a->len > b->len ? 1 : 0);
 }
 
-/* UTF-16 code-unit comparison over well-formed UTF-8 (the default
- * Array.sort/toSorted and URLSearchParams.sort order). Byte order ALMOST
- * matches — the exception is U+E000..U+FFFF (3-byte UTF-8, single high code
- * units) vs supplementary code points (4-byte UTF-8, surrogate pairs
- * 0xD800..0xDFFF): bytes put the 4-byte form last, code units put it first.
- * Decode code points and compare their leading UTF-16 units. */
-static uint32_t scr_str_lead_u16(const unsigned char *s, size_t len,
-                                size_t *adv) {
-  unsigned char b = s[0];
-  uint32_t cp;
-  size_t n;
-  if (b < 0x80) {
-    cp = b; n = 1;
-  } else if ((b & 0xe0) == 0xc0) {
-    cp = b & 0x1fu; n = 2;
-  } else if ((b & 0xf0) == 0xe0) {
-    cp = b & 0x0fu; n = 3;
-  } else {
-    cp = b & 0x07u; n = 4;
-  }
-  if (n > len) n = len; /* defensive: strings are well-formed by contract */
-  for (size_t i = 1; i < n; i++) cp = (cp << 6) | (s[i] & 0x3fu);
-  *adv = n;
-  if (cp >= 0x10000) return 0xd800 + ((cp - 0x10000) >> 10);
-  return cp;
-}
-
+/* UTF-16 ordering over well-formed UTF-8. Equal bytes can be skipped even
+ * inside a multibyte character: unequal continuation bytes preserve code
+ * point order. Only differing lead bytes for U+E000..U+FFFF versus a
+ * supplementary character reverse byte order, because the latter starts
+ * with a UTF-16 high surrogate below U+E000. */
 int scr_str_cmp_u16(ScrStr *a, ScrStr *b) {
-  size_t ia = 0, ib = 0;
-  while (ia < a->len && ib < b->len) {
-    size_t na, nb;
-    uint32_t ua = scr_str_lead_u16(
-        (const unsigned char *)a->data + ia, a->len - ia, &na);
-    uint32_t ub = scr_str_lead_u16(
-        (const unsigned char *)b->data + ib, b->len - ib, &nb);
-    if (ua != ub) return ua < ub ? -1 : 1;
-    /* Equal leading units: equal whole code points (both single units or
-     * both pairs with equal highs — lows only differ if cps differ). */
-    if (na == 4 && nb == 4) {
-      uint32_t cpa = 0, cpb = 0;
-      for (size_t i = 0; i < 4; i++) {
-        cpa = (cpa << 6) |
-              (i == 0 ? (unsigned char)a->data[ia] & 0x07u
-                      : (unsigned char)a->data[ia + i] & 0x3fu);
-        cpb = (cpb << 6) |
-              (i == 0 ? (unsigned char)b->data[ib] & 0x07u
-                      : (unsigned char)b->data[ib + i] & 0x3fu);
-      }
-      if (cpa != cpb) return cpa < cpb ? -1 : 1;
-    }
-    ia += na;
-    ib += nb;
-  }
-  if (ia < a->len) return 1;
-  if (ib < b->len) return -1;
-  return 0;
+  if (a == b) return 0;
+  size_t common = a->len < b->len ? a->len : b->len;
+  size_t i = 0;
+  while (common - i >= sizeof(uint64_t)) {
+    uint64_t left, right;
+    memcpy(&left, a->data + i, sizeof(left));
+    memcpy(&right, b->data + i, sizeof(right));
+    if (left != right) break;
+    i += sizeof(left);
+  }
+  while (i < common && a->data[i] == b->data[i]) i++;
+  if (i == common) return (a->len > b->len) - (a->len < b->len);
+  unsigned char left = (unsigned char)a->data[i];
+  unsigned char right = (unsigned char)b->data[i];
+  if (left >= 0xf0 && right >= 0xee && right <= 0xef) return -1;
+  if (right >= 0xf0 && left >= 0xee && left <= 0xef) return 1;
+  return left < right ? -1 : 1;
 }
 
 /* ── interned strings ─────────────────────────────────────────────────
@@ -779,9 +786,14 @@ static size_t scr_sidx_abs_diff(size_t a, size_t b) {
  * sufficient; the hot cursor retains sequential-access locality. */
 static ScrSidxPoint scr_sidx_near_u16(const ScrStr *s, const ScrSidx *e,
                                       size_t u16) {
+  /* A nearby cursor already bounds the walk. Searching the complete index
+   * first would make each sequential read depend on the receiver's size. */
+  if (e->cb <= s->len && scr_sidx_abs_diff(e->cu, u16) <= 16)
+    return (ScrSidxPoint){e->cu, e->cb};
   ScrSidxPoint best = {0, 0};
   size_t best_dist = u16;
   if (e->npoints != 0) {
+    SCR_SIDX_SEARCH();
     size_t lo = 0, hi = e->npoints;
     while (lo < hi) {
       size_t m = lo + (hi - lo) / 2;
@@ -812,9 +824,12 @@ static ScrSidxPoint scr_sidx_near_u16(const ScrStr *s, const ScrSidx *e,
 
 static ScrSidxPoint scr_sidx_near_byte(const ScrStr *s, const ScrSidx *e,
                                        size_t byte_off) {
+  if (e->cb <= s->len && scr_sidx_abs_diff(e->cb, byte_off) <= 16)
+    return (ScrSidxPoint){e->cu, e->cb};
   ScrSidxPoint best = {0, 0};
   size_t best_dist = byte_off;
   if (e->npoints != 0) {
+    SCR_SIDX_SEARCH();
     size_t lo = 0, hi = e->npoints;
     while (lo < hi) {
       size_t m = lo + (hi - lo) / 2;
@@ -843,6 +858,36 @@ static ScrSidxPoint scr_sidx_near_byte(const ScrStr *s, const ScrSidx *e,
   return best;
 }
 
+/* Cache only a bounded ASCII run at a resolved boundary. Local scans then
+ * use arithmetic even inside a mixed string. The bytes are immutable except
+ * for append, which preserves this prefix; eviction/reallocation clears the
+ * whole entry. No scan reads outside the receiver or allocates metadata. */
+static void scr_sidx_ascii_run(const ScrStr *s, ScrSidx *e) {
+  size_t start = e->cb, end = start;
+  /* Center the window on the access so reverse scans reuse it too. A
+   * forward-only window would rescan its full width on every backward read. */
+  size_t lower = start < 128 ? 0 : start - 128;
+  while (start - lower >= 8) {
+    uint64_t word;
+    memcpy(&word, s->data + start - 8, 8);
+    if (word & UINT64_C(0x8080808080808080)) break;
+    start -= 8;
+  }
+  while (start > lower && (unsigned char)s->data[start - 1] < 0x80) start--;
+  size_t remaining = s->len - end;
+  size_t limit = end + (remaining < 128 ? remaining : 128);
+  while (limit - end >= 8) {
+    uint64_t word;
+    memcpy(&word, s->data + end, 8);
+    if (word & UINT64_C(0x8080808080808080)) break;
+    end += 8;
+  }
+  while (end < limit && (unsigned char)s->data[end] < 0x80) end++;
+  e->ascii_cu = e->cu - (e->cb - start);
+  e->ascii_cb = start;
+  e->ascii_end = end;
+}
+
 /* Convert a UTF-16 index to a byte offset from the closest sparse anchor or
  * hot cursor. If u16 addresses the second (low-surrogate) unit of
  * an astral char, *mid is set and the returned offset is the START of that
@@ -854,6 +899,12 @@ static size_t scr_u16_to_byte_c(const ScrStr *s, ScrSidx *e, size_t u16,
     *mid = false;
     return u16 < s->len ? u16 : s->len;
   }
+  if (u16 >= e->ascii_cu && u16 - e->ascii_cu < e->ascii_end - e->ascii_cb) {
+    e->cb = e->ascii_cb + (u16 - e->ascii_cu);
+    e->cu = u16;
+    *mid = false;
+    return e->cb;
+  }
   scr_sidx_extend_to_u16(s, e, u16);
   /* Extending a far-end lookup can just have proved identity. Do not
    * materialize an index that the identity fast path will never consult. */
@@ -864,9 +915,31 @@ static size_t scr_u16_to_byte_c(const ScrStr *s, ScrSidx *e, size_t u16,
   scr_sidx_materialize_identity_prefix(s, e);
   ScrSidxPoint near = scr_sidx_near_u16(s, e, u16);
   size_t cu = near.cu, cb = near.cb;
-  while (cu > u16) scr_sidx_back(s, &cu, &cb);
+  while (cu > u16) {
+    /* Eight bytes starting inside a sequence can reach back at most three
+     * more bytes to its lead. Such a span contains at most nine UTF-16
+     * units (seven ASCII bytes plus an astral pair), so it cannot overshoot
+     * a target at least nine units away. */
+    if (cu - u16 >= 9 && cb >= 8) {
+      size_t start = cb - 8;
+      while (start > 0 && ((unsigned char)s->data[start] & 0xC0) == 0x80)
+        start--;
+      cu -= scr_utf16_units_span(s->data + start, cb - start, NULL);
+      cb = start;
+    } else {
+      scr_sidx_back(s, &cu, &cb);
+    }
+  }
   bool m = false;
   while (cu < u16 && cb < s->len) {
+    if (u16 - cu >= 9 && s->len - cb >= 8) {
+      size_t end = cb + 8;
+      while (end < s->len && ((unsigned char)s->data[end] & 0xC0) == 0x80)
+        end++;
+      cu += scr_utf16_units_span(s->data + cb, end - cb, NULL);
+      cb = end;
+      continue;
+    }
     SCR_SIDX_STEP();
     size_t seq = scr_utf8_seq_len((unsigned char)s->data[cb]);
     size_t w = seq == 4 ? 2 : 1;
@@ -879,6 +952,8 @@ static size_t scr_u16_to_byte_c(const ScrStr *s, ScrSidx *e, size_t u16,
   }
   e->cu = cu;
   e->cb = cb;
+  if (cb < s->len && (unsigned char)s->data[cb] < 0x80)
+    scr_sidx_ascii_run(s, e);
   *mid = m;
   return cb;
 }
@@ -888,6 +963,11 @@ static size_t scr_u16_to_byte_c(const ScrStr *s, ScrSidx *e, size_t u16,
 static size_t scr_byte_to_u16_c(const ScrStr *s, ScrSidx *e,
                                  size_t byte_off) {
   if (e->u16len == s->len) return byte_off; /* all ASCII */
+  if (byte_off >= e->ascii_cb && byte_off < e->ascii_end) {
+    e->cu = e->ascii_cu + (byte_off - e->ascii_cb);
+    e->cb = byte_off;
+    return e->cu;
+  }
   /* A byte search result may be far beyond the existing prefix. Build the
    * same sparse intervals first, then choose the closest boundary anchor. */
   if (byte_off > e->indexed_cb) {
@@ -900,15 +980,17 @@ static size_t scr_byte_to_u16_c(const ScrStr *s, ScrSidx *e,
   scr_sidx_materialize_identity_prefix(s, e);
   ScrSidxPoint near = scr_sidx_near_byte(s, e, byte_off);
   size_t cu = near.cu, cb = near.cb;
-  while (cb > byte_off) scr_sidx_back(s, &cu, &cb);
-  while (cb < byte_off) {
-    SCR_SIDX_STEP();
-    size_t seq = scr_utf8_seq_len((unsigned char)s->data[cb]);
-    cu += seq == 4 ? 2 : 1;
-    cb += seq;
-  }
+  /* Unlike unit-to-byte conversion, both endpoints are already exact byte
+   * boundaries. Count the whole span with the shared word-wise classifier. */
+  if (cb > byte_off)
+    cu -= scr_utf16_units_span(s->data + byte_off, cb - byte_off, NULL);
+  else
+    cu += scr_utf16_units_span(s->data + cb, byte_off - cb, NULL);
+  cb = byte_off;
   e->cu = cu;
   e->cb = cb;
+  if (cb < s->len && (unsigned char)s->data[cb] < 0x80)
+    scr_sidx_ascii_run(s, e);
   return cu;
 }
 
@@ -919,16 +1001,21 @@ static double scr_to_integer_or_infinity(double x) {
   return trunc(x);
 }
 
-/* Naive byte substring search (needle and hay are both well-formed UTF-8,
+/* Byte substring search (needle and hay are both well-formed UTF-8,
  * so any byte-level match starts on a char boundary — UTF-8 is
  * self-synchronizing). Empty needle matches at hay. */
 static const char *scr_byte_find(const char *hay, size_t hay_len,
                                   const char *nee, size_t nee_len) {
   if (nee_len == 0) return hay;
   if (nee_len > hay_len) return NULL;
-  for (size_t i = 0; i + nee_len <= hay_len; i++) {
-    if (hay[i] == nee[0] && memcmp(hay + i, nee, nee_len) == 0)
-      return hay + i;
+  if (nee_len == 1) return memchr(hay, (unsigned char)nee[0], hay_len);
+  size_t remaining = hay_len - nee_len + 1;
+  while (remaining) {
+    const char *found = memchr(hay, (unsigned char)nee[0], remaining);
+    if (!found) return NULL;
+    if (memcmp(found + 1, nee + 1, nee_len - 1) == 0) return found;
+    remaining -= (size_t)(found - hay) + 1;
+    hay = found + 1;
   }
   return NULL;
 }
@@ -981,14 +1068,18 @@ double scr_str_char_code_at(ScrStr *s, double i) {
 
 double scr_str_index_of(ScrStr *s, ScrStr *needle, double fromIndex) {
   double pos = scr_to_integer_or_infinity(fromIndex);
+  if (needle->len > s->len) return -1.0;
   ScrSidx *e = scr_sidx(s);
-  size_t len16 = scr_sidx_len(s, e);
-  size_t start16 = pos <= 0             ? 0
-                   : pos >= (double)len16 ? len16
-                                          : (size_t)pos;
   /* Per spec, the empty needle is found at the clamped fromIndex itself —
    * even when that index is between the halves of an astral pair. */
-  if (needle->len == 0) return (double)start16;
+  if (needle->len == 0) {
+    size_t len16 = scr_sidx_len(s, e);
+    return pos <= 0 ? 0 : pos >= (double)len16 ? (double)len16 : pos;
+  }
+  /* Byte length bounds UTF-16 length and fences the cast. Let the mapper
+   * extend only as far as needed instead of indexing an unsearched suffix. */
+  if (pos >= (double)s->len) return -1.0;
+  size_t start16 = pos <= 0 ? 0 : (size_t)pos;
   bool mid;
   size_t start_b = scr_u16_to_byte_c(s, e, start16, &mid);
   /* A match can't begin on a low-surrogate half (needles are well-formed),
@@ -1001,11 +1092,11 @@ double scr_str_index_of(ScrStr *s, ScrStr *needle, double fromIndex) {
   return (double)scr_byte_to_u16_c(s, e, (size_t)(found - s->data));
 }
 
-/* substring: slice's clamp-and-swap sibling — ToIntegerOrInfinity both
- * boundaries (NaN → 0), clamp each to [0, len16] (negatives clamp to 0,
- * NOT relative like slice's), swap when start > end, then extract exactly
- * like slice (whose relative/negative handling is inert on the
- * already-clamped values — delegation is exact). */
+static ScrStr *scr_str_slice_units(ScrStr *s, ScrSidx *e,
+                                    size_t from, size_t to);
+
+/* Normalize once, then share slice's extraction without another cache
+ * lookup, length query or floating-point boundary conversion. */
 ScrStr *scr_str_substring(ScrStr *s, double start, double end) {
   ScrSidx *e = scr_sidx(s);
   double len16 = (double)scr_sidx_len(s, e);
@@ -1013,7 +1104,8 @@ ScrStr *scr_str_substring(ScrStr *s, double start, double end) {
   double b = scr_to_integer_or_infinity(end);
   double fa = a < 0 ? 0 : a > len16 ? len16 : a;
   double fb = b < 0 ? 0 : b > len16 ? len16 : b;
-  return fa < fb ? scr_str_slice(s, fa, fb) : scr_str_slice(s, fb, fa);
+  return fa < fb ? scr_str_slice_units(s, e, (size_t)fa, (size_t)fb)
+                 : scr_str_slice_units(s, e, (size_t)fb, (size_t)fa);
 }
 
 bool scr_str_includes(ScrStr *s, ScrStr *needle) {
@@ -1037,22 +1129,27 @@ static size_t scr_str_clamp_u16_position(double position, size_t len16) {
 }
 
 bool scr_str_starts_with_from(ScrStr *s, ScrStr *needle, double position) {
-  ScrSidx *e = scr_sidx(s);
-  size_t len16 = scr_sidx_len(s, e);
-  size_t start16 = scr_str_clamp_u16_position(position, len16);
   if (needle->len == 0) return true;
+  double pos = scr_to_integer_or_infinity(position);
+  if (pos <= 0) return scr_str_starts_with(s, needle);
+  if (pos >= (double)s->len || needle->len > s->len) return false;
+  ScrSidx *e = scr_sidx(s);
   bool mid;
-  size_t start_byte = scr_u16_to_byte_c(s, e, start16, &mid);
+  size_t start_byte = scr_u16_to_byte_c(s, e, (size_t)pos, &mid);
   return !mid && needle->len <= s->len - start_byte &&
          memcmp(s->data + start_byte, needle->data, needle->len) == 0;
 }
 
 bool scr_str_ends_with_from(ScrStr *s, ScrStr *needle, double end_position) {
+  if (needle->len == 0) return true;
+  if (needle->len > s->len) return false;
+  if (end_position >= (double)s->len) return scr_str_ends_with(s, needle);
+  /* A second receiver lookup can evict the first receiver's entry. Resolve
+   * the needle before borrowing the haystack entry for both conversions. */
+  size_t needle16 = scr_sidx_len(needle, scr_sidx(needle));
   ScrSidx *e = scr_sidx(s);
   size_t len16 = scr_sidx_len(s, e);
   size_t end16 = scr_str_clamp_u16_position(end_position, len16);
-  size_t needle16 = scr_sidx_len(needle, scr_sidx(needle));
-  if (needle16 == 0) return true;
   if (needle16 > end16) return false;
   bool start_mid, end_mid;
   size_t start_byte = scr_u16_to_byte_c(s, e, end16 - needle16, &start_mid);
@@ -1077,7 +1174,46 @@ ScrStr *scr_str_slice(ScrStr *s, double start, double end) {
   size_t len16 = scr_sidx_len(s, e);
   size_t from = scr_slice_boundary(scr_to_integer_or_infinity(start), len16);
   size_t to = scr_slice_boundary(scr_to_integer_or_infinity(end), len16);
+  return scr_str_slice_units(s, e, from, to);
+}
+
+void scr_str_slice_range(ScrStr *s, double start, double end, bool substring,
+                         ScrStringSlice *out) {
+  ScrSidx *e = scr_sidx(s);
+  size_t length = scr_sidx_len(s, e);
+  double a = scr_to_integer_or_infinity(start), b = scr_to_integer_or_infinity(end);
+  size_t from, to;
+  if (substring) {
+    from = a <= 0 ? 0 : a >= (double)length ? length : (size_t)a;
+    to = b <= 0 ? 0 : b >= (double)length ? length : (size_t)b;
+    if (from > to) { size_t swap = from; from = to; to = swap; }
+  } else {
+    from = scr_slice_boundary(a, length);
+    to = scr_slice_boundary(b, length);
+  }
+  out->start = from;
+  out->length = to > from ? to - from : 0;
+  out->split = 0;
+  if (out->length) {
+    bool first, last;
+    (void)scr_u16_to_byte_c(s, e, from, &first);
+    (void)scr_u16_to_byte_c(s, e, to, &last);
+    out->split = (first ? 1u : 0u) | (last ? 2u : 0u);
+  }
+}
+
+double scr_str_slice_char_code_at(ScrStr *s, const ScrStringSlice *range, double index) {
+  double unit = scr_to_integer_or_infinity(index);
+  if (!(unit >= 0) || unit >= (double)range->length) return NAN;
+  if ((unit == 0 && (range->split & 1u)) ||
+      (unit == (double)(range->length - 1) && (range->split & 2u))) return 0xFFFD;
+  return scr_str_char_code_at(s, (double)range->start + unit);
+}
+
+static ScrStr *scr_str_slice_units(ScrStr *s, ScrSidx *e,
+                                    size_t from, size_t to) {
   if (from >= to) return scr_str_empty();
+  if (from == 0 && to == e->u16len) return scr_str_retain(s);
 
   bool from_mid, to_mid;
   size_t from_b = scr_u16_to_byte_c(s, e, from, &from_mid);
@@ -1087,24 +1223,28 @@ ScrStr *scr_str_slice(ScrStr *s, double start, double end) {
   size_t content_b = from_mid ? from_b + 4 : from_b;
   size_t content_len = to_b - content_b;
 
-  if (!from_mid && !to_mid)
-    return scr_str_from_span(s->data + from_b, content_len);
+  if (!from_mid && !to_mid) {
+    ScrStr *result = scr_str_from_span(s->data + from_b, content_len);
+    /* Unit boundaries already prove the exact output length. Preserve it
+     * instead of decoding a potentially megabyte-sized copy on .length.
+     * Index checkpoints remain lazy and owned by the result's cache slot. */
+    if (content_len >= SCR_SIDX_MIN_BYTES) scr_sidx(result)->u16len = to - from;
+    return result;
+  }
 
   /* Divergence: JS would emit the lone surrogate half; we emit U+FFFD. */
   size_t total = content_len + (from_mid ? SCR_REPLACEMENT_LEN : 0) +
                  (to_mid ? SCR_REPLACEMENT_LEN : 0);
-  char *tmp = malloc(total);
-  if (!tmp) scr_oom();
+  ScrStr *r = scr_str_alloc(total, total);
   size_t o = 0;
   if (from_mid) {
-    memcpy(tmp + o, SCR_REPLACEMENT, SCR_REPLACEMENT_LEN);
+    memcpy(r->data + o, SCR_REPLACEMENT, SCR_REPLACEMENT_LEN);
     o += SCR_REPLACEMENT_LEN;
   }
-  memcpy(tmp + o, s->data + content_b, content_len);
+  memcpy(r->data + o, s->data + content_b, content_len);
   o += content_len;
-  if (to_mid) memcpy(tmp + o, SCR_REPLACEMENT, SCR_REPLACEMENT_LEN);
-  ScrStr *r = scr_str_new(tmp, total);
-  free(tmp);
+  if (to_mid) memcpy(r->data + o, SCR_REPLACEMENT, SCR_REPLACEMENT_LEN);
+  r->data[total] = '\0';
   return r;
 }
 
@@ -1213,6 +1353,9 @@ ScrStr *scr_str_trim_end(ScrStr *s) {
 static const struct { size_t rc; size_t len; size_t cap; char data[4]; }
     scr_lit_fffd = {SIZE_MAX, 3, 3, "\xEF\xBF\xBD"};
 
+/* Split owns a fresh array and appends only present string values. Fill an
+ * available dense slot directly; ordinary push handles growth and the sparse
+ * boundary. The array remains valid after every append, including RC audit. */
 /* split(separator, limit) with a STRING separator (ECMA-262 22.1.3.23):
  * limit is ToUint32'd; zero returns [] and reaching the limit stops before
  * any later separator probes. The no-limit wrapper supplies 2^32-1.
@@ -1225,38 +1368,119 @@ static const struct { size_t rc; size_t len; size_t cap; char data[4]; }
  * yield the two lone surrogate halves, each half is U+FFFD here
  * (divergence 2 — the same substitution the island's boundary marshal
  * applied). Borrows both; returns a +1 string[]. */
-ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit_num) {
-  ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
-  uint32_t limit = scr_to_uint32(limit_num);
-  if (limit == 0) return out;
-  if (sep->len == 0) {
-    size_t i = 0;
-    while (i < s->len) {
-      size_t adv;
-      uint32_t cp = scr_utf8_decode(s->data + i, &adv);
-      if (cp >= 0x10000) { /* two units in JS: both halves become U+FFFD */
-        scr_arr_push_ref(out, scr_str_retain((ScrStr *)&scr_lit_fffd));
-        if (out->len == limit) return out;
-        scr_arr_push_ref(out, scr_str_retain((ScrStr *)&scr_lit_fffd));
-      } else {
-        scr_arr_push_ref(out, scr_str_from_span(s->data + i, adv));
-      }
-      if (out->len == limit) return out;
-      i += adv;
+void scr_str_split_cursor_init(ScrSplitCursor *cursor, uint32_t limit) {
+  cursor->offset = 0;
+  cursor->remaining = limit;
+  cursor->pending_unit = 0;
+}
+
+static ScrStr *scr_str_split_piece(const char *bytes, size_t len, ScrStr **scratch) {
+  if (!scratch || len <= 4) return scr_str_from_span(bytes, len);
+  ScrStr *piece = *scratch;
+  if (piece && piece->rc == 1 && piece->cap >= len) {
+    /* The scratch owner is the only remaining reference. Invalidate all
+     * metadata before replacing bytes, just as unique concatenation does. */
+    scr_short_forget(piece);
+    scr_sidx_purge(piece);
+    memcpy(piece->data, bytes, len);
+    piece->len = len;
+    piece->data[len] = '\0';
+  } else {
+    ScrStr *fresh = scr_str_alloc_raw(len, len < 64 ? 64 : len);
+    memcpy(fresh->data, bytes, len);
+    fresh->data[len] = '\0';
+    *scratch = fresh;
+    scr_str_release(piece);
+    piece = fresh;
+  }
+  return scr_str_retain(piece);
+}
+
+/* Both eager and loop consumers use the same boundary state machine.
+ * Eager consumers select the unit/substring path once before their loop. */
+static const char *scr_str_split_span(ScrStr *s, ScrStr *sep,
+                                     ScrSplitCursor *cursor, bool units,
+                                     size_t *len) {
+  if (cursor->remaining == 0 || cursor->offset > s->len) return NULL;
+  if (units) {
+    if (cursor->pending_unit) {
+      cursor->pending_unit = 0;
+      cursor->remaining--;
+      *len = 3;
+      return scr_lit_fffd.data;
     }
-    return out;
-  }
-  size_t start = 0;
+    if (cursor->offset == s->len) return NULL;
+    size_t start = cursor->offset, adv;
+    uint32_t cp = scr_utf8_decode(s->data + start, &adv);
+    cursor->offset += adv;
+    cursor->remaining--;
+    if (cp >= 0x10000) {
+      cursor->pending_unit = 1;
+      *len = 3;
+      return scr_lit_fffd.data;
+    }
+    *len = adv;
+    return s->data + start;
+  }
+  size_t start = cursor->offset;
+  const char *found = scr_byte_find(s->data + start, s->len - start,
+                                    sep->data, sep->len);
+  size_t end = found ? (size_t)(found - s->data) : s->len;
+  /* String allocations reserve the header and terminator, so len + 1
+   * cannot overflow. This sentinel includes a final empty trailing piece. */
+  cursor->offset = found ? end + sep->len : s->len + 1;
+  cursor->remaining--;
+  *len = end - start;
+  return s->data + start;
+}
+
+/* The source snapshot owns these bytes through the current iteration.
+ * A consumer that stores or otherwise exposes the piece materializes it
+ * with ordinary string ownership instead. */
+const char *scr_str_split_cursor_span(ScrStr *s, ScrStr *sep, ScrSplitCursor *cursor,
+                                     size_t *length) {
+  return scr_str_split_span(s, sep, cursor, sep->len == 0, length);
+}
+
+ScrStr *scr_str_split_materialize(const char *bytes, size_t length, ScrStr **scratch) {
+  return scr_str_split_piece(bytes, length, scratch);
+}
+
+ScrStr *scr_str_split_cursor_next(ScrStr *s, ScrStr *sep, ScrSplitCursor *cursor,
+                                  ScrStr **scratch) {
+  size_t len;
+  const char *bytes = scr_str_split_span(s, sep, cursor, sep->len == 0, &len);
+  if (!bytes) return NULL;
+  if (bytes == scr_lit_fffd.data) return scr_str_retain((ScrStr *)&scr_lit_fffd);
+  return scr_str_split_piece(bytes, len, scratch);
+}
+
+/* Move a bounded batch of pieces into array storage in one operation.
+ * This avoids a second separator scan and preserves sparse overflow. */
+static void scr_str_split_fill(ScrArr *out, ScrStr *s, ScrStr *sep,
+                               ScrSplitCursor *cursor, bool units) {
+  uint64_t slots[64];
   for (;;) {
-    const char *found = scr_byte_find(s->data + start, s->len - start,
-                                       sep->data, sep->len);
-    if (!found) break;
-    size_t at = (size_t)(found - s->data);
-    scr_arr_push_ref(out, scr_str_from_span(s->data + start, at - start));
-    if (out->len == limit) return out;
-    start = at + sep->len;
-  }
-  scr_arr_push_ref(out, scr_str_from_span(s->data + start, s->len - start));
+    size_t count = 0, len;
+    const char *bytes;
+    while (count < 64 && (bytes = scr_str_split_span(s, sep, cursor, units, &len))) {
+      ScrStr *piece = bytes == scr_lit_fffd.data
+                       ? scr_str_retain((ScrStr *)&scr_lit_fffd)
+                       : scr_str_from_span(bytes, len);
+      slots[count++] = (uint64_t)(uintptr_t)piece;
+    }
+    if (count) scr_arr_push_many(out, count, slots);
+    if (count < 64) return;
+  }
+}
+
+ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit_num) {
+  uint32_t limit = scr_to_uint32(limit_num);
+  ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
+  ScrSplitCursor cursor;
+  scr_str_split_cursor_init(&cursor, limit);
+  if (sep->len == 0) scr_str_split_fill(out, s, sep, &cursor, true);
+  else scr_str_split_fill(out, s, sep, &cursor, false);
   return out;
 }