@scriptc/compiler 0.0.34 → 0.0.36

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

@@ -1,43 +1,62 @@
+import { InternalCompilerError } from "../../errors.js";
 import { mangleArgPack, mangleAsyncSpawn, mangleChildDataThunk, mangleChildExitThunk, mangleCloseBindThunk, mangleCloseOverrideWrap, mangleConnectResThunk, mangleConnectSockThunk, mangleDgramMsgThunk, mangleDnsLookupThunk, mangleField, mangleFsRenameThunk, mangleFunction, mangleGenDrop, mangleGenResThunk, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRaceThunk, mangleRawParam, mangleNetLookupAnswerThunk, mangleEmitterInvokeThunk, mangleStreamCbThunk, mangleStreamDoneFn, mangleRecordNew, mangleRecordRelease, mangleRecordStruct, mangleResolveThunk, mangleSniAnswerThunk, mangleTrampoline } from "../mangle.js";
-import { cDecl, cType, releaseCallC, retainCallC, vAdapters } from "./emit-types.js";
-import { isRefCounted, isUnitType, typeEquals, typeKey } from "../../ir/nodes.js";
+import { cDecl, cType, releaseCallC, retainCallC, vAdapters } from "./types.js";
+import { isRefCounted, isUnitType, typeEquals, typeKey } from "../../ir/ir.js";
+/** The argument-pack ABI and trampoline prefix shared by async functions
+ * and generators. Their promise/generator completion and spawn tails stay
+ * with the callers below. */
+function emitArgPackAndTrampolinePrologue(fn) {
+    const pack = mangleArgPack(fn.name);
+    const lifted = fn.captures !== undefined;
+    const fields = [];
+    if (lifted)
+        fields.push("ScrClosure *sc_env;");
+    const boxedIds = new Set(fn.locals.filter((l) => l.boxed).map((l) => l.id));
+    const pname = (p) => boxedIds.has(p.localId) ? mangleRawParam(p.localId) : mangleLocal(p.localId);
+    for (const p of fn.params)
+        fields.push(`${cDecl(p.type, pname(p))};`);
+    const definitions = [``, `typedef struct { ${fields.join(" ") || "char sc_unused;"} } ${pack};`];
+    const callArgs = [
+        ...(lifted ? ["sc_a.sc_env"] : []),
+        ...fn.params.map((p) => `sc_a.${pname(p)}`),
+    ].join(", ");
+    const ret = fn.returnType;
+    const bodyCall = `${mangleFunction(fn.name)}(${callArgs})`;
+    const lines = [
+        `static void ${mangleTrampoline(fn.name)}(ScrFiber *sc_self, void *sc_ap0) {`,
+        `  ${pack} sc_a = *(${pack} *)sc_ap0;`,
+        `  free(sc_ap0);`,
+    ];
+    if (ret.kind === "void") {
+        lines.push(`  ${bodyCall};`);
+    }
+    else {
+        lines.push(`  ${cDecl(ret, "sc_r")} = ${bodyCall};`);
+    }
+    if (lifted)
+        lines.push(`  scr_closure_release(sc_a.sc_env);`);
+    const spawnParams = [
+        ...(lifted ? ["ScrClosure *sc_env"] : []),
+        ...fn.params.map((p) => cDecl(p.type, pname(p))),
+    ];
+    const argPackLines = [
+        `  ${pack} *sc_ap = malloc(sizeof *sc_ap);`,
+        `  if (!sc_ap) { scr_trap("scriptc: out of memory\\n"); }`,
+        ...(lifted ? [`  sc_ap->sc_env = scr_closure_retain(sc_env);`] : []),
+        ...fn.params.map((p) => `  sc_ap->${pname(p)} = ${pname(p)};`),
+    ];
+    return { definitions, pack, lifted, pname, ret, lines, spawnParams, argPackLines };
+}
 /** Per-async-function machinery: an argument pack, a fiber trampoline
    * (unpacks, runs the ordinary compiled body, settles the promise), and a
    * spawn wrapper call sites use. Lifted async lambdas additionally thread
    * their closure env through the pack (+1, released after the body). */
