@scriptc/cli-darwin-x64 0.0.0 → 0.2.1

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

@@ -0,0 +1,291 @@
+/* Native builtin export objects. The compiler supplies the existing static
+ * callable implementations; this unit owns lookup, identity, and mutations. */
+#include "scr_runtime.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+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) {
+  ScrDyn *value = scr_hrtime_value;
+  scr_hrtime_value = NULL;
+  scr_dyn_release(value);
+}
+
+static ScrDyn *scr_hrtime_bigint_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
+  (void)closure; (void)args; (void)argc;
+  ScrBigInt *time = scr_bigint_from_u64(scr_hrtime_ns());
+  ScrDyn *value = scr_dyn_new_bigint(time);
+  scr_bigint_release(time);
+  return value;
+}
+
+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));
+  if (argc && args[0]->kind != SCR_DYN_UNDEF) {
+    const ScrDyn *previous = args[0];
+    if (previous->kind != SCR_DYN_ARR) {
+      scr_dyn_arg_type_fail("time", "an instance of Array", previous);
+      return NULL;
+    }
+    if (previous->v.arr.len != 2) {
+      ScrJsonBuf message;
+      scr_jb_init(&message);
+      scr_jb_puts(&message, "The value of \"time\" is out of range. It must be 2. Received ");
+      ScrStr *length = scr_f64_to_scrstr((double)previous->v.arr.len);
+      scr_jb_put_str(&message, length);
+      scr_str_release(length);
+      ScrStr *text = scr_jb_finish(&message);
+      scr_throw_error_msg_code(SCR_ERR_RANGE, text->data, text->len, "ERR_OUT_OF_RANGE");
+      scr_str_release(text);
+      return NULL;
+    }
+    ScrDyn *prior = scr_dyn_arr_at(previous, 0);
+    if (prior->kind == SCR_DYN_BIGINT) {
+      scr_dyn_release(prior);
+      static const char message[] = "Cannot mix BigInt and other types, use explicit conversions";
+      scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+      return NULL;
+    }
+    double priorSeconds = scr_dyn_number_coerce(prior);
+    scr_dyn_release(prior);
+    if (scr_exc_pending()) return NULL;
+    prior = scr_dyn_arr_at(previous, 1);
+    if (prior->kind == SCR_DYN_BIGINT) {
+      scr_dyn_release(prior);
+      static const char message[] = "Cannot mix BigInt and other types, use explicit conversions";
+      scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+      return NULL;
+    }
+    double priorNanos = scr_dyn_number_coerce(prior);
+    scr_dyn_release(prior);
+    if (scr_exc_pending()) return NULL;
+    seconds -= priorSeconds;
+    nanos -= priorNanos;
+    if (nanos < 0) { seconds--; nanos += 1e9; }
+  }
+  ScrDyn *result = scr_dyn_new_arr();
+  scr_dyn_arr_push(result, scr_dyn_new_num(seconds));
+  scr_dyn_arr_push(result, scr_dyn_new_num(nanos));
+  return result;
+}
+
+ScrDyn *scr_process_hrtime_value(void) {
+  if (!scr_hrtime_value) {
+    scr_hrtime_value = scr_dyn_new_func(scr_closure_new(NULL, 0), scr_hrtime_call, 1, "native:process.hrtime", "hrtime");
+    ScrDyn *bigint = scr_dyn_new_func(scr_closure_new(NULL, 0), scr_hrtime_bigint_call, 0, "native:process.hrtime.bigint", "hrtimeBigInt");
+    ScrStr *key = scr_str_new("bigint", 6);
+    scr_dyn_key_set(scr_hrtime_value, key, bigint);
+    scr_str_release(key);
+    scr_dyn_release(bigint);
+    scr_atexit(scr_hrtime_cleanup);
+  }
+  return scr_dyn_retain(scr_hrtime_value);
+}
+
+static void scr_global_cleanup(void) {
+  scr_dyn_release(scr_global_known);
+  scr_dyn_release(scr_global_own);
+  scr_global_known = NULL;
+  scr_global_own = NULL;
+}
+
+static void *scr_global_retain(void *handle) { return handle; }
+static void scr_global_release(void *handle) { (void)handle; }
+
+static ScrDyn *scr_global_get(void *handle, const char *key, size_t length) {
+  (void)handle;
+  ScrDyn *own = scr_global_own ? scr_dyn_obj_get(scr_global_own, key, length) : NULL;
+  if (own) return scr_dyn_retain(own);
+  if ((length == 10 && memcmp(key, "globalThis", length) == 0) ||
+      (length == 6 && memcmp(key, "global", length) == 0))
+    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);
+  if (!scr_dyn_obj_get(scr_global_known, key, length)) return scr_dyn_undefined();
+  ScrJsonBuf text;
+  scr_jb_init(&text);
+  scr_jb_puts(&text, "reading globalThis.");
+  for (size_t i = 0; i < length; i++) scr_jb_putc(&text, key[i]);
+  scr_jb_puts(&text, " through a stored global object is not supported yet [SC2020]");
+  ScrStr *message = scr_jb_finish(&text);
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message->data, message->len, "SC2020");
+  scr_str_release(message);
+  return NULL;
+}
+
+static bool scr_global_set(void *handle, const char *key, size_t length, const ScrDyn *value) {
+  (void)handle;
+  // Builtin globals have separate native implementations. Preserve their
+  // explicit mutation boundary instead of shadowing only one access path.
+  if (scr_dyn_obj_get(scr_global_known, key, length)) return false;
+  scr_dyn_obj_set(scr_global_own, key, length, scr_dyn_retain((ScrDyn *)value));
+  return true;
+}
+
+ScrDyn *scr_global_native_init(ScrArr *known, ScrDyn *(*console_get)(void)) {
+  static const ScrDynHandleOps ops = {
+    .cls = "Object", .retain = scr_global_retain, .release = scr_global_release,
+    .get = scr_global_get, .set = scr_global_set,
+  };
+  scr_dyn_handle_install(SCR_DYNH_GLOBAL, &ops);
+  scr_global_console_get = console_get;
+  if (!scr_global_known) scr_global_known = scr_dyn_new_obj();
+  if (!scr_global_own) scr_global_own = scr_dyn_new_obj();
+  if (!scr_global_cleanup_registered) {
+    scr_atexit(scr_global_cleanup);
+    scr_global_cleanup_registered = true;
+  }
+  for (size_t i = 0; i < known->len; i++) {
+    ScrStr *key = (ScrStr *)scr_arr_get_ref(known, (double)i);
+    if (!scr_dyn_obj_get(scr_global_known, key->data, key->len))
+      scr_dyn_obj_set(scr_global_known, key->data, key->len, scr_dyn_new_bool(true));
+    scr_str_release(key);
+  }
+  return scr_dyn_new_handle(&scr_global_known, SCR_DYNH_GLOBAL);
+}
+
+typedef struct ScrBuiltinModule {
+  size_t rc;
+  ScrStr *id;
+  ScrDyn *getter;
+  ScrDyn *exports;
+  struct ScrBuiltinModule *next;
+} ScrBuiltinModule;
+
+static SCR_TL ScrBuiltinModule *scr_builtin_modules;
+static SCR_TL bool scr_builtin_cleanup_registered;
+
+static void *scr_builtin_retain(void *handle) {
+  ScrBuiltinModule *module = handle;
+  module->rc++;
+  return module;
+}
+
+static void scr_builtin_release(void *handle) {
+  ScrBuiltinModule *module = handle;
+  if (--module->rc) return;
+  scr_str_release(module->id);
+  scr_dyn_release(module->getter);
+  scr_dyn_release(module->exports);
+  free(module);
+}
+
+static void scr_builtin_cleanup(void) {
+  while (scr_builtin_modules) {
+    ScrBuiltinModule *module = scr_builtin_modules;
+    scr_builtin_modules = module->next;
+    scr_builtin_release(module);
+  }
+}
+
+static ScrDyn *scr_builtin_get(void *handle, const char *key, size_t length) {
+  ScrBuiltinModule *module = handle;
+  ScrDyn *cached = scr_dyn_obj_get(module->exports, key, length);
+  if (cached) return scr_dyn_retain(cached);
+  ScrStr *name = scr_str_new(key, length);
+  ScrDyn *arg = scr_dyn_new_str(name);
+  scr_str_release(name);
+  ScrDyn *result = scr_dyn_call(module->getter, &arg, 1, "builtin export");
+  scr_dyn_release(arg);
+  if (!result) return NULL;
+  // Nested path aliases are handles rooted in the registry. Caching them
+  // would add path.posix/path.win32 cycles to the reference-counted graph.
+  if (!(result->kind == SCR_DYN_HANDLE && result->v.handle.tag == SCR_DYNH_BUILTIN_MODULE))
+    scr_dyn_obj_set(module->exports, key, length, scr_dyn_retain(result));
+  return result;
+}
+
+static bool scr_builtin_set(void *handle, const char *key, size_t length, const ScrDyn *value) {
+  ScrBuiltinModule *module = handle;
+  scr_dyn_obj_set(module->exports, key, length, scr_dyn_retain((ScrDyn *)value));
+  return true;
+}
+
+static ScrDyn *scr_builtin_invoke(void *handle, ScrDyn *self, const char *key,
+                                ScrDyn *const *args, size_t argc, const char *what) {
+  ScrDyn *fn = scr_builtin_get(handle, key, strlen(key));
+  if (!fn) return NULL;
+  scr_dyn_this_push_dyn(self);
+  ScrDyn *result = scr_dyn_call(fn, args, argc, what);
+  scr_dyn_this_pop();
+  scr_dyn_release(fn);
+  return result;
+}
+
+ScrStr *scr_process_builtin_id(ScrDyn *id, ScrArr *known) {
+  if (id->kind != SCR_DYN_STR) {
+    scr_dyn_arg_type_fail("id", "of type string", id);
+    return NULL;
+  }
+  ScrStr *value = id->v.str;
+  bool prefix = value->len >= 5 && memcmp(value->data, "node:", 5) == 0;
+  for (size_t i = 0; i < known->len; i++) {
+    ScrStr *entry = (ScrStr *)scr_arr_get_ref(known, (double)i);
+    bool exact = entry->len == value->len && memcmp(entry->data, value->data, value->len) == 0;
+    bool prefix_only = entry->len >= 5 && memcmp(entry->data, "node:", 5) == 0;
+    bool bare = prefix && !prefix_only && entry->len == value->len - 5 && memcmp(entry->data, value->data + 5, entry->len) == 0;
+    scr_str_release(entry);
+    if (exact || bare) return scr_str_new(value->data + (prefix ? 5 : 0), value->len - (prefix ? 5 : 0));
+  }
+  return scr_str_new("", 0);
+}
+
+ScrDyn *scr_process_builtin_module(ScrStr *id, ScrDyn *getter) {
+  static const ScrDynHandleOps ops = {
+    .cls = "Object", .retain = scr_builtin_retain, .release = scr_builtin_release,
+    .get = scr_builtin_get, .set = scr_builtin_set, .invoke = scr_builtin_invoke,
+  };
+  scr_dyn_handle_install(SCR_DYNH_BUILTIN_MODULE, &ops);
+  for (ScrBuiltinModule *module = scr_builtin_modules; module; module = module->next) {
+    if (module->id->len == id->len && memcmp(module->id->data, id->data, id->len) == 0)
+      return scr_dyn_new_handle(module, SCR_DYNH_BUILTIN_MODULE);
+  }
+  if (!scr_builtin_cleanup_registered) {
+    scr_atexit(scr_builtin_cleanup);
+    scr_builtin_cleanup_registered = true;
+  }
+  ScrBuiltinModule *module = malloc(sizeof(*module));
+  if (!module) scr_trap("scriptc: out of memory\n");
+  *module = (ScrBuiltinModule){ 1, scr_str_retain(id), scr_dyn_retain(getter), scr_dyn_new_obj(), scr_builtin_modules };
+  scr_builtin_modules = module;
+  return scr_dyn_new_handle(module, SCR_DYNH_BUILTIN_MODULE);
+}
+
+ScrDyn *scr_process_builtin_unsupported(ScrStr *id, ScrStr *member) {
+  ScrJsonBuf text;
+  scr_jb_init(&text);
+  scr_jb_puts(&text, "native builtin '");
+  for (size_t i = 0; i < id->len; i++) scr_jb_putc(&text, id->data[i]);
+  if (member->len) {
+    scr_jb_putc(&text, '.');
+    for (size_t i = 0; i < member->len; i++) scr_jb_putc(&text, member->data[i]);
+  }
+  scr_jb_puts(&text, "' is not supported through process.getBuiltinModule yet [SC2020]");
+  ScrStr *message = scr_jb_finish(&text);
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message->data, message->len, "SC2020");
+  scr_str_release(message);
+  return NULL;
+}

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

