@scriptc/runtime 0.0.7 → 0.0.9

package/src/scr_json.c

@@ -424,6 +424,52 @@ void scr_dyn_arr_push(ScrDyn *arr, ScrDyn *item) {
   arr->v.arr.items[arr->v.arr.len++] = item; /* ownership moves in */
 }
 
+/* Spread completion for a runtime-arity argument list (`f(...xs)` in the
+ * checked-dynamic tier): JS's spread over the DOM's iterable kinds —
+ * arrays element-by-element (retained), strings by code POINT (the string
+ * iterator; astral chars arrive unsplit), bytes by byte; every other kind
+ * throws V8's exact SPREAD-CALL TypeError (catchable, pending — callers
+ * check): nullish sources spell the spread expression (`what`) — "v is
+ * not iterable (cannot read property undefined)" — and everything else is
+ * the generic "Spread syntax requires ...iterable[Symbol.iterator] to be
+ * a function". Borrows src. */
+void scr_dyn_arr_push_spread(ScrDyn *arr, const ScrDyn *src, const char *what) {
+  if (src->kind == SCR_DYN_ARR) {
+    for (size_t i = 0; i < src->v.arr.len; i++) {
+      scr_dyn_arr_push(arr, scr_dyn_retain(src->v.arr.items[i]));
+    }
+    return;
+  }
+  if (src->kind == SCR_DYN_BYTES) {
+    for (size_t i = 0; i < src->v.bytes->len; i++) {
+      scr_dyn_arr_push(arr, scr_dyn_new_num((double)src->v.bytes->data[i]));
+    }
+    return;
+  }
+  if (src->kind == SCR_DYN_STR) {
+    double len = scr_str_utf16_len(src->v.str);
+    for (double at = 0; at < len;) {
+      ScrStr *cp = scr_str_cp_at(src->v.str, at);
+      at += scr_str_utf16_len(cp);
+      scr_dyn_arr_push(arr, scr_dyn_new_str(cp));
+      scr_str_release(cp);
+    }
+    return;
+  }
+  if (src->kind == SCR_DYN_UNDEF || src->kind == SCR_DYN_NULL) {
+    ScrJsonBuf b;
+    scr_jb_init(&b);
+    scr_jb_puts(&b, what);
+    scr_jb_puts(&b, " is not iterable (cannot read property ");
+    scr_jb_puts(&b, src->kind == SCR_DYN_UNDEF ? "undefined" : "null");
+    scr_jb_puts(&b, ")");
+    scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));
+    return;
+  }
+  static const char msg[] = "Spread syntax requires ...iterable[Symbol.iterator] to be a function";
+  scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+}
+
 /* Takes ownership of key (malloc'd) and value. Duplicate keys: the LATER
  * value wins (like JS JSON.parse) — the old value is released and the new
  * key buffer freed (the surviving entry keeps its original, equal key). */
@@ -551,6 +597,13 @@ ScrDyn *scr_dyn_call(const ScrDyn *d, ScrDyn *const *args, size_t argc, const ch
   return d->v.fn.thunk(d->v.fn.clo, args, argc);
 }
 