-export function emitAsyncScaffolding(E, out) {
-    for (const fn of E.mod.functions) {
+export function emitAsyncScaffolding(emitter, out) {
+    for (const fn of emitter.mod.functions) {
         if (!fn.async)
             continue;
-        const pack = mangleArgPack(fn.name);
-        const lifted = fn.captures !== undefined;
-        const fields = [];
-        if (lifted)
-            fields.push("ScrClosure *sc_env;");
-        const boxedIds = new Set(fn.locals.filter((l) => l.boxed).map((l) => l.id));
-        const pname = (p) => boxedIds.has(p.localId) ? mangleRawParam(p.localId) : mangleLocal(p.localId);
-        for (const p of fn.params)
-            fields.push(`${cDecl(p.type, pname(p))};`);
-        out.push(``, `typedef struct { ${fields.join(" ") || "char sc_unused;"} } ${pack};`);
-        const callArgs = [
-            ...(lifted ? ["sc_a.sc_env"] : []),
-            ...fn.params.map((p) => `sc_a.${pname(p)}`),
-        ].join(", ");
-        const ret = fn.returnType;
-        const bodyCall = `${mangleFunction(fn.name)}(${callArgs})`;
-        const lines = [
-            `static void ${mangleTrampoline(fn.name)}(ScrFiber *sc_self, void *sc_ap0) {`,
-            `  ${pack} sc_a = *(${pack} *)sc_ap0;`,
-            `  free(sc_ap0);`,
-        ];
-        if (ret.kind === "void") {
-            lines.push(`  ${bodyCall};`);
-        }
-        else {
-            lines.push(`  ${cDecl(ret, "sc_r")} = ${bodyCall};`);
-        }
-        if (lifted)
-            lines.push(`  scr_closure_release(sc_a.sc_env);`);
+        const { definitions, ret, lines, spawnParams, argPackLines } = emitArgPackAndTrampolinePrologue(fn);
+        out.push(...definitions);
         lines.push(`  if (!scr_exc_pending()) {`);
         switch (ret.kind) {
             case "void":
@@ -55,7 +74,7 @@ export function emitAsyncScaffolding(E, out) {
                 break;
             default: {
                 const v = vAdapters(ret);
-                lines.push(`    scr_promise_fulfill_ref(scr_fiber_promise(sc_self), sc_r, ${v.retain}, ${v.release}, ${E.traceArgC(ret)});`);
+                lines.push(`    scr_promise_fulfill_ref(scr_fiber_promise(sc_self), sc_r, ${v.retain}, ${v.release}, ${emitter.traceArgC(ret)});`);
             }
         }
         lines.push(`  }`);
@@ -65,15 +84,11 @@ export function emitAsyncScaffolding(E, out) {
         }
         lines.push(`}`);
         out.push(...lines);
-        const spawnParams = [
-            ...(lifted ? ["ScrClosure *sc_env"] : []),
-            ...fn.params.map((p) => cDecl(p.type, pname(p))),
-        ];
         const cache = fn.asyncCacheGlobal !== undefined ? mangleGlobal(fn.asyncCacheGlobal) : null;
         const cycleCache = fn.asyncCycleCacheGlobal !== undefined ? mangleGlobal(fn.asyncCycleCacheGlobal) : null;
         out.push(`static ScrPromise *${mangleAsyncSpawn(fn.name)}(${spawnParams.join(", ") || "void"}) {`, ...(cache !== null
             ? [`  if (${cache}) return scr_promise_retain(${cache});`]
-            : []), `  ${pack} *sc_ap = malloc(sizeof *sc_ap);`, `  if (!sc_ap) { scr_trap("scriptc: out of memory\\n"); }`, ...(lifted ? [`  sc_ap->sc_env = scr_closure_retain(sc_env);`] : []), ...fn.params.map((p) => `  sc_ap->${pname(p)} = ${pname(p)};`), `  ScrPromise *sc_p = scr_async_spawn(&${mangleTrampoline(fn.name)}, sc_ap);`, ...(cache !== null
+            : []), ...argPackLines, `  ScrPromise *sc_p = scr_async_spawn(&${mangleTrampoline(fn.name)}, sc_ap);`, ...(cache !== null
             ? [
                 // Module evaluation promises are loader-owned from the
                 // moment evaluation starts. Mark even a pending promise
@@ -104,7 +119,7 @@ export function emitAsyncScaffolding(E, out) {
             ]
             : []), `  return sc_p;`, `}`);
     }
-    emitGenScaffolding(E, out);
+    emitGenScaffolding(emitter, out);
 }
 /** Per-generator-function machinery — the async scaffolding's lazy
    * sibling: the same argument pack, a fiber trampoline whose epilogue
@@ -112,39 +127,12 @@ export function emitAsyncScaffolding(E, out) {
    * promoting the parked .return value), a spawn wrapper that only
    * ALLOCATES the suspended fiber (nothing runs until the first .next()),
    * and the never-started teardown that drops the packed (+1) arguments. */
-function emitGenScaffolding(E, out) {
-    for (const fn of E.mod.functions) {
+function emitGenScaffolding(emitter, out) {
+    for (const fn of emitter.mod.functions) {
         if (!fn.generator)
             continue;
-        const pack = mangleArgPack(fn.name);
-        const lifted = fn.captures !== undefined;
-        const fields = [];
-        if (lifted)
-            fields.push("ScrClosure *sc_env;");
-        const boxedIds = new Set(fn.locals.filter((l) => l.boxed).map((l) => l.id));
-        const pname = (p) => boxedIds.has(p.localId) ? mangleRawParam(p.localId) : mangleLocal(p.localId);
-        for (const p of fn.params)
-            fields.push(`${cDecl(p.type, pname(p))};`);
-        out.push(``, `typedef struct { ${fields.join(" ") || "char sc_unused;"} } ${pack};`);
-        const callArgs = [
-            ...(lifted ? ["sc_a.sc_env"] : []),
-            ...fn.params.map((p) => `sc_a.${pname(p)}`),
-        ].join(", ");
-        const ret = fn.returnType;
-        const bodyCall = `${mangleFunction(fn.name)}(${callArgs})`;
-        const lines = [
-            `static void ${mangleTrampoline(fn.name)}(ScrFiber *sc_self, void *sc_ap0) {`,
-            `  ${pack} sc_a = *(${pack} *)sc_ap0;`,
-            `  free(sc_ap0);`,
-        ];
-        if (ret.kind === "void") {
-            lines.push(`  ${bodyCall};`);
-        }
-        else {
-            lines.push(`  ${cDecl(ret, "sc_r")} = ${bodyCall};`);
-        }
-        if (lifted)
-            lines.push(`  scr_closure_release(sc_a.sc_env);`);
+        const { definitions, pack, lifted, pname, ret, lines, spawnParams, argPackLines } = emitArgPackAndTrampolinePrologue(fn);
+        out.push(...definitions);
         lines.push(`  ScrGen *sc_g = scr_gen_of_fiber(sc_self);`);
         // Normal completion stores the (typed) return value; void completes
         // with the NONE slot — JS's undefined done-value. A GENRET unwind
@@ -169,13 +157,9 @@ function emitGenScaffolding(E, out) {
             ? [`    ${releaseCallC(ret, "sc_r")}; /* unwound: the never-read dummy */`]
             : []), `  }`, `}`);
         out.push(...lines);
-        const spawnParams = [
-            ...(lifted ? ["ScrClosure *sc_env"] : []),
-            ...fn.params.map((p) => cDecl(p.type, pname(p))),
-        ];
         out.push(`static void ${mangleGenDrop(fn.name)}(void *sc_ap0) {`, `  ${pack} sc_a = *(${pack} *)sc_ap0;`, `  free(sc_ap0);`, ...(lifted ? [`  scr_closure_release(sc_a.sc_env);`] : []), ...fn.params
             .filter((p) => isRefCounted(p.type))
-            .map((p) => `  ${releaseCallC(p.type, `sc_a.${pname(p)}`)};`), ...(!lifted && !fn.params.some((p) => isRefCounted(p.type)) ? [`  (void)sc_a;`] : []), `}`, `static ScrGen *${mangleGenSpawn(fn.name)}(${spawnParams.join(", ") || "void"}) {`, `  ${pack} *sc_ap = malloc(sizeof *sc_ap);`, `  if (!sc_ap) { scr_trap("scriptc: out of memory\\n"); }`, ...(lifted ? [`  sc_ap->sc_env = scr_closure_retain(sc_env);`] : []), ...fn.params.map((p) => `  sc_ap->${pname(p)} = ${pname(p)};`), `  return scr_gen_new(&${mangleTrampoline(fn.name)}, sc_ap, &${mangleGenDrop(fn.name)});`, `}`);
+            .map((p) => `  ${releaseCallC(p.type, `sc_a.${pname(p)}`)};`), ...(!lifted && !fn.params.some((p) => isRefCounted(p.type)) ? [`  (void)sc_a;`] : []), `}`, `static ScrGen *${mangleGenSpawn(fn.name)}(${spawnParams.join(", ") || "void"}) {`, ...argPackLines, `  return scr_gen_new(&${mangleTrampoline(fn.name)}, sc_ap, &${mangleGenDrop(fn.name)});`, `}`);
     }
 }
 /** Interned per-union child exit adapter: the runtime invokes
@@ -185,22 +169,22 @@ function emitGenScaffolding(E, out) {
    * owns the union param per the universal convention (unit-arm
    * instances are immortal; their release is a no-op). The one-param
    * shape ignores the signal. */
-export function childExitThunkFor(E, param) {
+export function childExitThunkFor(emitter, param) {
     if (param.kind !== "union")
-        throw new Error("emitter bug: exit listener param not a union");
+        throw new InternalCompilerError("emitter bug: exit listener param not a union");
     const key = param.unionId;
-    let sym = E.childExitThunks.get(key);
+    let sym = emitter.childExitThunks.get(key);
     if (!sym) {
-        sym = mangleChildExitThunk(E.childExitThunks.size);
-        E.childExitThunks.set(key, sym);
-        const def = E.unionsById.get(param.unionId);
+        sym = mangleChildExitThunk(emitter.childExitThunks.size);
+        emitter.childExitThunks.set(key, sym);
+        const def = emitter.unionsById.get(param.unionId);
         const f64Tag = def ? def.arms.findIndex((a) => a.kind === "f64") : -1;
         const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
         if (f64Tag < 0 || nullTag < 0) {
-            throw new Error("emitter bug: exit listener union lacks its arms");
+            throw new InternalCompilerError("emitter bug: exit listener union lacks its arms");
         }
-        E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig);`);
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig) {`, `  (void)sc_sig;`, `  ScrUnion *sc_u = sc_has ? scr_union_new_f64(${f64Tag}, sc_code)`, `                           : ${E.unitInstanceRef(param.unionId, nullTag)};`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u);`, `}`);
+        emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig);`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig) {`, `  (void)sc_sig;`, `  ScrUnion *sc_u = sc_has ? scr_union_new_f64(${f64Tag}, sc_code)`, `                           : ${emitter.unitInstanceRef(param.unionId, nullTag)};`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u);`, `}`);
     }
     return sym;
 }
@@ -208,26 +192,26 @@ export function childExitThunkFor(E, param) {
    * the code union as above plus the signal as its own `string | null`
    * union (a fresh string from the runtime's static signal name when a
    * signal killed the child, the null arm otherwise). */
-export function childExitThunkFor2(E, codeParam, sigParam) {
+export function childExitSignalThunkFor(emitter, codeParam, sigParam) {
     if (codeParam.kind !== "union" || sigParam.kind !== "union") {
-        throw new Error("emitter bug: exit listener params not unions");
+        throw new InternalCompilerError("emitter bug: exit listener params not unions");
     }
     const key = `${codeParam.unionId}+${sigParam.unionId}`;
-    let sym = E.childExitThunks.get(key);
+    let sym = emitter.childExitThunks.get(key);
     if (!sym) {
-        sym = mangleChildExitThunk(E.childExitThunks.size);
-        E.childExitThunks.set(key, sym);
-        const codeDef = E.unionsById.get(codeParam.unionId);
+        sym = mangleChildExitThunk(emitter.childExitThunks.size);
+        emitter.childExitThunks.set(key, sym);
+        const codeDef = emitter.unionsById.get(codeParam.unionId);
         const f64Tag = codeDef ? codeDef.arms.findIndex((a) => a.kind === "f64") : -1;
         const codeNullTag = codeDef ? codeDef.arms.findIndex((a) => a.kind === "nullT") : -1;
-        const sigDef = E.unionsById.get(sigParam.unionId);
+        const sigDef = emitter.unionsById.get(sigParam.unionId);
         const strTag = sigDef ? sigDef.arms.findIndex((a) => a.kind === "string") : -1;
         const sigNullTag = sigDef ? sigDef.arms.findIndex((a) => a.kind === "nullT") : -1;
         if (f64Tag < 0 || codeNullTag < 0 || strTag < 0 || sigNullTag < 0) {
-            throw new Error("emitter bug: exit listener unions lack their arms");
+            throw new InternalCompilerError("emitter bug: exit listener unions lack their arms");
         }
-        E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig);`);
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig) {`, `  ScrUnion *sc_u = sc_has ? scr_union_new_f64(${f64Tag}, sc_code)`, `                           : ${E.unitInstanceRef(codeParam.unionId, codeNullTag)};`, `  ScrUnion *sc_s = sc_sig`, `      ? scr_union_new_ref(${strTag}, scr_str_new(sc_sig, strlen(sc_sig)), &scr_str_retain_v, &scr_str_release_v, NULL)`, `      : ${E.unitInstanceRef(sigParam.unionId, sigNullTag)};`, `  ((void (*)(ScrClosure *, ScrUnion *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u, sc_s);`, `}`);
+        emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig);`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, bool sc_has, double sc_code, const char *sc_sig) {`, `  ScrUnion *sc_u = sc_has ? scr_union_new_f64(${f64Tag}, sc_code)`, `                           : ${emitter.unitInstanceRef(codeParam.unionId, codeNullTag)};`, `  ScrUnion *sc_s = sc_sig`, `      ? scr_union_new_ref(${strTag}, scr_str_new(sc_sig, strlen(sc_sig)), &scr_str_retain_v, &scr_str_release_v, NULL)`, `      : ${emitter.unitInstanceRef(sigParam.unionId, sigNullTag)};`, `  ((void (*)(ScrClosure *, ScrUnion *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u, sc_s);`, `}`);
     }
     return sym;
 }
@@ -237,21 +221,21 @@ export function childExitThunkFor2(E, codeParam, sigParam) {
    * the arm exists — the ngrok `Buffer | string` listener; strings never
    * fire from a pipe) and calls the listener, which owns the union param
    * per the universal convention. */
