@scriptc/compiler 0.0.11 → 0.0.13

package/dist/backend/emission/emit-island.js

@@ -243,7 +243,7 @@ export function islandTypedAdapter(E, fn) {
                 break;
             case "dyn":
                 body.push(
-                // A checked-dynamic (+1 DOM) result: deep copy into the
+                // A checked-dynamic (+1 dyn) result: deep copy into the
                 // engine (the jsMarshal dyn rule — data kinds only; boxed
                 // functions/handles leave the exception pending and the NULL
                 // dummy bridges).

package/dist/backend/emission/emit-shapes.js

@@ -559,7 +559,7 @@ export function boxNewC(E, t) {
         t.kind === "jsval" ||
         // Checked-dynamic captures (the mustCall wrapper closing over its
         // implicit-any `fn` param): the box carries scr_dyn_retain_v/
-        // release_v and NO trace — a DOM tree is pure data except the
+        // release_v and NO trace — a dyn tree is pure data except the
         // function kind, whose closure edge stays invisible to the
         // collector (trial deletion treats it as an external root: cycles
         // through dyn never collect, nothing dangles — SEMANTICS.md).

package/dist/backend/emission/emit-walkers.d.ts

@@ -33,7 +33,7 @@ export declare function unionToStrHelper(E: CEmitter, unionId: string): string;
    * the result is owned (+1). */
 export declare function unionJoinHelper(E: CEmitter, unionId: string): string;
 /** The dyn ToString helper pair (interned once, type-independent):
-   * Node's String() over a DOM value — "undefined"/"null" texts, bools,
+   * Node's String() over a dyn value — "undefined"/"null" texts, bools,
    * JS-exact number formatting (NaN/Infinity spelled out — NOT the JSON
    * null), strings verbatim, arrays via Array.prototype.toString (join
    * with ","; null/undefined ELEMENTS print empty, nested arrays flatten
@@ -43,12 +43,12 @@ export declare function dynToStrHelper(E: CEmitter): string;
 /** The caught→dyn converter (interned once, type-independent): a catch
    * binding flowing into an `unknown` slot — the typed→unknown deep-copy
    * stance over the exception snapshot's runtime kind. Scalar payloads
-   * convert exactly; an Error-family OBJ payload becomes the DOM's error
+   * convert exactly; an Error-family OBJ payload becomes the checked-dynamic tree's error
    * encoding — the reserved "%error" marker plus name/message (and code
    * when stamped), so `instanceof Error`, the %Error extraction, and
    * String() answer like Node; every other payload (REF — records, arrays,
    * closures, unions — and non-Error hierarchy objects, type-erased at
-   * runtime) becomes an EMPTY DOM object (SEMANTICS.md 67). Borrows the
+   * runtime) becomes an EMPTY dyn object (SEMANTICS.md 67). Borrows the
    * snapshot; the result is a fresh tree (+1). Never throws. */
 export declare function caughtToDynHelper(E: CEmitter): string;
 /** The pretty-print re-indenter (interned once, type-independent):
@@ -64,12 +64,12 @@ export declare function caughtToDynHelper(E: CEmitter): string;
 export declare function jsonIndentHelper(E: CEmitter): string;
 export declare function jsonWriteHelper(E: CEmitter, t: IrType): string;
 /** The emitted match predicate for one dynCheck target type:
-   * `static bool sc_dm_<n>(const ScrDyn *d)` — does this DOM fit T?
+   * `static bool sc_dm_<n>(const ScrDyn *d)` — does this dyn fit T?
    * Never throws, builds nothing; union builders use it to try arms in
    * canonical order (first FULL match wins). Records are width-tolerant
    * here too: extra keys are ignored, only declared fields are examined. */
 export declare function dynMatchHelper(E: CEmitter, t: IrType): string;
-/** The emitted keyed read on a dyn DOM value:
+/** The emitted keyed read on a dyn value:
    * `static ScrDyn *sc_dyn_key_get(ScrDyn *d, ScrStr *k, bool opt)` —
    * OBJ answers the member (+1) or the undefined singleton (own-property
    * answer); ARR answers `length` and canonical in-range indices, STR
@@ -85,37 +85,37 @@ export declare function dynMatchHelper(E: CEmitter, t: IrType): string;
  * property 'PROP' of 'SPELL' …" when firstProp is non-NULL — V8's exact
  * strings, source spelling included. Non-nullish values pass silently. */
 export declare function dynDestrCheckHelper(E: CEmitter): string;
-/** GetIterator + first-N steps over a DOM value (the dynIterN node), as
+/** GetIterator + first-N steps over a dyn value (the dynIterN node), as
  * array destructuring sees it: arrays step by index, strings by CODE
  * POINT (the string iterator — astral chars arrive unsplit), Buffers by
  * byte; everything else throws V8's exact not-iterable TypeError
  * ("undefined is not iterable …", "object null is not iterable …",
  * "number 1 is not iterable …", "boolean true …", "object …",
  * "function …" — each with the "(cannot read property
- * Symbol(Symbol.iterator))" tail). Returns a fresh +1 DOM array of
+ * Symbol(Symbol.iterator))" tail). Returns a fresh +1 dyn array of
  * exactly n elements, undefined-padded past the end. */
 export declare function dynIterNHelper(E: CEmitter): string;
 export declare function dynKeyGetHelper(E: CEmitter): string;
 /** The emitted checked builder for one dynCheck target type:
    * `static T sc_dc_<n>(const ScrDyn *d, const ScrDynPath *path)` —
-   * validate the DOM against T and BUILD the typed value (+1), or throw a
+   * validate the checked-dynamic tree against T and BUILD the typed value (+1), or throw a
    * catchable, path-annotated TypeError-shaped string through the exception
    * cell and return a dummy (0/false/NULL) with the pending flag set.
    * Recursive calls propagate a pending exception by releasing the
    * partially-built value and returning — the same pending-check discipline
    * emitted function bodies follow. */
 export declare function dynCheckHelper(E: CEmitter, t: IrType): string;
-/** The emitted static→DOM converter for one type:
-   * `static ScrDyn *sc_td_<n>(<T> v)` — build a fresh dyn DOM value from a
+/** The emitted static→dyn converter for one type:
+   * `static ScrDyn *sc_td_<n>(<T> v)` — build a fresh dyn value from a
    * static one (+1), DEEP-COPYING composites (a dyn value never aliases
    * static storage — the jsMarshal stance). Domain: the JSON-safe kinds
    * plus undefined-armed unions (the undefined arm becomes the undefined
-   * DOM singleton) and index-signature records (whose overflow entries
+   * dyn singleton) and index-signature records (whose overflow entries
    * copy over). The operand is borrowed. Never throws. */
 export declare function toDynHelper(E: CEmitter, t: IrType): string;
-/** The DOM-promise settle adapter for one fulfillment payload type:
+/** The checked-dynamic tree-promise settle adapter for one fulfillment payload type:
    * `static void sc_pda_<n>(ScrPromise *dst, ScrPromise *src)` — read
-   * src's fulfilled payload by its compile-time kind, convert it to a DOM
+   * src's fulfilled payload by its compile-time kind, convert it to a dyn
    * value, and fulfill dst with it (scr_dyn_new_promise_adapting's
    * callback; rejections never reach an adapter — the runtime copies them
    * raw). Interned per inner typeKey. */
@@ -140,7 +140,7 @@ export declare function dynFuncAdapterHelper(E: CEmitter, t: IrType & {
    * answer first (string comparisons in canonical order; the frontend
    * proved each surfaces as T: identity, a to-dyn conversion, or an
    * arm-into-union wrap), then the overflow map on index-signature shapes.
-   * A MISSING key yields the undefined DOM value (T dyn), the undefined
+   * A MISSING key yields the undefined dyn value (T dyn), the undefined
    * arm (T undefined-armed union), or TRAPS with the key text (the array
    * OOB policy — the checker claimed T and no undefined is representable).
    * Borrows both; refcounted results are owned (+1). */

package/dist/backend/emission/emit-walkers.js

@@ -26,7 +26,7 @@ export function dynDesc(E, t) {
         // omitting the key).
         case "undefinedT":
             return "undefined";
-        // dyn fields accept any DOM value — only reachable in messages as a
+        // dyn fields accept any dyn value — only reachable in messages as a
         // sibling of a failing field, never as the failure itself.
         case "dyn":
             return "unknown";
@@ -235,7 +235,7 @@ export function unionJoinHelper(E, unionId) {
     return name;
 }
 /** The dyn ToString helper pair (interned once, type-independent):
-   * Node's String() over a DOM value — "undefined"/"null" texts, bools,
+   * Node's String() over a dyn value — "undefined"/"null" texts, bools,
    * JS-exact number formatting (NaN/Infinity spelled out — NOT the JSON
    * null), strings verbatim, arrays via Array.prototype.toString (join
    * with ","; null/undefined ELEMENTS print empty, nested arrays flatten
@@ -247,18 +247,18 @@ export function dynToStrHelper(E) {
     const name = "sc_ds";
     E.dynToStrFn = name;
     E.walkerProtos.push(`static void ${name}_buf(ScrJsonBuf *b, const ScrDyn *d); /* String(unknown) walker */`, `static ScrStr *${name}(const ScrDyn *d); /* String(unknown) */`);
-    E.walkerDefs.push(`static void ${name}_buf(ScrJsonBuf *b, const ScrDyn *d) { /* String(unknown), recursive */`, `  switch (d->kind) {`, `  case SCR_DYN_UNDEF: scr_jb_puts(b, "undefined"); break;`, `  case SCR_DYN_NULL: scr_jb_puts(b, "null"); break;`, `  case SCR_DYN_BOOL: scr_jb_puts(b, d->v.b ? "true" : "false"); break;`, `  case SCR_DYN_NUM: {`, `    ScrStr *s = scr_f64_to_scrstr(d->v.num); /* String(n): NaN/Infinity spelled out, not JSON null */`, `    for (size_t i = 0; i < s->len; i++) scr_jb_putc(b, s->data[i]);`, `    scr_str_release(s);`, `    break;`, `  }`, `  case SCR_DYN_STR:`, `    for (size_t i = 0; i < d->v.str->len; i++) scr_jb_putc(b, d->v.str->data[i]);`, `    break;`, `  case SCR_DYN_ARR:`, `    /* Array.prototype.toString: join(",") — null/undefined ELEMENTS`, `     * print empty (unlike top level), nested arrays flatten. */`, `    for (size_t i = 0; i < d->v.arr.len; i++) {`, `      if (i > 0) scr_jb_putc(b, ',');`, `      const ScrDyn *e = d->v.arr.items[i];`, `      if (e->kind == SCR_DYN_UNDEF || e->kind == SCR_DYN_NULL) continue;`, `      ${name}_buf(b, e);`, `    }`, `    break;`, `  case SCR_DYN_OBJ:`, `    if (scr_dyn_obj_get(d, "%error", 6)) {`, `      /* The DOM's error encoding (caughtToDyn): Error.prototype`, `       * .toString over the encoded name/message — Node's String(err),`, `       * which carries no stack either. */`, `      const ScrDyn *en = scr_dyn_obj_get(d, "name", 4);`, `      const ScrDyn *em = scr_dyn_obj_get(d, "message", 7);`, `      const ScrStr *ens = (en && en->kind == SCR_DYN_STR) ? en->v.str : NULL;`, `      const ScrStr *ems = (em && em->kind == SCR_DYN_STR) ? em->v.str : NULL;`, `      if (ens) for (size_t i = 0; i < ens->len; i++) scr_jb_putc(b, ens->data[i]);`, `      if (ens && ens->len && ems && ems->len) scr_jb_puts(b, ": ");`, `      if (ems) for (size_t i = 0; i < ems->len; i++) scr_jb_putc(b, ems->data[i]);`, `      break;`, `    }`, `    scr_jb_puts(b, "[object Object]");`, `    break;`, `  case SCR_DYN_BYTES: {`, `    /* Buffer-flavored values (stream chunks) coerce utf8 (Node's`, `     * Buffer.toString); plain Uint8Array joins its elements. */`, `    if (d->buffer) {`, `      ScrStr *enc = scr_str_new("utf8", 4);`, `      ScrStr *txt = scr_bytes_to_str(d->v.bytes, enc);`, `      scr_str_release(enc);`, `      for (size_t i = 0; i < txt->len; i++) scr_jb_putc(b, txt->data[i]);`, `      scr_str_release(txt);`, `      break;`, `    }`, `    for (size_t i = 0; i < d->v.bytes->len; i++) {`, `      if (i > 0) scr_jb_putc(b, ',');`, `      char n[16];`, `      snprintf(n, sizeof n, "%u", (unsigned)d->v.bytes->data[i]);`, `      scr_jb_puts(b, n);`, `    }`, `    break;`, `  }`, `  case SCR_DYN_FUNC:`, `    /* Function.prototype.toString: the SOURCE is gone in a compiled`, `     * program, so the native-code form — exactly what JS engines`, `     * print for their own non-JS functions. */`, `    scr_jb_puts(b, "function ");`, `    if (d->v.fn.name) scr_jb_puts(b, d->v.fn.name);`, `    scr_jb_puts(b, "() { [native code] }");`, `    break;`, `  case SCR_DYN_HANDLE:`, `    /* Object.prototype.toString — Node's String() over these`, `     * classes (IncomingMessage/ServerResponse/Socket). */`, `    scr_jb_puts(b, "[object Object]");`, `    break;`, `  case SCR_DYN_PROMISE:`, `    /* Object.prototype.toString with the Promise @@toStringTag. */`, `    scr_jb_puts(b, "[object Promise]");`, `    break;`, `  case SCR_DYN_JSVAL:`, `    /* Island-held: the engine's own ToString (a bridged failure`, `     * leaves the exception pending and appends nothing). */`, `    scr_dyn_isl_tostr_buf(b, d);`, `    break;`, `  }`, `}`, `static ScrStr *${name}(const ScrDyn *d) { /* String(unknown) -> owned (+1) */`, `  if (d->kind == SCR_DYN_STR) return scr_str_retain(d->v.str);`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  ${name}_buf(&b, d);`, `  return scr_jb_finish(&b);`, `}`, ``);
+    E.walkerDefs.push(`static void ${name}_buf(ScrJsonBuf *b, const ScrDyn *d) { /* String(unknown), recursive */`, `  switch (d->kind) {`, `  case SCR_DYN_UNDEF: scr_jb_puts(b, "undefined"); break;`, `  case SCR_DYN_NULL: scr_jb_puts(b, "null"); break;`, `  case SCR_DYN_BOOL: scr_jb_puts(b, d->v.b ? "true" : "false"); break;`, `  case SCR_DYN_NUM: {`, `    ScrStr *s = scr_f64_to_scrstr(d->v.num); /* String(n): NaN/Infinity spelled out, not JSON null */`, `    for (size_t i = 0; i < s->len; i++) scr_jb_putc(b, s->data[i]);`, `    scr_str_release(s);`, `    break;`, `  }`, `  case SCR_DYN_STR:`, `    for (size_t i = 0; i < d->v.str->len; i++) scr_jb_putc(b, d->v.str->data[i]);`, `    break;`, `  case SCR_DYN_ARR:`, `    /* Array.prototype.toString: join(",") — null/undefined ELEMENTS`, `     * print empty (unlike top level), nested arrays flatten. */`, `    for (size_t i = 0; i < d->v.arr.len; i++) {`, `      if (i > 0) scr_jb_putc(b, ',');`, `      const ScrDyn *e = d->v.arr.items[i];`, `      if (e->kind == SCR_DYN_UNDEF || e->kind == SCR_DYN_NULL) continue;`, `      ${name}_buf(b, e);`, `    }`, `    break;`, `  case SCR_DYN_OBJ:`, `    if (scr_dyn_obj_get(d, "%error", 6)) {`, `      /* The checked-dynamic tree's error encoding (caughtToDyn): Error.prototype`, `       * .toString over the encoded name/message — Node's String(err),`, `       * which carries no stack either. */`, `      const ScrDyn *en = scr_dyn_obj_get(d, "name", 4);`, `      const ScrDyn *em = scr_dyn_obj_get(d, "message", 7);`, `      const ScrStr *ens = (en && en->kind == SCR_DYN_STR) ? en->v.str : NULL;`, `      const ScrStr *ems = (em && em->kind == SCR_DYN_STR) ? em->v.str : NULL;`, `      if (ens) for (size_t i = 0; i < ens->len; i++) scr_jb_putc(b, ens->data[i]);`, `      if (ens && ens->len && ems && ems->len) scr_jb_puts(b, ": ");`, `      if (ems) for (size_t i = 0; i < ems->len; i++) scr_jb_putc(b, ems->data[i]);`, `      break;`, `    }`, `    scr_jb_puts(b, "[object Object]");`, `    break;`, `  case SCR_DYN_BYTES: {`, `    /* Buffer-flavored values (stream chunks) coerce utf8 (Node's`, `     * Buffer.toString); plain Uint8Array joins its elements. */`, `    if (d->buffer) {`, `      ScrStr *enc = scr_str_new("utf8", 4);`, `      ScrStr *txt = scr_bytes_to_str(d->v.bytes, enc);`, `      scr_str_release(enc);`, `      for (size_t i = 0; i < txt->len; i++) scr_jb_putc(b, txt->data[i]);`, `      scr_str_release(txt);`, `      break;`, `    }`, `    for (size_t i = 0; i < d->v.bytes->len; i++) {`, `      if (i > 0) scr_jb_putc(b, ',');`, `      char n[16];`, `      snprintf(n, sizeof n, "%u", (unsigned)d->v.bytes->data[i]);`, `      scr_jb_puts(b, n);`, `    }`, `    break;`, `  }`, `  case SCR_DYN_FUNC:`, `    /* Function.prototype.toString: the SOURCE is gone in a compiled`, `     * program, so the native-code form — exactly what JS engines`, `     * print for their own non-JS functions. */`, `    scr_jb_puts(b, "function ");`, `    if (d->v.fn.name) scr_jb_puts(b, d->v.fn.name);`, `    scr_jb_puts(b, "() { [native code] }");`, `    break;`, `  case SCR_DYN_HANDLE:`, `    /* Object.prototype.toString — Node's String() over these`, `     * classes (IncomingMessage/ServerResponse/Socket). */`, `    scr_jb_puts(b, "[object Object]");`, `    break;`, `  case SCR_DYN_PROMISE:`, `    /* Object.prototype.toString with the Promise @@toStringTag. */`, `    scr_jb_puts(b, "[object Promise]");`, `    break;`, `  case SCR_DYN_JSVAL:`, `    /* Island-held: the engine's own ToString (a bridged failure`, `     * leaves the exception pending and appends nothing). */`, `    scr_dyn_isl_tostr_buf(b, d);`, `    break;`, `  }`, `}`, `static ScrStr *${name}(const ScrDyn *d) { /* String(unknown) -> owned (+1) */`, `  if (d->kind == SCR_DYN_STR) return scr_str_retain(d->v.str);`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  ${name}_buf(&b, d);`, `  return scr_jb_finish(&b);`, `}`, ``);
     return name;
 }
 /** The caught→dyn converter (interned once, type-independent): a catch
    * binding flowing into an `unknown` slot — the typed→unknown deep-copy
    * stance over the exception snapshot's runtime kind. Scalar payloads
-   * convert exactly; an Error-family OBJ payload becomes the DOM's error
+   * convert exactly; an Error-family OBJ payload becomes the checked-dynamic tree's error
    * encoding — the reserved "%error" marker plus name/message (and code
    * when stamped), so `instanceof Error`, the %Error extraction, and
    * String() answer like Node; every other payload (REF — records, arrays,
    * closures, unions — and non-Error hierarchy objects, type-erased at
-   * runtime) becomes an EMPTY DOM object (SEMANTICS.md 67). Borrows the
+   * runtime) becomes an EMPTY dyn object (SEMANTICS.md 67). Borrows the
    * snapshot; the result is a fresh tree (+1). Never throws. */
 export function caughtToDynHelper(E) {
     if (E.caughtToDynFn)
@@ -267,7 +267,7 @@ export function caughtToDynHelper(E) {
     E.caughtToDynFn = name;
     const sig = `static ScrDyn *${name}(const ScrCaught *c)`;
     E.walkerProtos.push(`${sig}; /* caught -> unknown */`);
-    E.walkerDefs.push(`${sig} { /* caught -> unknown (+1, fresh tree) */`, `  switch (c->kind) {`, `  case SCR_EXC_F64: return scr_dyn_new_num(c->f64);`, `  case SCR_EXC_BOOL: return scr_dyn_new_bool(c->b);`, `  case SCR_EXC_STR: return scr_dyn_new_str((ScrStr *)c->payload); /* _new_str retains */`, `  case SCR_EXC_OBJ:`, `    if (scr_error_is(c->payload)) {`, `      /* The identity-cached crossing (scr_json.c): the SAME error`, `       * instance boxes to ONE DOM node however it crosses, so a`, `       * caught dyn compares reference-equal to the thrown error's`, `       * other boxings, like Node. */`, `      return scr_dyn_from_error((const ScrError *)c->payload);`, `    }`, `    /* FALLTHROUGH: a non-Error hierarchy object is type-erased */`, `  case SCR_EXC_REF:`, `    /* A thrown DOM value passes back BY REFERENCE (identity with`, `     * every other holder of the node — the traced-throw shape). */`, `    if (c->retain_fn == scr_dyn_retain_v) return scr_dyn_retain((ScrDyn *)c->payload);`, `    /* FALLTHROUGH */`, `  default:`, `    /* non-dyn REF and non-Error objects: the "[object Object]"`, `     * approximation — truthy, typeof "object", fields unreadable. */`, `    return scr_dyn_new_obj();`, `  }`, `}`, ``);
+    E.walkerDefs.push(`${sig} { /* caught -> unknown (+1, fresh tree) */`, `  switch (c->kind) {`, `  case SCR_EXC_F64: return scr_dyn_new_num(c->f64);`, `  case SCR_EXC_BOOL: return scr_dyn_new_bool(c->b);`, `  case SCR_EXC_STR: return scr_dyn_new_str((ScrStr *)c->payload); /* _new_str retains */`, `  case SCR_EXC_OBJ:`, `    if (scr_error_is(c->payload)) {`, `      /* The identity-cached crossing (scr_json.c): the SAME error`, `       * instance boxes to ONE dyn node however it crosses, so a`, `       * caught dyn compares reference-equal to the thrown error's`, `       * other boxings, like Node. */`, `      return scr_dyn_from_error((const ScrError *)c->payload);`, `    }`, `    /* FALLTHROUGH: a non-Error hierarchy object is type-erased */`, `  case SCR_EXC_REF:`, `    /* A thrown dyn value passes back BY REFERENCE (identity with`, `     * every other holder of the node — the traced-throw shape). */`, `    if (c->retain_fn == scr_dyn_retain_v) return scr_dyn_retain((ScrDyn *)c->payload);`, `    /* FALLTHROUGH */`, `  default:`, `    /* non-dyn REF and non-Error objects: the "[object Object]"`, `     * approximation — truthy, typeof "object", fields unreadable. */`, `    return scr_dyn_new_obj();`, `  }`, `}`, ``);
     return name;
 }
 /** The pretty-print re-indenter (interned once, type-independent):
@@ -450,7 +450,7 @@ export function jsonWriteHelper(E, t) {
             break;
         }
         case "dyn":
-            // Overflow values under an `unknown` index signature: the DOM
+            // Overflow values under an `unknown` index signature: the checked-dynamic tree
             // serializes itself (runtime walker) — object members holding
             // undefined drop, array slots holding undefined print null,
             // exactly Node. Bare JSON.stringify of dyn stays frontend-fenced;
@@ -533,7 +533,7 @@ export function jsonWriteHelper(E, t) {
     return name;
 }
 /** The emitted match predicate for one dynCheck target type:
-   * `static bool sc_dm_<n>(const ScrDyn *d)` — does this DOM fit T?
+   * `static bool sc_dm_<n>(const ScrDyn *d)` — does this dyn fit T?
    * Never throws, builds nothing; union builders use it to try arms in
    * canonical order (first FULL match wins). Records are width-tolerant
    * here too: extra keys are ignored, only declared fields are examined. */
@@ -563,18 +563,18 @@ export function dynMatchHelper(E, t) {
             d.push(`  return d->kind == SCR_DYN_NULL;`);
             break;
         case "undefinedT":
-            // JSON text never parses to undefined, but the DOM can HOLD it now
+            // JSON text never parses to undefined, but the checked-dynamic tree can HOLD it now
             // (overflow reads/conversions under `unknown` index signatures):
-            // the undefined DOM value matches exactly the undefined arm.
+            // the undefined dyn value matches exactly the undefined arm.
             d.push(`  return d->kind == SCR_DYN_UNDEF;`);
             break;
         case "dyn":
-            // An `unknown` target: every DOM value fits, undefined included.
+            // An `unknown` target: every dyn value fits, undefined included.
             d.push(`  (void)d;`);
             d.push(`  return true;`);
             break;
         case "bytes":
-            // A Uint8Array target (the DOM carries u8 payloads only).
+            // A Uint8Array target (the checked-dynamic tree carries u8 payloads only).
             if (t.elem !== "u8")
                 throw new Error(`emitter bug: dynMatch of bytes<${t.elem}>`);
             d.push(`  return d->kind == SCR_DYN_BYTES;`);
@@ -597,7 +597,7 @@ export function dynMatchHelper(E, t) {
             }
             d.push(`  if (d->kind != SCR_DYN_OBJ) return false;`);
             // dyn ('unknown') fields match ANY value, present or missing (a
-            // missing key builds the undefined DOM value) — no test to emit.
+            // missing key builds the undefined dyn value) — no test to emit.
             if (shape.fields.some((f) => f.type.kind !== "dyn"))
                 d.push(`  const ScrDyn *m;`);
             for (const f of shape.fields) {
@@ -652,7 +652,7 @@ export function dynMatchHelper(E, t) {
                 throw new Error(`emitter bug: dynCheck of unknown union ${t.unionId}`);
             // The undefined arm participates: parsed JSON never contains
             // undefined (a MISSING record key was the arm's only source), but
-            // the DOM can hold the undefined value now — overflow entries
+            // the checked-dynamic tree can hold the undefined value now — overflow entries
             // under `unknown` index signatures — and it matches exactly the
             // undefined arm.
             const arms = def.arms.map((a) => `${E.dynMatchHelper(a)}(d)`);
@@ -666,7 +666,7 @@ export function dynMatchHelper(E, t) {
     E.walkerDefs.push(...d);
     return name;
 }
-/** The emitted keyed read on a dyn DOM value:
+/** The emitted keyed read on a dyn value:
    * `static ScrDyn *sc_dyn_key_get(ScrDyn *d, ScrStr *k, bool opt)` —
    * OBJ answers the member (+1) or the undefined singleton (own-property
    * answer); ARR answers `length` and canonical in-range indices, STR
@@ -693,14 +693,14 @@ export function dynDestrCheckHelper(E) {
     E.walkerDefs.push(`${sig} { /* destructuring RequireObjectCoercible */`, `  if (d->kind != SCR_DYN_UNDEF && d->kind != SCR_DYN_NULL) return;`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  if (firstProp) {`, `    scr_jb_puts(&b, "Cannot destructure property '");`, `    scr_jb_puts(&b, firstProp);`, `    scr_jb_puts(&b, "' of '");`, `    scr_jb_puts(&b, spell);`, `    scr_jb_puts(&b, "' as it is ");`, `  } else {`, `    scr_jb_puts(&b, "Cannot destructure '");`, `    scr_jb_puts(&b, spell);`, `    scr_jb_puts(&b, "' as it is ");`, `  }`, `  scr_jb_puts(&b, d->kind == SCR_DYN_UNDEF ? "undefined." : "null.");`, `  scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));`, `}`, ``);
     return name;
 }
-/** GetIterator + first-N steps over a DOM value (the dynIterN node), as
+/** GetIterator + first-N steps over a dyn value (the dynIterN node), as
  * array destructuring sees it: arrays step by index, strings by CODE
  * POINT (the string iterator — astral chars arrive unsplit), Buffers by
  * byte; everything else throws V8's exact not-iterable TypeError
  * ("undefined is not iterable …", "object null is not iterable …",
  * "number 1 is not iterable …", "boolean true …", "object …",
  * "function …" — each with the "(cannot read property
- * Symbol(Symbol.iterator))" tail). Returns a fresh +1 DOM array of
+ * Symbol(Symbol.iterator))" tail). Returns a fresh +1 dyn array of
  * exactly n elements, undefined-padded past the end. */
 export function dynIterNHelper(E) {
     const memoKey = "%dynIterN";
@@ -807,7 +807,7 @@ export function dynKeyGetHelper(E) {
 }
 /** The emitted checked builder for one dynCheck target type:
    * `static T sc_dc_<n>(const ScrDyn *d, const ScrDynPath *path)` —
-   * validate the DOM against T and BUILD the typed value (+1), or throw a
+   * validate the checked-dynamic tree against T and BUILD the typed value (+1), or throw a
    * catchable, path-annotated TypeError-shaped string through the exception
    * cell and return a dummy (0/false/NULL) with the pending flag set.
    * Recursive calls propagate a pending exception by releasing the
@@ -838,7 +838,7 @@ export function dynCheckHelper(E, t) {
             d.push(`  return scr_str_retain(d->v.str);`);
             break;
         case "dyn":
-            // An `unknown` slot (a dyn record field): the DOM subtree passes
+            // An `unknown` slot (a dyn record field): the checked-dynamic tree subtree passes
             // through as-is — nothing to validate, nothing to build.
             d.push(`  (void)path;`);
             d.push(`  return scr_dyn_retain((ScrDyn *)d);`);
@@ -853,14 +853,14 @@ export function dynCheckHelper(E, t) {
             break;
         case "object":
             // The %Error extraction (an instanceof-Error narrow on unknown):
-            // validate the DOM's error encoding — the reserved "%error" marker
+            // validate the checked-dynamic tree's error encoding — the reserved "%error" marker
             // caughtToDyn builds — and extract through the runtime's IDENTITY
-            // CACHE (scr_error_from_dyn): a DOM error that came from a runtime
+            // CACHE (scr_error_from_dyn): a dyn error that came from a runtime
             // ScrError answers that very instance, so out-and-back crossings
             // compare reference-equal (the tracing suite's shape); alien
             // %error objects rebuild once and cache the pair.
             if (t.className !== "%Error") {
-                throw new Error(`emitter bug: dynCheck of class ${t.className} (only %Error extracts from the DOM)`);
+                throw new Error(`emitter bug: dynCheck of class ${t.className} (only %Error extracts from the checked-dynamic tree)`);
             }
             d.push(`  if (d->kind != SCR_DYN_OBJ || !scr_dyn_obj_get(d, "%error", 6)) { scr_dyn_check_fail(path, ${want}, d); return NULL; }`);
             d.push(`  return scr_error_from_dyn(d);`);
@@ -906,7 +906,7 @@ export function dynCheckHelper(E, t) {
                 d.push(`    const ScrDyn *m = scr_dyn_obj_get(d, ${keyLit}, ${keyLen});`);
                 if (f.type.kind === "dyn") {
                     // An `unknown` field: a present key passes through, a missing
-                    // one IS the undefined DOM value (JS's missing-property read).
+                    // one IS the undefined dyn value (JS's missing-property read).
                     d.push(`    (void)p;`);
                     d.push(`    r->${mangleField(f.name)} = scr_dyn_retain(m ? (ScrDyn *)m : scr_dyn_undefined());`);
                 }
@@ -928,7 +928,7 @@ export function dynCheckHelper(E, t) {
             }
             // Index-signature shapes CAPTURE undeclared keys into the overflow
             // map (width tolerance became width capture — plain shapes above
-            // keep ignoring extras). dyn value types retain the DOM subtree
+            // keep ignoring extras). dyn value types retain the checked-dynamic tree subtree
             // as-is; concrete types validate each entry with its key path.
             if (shape.indexValue) {
                 const iv = shape.indexValue;
@@ -990,7 +990,7 @@ export function dynCheckHelper(E, t) {
                 if (arm.kind === "undefinedT") {
                     // Parsed JSON never matches here (no undefined in JSON text —
                     // a MISSING record key builds this arm in the record builder
-                    // above), but the undefined DOM value can arrive from
+                    // above), but the undefined dyn value can arrive from
                     // `unknown` index-signature overflows and builds the interned
                     // unit instance exactly like null.
                     d.push(`  if (${m}(d)) {`);
@@ -1062,12 +1062,12 @@ export function dynCheckHelper(E, t) {
     E.walkerDefs.push(...d);
     return name;
 }
-/** The emitted static→DOM converter for one type:
-   * `static ScrDyn *sc_td_<n>(<T> v)` — build a fresh dyn DOM value from a
+/** The emitted static→dyn converter for one type:
+   * `static ScrDyn *sc_td_<n>(<T> v)` — build a fresh dyn value from a
    * static one (+1), DEEP-COPYING composites (a dyn value never aliases
    * static storage — the jsMarshal stance). Domain: the JSON-safe kinds
    * plus undefined-armed unions (the undefined arm becomes the undefined
-   * DOM singleton) and index-signature records (whose overflow entries
+   * dyn singleton) and index-signature records (whose overflow entries
    * copy over). The operand is borrowed. Never throws. */
 export function toDynHelper(E, t) {
     const key = typeKey(t);
@@ -1091,14 +1091,14 @@ export function toDynHelper(E, t) {
             break;
         case "undefinedT":
             // A bare unit field (`x: undefined` in a record — the tls
-            // options-record's explicit-absent member): the DOM unit value.
+            // options-record's explicit-absent member): the dyn unit value.
             d.push(`  (void)v; return scr_dyn_retain(scr_dyn_undefined());`);
             break;
         case "nullT":
             d.push(`  (void)v; return scr_dyn_new_null();`);
             break;
         case "object":
-            // %Error only (canConvertToDyn's gate): the DOM's error encoding.
+            // %Error only (canConvertToDyn's gate): the checked-dynamic tree's error encoding.
             if (t.className !== "%Error") {
                 throw new Error(`emitter bug: to-dyn of class ${t.className}`);
             }
@@ -1106,12 +1106,12 @@ export function toDynHelper(E, t) {
             break;
         case "dyn":
             // A dyn member of a converting composite (a dyn record field): the
-            // DOM value passes through by reference — already a DOM, already
+            // dyn value passes through by reference — already a dyn, already
             // immutable-through-copies.
             d.push(`  return scr_dyn_retain(v);`);
             break;
         case "bytes":
-            // bytes<u8> → the DOM's bytes kind, payload COPIED (the boundary
+            // bytes<u8> → the checked-dynamic tree's bytes kind, payload COPIED (the boundary
             // stance; stdin chunks into unknown-typed helpers).
             if (t.elem !== "u8")
                 throw new Error(`emitter bug: to-dyn of bytes<${t.elem}>`);
@@ -1122,7 +1122,7 @@ export function toDynHelper(E, t) {
             if (!shape)
                 throw new Error(`emitter bug: to-dyn of unknown shape ${t.shapeId}`);
             // CYCLE-CAPABLE shapes guard the deep copy: a cyclic value has no
-            // finite DOM copy, so enter TRAPS on re-entry (SEMANTICS.md — Node
+            // finite dyn copy, so enter TRAPS on re-entry (SEMANTICS.md — Node
             // shares the reference instead of copying).
             const cyclicRec = E.traceAdapterC(t) !== null;
             if (cyclicRec)
@@ -1140,11 +1140,11 @@ export function toDynHelper(E, t) {
                 break;
             }
             d.push(`  ScrDyn *d = scr_dyn_new_obj();`);
-            // Keys insert in DECLARED order — the DOM object's insertion order
+            // Keys insert in DECLARED order — the dyn object's insertion order
             // is observable (Object.keys/for-in over checked-dynamic values,
             // dyn JSON), so it must be JS's (SEMANTICS.md 36's stance, same as
             // the JSON writer above). Internal '%'-fields declaredOrder omits
-            // still enter the DOM (after the visible keys) so a
+            // still enter the checked-dynamic tree (after the visible keys) so a
             // record→dyn→record round trip keeps their data.
             {
                 const byName = new Map(shape.fields.map((f) => [f.name, f]));
@@ -1252,7 +1252,7 @@ export function toDynHelper(E, t) {
         case "promise": {
             // Promises box by REFERENCE (SCR_DYN_PROMISE — identity is the
             // promise): promise<dyn> carries its ScrPromise directly (the
-            // payload is already a DOM value); any other inner boxes an
+            // payload is already a dyn value); any other inner boxes an
             // ADAPTER promise whose settle callback converts the payload
             // (rejections copy raw inside the runtime's cb-waiter machinery).
             if (t.inner.kind === "dyn") {
@@ -1278,9 +1278,9 @@ export function toDynHelper(E, t) {
     E.walkerDefs.push(...d);
     return name;
 }
-/** The DOM-promise settle adapter for one fulfillment payload type:
+/** The checked-dynamic tree-promise settle adapter for one fulfillment payload type:
    * `static void sc_pda_<n>(ScrPromise *dst, ScrPromise *src)` — read
-   * src's fulfilled payload by its compile-time kind, convert it to a DOM
+   * src's fulfilled payload by its compile-time kind, convert it to a dyn
    * value, and fulfill dst with it (scr_dyn_new_promise_adapting's
    * callback; rejections never reach an adapter — the runtime copies them
    * raw). Interned per inner typeKey. */
@@ -1338,10 +1338,10 @@ export function promiseDynAdapterHelper(E, inner) {
    *
    *   sc_dfk_<n> — the CALL THUNK a dyn-boxed closure carries: validate
    *   each dyn argument into the declared param type (JS arity: extras
-   *   ignored, missing args are the undefined DOM value — a param type
+   *   ignored, missing args are the undefined dyn value — a param type
    *   the undefined value fails checks throws the path-annotated
    *   TypeError), call through the closure, convert the result back to a
-   *   DOM value (+1).
+   *   dyn value (+1).
    *
    *   sc_dfb_<n> — the BOX builder dynFrom emits: a fresh SCR_DYN_FUNC
    *   node carrying the retained closure, the thunk, the arity, the
@@ -1384,7 +1384,7 @@ export function dynFuncThunkHelper(E, t) {
         d.push(`  (void)args;`);
     d.push(`  (void)argc;`);
     t.params.forEach((p, i) => {
-        // JS arity: a missing argument IS the undefined DOM value; the
+        // JS arity: a missing argument IS the undefined dyn value; the
         // param's own check decides whether that flies (dyn params take
         // anything; a number param throws the catchable TypeError).
         d.push(`  ${cDecl(p, `a${i}`)};`);
@@ -1394,7 +1394,7 @@ export function dynFuncThunkHelper(E, t) {
             d.push(`    a${i} = scr_dyn_retain((ScrDyn *)ad);`);
         }
         else if (p.kind === "jsval") {
-            // A checker-'any' param: the DOM argument enters the island —
+            // A checker-'any' param: the dyn argument enters the island —
             // wrapped cells unwrap by reference, data deep-copies, boxed
             // functions cross through the host shim; a kind with no crossing
             // throws the catchable TypeError (NULL + pending).
@@ -1414,7 +1414,7 @@ export function dynFuncThunkHelper(E, t) {
         }
         d.push(`  }`);
     });
-    // VARIADIC (rest-marked) signatures: one extra trailing DOM-array
+    // VARIADIC (rest-marked) signatures: one extra trailing dyn-array
     // param carries the call's arguments from index params.length on —
     // the mustCall wrapper's `arguments`, a JS `...args`. Built fresh per
     // call (+1, moved into the callee like every param).
@@ -1522,7 +1522,7 @@ export function dynFuncAdapterHelper(E, t) {
    * answer first (string comparisons in canonical order; the frontend
    * proved each surfaces as T: identity, a to-dyn conversion, or an
    * arm-into-union wrap), then the overflow map on index-signature shapes.
-   * A MISSING key yields the undefined DOM value (T dyn), the undefined
+   * A MISSING key yields the undefined dyn value (T dyn), the undefined
    * arm (T undefined-armed union), or TRAPS with the key text (the array
    * OOB policy — the checker claimed T and no undefined is representable).
    * Borrows both; refcounted results are owned (+1). */