+/* scr_dyn_call over a DOM ARRAY's elements — the spread-application form
+ * (`f(...args)` after the emitted argument array is built). Borrows both;
+ * result owned (+1), or NULL with the exception pending. */
+ScrDyn *scr_dyn_apply(const ScrDyn *d, const ScrDyn *args, const char *what) {
+  return scr_dyn_call(d, args->v.arr.items, args->v.arr.len, what);
+}
+
 /* ── native handles in the DOM (SCR_DYN_HANDLE) ───────────────────────
  * Per-tag ops stamped by the owning units at main() (scr_http_dyn_install
  * / scr_net_dyn_install — the scr_net_install hook story), so this
@@ -582,6 +635,76 @@ const ScrDynHandleOps *scr_dyn_handle_ops_of(const ScrDyn *d) {
   return scr_dyn_handle_ops(d->v.handle.tag);
 }
 
+/* errors.js's determineSpecificType over a DOM value — the "Received
+ * ..." tail of Node's ERR_INVALID_ARG_TYPE messages. Renders into buf
+ * when the shape needs a payload; returns the text either way. Lives
+ * beside the DOM core (not the gated handle unit) because the always-
+ * linked argument validators (bytes, fs) render through it too. */
+const char *scr_dyn_specific_type(const ScrDyn *cb, char *detail, size_t cap) {
+  const char *d = detail;
+  switch (cb->kind) {
+  case SCR_DYN_NULL: d = "null"; break;
+  case SCR_DYN_UNDEF: d = "undefined"; break;
+  case SCR_DYN_OBJ: d = "an instance of Object"; break;
+  case SCR_DYN_ARR: d = "an instance of Array"; break;
+  case SCR_DYN_BYTES: d = "an instance of Uint8Array"; break;
+  case SCR_DYN_FUNC: d = "function"; break; /* callers usually return before this */
+  case SCR_DYN_HANDLE:
+    snprintf(detail, cap, "an instance of %s", scr_dyn_handle_cls(cb));
+    break;
+  case SCR_DYN_PROMISE: d = "an instance of Promise"; break;
+  case SCR_DYN_BOOL:
+    snprintf(detail, cap, "type boolean (%s)", cb->v.b ? "true" : "false");
+    break;
+  case SCR_DYN_NUM: {
+    char num[32];
+    size_t n = scr_f64_to_str(cb->v.num, num);
+    snprintf(detail, cap, "type number (%.*s)", (int)n, num);
+    break;
+  }
+  case SCR_DYN_STR: {
+    const ScrStr *sv = cb->v.str;
+    char insp[32];
+    size_t n = 0;
+    insp[n++] = '\'';
+    for (size_t i = 0; i < sv->len && n < 28; i++) insp[n++] = sv->data[i];
+    if (sv->len + 2 > 28) {
+      n = 25;
+      memcpy(insp + n, "...", 3);
+      n += 3;
+    } else {
+      insp[n++] = '\'';
+    }
+    snprintf(detail, cap, "type string (%.*s)", (int)n, insp);
+    break;
+  }
+  default: d = "an instance of Object"; break;
+  }
+  return d;
+}
+
+/* Node's ERR_INVALID_ARG_TYPE thrower ("The \"chunk\" argument must be
+ * of type string or an instance of Buffer or Uint8Array. Received type
+ * number (5)") — the handle dispatchers' and argument validators'
+ * per-arg gates. `expected` is the full "of type ..."/"an instance of
+ * ..." clause. */
+/* The compiler-resolved ERR_INVALID_ARG_TYPE throw with a RUNTIME-
+ * rendered Received tail (error.argTypeThrow — the always-throwing
+ * lowered arms whose offending value is not a literal). Borrows all
+ * three; always throws catchably. */
+void scr_throw_arg_type(const ScrStr *argname, const ScrStr *expected, const ScrDyn *got) {
+  scr_dyn_arg_type_fail(argname->data, expected->data, got);
+}
+
+void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrDyn *got) {
+  char detail[64];
+  const char *d = scr_dyn_specific_type(got, detail, sizeof detail);
+  char msg[224];
+  int len = snprintf(msg, sizeof msg,
+                     "The \"%s\" argument must be %s. Received %s", argname, expected, d);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_TYPE");
+}
+
 static void scr_dyn_handle_release(void *h, ScrDynHandleTag tag) {
   scr_dyn_handle_ops(tag)->release(h);
 }
@@ -1066,6 +1189,39 @@ ScrStr *scr_dyn_string_coerce(const ScrDyn *d) {
   return scr_dyn_to_string(d, NULL);
 }
 