-export function childDataThunkFor(E, param) {
+export function childDataThunkFor(emitter, param) {
     if (param.kind !== "union")
-        throw new Error("emitter bug: stream data listener param not a union");
+        throw new InternalCompilerError("emitter bug: stream data listener param not a union");
     const key = param.unionId;
-    let sym = E.childDataThunks.get(key);
+    let sym = emitter.childDataThunks.get(key);
     if (!sym) {
-        sym = mangleChildDataThunk(E.childDataThunks.size);
-        E.childDataThunks.set(key, sym);
-        const def = E.unionsById.get(param.unionId);
+        sym = mangleChildDataThunk(emitter.childDataThunks.size);
+        emitter.childDataThunks.set(key, sym);
+        const def = emitter.unionsById.get(param.unionId);
         const bytesTag = def ? def.arms.findIndex((a) => a.kind === "bytes" && a.elem === "u8") : -1;
         if (bytesTag < 0) {
-            throw new Error("emitter bug: stream data listener union lacks its Buffer arm");
+            throw new InternalCompilerError("emitter bug: stream data listener union lacks its Buffer arm");
         }
-        E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_chunk);`);
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_chunk) {`, `  ScrUnion *sc_u = scr_union_new_ref(${bytesTag}, scr_bytes_retain(sc_chunk), &scr_bytes_retain_v, &scr_bytes_release_v, NULL);`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u);`, `}`);
+        emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_chunk);`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_chunk) {`, `  ScrUnion *sc_u = scr_union_new_ref(${bytesTag}, scr_bytes_retain(sc_chunk), &scr_bytes_retain_v, &scr_bytes_release_v, NULL);`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u);`, `}`);
     }
     return sym;
 }
