@scriptc/compiler 0.0.34 → 0.0.36

package/dist/backend/{emission/emit-walkers.js → c/walkers.js}

@@ -1,84 +1,24 @@
-import { DYN_HANDLE_KINDS, isRefCounted, typeEquals, typeKey } from "../../ir/nodes.js";
-import { cDecl, cStringLiteral, cType, elemAccess, releaseCallC, retainCallC, vAdapters } from "./emit-types.js";
+import { InternalCompilerError } from "../../errors.js";
+import { DYN_HANDLE_KINDS, isRefCounted, typeEquals, typeKey } from "../../ir/ir.js";
+import { dynDesc, undefinedArmTag } from "../../ir/analysis.js";
+import { cDecl, cStringLiteral, cType, elemAccess, releaseCallC, retainCallC, vAdapters } from "./types.js";
 import { mangleField, mangleRecordNew, mangleRecordStruct } from "../mangle.js";
-import { OVERFLOW_MEMBER } from "./emit-shapes.js";
-/** Short human description of a dynCheck target for error messages
-   * ("expected number | string at $.items[2]"). Records read as "object" —
-   * the path already says where; the full shape would bloat messages. */
-export function dynDesc(E, t) {
-    switch (t.kind) {
-        case "f64":
-            return "number";
-        case "string":
-            return "string";
-        case "bool":
-            return "boolean";
-        case "record":
-            // Tuples read as "array": that IS the JSON representation the
-            // caller must supply (arity failures carry their own message).
-            return E.recordsById.get(t.shapeId)?.tuple ? "array" : "object";
-        case "array":
-            return "array";
-        case "nullT":
-            return "null";
-        // Reachable through optional-flavored record fields ("expected
-        // string | undefined at $.a" — honest: the fix is a string value OR
-        // omitting the key).
-        case "undefinedT":
-            return "undefined";
-        // 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";
-        case "bytes":
-            return "Uint8Array";
-        // The %Error extraction (an instanceof-Error narrow / cast on an
-        // unknown value): the failure names the class, like caughtCheck's.
-        case "object":
-            return t.className.replace(/^%/, "");
-        case "union": {
-            const def = E.unionsById.get(t.unionId);
-            if (!def)
-                throw new Error(`emitter bug: dynDesc of unknown union ${t.unionId}`);
-            return def.arms.map((a) => E.dynDesc(a)).join(" | ");
-        }
-        // Function targets (the checked-dynamic function boundary): the
-        // failure names the expected callability, not the full signature —
-        // the path already says where.
-        case "func":
-            return "function";
-        // Map/Set-valued index signatures (Record<string, Map<K, V>>): only
-        // reachable through the keyed-read miss trap's message — no dynCheck
-        // ever expects one.
-        case "map":
-            return "Map";
-        case "set":
-            return "Set";
-        default: {
-            // Runtime HANDLE targets name the class ("expected
-            // IncomingMessage at $, got string").
-            const h = DYN_HANDLE_KINDS.get(t.kind);
-            if (h)
-                return h.cls;
-            throw new Error(`emitter bug: dynDesc of non-JSON type ${t.kind}`);
-        }
-    }
-}
+import { OVERFLOW_MEMBER } from "./shapes.js";
 /** The per-union ToBoolean helper (interned per unionId): switch on the
    * runtime tag — unit arms false, f64 arms 0/NaN-falsy, string arms
    * empty-falsy, bool arms by payload, ref arms always true (JS objects),
    * jsval arms answered by the engine. Borrows the operand. */