+/* JS ToString over a DOM value WITH the object protocol (the WHATWG
+ * USVString conversions — URLSearchParams names/values): an OBJ whose
+ * own 'toString' member is callable is invoked with zero arguments (its
+ * throw propagates, catchably); a non-primitive answer falls through to
+ * 'valueOf' (ToPrimitive's string hint); exhaustion is the spec's
+ * "Cannot convert object to primitive value" TypeError. Every other
+ * kind matches scr_dyn_string_coerce (units RENDER — ToString(null) is
+ * "null"). Borrows; +1, or NULL with the exception pending. */
+ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d) {
+  if (d->kind == SCR_DYN_OBJ) {
+    static const char *const hint[2] = { "toString", "valueOf" };
+    for (int i = 0; i < 2; i++) {
+      ScrDyn *m = scr_dyn_obj_get(d, hint[i], strlen(hint[i])); /* borrowed */
+      if (!m || m->kind != SCR_DYN_FUNC) continue;
+      ScrDyn *r = scr_dyn_call(m, NULL, 0, hint[i]);
+      if (!r) return NULL; /* the method threw — pending */
+      if (r->kind == SCR_DYN_OBJ || r->kind == SCR_DYN_ARR ||
+          r->kind == SCR_DYN_FUNC || r->kind == SCR_DYN_HANDLE ||
+          r->kind == SCR_DYN_PROMISE) {
+        scr_dyn_release(r); /* non-primitive answer: try the next method */
+        continue;
+      }
+      ScrStr *s = scr_dyn_string_coerce(r);
+      scr_dyn_release(r);
+      return s;
+    }
+    static const char msg[] = "Cannot convert object to primitive value";
+    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+    return NULL;
+  }
+  return scr_dyn_string_coerce(d);
+}
+
 /* The checked-dynamic keyed WRITE (`h.k = v` on a dyn receiver): OBJ sets
  * the member (later writes win, insertion order — JS); undefined/null
  * throws Node's "Cannot set properties of ..."; every other kind throws
@@ -1078,6 +1234,26 @@ void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value) {
     scr_dyn_obj_set(recv, key->data, key->len, scr_dyn_retain(value));
     return;
   }
+  if (recv->kind == SCR_DYN_ARR) {
+    /* An INDEX write on a DOM array (`args[i] = v` — the variadic-rest
+     * rebuild): a canonical numeric key sets/extends the element, holes
+     * padding with undefined exactly like JS length growth. Non-index
+     * keys keep the throw below (DOM arrays carry no expando table). */
+    size_t idx = 0;
+    int is_index = key->len > 0 && !(key->len > 1 && key->data[0] == '0');
+    for (size_t i = 0; is_index && i < key->len; i++) {
+      if (key->data[i] < '0' || key->data[i] > '9') is_index = 0;
+      else idx = idx * 10 + (size_t)(key->data[i] - '0');
+    }
+    if (is_index) {
+      while (recv->v.arr.len <= idx) {
+        scr_dyn_arr_push(recv, scr_dyn_retain(scr_dyn_undefined()));
+      }
+      scr_dyn_release(recv->v.arr.items[idx]);
+      recv->v.arr.items[idx] = scr_dyn_retain(value);
+      return;
+    }
+  }
   if (recv->kind == SCR_DYN_HANDLE) {
     scr_dyn_handle_key_set(recv, key, value);
     return;
@@ -2089,6 +2265,48 @@ static ScrDyn *scr_dyn_objwalk(const ScrDyn *v, ScrObjWalk mode) {
 }
 
 ScrDyn *scr_dyn_obj_keys(const ScrDyn *v) { return scr_dyn_objwalk(v, SCR_OBJWALK_KEYS); }
+
+/* Object.assign over DOM values: copies `src`'s own members onto `target`
+ * (last write wins) and answers the target retained (+1). Nullish
+ * receivers throw Node's ToObject TypeError; nullish sources copy
+ * nothing; non-object sources copy nothing DOM-representable. */
+ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src) {
+  if (target->kind == SCR_DYN_UNDEF || target->kind == SCR_DYN_NULL) {
+    const char *m = "Cannot convert undefined or null to object";
+    scr_throw_error_msg(SCR_ERR_TYPE, m, strlen(m));
+    return NULL;
+  }
+  if (target->kind == SCR_DYN_OBJ && src->kind == SCR_DYN_OBJ) {
+    for (size_t i = 0; i < src->v.obj.len; i++) {
+      scr_dyn_obj_set(target, src->v.obj.entries[i].key,
+                      src->v.obj.entries[i].key_len,
+                      scr_dyn_retain(src->v.obj.entries[i].value));
+    }
+  }
+  return scr_dyn_retain(target);
+}
+
+bool scr_dyn_has_own(const ScrDyn *v, const ScrStr *key) {
+  if (v->kind == SCR_DYN_UNDEF || v->kind == SCR_DYN_NULL) {
+    const char *m = "Cannot convert undefined or null to object";
+    scr_throw_error_msg(SCR_ERR_TYPE, m, strlen(m));
+    return false;
+  }
+  if (v->kind == SCR_DYN_OBJ) {
+    return scr_dyn_obj_get(v, key->data, key->len) != NULL;
+  }
+  if (v->kind == SCR_DYN_ARR) {
+    if (key->len == 6 && memcmp(key->data, "length", 6) == 0) return true;
+    size_t idx = 0;
+    int is_index = key->len > 0 && !(key->len > 1 && key->data[0] == '0');
+    for (size_t i = 0; is_index && i < key->len; i++) {
+      if (key->data[i] < '0' || key->data[i] > '9') is_index = 0;
+      else idx = idx * 10 + (size_t)(key->data[i] - '0');
+    }
+    return is_index != 0 && idx < v->v.arr.len;
+  }
+  return false;
+}
 ScrDyn *scr_dyn_obj_values(const ScrDyn *v) { return scr_dyn_objwalk(v, SCR_OBJWALK_VALUES); }
 ScrDyn *scr_dyn_obj_entries(const ScrDyn *v) { return scr_dyn_objwalk(v, SCR_OBJWALK_ENTRIES); }
 