@@ -263,38 +247,38 @@ export function childDataThunkFor(E, param) {
    * `(err?: Error) => void`) behind an emitted zero-arg trampoline that
    * fires it with the undefined arm (a clean close carries no error) —
    * and answers the +1 server (Node's chaining return). */
-export function closeBindThunkFor(E, cbUnion, retServer) {
+export function closeBindThunkFor(emitter, cbUnion, retServer) {
     if (cbUnion.kind !== "union")
-        throw new Error("emitter bug: bound-close callback param not a union");
+        throw new InternalCompilerError("emitter bug: bound-close callback param not a union");
     const key = `${cbUnion.unionId}:${retServer ? "srv" : "void"}`;
-    let sym = E.closeBindThunks.get(key);
+    let sym = emitter.closeBindThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleCloseBindThunk(E.closeBindThunks.size);
-    E.closeBindThunks.set(key, sym);
-    const def = E.unionsById.get(cbUnion.unionId);
+    sym = mangleCloseBindThunk(emitter.closeBindThunks.size);
+    emitter.closeBindThunks.set(key, sym);
+    const def = emitter.unionsById.get(cbUnion.unionId);
     const funcTag = def ? def.arms.findIndex((a) => a.kind === "func") : -1;
     const funcArm = funcTag >= 0 ? def.arms[funcTag] : null;
     if (!funcArm)
-        throw new Error("emitter bug: bound-close callback union lacks its func arm");
+        throw new InternalCompilerError("emitter bug: bound-close callback union lacks its func arm");
     const oneParam = funcArm.params.length === 1;
     let trampoline = null;
     if (oneParam) {
         const errParam = funcArm.params[0];
         if (errParam.kind !== "union") {
-            throw new Error("emitter bug: bound-close callback's err param is not a union");
+            throw new InternalCompilerError("emitter bug: bound-close callback's err param is not a union");
         }
-        const errDef = E.unionsById.get(errParam.unionId);
+        const errDef = emitter.unionsById.get(errParam.unionId);
         const undefTag = errDef ? errDef.arms.findIndex((a) => a.kind === "undefinedT") : -1;
         if (undefTag < 0)
-            throw new Error("emitter bug: bound-close err union lacks its undefined arm");
+            throw new InternalCompilerError("emitter bug: bound-close err union lacks its undefined arm");
         trampoline = `${sym}_cb`;
-        E.walkerProtos.push(`static void ${trampoline}(ScrClosure *sc_self);`);
-        E.walkerDefs.push(`static void ${trampoline}(ScrClosure *sc_self) { /* close cb: fire with no error */`, `  ScrClosure *sc_inner = (ScrClosure *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_inner->fn)(sc_inner, ${E.unitInstanceRef(errParam.unionId, undefTag)});`, `  scr_closure_release(sc_inner);`, `}`);
+        emitter.walkerProtos.push(`static void ${trampoline}(ScrClosure *sc_self);`);
+        emitter.walkerDefs.push(`static void ${trampoline}(ScrClosure *sc_self) { /* close cb: fire with no error */`, `  ScrClosure *sc_inner = (ScrClosure *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_inner->fn)(sc_inner, ${emitter.unitInstanceRef(errParam.unionId, undefTag)});`, `  scr_closure_release(sc_inner);`, `}`);
     }
     const retC = retServer ? "ScrNetServer *" : "void";
-    E.walkerProtos.push(`static ${retC}${retServer ? "" : " "}${sym}(ScrClosure *sc_self, ScrUnion *sc_cb);`);
-    E.walkerDefs.push(`static ${retC}${retServer ? "" : " "}${sym}(ScrClosure *sc_self, ScrUnion *sc_cb) { /* bound server.close */`, `  ScrNetServer *sc_srv = (ScrNetServer *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`, `  ScrClosure *sc_reg = NULL;`, `  if (sc_cb->tag == ${funcTag}) {`, ...(oneParam
+    emitter.walkerProtos.push(`static ${retC}${retServer ? "" : " "}${sym}(ScrClosure *sc_self, ScrUnion *sc_cb);`);
+    emitter.walkerDefs.push(`static ${retC}${retServer ? "" : " "}${sym}(ScrClosure *sc_self, ScrUnion *sc_cb) { /* bound server.close */`, `  ScrNetServer *sc_srv = (ScrNetServer *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`, `  ScrClosure *sc_reg = NULL;`, `  if (sc_cb->tag == ${funcTag}) {`, ...(oneParam
         ? [
             `    sc_reg = scr_closure_new((void *)&${trampoline}, 1);`,
             `    sc_reg->caps[0] = scr_box_new(SCR_BOX_FUNC);`,
@@ -310,27 +294,27 @@ export function closeBindThunkFor(E, cbUnion, retServer) {
    * types, so this wrapper carries the user function and fires it with
    * the undefined-arm callback argument (tags are program data),
    * releasing the chaining-return server when the signature answers one. */
-export function closeOverrideWrapFor(E, cbUnion, retServer) {
+export function closeOverrideWrapFor(emitter, cbUnion, retServer) {
     if (cbUnion.kind !== "union")
-        throw new Error("emitter bug: close-override callback param not a union");
+        throw new InternalCompilerError("emitter bug: close-override callback param not a union");
     const key = `${cbUnion.unionId}:${retServer ? "srv" : "void"}`;
-    let sym = E.closeOverrideWraps.get(key);
+    let sym = emitter.closeOverrideWraps.get(key);
     if (sym)
         return sym;
-    sym = mangleCloseOverrideWrap(E.closeOverrideWraps.size);
-    E.closeOverrideWraps.set(key, sym);
-    const def = E.unionsById.get(cbUnion.unionId);
+    sym = mangleCloseOverrideWrap(emitter.closeOverrideWraps.size);
+    emitter.closeOverrideWraps.set(key, sym);
+    const def = emitter.unionsById.get(cbUnion.unionId);
     const undefTag = def ? def.arms.findIndex((a) => a.kind === "undefinedT") : -1;
     if (undefTag < 0)
-        throw new Error("emitter bug: close-override callback union lacks its undefined arm");
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_self);`);
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_self) { /* close override wrapper */`, `  ScrClosure *sc_inner = (ScrClosure *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`, ...(retServer
+        throw new InternalCompilerError("emitter bug: close-override callback union lacks its undefined arm");
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_self);`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_self) { /* close override wrapper */`, `  ScrClosure *sc_inner = (ScrClosure *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`, ...(retServer
         ? [
-            `  ScrNetServer *sc_r = ((ScrNetServer *(*)(ScrClosure *, ScrUnion *))sc_inner->fn)(sc_inner, ${E.unitInstanceRef(cbUnion.unionId, undefTag)});`,
+            `  ScrNetServer *sc_r = ((ScrNetServer *(*)(ScrClosure *, ScrUnion *))sc_inner->fn)(sc_inner, ${emitter.unitInstanceRef(cbUnion.unionId, undefTag)});`,
             `  scr_net_server_release(sc_r); /* the chaining return is unobserved here */`,
         ]
         : [
-            `  ((void (*)(ScrClosure *, ScrUnion *))sc_inner->fn)(sc_inner, ${E.unitInstanceRef(cbUnion.unionId, undefTag)});`,
+            `  ((void (*)(ScrClosure *, ScrUnion *))sc_inner->fn)(sc_inner, ${emitter.unitInstanceRef(cbUnion.unionId, undefTag)});`,
         ]), `  scr_closure_release(sc_inner);`, `}`);
     return sym;
 }
@@ -341,17 +325,17 @@ export function closeOverrideWrapFor(E, cbUnion, retServer) {
    * which owns both params per the universal convention (msg retains like
    * the net data thunk). Zero/one-param listeners take the runtime's own
    * scr_dgram_msg_thunk0/1. */
-export function dgramMsgThunkFor(E, param) {
+export function dgramMsgThunkFor(emitter, param) {
     if (param.kind !== "record")
-        throw new Error("emitter bug: message listener rinfo not a record");
+        throw new InternalCompilerError("emitter bug: message listener rinfo not a record");
     const key = param.shapeId;
-    let sym = E.dgramMsgThunks.get(key);
+    let sym = emitter.dgramMsgThunks.get(key);
     if (!sym) {
-        sym = mangleDgramMsgThunk(E.dgramMsgThunks.size);
-        E.dgramMsgThunks.set(key, sym);
+        sym = mangleDgramMsgThunk(emitter.dgramMsgThunks.size);
+        emitter.dgramMsgThunks.set(key, sym);
         const struct = mangleRecordStruct(param.shapeId);
-        E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_msg, ScrStr *sc_addr, ScrStr *sc_family, double sc_port, double sc_size);`);
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_msg, ScrStr *sc_addr, ScrStr *sc_family, double sc_port, double sc_size) {`, `  ${struct} *sc_ri = ${mangleRecordNew(param.shapeId)}();`, `  sc_ri->${mangleField("address")} = scr_str_retain(sc_addr);`, `  sc_ri->${mangleField("family")} = scr_str_retain(sc_family);`, `  sc_ri->${mangleField("port")} = sc_port;`, `  sc_ri->${mangleField("size")} = sc_size;`, `  ((void (*)(ScrClosure *, ScrBytes *, ${struct} *))sc_cb->fn)(sc_cb, scr_bytes_retain(sc_msg), sc_ri);`, `}`);
+        emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_msg, ScrStr *sc_addr, ScrStr *sc_family, double sc_port, double sc_size);`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrBytes *sc_msg, ScrStr *sc_addr, ScrStr *sc_family, double sc_port, double sc_size) {`, `  ${struct} *sc_ri = ${mangleRecordNew(param.shapeId)}();`, `  sc_ri->${mangleField("address")} = scr_str_retain(sc_addr);`, `  sc_ri->${mangleField("family")} = scr_str_retain(sc_family);`, `  sc_ri->${mangleField("port")} = sc_port;`, `  sc_ri->${mangleField("size")} = sc_size;`, `  ((void (*)(ScrClosure *, ScrBytes *, ${struct} *))sc_cb->fn)(sc_cb, scr_bytes_retain(sc_msg), sc_ri);`, `}`);
     }
     return sym;
 }
@@ -361,61 +345,61 @@ export function dgramMsgThunkFor(E, param) {
    * argument (tags are program data — the frontend pinned the union) and
    * calls the listener with as many arguments as it declared, each owned
    * per the universal convention. */
-export function dnsLookupThunkFor(E, cbT) {
+export function dnsLookupThunkFor(emitter, cbT) {
     if (cbT.kind !== "func")
-        throw new Error("emitter bug: dns.lookup callback not a func");
+        throw new InternalCompilerError("emitter bug: dns.lookup callback not a func");
     const nparams = cbT.params.length;
     if (nparams === 0)
         return "scr_dns_thunk0";
     const errT = cbT.params[0];
     if (errT.kind !== "union")
-        throw new Error("emitter bug: dns.lookup err param not a union");
+        throw new InternalCompilerError("emitter bug: dns.lookup err param not a union");
     const key = `${errT.unionId}/${nparams}`;
-    let sym = E.dnsLookupThunks.get(key);
+    let sym = emitter.dnsLookupThunks.get(key);
     if (!sym) {
-        sym = mangleDnsLookupThunk(E.dnsLookupThunks.size);
-        E.dnsLookupThunks.set(key, sym);
-        const def = E.unionsById.get(errT.unionId);
+        sym = mangleDnsLookupThunk(emitter.dnsLookupThunks.size);
+        emitter.dnsLookupThunks.set(key, sym);
+        const def = emitter.unionsById.get(errT.unionId);
         const errTag = def ? def.arms.findIndex((a) => a.kind === "object") : -1;
         const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
         if (errTag < 0 || nullTag < 0) {
-            throw new Error("emitter bug: dns.lookup err union lacks its arms");
+            throw new InternalCompilerError("emitter bug: dns.lookup err union lacks its arms");
         }
         const callSig = ["ScrClosure *", "ScrUnion *", ...(nparams >= 2 ? ["ScrStr *"] : []), ...(nparams >= 3 ? ["double"] : [])].join(", ");
         const callArgs = ["sc_cb", "sc_u", ...(nparams >= 2 ? ["scr_str_retain(sc_addr)"] : []), ...(nparams >= 3 ? ["sc_family"] : [])].join(", ");
-        E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrStr *sc_err, ScrStr *sc_addr, double sc_family);`);
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrStr *sc_err, ScrStr *sc_addr, double sc_family) {`, `  (void)sc_addr; (void)sc_family;`, `  ScrUnion *sc_u = sc_err`, `      ? scr_union_new_ref(${errTag}, scr_error_new(0, sc_err), &scr_error_retain_v, &scr_error_release_v, NULL)`, `      : ${E.unitInstanceRef(errT.unionId, nullTag)};`, `  ((void (*)(${callSig}))sc_cb->fn)(${callArgs});`, `}`);
+        emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrStr *sc_err, ScrStr *sc_addr, double sc_family);`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrStr *sc_err, ScrStr *sc_addr, double sc_family) {`, `  (void)sc_addr; (void)sc_family;`, `  ScrUnion *sc_u = sc_err`, `      ? scr_union_new_ref(${errTag}, scr_error_new(0, sc_err), &scr_error_retain_v, &scr_error_release_v, NULL)`, `      : ${emitter.unitInstanceRef(errT.unionId, nullTag)};`, `  ((void (*)(${callSig}))sc_cb->fn)(${callArgs});`, `}`);
     }
     return sym;
 }
 /** Interned fs.rename callback adapter. The runtime supplies a borrowed
  * ScrError (or NULL); the adapter builds the callback's program-specific
  * Error | null union, or a dyn error/null for checkJs callbacks. */
-export function fsRenameThunkFor(E, cbT) {
+export function fsRenameThunkFor(emitter, cbT) {
     if (cbT.kind !== "func")
-        throw new Error("emitter bug: fs.rename callback not a func");
+        throw new InternalCompilerError("emitter bug: fs.rename callback not a func");
     if (cbT.params.length === 0)
         return "scr_fs_rename_thunk0";
     const param = cbT.params[0];
     const key = typeKey(cbT);
-    let sym = E.fsRenameThunks.get(key);
+    let sym = emitter.fsRenameThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleFsRenameThunk(E.fsRenameThunks.size);
-    E.fsRenameThunks.set(key, sym);
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrError *sc_err);`);
+    sym = mangleFsRenameThunk(emitter.fsRenameThunks.size);
+    emitter.fsRenameThunks.set(key, sym);
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrError *sc_err);`);
     if (param.kind === "dyn") {
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrError *sc_err) {`, `  ScrDyn *sc_arg = sc_err ? scr_dyn_from_error(sc_err) : scr_dyn_new_null();`, `  ((void (*)(ScrClosure *, ScrDyn *))sc_cb->fn)(sc_cb, sc_arg);`, `}`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrError *sc_err) {`, `  ScrDyn *sc_arg = sc_err ? scr_dyn_from_error(sc_err) : scr_dyn_new_null();`, `  ((void (*)(ScrClosure *, ScrDyn *))sc_cb->fn)(sc_cb, sc_arg);`, `}`);
         return sym;
     }
     if (param.kind !== "union")
-        throw new Error("emitter bug: fs.rename error param not a union");
-    const def = E.unionsById.get(param.unionId);
+        throw new InternalCompilerError("emitter bug: fs.rename error param not a union");
+    const def = emitter.unionsById.get(param.unionId);
     const errTag = def ? def.arms.findIndex((a) => a.kind === "object" && a.className === "%Error") : -1;
     const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
     if (errTag < 0 || nullTag < 0)
-        throw new Error("emitter bug: fs.rename error union lacks its arms");
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrError *sc_err) {`, `  ScrUnion *sc_u = sc_err`, `      ? scr_union_new_ref(${errTag}, scr_error_retain(sc_err), &scr_error_retain_v, &scr_error_release_v, NULL)`, `      : ${E.unitInstanceRef(param.unionId, nullTag)};`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u);`, `}`);
+        throw new InternalCompilerError("emitter bug: fs.rename error union lacks its arms");
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrError *sc_err) {`, `  ScrUnion *sc_u = sc_err`, `      ? scr_union_new_ref(${errTag}, scr_error_retain(sc_err), &scr_error_retain_v, &scr_error_release_v, NULL)`, `      : ${emitter.unitInstanceRef(param.unionId, nullTag)};`, `  ((void (*)(ScrClosure *, ScrUnion *))sc_cb->fn)(sc_cb, sc_u);`, `}`);
     return sym;
 }
 /** Interned CONNECT-listener adapter for a UNION socket slot — the h2
@@ -424,48 +408,48 @@ export function fsRenameThunkFor(E, cbT) {
    * the adapter wraps the socket at the union's netSocket arm (its tag is
    * program data) and drops `head` when the listener declares two params.
    * All three runtime args arrive +1; the union takes the socket's. */
-export function connectSockThunkFor(E, cbT) {
+export function connectSockThunkFor(emitter, cbT) {
     if (cbT.kind !== "func" || cbT.params[1]?.kind !== "union") {
-        throw new Error("emitter bug: connect listener union shape (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: connect listener union shape (frontend must fence)");
     }
     const key = typeKey(cbT);
-    let sym = E.connectSockThunks.get(key);
+    let sym = emitter.connectSockThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleConnectSockThunk(E.connectSockThunks.size);
-    E.connectSockThunks.set(key, sym);
+    sym = mangleConnectSockThunk(emitter.connectSockThunks.size);
+    emitter.connectSockThunks.set(key, sym);
     const sockT = cbT.params[1];
-    const def = E.unionsById.get(sockT.unionId);
+    const def = emitter.unionsById.get(sockT.unionId);
     const tag = def ? def.arms.findIndex((a) => a.kind === "netSocket") : -1;
     if (tag < 0)
-        throw new Error("emitter bug: connect listener union lacks its socket arm");
+        throw new InternalCompilerError("emitter bug: connect listener union lacks its socket arm");
     const three = cbT.params.length === 3;
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrNetSocket *sc_sock, ScrBytes *sc_head);`);
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrNetSocket *sc_sock, ScrBytes *sc_head) {`, ...(three ? [] : [`  scr_bytes_release(sc_head);`]), `  ScrUnion *sc_u = scr_union_new_ref(${tag}, sc_sock, &scr_net_sock_retain_v, &scr_net_sock_release_v, NULL);`, three
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrNetSocket *sc_sock, ScrBytes *sc_head);`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrNetSocket *sc_sock, ScrBytes *sc_head) {`, ...(three ? [] : [`  scr_bytes_release(sc_head);`]), `  ScrUnion *sc_u = scr_union_new_ref(${tag}, sc_sock, &scr_net_sock_retain_v, &scr_net_sock_release_v, NULL);`, three
         ? `  ((void (*)(ScrClosure *, ScrHttpReq *, ScrUnion *, ScrBytes *))sc_cb->fn)(sc_cb, sc_req, sc_u, sc_head);`
         : `  ((void (*)(ScrClosure *, ScrHttpReq *, ScrUnion *))sc_cb->fn)(sc_cb, sc_req, sc_u);`, `}`);
     return sym;
 }
-export function connectResThunkFor(E, cbT) {
+export function connectResThunkFor(emitter, cbT) {
     if (cbT.kind !== "func")
-        throw new Error("emitter bug: connect listener shape");
+        throw new InternalCompilerError("emitter bug: connect listener shape");
     const key = `res:${typeKey(cbT)}`;
-    let sym = E.connectSockThunks.get(key);
+    let sym = emitter.connectSockThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleConnectResThunk(E.connectSockThunks.size);
-    E.connectSockThunks.set(key, sym);
+    sym = mangleConnectResThunk(emitter.connectSockThunks.size);
+    emitter.connectSockThunks.set(key, sym);
     const p1 = cbT.params[1];
-    const def = p1?.kind === "union" ? E.unionsById.get(p1.unionId) : undefined;
+    const def = p1?.kind === "union" ? emitter.unionsById.get(p1.unionId) : undefined;
     const tag = def ? def.arms.findIndex((a) => a.kind === "httpRes") : -1;
     if (p1?.kind === "union" && tag < 0)
-        throw new Error("emitter bug: connect listener union lacks its response arm");
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrHttpRes *sc_res);`);
+        throw new InternalCompilerError("emitter bug: connect listener union lacks its response arm");
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrHttpRes *sc_res);`);
     const second = p1?.kind === "union"
         ? `ScrUnion *sc_u = scr_union_new_ref(${tag}, sc_res, &scr_http_res_retain_v, &scr_http_res_release_v, NULL);`
         : "";
     const arg = p1?.kind === "union" ? "sc_u" : "sc_res";
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrHttpRes *sc_res) {`, ...(second ? [`  ${second}`] : []), ...(cbT.params.length === 0
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ScrHttpReq *sc_req, ScrHttpRes *sc_res) {`, ...(second ? [`  ${second}`] : []), ...(cbT.params.length === 0
         ? ["  scr_http_req_release(sc_req);", "  scr_http_res_release(sc_res);", "  ((void (*)(ScrClosure *))sc_cb->fn)(sc_cb);"]
         : cbT.params.length === 1
             ? ["  scr_http_res_release(sc_res);", "  ((void (*)(ScrClosure *, ScrHttpReq *))sc_cb->fn)(sc_cb, sc_req);"]
@@ -480,32 +464,32 @@ export function connectResThunkFor(E, cbT) {
    * tag) and the addresses record's field layout down to the runtime's
    * (has_err, message, ip-list) answer. Params arrive +1 and release
    * here; the extracted message/ips hand over +1. */
-export function netLookupAnswerThunkFor(E, cbT) {
+export function netLookupAnswerThunkFor(emitter, cbT) {
     if (cbT.kind !== "func" || cbT.params.length !== 2) {
-        throw new Error("emitter bug: lookup answer cb shape (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: lookup answer cb shape (frontend must fence)");
     }
     const key = typeKey(cbT);
-    let sym = E.netLookupAnswerThunks.get(key);
+    let sym = emitter.netLookupAnswerThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleNetLookupAnswerThunk(E.netLookupAnswerThunks.size);
-    E.netLookupAnswerThunks.set(key, sym);
+    sym = mangleNetLookupAnswerThunk(emitter.netLookupAnswerThunks.size);
+    emitter.netLookupAnswerThunks.set(key, sym);
     const errT = cbT.params[0];
     if (errT.kind !== "union")
-        throw new Error("emitter bug: lookup answer err param not a union");
-    const errDef = E.unionsById.get(errT.unionId);
+        throw new InternalCompilerError("emitter bug: lookup answer err param not a union");
+    const errDef = emitter.unionsById.get(errT.unionId);
     const nullTag = errDef ? errDef.arms.findIndex((a) => a.kind === "nullT") : -1;
     if (nullTag < 0)
-        throw new Error("emitter bug: lookup answer err union lacks its null arm");
+        throw new InternalCompilerError("emitter bug: lookup answer err union lacks its null arm");
     const addrsT = cbT.params[1];
     if (addrsT.kind !== "array" || addrsT.elem.kind !== "record") {
-        throw new Error("emitter bug: lookup answer addresses param not a record array");
+        throw new InternalCompilerError("emitter bug: lookup answer addresses param not a record array");
     }
     const recStruct = mangleRecordStruct(addrsT.elem.shapeId);
     const recRelease = mangleRecordRelease(addrsT.elem.shapeId);
     const addrField = mangleField("address");
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_self, ScrUnion *sc_err, ScrArr *sc_addrs);`);
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_self, ScrUnion *sc_err, ScrArr *sc_addrs) {`, `  bool sc_has_err = sc_err->tag != ${nullTag};`, `  ScrStr *sc_msg = NULL;`, `  if (sc_has_err) sc_msg = scr_str_retain(((ScrError *)scr_union_peek(sc_err))->message);`, `  ScrArr *sc_ips = NULL;`, `  if (!sc_has_err) {`, `    double sc_n = scr_arr_len(sc_addrs);`, `    sc_ips = scr_arr_new(SCR_ELEM_STR, (size_t)sc_n);`, `    for (double sc_i = 0; sc_i < sc_n; sc_i++) {`, `      ${recStruct} *sc_r = (${recStruct} *)scr_arr_get_ref(sc_addrs, sc_i);`, `      scr_arr_push_ref(sc_ips, scr_str_retain(sc_r->${addrField}));`, `      ${recRelease}(sc_r);`, `    }`, `  }`, `  scr_net_lookup_answer(sc_self, sc_has_err, sc_msg, sc_ips);`, `  scr_str_release(sc_msg);`, `  scr_arr_release(sc_ips);`, `  scr_union_release(sc_err);`, `  scr_arr_release(sc_addrs);`, `}`);
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_self, ScrUnion *sc_err, ScrArr *sc_addrs);`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_self, ScrUnion *sc_err, ScrArr *sc_addrs) {`, `  bool sc_has_err = sc_err->tag != ${nullTag};`, `  ScrStr *sc_msg = NULL;`, `  if (sc_has_err) sc_msg = scr_str_retain(((ScrError *)scr_union_peek(sc_err))->message);`, `  ScrArr *sc_ips = NULL;`, `  if (!sc_has_err) {`, `    double sc_n = scr_arr_len(sc_addrs);`, `    sc_ips = scr_arr_new(SCR_ELEM_STR, (size_t)sc_n);`, `    for (double sc_i = 0; sc_i < sc_n; sc_i++) {`, `      ${recStruct} *sc_r = (${recStruct} *)scr_arr_get_ref(sc_addrs, sc_i);`, `      scr_arr_push_ref(sc_ips, scr_str_retain(sc_r->${addrField}));`, `      ${recRelease}(sc_r);`, `    }`, `  }`, `  scr_net_lookup_answer(sc_self, sc_has_err, sc_msg, sc_ips);`, `  scr_str_release(sc_msg);`, `  scr_arr_release(sc_ips);`, `  scr_union_release(sc_err);`, `  scr_arr_release(sc_addrs);`, `}`);
     return sym;
 }
 /** Interned SNI answer-closure thunk: the fn of the runtime-minted `cb`
@@ -516,15 +500,15 @@ export function netLookupAnswerThunkFor(E, cbT) {
    * to the runtime's (has_err, ctx-or-NULL) answer. The thunk owns its
    * union params per the universal convention (the ctx payload retains
    * +1 before its union releases; ownership moves to the runtime). */
-export function sniAnswerThunkFor(E, cbT) {
+export function sniAnswerThunkFor(emitter, cbT) {
     if (cbT.kind !== "func")
-        throw new Error("emitter bug: SNI answer cb not a func");
+        throw new InternalCompilerError("emitter bug: SNI answer cb not a func");
     const key = typeKey(cbT);
-    let sym = E.sniAnswerThunks.get(key);
+    let sym = emitter.sniAnswerThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleSniAnswerThunk(E.sniAnswerThunks.size);
-    E.sniAnswerThunks.set(key, sym);
+    sym = mangleSniAnswerThunk(emitter.sniAnswerThunks.size);
+    emitter.sniAnswerThunks.set(key, sym);
     const nparams = cbT.params.length;
     const params = ["ScrClosure *sc_self"];
     const body = [];
@@ -532,11 +516,11 @@ export function sniAnswerThunkFor(E, cbT) {
     if (nparams >= 1) {
         const errT = cbT.params[0];
         if (errT.kind !== "union")
-            throw new Error("emitter bug: SNI answer err param not a union");
-        const def = E.unionsById.get(errT.unionId);
+            throw new InternalCompilerError("emitter bug: SNI answer err param not a union");
+        const def = emitter.unionsById.get(errT.unionId);
         const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
         if (nullTag < 0)
-            throw new Error("emitter bug: SNI answer err union lacks its null arm");
+            throw new InternalCompilerError("emitter bug: SNI answer err union lacks its null arm");
         params.push("ScrUnion *sc_err");
         hasErr = `sc_err->tag != ${nullTag}`;
     }
@@ -544,11 +528,11 @@ export function sniAnswerThunkFor(E, cbT) {
     if (nparams >= 2) {
         const ctxT = cbT.params[1];
         if (ctxT.kind !== "union")
-            throw new Error("emitter bug: SNI answer ctx param not a union");
-        const def = E.unionsById.get(ctxT.unionId);
+            throw new InternalCompilerError("emitter bug: SNI answer ctx param not a union");
+        const def = emitter.unionsById.get(ctxT.unionId);
         const ctxTag = def ? def.arms.findIndex((a) => a.kind === "secureCtx") : -1;
         if (ctxTag < 0)
-            throw new Error("emitter bug: SNI answer ctx union lacks its SecureContext arm");
+            throw new InternalCompilerError("emitter bug: SNI answer ctx union lacks its SecureContext arm");
         params.push("ScrUnion *sc_ctx");
         body.push(`  ScrSecureCtx *sc_c = sc_ctx->tag == ${ctxTag} ? scr_secure_ctx_retain((ScrSecureCtx *)scr_union_peek(sc_ctx)) : NULL;`, `  scr_union_release(sc_ctx);`);
         ctx = "sc_c";
@@ -557,8 +541,8 @@ export function sniAnswerThunkFor(E, cbT) {
     if (nparams >= 1)
         body.push(`  scr_union_release(sc_err);`);
     body.push(`  scr_tls_sni_answer(sc_self, sc_has_err, ${ctx});`);
-    E.walkerProtos.push(`static void ${sym}(${params.join(", ")});`);
-    E.walkerDefs.push(`static void ${sym}(${params.join(", ")}) {`, ...body, `}`);
+    emitter.walkerProtos.push(`static void ${sym}(${params.join(", ")});`);
+    emitter.walkerDefs.push(`static void ${sym}(${params.join(", ")}) {`, ...body, `}`);
     return sym;
 }
 /** Interned Promise.race fulfillment adapter: converts a settled entry's
@@ -569,29 +553,29 @@ export function sniAnswerThunkFor(E, cbT) {
    * entry re-tags arm-wise (canonical arm order makes the mapping a
    * typeKey lookup). Rejections never reach adapters — the runtime copies
    * them raw. */
-export function raceAdapterFor(E, from, to) {
+export function raceAdapterFor(emitter, from, to) {
     if (typeEquals(from, to))
         return "scr_promise_adapt_copy";
     const key = `${typeKey(from)}=>${typeKey(to)}`;
-    let sym = E.raceThunks.get(key);
+    let sym = emitter.raceThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleRaceThunk(E.raceThunks.size);
-    E.raceThunks.set(key, sym);
+    sym = mangleRaceThunk(emitter.raceThunks.size);
+    emitter.raceThunks.set(key, sym);
     if (to.kind !== "union")
-        throw new Error("emitter bug: race adapter to a non-union");
-    const toDef = E.unionsById.get(to.unionId);
+        throw new InternalCompilerError("emitter bug: race adapter to a non-union");
+    const toDef = emitter.unionsById.get(to.unionId);
     if (!toDef)
-        throw new Error("emitter bug: race adapter to an unknown union");
+        throw new InternalCompilerError("emitter bug: race adapter to an unknown union");
     const tagOf = (t) => {
         const tag = toDef.arms.findIndex((a) => typeEquals(a, t));
         if (tag < 0)
-            throw new Error("emitter bug: race adapter arm missing (frontend must fence)");
+            throw new InternalCompilerError("emitter bug: race adapter arm missing (frontend must fence)");
         return tag;
     };
     const rv = vAdapters(to);
-    const fulfill = (value) => `scr_promise_fulfill_ref(sc_dst, ${value}, ${rv.retain}, ${rv.release}, ${E.traceArgC(to)});`;
-    E.walkerProtos.push(`static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src);`);
+    const fulfill = (value) => `scr_promise_fulfill_ref(sc_dst, ${value}, ${rv.retain}, ${rv.release}, ${emitter.traceArgC(to)});`;
+    emitter.walkerProtos.push(`static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src);`);
     if (from.kind !== "union") {
         // One arm wrap, straight off the payload accessors.
         const tag = tagOf(from);
@@ -608,22 +592,22 @@ export function raceAdapterFor(E, from, to) {
                 break;
             default: {
                 const fv = vAdapters(from);
-                value = `scr_union_new_ref(${tag}, scr_promise_payload_ref(sc_src), ${fv.retain}, ${fv.release}, ${E.traceArgC(from)})`;
+                value = `scr_union_new_ref(${tag}, scr_promise_payload_ref(sc_src), ${fv.retain}, ${fv.release}, ${emitter.traceArgC(from)})`;
             }
         }
-        E.walkerDefs.push(`static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src) {`, `  ${fulfill(value)}`, `}`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src) {`, `  ${fulfill(value)}`, `}`);
         return sym;
     }
     // Sub-union re-tag: switch over the entry's arms, rebuild under the
     // result's tags (payloads retained through each arm's own adapters).
