@scriptc/runtime 0.0.10 → 0.0.12

package/package.json

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

package/src/scr_assert.c

@@ -396,15 +396,15 @@ void scr_assert_ref_eq_fn(const ScrClosure *a, const ScrClosure *b, bool negated
 }
 
 /* ── strictEqual / deepStrictEqual over CHECKED-DYNAMIC (dyn) operands ──
- * The DOM carries the value's kind at runtime, so one entry point serves
+ * The checked-dynamic tree carries the value's kind at runtime, so one entry point serves
  * the whole quartet: SameValue for the strict pair (numbers by Object.is,
  * strings by bytes, units by kind, arrays/objects/bytes by node identity,
  * functions by the BOXED CLOSURE — two dyn crossings of one function are
- * the same JS function), a structural DOM walk for the deep pair.
+ * the same JS function), a structural dyn walk for the deep pair.
  *
  * Failure messages reproduce Node's assertion_error.js against the v24
  * sources: inspectValue is a compact:false / sorted:true / depth-1000
- * rendering of the DOM (each entry on its own line, entries sorted by
+ * rendering of the checked-dynamic tree (each entry on its own line, entries sorted by
  * their RENDERED text — Node's `sorted: true` sorts formatted entries),
  * the simple/stacked scalar forms match the static paths byte-for-byte,
  * and composite diffs run the real myers line diff with Node's printer
@@ -415,7 +415,7 @@ void scr_assert_ref_eq_fn(const ScrClosure *a, const ScrClosure *b, bool negated
  * the [Function: name] form, and values rendering past ~4096 lines fall
  * back to the whole-value +/- form without context collapsing. */
 
-/* JS SameValue over two DOM values (Object.is — the strictEqual and
+/* JS SameValue over two dyn values (Object.is — the strictEqual and
  * notStrictEqual comparison). Functions compare by boxed closure: the
  * ScrDyn box is a boundary artifact, the closure IS the JS identity. */
 static bool scr_assert_dyn_same_value(const ScrDyn *a, const ScrDyn *b) {
@@ -449,19 +449,19 @@ static bool scr_assert_dyn_same_value(const ScrDyn *a, const ScrDyn *b) {
   }
 }
 