package/src/scr_lib.c

@@ -1647,7 +1647,7 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length)
     mlen = snprintf(msg, sizeof msg,
                     "The value of \"offset\" is out of range. It must be >= 0 && <= 9007199254740991. Received %s",
                     numbuf);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return 0;
   }
   size_t off = (size_t)offset;
@@ -1656,7 +1656,7 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length)
     mlen = snprintf(msg, sizeof msg,
                     "The value of \"length\" is out of range. It must be <= %zu. Received %s",
                     bytelen - off, numbuf);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return 0;
   }
   size_t want = (size_t)length;
@@ -2528,7 +2528,7 @@ ScrStr *scr_crypto_random_string(double n, ScrStr *enc) {
     int mlen = snprintf(msg, sizeof msg,
                         "The value of \"size\" is out of range. It must be >= 0 && <= 2147483647. Received %.*s",
                         (int)numlen, num);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return NULL;
   }
   size_t size = (size_t)n;
@@ -3486,6 +3486,104 @@ ScrStr *scr_num_to_fixed0(double x) {
   return r;
 }
 
+/* Increment a decimal digit string in place. Returns true on overflow —
+ * the value becomes 1 followed by len zeros (the caller folds the zeros
+ * into its scale); an EMPTY string increments to "1" the same way (the
+ * round-up-from-nothing case: 0.0005 at 3 fraction digits). */
+static bool scr_dec_inc(char *d, int len) {
+  for (int i = len - 1; i >= 0; i--) {
+    if (d[i] != '9') {
+      d[i]++;
+      return false;
+    }
+    d[i] = '0';
+  }
+  d[0] = '1';
+  return true;
+}
+
+/* Intl.NumberFormat("en-US").format(x) / x.toLocaleString("en-US") with
+ * DEFAULT options: decimal notation, minimum 0 / maximum 3 fraction
+ * digits, "," grouping every three integer digits, "∞"/"NaN" texts, and
+ * "-0" whenever the input is negative or negative zero even after
+ * rounding to zero. Rounding is half-up ON THE SHORTEST ROUND-TRIPPING
+ * DECIMAL — ICU's rounding input, probed against Node: format(1.0005) is
+ * "1.001" although the double is 1.000499... and toFixed(3) answers
+ * "1.000"; format(1e23) prints the shortest form's trailing zeros, not
+ * the double's exact expansion. The en-US/latn symbols (",", ".", "∞",
+ * "NaN", group size 3) are the whole embedded locale surface. Verified
+ * differentially against Node. Result +1; never throws. */
+ScrStr *scr_intl_num_format_en_us(double x) {
+  if (isnan(x)) return scr_str_new("NaN", 3);
+  if (isinf(x)) {
+    return x < 0 ? scr_str_new("-\xE2\x88\x9E", 4) : scr_str_new("\xE2\x88\x9E", 3);
+  }
+  bool neg = signbit(x) != 0;
+  if (x == 0) return neg ? scr_str_new("-0", 2) : scr_str_new("0", 1);
+  double a = neg ? -x : x;
+
+  /* Shortest digits: value = 0.d × 10^n (no trailing zeros, k ≤ 17). */
+  char d[18];
+  int n;
+  int k = scr_f64_digits(a, d, &n);
+
+  /* Round at 3 fraction digits: fraction position p is digit index
+   * n+p-1, so index n+3 is the first DROPPED digit. Half-up on the
+   * decimal digits — the shortest string ends right after them, so
+   * "first dropped digit ≥ 5" IS the whole decision. */
+  int keep = n + 3;
+  if (keep < k) {
+    bool up = keep >= 0 && d[keep] >= '5';
+    k = keep < 0 ? 0 : keep;
+    if (up && scr_dec_inc(d, k)) {
+      /* Carried out (all nines, or the round-up-from-nothing 0.0005
+       * case): one leading 1, the dropped nines fold into the scale. */
+      k = 1;
+      n += 1;
+    } else if (k == 0) {
+      /* Everything rounded away: ±0 with the sign preserved. */
+      return neg ? scr_str_new("-0", 2) : scr_str_new("0", 1);
+    }
+  }
+
+  /* Assemble: integer digits (indices [0, n)), zero-padded past k, then
+   * the ≤ 3 fraction digits (indices n..n+2, '0' outside [0, k)) with
+   * trailing zeros trimmed, then commas every three integer digits. */
+  char frac[3];
+  int flen = 0;
+  for (int p = 1; p <= 3; p++) {
+    int idx = n + p - 1;
+    frac[flen++] = (idx >= 0 && idx < k) ? d[idx] : '0';
+  }
+  while (flen > 0 && frac[flen - 1] == '0') flen--;
+
+  char out[512];
+  int o = 0;
+  if (neg) out[o++] = '-';
+  if (n <= 0) {
+    out[o++] = '0';
+  } else {
+    for (int i = 0; i < n; i++) {
+      if (i > 0 && (n - i) % 3 == 0) out[o++] = ',';
+      out[o++] = (i < k) ? d[i] : '0';
+    }
+  }
+  if (flen > 0) {
+    out[o++] = '.';
+    memcpy(out + o, frac, (size_t)flen);
+    o += flen;
+  }
+  return scr_str_new(out, (size_t)o);
+}
+
+/* Object.is over two numbers — the spec's SameValue on doubles: NaN
+ * equals NaN, +0 differs from -0, everything else is ==. */
+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;
+}
+
 bool scr_num_is_nan(double x) { return isnan(x) != 0; }
 
 bool scr_num_is_integer(double x) { return isfinite(x) && trunc(x) == x; }

