@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

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

@@ -1,6 +1,13 @@
 #include "scr_runtime.h"
 #include <assert.h>
+#include <math.h>
 #include <stdio.h>
+#include <string.h>
+
+#ifdef SCR_RC_AUDIT
+long scr_str_live_count(void);
+long scr_dyn_key_live_count(void);
+#endif
 
 static void put(ScrDyn *map, ScrDyn *key, ScrDyn *value) {
   ScrDyn *args[] = {key, value};
@@ -20,8 +27,339 @@ static ScrDyn *nothing(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
   return scr_dyn_retain(scr_dyn_undefined());
 }
 
+static void json_string_boundaries(void) {
+  /* Every escape/control at every word alignment, followed by raw UTF-8.
+   * ASan also checks short tails that cannot supply a complete word. */
+  const char suffix[] = "tail\xF0\x9F\x99\x82\xE9\x9B\xAA";
+  for (size_t prefix = 0; prefix < 64; prefix++) {
+    for (unsigned special = 0; special < 34; special++) {
+      char bytes[96];
+      memset(bytes, 'a', prefix);
+      bytes[prefix] = special < 32 ? (char)special : special == 32 ? '"' : '\\';
+      memcpy(bytes + prefix + 1, suffix, sizeof suffix - 1);
+      size_t length = prefix + sizeof suffix;
+      ScrStr *original = scr_str_new(bytes, length);
+      ScrJsonBuf buffer;
+      scr_jb_init(&buffer);
+      scr_jb_put_json_str(&buffer, original);
+      ScrStr *encoded = scr_jb_finish(&buffer);
+      ScrDyn *parsed = scr_json_parse(encoded);
+      assert(parsed && parsed->kind == SCR_DYN_STR && !scr_exc_pending());
+      assert(scr_str_eq(original, parsed->v.str));
+      scr_dyn_release(parsed);
+      scr_str_release(encoded);
+      scr_str_release(original);
+
+      if (special < 32) {
+        char invalid[68];
+        invalid[0] = '"';
+        memset(invalid + 1, 'a', prefix);
+        invalid[prefix + 1] = (char)special;
+        invalid[prefix + 2] = '"';
+        ScrStr *input = scr_str_new(invalid, prefix + 3);
+        assert(!scr_json_parse(input) && scr_exc_pending());
+        scr_exc_clear();
+        scr_str_release(input);
+      }
+    }
+    char plain[68];
+    plain[0] = '"';
+    memset(plain + 1, 'z', prefix);
+    plain[prefix + 1] = '"';
+    ScrStr *input = scr_str_new(plain, prefix + 2);
+    ScrDyn *parsed = scr_json_parse(input);
+    assert(parsed && parsed->v.str->len == prefix && !scr_exc_pending());
+    scr_dyn_release(parsed);
+    scr_str_release(input);
+    input = scr_str_new(plain, prefix + 1);
+    assert(!scr_json_parse(input) && scr_exc_pending());
+    scr_exc_clear();
+    scr_str_release(input);
+  }
+}
+
+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. */
+  for (int round = 0; round < 100; round++) {
+    const char *text = round % 2 ? "{\"alpha\":1,\"beta\":2,\"gamma\":3}"
+      : "{\"gamma\":3,\"alpha\":0,\"\\u0061lpha\":1,\"beta\":2}";
+    ScrStr *input = scr_str_new(text, strlen(text));
+    ScrDyn *object = scr_json_parse(input);
+    scr_str_release(input);
+    assert(object && object->v.obj.len == 3);
+    assert(scr_dyn_obj_get(object, "alpha", 5)->v.num == 1);
+    ScrStr *key = scr_str_new("beta", 4);
+    scr_dyn_key_delete(object, key, true);
+    scr_str_release(key);
+    assert(!scr_dyn_obj_get(object, "beta", 4));
+    assert(scr_dyn_obj_get(object, "gamma", 5)->v.num == 3);
+    char mutable_key[] = "new\0key";
+    scr_dyn_obj_set(object, mutable_key, sizeof mutable_key - 1, scr_dyn_new_num(4));
+    mutable_key[0] = 'x';
+    assert(scr_dyn_obj_get(object, "new\0key", 7)->v.num == 4);
+    scr_dyn_release(object);
+  }
+  /* Larger objects and long names leave no stale pooled tail keys when a
+   * later small object grows through the same capacity. */
+  for (int round = 0; round < 4; round++) {
+    ScrDyn *object = scr_dyn_new_obj();
+    for (int i = 0; i < 80; i++) {
+      char key[160];
+      memset(key, 'a' + i % 20, sizeof key);
+      int prefix = snprintf(key, sizeof key, "%d:", i);
+      memset(key + prefix, 'a' + i % 20, sizeof key - (size_t)prefix);
+      scr_dyn_obj_set(object, key, sizeof key, scr_dyn_new_num(i));
+      assert(scr_dyn_obj_get(object, key, sizeof key)->v.num == i);
+    }
+    scr_dyn_release(object);
+  }
+  /* Cross index growth boundaries, invalidate moved entry positions, then
+   * recreate the index from survivors. Repeat after pool reuse. */
+  for (int round = 0; round < 4; round++) {
+    ScrDyn *object = scr_dyn_new_obj();
+    assert(!object->v.obj.index);
+    for (int i = 0; i < 129; i++) {
+      char key[16];
+      int length = snprintf(key, sizeof key, "key-%d", i);
+      scr_dyn_obj_set(object, key, (size_t)length, scr_dyn_new_num(i));
+      assert((object->v.obj.index != NULL) == (i >= 31));
+    }
+    for (int i = 0; i < 129; i++) {
+      char key[16];
+      int length = snprintf(key, sizeof key, "key-%d", i);
+      assert(scr_dyn_obj_get(object, key, (size_t)length)->v.num == i);
+      if (i % 3 == 0) {
+        ScrStr *name = scr_str_new(key, (size_t)length);
+        scr_dyn_key_delete(object, name, true);
+        scr_str_release(name);
+        assert(!scr_dyn_obj_get(object, key, (size_t)length));
+      }
+    }
+    scr_dyn_obj_set(object, "last", 4, scr_dyn_new_num(129));
+    assert(object->v.obj.index);
+    for (int i = 0; i < 129; i++) {
+      char key[16];
+      int length = snprintf(key, sizeof key, "key-%d", i);
+      ScrDyn *value = scr_dyn_obj_get(object, key, (size_t)length);
+      assert(i % 3 == 0 ? value == NULL : value && value->v.num == i);
+    }
+    scr_dyn_obj_set(object, "key-128", 7, scr_dyn_new_num(900));
+    assert(object->v.obj.len == 87);
+    assert(scr_dyn_obj_get(object, "key-128", 7)->v.num == 900);
+    scr_dyn_release(object);
+  }
+  /* A direct step is authorized only by the captured builtin method. */
+  ScrDyn *source = scr_dyn_new_arr();
+  scr_dyn_arr_push(source, scr_dyn_new_num(7));
+  scr_dyn_arr_push(source, scr_dyn_retain(scr_dyn_undefined()));
+  ScrStr *spell = scr_str_new("source", 6);
+  ScrDyn *iterator = scr_dyn_iterator(source, spell);
+  scr_str_release(spell);
+  ScrDyn *next = scr_dyn_handle_ops_of(iterator)->get(iterator->v.handle.ptr, "next", 4);
+  assert(scr_dyn_iterator_can_step(iterator, next));
+  assert(!scr_dyn_iterator_can_step(source, next));
+  assert(!scr_dyn_iterator_can_step(iterator, scr_dyn_undefined()));
+  ScrDyn *item = scr_dyn_iterator_step(iterator);
+  assert(item->v.num == 7 && !scr_dyn_iterator_step_done(iterator));
+  scr_dyn_release(item);
+  item = scr_dyn_iterator_step(iterator);
+  assert(item->kind == SCR_DYN_UNDEF && !scr_dyn_iterator_step_done(iterator));
+  scr_dyn_release(item);
+  scr_dyn_arr_push(source, scr_dyn_new_num(9));
+  item = scr_dyn_iterator_step(iterator);
+  assert(item->v.num == 9 && !scr_dyn_iterator_step_done(iterator));
+  scr_dyn_release(item);
+  item = scr_dyn_iterator_step(iterator);
+  assert(item->kind == SCR_DYN_UNDEF && scr_dyn_iterator_step_done(iterator));
+  scr_dyn_release(item);
+  scr_dyn_arr_push(source, scr_dyn_new_num(11));
+  item = scr_dyn_iterator_step(iterator);
+  assert(item->kind == SCR_DYN_UNDEF && scr_dyn_iterator_step_done(iterator));
+  scr_dyn_release(item);
+  scr_dyn_release(next);
+  scr_dyn_release(iterator);
+  scr_dyn_release(source);
+  assert(!scr_exc_pending());
+}
+
+static void shared_property_keys(void) {
+#ifdef SCR_RC_AUDIT
+  long before = scr_dyn_key_live_count();
+#endif
+  /* Distinct objects share bytes, not values or property attributes. Key
+   * deletion, a collected owner and a caller-owned input cannot invalidate
+   * the surviving entry. */
+  ScrDyn *first = scr_dyn_new_obj(), *second = scr_dyn_new_obj();
+  char key[] = "shared\0name";
+  scr_dyn_obj_set(first, key, sizeof key - 1, scr_dyn_new_num(1));
+  scr_dyn_obj_set(second, key, sizeof key - 1, scr_dyn_new_num(2));
+  assert(first->v.obj.entries[0].key == second->v.obj.entries[0].key);
+  key[0] = 'x';
+  ScrStr *name = scr_str_new("shared\0name", sizeof key - 1);
+  scr_dyn_key_delete(first, name, true);
+  scr_str_release(name);
+  assert(scr_dyn_obj_get(second, "shared\0name", sizeof key - 1)->v.num == 2);
+  scr_dyn_obj_set(first, "shared\0name", sizeof key - 1, scr_dyn_new_num(3));
+  scr_dyn_obj_set(first, "self", 4, scr_dyn_retain(first));
+  scr_dyn_release(first);
+  scr_collect_cycles();
+  assert(scr_dyn_obj_get(second, "shared\0name", sizeof key - 1)->v.num == 2);
+  scr_dyn_release(second);
+
+  /* More distinct live names than weak slots force collisions. Releasing
+   * an evicted owner must not clear or free the replacement's storage. */
+  ScrDyn *objects[600];
+  for (int round = 0; round < 2; round++) {
+    for (int i = 0; i < 600; i++) {
+      char bytes[32];
+      int length = snprintf(bytes, sizeof bytes, "field-%d", i);
+      objects[i] = scr_dyn_new_obj();
+      scr_dyn_obj_set(objects[i], bytes, (size_t)length, scr_dyn_new_num(i));
+    }
+    for (int i = 0; i < 600; i++) {
+      char bytes[32];
+      int length = snprintf(bytes, sizeof bytes, "field-%d", i);
+      assert(scr_dyn_obj_get(objects[i], bytes, (size_t)length)->v.num == i);
+      scr_dyn_release(objects[i]);
+    }
+  }
+#ifdef SCR_RC_AUDIT
+  assert(scr_dyn_key_live_count() == before);
+#endif
+}
+
+static void checked_leaf_cycles(void) {
+  /* Object properties omit primitives from trial deletion, while arrays and
+   * captured unknown values still trace them. Exercise shared leaves through
+   * both edge kinds, with and without an external owner, in either generation. */
+  for (int old = 0; old < 2; old++) {
+    for (int external = 0; external < 2; external++) {
+#ifdef SCR_RC_AUDIT
+      long before_dyns = scr_dyn_live_count();
+      long before_strings = scr_str_live_count();
+#endif
+      ScrStr *text = scr_str_new("survives either edge", 20);
+      ScrDyn *leaf = scr_dyn_new_str(text);
+      scr_str_release(text);
+      if (old) scr_cyc_hdr(leaf)->gen = SCR_CYC_MATURE;
+      ScrDyn *first = scr_dyn_new_obj(), *second = scr_dyn_new_obj();
+      ScrDyn *array = scr_dyn_new_arr();
+      ScrClosure *closure = scr_closure_new(NULL, 1);
+      closure->caps[0] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+      scr_box_set_ref(closure->caps[0], scr_dyn_retain(leaf));
+      scr_dyn_obj_set(first, "callback", 8, scr_dyn_new_func(closure, nothing, 0, "func()=>dyn", "leaf"));
+      scr_dyn_obj_set(first, "leaf", 4, scr_dyn_retain(leaf));
+      scr_dyn_obj_set(second, "leaf", 4, scr_dyn_retain(leaf));
+      scr_dyn_obj_set(second, "number", 6, scr_dyn_new_num(42));
+      scr_dyn_obj_set(second, "empty", 5, scr_dyn_new_null());
+      scr_dyn_obj_set(second, "missing", 7, scr_dyn_retain(scr_dyn_undefined()));
+      scr_dyn_arr_push(array, scr_dyn_retain(leaf));
+      scr_dyn_arr_push(array, scr_dyn_retain(first));
+      scr_dyn_obj_set(first, "next", 4, scr_dyn_retain(second));
+      scr_dyn_obj_set(second, "back", 4, scr_dyn_retain(first));
+      scr_dyn_obj_set(second, "array", 5, array);
+      if (!external) scr_dyn_release(leaf);
+      scr_dyn_release(first);
+      scr_dyn_release(second);
+      scr_cyc_collect_scheduled();
+      scr_collect_cycles();
+      if (external) {
+        assert(leaf->rc == 1 && leaf->v.str->len == 20);
+        scr_dyn_release(leaf);
+      }
+#ifdef SCR_RC_AUDIT
+      assert(scr_dyn_live_count() == before_dyns);
+      assert(scr_str_live_count() == before_strings);
+#endif
+    }
+  }
+
+  /* A previous trace snapshot must not survive a property mutation: the
+   * next collection must trace a new object edge or release a new leaf. */
+  for (int leaf_after = 0; leaf_after < 2; leaf_after++) {
+#ifdef SCR_RC_AUDIT
+    long before = scr_dyn_live_count();
+#endif
+    ScrDyn *object = scr_dyn_new_obj(), *child = scr_dyn_new_obj();
+    scr_dyn_obj_set(object, "self", 4, scr_dyn_retain(object));
+    scr_dyn_obj_set(object, "value", 5, leaf_after ? scr_dyn_retain(child) : scr_dyn_new_num(1));
+    scr_dyn_release(scr_dyn_retain(object));
+    scr_collect_cycles();
+    scr_dyn_obj_set(object, "value", 5, leaf_after ? scr_dyn_new_num(2) : scr_dyn_retain(child));
+    scr_dyn_obj_set(child, "parent", 6, scr_dyn_retain(object));
+    scr_dyn_release(child);
+    scr_dyn_release(object);
+    scr_collect_cycles();
+#ifdef SCR_RC_AUDIT
+    assert(scr_dyn_live_count() == before);
+#endif
+  }
+}
+
+static void checked_number_storage(void) {
+#ifdef SCR_RC_AUDIT
+  long before = scr_dyn_live_count();
+#endif
+  for (int value = -130; value < 258; value++) {
+    ScrDyn *first = scr_dyn_new_num(value), *second = scr_dyn_new_num(value);
+    assert(first->kind == SCR_DYN_NUM && first->v.num == value);
+    assert(scr_dyn_strict_eq(first, second));
+    if (value >= -128 && value <= 255) assert(first == second && first->rc == SIZE_MAX);
+    ScrDyn *array = scr_dyn_new_arr();
+    scr_dyn_arr_push(array, first);
+    scr_dyn_arr_push(array, second);
+    scr_dyn_arr_push(array, scr_dyn_retain(array));
+    scr_dyn_release(array);
+    scr_collect_cycles();
+  }
+  const double special[] = {-0.0, 0.5, -0.5, NAN, INFINITY, -INFINITY, 9007199254740991.0};
+  for (size_t i = 0; i < sizeof special / sizeof special[0]; i++) {
+    ScrDyn *value = scr_dyn_new_num(special[i]);
+    assert(value->rc != SIZE_MAX);
+    assert(isnan(special[i]) ? isnan(value->v.num) : value->v.num == special[i]);
+    if (special[i] == 0) assert(signbit(value->v.num));
+    scr_dyn_release(value);
+  }
+  const char raw[] = "[-0,0,1.0,1e2,-128,255,256,1e400]";
+  ScrStr *input = scr_str_new(raw, sizeof raw - 1);
+  ScrDyn *parsed = scr_json_parse(input);
+  assert(parsed && parsed->v.arr.len == 8);
+  assert(signbit(parsed->v.arr.items[0]->v.num));
+  assert(!signbit(parsed->v.arr.items[1]->v.num));
+  assert(parsed->v.arr.items[2] == scr_dyn_new_num(1));
+  assert(parsed->v.arr.items[3] == scr_dyn_new_num(100));
+  assert(isinf(parsed->v.arr.items[7]->v.num));
+  scr_dyn_release(parsed);
+  scr_str_release(input);
+#ifdef SCR_RC_AUDIT
+  assert(scr_dyn_live_count() == before);
+#endif
+}
+
 int main(void) {
+  json_string_boundaries();
+  json_indent_ownership();
   scr_init();
+  checked_storage();
+  shared_property_keys();
+  checked_leaf_cycles();
+  checked_number_storage();
   /* Native Set boxes may own headerless scalar/string maps. Collecting an
    * enclosing cycle must neither trace those leaves nor skip their release. */
   for (int i = 0; i < 2000; i++) {
@@ -177,6 +515,6 @@ int main(void) {
   scr_dyn_release(key);
   scr_dyn_release(first);
   assert(!scr_exc_pending());
-  puts("weak metadata lifetime checks passed");
+  puts("checked storage and weak metadata lifetime checks passed");
   return 0;
 }

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

@@ -7,28 +7,62 @@ import { expect, test } from "vitest";
 
 const exec = promisify(execFile);
 
-test.each([false, true])("weak metadata releases values when native keys die (audit=%s)", async (audit) => {
-  const scratch = await mkdtemp(join(tmpdir(), "scriptc-weak-map-"));
-  const src = import.meta.dirname;
-  const binary = join(scratch, "weak-map");
-  try {
-    await exec("clang", [
-      "-std=c11", "-O1", "-Wall", "-Wextra", "-fsanitize=address,undefined", ...(audit ? ["-DSCR_RC_AUDIT"] : []),
-      "-I", src, "-o", binary,
-      ...[
-        "scr_json.test.c", "scr_json.c", "scr_string.c", "scr_array.c", "scr_map.c",
-        "scr_exception.c", "scr_error.c", "scr_number.c", "scr_console.c", "scr_closure.c",
-        "scr_object.c", "scr_union.c", "scr_cycle.c", "scr_lib.c", "scr_bytes.c", "scr_bigint.c",
-        "scr_url.c", "scr_url_params.c", "scr_path.c",
-      ].map((file) => join(src, file)),
-      ...(process.platform === "linux" ? ["-D_GNU_SOURCE", "-lm"] : []),
-    ]);
-    const result = await exec(binary, [], {
-      env: { ...process.env, ASAN_OPTIONS: "detect_leaks=0:halt_on_error=1", UBSAN_OPTIONS: "halt_on_error=1" },
-    });
-    expect(result.stdout).toBe("weak metadata lifetime checks passed\n");
-    expect(result.stderr).toBe("");
-  } finally {
-    await rm(scratch, { recursive: true, force: true });
-  }
-});
+test.each([false, true])(
+  "checked storage and weak metadata preserve ownership (audit=%s)",
+  async (audit) => {
+    const scratch = await mkdtemp(join(tmpdir(), "scriptc-weak-map-"));
+    const src = import.meta.dirname;
+    const binary = join(scratch, "weak-map");
+    try {
+      await exec("clang", [
+        "-std=c11",
+        "-O1",
+        "-Wall",
+        "-Wextra",
+        "-fsanitize=address,undefined",
+        ...(audit ? ["-DSCR_RC_AUDIT"] : []),
+        "-I",
+        src,
+        "-o",
+        binary,
+        ...[
+          "scr_json.test.c",
+          "scr_json.c",
+          "scr_string.c",
+          "scr_array.c",
+          "scr_map.c",
+          "scr_exception.c",
+          "scr_error.c",
+          "scr_number.c",
+          "scr_console.c",
+          "scr_closure.c",
+          "scr_object.c",
+          "scr_union.c",
+          "scr_cycle.c",
+          "scr_lib.c",
+          "scr_bytes.c",
+          "scr_shared.c",
+          "scr_bigint.c",
+          "scr_url.c",
+          "scr_url_params.c",
+          "scr_path.c",
+        ].map((file) => join(src, file)),
+        ...(process.platform === "linux" ? ["-D_GNU_SOURCE", "-lm"] : []),
+      ]);
+      for (const threshold of ["1", "7", "256"]) {
+        const result = await exec(binary, [], {
+          env: {
+            ...process.env,
+            SCR_CYCLE_THRESHOLD: threshold,
+            ASAN_OPTIONS: "detect_leaks=0:halt_on_error=1",
+            UBSAN_OPTIONS: "halt_on_error=1",
+          },
+        });
+        expect(result.stdout).toBe("checked storage and weak metadata lifetime checks passed\n");
+        expect(result.stderr).toBe("");
+      }
+    } finally {
+      await rm(scratch, { recursive: true, force: true });
+    }
+  },
+);

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

@@ -0,0 +1,92 @@
+/* Internal key hashing and canonical array-index ordering shared by native
+ * maps and checked objects. Hashes never escape into JavaScript values. */
+#ifndef SCR_KEY_H
+#define SCR_KEY_H
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+static inline uint64_t scr_key_mix(uint64_t value) {
+  value ^= value >> 30;
+  value *= UINT64_C(0xbf58476d1ce4e5b9);
+  value ^= value >> 27;
+  value *= UINT64_C(0x94d049bb133111eb);
+  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.
+ * 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;
+    memcpy(&word, bytes + i, sizeof word);
+    hash = scr_key_mix(hash ^ word);
+    i += sizeof word;
+  }
+  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) {
+  if (length == 0 || length > 10 || (length > 1 && key[0] == '0')) return false;
+  uint64_t value = 0;
+  for (size_t i = 0; i < length; i++) {
+    if (key[i] < '0' || key[i] > '9') return false;
+    value = value * 10 + (unsigned)(key[i] - '0');
+  }
+  if (value >= UINT32_MAX) return false;
+  *out = (uint32_t)value;
+  return true;
+}
+
+typedef struct {
+  uint32_t index;
+  size_t entry;
+} ScrKeyIndex;
+
+static inline int scr_key_index_compare(const void *left, const void *right) {
+  uint32_t a = ((const ScrKeyIndex *)left)->index;
+  uint32_t b = ((const ScrKeyIndex *)right)->index;
+  return (a > b) - (a < b);
+}
+
+/* Keys are unique. Already ordered inputs need no sort, while arbitrary
+ * numeric property insertion must not require quadratic enumeration. */
+static inline void scr_key_index_sort(ScrKeyIndex *keys, size_t count) {
+  for (size_t i = 1; i < count; i++) {
+    if (keys[i - 1].index > keys[i].index) {
+      qsort(keys, count, sizeof *keys, scr_key_index_compare);
+      return;
+    }
+  }
+}
+#endif