-    const fromDef = E.unionsById.get(from.unionId);
+    const fromDef = emitter.unionsById.get(from.unionId);
     if (!fromDef)
-        throw new Error("emitter bug: race adapter from an unknown union");
+        throw new InternalCompilerError("emitter bug: race adapter from an unknown union");
     const cases = fromDef.arms.map((arm, i) => {
         const tag = tagOf(arm);
         let build;
         if (isUnitType(arm)) {
-            build = E.unitInstanceRef(to.unionId, tag);
+            build = emitter.unitInstanceRef(to.unionId, tag);
         }
         else if (arm.kind === "f64") {
             build = `scr_union_new_f64(${tag}, scr_union_get_f64(sc_u))`;
@@ -633,11 +617,11 @@ export function raceAdapterFor(E, from, to) {
         }
         else {
             const av = vAdapters(arm);
-            build = `scr_union_new_ref(${tag}, ${av.retain}(scr_union_peek(sc_u)), ${av.retain}, ${av.release}, ${E.traceArgC(arm)})`;
+            build = `scr_union_new_ref(${tag}, ${av.retain}(scr_union_peek(sc_u)), ${av.retain}, ${av.release}, ${emitter.traceArgC(arm)})`;
         }
         return `  case ${i}: sc_v = ${build}; break;`;
     });
-    E.walkerDefs.push(`static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src) {`, `  ScrUnion *sc_u = (ScrUnion *)scr_promise_payload_ref(sc_src);`, `  ScrUnion *sc_v = NULL;`, `  switch (sc_u->tag) {`, ...cases, `  default: break;`, `  }`, `  scr_union_release(sc_u);`, `  ${fulfill("sc_v")}`, `}`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src) {`, `  ScrUnion *sc_u = (ScrUnion *)scr_promise_payload_ref(sc_src);`, `  ScrUnion *sc_v = NULL;`, `  switch (sc_u->tag) {`, ...cases, `  default: break;`, `  }`, `  scr_union_release(sc_u);`, `  ${fulfill("sc_v")}`, `}`);
     return sym;
 }
 /** Interned generator-resume result builder: reads the post-resume state
@@ -649,18 +633,18 @@ export function raceAdapterFor(E, from, to) {
    * a present completion value wraps the same way and an empty OUT is
    * JS's undefined (the interned undefined arm — or the dyn undefined
    * when V is dyn, the any/unknown channel). */
-export function genResultThunkFor(E, genT, recT) {
+export function genResultThunkFor(emitter, genT, recT) {
     const key = typeKey(genT);
-    let sym = E.genResThunks.get(key);
+    let sym = emitter.genResThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleGenResThunk(E.genResThunks.size);
-    E.genResThunks.set(key, sym);
+    sym = mangleGenResThunk(emitter.genResThunks.size);
+    emitter.genResThunks.set(key, sym);
     const struct = mangleRecordStruct(recT.shapeId);
-    const shape = E.mod.records?.find((r) => r.id === recT.shapeId);
+    const shape = emitter.mod.records?.find((r) => r.id === recT.shapeId);
     const valueT = shape?.fields.find((f) => f.name === "value")?.type;
     if (!valueT)
-        throw new Error("emitter bug: genResume record lacks its value field");
+        throw new InternalCompilerError("emitter bug: genResume record lacks its value field");
     const lines = [
         `static ${struct} *${sym}(ScrGen *sc_g) {`,
         `  ${struct} *sc_r = ${mangleRecordNew(recT.shapeId)}();`,
@@ -673,20 +657,20 @@ export function genResultThunkFor(E, genT, recT) {
     }
     else {
         if (valueT.kind !== "union") {
-            throw new Error("emitter bug: genResume value slot is neither dyn nor a union");
+            throw new InternalCompilerError("emitter bug: genResume value slot is neither dyn nor a union");
         }
-        const def = E.unionsById.get(valueT.unionId);
+        const def = emitter.unionsById.get(valueT.unionId);
         if (!def)
-            throw new Error("emitter bug: genResume value union unknown");
+            throw new InternalCompilerError("emitter bug: genResume value union unknown");
         const tagOf = (t) => {
             const tag = def.arms.findIndex((a) => typeEquals(a, t));
             if (tag < 0)
-                throw new Error("emitter bug: genResume value union lacks an arm");
+                throw new InternalCompilerError("emitter bug: genResume value union lacks an arm");
             return tag;
         };
         const undefTag = def.arms.findIndex((a) => a.kind === "undefinedT");
         if (undefTag < 0)
-            throw new Error("emitter bug: genResume value union lacks undefined");
+            throw new InternalCompilerError("emitter bug: genResume value union lacks undefined");
         // Lines that leave the wrapped value in `sc_v`, taking OUT's payload.
         const wrapFrom = (srcT) => {
             if (srcT.kind === "f64") {
@@ -698,7 +682,7 @@ export function genResultThunkFor(E, genT, recT) {
             if (srcT.kind !== "union") {
                 const v = vAdapters(srcT);
                 return [
-                    `    sc_v = scr_union_new_ref(${tagOf(srcT)}, scr_gen_take_out_ref(sc_g), ${v.retain}, ${v.release}, ${E.traceArgC(srcT)});`,
+                    `    sc_v = scr_union_new_ref(${tagOf(srcT)}, scr_gen_take_out_ref(sc_g), ${v.retain}, ${v.release}, ${emitter.traceArgC(srcT)});`,
                 ];
             }
             // A union channel: OUT holds the union box itself. Identical V
@@ -707,14 +691,14 @@ export function genResultThunkFor(E, genT, recT) {
             if (typeEquals(srcT, valueT)) {
                 return [`    sc_v = (ScrUnion *)scr_gen_take_out_ref(sc_g);`];
             }
-            const srcDef = E.unionsById.get(srcT.unionId);
+            const srcDef = emitter.unionsById.get(srcT.unionId);
             if (!srcDef)
-                throw new Error("emitter bug: genResume channel union unknown");
+                throw new InternalCompilerError("emitter bug: genResume channel union unknown");
             const cases = srcDef.arms.map((arm, i) => {
                 const tag = tagOf(arm);
                 let build;
                 if (isUnitType(arm)) {
-                    build = E.unitInstanceRef(valueT.unionId, tag);
+                    build = emitter.unitInstanceRef(valueT.unionId, tag);
                 }
                 else if (arm.kind === "f64") {
                     build = `scr_union_new_f64(${tag}, scr_union_get_f64(sc_u))`;
@@ -724,7 +708,7 @@ export function genResultThunkFor(E, genT, recT) {
                 }
                 else {
                     const av = vAdapters(arm);
-                    build = `scr_union_new_ref(${tag}, ${av.retain}(scr_union_peek(sc_u)), ${av.retain}, ${av.release}, ${E.traceArgC(arm)})`;
+                    build = `scr_union_new_ref(${tag}, ${av.retain}(scr_union_peek(sc_u)), ${av.retain}, ${av.release}, ${emitter.traceArgC(arm)})`;
                 }
                 return `    case ${i}: sc_v = ${build}; break;`;
             });
@@ -732,12 +716,12 @@ export function genResultThunkFor(E, genT, recT) {
                 `    { ScrUnion *sc_u = (ScrUnion *)scr_gen_take_out_ref(sc_g);`,
                 `    switch (sc_u->tag) {`,
                 ...cases,
-                `    default: sc_v = ${E.unitInstanceRef(valueT.unionId, undefTag)}; break;`,
+                `    default: sc_v = ${emitter.unitInstanceRef(valueT.unionId, undefTag)}; break;`,
                 `    }`,
                 `    scr_union_release(sc_u); }`,
             ];
         };
-        const undefLine = `    sc_v = ${E.unitInstanceRef(valueT.unionId, undefTag)};`;
+        const undefLine = `    sc_v = ${emitter.unitInstanceRef(valueT.unionId, undefTag)};`;
         lines.push(`  ScrUnion *sc_v;`);
         lines.push(`  if (!sc_d) {`);
         // yieldT VOID marks a generator that can never yield (TS's `never`):
@@ -750,20 +734,20 @@ export function genResultThunkFor(E, genT, recT) {
         lines.push(`  sc_r->${mangleField("value")} = sc_v;`);
     }
     lines.push(`  return sc_r;`, `}`);
-    E.walkerProtos.push(`static ${struct} *${sym}(ScrGen *sc_g);`);
-    E.walkerDefs.push(...lines, ``);
+    emitter.walkerProtos.push(`static ${struct} *${sym}(ScrGen *sc_g);`);
+    emitter.walkerDefs.push(...lines, ``);
     return sym;
 }
 /** Interned per inner-type resolve thunk for ref-kind new Promise. */
-export function resolveThunkFor(E, inner) {
+export function resolveThunkFor(emitter, inner) {
     const key = typeKey(inner);
-    let sym = E.resolveThunks.get(key);
+    let sym = emitter.resolveThunks.get(key);
     if (!sym) {
-        sym = mangleResolveThunk(E.resolveThunks.size);
-        E.resolveThunks.set(key, sym);
+        sym = mangleResolveThunk(emitter.resolveThunks.size);
+        emitter.resolveThunks.set(key, sym);
         const v = vAdapters(inner);
-        E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_self, ${cDecl(inner, "sc_v")});`);
-        E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_self, ${cDecl(inner, "sc_v")}) {`, `  scr_resolve_ref_impl(sc_self, sc_v, ${v.retain}, ${v.release}, ${E.traceArgC(inner)});`, `}`);
+        emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_self, ${cDecl(inner, "sc_v")});`);
+        emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_self, ${cDecl(inner, "sc_v")}) {`, `  scr_resolve_ref_impl(sc_self, sc_v, ${v.retain}, ${v.release}, ${emitter.traceArgC(inner)});`, `}`);
     }
     return sym;
 }
@@ -773,16 +757,16 @@ export function resolveThunkFor(E, inner) {
  * the tuple, so reads agree with writes), retains each refcounted value
  * (the callee owns +1 per the universal convention; f64/bool copy), and
  * calls cb->fn behind its exact C signature. Interned per func-type key. */
-export function emitterInvokeThunkFor(E, cbT) {
+export function emitterInvokeThunkFor(emitter, cbT) {
     if (cbT.kind !== "func") {
-        throw new Error("emitter bug: emitter.on listener not a func (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: emitter.on listener not a func (frontend must fence)");
     }
     const key = typeKey(cbT);
-    let sym = E.emitterInvokeThunks.get(key);
+    let sym = emitter.emitterInvokeThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleEmitterInvokeThunk(E.emitterInvokeThunks.size);
-    E.emitterInvokeThunks.set(key, sym);
+    sym = mangleEmitterInvokeThunk(emitter.emitterInvokeThunks.size);
+    emitter.emitterInvokeThunks.set(key, sym);
     const reads = [];
     const passed = [];
     cbT.params.forEach((p, i) => {
@@ -807,8 +791,8 @@ export function emitterInvokeThunkFor(E, cbT) {
     // listener return values.
     const retC = cbT.ret.kind === "void" ? "void" : cType(cbT.ret).trim();
     const invoke = `((${retC} (*)(${sigParams}))sc_cb->fn)(${["sc_cb", ...passed].join(", ")})`;
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap);`);
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap) {`, ...(cbT.params.length === 0 ? [`  (void)sc_ap;`] : reads), ...(cbT.ret.kind === "void"
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap);`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap) {`, ...(cbT.params.length === 0 ? [`  (void)sc_ap;`] : reads), ...(cbT.ret.kind === "void"
         ? [`  ${invoke};`]
         : isRefCounted(cbT.ret)
             ? [`  ${retC} sc_r = ${invoke};`, `  if (sc_r) ${releaseCallC(cbT.ret, "sc_r")};`]
@@ -823,16 +807,16 @@ export function emitterInvokeThunkFor(E, cbT) {
  * scr_stream_final_done, "d" scr_stream_destroy_done, "t"
  * scr_stream_transform_done, "l" scr_stream_flush_done. Args arrive
  * callee-owned (+1) per the universal convention and are released here. */
-export function streamDoneFnFor(E, kind, doneT) {
+function streamDoneFnFor(emitter, kind, doneT) {
     if (doneT.kind !== "func") {
-        throw new Error("emitter bug: stream done callback not a func (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: stream done callback not a func (frontend must fence)");
     }
     const key = `${kind}:${typeKey(doneT)}`;
-    let sym = E.streamDoneFns.get(key);
+    let sym = emitter.streamDoneFns.get(key);
     if (sym)
         return sym;
-    sym = mangleStreamDoneFn(E.streamDoneFns.size);
-    E.streamDoneFns.set(key, sym);
+    sym = mangleStreamDoneFn(emitter.streamDoneFns.size);
+    emitter.streamDoneFns.set(key, sym);
     const params = ["ScrClosure *sc_self"];
     const body = [
         `  ScrStream *sc_s = (ScrStream *)scr_box_get_ref(sc_self->caps[0]); /* +1 */`,
@@ -841,11 +825,11 @@ export function streamDoneFnFor(E, kind, doneT) {
     const errT = doneT.params[0];
     if (errT !== undefined) {
         if (errT.kind !== "union")
-            throw new Error("emitter bug: stream done err param not a union");
-        const def = E.unionsById.get(errT.unionId);
+            throw new InternalCompilerError("emitter bug: stream done err param not a union");
+        const def = emitter.unionsById.get(errT.unionId);
         const errTag = def ? def.arms.findIndex((a) => a.kind === "object") : -1;
         if (errTag < 0)
-            throw new Error("emitter bug: stream done err union lacks its Error arm");
+            throw new InternalCompilerError("emitter bug: stream done err union lacks its Error arm");
         params.push("ScrUnion *sc_e");
         body.push(`  if (sc_e && sc_e->tag == ${errTag}) sc_err = scr_error_retain((ScrError *)scr_union_peek(sc_e));`);
     }
@@ -855,8 +839,8 @@ export function streamDoneFnFor(E, kind, doneT) {
         body.push(...dataLines);
         if (dataT !== undefined) {
             if (dataT.kind !== "union")
-                throw new Error("emitter bug: stream done data param not a union");
-            const def = E.unionsById.get(dataT.unionId);
+                throw new InternalCompilerError("emitter bug: stream done data param not a union");
+            const def = emitter.unionsById.get(dataT.unionId);
             const bytesTag = def ? def.arms.findIndex((a) => a.kind === "bytes") : -1;
             const strTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1;
             params.push("ScrUnion *sc_d");
@@ -874,8 +858,8 @@ export function streamDoneFnFor(E, kind, doneT) {
     const tail = kind === "t" || kind === "l"
         ? `${entry}(sc_s, sc_err, sc_data, sc_dataStr);`
         : `${entry}(sc_s, sc_err);`;
-    E.walkerProtos.push(`static void ${sym}(${params.join(", ")});`);
-    E.walkerDefs.push(`static void ${sym}(${params.join(", ")}) {`, ...body, `  ${tail} /* moves sc_err/sc_data; borrows sc_s */`, `  scr_stream_release(sc_s);`, ...(errT !== undefined ? [`  if (sc_e) scr_union_release(sc_e);`] : []), ...((kind === "t" || kind === "l") && dataT !== undefined ? [`  if (sc_d) scr_union_release(sc_d);`] : []), `}`, ``);
+    emitter.walkerProtos.push(`static void ${sym}(${params.join(", ")});`);
+    emitter.walkerDefs.push(`static void ${sym}(${params.join(", ")}) {`, ...body, `  ${tail} /* moves sc_err/sc_data; borrows sc_s */`, `  scr_stream_release(sc_s);`, ...(errT !== undefined ? [`  if (sc_e) scr_union_release(sc_e);`] : []), ...((kind === "t" || kind === "l") && dataT !== undefined ? [`  if (sc_d) scr_union_release(sc_d);`] : []), `}`, ``);
     return sym;
 }
 /** The stream-'data' listener invoke adapter for one listener func type:
@@ -887,19 +871,19 @@ export function streamDoneFnFor(E, kind, doneT) {
  * just hand the value over — SEMANTICS.md). Zero-parameter listeners
  * ignore both slots; DYN-parameter listeners (the JS lane's adapter,
  * emitter.onDataDyn) box by tag, which is always right. */
-export function streamDataThunkFor(E, cbT) {
+export function streamDataThunkFor(emitter, cbT) {
     if (cbT.kind !== "func") {
-        throw new Error("emitter bug: stream data listener not a func (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: stream data listener not a func (frontend must fence)");
     }
     const key = `data:${typeKey(cbT)}`;
-    let sym = E.emitterInvokeThunks.get(key);
+    let sym = emitter.emitterInvokeThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleEmitterInvokeThunk(E.emitterInvokeThunks.size);
-    E.emitterInvokeThunks.set(key, sym);
+    sym = mangleEmitterInvokeThunk(emitter.emitterInvokeThunks.size);
+    emitter.emitterInvokeThunks.set(key, sym);
     const p = cbT.params[0];
     if (cbT.params.length > 1 || (p && p.kind !== "bytes" && p.kind !== "string" && p.kind !== "dyn")) {
-        throw new Error("emitter bug: stream data listener param shape (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: stream data listener param shape (frontend must fence)");
     }
     const body = [
         `  ScrBytes *sc_b = va_arg(sc_ap, ScrBytes *);`,
@@ -925,8 +909,8 @@ export function streamDataThunkFor(E, cbT) {
     const sigParams = ["ScrClosure *", ...cbT.params.map((q) => cType(q).trim())].join(", ");
     const retC = cbT.ret.kind === "void" ? "void" : cType(cbT.ret).trim();
     const invoke = `((${retC} (*)(${sigParams}))sc_cb->fn)(${passed.join(", ")})`;
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap);`);
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap) {`, ...body, ...(cbT.ret.kind === "void"
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap);`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, va_list sc_ap) {`, ...body, ...(cbT.ret.kind === "void"
         ? [`  ${invoke};`]
         : isRefCounted(cbT.ret)
             ? [`  ${retC} sc_r = ${invoke};`, `  if (sc_r) ${releaseCallC(cbT.ret, "sc_r")};`]
@@ -944,16 +928,16 @@ export function streamDataThunkFor(E, cbT) {
  * never complete, exactly Node. Kinds: "r" read(size), "w" write(chunk,
  * enc, cb), "f" final(cb), "d" destroy(err, cb), "t" transform(chunk,
  * enc, cb), "l" flush(cb). */
-export function streamCbThunkFor(E, kind, cbT) {
+export function streamCbThunkFor(emitter, kind, cbT) {
     if (cbT.kind !== "func") {
-        throw new Error("emitter bug: stream option callback not a func (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: stream option callback not a func (frontend must fence)");
     }
     const key = `${kind}:${typeKey(cbT)}`;
-    let sym = E.streamCbThunks.get(key);
+    let sym = emitter.streamCbThunks.get(key);
     if (sym)
         return sym;
-    sym = mangleStreamCbThunk(E.streamCbThunks.size);
-    E.streamCbThunks.set(key, sym);
+    sym = mangleStreamCbThunk(emitter.streamCbThunks.size);
+    emitter.streamCbThunks.set(key, sym);
     // The runtime-facing C signatures, per kind.
     const runtimeParams = kind === "r" ? ["ScrStream *sc_s", "double sc_size"] :
         kind === "w" || kind === "t" ? ["ScrStream *sc_s", "ScrBytes *sc_chunk"] :
@@ -967,7 +951,7 @@ export function streamCbThunkFor(E, kind, cbT) {
     const declared = cbT.params;
     const hasThis = declared[0] !== undefined && declared[0].kind === "object";
     if (declared.length === 0) {
-        throw new Error("emitter bug: stream option callback with no params (frontend must fence)");
+        throw new InternalCompilerError("emitter bug: stream option callback with no params (frontend must fence)");
     }
     const passed = hasThis
         ? ["sc_cb", `(${cType(declared[0]).trim()})scr_stream_retain(sc_s)`]
@@ -977,7 +961,7 @@ export function streamCbThunkFor(E, kind, cbT) {
     const full = (kind === "r" ? 1 : kind === "w" || kind === "t" ? 3 : kind === "d" ? 2 : 1) + off;
     // "e" (the finished/pipeline callback): ONE Node position — the error.
     if (declared.length > full) {
-        throw new Error(`emitter bug: stream '${kind}' callback declares ${declared.length} params (frontend must fence)`);
+        throw new InternalCompilerError(`emitter bug: stream '${kind}' callback declares ${declared.length} params (frontend must fence)`);
     }
     for (let i = off; i < declared.length; i++) {
         const p = declared[i];
@@ -1019,7 +1003,7 @@ export function streamCbThunkFor(E, kind, cbT) {
                 passed.push(`sc_done`);
             }
             else {
-                throw new Error(`emitter bug: stream '${kind}' dyn callback param ${i} has no adapter`);
+                throw new InternalCompilerError(`emitter bug: stream '${kind}' dyn callback param ${i} has no adapter`);
             }
             continue;
         }
@@ -1037,26 +1021,26 @@ export function streamCbThunkFor(E, kind, cbT) {
             // undefined` (the @types signature); success prefers the undefined
             // arm there (Node calls the eos callback with NO arguments).
             if (p.kind !== "union")
-                throw new Error("emitter bug: stream destroy err param not a union");
-            const def = E.unionsById.get(p.unionId);
+                throw new InternalCompilerError("emitter bug: stream destroy err param not a union");
+            const def = emitter.unionsById.get(p.unionId);
             const errTag = def ? def.arms.findIndex((a) => a.kind === "object") : -1;
             const undefTag = kind === "e" && def ? def.arms.findIndex((a) => a.kind === "undefinedT") : -1;
             const nullTag = def
                 ? (undefTag >= 0 ? undefTag : def.arms.findIndex((a) => a.kind === "nullT"))
                 : -1;
             if (errTag < 0 || nullTag < 0)
-                throw new Error("emitter bug: stream destroy err union lacks its arms");
-            body.push(`  ScrUnion *sc_eu = sc_err ? scr_union_new_ref(${errTag}, scr_error_retain(sc_err), &scr_error_retain_v, &scr_error_release_v, scr_error_trace_arg()) : scr_union_retain(${E.unitInstanceRef(p.unionId, nullTag)});`);
+                throw new InternalCompilerError("emitter bug: stream destroy err union lacks its arms");
+            body.push(`  ScrUnion *sc_eu = sc_err ? scr_union_new_ref(${errTag}, scr_error_retain(sc_err), &scr_error_retain_v, &scr_error_release_v, scr_error_trace_arg()) : scr_union_retain(${emitter.unitInstanceRef(p.unionId, nullTag)});`);
             passed.push(`sc_eu`);
         }
         else if (isDonePos) {
             const doneKind = kind; // "e" has no done position
-            const doneFn = streamDoneFnFor(E, doneKind, p);
+            const doneFn = streamDoneFnFor(emitter, doneKind, p);
             body.push(`  ScrClosure *sc_done = scr_closure_new((void *)&${doneFn}, 1);`, `  sc_done->caps[0] = scr_box_new_obj(&scr_stream_retain_v, &scr_stream_release_v, &scr_stream_trace);`, `  scr_box_set_ref(sc_done->caps[0], scr_stream_retain(sc_s));`);
             passed.push(`sc_done`);
         }
         else {
-            throw new Error(`emitter bug: stream '${kind}' callback param ${i} has no adapter`);
+            throw new InternalCompilerError(`emitter bug: stream '${kind}' callback param ${i} has no adapter`);
         }
     }
     const sigParams = ["ScrClosure *", ...declared.map((p) => cType(p).trim())].join(", ");
