@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

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

@@ -256,6 +256,7 @@ static void scr_map_trace(void *o, ScrTraceVisit visit, void *ctx) {
  * an identity-key map may trace keys, values, or both independently. */
 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->key_trace) scr_map_release_key(m, m->entries[e].key);
@@ -314,6 +315,7 @@ ScrMap *scr_map_retain(ScrMap *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].live) continue;
@@ -602,6 +604,51 @@ bool scr_map_iter_val_bool(const ScrMap *m, double i) {
   return scr_map_iter_at(m, i)->val != 0;
 }
 
+void scr_map_dyn_attach(ScrMap *map, const ScrMapDynOps *ops) {
+  map->dyn_ops = ops;
+}
+
+ScrDyn *scr_map_dyn_key(const ScrMap *map, double index) {
+  uint64_t slot = scr_map_iter_at(map, index)->key;
+  return map->dyn_ops ? map->dyn_ops->key_box(slot) : scr_dyn_retain(scr_map_slot_to_ptr(slot));
+}
+
+ScrDyn *scr_map_dyn_value(const ScrMap *map, double index) {
+  uint64_t slot = scr_map_iter_at(map, index)->val;
+  return map->dyn_ops ? map->dyn_ops->val_box(slot) : scr_dyn_retain(scr_map_slot_to_ptr(slot));
+}
+
+static size_t scr_map_dyn_find(ScrMap *map, const ScrDyn *key) {
+  if (map->dyn_ops && !map->dyn_ops->key_matches(key)) return SCR_MAP_EMPTY;
+  uint64_t slot = map->dyn_ops ? map->dyn_ops->key_unbox(key) : scr_map_slot_from_ptr(scr_dyn_retain((ScrDyn *)key));
+  if (scr_exc_pending()) return SCR_MAP_EMPTY;
+  if (map->key_kind == SCR_MAP_KEY_F64) slot = scr_map_f64_bits(scr_map_slot_to_f64(slot));
+  size_t entry = scr_map_find(map, scr_map_hash_key(map, slot), slot);
+  scr_map_release_key(map, slot);
+  return entry;
+}
+
+ScrDyn *scr_map_dyn_get(ScrMap *map, const ScrDyn *key) {
+  size_t entry = scr_map_dyn_find(map, key);
+  if (scr_exc_pending()) return NULL;
+  return entry == SCR_MAP_EMPTY ? scr_dyn_retain(scr_dyn_undefined()) : scr_map_dyn_value(map, (double)entry);
+}
+
+bool scr_map_dyn_has(ScrMap *map, const ScrDyn *key, bool remove) {
+  size_t entry = scr_map_dyn_find(map, key);
+  return remove ? scr_map_delete_found(map, entry) : entry != SCR_MAP_EMPTY;
+}
+
+void scr_map_dyn_set(ScrMap *map, const ScrDyn *key, const ScrDyn *value, bool set) {
+  uint64_t key_slot = map->dyn_ops ? map->dyn_ops->key_unbox(key) : scr_map_slot_from_ptr(scr_dyn_retain((ScrDyn *)key));
+  if (scr_exc_pending()) return;
+  uint64_t value_slot = set ? 0 : map->dyn_ops ? map->dyn_ops->val_unbox(value) : scr_map_slot_from_ptr(scr_dyn_retain((ScrDyn *)value));
+  if (scr_exc_pending()) { scr_map_release_key(map, key_slot); return; }
+  if (map->key_kind == SCR_MAP_KEY_F64) key_slot = scr_map_f64_bits(scr_map_slot_to_f64(key_slot));
+  scr_map_set(map, scr_map_hash_key(map, key_slot), key_slot, value_slot);
+  scr_map_release_key(map, key_slot);
+}
+
 void *scr_map_iter_val_ref(const ScrMap *m, double i) {
   return m->val_retain(scr_map_slot_to_ptr(scr_map_iter_at(m, i)->val)); /* +1 */
 }

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

@@ -10,6 +10,9 @@ static SCR_TL ScrDyn *scr_global_known;
 static SCR_TL ScrDyn *scr_global_own;
 static SCR_TL bool scr_global_cleanup_registered;
 static SCR_TL ScrDyn *(*scr_global_console_get)(void);
