@scriptc/runtime 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "scriptc native runtime — C sources, compiled into every scriptc binary",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/src/scr_exception.c

@@ -185,6 +185,26 @@ ScrStr *scr_caught_to_string(const ScrCaught *c) {
 void scr_library_check_exc(void) {
   if (!scr_exc_pending()) return;
   static char buf[1024]; /* the message is copied out before the payload dies */
+  /* The ratified verbatim rule: a thrown message that ALREADY begins with
+   * the structured trap-teaching marker (0x01) is delivered exactly as
+   * authored — no "Uncaught " prefix, no added newline — which is how a
+   * facade-authored structured teaching rides the throw channel through to
+   * the sink. Both throw idioms qualify: a thrown string, and an Error
+   * whose .message starts with the marker. Everything else keeps the
+   * baseline "Uncaught ..." shape below, whose first byte is printable —
+   * the guarantee the marker's unambiguity rests on. */
+  const ScrStr *marked = NULL;
+  if (scr_exc_kind == SCR_EXC_STR) {
+    marked = (const ScrStr *)scr_exc_payload;
+  } else if (scr_exc_kind == SCR_EXC_OBJ && scr_error_is(scr_exc_payload)) {
+    marked = ((const ScrError *)scr_exc_payload)->message;
+  }
+  if (marked != NULL && marked->len > 0 && (uint8_t)marked->data[0] == 0x01) {
+    size_t take = marked->len > sizeof buf ? sizeof buf : marked->len;
+    memcpy(buf, marked->data, take);
+    scr_exc_reset(); /* the payload is released before the funnel poisons */
+    scr_trap_len(buf, take);
+  }
   size_t n = 0;
   const char prefix[] = "Uncaught ";
   memcpy(buf, prefix, sizeof prefix - 1);

package/src/scr_island.c

@@ -1412,8 +1412,27 @@ static JSValue isl_hostfn_invoke(JSContext *ctx, JSValueConst this_val, int argc
   IslHostFn *b = JS_GetOpaque(func_data[0], isl_hostfn_class_id);
   if (!b) return JS_ThrowTypeError(ctx, "detached scriptc host function");
   ScrJsval *cells[ISL_HOSTFN_MAX_ARITY];
-  for (int i = 0; i < b->arity; i++) {
-    cells[i] = isl_cell_new(i < argc ? JS_DupValue(ctx, argv[i]) : JS_UNDEFINED);
+  int ncells;
+  if (b->arity < 0) {
+    /* The ISLAND-REST shape (negative arity = -(leading declared + 1)):
+     * leading params pad/drop like any host call; the trailing cell is a
+     * fresh ENGINE ARRAY of the surplus arguments — the closure's rest
+     * binding IS the engine's own arguments array. */
+    int leading = -b->arity - 1;
+    for (int i = 0; i < leading; i++) {
+      cells[i] = isl_cell_new(i < argc ? JS_DupValue(ctx, argv[i]) : JS_UNDEFINED);
+    }
+    JSValue rest = JS_NewArray(ctx);
+    for (int i = leading; i < argc; i++) {
+      JS_SetPropertyUint32(ctx, rest, (uint32_t)(i - leading), JS_DupValue(ctx, argv[i]));
+    }
+    cells[leading] = isl_cell_new(rest);
+    ncells = leading + 1;
+  } else {
+    for (int i = 0; i < b->arity; i++) {
+      cells[i] = isl_cell_new(i < argc ? JS_DupValue(ctx, argv[i]) : JS_UNDEFINED);
+    }
+    ncells = b->arity;
   }
   bool strayed_before = isl_anchor_strayed;
   isl_host_depth++;
@@ -1429,7 +1448,7 @@ static JSValue isl_hostfn_invoke(JSContext *ctx, JSValueConst this_val, int argc
     isl_anchor_here();
     isl_anchor_strayed = strayed_before;
   }
-  for (int i = 0; i < b->arity; i++) scr_jsval_release(cells[i]);
+  for (int i = 0; i < ncells; i++) scr_jsval_release(cells[i]);
   if (scr_exc_pending()) {
     if (r) scr_jsval_release(r);
     return isl_throw_pending(ctx);
@@ -1443,7 +1462,9 @@ static JSValue isl_hostfn_invoke(JSContext *ctx, JSValueConst this_val, int argc
 ScrJsval *scr_jsval_from_closure(ScrClosure *c, int arity,
                                   ScrJsval *(*adapt)(ScrClosure *, ScrJsval **)) {
   isl_entry();
-  if (arity > ISL_HOSTFN_MAX_ARITY) {
+  /* Negative arity = the island-rest shape; the CELL count is the leading
+   * declared params + the one rest-array slot. */
+  if ((arity < 0 ? -arity : arity) > ISL_HOSTFN_MAX_ARITY) {
     fprintf(stderr, "scriptc: island callback arity %d exceeds %d\n", arity,
             ISL_HOSTFN_MAX_ARITY);
     abort(); /* the frontend fences this; reaching here is a compiler bug */
@@ -1459,7 +1480,7 @@ ScrJsval *scr_jsval_from_closure(ScrClosure *c, int arity,
   JSValue box = JS_NewObjectClass(isl_ctx, isl_hostfn_class_id);
   JS_SetOpaque(box, b);
   JSValueConst data[1] = {box};
-  JSValue fn = JS_NewCFunctionData(isl_ctx, isl_hostfn_invoke, arity, 0, 1, data);
+  JSValue fn = JS_NewCFunctionData(isl_ctx, isl_hostfn_invoke, arity < 0 ? -arity - 1 : arity, 0, 1, data);
   JS_FreeValue(isl_ctx, box); /* fn's func_data holds its own reference */
   return isl_cell_new(fn);
 }
@@ -1717,6 +1738,60 @@ ScrJsval *scr_jsval_obj_lit(int npairs, ScrJsval **kv) {
   return isl_cell_new(o);
 }
 
+/* The engine-native TemplateStringsArray for an island tag call: `kv`
+ * carries n cooked strings then n raw strings — a fresh array whose
+ * `.raw` property holds the raw spellings, exactly the object a tagged
+ * template hands its tag (a JSON marshal would drop `.raw`, and tags
+ * dispatch on it). */
+ScrJsval *scr_jsval_tpl_strings(int n, ScrJsval **kv) {
+  isl_entry();
+  JSValue cooked = JS_NewArray(isl_ctx);
+  JSValue raw = JS_NewArray(isl_ctx);
+  for (int i = 0; i < n; i++) {
+    JS_SetPropertyUint32(isl_ctx, cooked, (uint32_t)i, JS_DupValue(isl_ctx, kv[i]->v));
+    JS_SetPropertyUint32(isl_ctx, raw, (uint32_t)i, JS_DupValue(isl_ctx, kv[n + i]->v));
+  }
+  JS_SetPropertyStr(isl_ctx, cooked, "raw", raw); /* consumes raw */
+  return isl_cell_new(cooked);
+}
+
+/* Spread completion for an island-native literal: copies `src`'s own
+ * enumerable properties onto `obj` — the engine's own Object.assign (the
+ * spec's CopyDataProperties; null/undefined sources spread nothing) — and
+ * answers the target retained (+1). NULL with the exception pending when
+ * a source getter throws. */
+ScrJsval *scr_jsval_obj_spread(ScrJsval *obj, ScrJsval *src) {
+  isl_entry();
+  if (JS_IsNull(src->v) || JS_IsUndefined(src->v)) return scr_jsval_retain(obj);
+  JSValue global = JS_GetGlobalObject(isl_ctx);
+  JSValue object_ctor = JS_GetPropertyStr(isl_ctx, global, "Object");
+  JS_FreeValue(isl_ctx, global);
+  JSValue assign = JS_GetPropertyStr(isl_ctx, object_ctor, "assign");
+  JS_FreeValue(isl_ctx, object_ctor);
+  JSValueConst args[2] = { obj->v, src->v };
+  JSValue r = JS_Call(isl_ctx, assign, JS_UNDEFINED, 2, args);
+  JS_FreeValue(isl_ctx, assign);
+  if (JS_IsException(r)) {
+    isl_bridge_exception();
+    return NULL;
+  }
+  JS_FreeValue(isl_ctx, r); /* assign answers the target itself */
+  return scr_jsval_retain(obj);
+}
+
+/* Getter completion for an island-native literal: defines `key` on `obj`
+ * as an engine GETTER invoking `fn` (a marshaled host function), and
+ * answers the object retained (+1) so builds chain. Enumerable +
+ * configurable, no setter — exactly a JS object-literal `get k() {}`. */
+ScrJsval *scr_jsval_define_getter(ScrJsval *obj, ScrJsval *key, ScrJsval *fn) {
+  isl_entry();
+  JSAtom k = JS_ValueToAtom(isl_ctx, key->v);
+  JS_DefinePropertyGetSet(isl_ctx, obj->v, k, JS_DupValue(isl_ctx, fn->v), JS_UNDEFINED,
+                          JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE);
+  JS_FreeAtom(isl_ctx, k);
+  return scr_jsval_retain(obj);
+}
+
 ScrJsval *scr_jsval_arr_lit(int n, ScrJsval **elems) {
   isl_entry();
   JSValue a = JS_NewArray(isl_ctx);

package/src/scr_json.c

@@ -1078,6 +1078,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 +2109,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_library.c

@@ -60,6 +60,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;
@@ -125,13 +133,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_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; }

package/src/scr_runtime.h

@@ -67,7 +67,22 @@ typedef struct ScrBytes ScrBytes;
  * call; address is the trap site's return address (0 when the toolchain
  * cannot supply one); ctx is the registration's opaque pointer. The sink
  * must not call back into any library entry and must not unwind or longjmp
- * back into library frames. */
+ * back into library frames.
+ *
+ * Message shape (the ratified structured trap-teaching encoding): a
+ * BASELINE message is plain text whose first byte is printable (>= 0x20) —
+ * no emitter path ever produces an unstructured message starting below
+ * 0x20. A STRUCTURED message begins with the marker byte 0x01 followed by
+ * the human teaching text and 0x1F-separated fields:
+ *
+ *   0x01  text  0x1F code  0x1F symbol  [ 0x1F remediation ]
+ *
+ * so msg_len > 0 && msg[0] == 0x01 is the one version test. Parse: split
+ * the bytes after the marker on 0x1F — field 0 is the human text, 1 the
+ * diagnostic code, 2 the trapping symbol as the host linked it, 3 the
+ * remediation; a missing or empty field means none; ignore any field past
+ * the fourth. Fields are (pointer, length) — never assume NUL termination.
+ * A plain-text host may print the whole buffer: the teaching leads it. */
 typedef void (*ScrLibSinkFn)(void *ctx, const uint8_t *msg, size_t msg_len,
                               uint64_t address);
 void scr_library_set_sink(ScrLibSinkFn fn, void *ctx); /* latest wins */
@@ -96,16 +111,29 @@ void scr_library_register_reset(void (*fn)(void));
 /* An escaped exception at an entry boundary: renders the same "Uncaught
  * ..." text the executable epilogue prints, releases the payload, and
  * routes the text through the trap funnel. No-op when nothing is pending.
- * Defined in scr_exception.c (it owns the cell). */
+ * The ratified verbatim rule: a thrown message that ALREADY begins with the
+ * structured marker 0x01 (a thrown string, or an Error whose .message
+ * starts with it) is delivered byte-for-byte — no "Uncaught " prefix, no
+ * added newline — which is how facade-authored structured teachings ride
+ * the throw channel to the sink. Defined in scr_exception.c (it owns the
+ * cell). */
 void scr_library_check_exc(void);
 
+/* The length-taking funnel entry (library lane only): delivers exactly the
+ * given bytes to the sink — the verbatim path above needs it because a
+ * structured message is length-delimited, never NUL-scanned. */
+_Noreturn void scr_trap_len(const char *msg, size_t len);
+
 /* Marshalling helpers the generated wrappers call (both emissions share
  * these bodies, which is how the two lanes stay identical by
  * construction). Inbound is borrowed-and-copied; outbound values MOVE into
  * the result arena and stay valid until the next arena reset. String
  * results are NUL-terminated after *out_len bytes (ScrStr's layout). */
 ScrStr *scr_library_str_in(const uint8_t *p, size_t len);   /* +1 */
-ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len); /* +1, u8 */
+/* trap_msg is the wrapper's compiler-assembled host-contract trap message
+ * (structured trap-teaching bytes naming this entry's symbol), delivered
+ * through the funnel when len falls outside the marshalling class. */
+ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len, const char *trap_msg); /* +1, u8 */
 void scr_library_str_out(ScrStr *s, const uint8_t **out, size_t *out_len);
 void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len);
 
@@ -287,6 +315,10 @@ void *scr_classobj_retain_v(void *c);
 void scr_classobj_release_v(void *c);
 /* `X.name` (+1 — a no-op retain on the interned immortal). */
 ScrStr *scr_classobj_name(ScrClassObj *c);
+/* The keyed-write miss on a fixed-shape record: throws the catchable
+ * TypeError naming the key (JS would add the property — the documented
+ * monomorphic-struct divergence). scr_object.c. */
+void scr_record_key_miss(ScrStr *k);
 
 /* ── error objects (scr_error.c) ──────────────────────────────────────
  * `Error` and its lib subclasses (TypeError/RangeError/SyntaxError) are a
@@ -2640,6 +2672,13 @@ ScrDyn *scr_dyn_obj_get(const ScrDyn *d, const char *key, size_t key_len);
  * member nodes. null/undefined receivers throw Node's catchable
  * TypeError. */
 ScrDyn *scr_dyn_obj_keys(const ScrDyn *v);
+/* Object.hasOwn over a DOM receiver: OBJ member presence, ARR index
+ * bounds ("length" included); nullish receivers throw Node's ToObject
+ * TypeError; every other kind answers false. */
+bool scr_dyn_has_own(const ScrDyn *v, const ScrStr *key);
+/* Object.assign over DOM values (+1 target back; ToObject TypeError on a
+ * nullish target). */
+ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src);
 ScrDyn *scr_dyn_obj_values(const ScrDyn *v);
 ScrDyn *scr_dyn_obj_entries(const ScrDyn *v);
 
@@ -3765,6 +3804,16 @@ ScrPromise *scr_jsval_bridge_promise(ScrJsval *v, int payload);
  * marshaled strings) or an array from elements. Borrow argv; +1 out.
  * Cannot fail (allocation failure aborts, like every runtime OOM). */
 ScrJsval *scr_jsval_obj_lit(int npairs, ScrJsval **kv);
+/* Getter completion for an island literal: defines `key` on `obj` as an
+ * engine getter invoking `fn`; answers the object retained (+1). */
+ScrJsval *scr_jsval_define_getter(ScrJsval *obj, ScrJsval *key, ScrJsval *fn);
+/* The engine TemplateStringsArray for an island tag call: n cooked then n
+ * raw strings; the result array carries `.raw` (+1). */
+ScrJsval *scr_jsval_tpl_strings(int n, ScrJsval **kv);
+/* Spread completion for an island literal: engine CopyDataProperties of
+ * `src` onto `obj`; answers the target (+1), NULL + pending on a getter
+ * throw. */
+ScrJsval *scr_jsval_obj_spread(ScrJsval *obj, ScrJsval *src);
 ScrJsval *scr_jsval_arr_lit(int n, ScrJsval **elems);
 
 /* Marshal out (island → static): validated, STRICT extraction — a