@@ -1076,12 +1060,12 @@ export function streamCbThunkFor(E, kind, cbT) {
     // callback results (`read: () => this.push(null)`).
     const retC = cbT.ret.kind === "void" ? "void" : cType(cbT.ret).trim();
     const invoke = `((${retC} (*)(${sigParams}))sc_cb->fn)(${passed.join(", ")})`;
-    E.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ${runtimeParams.join(", ")});`);
-    E.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ${runtimeParams.join(", ")}) {`, ...unused, ...body, ...(cbT.ret.kind === "void"
+    emitter.walkerProtos.push(`static void ${sym}(ScrClosure *sc_cb, ${runtimeParams.join(", ")});`);
+    emitter.walkerDefs.push(`static void ${sym}(ScrClosure *sc_cb, ${runtimeParams.join(", ")}) {`, ...unused, ...body, ...(cbT.ret.kind === "void"
         ? [`  ${invoke};`]
         : isRefCounted(cbT.ret)
             ? [`  ${retC} sc_r = ${invoke};`, `  if (sc_r) ${releaseCallC(cbT.ret, "sc_r")};`]
             : [`  (void)${invoke};`]), `}`, ``);
     return sym;
 }
-//# sourceMappingURL=emit-async.js.map
+//# sourceMappingURL=async.js.map