@scriptc/runtime 0.0.11 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.11",
+  "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
@@ -1024,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 */
@@ -1439,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. */
 
@@ -2050,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_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));

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).
@@ -682,9 +682,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");

package/src/scr_http.c

@@ -2774,7 +2774,7 @@ void scr_http_resp_thunk_res(ScrClosure *cb, ScrHttpReq *res) {
  *
  * The receiver surface behind `server.on('request', mustCall((req, res)
  * => ...))`: the mustCall wrapper makes the listener dyn, req/res box
- * into the DOM as HANDLE values, and member uses inside the listener
+ * into the checked-dynamic tree as HANDLE values, and member uses inside the listener
  * body dispatch HERE — onto the very entry points the static lowerings
  * use, with per-argument gates shaped like Node's (the libCall signature
  * table in validate.ts is the modeled surface; this dispatcher mirrors
@@ -2785,7 +2785,7 @@ void scr_http_resp_thunk_res(ScrClosure *cb, ScrHttpReq *res) {
  *   - a member the class HAS but this table does not model: a LOUD
  *     "not supported yet" Error — never a silent wrong answer;
  *   - anything else: Node's "<spelling> is not a function" for calls,
- *     the undefined singleton for reads (the DOM's own-property answer;
+ *     the undefined singleton for reads (the checked-dynamic tree's own-property answer;
  *     SEMANTICS.md documents the remainder).
  *
  * Ownership: invoke/get/set receive BORROWED handles/args and answer
@@ -3009,7 +3009,7 @@ static ScrDyn *scr_http_dynh_req_get(void *h, const char *key, size_t key_len) {
     double st = scr_http_req_status(r);
     /* Node's IncomingMessage constructor sets statusCode = null; only a
      * client response assigns a number (the static lane's typed surface
-     * spells this number|undefined — the DOM can afford Node's null). */
+     * spells this number|undefined — the checked-dynamic tree can afford Node's null). */
     return st < 0 ? scr_dyn_new_null() : scr_dyn_new_num(st);
   }
   if (strcmp(key, "statusMessage") == 0) {
@@ -3049,7 +3049,7 @@ static bool scr_http_dynh_req_set(void *h, const char *key, size_t key_len, cons
 
 /* ── ServerResponse (SCR_DYNH_HTTP_RES) ──────────────────────────────── */
 
-/* writeHead's header-object form over a DOM OBJ: flatten into the
+/* writeHead's header-object form over a dyn OBJ: flatten into the
  * [k0, v0, k1, v1, ...] pairs the static lowering feeds
  * scr_http_res_write_head_pairs (repeats append — array values expand to
  * consecutive same-name pairs). Numbers format through String(n). NULL =