+static SCR_TL ScrDyn *(*scr_global_fetch_get)(void);
+
+void scr_global_fetch_install(ScrDyn *(*get)(void)) { scr_global_fetch_get = get; }
 
 static SCR_TL ScrDyn *scr_hrtime_value;
 static void scr_hrtime_cleanup(void) {
@@ -28,6 +31,12 @@ static ScrDyn *scr_hrtime_bigint_call(ScrClosure *closure, ScrDyn *const *args,
 
 static ScrDyn *scr_hrtime_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
   (void)closure;
+  if (argc && args[0]->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(args[0]);
+    ScrDyn *result = view && !scr_exc_pending() ? scr_hrtime_call(closure, &view, 1) : NULL;
+    scr_dyn_release(view);
+    return result;
+  }
   uint64_t time = scr_hrtime_ns();
   double seconds = (double)(time / UINT64_C(1000000000));
   double nanos = (double)(time % UINT64_C(1000000000));
@@ -111,6 +120,7 @@ static ScrDyn *scr_global_get(void *handle, const char *key, size_t length) {
     return scr_dyn_new_handle(&scr_global_known, SCR_DYNH_GLOBAL);
   if (length == 7 && memcmp(key, "console", length) == 0 && scr_global_console_get)
     return scr_global_console_get();
+  if (length == 5 && memcmp(key, "fetch", length) == 0 && scr_global_fetch_get) return scr_global_fetch_get();
   if (length == 9 && memcmp(key, "undefined", length) == 0) return scr_dyn_undefined();
   if (length == 3 && memcmp(key, "NaN", length) == 0) return scr_dyn_new_num(NAN);
   if (length == 8 && memcmp(key, "Infinity", length) == 0) return scr_dyn_new_num(INFINITY);

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

@@ -6,6 +6,7 @@ void scr_classobj_trace_v(void *object, ScrTraceVisit visit, void *ctx) {
   ScrClassObj *c = object;
   for (size_t i = 0; i < c->ncaps; i++) visit(c->caps[i], ctx);
   visit(c->prototype_data, ctx);
+  visit(c->static_data, ctx);
 }
 
 static void scr_classobj_gcfree(void *object) {
@@ -26,6 +27,7 @@ ScrClassObj *scr_classobj_new(const ScrClassObj *template, size_t ncaps) {
   c->ncaps = ncaps;
   c->length = template->length;
   c->prototype_data = NULL;
+  c->static_data = NULL;
   scr_obj_alloc_note();
   return c;
 }
@@ -36,6 +38,7 @@ void scr_classobj_release(ScrClassObj *c) {
     scr_cyc_on_dead(c);
     for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
     scr_box_release(c->prototype_data);
+    scr_box_release(c->static_data);
     scr_classobj_gcfree(c);
   } else {
     scr_cyc_on_release(c);
@@ -45,6 +48,14 @@ void scr_classobj_release(ScrClassObj *c) {
 void *scr_classobj_retain_v(void *c) {
   return scr_classobj_retain((ScrClassObj *)c);
 }
+
+void scr_classobj_clear_properties(ScrClassObj *c) {
+  ScrBox *prototype = c->prototype_data, *statics = c->static_data;
+  c->prototype_data = NULL;
+  c->static_data = NULL;
+  scr_box_release(prototype);
+  scr_box_release(statics);
+}
 void scr_classobj_release_v(void *c) { scr_classobj_release((ScrClassObj *)c); }
 
 ScrStr *scr_classobj_name(ScrClassObj *c) {

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

@@ -460,6 +460,12 @@ static void qs_stringify_value(QsBuf *b, const ScrDyn *v) {
 
 ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
                          const ScrStr *eq) {
+  if (obj && obj->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(obj);
+    ScrStr *result = view && !scr_exc_pending() ? scr_qs_stringify(view, sep, eq) : NULL;
+    scr_dyn_release(view);
+    return result;
+  }
   const char *sep_b = (sep && sep->len) ? sep->data : "&";
   size_t sep_len = (sep && sep->len) ? sep->len : 1;
   const char *eq_b = (eq && eq->len) ? eq->data : "=";
@@ -475,6 +481,9 @@ ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
     const ScrStr *k = kd->v.str;
     const ScrDyn *v = scr_dyn_obj_get(obj, k->data, k->len);
     if (!v) continue; /* unreachable: keys came from the object */
+    ScrDyn *view = v->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(v) : NULL;
+    if (view) v = view;
+    if (scr_exc_pending()) { scr_dyn_release(view); scr_dyn_release(keys); free(fields.data); return NULL; }
     ScrStr *ks = scr_str_encode_uri_component((ScrStr *)k);
     if (v->kind == SCR_DYN_ARR) {
       for (size_t j = 0; j < v->v.arr.len; j++) {
@@ -490,6 +499,7 @@ ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
       qs_stringify_value(&fields, v);
     }
     scr_str_release(ks);
+    scr_dyn_release(view);
   }
   scr_dyn_release(keys);
   return qb_take(&fields);

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

@@ -7,10 +7,10 @@
  * the always-compiled runtime source list (see native-toolchain.ts), so regex-free
  * programs keep a byte-identical link line.
  *
- * - Every ScrRegex today is an immortal interned literal (the compiler
- *   emits one static per distinct (pattern, flags) pair, like string
- *   literals). The pattern is compiled to bytecode LAZILY on first use and
- *   cached on the struct; a pattern lre_compile rejects aborts with a clear
+ * - Each literal evaluation creates a refcounted regex with fresh state.
+ *   Instances share an immortal template per (pattern, flags) pair. The
+ *   template compiles and caches bytecode LAZILY on first use; a pattern
+ *   lre_compile rejects aborts with a clear
  *   message (Node throws SyntaxError at parse time — documented divergence;
  *   rare, since tsc's parser has already syntax-checked the literal).
  * - Subjects are matched as UTF-16: lre_exec runs over a per-call
@@ -23,14 +23,14 @@
  *   temporary registers past the capture slots), unmatched groups leave
  *   NULL pointers, and zero-length matches advance by one code unit — or by
  *   a whole surrogate pair under /u (AdvanceStringIndex).
- * - Statefulness fence: /g regexes carry mutable lastIndex in JS. This
- *   slice supports /g (and /y) only where the iteration is internal —
- *   replace/replaceAll/split; test() on a g/y-flagged regex aborts with a
- *   clear message (the frontend already rejects the cases it can see).
+ * - Global and sticky exec/test use numeric lastIndex and update or reset
+ *   it after matching. String matching/replacement follows its own state
+ *   rules; matchAll, search, and split preserve the original regex state.
  */
 #include "scr_runtime.h"
 
 #include <stdio.h>
+#include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -176,6 +176,7 @@ static char *scr_pattern_cesu8(const ScrStr *src, size_t *plen) {
 /* The compiled bytecode, compiling (and caching) on first use. */
 static uint8_t *scr_regex_bc(ScrRegex *re) {
   if (re->bc) return re->bc;
+  if (re->literal) return re->bc = scr_regex_bc(re->literal);
   int flags = scr_lre_flags(re->flags);
   const char *pat = re->source->data;
   size_t pat_len = re->source->len;
@@ -204,15 +205,15 @@ static uint8_t *scr_regex_bc(ScrRegex *re) {
 }
 
 /* ── RC entry points ──────────────────────────────────────────────────
- * Dead paths today (every regex value is an immortal interned literal);
- * correct anyway so dynamic construction can arrive without surprises. */
+ * Literal instances borrow bytecode from their immortal templates;
+ * constructed regexes own their compiled bytecode. */
 
 void scr_regex_release(ScrRegex *re) {
   if (!re || re->rc == SIZE_MAX) return;
   if (--re->rc == 0) {
     scr_str_release(re->source);
     scr_str_release(re->flags);
-    if (re->bc) lre_realloc(lre_opaque(), re->bc, 0);
+    if (re->bc && !re->literal) lre_realloc(lre_opaque(), re->bc, 0);
     free(re);
   }
 }
@@ -220,6 +221,18 @@ void scr_regex_release(ScrRegex *re) {
 void *scr_regex_retain_v(void *re) { return scr_regex_retain(re); }
 void scr_regex_release_v(void *re) { scr_regex_release(re); }
 
+ScrRegex *scr_regex_literal(ScrRegex *literal) {
+  ScrRegex *re = calloc(1, sizeof *re);
+  if (!re) scr_regex_oom();
+  re->rc = 1;
+  re->source = scr_str_retain(literal->source);
+  re->flags = scr_str_retain(literal->flags);
+  re->literal = literal;
+  return re;
+}
+
+double scr_regex_last_index(ScrRegex *re) { return re->last_index; }
+
 ScrStr *scr_regex_source(ScrRegex *re) { return scr_str_retain(re->source); }
 ScrStr *scr_regex_flags(ScrRegex *re) { return scr_str_retain(re->flags); }
 ScrStr *scr_regex_to_string(ScrRegex *re) {
@@ -403,56 +416,53 @@ static int scr_advance(const uint16_t *u, int len, int i, bool unicode) {
 
 /* ── test ─────────────────────────────────────────────────────────────── */
 
+void scr_regex_reset_last_index(ScrRegex *re, double index) {
+  re->last_index = index;
+}
+
 bool scr_regex_test(ScrRegex *re, ScrStr *s) {
-  uint8_t *bc = scr_regex_bc(re);
-  if (lre_get_flags(bc) & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) {
-    /* JS test() on a g/y regex reads AND writes lastIndex — stateful
-     * iteration this slice does not model (the frontend rejects the sites
-     * it can see; values that flow through variables land here). */
-    fflush(stdout);
-    scr_trap("scriptc: test() on a regex with the 'g' or 'y' flag is not "
-             "supported (stateful lastIndex); drop the flag, or use "
-             "replace/replaceAll/split\n");
-  }
-  int len;
-  uint16_t *u = scr_to_utf16(s, &len);
-  uint8_t **capture = scr_capture_alloc(bc);
-  int rc = scr_exec(capture, bc, u, 0, len);
-  free(capture);
-  free(u);
-  return rc == 1;
+  ScrArr *result = scr_regex_exec(s, re);
+  bool matched = result != NULL;
+  scr_arr_release(result);
+  return matched;
+}
+
+static int scr_regex_start(ScrRegex *re, int len) {
+  double index = re->last_index;
+  if (isnan(index) || index <= 0) return 0;
+  if (index > len) return -1;
+  return (int)floor(index);
 }
 
 /* ── match ────────────────────────────────────────────────────────────── */
 
-/* s.match(re) for non-g/y regexes: Node's exec-shaped result reduced to
- * the honest slice — a fresh string[] of [whole match, ...captures], or
- * NULL for no match (the compiler wraps the `string[] | null` union). A
- * NONPARTICIPATING capture holds "" where Node's slot is undefined
- * (truthiness tests agree; SEMANTICS.md documents the divergence). g/y
- * regexes abort like test() — a g-flagged match returns EVERY match, a
- * different shape the frontend fences on literals. */
-ScrArr *scr_regex_match(ScrStr *s, ScrRegex *re) {
+/* re.exec(s): a fresh string[] of [whole match, ...captures], or NULL
+ * for no match (the compiler wraps the `string[] | null` union). Global
+ * and sticky regexes start at lastIndex, set it to the match end, and
+ * reset it on failure. Nonparticipating captures are present undefined
+ * elements, distinct from participating empty captures and array holes. */
+ScrArr *scr_regex_exec(ScrStr *s, ScrRegex *re) {
   uint8_t *bc = scr_regex_bc(re);
-  if (lre_get_flags(bc) & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) {
-    fflush(stdout);
-    scr_trap("scriptc: match() on a regex with the 'g' or 'y' flag is not "
-             "supported (an every-match array is a different shape); drop the "
-             "flag, or use replace/replaceAll/split\n");
-  }
+  bool stateful = (lre_get_flags(bc) & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) != 0;
   int len;
   uint16_t *u = scr_to_utf16(s, &len);
   uint8_t **capture = scr_capture_alloc(bc);
-  int rc = scr_exec(capture, bc, u, 0, len);
+  int pos = stateful ? scr_regex_start(re, len) : 0;
+  int rc = pos < 0 ? 0 : scr_exec(capture, bc, u, pos, len);
+  if (stateful) re->last_index = rc == 1
+    ? (double)((capture[1] - (const uint8_t *)u) >> 1) : 0;
   ScrArr *out = NULL;
   if (rc == 1) {
     const uint8_t *ubase = (const uint8_t *)u;
     int count = lre_get_capture_count(bc);
     out = scr_arr_new(SCR_ELEM_STR, (size_t)count);
+    out->metadata = scr_dyn_new_obj();
+    scr_dyn_obj_set(out->metadata, "index", 5, scr_dyn_new_num((double)((capture[0] - ubase) >> 1)));
+    scr_dyn_obj_set(out->metadata, "input", 5, scr_dyn_new_str(s));
     for (int k = 0; k < count; k++) {
       const uint8_t *cs = capture[2 * k], *ce = capture[2 * k + 1];
       if (cs == NULL || ce == NULL) {
-        scr_arr_push_ref(out, scr_str_new("", 0));
+        scr_arr_set_undefined(out, (double)out->len);
       } else {
         scr_arr_push_ref(
             out, scr_str_from_utf16(u, (int)((cs - ubase) >> 1), (int)((ce - ubase) >> 1)));
@@ -464,12 +474,42 @@ ScrArr *scr_regex_match(ScrStr *s, ScrRegex *re) {
   return out; /* +1, or NULL (no match) */
 }
 
+/* Global Symbol.match always starts at zero and drains whole matches,
+ * ignoring capture groups. Its terminating failed exec resets lastIndex
+ * to zero, so no state escapes this internal iteration. Sticky globals
+ * stop at the first gap; empty matches advance by a Unicode code point
+ * under /u and by one UTF-16 unit otherwise. */
+ScrArr *scr_regex_match(ScrStr *s, ScrRegex *re) {
+  uint8_t *bc = scr_regex_bc(re);
+  int flags = lre_get_flags(bc);
+  if (!(flags & LRE_FLAG_GLOBAL)) return scr_regex_exec(s, re);
+  re->last_index = 0;
+  bool unicode = (flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
+  int len;
+  uint16_t *u = scr_to_utf16(s, &len);
+  uint8_t **capture = scr_capture_alloc(bc);
+  const uint8_t *ubase = (const uint8_t *)u;
+  ScrArr *out = NULL;
+  int pos = scr_regex_start(re, len);
+  if (pos < 0) pos = len + 1;
+  while (pos <= len && scr_exec(capture, bc, u, pos, len) == 1) {
+    int start = (int)((capture[0] - ubase) >> 1);
+    int end = (int)((capture[1] - ubase) >> 1);
+    if (!out) out = scr_arr_new(SCR_ELEM_STR, 4);
+    scr_arr_push_ref(out, scr_str_from_utf16(u, start, end));
+    pos = start == end ? scr_advance(u, len, end, unicode) : end;
+  }
+  free(capture);
+  free(u);
+  return out;
+}
+
 /* ── search ───────────────────────────────────────────────────────────── */
 
 /* s.search(re): the first match's UTF-16 index, or -1 — Symbol.search's
  * fresh exec from position 0. lastIndex is neither read nor written in JS
- * (the spec saves and restores it), so no flag fence applies here, unlike
- * test/match: /g is irrelevant and /y anchors at 0 (libregexp's sticky
+ * (the spec saves and restores it): /g is irrelevant and /y anchors at 0
+ * (libregexp's sticky
  * bytecode omits the implicit forward scan) — exactly Node. */
 double scr_regex_search(ScrStr *s, ScrRegex *re) {
   uint8_t *bc = scr_regex_bc(re);
@@ -485,7 +525,7 @@ double scr_regex_search(ScrStr *s, ScrRegex *re) {
 }
 
 /* matchAll(re): every match as its honest slice string[] (whole match +
- * captures, nonparticipating = "" — match()'s rule) drained EAGERLY into
+ * captures, nonparticipating = undefined — match()'s rule) drained EAGERLY into
  * a fresh string[][]. The lazy iterator is unobservable across the
  * lowered surface: strings are immutable and the spec clones the regex at
  * the call, so nothing can perturb the drain. Non-global regexes throw
@@ -509,7 +549,8 @@ static ScrArr *scr_regex_match_all_core(ScrStr *s, ScrRegex *re, ScrArr *indices
   uint8_t **capture = scr_capture_alloc(bc);
   const uint8_t *ubase = (const uint8_t *)u;
   ScrArr *out = scr_arr_new(SCR_ELEM_ARR, 4);
-  int pos = 0;
+  int pos = scr_regex_start(re, len);
+  if (pos < 0) pos = len + 1;
   while (pos <= len) {
     if (scr_exec(capture, bc, u, pos, len) != 1) break;
     int start = (int)((capture[0] - ubase) >> 1);
@@ -518,7 +559,7 @@ static ScrArr *scr_regex_match_all_core(ScrStr *s, ScrRegex *re, ScrArr *indices
     for (int k = 0; k < capture_count; k++) {
       const uint8_t *cs = capture[2 * k], *ce = capture[2 * k + 1];
       if (cs == NULL || ce == NULL) {
-        scr_arr_push_ref(row, scr_str_new("", 0));
+        scr_arr_set_undefined(row, (double)row->len);
       } else {
         scr_arr_push_ref(
             row, scr_str_from_utf16(u, (int)((cs - ubase) >> 1), (int)((ce - ubase) >> 1)));
@@ -643,6 +684,7 @@ static ScrStr *scr_replace_impl(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   uint8_t *bc = scr_regex_bc(re);
   int re_flags = lre_get_flags(bc);
   bool global = (re_flags & LRE_FLAG_GLOBAL) != 0;
+  bool sticky = (re_flags & LRE_FLAG_STICKY) != 0;
   bool unicode = (re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
   int capture_count = lre_get_capture_count(bc);
   const char *groupnames = lre_get_groupnames(bc);
@@ -652,11 +694,15 @@ static ScrStr *scr_replace_impl(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   const uint8_t *ubase = (const uint8_t *)u;
   ScrJsonBuf b;
   scr_jb_init(&b);
-  int next = 0, pos = 0;
+  if (global) re->last_index = 0;
+  int next = 0, pos = sticky ? scr_regex_start(re, len) : 0;
+  if (pos < 0) pos = len + 1;
+  if (sticky && !global) re->last_index = 0;
   while (pos <= len) {
     if (scr_exec(capture, bc, u, pos, len) != 1) break;
     int start = (int)((capture[0] - ubase) >> 1);
     int end = (int)((capture[1] - ubase) >> 1);
+    if (sticky && !global) re->last_index = end;
     scr_jb_put_utf16(&b, u, next, start);
     scr_put_substitution(&b, u, len, start, end, capture, capture_count, groupnames, rep);
     next = end;
@@ -877,27 +923,48 @@ static ScrStr *scr_str_case_conv(const ScrStr *s, int to_lower) {
 ScrStr *scr_str_to_lower(const ScrStr *s) { return scr_str_case_conv(s, 1); }
 ScrStr *scr_str_to_upper(const ScrStr *s) { return scr_str_case_conv(s, 0); }
 
+static void *scr_normalize_realloc(void *opaque, void *ptr, size_t size) {
+  (void)opaque;
+  if (!size) { free(ptr); return NULL; }
+  return realloc(ptr, size);
+}
+
+ScrStr *scr_str_normalize(const ScrStr *s, const ScrStr *form) {
+  UnicodeNormalizationEnum mode;
+  if (form->len == 3 && !memcmp(form->data, "NFC", 3)) mode = UNICODE_NFC;
+  else if (form->len == 3 && !memcmp(form->data, "NFD", 3)) mode = UNICODE_NFD;
+  else if (form->len == 4 && !memcmp(form->data, "NFKC", 4)) mode = UNICODE_NFKC;
+  else if (form->len == 4 && !memcmp(form->data, "NFKD", 4)) mode = UNICODE_NFKD;
+  else {
+    static const char message[] = "The normalization form should be one of NFC, NFD, NFKC, NFKD.";
+    scr_throw_error(SCR_ERR_RANGE, scr_str_new(message, sizeof message - 1));
+    return NULL;
+  }
+  if (s->len > INT32_MAX / sizeof(uint32_t)) scr_regex_oom();
+  uint32_t *input = malloc((s->len + 1) * sizeof(uint32_t));
+  if (!input) scr_regex_oom();
+  int length = 0;
+  for (size_t offset = 0; offset < s->len;) {
+    size_t step;
+    input[length++] = scr_case_decode(s->data + offset, &step);
+    offset += step;
+  }
+  uint32_t *output = NULL;
+  int count = unicode_normalize(&output, input, length, mode, NULL, scr_normalize_realloc);
+  free(input);
+  if (count < 0) scr_regex_oom();
+  ScrJsonBuf buffer;
+  scr_jb_init(&buffer);
+  for (int i = 0; i < count; i++) scr_case_put_cp(&buffer, output[i]);
+  free(output);
+  return scr_jb_finish(&buffer);
+}
+
 /* ── assert.match / assert.doesNotMatch ──────────────────────────────────
- * Lives here (not scr_assert.c) because it needs the matcher, and every
- * call site carries a regex value — the regex link switch is already on,
- * so assert-only binaries never pull libregexp. A fresh exec from index 0:
- * Node's exec on a fresh regex literal; lastIndex statefulness is not
- * modeled anywhere in this runtime, so g/y-flagged regexes test like
- * their flag-free twins here instead of aborting (assert.match(s, /x/g)
- * works in Node — matching that beats scr_regex_test's fence;
- * SEMANTICS.md 107 covers reused stateful regexes). */
-/* A fresh exec from index 0 (assert.match's stance: g/y-flagged regexes
- * test like their flag-free twins here — SEMANTICS.md 107 covers reused
- * stateful regexes). */
+ * Lives here because it needs the matcher. Assertion matching follows
+ * RegExp.test, including global and sticky lastIndex transitions. */
 static bool scr_assert_regex_hits(ScrRegex *re, ScrStr *s) {
-  uint8_t *bc = scr_regex_bc(re);
-  int len;
-  uint16_t *u = scr_to_utf16(s, &len);
-  uint8_t **capture = scr_capture_alloc(bc);
-  bool matched = scr_exec(capture, bc, u, 0, len) == 1;
-  free(capture);
-  free(u);
-  return matched;
+  return scr_regex_test(re, s);
 }
 
 /* The regex's own inspection — /source/ + FLAGS IN GETTER ORDER
@@ -1209,6 +1276,7 @@ static ScrDyn *scr_native_regex_get(void *ptr, const char *key, size_t len) {
   ScrRegex *re = ptr;
   if (len == 6 && memcmp(key, "source", 6) == 0) return scr_native_regex_string(scr_regex_source(re));
   if (len == 5 && memcmp(key, "flags", 5) == 0) return scr_native_regex_string(scr_regex_flags(re));
+  if (len == 9 && memcmp(key, "lastIndex", 9) == 0) return scr_dyn_new_num(re->last_index);
   static const struct { const char *name; char flag; } flags[] = {
     {"global", 'g'}, {"ignoreCase", 'i'}, {"multiline", 'm'}, {"dotAll", 's'},
     {"unicode", 'u'}, {"sticky", 'y'}, {"hasIndices", 'd'}, {"unicodeSets", 'v'},
@@ -1217,10 +1285,10 @@ static ScrDyn *scr_native_regex_get(void *ptr, const char *key, size_t len) {
     if (strlen(flags[i].name) == len && memcmp(key, flags[i].name, len) == 0)
       return scr_dyn_new_bool(memchr(re->flags->data, flags[i].flag, re->flags->len) != NULL);
   }
-  static const char *const methods[] = {"test", "exec", "toString", "compile", "lastIndex"};
+  static const char *const methods[] = {"test", "exec", "toString", "compile"};
   for (size_t i = 0; i < sizeof methods / sizeof methods[0]; i++) {
     if (strlen(methods[i]) == len && memcmp(key, methods[i], len) == 0) {
-      static const char message[] = "Native RegExp method values and lastIndex have no lowering";
+      static const char message[] = "Native RegExp method values have no lowering";
       scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
       break;
     }
@@ -1229,7 +1297,15 @@ static ScrDyn *scr_native_regex_get(void *ptr, const char *key, size_t len) {
 }
 
 static bool scr_native_regex_set(void *ptr, const char *key, size_t len, const ScrDyn *value) {
-  (void)ptr; (void)key; (void)len; (void)value;
+  if (len == 9 && memcmp(key, "lastIndex", 9) == 0) {
+    if (value->kind != SCR_DYN_NUM) {
+      static const char message[] = "Non-numeric RegExp.lastIndex values have no native lowering";
+      scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+      return true;
+    }
+    ((ScrRegex *)ptr)->last_index = value->v.num;
+    return true;
+  }
   return false;
 }