@scriptc/cli-darwin-arm64 0.2.5 → 0.2.6

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

@@ -215,7 +215,7 @@ typedef struct ScrH2HuffNode {
   int sym; /* -1 = interior */
 } ScrH2HuffNode;
 
-static ScrH2HuffNode *scr_h2_huff_root = NULL;
+static SCR_TL ScrH2HuffNode *scr_h2_huff_root = NULL;
 
 static ScrH2HuffNode *scr_h2_huff_node(void) {
   ScrH2HuffNode *n = calloc(1, sizeof *n);
@@ -762,8 +762,8 @@ struct ScrH2Session {
 /* ── refcounts + the RC audit ────────────────────────────────────────── */
 
 #ifdef SCR_RC_AUDIT
-static long scr_h2_sessions_live = 0;
-static long scr_h2_streams_live = 0;
+static SCR_TL long scr_h2_sessions_live = 0;
+static SCR_TL long scr_h2_streams_live = 0;
 long scr_http2_live_count(void) { return scr_h2_sessions_live + scr_h2_streams_live; }
 #endif
 
@@ -885,9 +885,9 @@ typedef struct {
   void *h; /* +1, typed by kind */
 } ScrH2Emit;
 
-static ScrH2Emit *scr_h2_emits = NULL;
-static size_t scr_h2_emits_head = 0, scr_h2_emits_len = 0, scr_h2_emits_cap = 0;
-static bool scr_h2_exiting = false;
+static SCR_TL ScrH2Emit *scr_h2_emits = NULL;
+static SCR_TL size_t scr_h2_emits_head = 0, scr_h2_emits_len = 0, scr_h2_emits_cap = 0;
+static SCR_TL bool scr_h2_exiting = false;
 
 static void scr_h2_emit_release(ScrH2Emit *e) {
   switch (e->kind) {
@@ -1249,10 +1249,10 @@ static void scr_h2_connect_hook(void *ctx, ScrClosure *cb, void *h1_fn, void *h2
 static void scr_h2_upgrade_hook(void *ctx, ScrClosure *cb, void *fn, bool once);
 
 static void scr_http2_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_h2_cleanup_atexit);
+  scr_atexit(scr_h2_cleanup_atexit);
   scr_net_set_proto_sweep(&scr_h2_proto_pending, &scr_h2_proto_sweep);
   /* the compat seam: scr_http.c routes h2-backed responses through the
    * ops vtable and h2-tagged 'request' registrations through the hook */
@@ -1887,6 +1887,7 @@ void scr_http2_stream_write_str(ScrH2Stream *st, ScrStr *data /*borrowed*/) {
 }
 
 void scr_http2_stream_write_bytes(ScrH2Stream *st, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_h2_stream_send(st, (const char *)data->data, (size_t)(data->len * scr_bytes_elem_size(data->elem)));
 }
 
@@ -1904,6 +1905,7 @@ void scr_http2_stream_end_str(ScrH2Stream *st, ScrStr *data /*borrowed*/) {
 }
 
 void scr_http2_stream_end_bytes(ScrH2Stream *st, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   if (st->destroyed || st->want_end || scr_h2_stream_local_closed(st)) return;
   scr_h2_buf_put(&st->wbuf, (const char *)data->data, (size_t)(data->len * scr_bytes_elem_size(data->elem)));
   st->want_end = true;

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

@@ -629,6 +629,7 @@ ScrStr *scr_insp_regex(ScrRegex *re) {
  * runs before the depth check in Node). u8 element kind only (the
  * frontend fences the rest). */
 ScrStr *scr_insp_buffer(ScrBytes *b) {
+  SCR_SHARED_GUARD(b, NULL);
   InspBuf out = {0};
   ib_cstr(&out, "<Buffer ");
   size_t max = b->len < 50 ? b->len : 50;

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

@@ -587,7 +587,7 @@ static void isl_init(void) {
   isl_register_hostfn_class();
   /* LIFO: registered after scr_init's handlers, so teardown runs before
    * the cycle collection + RC audit — the audit sees the engine gone. */
-  atexit(isl_teardown_at_exit);
+  scr_atexit(isl_teardown_at_exit);
 }
 
 /* Nesting depth of host-function callbacks (scriptc closures invoked BY

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

@@ -208,6 +208,12 @@ void scr_jb_put_str(ScrJsonBuf *b, const ScrStr *s) {
 
 void scr_jb_puts(ScrJsonBuf *b, const char *s) { scr_jb_write(b, s, strlen(s)); }
 
+void scr_jb_put_number(ScrJsonBuf *b, double v) {
+  char buf[32];
+  size_t n = scr_f64_to_str(v, buf);
+  scr_jb_write(b, buf, n);
+}
+
 void scr_jb_put_f64(ScrJsonBuf *b, double v) {
   /* JSON.stringify number rules: non-finite → null, -0 → "0" (String(-0)
    * is "0" too, so scr_f64_to_str would agree — the zero test just makes
@@ -220,9 +226,7 @@ void scr_jb_put_f64(ScrJsonBuf *b, double v) {
     scr_jb_putc(b, '0');
     return;
   }
-  char buf[32];
-  size_t n = scr_f64_to_str(v, buf);
-  scr_jb_write(b, buf, n);
+  scr_jb_put_number(b, v);
 }
 
 /* Find the next quote, backslash or control byte. memcpy keeps the word
@@ -254,32 +258,46 @@ static size_t scr_json_plain_bytes(const char *data, size_t len) {
 }
 
 static void scr_jb_put_json_span(ScrJsonBuf *b, const char *data, size_t len) {
-  scr_jb_putc(b, '"');
-  /* Bulk-copy runs of unescaped bytes (UTF-8 passes through verbatim,
-   * like JS); escapes interrupt the run. */
-  size_t i = 0;
+  if (len > SIZE_MAX - 2) scr_json_oom();
+  size_t run = scr_json_plain_bytes(data, len);
+  /* The overwhelmingly common unescaped string needs one capacity check,
+   * including both quotes, and no per-byte builder calls. */
+  scr_jb_grow(b, run + 2);
+  b->data[b->len++] = '"';
+  if (run) memcpy(b->data + b->len, data, run);
+  b->len += run;
+  size_t i = run;
   while (i < len) {
-    size_t run = scr_json_plain_bytes(data + i, len - i);
-    scr_jb_write(b, data + i, run);
-    i += run;
-    if (i == len) break;
     unsigned char c = (unsigned char)data[i++];
+    char escaped[6] = {'\\', 0, '0', '0', 0, 0};
+    size_t count = 2;
     switch (c) {
-    case '"': scr_jb_puts(b, "\\\""); break;
-    case '\\': scr_jb_puts(b, "\\\\"); break;
-    case '\n': scr_jb_puts(b, "\\n"); break;
-    case '\r': scr_jb_puts(b, "\\r"); break;
-    case '\t': scr_jb_puts(b, "\\t"); break;
-    case '\b': scr_jb_puts(b, "\\b"); break;
-    case '\f': scr_jb_puts(b, "\\f"); break;
+    case '"': escaped[1] = '"'; break;
+    case '\\': escaped[1] = '\\'; break;
+    case '\n': escaped[1] = 'n'; break;
+    case '\r': escaped[1] = 'r'; break;
+    case '\t': escaped[1] = 't'; break;
+    case '\b': escaped[1] = 'b'; break;
+    case '\f': escaped[1] = 'f'; break;
     default: {
-      char esc[8];
-      snprintf(esc, sizeof esc, "\\u%04x", c);
-      scr_jb_puts(b, esc);
-    }
-    }
+      static const char hex[] = "0123456789abcdef";
+      escaped[1] = 'u';
+      escaped[4] = hex[c >> 4];
+      escaped[5] = hex[c & 15];
+      count = 6;
+    }
+    }
+    run = scr_json_plain_bytes(data + i, len - i);
+    if (run > SIZE_MAX - count) scr_json_oom();
+    scr_jb_grow(b, count + run);
+    memcpy(b->data + b->len, escaped, count);
+    b->len += count;
+    if (run) memcpy(b->data + b->len, data + i, run);
+    b->len += run;
+    i += run;
   }
-  scr_jb_putc(b, '"');
+  scr_jb_grow(b, 1);
+  b->data[b->len++] = '"';
 }
 
 void scr_jb_put_json_str(ScrJsonBuf *b, const ScrStr *s) {
@@ -302,6 +320,81 @@ ScrStr *scr_jb_finish(ScrJsonBuf *b) {
   return s;
 }
 
+/* Write newline and a repeated gap with one reservation. Copies never
+ * overlap: each doubling reads only the already initialized prefix. */
+static void scr_jb_indent(ScrJsonBuf *b, const char *gap, size_t gap_len, size_t depth) {
+  if (gap_len && depth > (SIZE_MAX - 1) / gap_len) scr_json_oom();
+  size_t count = gap_len * depth;
+  scr_jb_grow(b, count + 1);
+  b->data[b->len++] = '\n';
+  if (!count) return;
+  memcpy(b->data + b->len, gap, gap_len);
+  size_t filled = gap_len;
+  while (filled < count) {
+    size_t take = filled < count - filled ? filled : count - filled;
+    memcpy(b->data + b->len + filled, b->data + b->len, take);
+    filled += take;
+  }
+  b->len += count;
+}
+
+ScrStr *scr_json_indent(const ScrStr *compact, const char *gap, size_t gap_len) {
+  if (!gap_len) return scr_str_retain((ScrStr *)compact);
+  /* Node stops copying the gap at its first NUL but still inserts breaks
+   * and colon spaces when the original gap is nonempty. */
+  const char *end = memchr(gap, 0, gap_len);
+  if (end) gap_len = (size_t)(end - gap);
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  size_t depth = 0, start = 0, i = 0;
+  while (i < compact->len) {
+    char c = compact->data[i];
+    if (c == '"') {
+      /* Quoted punctuation is data. Scan ordinary runs and skip the byte
+       * after each backslash so an escaped quote cannot end this string. */
+      i++;
+      while (i < compact->len) {
+        i += scr_json_plain_bytes(compact->data + i, compact->len - i);
+        if (i == compact->len) break;
+        if (compact->data[i] == '\\') {
+          i += compact->len - i >= 2 ? 2 : 1;
+        } else {
+          i++;
+          break;
+        }
+      }
+      continue;
+    }
+    if (c == '{' || c == '[') {
+      char closer = c == '{' ? '}' : ']';
+      if (i + 1 < compact->len && compact->data[i + 1] == closer) {
+        i += 2;
+        continue;
+      }
+      scr_jb_write(&b, compact->data + start, i + 1 - start);
+      scr_jb_indent(&b, gap, gap_len, ++depth);
+      start = ++i;
+      continue;
+    }
+    if (c == '}' || c == ']') {
+      scr_jb_write(&b, compact->data + start, i - start);
+      scr_jb_indent(&b, gap, gap_len, --depth);
+      start = i++;
+      continue;
+    }
+    if (c == ',' || c == ':') {
+      scr_jb_write(&b, compact->data + start, i + 1 - start);
+      if (c == ',') scr_jb_indent(&b, gap, gap_len, depth);
+      else scr_jb_putc(&b, ' ');
+      start = ++i;
+      continue;
+    }
+    i++;
+  }
+  scr_jb_write(&b, compact->data + start, compact->len - start);
+  return scr_jb_finish(&b);
+}
+
 /* ── circular-structure detection ──────────────────────────────────────
  * RECURSIVE record types permit runtime reference cycles; JSON.stringify
  * of a cyclic value throws V8's exact TypeError. The compiler-emitted
@@ -821,6 +914,8 @@ static void scr_dyn_dispose(ScrDyn *d, bool collected) {
 
 static void scr_dyn_gcfree(void *ptr) { scr_dyn_dispose(ptr, true); }
 
+static void scr_dyn_destroy(void *ptr) { scr_dyn_dispose(ptr, false); }
+
 void scr_dyn_release(ScrDyn *d) {
   if (!d || d->rc == SIZE_MAX) return;
   if (--d->rc != 0) {
@@ -831,7 +926,7 @@ void scr_dyn_release(ScrDyn *d) {
     return;
   }
   scr_cyc_on_dead(d);
-  scr_dyn_dispose(d, false);
+  scr_rc_destroy(d, scr_dyn_destroy);
 }
 
 /* Small objects retain their compact linear representation. A wide object
@@ -880,7 +975,7 @@ static SCR_TL size_t scr_dyn_property_hints[SCR_DYN_PROPERTY_HINTS];
 static ScrDynEntry *scr_dyn_find_linear_entry(const ScrDyn *object, const char *key, size_t length) {
   for (size_t i = 0; i < object->v.obj.len; i++) {
     ScrDynEntry *entry = &object->v.obj.entries[i];
-    if (entry->key_len == length && !memcmp(entry->key, key, length)) return entry;
+    if (entry->key_len == length && scr_key_equal(entry->key, key, length)) return entry;
   }
   return NULL;
 }
@@ -891,7 +986,7 @@ static __attribute__((noinline)) ScrDynEntry *scr_dyn_find_indexed_entry(
   size_t slot = scr_key_hash(key, length) & (index->buckets - 1);
   while (index->slots[slot]) {
     ScrDynEntry *entry = &object->v.obj.entries[index->slots[slot] - 1];
-    if (entry->key_len == length && !memcmp(entry->key, key, length)) return entry;
+    if (entry->key_len == length && scr_key_equal(entry->key, key, length)) return entry;
     slot = (slot + 1) & (index->buckets - 1);
   }
   return NULL;
@@ -904,7 +999,7 @@ static ScrDynEntry *scr_dyn_find_entry(const ScrDyn *object, const char *key, si
   size_t hint = scr_dyn_property_hints[slot];
   if (hint < object->v.obj.len) {
     ScrDynEntry *entry = &object->v.obj.entries[hint];
-    if (entry->key_len == length && !memcmp(entry->key, key, length)) return entry;
+    if (entry->key_len == length && scr_key_equal(entry->key, key, length)) return entry;
   }
   ScrDynEntry *entry = scr_dyn_find_linear_entry(object, key, length);
   if (entry) scr_dyn_property_hints[slot] = (size_t)(entry - object->v.obj.entries);
@@ -2173,7 +2268,9 @@ bool scr_dyn_util_type_is(const ScrDyn *value, const ScrStr *probe) {
   if (!value) return false;
   if (value->kind == SCR_DYN_JSVAL) return scr_dyn_jsval_ops()->type_probe(value->v.jsval.cell, probe);
 #define PROBE(name) (probe->len == sizeof(name) - 1 && memcmp(probe->data, name, sizeof(name) - 1) == 0)
-  if (PROBE("isAnyArrayBuffer") || PROBE("isArrayBuffer")) return scr_array_buffer_is(value);
+  if (PROBE("isAnyArrayBuffer")) return scr_buffer_storage_is(value);
+  if (PROBE("isArrayBuffer")) return scr_array_buffer_is(value);
+  if (PROBE("isSharedArrayBuffer")) return scr_shared_array_buffer_is(value);
   if (PROBE("isArrayBufferView")) return value->kind == SCR_DYN_BYTES;
   if (PROBE("isDataView")) return value->kind == SCR_DYN_BYTES && value->v.bytes->is_data_view;
   if (PROBE("isTypedArray")) return value->kind == SCR_DYN_BYTES && !value->v.bytes->is_data_view;
@@ -2411,7 +2508,7 @@ void scr_dyn_chunk_enc(bool utf8) { scr_dyn_chunk_utf8 = utf8; }
  * a Buffer-flavored bytes box, or a string inside a setEncoding window. */
 ScrDyn *scr_dyn_new_chunk(const ScrBytes *b) {
   if (scr_dyn_chunk_utf8) {
-    ScrStr *s = scr_str_new((const char *)b->data, b->len);
+    ScrStr *s = scr_bytes_string(b, 0, b->len);
     ScrDyn *d = scr_dyn_new_str(s);
     scr_str_release(s);
     return d;
@@ -2589,7 +2686,7 @@ ScrDyn *scr_dyn_bind(ScrDyn *target, ScrDyn *const *args, size_t argc) {
  * always-linked core never references gated units. A missing tag at use
  * is an internal error: emitted programs install a unit's ops whenever
  * they can box its handles. */
-static const ScrDynHandleOps *scr_dynh_ops[SCR_DYNH_COUNT];
+static SCR_TL const ScrDynHandleOps *scr_dynh_ops[SCR_DYNH_COUNT];
 
 void scr_dyn_handle_install(ScrDynHandleTag tag, const ScrDynHandleOps *ops) {
   scr_dynh_ops[tag] = ops;
@@ -2836,6 +2933,7 @@ ScrDyn *scr_dyn_new_handle(void *h, ScrDynHandleTag tag) {
   d->v.handle.ptr = scr_dyn_handle_ops(tag)->retain(h);
   d->v.handle.tag = tag;
   d->v.handle.traced = tag == SCR_DYNH_WEAK_MAP || tag == SCR_DYNH_WEAK_SET ||
+      tag == SCR_DYNH_WORKER || tag == SCR_DYNH_MESSAGE_PORT ||
       ((tag == SCR_DYNH_SET || tag == SCR_DYNH_MAP) &&
        (((ScrMap *)h)->key_trace != NULL || ((ScrMap *)h)->val_trace != NULL));
   return d;
@@ -2845,8 +2943,8 @@ ScrDyn *scr_dyn_new_handle(void *h, ScrDynHandleTag tag) {
  * allocator view; the freelist stays private, and the release arm's
  * scr_promise_release edge installs HERE — a promise-free link never
  * references the fiber machinery (the unit-test subset links). */
-void (*scr_dyn_promise_release_fn)(ScrPromise *p) = NULL;
-bool (*scr_dyn_promise_identity_fn)(ScrPromise *a, ScrPromise *b) = NULL;
+SCR_TL void (*scr_dyn_promise_release_fn)(ScrPromise *p) = NULL;
+SCR_TL bool (*scr_dyn_promise_identity_fn)(ScrPromise *a, ScrPromise *b) = NULL;
 
 ScrDyn *scr_dyn_alloc_promise(void (*release_fn)(ScrPromise *p)) {
   scr_dyn_promise_release_fn = release_fn;
@@ -3011,7 +3109,15 @@ typedef struct {
 static SCR_TL ScrDynThisEnt *scr_dyn_this_stack;
 static SCR_TL size_t scr_dyn_this_n, scr_dyn_this_cap;
 
+static void scr_dyn_this_cleanup(void) {
+  while (scr_dyn_this_n) scr_dyn_this_pop();
+  free(scr_dyn_this_stack);
+  scr_dyn_this_stack = NULL;
+  scr_dyn_this_cap = 0;
+}
+
 static ScrDynThisEnt *scr_dyn_this_grow(void) {
+  if (!scr_dyn_this_stack) scr_atexit(scr_dyn_this_cleanup);
   if (scr_dyn_this_n == scr_dyn_this_cap) {
     size_t cap = scr_dyn_this_cap ? scr_dyn_this_cap * 2 : 8;
     ScrDynThisEnt *s = realloc(scr_dyn_this_stack, cap * sizeof *s);
@@ -4220,7 +4326,7 @@ ScrStr *scr_dyn_object_tag(const ScrDyn *d) {
   case SCR_DYN_OBJ: tag = "[object Object]"; break;
   case SCR_DYN_HANDLE:
     if ((d->v.handle.tag >= SCR_DYNH_ABORT_SIGNAL &&
-         d->v.handle.tag <= SCR_DYNH_ABORT_CONTROLLER) || d->v.handle.tag == SCR_DYNH_ARRAY_BUFFER ||
+         d->v.handle.tag <= SCR_DYNH_ABORT_CONTROLLER) || d->v.handle.tag == SCR_DYNH_ARRAY_BUFFER || d->v.handle.tag == SCR_DYNH_SHARED_ARRAY_BUFFER ||
         d->v.handle.tag == SCR_DYNH_WEAK_MAP || d->v.handle.tag == SCR_DYNH_WEAK_SET ||
         d->v.handle.tag == SCR_DYNH_SET || d->v.handle.tag == SCR_DYNH_MAP || d->v.handle.tag == SCR_DYNH_REGEXP ||
         d->v.handle.tag == SCR_DYNH_DATE) {
@@ -4713,7 +4819,7 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) {
       return out;
     }
     if ((d->v.handle.tag >= SCR_DYNH_ABORT_SIGNAL &&
-         d->v.handle.tag <= SCR_DYNH_ABORT_CONTROLLER) || d->v.handle.tag == SCR_DYNH_ARRAY_BUFFER || d->v.handle.tag == SCR_DYNH_SET || d->v.handle.tag == SCR_DYNH_MAP) {
+         d->v.handle.tag <= SCR_DYNH_ABORT_CONTROLLER) || d->v.handle.tag == SCR_DYNH_ARRAY_BUFFER || d->v.handle.tag == SCR_DYNH_SHARED_ARRAY_BUFFER || d->v.handle.tag == SCR_DYNH_SET || d->v.handle.tag == SCR_DYNH_MAP) {
       ScrJsonBuf b;
       scr_jb_init(&b);
       scr_jb_puts(&b, "[object ");
@@ -6599,8 +6705,9 @@ static bool scr_json_omitted(const ScrDyn *value) {
 
 static void scr_json_gap(ScrJsonBuf *buffer, const ScrStr *gap, size_t depth) {
   if (!gap->len) return;
-  scr_jb_putc(buffer, '\n');
-  for (size_t i = 0; i < depth; i++) scr_jb_write(buffer, gap->data, gap->len);
+  const char *end = memchr(gap->data, 0, gap->len);
+  size_t length = end ? (size_t)(end - gap->data) : gap->len;
+  scr_jb_indent(buffer, gap->data, length, depth);
 }
 
 /* These primitive values cannot invoke toJSON or mutate a containing frame.
@@ -8639,6 +8746,14 @@ bool scr_array_buffer_is(const ScrDyn *value) {
   return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_ARRAY_BUFFER;
 }
 
+bool scr_shared_array_buffer_is(const ScrDyn *value) {
+  return value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_SHARED_ARRAY_BUFFER;
+}
+
+bool scr_buffer_storage_is(const ScrDyn *value) {
+  return scr_array_buffer_is(value) || scr_shared_array_buffer_is(value);
+}
+
 bool scr_array_buffer_is_view(const ScrDyn *value) {
   return value->kind == SCR_DYN_BYTES;
 }
@@ -8647,8 +8762,9 @@ static ScrDyn *scr_array_buffer_get(void *h, const char *key, size_t len) {
   if ((len == 10 && memcmp(key, "byteLength", len) == 0) ||
       (len == 13 && memcmp(key, "maxByteLength", len) == 0))
     return scr_dyn_new_num(scr_bytes_byte_len(h));
-  if ((len == 9 && memcmp(key, "resizable", len) == 0) ||
-      (len == 8 && memcmp(key, "detached", len) == 0)) return scr_dyn_new_bool(false);
+  if (len == 8 && !memcmp(key, "growable", len) && ((ScrBytes *)h)->shared) return scr_dyn_new_bool(false);
+  if (!((ScrBytes *)h)->shared && ((len == 9 && memcmp(key, "resizable", len) == 0) ||
+      (len == 8 && memcmp(key, "detached", len) == 0))) return scr_dyn_new_bool(false);
   return NULL;
 }
 
@@ -8667,6 +8783,7 @@ static ScrDyn *scr_array_buffer_invoke(void *h, ScrDyn *self, const char *method
     ScrBytes *view = scr_bytes_buffer_view(h, SCR_BYTES_U8, 0, false, 0);
     if (!view) return NULL;
     ScrBytes *copy = scr_bytes_slice(view, start, end);
+    if (((ScrBytes *)h)->shared) scr_bytes_make_shared(copy);
     scr_bytes_release(view);
     ScrDyn *result = scr_array_buffer_from_bytes(copy);
     scr_bytes_release(copy);
@@ -8682,8 +8799,13 @@ ScrDyn *scr_array_buffer_from_bytes(ScrBytes *view) {
     "ArrayBuffer", &scr_bytes_retain_v, &scr_bytes_release_v,
     &scr_array_buffer_invoke, &scr_array_buffer_get, &scr_array_buffer_set, NULL,
   };
-  scr_dyn_handle_install(SCR_DYNH_ARRAY_BUFFER, &ops);
-  return scr_dyn_new_handle(view->backing ? view->backing : view, SCR_DYNH_ARRAY_BUFFER);
+  static const ScrDynHandleOps shared_ops = {
+    "SharedArrayBuffer", &scr_bytes_retain_v, &scr_bytes_release_v,
+    &scr_array_buffer_invoke, &scr_array_buffer_get, &scr_array_buffer_set, NULL,
+  };
+  ScrDynHandleTag tag = view->shared ? SCR_DYNH_SHARED_ARRAY_BUFFER : SCR_DYNH_ARRAY_BUFFER;
+  scr_dyn_handle_install(tag, view->shared ? &shared_ops : &ops);
+  return scr_dyn_new_handle(view->backing ? view->backing : view, tag);
 }
 
 static ScrDyn *scr_ffi_fail(const char *message) {
@@ -8714,7 +8836,8 @@ ScrDyn *scr_ffi_argument(ScrDyn *value, ScrStr *type) {
     void *address = NULL;
     bool converted = value->kind == SCR_DYN_NULL || value->kind == SCR_DYN_UNDEF;
     ScrBytes *bytes = value->kind == SCR_DYN_BYTES ? value->v.bytes :
-      scr_array_buffer_is(value) ? value->v.handle.ptr : NULL;
+      scr_buffer_storage_is(value) ? value->v.handle.ptr : NULL;
+    if (bytes && bytes->shared) return scr_ffi_fail("Shared byte storage cannot expose an unmanaged native pointer");
     if (bytes) { address = bytes->data; converted = true; }
     if (value->kind == SCR_DYN_STR) {
       if (memchr(value->v.str->data, 0, value->v.str->len)) {
@@ -8964,6 +9087,7 @@ static ScrDyn *scr_ffi_memory_call(ScrClosure *closure, ScrDyn *const *args, siz
       scr_dyn_arg_type_fail("source", "an ArrayBuffer or ArrayBufferView", value);
       return NULL;
     }
+    if (bytes->shared) return scr_ffi_fail("Shared byte storage cannot expose an unmanaged native pointer");
     ScrBigInt *pointer = scr_bigint_from_pointer(bytes->data);
     ScrDyn *result = scr_dyn_new_bigint(pointer);
     scr_bigint_release(pointer);
@@ -9151,7 +9275,7 @@ static int scr_weak_key(const ScrDyn *key, void **ptr, unsigned *kind) {
     *ptr = key->v.fn.class_obj ? (void *)key->v.fn.class_obj : (void *)key->v.fn.clo;
     *kind = key->v.fn.class_obj ? 3 : 2; return 1;
   case SCR_DYN_HANDLE:
-    if (key->v.handle.tag != SCR_DYNH_ARRAY_BUFFER && key->v.handle.tag != SCR_DYNH_WEAK_MAP &&
+    if (key->v.handle.tag != SCR_DYNH_ARRAY_BUFFER && key->v.handle.tag != SCR_DYNH_SHARED_ARRAY_BUFFER && key->v.handle.tag != SCR_DYNH_WEAK_MAP &&
         key->v.handle.tag != SCR_DYNH_WEAK_SET && key->v.handle.tag != SCR_DYNH_STDIO &&
         key->v.handle.tag != SCR_DYNH_FETCH_REQUEST && key->v.handle.tag != SCR_DYNH_FETCH_RESPONSE &&
         key->v.handle.tag != SCR_DYNH_MAP && key->v.handle.tag != SCR_DYNH_SET) return -1;
@@ -9382,6 +9506,16 @@ ScrDyn *scr_array_buffer_new(ScrDyn *length) {
   return result;
 }
 
+ScrDyn *scr_shared_array_buffer_new(ScrDyn *length) {
+  ScrDyn *buffer = scr_array_buffer_new(length);
+  if (!buffer) return NULL;
+  ScrBytes *storage = buffer->v.handle.ptr;
+  scr_bytes_make_shared(storage);
+  ScrDyn *result = scr_array_buffer_from_bytes(storage);
+  scr_dyn_release(buffer);
+  return result;
+}
+
 double scr_array_buffer_byte_length_getter(void) {
   ScrDyn *receiver = scr_dyn_this_get();
   if (!scr_array_buffer_is(receiver)) {
@@ -9408,7 +9542,7 @@ ScrDyn *scr_array_buffer_byte_length_descriptor(ScrDyn *getter) {
 
 ScrBytes *scr_array_buffer_view(ScrBytesElem elem, const ScrDyn *buffer,
     const ScrDyn *offset, const ScrDyn *length) {
-  if (!scr_array_buffer_is(buffer)) {
+  if (!scr_buffer_storage_is(buffer)) {
     // Non-buffer inputs use the length/iterable/array-like constructor.
     // Their extra arguments are evaluated by the caller, but not coerced.
     return scr_bytes_from_dyn(elem, buffer, false);
@@ -9443,7 +9577,7 @@ SCR_ARRAY_BUFFER_VIEW(f64, SCR_BYTES_F64)
 #undef SCR_ARRAY_BUFFER_VIEW
 
 ScrBytes *scr_array_buffer_view_dv(ScrDyn *buffer, ScrDyn *offset, ScrDyn *length) {
-  if (!scr_array_buffer_is(buffer)) {
+  if (!scr_buffer_storage_is(buffer)) {
     static const char msg[] = "First argument to DataView constructor must be an ArrayBuffer";
     scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
     return NULL;

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

@@ -78,6 +78,21 @@ static void json_string_boundaries(void) {
   }
 }
 
+static void json_indent_ownership(void) {
+  const char compact[] = "{\"a\":[],\"b\":[1,{}]}";
+  const char expected[] = "{\n  \"a\": [],\n  \"b\": [\n    1,\n    {}\n  ]\n}";
+  ScrStr *input = scr_str_new(compact, sizeof compact - 1);
+  ScrStr *same = scr_json_indent(input, "", 0);
+  assert(same == input && input->rc == 2);
+  scr_str_release(same);
+  ScrStr *pretty = scr_json_indent(input, "  ", 2);
+  assert(pretty->len == sizeof expected - 1);
+  assert(!memcmp(pretty->data, expected, sizeof expected - 1));
+  scr_str_release(input);
+  assert(!memcmp(pretty->data, expected, sizeof expected - 1));
+  scr_str_release(pretty);
+}
+
 static void checked_storage(void) {
   /* Reuse after deletion, changing field order, embedded NUL and escaped
    * duplicate names must leave independently owned keys and values. */
@@ -339,6 +354,7 @@ static void checked_number_storage(void) {
 
 int main(void) {
   json_string_boundaries();
+  json_indent_ownership();
   scr_init();
   checked_storage();
   shared_property_keys();

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

@@ -41,6 +41,7 @@ test.each([false, true])(
           "scr_cycle.c",
           "scr_lib.c",
           "scr_bytes.c",
+          "scr_shared.c",
           "scr_bigint.c",
           "scr_url.c",
           "scr_url_params.c",

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

@@ -16,10 +16,36 @@ static inline uint64_t scr_key_mix(uint64_t value) {
   return value ^ (value >> 31);
 }
 
+/* Pack at most eight bytes with fixed-size, unaligned loads. The overlapping
+ * ends cover every byte at lengths four through eight; the three selected
+ * bytes cover lengths one through three. No terminator or padding is read. */
+static inline uint64_t scr_key_short_word(const char *bytes, size_t length) {
+  if (length >= 4) {
+    uint32_t first, last;
+    memcpy(&first, bytes, sizeof first);
+    memcpy(&last, bytes + length - sizeof last, sizeof last);
+    return ((uint64_t)first << 32) | last;
+  }
+  if (length == 0) return 0;
+  return ((uint64_t)(unsigned char)bytes[0] << 16) |
+         ((uint64_t)(unsigned char)bytes[length / 2] << 8) |
+         (unsigned char)bytes[length - 1];
+}
+
+/* Callers check equal lengths first. Short keys need no out-of-line memcmp;
+ * longer keys keep the platform's bulk comparison. */
+static inline bool scr_key_equal(const char *a, const char *b, size_t length) {
+  if (a == b) return true;
+  if (length <= 8) return scr_key_short_word(a, length) == scr_key_short_word(b, length);
+  return memcmp(a, b, length) == 0;
+}
+
 /* Unaligned loads stay inside the input. Hashing is process-local, so host
- * byte order is immaterial; equal byte strings always follow the same path. */
+ * byte order is immaterial; equal byte strings always follow the same path.
+ * Short keys need one avalanche and no variable-size tail copy. */
 static inline uint64_t scr_key_hash(const char *bytes, size_t length) {
   uint64_t hash = UINT64_C(0x9e3779b97f4a7c15) ^ length;
+  if (length <= 8) return scr_key_mix(hash ^ scr_key_short_word(bytes, length));
   size_t i = 0;
   while (length - i >= sizeof(uint64_t)) {
     uint64_t word;
@@ -27,9 +53,7 @@ static inline uint64_t scr_key_hash(const char *bytes, size_t length) {
     hash = scr_key_mix(hash ^ word);
     i += sizeof word;
   }
-  uint64_t tail = 0;
-  if (i < length) memcpy(&tail, bytes + i, length - i);
-  return scr_key_mix(hash ^ tail);
+  return scr_key_mix(hash ^ scr_key_short_word(bytes + i, length - i));
 }
 
 static inline bool scr_key_array_index(const char *key, size_t length, uint32_t *out) {