@scriptc/runtime 0.0.11 → 0.0.13

package/src/scr_dc.c

@@ -1,13 +1,13 @@
 /* node:diagnostics_channel — the in-process pub/sub core (scr_runtime.h
  * has the API contract). Linked only when the IR carries dc.* libCalls
- * (cc.ts; the zlib gating precedent), pure data structure over the DOM —
+ * (cc.ts; the zlib gating precedent), pure data structure over the checked-dynamic tree —
  * no loop hooks, no platform seams, cross-compiles everywhere.
  *
  * - The registry is process-global and append-only (Node's channels are
  *   process-lived too — its WeakRefMap only collects channels nothing
  *   references, which a compiled program cannot observe). Handles are
  *   1-based indexes so a zeroed f64 can never alias channel 0.
- * - Subscribers are DOM FUNCTION values. unsubscribe matches by the
+ * - Subscribers are dyn FUNCTION values. unsubscribe matches by the
  *   UNDERLYING closure when both sides are functions (boxing one function
  *   twice yields distinct ScrDyn nodes sharing one ScrClosure, and JS has
  *   ONE function object), falling back to node identity.
@@ -98,7 +98,7 @@ static ScrDcChannel *dc_of(double handle) {
 }
 
 /* Node's ERR_INVALID_ARG_TYPE for a non-function subscriber — the
- * "Received ..." tail covers the DOM kinds (determineSpecificType lite;
+ * "Received ..." tail covers the dyn kinds (determineSpecificType lite;
  * scr_dyn_handle.c's full renderer is not linked here). */
 static void dc_throw_bad_fn_arg(const ScrDyn *cb, const char *arg_name) {
   const char *received = "an instance of Object";
@@ -341,7 +341,7 @@ ScrDyn *scr_dc_chan_run_stores(double handle, ScrDyn *data, ScrDyn *fn, ScrDyn *
 /* ── TracingChannel ────────────────────────────────────────────────────
  * A registry entry of five channel indexes (start/end/asyncStart/asyncEnd/
  * error), handled as a 1-based f64 like Channel. The trace choreography
- * lives here in C over the DOM: publishes stash the pending traced-call /
+ * lives here in C over the checked-dynamic tree: publishes stash the pending traced-call /
  * subscriber exception in a ScrCaught box first (compiled subscriber
  * bodies run with a CLEAR cell — a pending flag would unwind them at
  * their first call) and re-raise after, so throws propagate exactly like
@@ -468,8 +468,8 @@ bool scr_dc_tc_unsubscribe(double h, ScrDyn *handlers) {
   return done;
 }
 
-/* The pending exception as a DOM value for ctx.error: scr_caught_to_dyn
- * (scr_json.c) — identity-preserving for DOM payloads and %Error
+/* The pending exception as a dyn value for ctx.error: scr_caught_to_dyn
+ * (scr_json.c) — identity-preserving for dyn payloads and %Error
  * instances (the identity-cached crossing: the stamped ctx.error compares
  * reference-equal to the thrown error's other boxings). */
 
@@ -586,7 +586,7 @@ static void dc_tp_entry(ScrFiber *self, void *ap) {
   free(a);
 }
 
-/* The traced result as a promise (+1): a DOM promise unwraps, anything
+/* The traced result as a promise (+1): a dyn promise unwraps, anything
  * else is PromiseResolve'd (Node converts non-promise returns; a raw
  * non-promise return on the NO-SUBSCRIBER path wraps too — the lowering
  * types the result Promise<unknown>, a wrap Node skips, SEMANTICS.md). */
@@ -728,7 +728,7 @@ ScrDyn *scr_dc_tc_trace_callback(double h, ScrDyn *fn, double position, ScrDyn *
     dc_throw_bad_fn_arg(cb, "callback");
     return NULL;
   }
-  /* Splice the wrapper in (a fresh argument vector; the DOM array is
+  /* Splice the wrapper in (a fresh argument vector; the dyn array is
    * borrowed and Node's splice mutation is unobservable through it — the
    * caller rebuilt it from the call site's arguments). */
   ScrClosure *clo = scr_closure_new((void *)dc_tc_wrapped_cb, 3);

package/src/scr_dgram.c

@@ -1020,7 +1020,7 @@ void scr_dgram_install(void) {
 
 /* ── the send argument-validation ladder (checked-dynamic lane) ─────────
  * Node's Socket.prototype.send signature shuffle and validation order
- * over DOM arguments, byte-for-byte: the connected/unconnected split
+ * over dyn arguments, byte-for-byte: the connected/unconnected split
  * decides whether (a1, a2) are an offset/length slice or the port/address
  * pair; sliceBuffer validates the buffer's type and bounds
  * (ERR_BUFFER_OUT_OF_BOUNDS); list payloads validate per element with the

package/src/scr_dyn_handle.c

@@ -1,10 +1,10 @@
 /* The checked-dynamic HANDLE support unit — everything the handle
  * dispatchers (scr_http.c / scr_net.c) and the emitter unit's dyn
- * registrations share BEYOND the DOM core: the listener gate over the
+ * registrations share BEYOND the dyn core: the listener gate over the
  * ERR_INVALID_ARG_TYPE throwers (the throwers themselves live in
- * scr_json.c beside the DOM core — the always-linked bytes/fs argument
+ * scr_json.c beside the dyn core — the always-linked bytes/fs argument
  * validators call them too), and the runtime-built listener adapter
- * closures whose fire thunks box event tuples back into the DOM. Split
+ * closures whose fire thunks box event tuples back into the checked-dynamic tree. Split
  * out of scr_json.c so handle-free binaries keep their exact size
  * class: cc.ts compiles this unit exactly when a user of it links (the
  * net or emitter gate — http implies net).
@@ -24,7 +24,7 @@ void scr_dyn_check_listener(const ScrDyn *cb, const char *argname) {
 
 /* ── runtime-built listener closures (the handle dispatchers' .on paths) ─
  * One capture: a box holding the retained dyn FUNCTION value. The fire
- * thunks box the event tuple back into the DOM and call through the
+ * thunks box the event tuple back into the checked-dynamic tree and call through the
  * checked-dynamic machinery (scr_dyn_call — per-arg validation lives in
  * the boxed thunk). A throw from the listener stays pending, exactly like
  * a compiler-emitted listener body. */
@@ -56,7 +56,7 @@ void scr_dyn_listener_fire_data(ScrClosure *cb, ScrBytes *chunk) {
 
 void scr_dyn_listener_fire_err(ScrClosure *cb, ScrStr *msg) {
   ScrDyn *fn = scr_dyn_listener_peek(cb);
-  /* The DOM's error encoding (caughtToDyn's shape) — what a dyn 'error'
+  /* The checked-dynamic tree's error encoding (caughtToDyn's shape) — what a dyn 'error'
    * listener body can instanceof-test and read .message from. */
   ScrDyn *arg = scr_dyn_new_obj();
   scr_dyn_obj_set(arg, "%error", 6, scr_dyn_new_bool(true));

package/src/scr_dyn_invoke.c

@@ -1,10 +1,10 @@
 /* Prototype-method dispatch on checked-dynamic receivers (scr_dyn_invoke)
- * and its companions: JS String() over the DOM (scr_dyn_display — join
+ * and its companions: JS String() over the checked-dynamic tree (scr_dyn_display — join
  * and the error texts need it standalone) and Object.defineProperties
- * over DOM values (scr_dyn_define_props). Linked only when the IR
+ * over dyn values (scr_dyn_define_props). Linked only when the IR
  * carries dynInvoke nodes or dyn.defineProps calls (cc.ts gates on
  * moduleUsesDynInvoke — the scr_assert.c precedent), so dispatch-free
- * binaries keep their exact size class. The DOM itself lives in
+ * binaries keep their exact size class. The checked-dynamic tree itself lives in
  * scr_json.c; this unit uses only its public surface plus ScrJsonBuf.
  */
 #include "scr_runtime.h"
@@ -16,8 +16,8 @@
 
 /* ── checked-dynamic METHOD DISPATCH (scr_dyn_invoke) ──────────────────
  *
- * `recv.m(args)` where recv is a DOM value and `m` is a name a
- * DOM-representable prototype declares (Array/String/Function shared
+ * `recv.m(args)` where recv is a dyn value and `m` is a name a
+ * dyn-representable prototype declares (Array/String/Function shared
  * names — push, slice, forEach, apply, ...): a stored-member read would
  * silently mis-answer real methods, so the dispatch runs HERE, over the
  * receiver's runtime kind. test/common's mustCall internals are the
@@ -38,10 +38,10 @@
  * recv/args are BORROWED; the result is owned (+1). MAY THROW (returns
  * NULL with the exception pending). */
 
-/* JS String() over a DOM value, runtime-side (join needs it standalone —
+/* JS String() over a dyn value, runtime-side (join needs it standalone —
  * the emitted sc_ds walker exists only in programs that spell
  * String(unknown) themselves). Same rules: arrays join with "," and
- * null/undefined elements print empty, the DOM's error encoding renders
+ * null/undefined elements print empty, the checked-dynamic tree's error encoding renders
  * "name: message", functions render the native-code form, plain objects
  * are [object Object]. */
 static void scr_dyn_display_buf(ScrJsonBuf *b, const ScrDyn *d) {
@@ -192,7 +192,7 @@ static bool dyn_cb_check(ScrDyn *const *args, size_t argc) {
   ScrDyn *cb = argc > 0 ? args[0] : scr_dyn_undefined();
   if (cb->kind == SCR_DYN_FUNC) return true;
   /* An ENGINE function is callable — scr_dyn_call's JSVAL arm routes it
-   * (the loops below call through scr_dyn_call, which converts the DOM
+   * (the loops below call through scr_dyn_call, which converts the checked-dynamic tree
    * element arguments per the uniform crossing). A wrapped NON-function
    * falls through to the display path: String(cb) renders through the
    * engine, exactly Node's message. */
@@ -215,7 +215,7 @@ static ScrDyn *scr_dynh_dispatch(ScrDyn *recv, const char *method, ScrDyn *const
   return ops->invoke(recv->v.handle.ptr, recv, method, args, argc, what);
 }
 
-/* JS Array.prototype.sort over a DOM array: the spec's snapshot-sort —
+/* JS Array.prototype.sort over a dyn array: the spec's snapshot-sort —
  * elements copy (retained) into a work list, a stable merge sort orders
  * it (undefined elements sink to the end before any comparator runs),
  * and the ordered list writes back index by index, so a comparator that
@@ -339,7 +339,7 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
   /* Island-held receivers: the ENGINE runs its own prototypes (JS-exact
    * flatMap/map/forEach/filter — Array.prototype is the engine's) through
    * scr_jsval_call_method; arguments cross per the uniform conversion
-   * (wrapped cells by reference, DOM data deep-copied, FUNC boxes through
+   * (wrapped cells by reference, dyn data deep-copied, FUNC boxes through
    * the host shim), a missing member throws the engine's own TypeError,
    * and the result wraps back scalar-normalized. `what` is unused — the
    * engine's message names the failure. */
@@ -352,7 +352,7 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
   if (recv->kind == SCR_DYN_OBJ) {
     ScrDyn *m = scr_dyn_obj_get(recv, method, strlen(method));
     if (m && (m->kind == SCR_DYN_FUNC ||
-              /* a WRAPPED engine function stored as a DOM member: the
+              /* a WRAPPED engine function stored as a dyn member: the
                * routed call (scr_dyn_call's JSVAL arm) runs it. */
               (m->kind == SCR_DYN_JSVAL && scr_dyn_isl_typeof_is(m, "function")))) {
       /* JS binds the receiver for the call (`obj.method()` — this === obj):
@@ -584,8 +584,8 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
       return scr_dyn_retain(scr_dyn_undefined()); /* forEach */
     }
     if (dyn_name_is(method, "flatMap")) {
-      /* JS Array.prototype.flatMap over a DOM array: map + a depth-1
-       * flatten. Native DOM-array results flatten element-by-element; a
+      /* JS Array.prototype.flatMap over a dyn array: map + a depth-1
+       * flatten. Native dyn-array results flatten element-by-element; a
        * WRAPPED engine array flattens through the routed keyed reads
        * (elements wrap back scalar-normalized); everything else pushes
        * as a single element (JS keeps non-array callback results whole).
@@ -671,9 +671,33 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
     return NULL;
   }
 
-  if (recv->kind == SCR_DYN_BYTES && dyn_bytes_proto_real(method)) {
-    dyn_throw_unsupported("Uint8Array", method);
-    return NULL;
+  if (recv->kind == SCR_DYN_BYTES) {
+    ScrBytes *bytes = recv->v.bytes;
+    size_t blen = bytes->len;
+    if (dyn_name_is(method, "at")) {
+      double iD = dyn_index_arg(args, argc, 0, 0, what);
+      if (scr_exc_pending()) return NULL;
+      double idx = iD < 0 ? (double)blen + iD : iD;
+      if (idx < 0 || idx >= (double)blen) return scr_dyn_retain(scr_dyn_undefined());
+      return scr_dyn_new_num((double)bytes->data[(size_t)idx]);
+    }
+    if (dyn_name_is(method, "slice") || dyn_name_is(method, "subarray")) {
+      /* Both COPY (no views in this runtime — the static lane's
+       * documented divergence for subarray/Buffer.slice); the result
+       * keeps the receiver's Buffer flavor. */
+      double startD = dyn_index_arg(args, argc, 0, 0, what);
+      if (scr_exc_pending()) return NULL;
+      double endD = dyn_index_arg(args, argc, 1, (double)blen, what);
+      if (scr_exc_pending()) return NULL;
+      ScrBytes *out = scr_bytes_slice(bytes, startD, endD);
+      ScrDyn *d = recv->buffer ? scr_dyn_new_buffer_copy(out) : scr_dyn_new_bytes_copy(out);
+      scr_bytes_release(out);
+      return d;
+    }
+    if (dyn_bytes_proto_real(method)) {
+      dyn_throw_unsupported("Uint8Array", method);
+      return NULL;
+    }
   }
 
   /* NUM/BOOL/BYTES-remainder: the name is no method of this kind — JS's
@@ -682,9 +706,9 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
   return NULL;
 }
 
-/* Object.defineProperties over DOM values (see scr_runtime.h). Value
+/* Object.defineProperties over dyn values (see scr_runtime.h). Value
  * descriptors only: writable/enumerable/configurable accepted and IGNORED
- * (DOM properties are plain data properties — SEMANTICS.md); get/set
+ * (dyn properties are plain data properties — SEMANTICS.md); get/set
  * throw the loud unsupported Error, never a silent drop. */
 ScrDyn *scr_dyn_define_props(ScrDyn *target, ScrDyn *descs) {
   /* Island-held operands ARE objects to Node — the non-object TypeError

package/src/scr_error.c

@@ -44,9 +44,9 @@ static void scr_error_gcfree(void *obj) {
   scr_cyc_free(e);
 }
 
-/* DOMException teardown: the ScrError fields plus the owned cause DOM
+/* DOMException teardown: the ScrError fields plus the owned cause dyn
  * value. The cause is a ScrDyn — scr_json.c territory — and this file
- * must stay linkable WITHOUT the DOM (the runtime C-unit tests link
+ * must stay linkable WITHOUT the checked-dynamic tree (the runtime C-unit tests link
  * subsets), so the drop goes through a hook scr_json.c installs before
  * any cause can exist (scr_domex_new is the only producer). */
 static void (*scr_domex_cause_drop)(void *obj) = NULL;
@@ -273,7 +273,7 @@ void scr_undef_global_read(ScrStr *name) {
 /* ── DOMException ─────────────────────────────────────────────────────
  * The web-standard error shape (a Node global since v17): the ScrError
  * prefix plus the WebIDL slots (legacy numeric code, the options form's
- * cause). Construction resolves WebIDL's optionality over borrowed DOM
+ * cause). Construction resolves WebIDL's optionality over borrowed dyn
  * arguments — one place, shared by the compiled `new DOMException(...)`
  * and the runtime's own throw sites (atob/btoa). */
 

package/src/scr_events_emitter.c

@@ -466,7 +466,7 @@ ScrEmitter *scr_emitter_off_dyn(ScrEmitter *em, ScrStr *name, const ScrDyn *cb)
  * the simple '-quoted spelling — listener mistakes are words, not escape
  * zoos). */
 void scr_emitter_check_listener(const ScrDyn *cb) {
-  /* The shared gate lives in the always-linked DOM core (scr_json.c) so
+  /* The shared gate lives in the always-linked dyn core (scr_json.c) so
    * the handle dispatchers' .on paths render the same shapes without
    * linking this unit. */
   scr_dyn_check_listener(cb, "listener");