package/src/scr_library.c

@@ -40,7 +40,19 @@ void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
  * conforming survival pattern), then deliver exactly once, then abort:
  * before registration, or if the sink returns (the ruled host-contract
  * violation). The address is the funnel frame's return address — the trap
- * site — 0 where the toolchain cannot supply one. */
+ * site — 0 where the toolchain cannot supply one.
+ *
+ * Delivery shape (the ratified structured trap-teaching encoding): a
+ * message that already begins with the 0x01 marker — a facade-authored
+ * structured throw riding the verbatim rule, or the wrapper's compile-
+ * time-assembled SC4012 contract trap — is delivered byte-for-byte. Every
+ * OTHER message is a trap the runtime DETECTED, and the funnel assembles
+ * it here into 0x01 text 0x1F code 0x1F symbol [0x1F remediation]: the
+ * baseline human line becomes field 0 unchanged (so plain-text hosts read
+ * exactly what they always read), the code classifies the trap kind, the
+ * symbol is the entry the trapping call came through (recorded by the
+ * entry prologue below), and the remediation is the profile's for that
+ * code when the program TU's overlay table declares one. */
 
 #if defined(__GNUC__) || defined(__clang__)
 #define SCR_TRAP_ADDR() ((uint64_t)(uintptr_t)__builtin_return_address(0))
@@ -48,8 +60,95 @@ void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
 #define SCR_TRAP_ADDR() ((uint64_t)0)
 #endif
 