@@ -0,0 +1,192 @@
+/* JS-exact double → string.
+ *
+ * ECMA-262 §6.1.6.1.20 (Number::toString, radix 10) requires the shortest
+ * digit string s (with digit count k and scale n, so that the value is
+ * s * 10^(n-k)) that round-trips to the exact double — among equally short
+ * candidates the closest, ties to even — then fixed placement for
+ * -6 < n <= 21 and exponential notation otherwise.
+ *
+ * Digit generation is Ryū (vendored, see ../vendor/ryu/README.md): d2d()
+ * computes exactly that shortest/closest/ties-even digit string with pure
+ * integer arithmetic — no snprintf/strtod probing, no locale dependence.
+ * The ECMA placement logic below is ours and unchanged; only the digit
+ * source moved. Byte-exactness vs Node is pinned by the oracle case file
+ * and the 1M-double fuzz gate (packages/runtime/test/gen-number-cases.mjs).
+ */
+#include "scr_runtime.h"
+
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Ryū d2s core, textually included so the build's runtime source list is
+ * unchanged. Provides d2d(), d2d_small_int(), decimalLength17(), div10(). */
+#include "../vendor/ryu/d2s.c"
+
+/* ECMA ToUint32, shared by bitwise operators and split's limit: non-finite
+ * values become zero, finite values truncate toward zero and wrap mod 2^32. */
+uint32_t scr_to_uint32(double d) {
+  if (!isfinite(d)) return 0;
+  double t = fmod(trunc(d), 4294967296.0);
+  if (t < 0) t += 4294967296.0;
+  return (uint32_t)t;
+}
+
+/* ── bitwise operators ─────────────────────────────────────────────────
+ * JS-exact (scr_runtime.h has the contract). ToUint32 is the primitive —
+ * ToInt32 and the Int32-typed results are the same 32 bits reinterpreted
+ * as two's complement, spelled portably (no implementation-defined
+ * narrowing casts, no UB shifts of signed values).
+ */
+
+/* The 32 bits as a SIGNED (Int32) JS number. */
+static double scr_bits_as_int32(uint32_t u) {
+  return u >= UINT32_C(0x80000000)
+             ? (double)(int32_t)(u - UINT32_C(0x80000000)) + (double)INT32_MIN
+             : (double)u;
+}
+
+double scr_bit_and(double a, double b) {
+  return scr_bits_as_int32(scr_to_uint32(a) & scr_to_uint32(b));
+}
+
+double scr_bit_or(double a, double b) {
+  return scr_bits_as_int32(scr_to_uint32(a) | scr_to_uint32(b));
+}
+
+double scr_bit_xor(double a, double b) {
+  return scr_bits_as_int32(scr_to_uint32(a) ^ scr_to_uint32(b));
+}
+
+double scr_bit_shl(double a, double b) {
+  return scr_bits_as_int32(scr_to_uint32(a) << (scr_to_uint32(b) & 31u));
+}
+
+double scr_bit_shr(double a, double b) {
+  uint32_t u = scr_to_uint32(a);
+  uint32_t s = scr_to_uint32(b) & 31u;
+  uint32_t r = u >> s;
+  if ((u & UINT32_C(0x80000000)) != 0 && s != 0) {
+    r |= ~(UINT32_C(0xffffffff) >> s); /* arithmetic shift: sign-fill */
+  }
+  return scr_bits_as_int32(r);
+}
+
+double scr_bit_ushr(double a, double b) {
+  /* The one Uint32-typed result: (-1 >>> 0) === 4294967295. */
+  return (double)(scr_to_uint32(a) >> (scr_to_uint32(b) & 31u));
+}
+
+double scr_bit_not(double a) {
+  return scr_bits_as_int32(~scr_to_uint32(a));
+}
+
+/* SameValue on doubles is shared by Object.is and checked-value property
+ * descriptors. Keep it in the numeric core so JSON values do not require
+ * the optional standard-library module just to compare two numbers. */
+bool scr_num_same_value(double a, double b) {
+  if (a != a) return b != b;
+  if (a == 0 && b == 0) return signbit(a) == signbit(b);
+  return a == b;
+}
+
+/* The Ryū digit core, shared by the ECMA placement below and the Intl
+ * en-US number formatter (scr_lib.c): the shortest round-tripping digit
+ * string for a positive finite double — value = 0.digits × 10^n with no
+ * trailing zeros. Returns k (the digit count, ≤ 17); digits is
+ * NUL-terminated. Mirrors d2s_buffered_n's dispatch: the exact
+ * small-integer fast path first (trailing decimal zeros folded into the
+ * exponent), the full algorithm otherwise. */
+int scr_f64_digits(double x, char digits[18], int *n_out) {
+  uint64_t bits;
+  memcpy(&bits, &x, sizeof bits);
+  const uint64_t ieeeMantissa = bits & ((1ull << DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t ieeeExponent =
+      (uint32_t)(bits >> DOUBLE_MANTISSA_BITS); /* sign must be stripped */
+  floating_decimal_64 v;
+  if (d2d_small_int(ieeeMantissa, ieeeExponent, &v)) {
+    for (;;) {
+      const uint64_t q = div10(v.mantissa);
+      const uint32_t r = ((uint32_t)v.mantissa) - 10 * ((uint32_t)q);
+      if (r != 0) break;
+      v.mantissa = q;
+      ++v.exponent;
+    }
+  } else {
+    v = d2d(ieeeMantissa, ieeeExponent);
+  }
+
+  /* Ryū's (mantissa, exponent) → ECMA's (digits, k, n): the k mantissa
+   * digits have no trailing zeros, and value = 0.digits * 10^n. */
+  int k = (int)decimalLength17(v.mantissa);
+  *n_out = v.exponent + k;
+  digits[k] = '\0';
+  uint64_t m = v.mantissa;
+  for (int i = k - 1; i >= 0; i--) {
+    const uint64_t q = div10(m);
+    digits[i] = (char)('0' + (uint32_t)m - 10 * (uint32_t)q);
+    m = q;
+  }
+  return k;
+}
+
+size_t scr_f64_to_str(double x, char *buf) {
+  if (isnan(x)) return (size_t)(stpcpy(buf, "NaN") - buf);
+  if (x == 0) return (size_t)(stpcpy(buf, "0") - buf); /* covers -0 */
+  if (isinf(x)) {
+    return (size_t)(stpcpy(buf, x < 0 ? "-Infinity" : "Infinity") - buf);
+  }
+
+  char *out = buf;
+  if (x < 0) {
+    *out++ = '-';
+    x = -x;
+  }
+
+  char digits[18];
+  int n;
+  int k = scr_f64_digits(x, digits, &n);
+
+  if (k <= n && n <= 21) {
+    /* Integer: digits followed by n-k zeros. */
+    memcpy(out, digits, (size_t)k);
+    out += k;
+    for (int i = 0; i < n - k; i++) *out++ = '0';
+  } else if (0 < n && n <= 21) {
+    /* ddd.ddd */
+    memcpy(out, digits, (size_t)n);
+    out += n;
+    *out++ = '.';
+    memcpy(out, digits + n, (size_t)(k - n));
+    out += k - n;
+  } else if (-6 < n && n <= 0) {
+    /* 0.000ddd */
+    *out++ = '0';
+    *out++ = '.';
+    for (int i = 0; i < -n; i++) *out++ = '0';
+    memcpy(out, digits, (size_t)k);
+    out += k;
+  } else {
+    /* d.ddde±e — exponent is n-1, printed without leading zeros. */
+    *out++ = digits[0];
+    if (k > 1) {
+      *out++ = '.';
+      memcpy(out, digits + 1, (size_t)(k - 1));
+      out += k - 1;
+    }
+    *out++ = 'e';
+    int e = n - 1;
+    *out++ = e < 0 ? '-' : '+';
+    if (e < 0) e = -e;
+    char etmp[8];
+    int elen = 0;
+    do {
+      etmp[elen++] = (char)('0' + e % 10);
+      e /= 10;
+    } while (e > 0);
+    while (elen > 0) *out++ = etmp[--elen];
+  }
+  *out = '\0';
+  return (size_t)(out - buf);
+}

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

@@ -0,0 +1,91 @@
+/* Class instance layouts are emitted by the compiler. Class objects share
+ * one runtime layout, including captured bindings for local classes. */
+#include "scr_runtime.h"
+
+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) {
+  scr_obj_free_note();
+  scr_cyc_free(object);
+}
+
+ScrClassObj *scr_classobj_new(const ScrClassObj *template, size_t ncaps) {
+  if (ncaps > (SIZE_MAX - sizeof(ScrClassObj)) / sizeof(ScrBox *))
+    scr_trap("scriptc: class capture allocation overflow\n");
+  ScrClassObj *c = scr_cyc_alloc(sizeof(ScrClassObj) + ncaps * sizeof(ScrBox *),
+      &scr_classobj_trace_v, &scr_classobj_gcfree);
+  c->rc = 1;
+  c->pre = template->pre;
+  c->post = template->post;
+  c->ctor = template->ctor;
+  c->name = template->name;
+  c->ncaps = ncaps;
+  c->length = template->length;
+  c->prototype_data = NULL;
+  c->static_data = NULL;
+  scr_obj_alloc_note();
+  return c;
+}
+
+void scr_classobj_release(ScrClassObj *c) {
+  if (!c || c->rc == SIZE_MAX) return;
+  if (--c->rc == 0) {
+    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);
+  }
+}
+
+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) {
+  return scr_str_retain((ScrStr *)c->name);
+}
+
+/* The keyed-write MISS on a fixed-shape (signature-free) record: JS would
+ * ADD the property, which a monomorphic struct cannot — the write throws
+ * the catchable TypeError naming the key instead (the documented
+ * divergence; the emitted per-shape keyed-write helpers call this after
+ * the declared-field chain misses). */
+void scr_record_key_miss(ScrStr *k) {
+  const char *base = "Cannot add property '";
+  ScrStr *head = scr_str_new(base, strlen(base));
+  ScrStr *with_key = scr_str_concat(head, k);
+  scr_str_release(head);
+  const char *tail_c = "' to a fixed-shape object";
+  ScrStr *tail = scr_str_new(tail_c, strlen(tail_c));
+  ScrStr *msg = scr_str_concat(with_key, tail);
+  scr_str_release(with_key);
+  scr_str_release(tail);
+  scr_throw_error(SCR_ERR_TYPE, msg); /* takes ownership */
+}
+
+#ifdef SCR_RC_AUDIT
+static SCR_TL long scr_live_objects = 0;
+long scr_obj_live_count(void) { return scr_live_objects; }
+void scr_obj_alloc_note(void) { scr_live_objects++; }
+void scr_obj_free_note(void) { scr_live_objects--; }
+#else
+void scr_obj_alloc_note(void) {}
+void scr_obj_free_note(void) {}
+#endif