-/* Node's strict deep equality over two DOM values: kind-wise — Object.is
+/* Node's strict deep equality over two dyn values: kind-wise — Object.is
  * numbers, byte-equal strings, units by kind, per-element arrays,
- * key-set-plus-values objects (DOM keys are unique, so equal lengths and
+ * key-set-plus-values objects (dyn keys are unique, so equal lengths and
  * an a⊆b value walk prove the bijection), brand-aware bytes (the buffer
  * flavor bit IS the Buffer-vs-Uint8Array prototype Node compares first),
  * reference identity for functions (boxed closure). Plain recursion:
- * JSON-origin DOMs are trees; a keyed-write cycle (h.self = h) has no
+ * JSON-origin dyn values are trees; a keyed-write cycle (h.self = h) has no
  * memo here where Node carries one (documented divergence). */
 static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
   if (a == b) return true;
   if (a->kind != b->kind) {
     /* A MIXED comparison with an island side (wrapped engine object vs
-     * DOM data): Node walks both structurally — a plain `false` would
+     * dyn data): Node walks both structurally — a plain `false` would
      * mint a fabricated AssertionError for values Node may call equal.
      * Loud fence (the long-tail lane's structural walk). */
     if (a->kind == SCR_DYN_JSVAL || b->kind == SCR_DYN_JSVAL) {
@@ -528,7 +528,7 @@ static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
   return false; /* unreachable */
 }
 
-/* ── inspectValue over the DOM (assertion_error.js's inspect options:
+/* ── inspectValue over the checked-dynamic tree (assertion_error.js's inspect options:
  * compact:false, sorted:true, depth 1000, maxArrayLength Infinity) ───── */
 
 #define SCR_ASSERT_CF_DEPTH 1000
@@ -924,7 +924,7 @@ static bool scr_assert_print_myers(ScrAssertBuf *b, const ScrDiffOp *diff, size_
 
 /* ── the dyn entry point ─────────────────────────────────────────────── */
 
-/* Is this DOM kind `typeof == "object" && != null` to assertion_error.js? */
+/* Is this dyn kind `typeof == "object" && != null` to assertion_error.js? */
 static bool scr_assert_dyn_is_object(const ScrDyn *d) {
   return d->kind == SCR_DYN_ARR || d->kind == SCR_DYN_OBJ || d->kind == SCR_DYN_BYTES ||
          d->kind == SCR_DYN_HANDLE || d->kind == SCR_DYN_PROMISE ||
@@ -1095,7 +1095,7 @@ static void scr_assert_dyn_neq_fail(ScrDyn *a, bool deep, ScrStr *msg, bool has_
 }
 
 /* strictEqual / notStrictEqual / deepStrictEqual / notDeepStrictEqual
- * where either operand is a checked-dynamic value (both arrive as DOM
+ * where either operand is a checked-dynamic value (both arrive as dyn
  * values — the frontend boxes a static side). Borrows everything. */
 void scr_assert_eq_dyn(ScrDyn *a, ScrDyn *b, bool negated, bool deep,
                        ScrStr *msg, bool has_msg) {
@@ -1113,7 +1113,7 @@ void scr_assert_eq_dyn(ScrDyn *a, ScrDyn *b, bool negated, bool deep,
 }
 
 /* Node's expectsError over an error-INSTANCE expected (assert.throws/
- * rejects second argument): every key of the expected DOM error (the
+ * rejects second argument): every key of the expected dyn error (the
  * %error marker skipped; name/message/code is the encoding's surface)
  * must deep-strict-equal the caught value's — extra ACTUAL keys are fine
  * (Node walks the expected's keys only). A mismatch fails through the
@@ -1441,7 +1441,7 @@ void scr_assert_iferror_bool(bool v) {
 }
 
 /* The checked-dynamic argument (test/common's mustSucceed wrapper): the
- * DOM kind dispatches — units pass quietly, %error-marked objects (the
+ * dyn kind dispatches — units pass quietly, %error-marked objects (the
  * caughtToDyn encoding) throw with the error's message (its name when
  * the message is empty, Node's rule), everything else throws with the
  * value's inspection. */

package/src/scr_async.c

@@ -272,7 +272,7 @@ struct ScrFiber {
 
 /* ── AsyncLocalStorage (node:async_hooks) ─────────────────────────────
  * Stores are process-lived ids; the CONTEXT is an immutable refcounted
- * snapshot of (store id → DOM value) entries. One ACTIVE SLOT pointer
+ * snapshot of (store id → dyn value) entries. One ACTIVE SLOT pointer
  * (the exc-cell pattern): main owns a static slot, every fiber owns its
  * own field, scr_switch repoints the active slot — so run()'s window
  * rides the fiber across awaits, and a spawned fiber INHERITS the
@@ -591,7 +591,8 @@ ScrArr *scr_active_resources(void) {
  * left queued on the uncaught paths) never run — the teardown releases
  * them, like Node dropping the queue at exit. */
 typedef struct ScrNtick {
-  ScrClosure *cb; /* owned */
+  ScrClosure *cb;    /* owned; NULL for a raw C-hook entry */
+  void (*raw)(void); /* the hook when cb == NULL (stream tick markers) */
   struct ScrNtick *next;
 } ScrNtick;
 
@@ -612,11 +613,25 @@ void scr_next_tick(ScrClosure *cb /*moves*/) {
   scr_nt_tail = t;
 }
 
+/* A RAW C-hook tick: the stream unit enqueues one marker per deferred
+ * stream emission so those emissions interleave with user nextTicks in
+ * true FIFO order — in Node they ARE nextTicks (resume_, emitReadable_,
+ * endReadableNT, ...). The hook dispatches exactly one stream tick;
+ * teardown just drops markers (the stream queue owns its entries). */
+void scr_next_tick_raw(void (*fn)(void)) {
+  ScrNtick *t = calloc(1, sizeof *t);
+  if (!t) scr_oom();
+  t->raw = fn;
+  if (scr_nt_tail) scr_nt_tail->next = t;
+  else scr_nt_head = t;
+  scr_nt_tail = t;
+}
+
 void scr_nticks_teardown(void) {
   while (scr_nt_head != NULL) {
     ScrNtick *t = scr_nt_head;
     scr_nt_head = t->next;
-    scr_closure_release(t->cb);
+    if (t->cb) scr_closure_release(t->cb);
     free(t);
   }
   scr_nt_tail = NULL;
@@ -1009,7 +1024,7 @@ ScrStr *scr_promise_payload_str(ScrPromise *p) {
   return scr_str_retain((ScrStr *)p->payload);
 }
 /* Thin views for the gated dyn-async TU (scr_async_dyn.c): the payload
- * KIND, whether a REF payload is a DOM value (the dyn adapters), and the
+ * KIND, whether a REF payload is a dyn value (the dyn adapters), and the
  * settled-await primitive (park/hop + rejection re-throw; true =
  * fulfilled). */
 static bool scr_await_settled(ScrPromise *p); /* defined with the await family */
@@ -1424,12 +1439,12 @@ ScrPromise *scr_tp_set_immediate(void) {
   return p;
 }
 
-/* ── setImmediate as a first-class DOM value ─────────────────────────
+/* ── setImmediate as a first-class dyn value ─────────────────────────
  * The global passed AS A FUNCTION VALUE into untyped code (the Node-suite
  * traceCallback shape: `channel.traceCallback(setImmediate, 0, ctx, null,
  * cb)`). The minted dyn callable schedules its own immediate that calls
  * args[0] with the remaining arguments (Node's setImmediate(cb, ...args)
- * contract) and answers undefined (the Immediate handle object has no DOM
+ * contract) and answers undefined (the Immediate handle object has no dyn
  * story — clearImmediate over this value is not modeled). A non-function
  * first argument throws Node's ERR_INVALID_ARG_TYPE synchronously. */
 
@@ -1677,9 +1692,14 @@ void scr_loop_run(void) {
         scr_nt_head = t->next;
         if (scr_nt_head == NULL) scr_nt_tail = NULL;
         ScrClosure *cb = t->cb;
+        void (*raw)(void) = t->raw;
         free(t);
-        ((void (*)(ScrClosure *))cb->fn)(cb);
-        scr_closure_release(cb);
+        if (cb) {
+          ((void (*)(ScrClosure *))cb->fn)(cb);
+          scr_closure_release(cb);
+        } else {
+          raw(); /* one stream tick, FIFO with the user ticks around it */
+        }
         if (scr_exc_pending()) return;
       }
     }
@@ -2030,7 +2050,7 @@ void scr_loop_set_island_rejections(bool (*fn)(bool print)) {
 }
 
 /* ── process.on('unhandledRejection') ─────────────────────────────────
- * DOM listeners called per never-observed rejection instead of the
+ * dyn listeners called per never-observed rejection instead of the
  * default report below. Node fires the event at end-of-turn; the
  * compiled runtime fires at loop exhaustion, where the ledger is
  * decided — the same values, later (SEMANTICS.md; mustCall-style

package/src/scr_async_dyn.c

@@ -1,7 +1,7 @@
 /* Checked-dynamic ASYNC surfaces (gated — cc.ts links this TU only when
  * the IR carries the crossing libCalls or dyn dispatch: the scr_dc.c
  * size-class precedent). Everything here rides scr_async.c's public
- * machinery: the DOM-promise reaction helpers (.then/.catch/.finally
+ * machinery: the checked-dynamic tree-promise reaction helpers (.then/.catch/.finally
  * over SCR_DYN_PROMISE, await of a checked-dynamic value, the
  * `new Promise(setImmediate)` constructor), the AsyncLocalStorage API
  * over the fiber-carried snapshots (the always-linked core keeps only
@@ -128,7 +128,7 @@ void scr_als_disable(double id) {
 }
 
 /* run(store, fn, ...args) / exit(fn, ...args): enter (or clear), call the
- * DOM function with the forwarded arguments, restore — the finally, so a
+ * dyn function with the forwarded arguments, restore — the finally, so a
  * throw still restores before propagating. Result +1 or NULL pending. */
 static ScrDyn *scr_als_call_in(ScrAlsCtx *prev, ScrDyn *fn, ScrDyn *args) {
   size_t argc = args->kind == SCR_DYN_ARR ? args->v.arr.len : 0;
@@ -197,8 +197,8 @@ static bool scr_urj_dispatch(ScrPromise *p) {
 
 /* `new Promise(setImmediate)` (the Node-suite early-exit shape): the
  * executor IS setImmediate, so resolve rides the immediate queue — a
- * fresh promise an armed immediate fulfills with the undefined DOM value
- * (the executor's resolve receives no argument; the DOM payload keeps
+ * fresh promise an armed immediate fulfills with the undefined dyn value
+ * (the executor's resolve receives no argument; the dyn payload keeps
  * promise<dyn> awaiters honest and void awaiters ignore it). +1. */
 static void scr_imm_promise_thunk(ScrClosure *self) {
   ScrPromise *p = (ScrPromise *)scr_box_get_ref(self->caps[0]);
@@ -216,12 +216,12 @@ ScrPromise *scr_immediate_promise(void) {
   return p;
 }
 
-/* ── .then/.catch/.finally over DOM promises (scr_dyn_invoke's promise
+/* ── .then/.catch/.finally over dyn promises (scr_dyn_invoke's promise
  * arm and the dc tracePromise reactions) ──────────────────────────────
  * One reaction fiber per registration: it awaits src (the settled-await
  * microtask hop keeps JS's ordering — reactions never run synchronously
- * inside settle), runs the DOM handler, and settles dst. A handler
- * returning a DOM promise is ADOPTED (awaited in a loop, like JS's
+ * inside settle), runs the checked-dynamic tree handler, and settles dst. A handler
+ * returning a dyn promise is ADOPTED (awaited in a loop, like JS's
  * resolve). Non-callable handlers pass the settlement through (JS's
  * PromisePrototypeThen over non-function reactions). The fiber's own
  * promise is dropped unobserved — the entry consumes every exception
@@ -258,7 +258,7 @@ static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
         scr_promise_fulfill_ref(a->dst, scr_dyn_retain(v), scr_dyn_retain_v, scr_dyn_release_v, NULL);
       }
     } else {
-      /* Adopt DOM-promise results (JS's resolve walk). */
+      /* Adopt dyn-promise results (JS's resolve walk). */
       while (r != NULL && r->kind == SCR_DYN_PROMISE) {
         ScrDyn *inner = scr_await_dyn(r->v.promise);
         scr_dyn_release(r);
@@ -301,7 +301,7 @@ ScrDyn *scr_dyn_promise_then(ScrPromise *src, ScrDyn *onf, ScrDyn *onr, ScrDyn *
   scr_promise_release(waiter); /* the entry never rejects; nobody awaits it */
   return boxed;
 }
-/* `await v` where v is a CHECKED-DYNAMIC value: a DOM promise adopts
+/* `await v` where v is a CHECKED-DYNAMIC value: a dyn promise adopts
  * (the boxed promise awaits — rejections re-throw); every other kind is
  * JS's await-of-a-non-thenable — one microtask hop, the value itself
  * (+1). Thenable ADOPTION (a plain object carrying a then method) is not
@@ -314,14 +314,14 @@ ScrDyn *scr_await_dyn_value(ScrDyn *v) {
 
 /* ── process warnings (emitWarning + the 'warning' event) ─────────────
  * Gated with the rest of this TU (a deprecation-emitting unit's gate
- * must imply the dynAsync link). Listeners are DOM functions; emission
+ * must imply the dynAsync link). Listeners are dyn functions; emission
  * is SYNCHRONOUS at the
  * call (Node defers a tick through nextTick — the MaxListenersExceeded
  * precedent, SEMANTICS.md 138) and the default stderr report always
  * prints (Node's own bootstrap listener; a compiled binary has no
- * --no-warnings). The warning VALUE is the DOM error encoding built over
+ * --no-warnings). The warning VALUE is the dyn error encoding built over
  * an ScrError (identity-cached, so a listener comparing two deliveries
- * of one warning sees one object); a string `detail` joins the DOM node
+ * of one warning sees one object); a string `detail` joins the dyn node
  * and the report's second line, exactly Node. */
 static ScrDyn **scr_warn_listeners = NULL;
 static size_t scr_nwarn = 0, scr_warn_cap = 0;
@@ -366,7 +366,7 @@ void scr_process_off_warning(ScrDyn *fn) {
   }
 }
 
-/* Dispatch + the default stderr report over a built warning DOM node.
+/* Dispatch + the default stderr report over a built warning dyn node.
  * Borrowed. A listener throw propagates (the dc publish stance). */
 static void scr_warning_dispatch(ScrDyn *w) {
   for (size_t i = 0; i < scr_nwarn; i++) {
@@ -415,7 +415,7 @@ static void scr_warn_bad_arg(const char *arg, const char *want) {
   scr_throw_error_msg_code(SCR_ERR_TYPE, buf, (size_t)n, "ERR_INVALID_ARG_TYPE");
 }
 
-/* process.emitWarning(...) — Node's full argument grammar over DOM
+/* process.emitWarning(...) — Node's full argument grammar over dyn
  * values: (warning: string | Error), then for string warnings a type
  * string / ctor function / options object ({type, code, detail}) second
  * and a code string / ctor function third. Wrong kinds throw Node's
@@ -487,11 +487,11 @@ void scr_process_emit_warning(ScrDyn *args) {
 
 
 
-/* A caught-exception snapshot as a DOM value — identity-preserving for
- * DOM payloads (a dyn-thrown value is retained, not copied), the
+/* A caught-exception snapshot as a dyn value — identity-preserving for
+ * dyn payloads (a dyn-thrown value is retained, not copied), the
  * identity-cached %error encoding above for Error-family objects,
  * scalars by value, the type-erased empty object for the rest
- * (SEMANTICS.md 67). Shared by the dc trace choreography, the DOM
+ * (SEMANTICS.md 67). Shared by the dc trace choreography, the checked-dynamic tree
  * promise reactions, and the unhandled-rejection dispatch. Borrows the
  * box; result +1. */
 ScrDyn *scr_caught_to_dyn(const ScrCaught *c) {
@@ -510,8 +510,8 @@ ScrDyn *scr_caught_to_dyn(const ScrCaught *c) {
   }
 }
 
-/* Await a DOM-CROSSING promise (SCR_DYN_PROMISE's boundary contract —
- * dyn or void fulfillment): the payload as a DOM value (+1; a void
+/* Await a dyn-CROSSING promise (SCR_DYN_PROMISE's boundary contract —
+ * dyn or void fulfillment): the payload as a dyn value (+1; a void
  * fulfillment answers the undefined value, and the defensive scalar arms
  * cover payload kinds a direct box could theoretically carry), or NULL
  * with the rejection re-thrown into the awaiter. */
@@ -528,7 +528,7 @@ ScrDyn *scr_await_dyn(ScrPromise *p) {
   }
   case SCR_EXC_REF: {
     void *v = scr_promise_payload_ref(p);
-    if (v) return (ScrDyn *)v; /* the DOM contract: a retained dyn */
+    if (v) return (ScrDyn *)v; /* the dyn contract: a retained dyn */
     return scr_dyn_retain(scr_dyn_undefined());
   }
   default:
@@ -536,7 +536,7 @@ ScrDyn *scr_await_dyn(ScrPromise *p) {
   }
 }
 
-/* The rejection reason as a DOM value — the scr_caught_to_dyn stances
+/* The rejection reason as a dyn value — the scr_caught_to_dyn stances
  * over a promise's payload slot (identity-preserving for dyn-thrown
  * values and %Error instances). */
 ScrDyn *scr_promise_reason_dyn(const ScrPromise *p) {
@@ -573,10 +573,10 @@ ScrDyn *scr_promise_reason_dyn(const ScrPromise *p) {
   }
 }
 
-/* ── promises in the DOM (SCR_DYN_PROMISE) ────────────────────────────
+/* ── promises in the checked-dynamic tree (SCR_DYN_PROMISE) ────────────────────────────
  * Reference boxes over the fiber machinery's ScrPromise (scr_runtime.h's
  * design note). The boundary contract — a boxed promise settles with a
- * DOM payload — is the CALLERS' to keep: the compiler's converters box
+ * dyn payload — is the CALLERS' to keep: the compiler's converters box
  * promise<dyn> directly and every other inner type through the adapting
  * constructor below. */
 
@@ -588,7 +588,7 @@ ScrDyn *scr_dyn_new_promise(ScrPromise *p) {
 
 /* The typed-inner box: a fresh destination promise parked on `src`
  * through the Promise.race cb-waiter machinery — `adapt` (emitted,
- * per-inner-type) converts the fulfillment payload into a DOM value and
+ * per-inner-type) converts the fulfillment payload into a dyn value and
  * fulfills the destination; rejections copy raw inside the machinery and
  * count as HANDLED on src (the box is the tracked promise, like a JS
  * .then chain). Already-settled sources adapt inline. Borrows src; +1. */

package/src/scr_bytes.c

@@ -1,6 +1,8 @@
 /* Typed arrays / Buffer: ONE runtime representation (ScrBytes — see the
- * header contract). Element buffers own their storage outright: no views,
- * no byteOffset, slice/subarray both copy. Coercions are JS-exact
+ * header contract). An ScrBytes either OWNS its storage or is a VIEW into
+ * an owner's (backing set, chain depth exactly 1): DataView, subarray(),
+ * and Buffer's slice() all alias JS-exactly; only the plain typed arrays'
+ * slice() copies. Coercions are JS-exact
  * (ToUint8/ToUint32 modular truncation, double→float rounding); the
  * encoding conversions (utf8 with WHATWG replacement, hex, base64) match
  * Node byte-for-byte — the differential corpus holds them to it. */
@@ -164,7 +166,7 @@ void scr_bytes_set(ScrBytes *b, double i, double v) {
   }
 }
 
-/* ── slice / subarray (both COPY) ──────────────────────────────────────── */
+/* ── slice (copy) / subarray (view) ────────────────────────────────────── */
 
 /* Relative index: ToIntegerOrInfinity, negatives from the end, clamped. */
 static size_t scr_bytes_rel_index(double i, size_t len) {
@@ -186,6 +188,41 @@ ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end) {
   return out;
 }
 
+/* TypedArray.prototype.fill on non-u8 receivers: per-ELEMENT fill with
+ * the element write's JS-exact coercion (ToUint32/ToInt32 wrap, f32
+ * rounding), slice-clamped relative indices; answers the receiver +1
+ * (chaining). Never throws — Buffer's throwing fill family is separate. */
+ScrBytes *scr_bytes_fill_elem(ScrBytes *b, double v, double start, double end) {
+  size_t s = scr_bytes_rel_index(start, b->len);
+  size_t e = scr_bytes_rel_index(end, b->len);
+  for (size_t i = s; i < e; i++) scr_bytes_set(b, (double)i, v);
+  return scr_bytes_retain(b);
+}
+
+/* subarray(start, end): a same-elem VIEW over the receiver's storage —
+ * TypedArray.prototype.subarray and Buffer's slice()/subarray() all alias
+ * in JS (mutations are visible both ways; buffer-swap through a slice is
+ * the canonical Node use). Chain depth stays exactly 1: a subarray of a
+ * view retains the OWNER, offsets composed here (the DataView rule).
+ * Relative indices clamp like slice; never throws. */
+ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end) {
+  size_t s = scr_bytes_rel_index(start, b->len);
+  size_t e = scr_bytes_rel_index(end, b->len);
+  size_t count = e > s ? e - s : 0;
+  ScrBytes *owner = b->backing ? b->backing : b;
+  ScrBytes *v = malloc(sizeof(ScrBytes));
+  if (!v) scr_bytes_oom();
+  v->rc = 1;
+  v->len = count;
+  v->elem = b->elem;
+  v->data = b->data + s * scr_bytes_elem_size(b->elem);
+  v->backing = scr_bytes_retain(owner);
+#ifdef SCR_RC_AUDIT
+  scr_live_bytes++;
+#endif
+  return v;
+}
+
 void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset) {
   double t = (offset != offset) ? 0 : trunc(offset);
   if (!(t >= 0) || (double)src->len + t > (double)dst->len) {

package/src/scr_bytes_io.c

@@ -61,7 +61,7 @@ ScrBytes *scr_fs_read_file_bytes(ScrStr *path) {
  * utf8 answers a string, Node's other real encodings meet the loud
  * not-supported ladder, unknown names throw ERR_UNKNOWN_ENCODING, and an
  * options object dispatches on its `encoding` member (Node's form). +1
- * DOM value, or NULL with the exception pending. */
+ * dyn value, or NULL with the exception pending. */
 ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc) {
   if (enc->kind == SCR_DYN_OBJ) {
     ScrDyn *ev = scr_dyn_obj_get((ScrDyn *)enc, "encoding", 8); /* borrowed */
@@ -166,7 +166,7 @@ bool scr_process_stderr_write_bytes(const ScrBytes *b) {
 
 /* ── the checked-dynamic Buffer compare/equals validators ──────────────
  * Node's argument ladders for buf.equals / buf.compare / Buffer.compare
- * over DOM-boxed arguments (the invalid-input probes: string needles,
+ * over dyn-boxed arguments (the invalid-input probes: string needles,
  * '0' offsets, null/object range args). A well-typed dyn still computes
  * the real answer — validation, not a constant fence. */
 
@@ -260,7 +260,7 @@ double scr_fs_to_unix_timestamp(const ScrDyn *t) {
 
 /* ── the fs argument-validation ladders (checked-dynamic lane) ─────────
  * Each fs.*Chk libCall replicates its API's Node-order validation over
- * DOM values and throws Node's exact typed errors; when every validation
+ * dyn values and throws Node's exact typed errors; when every validation
  * passes, the honest tail runs — the real operation where one exists
  * (mkdtempSync, lchmodSync on macOS), the compiler-rendered SC2020 fence
  * otherwise (scr_throw_lowering_fence). All arguments borrowed. */
@@ -282,7 +282,7 @@ static bool scr_fs_cb_chk(const ScrDyn *cb, const char *name) {
 }
 
 /* getValidatedPath: strings and Buffers pass (URL instances never reach
- * these ladders — the DOM has no URL kind here, and Node would accept
+ * these ladders — the checked-dynamic tree has no URL kind here, and Node would accept
  * only file: URLs anyway). */
 static bool scr_fs_path_chk(const ScrDyn *p, const char *name) {
   if (p->kind == SCR_DYN_STR || p->kind == SCR_DYN_BYTES) return true;
@@ -522,7 +522,7 @@ static void scr_fs_lchmod_apply(const ScrDyn *path, const ScrDyn *mode) {
 }
 #endif
 
-/* Answers the DOM undefined (+1) on success — lchmodSync's JS value, so
+/* Answers the dyn undefined (+1) on success — lchmodSync's JS value, so
  * return-position uses lower; NULL with the exception pending. */
 ScrDyn *scr_fs_lchmod_sync_chk(const ScrDyn *path, const ScrDyn *mode) {
   if (!scr_fs_lchmod_defined("fs.lchmodSync")) return NULL;

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));