-export function unionTruthyHelper(E, unionId) {
-    const existing = E.unionTruthyFns.get(unionId);
+export function unionTruthyHelper(emitter, unionId) {
+    const existing = emitter.unionTruthyFns.get(unionId);
     if (existing)
         return existing;
-    const def = E.unionsById.get(unionId);
+    const def = emitter.unionsById.get(unionId);
     if (!def)
-        throw new Error(`emitter bug: truthiness of unknown union ${unionId}`);
-    const name = `sc_ut_${E.unionTruthyFns.size}`;
-    E.unionTruthyFns.set(unionId, name);
+        throw new InternalCompilerError(`emitter bug: truthiness of unknown union ${unionId}`);
+    const name = `sc_ut_${emitter.unionTruthyFns.size}`;
+    emitter.unionTruthyFns.set(unionId, name);
     const sig = `static bool ${name}(ScrUnion *v)`;
-    E.walkerProtos.push(`${sig}; /* ToBoolean ${unionId} */`);
+    emitter.walkerProtos.push(`${sig}; /* ToBoolean ${unionId} */`);
     const d = [`${sig} { /* ToBoolean ${unionId} */`, `  switch (v->tag) {`];
     def.arms.forEach((arm, i) => {
         switch (arm.kind) {
@@ -105,7 +45,7 @@ export function unionTruthyHelper(E, unionId) {
         }
     });
     d.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The per-union strict-equality helper (interned per unionId, with a
@@ -115,19 +55,19 @@ export function unionTruthyHelper(E, unionId) {
    * (NaN equals NaN, +0 differs from -0) under the sameValue flag,
    * strings by bytes, bools by value, ref arms by POINTER identity (JS
    * object equality). Borrows both operands. */
-export function unionEqHelper(E, unionId, sameValue) {
+export function unionEqHelper(emitter, unionId, sameValue) {
     const key = sameValue ? `sv:${unionId}` : unionId;
-    const existing = E.unionEqFns.get(key);
+    const existing = emitter.unionEqFns.get(key);
     if (existing)
         return existing;
-    const def = E.unionsById.get(unionId);
+    const def = emitter.unionsById.get(unionId);
     if (!def)
-        throw new Error(`emitter bug: equality of unknown union ${unionId}`);
-    const name = `sc_ue_${E.unionEqFns.size}`;
-    E.unionEqFns.set(key, name);
+        throw new InternalCompilerError(`emitter bug: equality of unknown union ${unionId}`);
+    const name = `sc_ue_${emitter.unionEqFns.size}`;
+    emitter.unionEqFns.set(key, name);
     const what = sameValue ? "SameValue" : "strict equality";
     const sig = `static bool ${name}(ScrUnion *a, ScrUnion *b)`;
-    E.walkerProtos.push(`${sig}; /* ${what} ${unionId} */`);
+    emitter.walkerProtos.push(`${sig}; /* ${what} ${unionId} */`);
     const d = [
         `${sig} { /* ${what} ${unionId} */`,
         `  if (a->tag != b->tag) return false;`,
@@ -156,7 +96,7 @@ export function unionEqHelper(E, unionId, sameValue) {
         }
     });
     d.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The per-union ToString helper (interned per unionId): switch on the
@@ -165,23 +105,23 @@ export function unionEqHelper(E, unionId, sameValue) {
    * formatters (String(x) semantics). Ref arms never arrive (the frontend
    * fences unions with object arms from string conversion — JS would print
    * "[object Object]"). Borrows the operand; the result is owned (+1). */
-export function unionToStrHelper(E, unionId) {
-    const existing = E.unionToStrFns.get(unionId);
+export function unionToStrHelper(emitter, unionId) {
+    const existing = emitter.unionToStrFns.get(unionId);
     if (existing)
         return existing;
-    const def = E.unionsById.get(unionId);
+    const def = emitter.unionsById.get(unionId);
     if (!def)
-        throw new Error(`emitter bug: ToString of unknown union ${unionId}`);
-    const name = `sc_us_${E.unionToStrFns.size}`;
-    E.unionToStrFns.set(unionId, name);
+        throw new InternalCompilerError(`emitter bug: ToString of unknown union ${unionId}`);
+    const name = `sc_us_${emitter.unionToStrFns.size}`;
+    emitter.unionToStrFns.set(unionId, name);
     const sig = `static ScrStr *${name}(ScrUnion *v)`;
-    E.walkerProtos.push(`${sig}; /* ToString ${unionId} */`);
+    emitter.walkerProtos.push(`${sig}; /* ToString ${unionId} */`);
     const d = [`${sig} { /* ToString ${unionId} */`, `  switch (v->tag) {`];
     def.arms.forEach((arm, i) => {
         switch (arm.kind) {
             case "undefinedT":
             case "nullT": {
-                const lit = E.internLiteral(arm.kind === "undefinedT" ? "undefined" : "null");
+                const lit = emitter.internLiteral(arm.kind === "undefinedT" ? "undefined" : "null");
                 d.push(`  case ${i}: return scr_str_retain((ScrStr *)&${lit});`);
                 break;
             }
@@ -197,16 +137,16 @@ export function unionToStrHelper(E, unionId) {
             case "bytes": {
                 // Buffer.toString() IS the utf8 decode (Node's default
                 // encoding) — the `Buffer | string` chunk idiom.
-                const enc = E.internLiteral("utf8");
+                const enc = emitter.internLiteral("utf8");
                 d.push(`  case ${i}: return scr_bytes_to_str((ScrBytes *)scr_union_peek(v), (ScrStr *)&${enc});`);
                 break;
             }
             default:
-                throw new Error(`emitter bug: ToString of union with a ${arm.kind} arm (frontend fences these)`);
+                throw new InternalCompilerError(`emitter bug: ToString of union with a ${arm.kind} arm (frontend fences these)`);
         }
     });
     d.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The per-union array-join helper (interned per unionId): Array.prototype
@@ -216,20 +156,20 @@ export function unionToStrHelper(E, unionId) {
    * f64/bool via the JS-exact formatters). The frontend admits only unions
    * of f64/string/bool/unit arms here. Borrows the array and separator;
    * the result is owned (+1). */
-export function unionJoinHelper(E, unionId) {
-    const existing = E.unionJoinFns.get(unionId);
+export function unionJoinHelper(emitter, unionId) {
+    const existing = emitter.unionJoinFns.get(unionId);
     if (existing)
         return existing;
-    const def = E.unionsById.get(unionId);
+    const def = emitter.unionsById.get(unionId);
     if (!def)
-        throw new Error(`emitter bug: join of unknown union ${unionId}`);
-    const name = `sc_uj_${E.unionJoinFns.size}`;
-    E.unionJoinFns.set(unionId, name);
-    const toStr = unionToStrHelper(E, unionId);
+        throw new InternalCompilerError(`emitter bug: join of unknown union ${unionId}`);
+    const name = `sc_uj_${emitter.unionJoinFns.size}`;
+    emitter.unionJoinFns.set(unionId, name);
+    const toStr = unionToStrHelper(emitter, unionId);
     const unitTags = def.arms.flatMap((a, i) => a.kind === "undefinedT" || a.kind === "nullT" ? [i] : []);
     const sig = `static ScrStr *${name}(ScrArr *a, ScrStr *sep)`;
-    E.walkerProtos.push(`${sig}; /* join ${unionId} */`);
-    E.walkerDefs.push(`${sig} { /* Array#join over ${unionId}: nullish arms print empty */`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  size_t n = (size_t)scr_arr_len(a);`, `  for (size_t i = 0; i < n; i++) {`, `    if (i) for (size_t j = 0; j < sep->len; j++) scr_jb_putc(&b, sep->data[j]);`, `    ScrUnion *u = (ScrUnion *)scr_arr_get_ref(a, (double)i);`, ...(unitTags.length > 0
+    emitter.walkerProtos.push(`${sig}; /* join ${unionId} */`);
+    emitter.walkerDefs.push(`${sig} { /* Array#join over ${unionId}: nullish arms print empty */`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  size_t n = (size_t)scr_arr_len(a);`, `  for (size_t i = 0; i < n; i++) {`, `    if (i) for (size_t j = 0; j < sep->len; j++) scr_jb_putc(&b, sep->data[j]);`, `    ScrUnion *u = (ScrUnion *)scr_arr_get_ref(a, (double)i);`, ...(unitTags.length > 0
         ? [`    if (${unitTags.map((t) => `u->tag == ${t}`).join(" || ")}) { scr_union_release(u); continue; }`]
         : []), `    ScrStr *s = ${toStr}(u);`, `    for (size_t j = 0; j < s->len; j++) scr_jb_putc(&b, s->data[j]);`, `    scr_str_release(s);`, `    scr_union_release(u);`, `  }`, `  return scr_jb_finish(&b);`, `}`, ``);
     return name;
@@ -241,13 +181,13 @@ export function unionJoinHelper(E, unionId) {
    * with ","; null/undefined ELEMENTS print empty, nested arrays flatten
    * through the recursion — JS-exact), plain objects as
    * "[object Object]". The operand is borrowed; the result is owned (+1). */
-export function dynToStrHelper(E) {
-    if (E.dynToStrFn)
-        return E.dynToStrFn;
+export function dynToStrHelper(emitter) {
+    if (emitter.dynToStrFn)
+        return emitter.dynToStrFn;
     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 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;`, `  case SCR_DYN_TYPED_REF: {`, `    ScrDyn *sc_materialized = scr_dyn_typed_ref_materialize(d);`, `    ${name}_buf(b, sc_materialized);`, `    scr_dyn_release(sc_materialized);`, `    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);`, `}`, ``);
+    emitter.dynToStrFn = name;
+    emitter.walkerProtos.push(`static void ${name}_buf(ScrJsonBuf *b, const ScrDyn *d); /* String(unknown) walker */`, `static ScrStr *${name}(const ScrDyn *d); /* String(unknown) */`);
+    emitter.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;`, `  case SCR_DYN_TYPED_REF: {`, `    ScrDyn *sc_materialized = scr_dyn_typed_ref_materialize(d);`, `    ${name}_buf(b, sc_materialized);`, `    scr_dyn_release(sc_materialized);`, `    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
@@ -260,14 +200,14 @@ export function dynToStrHelper(E) {
    * closures, unions — and non-Error hierarchy objects, type-erased at
    * 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)
-        return E.caughtToDynFn;
+export function caughtToDynHelper(emitter) {
+    if (emitter.caughtToDynFn)
+        return emitter.caughtToDynFn;
     const name = "sc_cd";
-    E.caughtToDynFn = name;
+    emitter.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 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();`, `  }`, `}`, ``);
+    emitter.walkerProtos.push(`${sig}; /* caught -> unknown */`);
+    emitter.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):
@@ -280,25 +220,25 @@ export function caughtToDynHelper(E) {
    * commas, and colons inside JSON strings untouched. Compact input is
    * BORROWED; the result is a fresh string (+1). An empty indent (space 0,
    * "", null) never reaches here — the frontend drops the property. */
-export function jsonIndentHelper(E) {
-    if (E.jsonIndentFn)
-        return E.jsonIndentFn;
+export function jsonIndentHelper(emitter) {
+    if (emitter.jsonIndentFn)
+        return emitter.jsonIndentFn;
     const name = "sc_ji";
-    E.jsonIndentFn = name;
+    emitter.jsonIndentFn = name;
     const sig = `static ScrStr *${name}(ScrStr *compact, const char *indent, size_t ilen)`;
-    E.walkerProtos.push(`${sig}; /* stringify space re-indent */`);
-    E.walkerDefs.push(`${sig} { /* stringify space re-indent (Node's gap algorithm) */`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  const char *s = compact->data;`, `  size_t n = compact->len;`, `  size_t depth = 0;`, `  bool instr = false;`, `#define SCR_JI_INDENT() do { \\`, `    scr_jb_putc(&b, '\\n'); \\`, `    for (size_t td = 0; td < depth; td++) \\`, `      for (size_t tk = 0; tk < ilen; tk++) scr_jb_putc(&b, indent[tk]); \\`, `  } while (0)`, `  for (size_t i = 0; i < n; i++) {`, `    char c = s[i];`, `    if (instr) {`, `      scr_jb_putc(&b, c);`, `      if (c == '\\\\' && i + 1 < n) { scr_jb_putc(&b, s[++i]); }`, `      else if (c == '"') instr = false;`, `      continue;`, `    }`, `    switch (c) {`, `    case '"': instr = true; scr_jb_putc(&b, c); break;`, `    case '{': case '[':`, `      scr_jb_putc(&b, c);`, `      if (i + 1 < n && s[i + 1] == (c == '{' ? '}' : ']')) {`, `        scr_jb_putc(&b, s[++i]); /* empty {} / [] stay inline, like Node */`, `        break;`, `      }`, `      depth++;`, `      SCR_JI_INDENT();`, `      break;`, `    case '}': case ']':`, `      depth--;`, `      SCR_JI_INDENT();`, `      scr_jb_putc(&b, c);`, `      break;`, `    case ',':`, `      scr_jb_putc(&b, ',');`, `      SCR_JI_INDENT();`, `      break;`, `    case ':':`, `      scr_jb_putc(&b, ':');`, `      scr_jb_putc(&b, ' ');`, `      break;`, `    default:`, `      scr_jb_putc(&b, c);`, `    }`, `  }`, `#undef SCR_JI_INDENT`, `  return scr_jb_finish(&b);`, `}`, ``);
+    emitter.walkerProtos.push(`${sig}; /* stringify space re-indent */`);
+    emitter.walkerDefs.push(`${sig} { /* stringify space re-indent (Node's gap algorithm) */`, `  ScrJsonBuf b;`, `  scr_jb_init(&b);`, `  const char *s = compact->data;`, `  size_t n = compact->len;`, `  size_t depth = 0;`, `  bool instr = false;`, `#define SCR_JI_INDENT() do { \\`, `    scr_jb_putc(&b, '\\n'); \\`, `    for (size_t td = 0; td < depth; td++) \\`, `      for (size_t tk = 0; tk < ilen; tk++) scr_jb_putc(&b, indent[tk]); \\`, `  } while (0)`, `  for (size_t i = 0; i < n; i++) {`, `    char c = s[i];`, `    if (instr) {`, `      scr_jb_putc(&b, c);`, `      if (c == '\\\\' && i + 1 < n) { scr_jb_putc(&b, s[++i]); }`, `      else if (c == '"') instr = false;`, `      continue;`, `    }`, `    switch (c) {`, `    case '"': instr = true; scr_jb_putc(&b, c); break;`, `    case '{': case '[':`, `      scr_jb_putc(&b, c);`, `      if (i + 1 < n && s[i + 1] == (c == '{' ? '}' : ']')) {`, `        scr_jb_putc(&b, s[++i]); /* empty {} / [] stay inline, like Node */`, `        break;`, `      }`, `      depth++;`, `      SCR_JI_INDENT();`, `      break;`, `    case '}': case ']':`, `      depth--;`, `      SCR_JI_INDENT();`, `      scr_jb_putc(&b, c);`, `      break;`, `    case ',':`, `      scr_jb_putc(&b, ',');`, `      SCR_JI_INDENT();`, `      break;`, `    case ':':`, `      scr_jb_putc(&b, ':');`, `      scr_jb_putc(&b, ' ');`, `      break;`, `    default:`, `      scr_jb_putc(&b, c);`, `    }`, `  }`, `#undef SCR_JI_INDENT`, `  return scr_jb_finish(&b);`, `}`, ``);
     return name;
 }
-export function jsonWriteHelper(E, t) {
+export function jsonWriteHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.jsonWriters.get(key);
+    const existing = emitter.jsonWriters.get(key);
     if (existing)
         return existing;
-    const name = `sc_jw_${E.jsonWriters.size}`;
-    E.jsonWriters.set(key, name);
+    const name = `sc_jw_${emitter.jsonWriters.size}`;
+    emitter.jsonWriters.set(key, name);
     const sig = `static void ${name}(ScrJsonBuf *b, ${cDecl(t, "v")})`;
-    E.walkerProtos.push(`${sig}; /* stringify ${key} */`);
+    emitter.walkerProtos.push(`${sig}; /* stringify ${key} */`);
     const d = [`${sig} { /* stringify ${key} */`];
     switch (t.kind) {
         case "f64":
@@ -311,17 +251,17 @@ export function jsonWriteHelper(E, t) {
             d.push(`  scr_jb_put_json_str(b, v);`);
             break;
         case "record": {
-            const shape = E.recordsById.get(t.shapeId);
+            const shape = emitter.recordsById.get(t.shapeId);
             if (!shape)
-                throw new Error(`emitter bug: jsonStringify of unknown shape ${t.shapeId}`);
+                throw new InternalCompilerError(`emitter bug: jsonStringify of unknown shape ${t.shapeId}`);
             // CYCLE-CAPABLE shapes (recursive record types — the collector-
             // fixpoint set) bracket the walk with the circular-detection
             // stack: a value already being serialized above throws V8's exact
             // circular-structure TypeError (scr_jb_enter). Edge labels stamp
             // only before members whose walk can re-enter (cycle-capable
             // types); acyclic shapes pay nothing.
-            const cyclic = E.traceAdapterC(t) !== null;
-            const edgeable = (ft) => cyclic && E.traceAdapterC(ft) !== null;
+            const cyclic = emitter.traceAdapterC(t) !== null;
+            const edgeable = (ft) => cyclic && emitter.traceAdapterC(ft) !== null;
             if (cyclic)
                 d.push(`  if (!scr_jb_enter(b, v, ${shape.tuple ? "true" : "false"})) return; /* circular: pending TypeError */`);
             // A tuple serializes as a JSON ARRAY in index order — JS-exact
@@ -335,7 +275,7 @@ export function jsonWriteHelper(E, t) {
                         d.push(`  scr_jb_putc(b, ',');`);
                     if (edgeable(f.type))
                         d.push(`  scr_jb_edge_idx(b, ${i});`);
-                    d.push(`  ${E.jsonWriteHelper(f.type)}(b, v->${mangleField(f.name)});`);
+                    d.push(`  ${emitter.jsonWriteHelper(f.type)}(b, v->${mangleField(f.name)});`);
                 });
                 d.push(`  scr_jb_putc(b, ']');`);
                 if (cyclic)
@@ -354,7 +294,7 @@ export function jsonWriteHelper(E, t) {
             const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
             const inOrder = new Set(order);
             if (shape.fields.some((f) => !inOrder.has(f.name) && !f.name.startsWith("%"))) {
-                throw new Error(`emitter bug: declaredOrder of shape ${t.shapeId} omits a non-internal field`);
+                throw new InternalCompilerError(`emitter bug: declaredOrder of shape ${t.shapeId} omits a non-internal field`);
             }
             const byName = new Map(shape.fields.map((f) => [f.name, f]));
             const emitFields = order.map((n) => byName.get(n)).filter((f) => f !== undefined);
@@ -364,7 +304,7 @@ export function jsonWriteHelper(E, t) {
             // flag); all-required shapes keep the static prefix labels. An
             // overflow portion forces the dynamic path too (entry count is
             // runtime state).
-            const droppable = emitFields.some((f) => E.undefinedArmTag(f.type) >= 0) || !!shape.indexValue;
+            const droppable = emitFields.some((f) => undefinedArmTag(f.type, emitter.unionsById) >= 0) || !!shape.indexValue;
             d.push(`  scr_jb_putc(b, '{');`);
             if (!droppable) {
                 emitFields.forEach((f, i) => {
@@ -374,14 +314,14 @@ export function jsonWriteHelper(E, t) {
                         d.push(`  scr_jb_edge_prop(b, ${cStringLiteral(Buffer.from(f.name, "utf8"))});`);
                     // Refcounted fields are BORROWED straight off the struct (the
                     // record itself is borrowed for the whole call).
-                    d.push(`  ${E.jsonWriteHelper(f.type)}(b, v->${mangleField(f.name)});`);
+                    d.push(`  ${emitter.jsonWriteHelper(f.type)}(b, v->${mangleField(f.name)});`);
                 });
             }
             else {
                 d.push(`  bool first = true;`);
                 for (const f of emitFields) {
                     const label = cStringLiteral(Buffer.from(`"${f.name}":`, "utf8"));
-                    const utag = E.undefinedArmTag(f.type);
+                    const utag = undefinedArmTag(f.type, emitter.unionsById);
                     const pad = utag >= 0 ? "    " : "  ";
                     if (utag >= 0) {
                         d.push(`  if (v->${mangleField(f.name)}->tag != ${utag}) { /* undefined-valued field: dropped, like Node */`);
@@ -391,7 +331,7 @@ export function jsonWriteHelper(E, t) {
                     d.push(`${pad}scr_jb_puts(b, ${label});`);
                     if (edgeable(f.type))
                         d.push(`${pad}scr_jb_edge_prop(b, ${cStringLiteral(Buffer.from(f.name, "utf8"))});`);
-                    d.push(`${pad}${E.jsonWriteHelper(f.type)}(b, v->${mangleField(f.name)});`);
+                    d.push(`${pad}${emitter.jsonWriteHelper(f.type)}(b, v->${mangleField(f.name)});`);
                     if (utag >= 0)
                         d.push(`  }`);
                 }
@@ -419,8 +359,8 @@ export function jsonWriteHelper(E, t) {
                     }
                     const skipUndef = iv.kind === "dyn"
                         ? `e->kind == SCR_DYN_UNDEF`
-                        : E.undefinedArmTag(iv) >= 0
-                            ? `e->tag == ${E.undefinedArmTag(iv)}`
+                        : undefinedArmTag(iv, emitter.unionsById) >= 0
+                            ? `e->tag == ${undefinedArmTag(iv, emitter.unionsById)}`
                             : null;
                     if (skipUndef) {
                         d.push(`      if (${skipUndef}) { /* undefined-valued entry: dropped, like Node */`);
@@ -435,7 +375,7 @@ export function jsonWriteHelper(E, t) {
                     d.push(`      scr_jb_putc(b, ':');`);
                     if (edgeable(iv))
                         d.push(`      scr_jb_edge_key(b, k);`);
-                    d.push(`      ${E.jsonWriteHelper(iv)}(b, e);`);
+                    d.push(`      ${emitter.jsonWriteHelper(iv)}(b, e);`);
                     d.push(`      scr_str_release(k);`);
                     if (isRefCounted(iv))
                         d.push(`      ${releaseCallC(iv, "e")};`);
@@ -459,10 +399,10 @@ export function jsonWriteHelper(E, t) {
             break;
         case "array": {
             const elem = t.elem;
-            const w = E.jsonWriteHelper(elem);
+            const w = emitter.jsonWriteHelper(elem);
             // A cycle-capable array (elements can point back at it) joins the
             // circular-detection stack exactly like a cycle-capable record.
-            const cyclic = E.traceAdapterC(t) !== null;
+            const cyclic = emitter.traceAdapterC(t) !== null;
             if (cyclic)
                 d.push(`  if (!scr_jb_enter(b, v, true)) return; /* circular: pending TypeError */`);
             d.push(`  scr_jb_putc(b, '[');`);
@@ -489,9 +429,9 @@ export function jsonWriteHelper(E, t) {
             break;
         }
         case "union": {
-            const def = E.unionsById.get(t.unionId);
+            const def = emitter.unionsById.get(t.unionId);
             if (!def)
-                throw new Error(`emitter bug: jsonStringify of unknown union ${t.unionId}`);
+                throw new InternalCompilerError(`emitter bug: jsonStringify of unknown union ${t.unionId}`);
             d.push(`  switch (v->tag) {`);
             def.arms.forEach((arm, i) => {
                 if (arm.kind === "nullT") {
@@ -509,7 +449,7 @@ export function jsonWriteHelper(E, t) {
                     d.push(`    scr_trap("scriptc: internal error: stringify reached an undefined arm\\n");`);
                     return;
                 }
-                const w = E.jsonWriteHelper(arm);
+                const w = emitter.jsonWriteHelper(arm);
                 if (arm.kind === "f64") {
                     d.push(`  case ${i}: ${w}(b, scr_union_get_f64(v)); break;`);
                 }
@@ -526,10 +466,10 @@ export function jsonWriteHelper(E, t) {
             break;
         }
         default:
-            throw new Error(`emitter bug: jsonStringify of non-JSON type ${t.kind}`);
+            throw new InternalCompilerError(`emitter bug: jsonStringify of non-JSON type ${t.kind}`);
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The emitted match predicate for one dynCheck target type:
@@ -537,15 +477,15 @@ export function jsonWriteHelper(E, 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 function dynMatchHelper(E, t) {
+export function dynMatchHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.dynMatchers.get(key);
+    const existing = emitter.dynMatchers.get(key);
     if (existing)
         return existing;
-    const name = `sc_dm_${E.dynMatchers.size}`;
-    E.dynMatchers.set(key, name);
+    const name = `sc_dm_${emitter.dynMatchers.size}`;
+    emitter.dynMatchers.set(key, name);
     const sig = `static bool ${name}(const ScrDyn *d)`;
-    E.walkerProtos.push(`${sig}; /* matches ${key} */`);
+    emitter.walkerProtos.push(`${sig}; /* matches ${key} */`);
     const d = [`${sig} { /* matches ${key} */`];
     if (isRefCounted(t) && t.kind !== "dyn") {
         const keyLit = cStringLiteral(Buffer.from(key, "utf8"));
@@ -583,13 +523,13 @@ export function dynMatchHelper(E, t) {
         case "bytes":
             // 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}>`);
+                throw new InternalCompilerError(`emitter bug: dynMatch of bytes<${t.elem}>`);
             d.push(`  return d->kind == SCR_DYN_BYTES;`);
             break;
         case "record": {
-            const shape = E.recordsById.get(t.shapeId);
+            const shape = emitter.recordsById.get(t.shapeId);
             if (!shape)
-                throw new Error(`emitter bug: dynCheck of unknown shape ${t.shapeId}`);
+                throw new InternalCompilerError(`emitter bug: dynCheck of unknown shape ${t.shapeId}`);
             // A tuple matches a JSON ARRAY of EXACTLY its arity whose elements
             // match positionally (arity is part of the type — width tolerance
             // is an object-key concept and does not apply).
@@ -597,7 +537,7 @@ export function dynMatchHelper(E, t) {
                 const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
                 d.push(`  if (d->kind != SCR_DYN_ARR || d->v.arr.len != ${byIndex.length}) return false;`);
                 byIndex.forEach((f, i) => {
-                    d.push(`  if (!${E.dynMatchHelper(f.type)}(d->v.arr.items[${i}])) return false;`);
+                    d.push(`  if (!${emitter.dynMatchHelper(f.type)}(d->v.arr.items[${i}])) return false;`);
                 });
                 d.push(`  return true;`);
                 break;
@@ -613,13 +553,13 @@ export function dynMatchHelper(E, t) {
                 const keyLit = cStringLiteral(Buffer.from(f.name, "utf8"));
                 const keyLen = Buffer.byteLength(f.name, "utf8");
                 d.push(`  m = scr_dyn_obj_get(d, ${keyLit}, ${keyLen});`);
-                if (E.undefinedArmTag(f.type) >= 0) {
+                if (undefinedArmTag(f.type, emitter.unionsById) >= 0) {
                     // Optional-flavored field: a MISSING key is the undefined arm
                     // (a match); a PRESENT key must fit the union as usual.
-                    d.push(`  if (m && !${E.dynMatchHelper(f.type)}(m)) return false;`);
+                    d.push(`  if (m && !${emitter.dynMatchHelper(f.type)}(m)) return false;`);
                 }
                 else {
-                    d.push(`  if (!m || !${E.dynMatchHelper(f.type)}(m)) return false;`);
+                    d.push(`  if (!m || !${emitter.dynMatchHelper(f.type)}(m)) return false;`);
                 }
             }
             // Index-signature shapes: UNDECLARED keys must fit the overflow
@@ -638,14 +578,14 @@ export function dynMatchHelper(E, t) {
                 d.push(`    const ScrDynEntry *e = &d->v.obj.entries[i];`);
                 if (shape.fields.length > 0)
                     d.push(`    if (${skip}) continue;`);
-                d.push(`    if (!${E.dynMatchHelper(shape.indexValue)}(e->value)) return false;`);
+                d.push(`    if (!${emitter.dynMatchHelper(shape.indexValue)}(e->value)) return false;`);
                 d.push(`  }`);
             }
             d.push(`  return true;`);
             break;
         }
         case "array": {
-            const m = E.dynMatchHelper(t.elem);
+            const m = emitter.dynMatchHelper(t.elem);
             d.push(`  if (d->kind != SCR_DYN_ARR) return false;`);
             d.push(`  for (size_t i = 0; i < d->v.arr.len; i++) {`);
             d.push(`    if (!${m}(d->v.arr.items[i])) return false;`);
@@ -654,23 +594,23 @@ export function dynMatchHelper(E, t) {
             break;
         }
         case "union": {
-            const def = E.unionsById.get(t.unionId);
+            const def = emitter.unionsById.get(t.unionId);
             if (!def)
-                throw new Error(`emitter bug: dynCheck of unknown union ${t.unionId}`);
+                throw new InternalCompilerError(`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 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)`);
+            const arms = def.arms.map((a) => `${emitter.dynMatchHelper(a)}(d)`);
             d.push(`  return ${arms.join(" || ")};`);
             break;
         }
         default:
-            throw new Error(`emitter bug: dynMatch of non-JSON type ${t.kind}`);
+            throw new InternalCompilerError(`emitter bug: dynMatch of non-JSON type ${t.kind}`);
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The emitted keyed read on a dyn value:
@@ -688,16 +628,16 @@ export function dynMatchHelper(E, t) {
  * is undefined." (or "…null."), the property form "Cannot destructure
  * property 'PROP' of 'SPELL' …" when firstProp is non-NULL — V8's exact
  * strings, source spelling included. Non-nullish values pass silently. */
-export function dynDestrCheckHelper(E) {
+export function dynDestrCheckHelper(emitter) {
     const memoKey = "%dynDestrCheck";
-    const existing = E.dynBuilders.get(memoKey);
+    const existing = emitter.dynBuilders.get(memoKey);
     if (existing)
         return existing;
     const name = "sc_dyn_destr_check";
-    E.dynBuilders.set(memoKey, name);
+    emitter.dynBuilders.set(memoKey, name);
     const sig = `static void ${name}(const ScrDyn *d, const char *spell, const char *firstProp)`;
-    E.walkerProtos.push(`${sig}; /* destructuring RequireObjectCoercible */`);
-    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));`, `}`, ``);
+    emitter.walkerProtos.push(`${sig}; /* destructuring RequireObjectCoercible */`);
+    emitter.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 dyn value (the dynIterN node), as
@@ -709,27 +649,27 @@ export function dynDestrCheckHelper(E) {
  * "function …" — each with the "(cannot read property
  * Symbol(Symbol.iterator))" tail). Returns a fresh +1 dyn array of
  * exactly n elements, undefined-padded past the end. */
-export function dynIterNHelper(E) {
+export function dynIterNHelper(emitter) {
     const memoKey = "%dynIterN";
-    const existing = E.dynBuilders.get(memoKey);
+    const existing = emitter.dynBuilders.get(memoKey);
     if (existing)
         return existing;
     const name = "sc_dyn_iter_n";
-    E.dynBuilders.set(memoKey, name);
+    emitter.dynBuilders.set(memoKey, name);
     const sig = `static ScrDyn *${name}(const ScrDyn *d, size_t n)`;
-    E.walkerProtos.push(`${sig}; /* destructuring GetIterator + N steps */`);
-    E.walkerDefs.push(`${sig} { /* destructuring GetIterator + N steps */`, `  if (d->kind == SCR_DYN_TYPED_REF) {`, `    ScrDyn *sc_materialized = scr_dyn_typed_ref_materialize(d);`, `    ScrDyn *sc_out = ${name}(sc_materialized, n);`, `    scr_dyn_release(sc_materialized);`, `    return sc_out;`, `  }`, `  if (d->kind == SCR_DYN_JSVAL) {`, `    /* An engine array IS iterable — the not-iterable TypeError below`, `     * would be a wrong claim. Loud fence (lane dyn-routing-ops). */`, `    scr_dyn_isl_fence(d, "iteration");`, `    return NULL;`, `  }`, `  if (d->kind != SCR_DYN_ARR && d->kind != SCR_DYN_STR && d->kind != SCR_DYN_BYTES) {`, `    ScrJsonBuf b;`, `    scr_jb_init(&b);`, `    switch (d->kind) {`, `    case SCR_DYN_UNDEF: scr_jb_puts(&b, "undefined"); break;`, `    case SCR_DYN_NULL: scr_jb_puts(&b, "object null"); break;`, `    case SCR_DYN_BOOL: scr_jb_puts(&b, d->v.b ? "boolean true" : "boolean false"); break;`, `    case SCR_DYN_NUM: {`, `      scr_jb_puts(&b, "number ");`, `      ScrStr *s = scr_f64_to_scrstr(d->v.num);`, `      for (size_t i = 0; i < s->len; i++) scr_jb_putc(&b, s->data[i]);`, `      scr_str_release(s);`, `      break;`, `    }`, `    case SCR_DYN_FUNC: scr_jb_puts(&b, "function"); break;`, `    default: scr_jb_puts(&b, "object"); break;`, `    }`, `    scr_jb_puts(&b, " is not iterable (cannot read property Symbol(Symbol.iterator))");`, `    scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));`, `    return NULL;`, `  }`, `  ScrDyn *out = scr_dyn_new_arr();`, `  for (size_t i = 0; i < n; i++) {`, `    ScrDyn *item = NULL;`, `    if (d->kind == SCR_DYN_ARR) {`, `      item = i < d->v.arr.len ? scr_dyn_retain(d->v.arr.items[i]) : scr_dyn_retain(scr_dyn_undefined());`, `    } else if (d->kind == SCR_DYN_BYTES) {`, `      item = i < d->v.bytes->len ? scr_dyn_new_num((double)d->v.bytes->data[i]) : scr_dyn_retain(scr_dyn_undefined());`, `    } else {`, `      /* String iteration: whole code POINTS (astral chars arrive`, `       * unsplit — the string iterator, not charAt). */`, `      double len = scr_str_utf16_len(d->v.str);`, `      double at = 0;`, `      for (size_t step = 0; step < i && at < len; step++) {`, `        ScrStr *cp = scr_str_cp_at(d->v.str, at);`, `        at += scr_str_utf16_len(cp);`, `        scr_str_release(cp);`, `      }`, `      if (at < len) {`, `        ScrStr *cp = scr_str_cp_at(d->v.str, at);`, `        item = scr_dyn_new_str(cp);`, `        scr_str_release(cp);`, `      } else {`, `        item = scr_dyn_retain(scr_dyn_undefined());`, `      }`, `    }`, `    scr_dyn_arr_push(out, item); /* push takes ownership */`, `  }`, `  return out;`, `}`, ``);
+    emitter.walkerProtos.push(`${sig}; /* destructuring GetIterator + N steps */`);
+    emitter.walkerDefs.push(`${sig} { /* destructuring GetIterator + N steps */`, `  if (d->kind == SCR_DYN_TYPED_REF) {`, `    ScrDyn *sc_materialized = scr_dyn_typed_ref_materialize(d);`, `    ScrDyn *sc_out = ${name}(sc_materialized, n);`, `    scr_dyn_release(sc_materialized);`, `    return sc_out;`, `  }`, `  if (d->kind == SCR_DYN_JSVAL) {`, `    /* An engine array IS iterable — the not-iterable TypeError below`, `     * would be a wrong claim. Loud fence (lane dyn-routing-ops). */`, `    scr_dyn_isl_fence(d, "iteration");`, `    return NULL;`, `  }`, `  if (d->kind != SCR_DYN_ARR && d->kind != SCR_DYN_STR && d->kind != SCR_DYN_BYTES) {`, `    ScrJsonBuf b;`, `    scr_jb_init(&b);`, `    switch (d->kind) {`, `    case SCR_DYN_UNDEF: scr_jb_puts(&b, "undefined"); break;`, `    case SCR_DYN_NULL: scr_jb_puts(&b, "object null"); break;`, `    case SCR_DYN_BOOL: scr_jb_puts(&b, d->v.b ? "boolean true" : "boolean false"); break;`, `    case SCR_DYN_NUM: {`, `      scr_jb_puts(&b, "number ");`, `      ScrStr *s = scr_f64_to_scrstr(d->v.num);`, `      for (size_t i = 0; i < s->len; i++) scr_jb_putc(&b, s->data[i]);`, `      scr_str_release(s);`, `      break;`, `    }`, `    case SCR_DYN_FUNC: scr_jb_puts(&b, "function"); break;`, `    default: scr_jb_puts(&b, "object"); break;`, `    }`, `    scr_jb_puts(&b, " is not iterable (cannot read property Symbol(Symbol.iterator))");`, `    scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));`, `    return NULL;`, `  }`, `  ScrDyn *out = scr_dyn_new_arr();`, `  for (size_t i = 0; i < n; i++) {`, `    ScrDyn *item = NULL;`, `    if (d->kind == SCR_DYN_ARR) {`, `      item = i < d->v.arr.len ? scr_dyn_retain(d->v.arr.items[i]) : scr_dyn_retain(scr_dyn_undefined());`, `    } else if (d->kind == SCR_DYN_BYTES) {`, `      item = i < d->v.bytes->len ? scr_dyn_new_num((double)d->v.bytes->data[i]) : scr_dyn_retain(scr_dyn_undefined());`, `    } else {`, `      /* String iteration: whole code POINTS (astral chars arrive`, `       * unsplit — the string iterator, not charAt). */`, `      double len = scr_str_utf16_len(d->v.str);`, `      double at = 0;`, `      for (size_t step = 0; step < i && at < len; step++) {`, `        ScrStr *cp = scr_str_cp_at(d->v.str, at);`, `        at += scr_str_utf16_len(cp);`, `        scr_str_release(cp);`, `      }`, `      if (at < len) {`, `        ScrStr *cp = scr_str_cp_at(d->v.str, at);`, `        item = scr_dyn_new_str(cp);`, `        scr_str_release(cp);`, `      } else {`, `        item = scr_dyn_retain(scr_dyn_undefined());`, `      }`, `    }`, `    scr_dyn_arr_push(out, item); /* push takes ownership */`, `  }`, `  return out;`, `}`, ``);
     return name;
 }
-export function dynKeyGetHelper(E) {
+export function dynKeyGetHelper(emitter) {
     const memoKey = "%dynKeyGet";
-    const existing = E.dynBuilders.get(memoKey);
+    const existing = emitter.dynBuilders.get(memoKey);
     if (existing)
         return existing;
     const name = "sc_dyn_key_get";
-    E.dynBuilders.set(memoKey, name);
+    emitter.dynBuilders.set(memoKey, name);
     const sig = `static ScrDyn *${name}(ScrDyn *d, ScrStr *k, bool opt)`;
-    E.walkerProtos.push(`${sig}; /* d[k] on dyn */`);
+    emitter.walkerProtos.push(`${sig}; /* d[k] on dyn */`);
     const d = [`${sig} { /* d[k] on dyn */`];
     d.push(`  if (d->kind == SCR_DYN_UNDEF || d->kind == SCR_DYN_NULL) {`);
     d.push(`    if (opt) return scr_dyn_retain(scr_dyn_undefined());`);
@@ -815,7 +755,7 @@ export function dynKeyGetHelper(E) {
     d.push(`  }`);
     d.push(`  return scr_dyn_retain(scr_dyn_undefined());`);
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The emitted checked builder for one dynCheck target type:
@@ -826,16 +766,16 @@ export function dynKeyGetHelper(E) {
    * Recursive calls propagate a pending exception by releasing the
    * partially-built value and returning — the same pending-check discipline
    * emitted function bodies follow. */
-export function dynCheckHelper(E, t) {
+export function dynCheckHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.dynBuilders.get(key);
+    const existing = emitter.dynBuilders.get(key);
     if (existing)
         return existing;
-    const name = `sc_dc_${E.dynBuilders.size}`;
-    E.dynBuilders.set(key, name);
+    const name = `sc_dc_${emitter.dynBuilders.size}`;
+    emitter.dynBuilders.set(key, name);
     const sig = `static ${cType(t)}${cType(t).endsWith("*") ? "" : " "}${name}(const ScrDyn *d, const ScrDynPath *path)`;
-    E.walkerProtos.push(`${sig}; /* check ${key} */`);
-    const want = cStringLiteral(Buffer.from(E.dynDesc(t), "utf8"));
+    emitter.walkerProtos.push(`${sig}; /* check ${key} */`);
+    const want = cStringLiteral(Buffer.from(dynDesc(t, emitter.recordsById, emitter.unionsById), "utf8"));
     const d = [`${sig} { /* check ${key} */`];
     if (isRefCounted(t) && t.kind !== "dyn") {
         const keyLit = cStringLiteral(Buffer.from(key, "utf8"));
@@ -849,9 +789,9 @@ export function dynCheckHelper(E, t) {
             }
             d.push(`    ScrDyn *sc_materialized = scr_dyn_typed_ref_materialize(d);`, `    ${cDecl(t, "sc_out")} = ${name}(sc_materialized, path);`, `    scr_dyn_release(sc_materialized);`);
             if (t.kind === "record") {
-                const shape = E.recordsById.get(t.shapeId);
+                const shape = emitter.recordsById.get(t.shapeId);
                 if (!shape) {
-                    throw new Error(`emitter bug: cached typed-ref cast of unknown shape ${t.shapeId}`);
+                    throw new InternalCompilerError(`emitter bug: cached typed-ref cast of unknown shape ${t.shapeId}`);
                 }
                 d.push(`    if (sc_out && sc_cached) {`);
                 for (const field of shape.fields) {
@@ -893,7 +833,7 @@ export function dynCheckHelper(E, t) {
             // `u as Uint8Array`: kind check, then a fresh COPY out (the
             // boundary's aliasing stance in both directions).
             if (t.elem !== "u8")
-                throw new Error(`emitter bug: dynCheck of bytes<${t.elem}>`);
+                throw new InternalCompilerError(`emitter bug: dynCheck of bytes<${t.elem}>`);
             d.push(`  if (d->kind != SCR_DYN_BYTES) { scr_dyn_check_fail(path, ${want}, d); return NULL; }`);
             d.push(`  return scr_dyn_bytes_copy_out(d);`);
             break;
@@ -906,15 +846,15 @@ export function dynCheckHelper(E, t) {
             // 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 checked-dynamic tree)`);
+                throw new InternalCompilerError(`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);`);
             break;
         case "record": {
-            const shape = E.recordsById.get(t.shapeId);
+            const shape = emitter.recordsById.get(t.shapeId);
             if (!shape)
-                throw new Error(`emitter bug: dynCheck of unknown shape ${t.shapeId}`);
+                throw new InternalCompilerError(`emitter bug: dynCheck of unknown shape ${t.shapeId}`);
             const rel = (v) => releaseCallC(t, v);
             // Tuple targets: a JSON ARRAY of exactly the arity, validated and
             // extracted positionally with index paths ("$.pairs[3][1]").
@@ -927,7 +867,7 @@ export function dynCheckHelper(E, t) {
                 byIndex.forEach((f, i) => {
                     d.push(`  {`);
                     d.push(`    ScrDynPath p = { path, NULL, ${i} };`);
-                    d.push(`    r->${mangleField(f.name)} = ${E.dynCheckHelper(f.type)}(d->v.arr.items[${i}], &p);`);
+                    d.push(`    r->${mangleField(f.name)} = ${emitter.dynCheckHelper(f.type)}(d->v.arr.items[${i}], &p);`);
                     d.push(`    if (scr_exc_pending()) { ${rel("r")}; return NULL; }`);
                     d.push(`  }`);
                 });
@@ -939,14 +879,14 @@ export function dynCheckHelper(E, t) {
             for (const f of shape.fields) {
                 const keyLit = cStringLiteral(Buffer.from(f.name, "utf8"));
                 const keyLen = Buffer.byteLength(f.name, "utf8");
-                const fieldWant = cStringLiteral(Buffer.from(E.dynDesc(f.type), "utf8"));
+                const fieldWant = cStringLiteral(Buffer.from(dynDesc(f.type, emitter.recordsById, emitter.unionsById), "utf8"));
                 // Width tolerance: only declared fields are looked up — extra JSON
                 // keys are simply never examined (check-and-extract, not shape
                 // equality). A missing field fails as "got undefined" — except
                 // optional-flavored fields (undefined-armed unions), where the
                 // missing key IS the undefined arm: the interned immortal
                 // instance, no retain owed (rc == SIZE_MAX).
-                const utag = f.type.kind === "union" ? E.undefinedArmTag(f.type) : -1;
+                const utag = f.type.kind === "union" ? undefinedArmTag(f.type, emitter.unionsById) : -1;
                 d.push(`  {`);
                 d.push(`    ScrDynPath p = { path, ${keyLit}, 0 };`);
                 d.push(`    const ScrDyn *m = scr_dyn_obj_get(d, ${keyLit}, ${keyLen});`);
@@ -955,20 +895,20 @@ export function dynCheckHelper(E, t) {
                     // one IS the undefined dyn value (JS's missing-property read).
                     // Go through the dyn builder so a Web-stream typed-ref capsule
                     // cannot escape inside a checked record field.
-                    d.push(`    r->${mangleField(f.name)} = ${E.dynCheckHelper(f.type)}(m ? m : scr_dyn_undefined(), &p);`);
+                    d.push(`    r->${mangleField(f.name)} = ${emitter.dynCheckHelper(f.type)}(m ? m : scr_dyn_undefined(), &p);`);
                 }
                 else if (utag >= 0 && f.type.kind === "union") {
-                    const unit = E.unitInstanceRef(f.type.unionId, utag);
+                    const unit = emitter.unitInstanceRef(f.type.unionId, utag);
                     d.push(`    if (!m) {`);
                     d.push(`      r->${mangleField(f.name)} = ${unit}; /* absent key -> the undefined arm */`);
                     d.push(`    } else {`);
-                    d.push(`      r->${mangleField(f.name)} = ${E.dynCheckHelper(f.type)}(m, &p);`);
+                    d.push(`      r->${mangleField(f.name)} = ${emitter.dynCheckHelper(f.type)}(m, &p);`);
                     d.push(`      if (scr_exc_pending()) { ${rel("r")}; return NULL; }`);
                     d.push(`    }`);
                 }
                 else {
                     d.push(`    if (!m) { scr_dyn_check_fail(&p, ${fieldWant}, NULL); ${rel("r")}; return NULL; }`);
-                    d.push(`    r->${mangleField(f.name)} = ${E.dynCheckHelper(f.type)}(m, &p);`);
+                    d.push(`    r->${mangleField(f.name)} = ${emitter.dynCheckHelper(f.type)}(m, &p);`);
                     d.push(`    if (scr_exc_pending()) { ${rel("r")}; return NULL; }`);
                 }
                 d.push(`  }`);
@@ -995,7 +935,7 @@ export function dynCheckHelper(E, t) {
                 }
                 else {
                     d.push(`    ScrDynPath p = { path, e->key, 0 };`);
-                    d.push(`    ${cDecl(iv, "ev")} = ${E.dynCheckHelper(iv)}(e->value, &p);`);
+                    d.push(`    ${cDecl(iv, "ev")} = ${emitter.dynCheckHelper(iv)}(e->value, &p);`);
                     d.push(`    if (scr_exc_pending()) { ${rel("r")}; return NULL; }`);
                 }
                 d.push(`    ScrStr *ek = scr_str_new(e->key, e->key_len);`);
@@ -1013,9 +953,9 @@ export function dynCheckHelper(E, t) {
         }
         case "array": {
             const elem = t.elem;
-            const c = E.dynCheckHelper(elem);
+            const c = emitter.dynCheckHelper(elem);
             d.push(`  if (d->kind != SCR_DYN_ARR) { scr_dyn_check_fail(path, ${want}, d); return NULL; }`);
-            d.push(`  ScrArr *a = ${E.arrNewC(elem, "d->v.arr.len")};`);
+            d.push(`  ScrArr *a = ${emitter.arrNewC(elem, "d->v.arr.len")};`);
             d.push(`  for (size_t i = 0; i < d->v.arr.len; i++) {`);
             d.push(`    ScrDynPath p = { path, NULL, i };`);
             d.push(`    ${cDecl(elem, "e")} = ${c}(d->v.arr.items[i], &p);`);
@@ -1026,14 +966,14 @@ export function dynCheckHelper(E, t) {
             break;
         }
         case "union": {
-            const def = E.unionsById.get(t.unionId);
+            const def = emitter.unionsById.get(t.unionId);
             if (!def)
-                throw new Error(`emitter bug: dynCheck of unknown union ${t.unionId}`);
+                throw new InternalCompilerError(`emitter bug: dynCheck of unknown union ${t.unionId}`);
             // Arms in CANONICAL order, first FULL match wins (discriminated
             // unions disambiguate naturally: the arm whose declared fields all
             // fit). The matched arm's builder can no longer fail.
             def.arms.forEach((arm, i) => {
-                const m = E.dynMatchHelper(arm);
+                const m = emitter.dynMatchHelper(arm);
                 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
@@ -1041,7 +981,7 @@ export function dynCheckHelper(E, t) {
                     // `unknown` index-signature overflows and builds the interned
                     // unit instance exactly like null.
                     d.push(`  if (${m}(d)) {`);
-                    d.push(`    return ${E.unitInstanceRef(t.unionId, i)};`);
+                    d.push(`    return ${emitter.unitInstanceRef(t.unionId, i)};`);
                     d.push(`  }`);
                     return;
                 }
@@ -1050,11 +990,11 @@ export function dynCheckHelper(E, t) {
                     // immortal instance (rc == SIZE_MAX — RC entry points and the
                     // collector both skip it, so no retain is owed).
                     d.push(`  if (${m}(d)) {`);
-                    d.push(`    return ${E.unitInstanceRef(t.unionId, i)};`);
+                    d.push(`    return ${emitter.unitInstanceRef(t.unionId, i)};`);
                     d.push(`  }`);
                     return;
                 }
-                const c = E.dynCheckHelper(arm);
+                const c = emitter.dynCheckHelper(arm);
                 d.push(`  if (${m}(d)) {`);
                 if (arm.kind === "f64") {
                     d.push(`    return scr_union_new_f64(${i}, ${c}(d, path));`);
@@ -1064,7 +1004,7 @@ export function dynCheckHelper(E, t) {
                 }
                 else {
                     const rc = vAdapters(arm);
-                    d.push(`    return scr_union_new_ref(${i}, ${c}(d, path), &${rc.retain}, &${rc.release}, ${E.traceArgC(arm)});`);
+                    d.push(`    return scr_union_new_ref(${i}, ${c}(d, path), &${rc.retain}, &${rc.release}, ${emitter.traceArgC(arm)});`);
                 }
                 d.push(`  }`);
             });
@@ -1113,7 +1053,7 @@ export function dynCheckHelper(E, t) {
             // wrapper, retained); anything else wraps in the per-target
             // adapter closure, whose caps[0] obj-box owns the dyn value
             // (untraced — cycles through dyn never collect, SEMANTICS.md).
-            const adapter = dynFuncAdapterHelper(E, t);
+            const adapter = dynFuncAdapterHelper(emitter, t);
             const sigLit = cStringLiteral(Buffer.from(key, "utf8"));
             d.push(`  if (d->kind != SCR_DYN_FUNC) { scr_dyn_check_fail(path, ${want}, d); return NULL; }`);
             d.push(`  if (strcmp(d->v.fn.sig, ${sigLit}) == 0) return scr_closure_retain(d->v.fn.clo);`);
@@ -1134,11 +1074,11 @@ export function dynCheckHelper(E, t) {
                 d.push(`  return (${cType(t).trim()})scr_dyn_handle_unbox(d, ${h.tag}, path, ${want});`);
                 break;
             }
-            throw new Error(`emitter bug: dynCheck of non-JSON type ${t.kind}`);
+            throw new InternalCompilerError(`emitter bug: dynCheck of non-JSON type ${t.kind}`);
         }
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The emitted static→dyn converter for one type:
@@ -1148,15 +1088,15 @@ export function dynCheckHelper(E, t) {
    * plus undefined-armed unions (the undefined arm becomes the undefined
    * dyn singleton) and index-signature records (whose overflow entries
    * copy over). The operand is borrowed. Never throws. */
-export function toDynHelper(E, t) {
+export function toDynHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.toDynFns.get(key);
+    const existing = emitter.toDynFns.get(key);
     if (existing)
         return existing;
-    const name = `sc_td_${E.toDynFns.size}`;
-    E.toDynFns.set(key, name);
+    const name = `sc_td_${emitter.toDynFns.size}`;
+    emitter.toDynFns.set(key, name);
     const sig = `static ScrDyn *${name}(${cDecl(t, "v")})`;
-    E.walkerProtos.push(`${sig}; /* to-dyn ${key} */`);
+    emitter.walkerProtos.push(`${sig}; /* to-dyn ${key} */`);
     const d = [`${sig} { /* to-dyn ${key} */`];
     let sourceAccessor = null;
     switch (t.kind) {
@@ -1180,7 +1120,7 @@ export function toDynHelper(E, t) {
         case "object":
             // %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}`);
+                throw new InternalCompilerError(`emitter bug: to-dyn of class ${t.className}`);
             }
             d.push(`  return scr_dyn_from_error(v);`);
             break;
@@ -1194,23 +1134,23 @@ export function toDynHelper(E, t) {
             // Function-valued record/array fields (EventListenerObject's
             // handleEvent method) box through the same identity-preserving
             // closure bridge as a bare dynFrom function.
-            d.push(`  return ${dynFuncBoxHelper(E, t)}(v, NULL);`);
+            d.push(`  return ${dynFuncBoxHelper(emitter, t)}(v, NULL);`);
             break;
         case "bytes":
             // 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}>`);
+                throw new InternalCompilerError(`emitter bug: to-dyn of bytes<${t.elem}>`);
             d.push(`  return scr_dyn_new_bytes_copy(v);`);
             break;
         case "record": {
-            const shape = E.recordsById.get(t.shapeId);
+            const shape = emitter.recordsById.get(t.shapeId);
             if (!shape)
-                throw new Error(`emitter bug: to-dyn of unknown shape ${t.shapeId}`);
+                throw new InternalCompilerError(`emitter bug: to-dyn of unknown shape ${t.shapeId}`);
             // CYCLE-CAPABLE shapes guard the deep copy: a cyclic value has no
             // finite dyn copy, so enter TRAPS on re-entry (SEMANTICS.md — Node
             // shares the reference instead of copying).
-            const cyclicRec = E.traceAdapterC(t) !== null;
+            const cyclicRec = emitter.traceAdapterC(t) !== null;
             if (cyclicRec)
                 d.push(`  scr_dyn_from_enter(v);`);
             if (shape.tuple) {
@@ -1218,7 +1158,7 @@ export function toDynHelper(E, t) {
                 const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
                 d.push(`  ScrDyn *d = scr_dyn_new_arr();`);
                 for (const f of byIndex) {
-                    d.push(`  scr_dyn_arr_push(d, ${E.toDynHelper(f.type)}(v->${mangleField(f.name)}));`);
+                    d.push(`  scr_dyn_arr_push(d, ${emitter.toDynHelper(f.type)}(v->${mangleField(f.name)}));`);
                 }
                 if (cyclicRec)
                     d.push(`  scr_dyn_from_leave();`);
@@ -1232,7 +1172,7 @@ export function toDynHelper(E, t) {
                     name: `${name}_source_access`,
                     release: rc.release,
                 };
-                E.walkerProtos.push(`static ScrDyn *${sourceAccessor.name}(void *v, bool materialize); /* live listener source ${key} */`);
+                emitter.walkerProtos.push(`static ScrDyn *${sourceAccessor.name}(void *v, bool materialize); /* live listener source ${key} */`);
                 d.push(`  ScrDyn *d = scr_dyn_new_obj_with_identity(v, &${rc.retain}, &${sourceAccessor.name});`);
             }
             else {
@@ -1255,7 +1195,7 @@ export function toDynHelper(E, t) {
                 for (const f of dynFields) {
                     const keyLit = cStringLiteral(Buffer.from(f.name, "utf8"));
                     const keyLen = Buffer.byteLength(f.name, "utf8");
-                    d.push(`  scr_dyn_obj_set(d, ${keyLit}, ${keyLen}, ${E.toDynHelper(f.type)}(v->${mangleField(f.name)}));`);
+                    d.push(`  scr_dyn_obj_set(d, ${keyLit}, ${keyLen}, ${emitter.toDynHelper(f.type)}(v->${mangleField(f.name)}));`);
                 }
             }
             if (shape.indexValue) {
@@ -1278,7 +1218,7 @@ export function toDynHelper(E, t) {
                 }
                 else {
                     d.push(`      ${cDecl(iv, "e")} = (${cType(iv).trim()})scr_map_get_str_ref(${m}, k);`);
-                    d.push(`      scr_dyn_obj_set(d, k->data, k->len, ${E.toDynHelper(iv)}(e));`);
+                    d.push(`      scr_dyn_obj_set(d, k->data, k->len, ${emitter.toDynHelper(iv)}(e));`);
                     d.push(`      ${releaseCallC(iv, "e")};`);
                 }
                 d.push(`      scr_str_release(k);`);
@@ -1294,7 +1234,7 @@ export function toDynHelper(E, t) {
         case "array": {
             const elem = t.elem;
             // Cycle-capable arrays guard the deep copy like records above.
-            const cyclicArr = E.traceAdapterC(t) !== null;
+            const cyclicArr = emitter.traceAdapterC(t) !== null;
             if (cyclicArr)
                 d.push(`  scr_dyn_from_enter(v);`);
             d.push(`  ScrDyn *d = scr_dyn_new_arr();`);
@@ -1307,7 +1247,7 @@ export function toDynHelper(E, t) {
             }
             else {
                 d.push(`    ${cDecl(elem, "e")} = (${cType(elem).trim()})scr_arr_get_ref(v, (double)i);`);
-                d.push(`    scr_dyn_arr_push(d, ${E.toDynHelper(elem)}(e));`);
+                d.push(`    scr_dyn_arr_push(d, ${emitter.toDynHelper(elem)}(e));`);
                 d.push(`    ${releaseCallC(elem, "e")};`);
             }
             d.push(`  }`);
@@ -1317,9 +1257,9 @@ export function toDynHelper(E, t) {
             break;
         }
         case "union": {
-            const def = E.unionsById.get(t.unionId);
+            const def = emitter.unionsById.get(t.unionId);
             if (!def)
-                throw new Error(`emitter bug: to-dyn of unknown union ${t.unionId}`);
+                throw new InternalCompilerError(`emitter bug: to-dyn of unknown union ${t.unionId}`);
             d.push(`  switch (v->tag) {`);
             def.arms.forEach((arm, i) => {
                 if (arm.kind === "undefinedT") {
@@ -1337,10 +1277,10 @@ export function toDynHelper(E, t) {
                 else if (arm.kind === "func") {
                     // A boxable function arm crosses through the checked-dynamic
                     // function boundary (the dynFrom func special case, sans name).
-                    d.push(`  case ${i}: return ${dynFuncBoxHelper(E, arm)}((ScrClosure *)scr_union_peek(v), NULL);`);
+                    d.push(`  case ${i}: return ${dynFuncBoxHelper(emitter, arm)}((ScrClosure *)scr_union_peek(v), NULL);`);
                 }
                 else {
-                    d.push(`  case ${i}: return ${E.toDynHelper(arm)}((${cType(arm).trim()})scr_union_peek(v));`);
+                    d.push(`  case ${i}: return ${emitter.toDynHelper(arm)}((${cType(arm).trim()})scr_union_peek(v));`);
                 }
             });
             d.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`);
@@ -1357,7 +1297,7 @@ export function toDynHelper(E, t) {
                 d.push(`  return scr_dyn_new_promise(v);`);
                 break;
             }
-            d.push(`  return scr_dyn_new_promise_adapting(v, &${promiseDynAdapterHelper(E, t.inner)});`);
+            d.push(`  return scr_dyn_new_promise_adapting(v, &${promiseDynAdapterHelper(emitter, t.inner)});`);
             break;
         }
         default: {
@@ -1369,13 +1309,13 @@ export function toDynHelper(E, t) {
                 d.push(`  return scr_dyn_new_handle(v, ${h.tag});`);
                 break;
             }
-            throw new Error(`emitter bug: to-dyn of unsupported type ${t.kind}`);
+            throw new InternalCompilerError(`emitter bug: to-dyn of unsupported type ${t.kind}`);
         }
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     if (sourceAccessor) {
-        E.walkerDefs.push(`static ScrDyn *${sourceAccessor.name}(void *v, bool materialize) {`, `  if (materialize) return ${name}((${cType(t).trim()})v);`, `  ${sourceAccessor.release}(v);`, `  return NULL;`, `}`, ``);
+        emitter.walkerDefs.push(`static ScrDyn *${sourceAccessor.name}(void *v, bool materialize) {`, `  if (materialize) return ${name}((${cType(t).trim()})v);`, `  ${sourceAccessor.release}(v);`, `  return NULL;`, `}`, ``);
     }
     return name;
 }
@@ -1385,15 +1325,15 @@ export function toDynHelper(E, t) {
    * 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. */
-export function promiseDynAdapterHelper(E, inner) {
+function promiseDynAdapterHelper(emitter, inner) {
     const key = typeKey(inner);
-    const existing = E.promiseDynAdapters.get(key);
+    const existing = emitter.promiseDynAdapters.get(key);
     if (existing)
         return existing;
-    const name = `sc_pda_${E.promiseDynAdapters.size}`;
-    E.promiseDynAdapters.set(key, name);
+    const name = `sc_pda_${emitter.promiseDynAdapters.size}`;
+    emitter.promiseDynAdapters.set(key, name);
     const sig = `static void ${name}(ScrPromise *dst, ScrPromise *src)`;
-    E.walkerProtos.push(`${sig}; /* dyn-box settle adapter for promise<${key}> */`);
+    emitter.walkerProtos.push(`${sig}; /* dyn-box settle adapter for promise<${key}> */`);
     const d = [`${sig} { /* dyn-box settle adapter for promise<${key}> */`];
     const fulfill = (expr) => `  scr_promise_fulfill_ref(dst, ${expr}, scr_dyn_retain_v, scr_dyn_release_v, NULL);`;
     switch (inner.kind) {
@@ -1423,7 +1363,7 @@ export function promiseDynAdapterHelper(E, inner) {
             // nested promises, handles): extract (+1 via the stored retain),
             // convert through the shared to-dyn spelling, release the extract.
             d.push(`  ${cDecl(inner, "pv")} = (${cType(inner).trim()})scr_promise_payload_ref(src);`);
-            d.push(`  ScrDyn *dv = ${toDynExprC(E, inner, "pv")};`);
+            d.push(`  ScrDyn *dv = ${toDynExprC(emitter, inner, "pv")};`);
             if (isRefCounted(inner))
                 d.push(`  ${releaseCallC(inner, "pv")};`);
             d.push(fulfill(`dv`));
@@ -1431,10 +1371,10 @@ export function promiseDynAdapterHelper(E, inner) {
         }
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
-/* ── the checked-dynamic function boundary (nodes.ts) ─────────────────
+/* ── the checked-dynamic function boundary (ir.ts) ─────────────────
    * Three interned per-signature helpers:
    *
    *   sc_dfk_<n> — the CALL THUNK a dyn-boxed closure carries: validate
@@ -1459,27 +1399,27 @@ export function promiseDynAdapterHelper(E, inner) {
    * result uniformly), funcs box (anonymous — the static name is gone by
    * the time a value flows through an adapter; SEMANTICS.md), everything
    * else rides the toDyn converter. `expr` is BORROWED in every arm. */
-function toDynExprC(E, t, expr) {
+function toDynExprC(emitter, t, expr) {
     if (t.kind === "dyn")
         return `scr_dyn_retain(${expr})`;
     if (t.kind === "func")
-        return `${E.dynFuncBoxHelper(t)}(${expr}, NULL)`;
+        return `${emitter.dynFuncBoxHelper(t)}(${expr}, NULL)`;
     // An island value wraps by reference (scalar-normalizing) — the
     // jsval-returning callback shape of the routed-dispatch lane.
     if (t.kind === "jsval")
         return `scr_dyn_from_jsval(${expr})`;
-    return `${E.toDynHelper(t)}(${expr})`;
+    return `${emitter.toDynHelper(t)}(${expr})`;
 }
 /** The call thunk for one closure signature (see the block comment). */
-export function dynFuncThunkHelper(E, t) {
+function dynFuncThunkHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.dynFuncThunks.get(key);
+    const existing = emitter.dynFuncThunks.get(key);
     if (existing)
         return existing;
-    const name = `sc_dfk_${E.dynFuncThunks.size}`;
-    E.dynFuncThunks.set(key, name);
+    const name = `sc_dfk_${emitter.dynFuncThunks.size}`;
+    emitter.dynFuncThunks.set(key, name);
     const sig = `static ScrDyn *${name}(ScrClosure *c, ScrDyn *const *args, size_t argc)`;
-    E.walkerProtos.push(`${sig}; /* dyn call thunk for ${key} */`);
+    emitter.walkerProtos.push(`${sig}; /* dyn call thunk for ${key} */`);
     const d = [`${sig} { /* dyn call thunk for ${key} */`];
     if (t.params.length === 0)
         d.push(`  (void)args;`);
@@ -1507,7 +1447,7 @@ export function dynFuncThunkHelper(E, t) {
         }
         else {
             d.push(`    ScrDynPath pp = { NULL, NULL, ${i} };`);
-            d.push(`    a${i} = ${E.dynCheckHelper(p)}(ad, &pp);`);
+            d.push(`    a${i} = ${emitter.dynCheckHelper(p)}(ad, &pp);`);
             const undo = t.params
                 .slice(0, i)
                 .flatMap((q, j) => (isRefCounted(q) ? [`${releaseCallC(q, `a${j}`)};`] : []));
@@ -1542,44 +1482,44 @@ export function dynFuncThunkHelper(E, t) {
     else {
         d.push(`  ${cDecl(t.ret, "r")} = ${call};`);
         d.push(`  if (scr_exc_pending()) return NULL;`);
-        d.push(`  ScrDyn *out = ${toDynExprC(E, t.ret, "r")};`);
+        d.push(`  ScrDyn *out = ${toDynExprC(emitter, t.ret, "r")};`);
         if (isRefCounted(t.ret))
             d.push(`  ${releaseCallC(t.ret, "r")};`);
         d.push(`  return out;`);
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The box builder dynFrom emits for one closure signature. */
-export function dynFuncBoxHelper(E, t) {
+export function dynFuncBoxHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.dynFuncBoxes.get(key);
+    const existing = emitter.dynFuncBoxes.get(key);
     if (existing)
         return existing;
-    const name = `sc_dfb_${E.dynFuncBoxes.size}`;
-    E.dynFuncBoxes.set(key, name);
+    const name = `sc_dfb_${emitter.dynFuncBoxes.size}`;
+    emitter.dynFuncBoxes.set(key, name);
     const sig = `static ScrDyn *${name}(ScrClosure *v, const char *fname)`;
-    E.walkerProtos.push(`${sig}; /* box ${key} into dyn */`);
-    const thunk = dynFuncThunkHelper(E, t);
+    emitter.walkerProtos.push(`${sig}; /* box ${key} into dyn */`);
+    const thunk = dynFuncThunkHelper(emitter, t);
     const sigLit = cStringLiteral(Buffer.from(key, "utf8"));
-    E.walkerDefs.push(`${sig} { /* box ${key} into dyn */`, `  return scr_dyn_new_func(scr_closure_retain(v), &${thunk}, ${t.params.length}, ${sigLit}, fname);`, `}`, ``);
+    emitter.walkerDefs.push(`${sig} { /* box ${key} into dyn */`, `  return scr_dyn_new_func(scr_closure_retain(v), &${thunk}, ${t.params.length}, ${sigLit}, fname);`, `}`, ``);
     return name;
 }
 /** The adapter closure body for one TARGET signature: the emitted C
    * function a func-targeted dynCheck wraps a non-identical boxed
    * signature in. caps[0] is an untraced obj-box owning the dyn function
    * value. */
-export function dynFuncAdapterHelper(E, t) {
+function dynFuncAdapterHelper(emitter, t) {
     const key = typeKey(t);
-    const existing = E.dynFuncAdapters.get(key);
+    const existing = emitter.dynFuncAdapters.get(key);
     if (existing)
         return existing;
-    const name = `sc_dfa_${E.dynFuncAdapters.size}`;
-    E.dynFuncAdapters.set(key, name);
+    const name = `sc_dfa_${emitter.dynFuncAdapters.size}`;
+    emitter.dynFuncAdapters.set(key, name);
     const params = ["ScrClosure *sc_env", ...t.params.map((p, i) => cDecl(p, `a${i}`))].join(", ");
     const sig = `static ${cType(t.ret)}${cType(t.ret).endsWith("*") ? "" : " "}${name}(${params})`;
-    E.walkerProtos.push(`${sig}; /* dyn fn adapter to ${key} */`);
+    emitter.walkerProtos.push(`${sig}; /* dyn fn adapter to ${key} */`);
     const dummy = t.ret.kind === "void" ? "" : t.ret.kind === "f64" ? "0" : t.ret.kind === "bool" ? "false" : "NULL";
     const d = [`${sig} { /* dyn fn adapter to ${key} */`];
     d.push(`  ScrDyn *sc_fn = (ScrDyn *)scr_box_get_ref(sc_env->caps[0]); /* +1 */`);
@@ -1588,7 +1528,7 @@ export function dynFuncAdapterHelper(E, t) {
     if (t.params.length > 0) {
         d.push(`  ScrDyn *sc_args[${t.params.length}];`);
         t.params.forEach((p, i) => {
-            d.push(`  sc_args[${i}] = ${toDynExprC(E, p, `a${i}`)};`);
+            d.push(`  sc_args[${i}] = ${toDynExprC(emitter, p, `a${i}`)};`);
             if (isRefCounted(p))
                 d.push(`  ${releaseCallC(p, `a${i}`)};`);
         });
@@ -1610,12 +1550,12 @@ export function dynFuncAdapterHelper(E, t) {
         // Validate the dyn result into the target's return type — a lying
         // wrapper throws the catchable TypeError here (path "$"), exactly
         // the dynCheck stance; the dummy result rides the pending unwind.
-        d.push(`  ${cDecl(t.ret, "out")} = ${E.dynCheckHelper(t.ret)}(sc_r, NULL);`);
+        d.push(`  ${cDecl(t.ret, "out")} = ${emitter.dynCheckHelper(t.ret)}(sc_r, NULL);`);
         d.push(`  scr_dyn_release(sc_r);`);
         d.push(`  return out;`);
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The emitted dynamic-keyed READ helper for one (shape, result type):
@@ -1627,19 +1567,19 @@ export function dynFuncAdapterHelper(E, t) {
    * 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). */
-export function recordKeyGetHelper(E, shapeId, t, overflowOnly = false) {
+export function recordKeyGetHelper(emitter, shapeId, t, overflowOnly = false) {
     const key = `${shapeId}|${typeKey(t)}${overflowOnly ? "|ovf" : ""}`;
-    const existing = E.recordKeyGetFns.get(key);
+    const existing = emitter.recordKeyGetFns.get(key);
     if (existing)
         return existing;
-    const shape = E.recordsById.get(shapeId);
+    const shape = emitter.recordsById.get(shapeId);
     if (!shape)
-        throw new Error(`emitter bug: keyed read of unknown shape ${shapeId}`);
-    const name = `sc_rkg_${E.recordKeyGetFns.size}`;
-    E.recordKeyGetFns.set(key, name);
+        throw new InternalCompilerError(`emitter bug: keyed read of unknown shape ${shapeId}`);
+    const name = `sc_rkg_${emitter.recordKeyGetFns.size}`;
+    emitter.recordKeyGetFns.set(key, name);
     const struct = mangleRecordStruct(shapeId);
     const sig = `static ${cType(t)}${cType(t).endsWith("*") ? "" : " "}${name}(${struct} *r, ScrStr *k)`;
-    E.walkerProtos.push(`${sig}; /* r[k] on ${shapeId} as ${typeKey(t)} */`);
+    emitter.walkerProtos.push(`${sig}; /* r[k] on ${shapeId} as ${typeKey(t)} */`);
     const d = [`${sig} { /* r[k] on ${shapeId} as ${typeKey(t)} */`];
     // How a value of type `vt` (a field, or the overflow hit) surfaces as T.
     const surface = (vt, expr, owned) => {
@@ -1648,27 +1588,27 @@ export function recordKeyGetHelper(E, shapeId, t, overflowOnly = false) {
         }
         if (t.kind === "dyn") {
             // toDyn borrows — an owned operand would leak; callers pass borrowed.
-            return `${E.toDynHelper(vt)}(${expr})`;
+            return `${emitter.toDynHelper(vt)}(${expr})`;
         }
         if (t.kind === "union") {
-            const def = E.unionsById.get(t.unionId);
+            const def = emitter.unionsById.get(t.unionId);
             const tag = def?.arms.findIndex((a) => typeEquals(a, vt)) ?? -1;
             if (tag < 0)
-                throw new Error(`emitter bug: keyed read arm for ${typeKey(vt)} in ${typeKey(t)}`);
+                throw new InternalCompilerError(`emitter bug: keyed read arm for ${typeKey(vt)} in ${typeKey(t)}`);
             if (vt.kind === "f64")
                 return `scr_union_new_f64(${tag}, ${expr})`;
             if (vt.kind === "bool")
                 return `scr_union_new_bool(${tag}, ${expr})`;
             const rc = vAdapters(vt);
             const payload = owned ? expr : retainCallC(vt, expr);
-            return `scr_union_new_ref(${tag}, ${payload}, &${rc.retain}, &${rc.release}, ${E.traceArgC(vt)})`;
+            return `scr_union_new_ref(${tag}, ${payload}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(vt)})`;
         }
-        throw new Error(`emitter bug: keyed read cannot surface ${typeKey(vt)} as ${typeKey(t)}`);
+        throw new InternalCompilerError(`emitter bug: keyed read cannot surface ${typeKey(vt)} as ${typeKey(t)}`);
     };
     // overflowOnly (a literal key naming no declared field): the declared
     // switch can never hit — only the overflow answers.
     for (const f of overflowOnly ? [] : shape.fields) {
-        const lit = E.internLiteral(f.name);
+        const lit = emitter.internLiteral(f.name);
         d.push(`  if (scr_str_eq(k, (ScrStr *)&${lit})) { /* ${f.name} */`);
         d.push(`    return ${surface(f.type, `r->${mangleField(f.name)}`, false)};`);
         d.push(`  }`);
@@ -1693,7 +1633,7 @@ export function recordKeyGetHelper(E, shapeId, t, overflowOnly = false) {
                 d.push(`    return ${surface(iv, "hit", true)};`);
             }
             else {
-                throw new Error(`emitter bug: keyed read overflow ${typeKey(iv)} as ${typeKey(t)}`);
+                throw new InternalCompilerError(`emitter bug: keyed read overflow ${typeKey(iv)} as ${typeKey(t)}`);
             }
             d.push(`  }`);
         }
@@ -1702,17 +1642,17 @@ export function recordKeyGetHelper(E, shapeId, t, overflowOnly = false) {
     if (t.kind === "dyn") {
         d.push(`  return scr_dyn_retain(scr_dyn_undefined());`);
     }
-    else if (t.kind === "union" && E.undefinedArmTag(t) >= 0) {
-        d.push(`  return ${E.unitInstanceRef(t.unionId, E.undefinedArmTag(t))};`);
+    else if (t.kind === "union" && undefinedArmTag(t, emitter.unionsById) >= 0) {
+        d.push(`  return ${emitter.unitInstanceRef(t.unionId, undefinedArmTag(t, emitter.unionsById))};`);
     }
     else {
         // JS would answer undefined; T has no way to say it (the checker
         // claimed T without noUncheckedIndexedAccess) — trap like an array
         // OOB read instead of corrupting a typed slot (SEMANTICS.md).
-        d.push(`  scr_trap_fmt("scriptc: TypeError: record has no key '%.*s' (typed '${E.dynDesc(t)}' — no undefined is representable)\\n", (int)k->len, k->data);`);
+        d.push(`  scr_trap_fmt("scriptc: TypeError: record has no key '%.*s' (typed '${dynDesc(t, emitter.recordsById, emitter.unionsById)}' — no undefined is representable)\\n", (int)k->len, k->data);`);
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
 /** The emitted dynamic-keyed WRITE helper for one index-signature shape:
@@ -1723,32 +1663,32 @@ export function recordKeyGetHelper(E, shapeId, t, overflowOnly = false) {
    * anything, the documented divergence; typed values store directly),
    * an undeclared key inserts/replaces in the overflow map. Borrows r and
    * k; OWNS v (+1 moves in — released on the validation-failure path). */
-export function recordKeySetHelper(E, shapeId) {
-    const existing = E.recordKeySetFns.get(shapeId);
+export function recordKeySetHelper(emitter, shapeId) {
+    const existing = emitter.recordKeySetFns.get(shapeId);
     if (existing)
         return existing;
-    const shape = E.recordsById.get(shapeId);
+    const shape = emitter.recordsById.get(shapeId);
     // Signature-free shapes dispatch over their (one-typed) declared
     // fields and TRAP on a miss (scr_record_key_miss — JS would add the
     // property, which a monomorphic struct cannot); overflow shapes keep
     // the map insert tail.
     const iv = shape?.indexValue ?? shape?.fields[0]?.type;
     if (!shape || !iv)
-        throw new Error(`emitter bug: keyed write on field-free non-overflow shape ${shapeId}`);
-    const name = `sc_rks_${E.recordKeySetFns.size}`;
-    E.recordKeySetFns.set(shapeId, name);
+        throw new InternalCompilerError(`emitter bug: keyed write on field-free non-overflow shape ${shapeId}`);
+    const name = `sc_rks_${emitter.recordKeySetFns.size}`;
+    emitter.recordKeySetFns.set(shapeId, name);
     const struct = mangleRecordStruct(shapeId);
     const sig = `static void ${name}(${struct} *r, ScrStr *k, ${cDecl(iv, "v")})`;
-    E.walkerProtos.push(`${sig}; /* r[k] = v on ${shapeId} */`);
+    emitter.walkerProtos.push(`${sig}; /* r[k] = v on ${shapeId} */`);
     const d = [`${sig} { /* r[k] = v on ${shapeId} */`];
     for (const f of shape.fields) {
-        const lit = E.internLiteral(f.name);
+        const lit = emitter.internLiteral(f.name);
         const member = `r->${mangleField(f.name)}`;
         d.push(`  if (scr_str_eq(k, (ScrStr *)&${lit})) { /* ${f.name} */`);
         if (iv.kind === "dyn" && shape.indexValue) {
             const keyLit = cStringLiteral(Buffer.from(f.name, "utf8"));
             d.push(`    ScrDynPath p = { NULL, ${keyLit}, 0 };`);
-            d.push(`    ${cDecl(f.type, "nv")} = ${E.dynCheckHelper(f.type)}(v, &p);`);
+            d.push(`    ${cDecl(f.type, "nv")} = ${emitter.dynCheckHelper(f.type)}(v, &p);`);
             d.push(`    scr_dyn_release(v);`);
             d.push(`    if (scr_exc_pending()) return; /* mismatched write: TypeError, field untouched */`);
             d.push(`    ${isRefCounted(f.type) ? `if (${member}) ${releaseCallC(f.type, member)};` : `(void)0;`}`);
@@ -1782,7 +1722,7 @@ export function recordKeySetHelper(E, shapeId) {
         }
     }
     d.push(`}`, ``);
-    E.walkerDefs.push(...d);
+    emitter.walkerDefs.push(...d);
     return name;
 }
-//# sourceMappingURL=emit-walkers.js.map
+//# sourceMappingURL=walkers.js.map