+/* The current-entry slot: every generated entry's prologue records its
+ * external symbol before dispatching into core code. A single static slot
+ * is sound — exactly one core is live per process (the one-live-core rule),
+ * entries never nest, and a trap can only fire while an entry is on the
+ * stack. NULL (never entered) renders as the empty symbol field. */
+static const char *scr_library_entry_symbol = NULL;
+
+/* Detected-trap classification: the runtime's trap sites self-classify
+ * through their message conventions (the exact bytes the executable lane
+ * prints), so the kind → code mapping keys on those prefixes. The codes are
+ * the compiler registry's runtime family (diagnostics/diagnostic.ts —
+ * documented beside SC4012); SC4019 is the family's residual for detected
+ * traps outside the named kinds (environment failures, unsupported
+ * operations, the RC audit). */
+static const struct {
+  const char *prefix;
+  const char *code;
+} scr_library_trap_kinds[] = {
+  {"Uncaught ", "SC4013"},                  /* escaped exception at an entry */
+  {"scriptc: RangeError: ", "SC4014"},      /* range trap */
+  {"scriptc: TypeError: ", "SC4015"},       /* type trap */
+  {"scriptc: SyntaxError: ", "SC4016"},     /* syntax trap (regex compile) */
+  {"scriptc: out of memory", "SC4017"},     /* allocation failure */
+  {"scriptc: internal error: ", "SC4018"},  /* internal invariant failure */
+};
+
+static const char *scr_library_trap_code(const char *msg, size_t len) {
+  for (size_t i = 0; i < sizeof scr_library_trap_kinds / sizeof scr_library_trap_kinds[0]; i++) {
+    size_t plen = strlen(scr_library_trap_kinds[i].prefix);
+    if (len >= plen && memcmp(msg, scr_library_trap_kinds[i].prefix, plen) == 0) {
+      return scr_library_trap_kinds[i].code;
+    }
+  }
+  return "SC4019"; /* other detected trap */
+}
+
 static _Noreturn void scr_library_trap_deliver(const char *msg, size_t len, uint64_t addr) {
   scr_library_poisoned = true;
+  if (!(len > 0 && (uint8_t)msg[0] == 0x01)) {
+    /* A detected trap: assemble the structured message. Static buffer —
+     * no malloc on the failure path; text truncates before structure ever
+     * would (codes and symbols are short; an oversized remediation drops
+     * whole, never split). */
+    static char buf[2048];
+    const char *code = scr_library_trap_code(msg, len);
+    const char *text = msg;
+    size_t text_len = len;
+    const char *rem = NULL;
+    for (size_t i = 0; i < scr_library_trap_overlays_len; i++) {
+      const char *const *t = &scr_library_trap_overlays[3 * i];
+      if (strcmp(t[0], code) == 0) {
+        if (t[1] != NULL) {
+          text = t[1];
+          text_len = strlen(t[1]);
+        }
+        rem = t[2];
+        break;
+      }
+    }
+    const char *sym = scr_library_entry_symbol != NULL ? scr_library_entry_symbol : "";
+    size_t tail = 2 + strlen(code) + strlen(sym);
+    if (rem != NULL) {
+      if (tail + 1 + strlen(rem) > sizeof buf - 1) rem = NULL; /* drop whole, keep structure */
+      else tail += 1 + strlen(rem);
+    }
+    size_t n = 0;
+    buf[n++] = '\x01';
+    size_t cap = sizeof buf - 1 - tail;
+    if (text_len > cap) text_len = cap;
+    for (size_t i = 0; i < text_len; i++) {
+      /* The encoding reserves 0x01/0x1F; runtime messages never contain
+       * them, but an escaped exception's rendered text embeds user bytes. */
+      char c = text[i];
+      buf[n++] = (c == '\x01' || c == '\x1f') ? ' ' : c;
+    }
+    buf[n++] = '\x1f';
+    memcpy(buf + n, code, strlen(code));
+    n += strlen(code);
+    buf[n++] = '\x1f';
+    memcpy(buf + n, sym, strlen(sym));
+    n += strlen(sym);
+    if (rem != NULL) {
+      buf[n++] = '\x1f';
+      memcpy(buf + n, rem, strlen(rem));
+      n += strlen(rem);
+    }
+    msg = buf;
+    len = n;
+  }
   if (scr_library_sink != NULL) {
     scr_library_sink(scr_library_sink_ctx, (const uint8_t *)msg, len, addr);
   }
@@ -60,6 +159,14 @@ __attribute__((noinline)) _Noreturn void scr_trap(const char *msg) {
   scr_library_trap_deliver(msg, strlen(msg), SCR_TRAP_ADDR());
 }
 
+__attribute__((noinline)) _Noreturn void scr_trap_len(const char *msg, size_t len) {
+  /* The length-delimited funnel entry: structured trap-teaching messages
+   * and verbatim 0x01-led thrown messages are byte-counted, never
+   * NUL-scanned (a thrown JS string may embed NUL). Same poison-deliver-
+   * abort discipline as scr_trap. */
+  scr_library_trap_deliver(msg, len, SCR_TRAP_ADDR());
+}
+
 __attribute__((noinline)) _Noreturn void scr_trap_fmt(const char *fmt, ...) {
   static char buf[512]; /* no malloc on the invariant-failure path */
   va_list ap;
@@ -72,7 +179,11 @@ __attribute__((noinline)) _Noreturn void scr_trap_fmt(const char *fmt, ...) {
 
 /* ── entry prologues ──────────────────────────────────────────────────── */
 
-void scr_library_entry(bool reset_arena) {
+void scr_library_entry(bool reset_arena, const char *entry_symbol) {
+  /* Record the entry symbol FIRST so even a poisoned-abort's core dump
+   * names the entry; a trap anywhere below (the arena reset's OOM
+   * included) then reports the right symbol. */
+  scr_library_entry_symbol = entry_symbol;
   /* A poisoned library's entries abort deterministically — never through the
    * sink again (it received its exactly-once message when the trap fired),
    * never into a heap whose invariants already failed. */
@@ -125,13 +236,16 @@ ScrStr *scr_library_str_in(const uint8_t *p, size_t len) {
   return scr_str_new(len == 0 ? "" : (const char *)p, len);
 }
 
-ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len) {
+ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len, const char *trap_msg) {
   ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)len);
   if (b == NULL) {
     /* scr_bytes_new throws only for lengths past 2^53-1 — an impossible
-     * host buffer; funnel the contract violation instead of a NULL deref. */
+     * host buffer; funnel the contract violation instead of a NULL deref.
+     * The message is the wrapper's compiler-assembled structured
+     * trap-teaching form (code SC4012, the trapping export's symbol, the
+     * profile's teaching and remediation) — opaque bytes here. */
     scr_exc_clear();
-    scr_trap("scriptc: library inbound bytes length out of range\n");
+    scr_trap(trap_msg);
   }
   if (len > 0 && p != NULL) memcpy(b->data, p, len);
   return b;

package/src/scr_number.c

@@ -24,27 +24,19 @@
  * unchanged. Provides d2d(), d2d_small_int(), decimalLength17(), div10(). */
 #include "../vendor/ryu/d2s.c"
 
-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;
-  }
-
-  /* Shortest round-tripping digits via Ryū. Mirrors d2s_buffered_n's
-   * dispatch: the exact small-integer fast path first (trailing decimal
-   * zeros folded into the exponent), the full algorithm otherwise. */
+/* 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 already stripped */
+      (uint32_t)(bits >> DOUBLE_MANTISSA_BITS); /* sign must be stripped */
   floating_decimal_64 v;
   if (d2d_small_int(ieeeMantissa, ieeeExponent, &v)) {
     for (;;) {
@@ -60,9 +52,8 @@ size_t scr_f64_to_str(double x, char *buf) {
 
   /* Ryū's (mantissa, exponent) → ECMA's (digits, k, n): the k mantissa
    * digits have no trailing zeros, and value = 0.digits * 10^n. */
-  char digits[18];
   int k = (int)decimalLength17(v.mantissa);
-  int n = v.exponent + k;
+  *n_out = v.exponent + k;
   digits[k] = '\0';
   uint64_t m = v.mantissa;
   for (int i = k - 1; i >= 0; i--) {
@@ -70,6 +61,25 @@ size_t scr_f64_to_str(double x, char *buf) {
     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. */

package/src/scr_object.c

@@ -14,6 +14,24 @@ 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 long scr_live_objects = 0;
 long scr_obj_live_count(void) { return scr_live_objects; }