@scriptc/compiler 0.0.11 → 0.0.13

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,4 @@
-import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, islandCallbackRet, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
+import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, islandCallbackRet, islandPromisePayloadTag, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
 import { computeMayThrow } from "../emission/may-throw.js";
 import { mangleArgPack, mangleAsyncSpawn, mangleClassNew, mangleClassObj, mangleClassRetain, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenResThunk, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleResolveThunk, mangleTrampoline, mangleVtStruct, mangleWrapper } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
@@ -226,6 +226,9 @@ const LIB_FN_SYMS = {
     "text.decode": "scr_text_decode",
     "zlib.deflateSync": "scr_zlib_deflate",
     "zlib.inflateSync": "scr_zlib_inflate",
+    // The CA-store read (tlsca.get/set are may-throw seeds and refuse by
+    // omission — the C fallback carries them).
+    "tlsca.root": "scr_tls_ca_root",
     "crypto.randomBytes": "scr_crypto_random_bytes",
     "crypto.randomBytesToString": "scr_crypto_random_string",
     "crypto.randomUUID": "scr_crypto_random_uuid",
@@ -340,7 +343,7 @@ const LIB_FN_SYMS = {
     "sym.toString": "scr_sym_to_string",
     "error.toString": "scr_error_to_string",
     "class.name": "scr_classobj_name",
-    // The dyn (ScrDyn DOM) surface (scr_json.c / scr_dyn_invoke.c):
+    // The dyn (ScrDyn dyn) surface (scr_json.c / scr_dyn_invoke.c):
     // json.parse throws the catchable SyntaxError; keySet/toString/
     // defineProps throw Node's TypeErrors (all in the may-throw seed set —
     // the generic path emits the standard pending check). typeof and the
@@ -348,6 +351,9 @@ const LIB_FN_SYMS = {
     "json.parse": "scr_json_parse",
     "dyn.keySet": "scr_dyn_key_set",
     "dyn.iterPack": "scr_dyn_iter_pack",
+    "dyn.arrLen": "scr_dyn_arr_len",
+    "dyn.arrAt": "scr_dyn_arr_at",
+    "dyn.hasKey": "scr_dyn_has_key",
     "dyn.defineProps": "scr_dyn_define_props",
     "dyn.typeof": "scr_dyn_typeof",
     "dyn.toString": "scr_dyn_to_string_method",
@@ -444,6 +450,12 @@ const LIB_FN_SYMS = {
     "net.sockSetEncoding": "scr_net_sock_set_encoding",
     "net.sockSetTimeout": "scr_net_sock_set_timeout",
     "net.sockUnshift": "scr_net_sock_unshift_bytes",
+    "net.sockPause": "scr_net_sock_pause",
+    "net.sockResume": "scr_net_sock_resume",
+    "net.sockSetNoDelay": "scr_net_sock_set_nodelay",
+    "net.sockDestroySoon": "scr_net_sock_destroy_soon",
+    "net.sockBytesWritten": "scr_net_sock_bytes_written",
+    "net.sockReadable": "scr_net_sock_readable",
     "net.sockPipeRes": "scr_http_sock_pipe_res",
     "net.serverEmitConnection": "scr_net_server_emit_connection",
     "net.getAutoSelTimeout": "scr_net_get_autosel_timeout",
@@ -490,6 +502,7 @@ const LIB_FN_SYMS = {
     "http.clientDestroy": "scr_http_client_destroy",
     "http.clientDestroyed": "scr_http_client_destroyed",
     "http2.streamUndefCall": "scr_http2_stream_undef_call",
+    "http.agentNew": "scr_http_agent_new",
     // The island surface (--dynamic): eval/import bridge catchably (the
     // may-throw seed's pending check); importDyn answers an engine promise
     // and never throws itself. insp.jsval throws on composite island
@@ -535,7 +548,7 @@ const LIB_FN_SYMS = {
     "dc.tcTraceCallback": "scr_dc_tc_trace_callback",
     "dc.tcTracePromise": "scr_dc_tc_trace_promise",
     // AsyncLocalStorage (scr_async_dyn.c): store ids are doubles, values
-    // ride the DOM; run/exitRun dispatch user callbacks (may-throw).
+    // ride the checked-dynamic tree; run/exitRun dispatch user callbacks (may-throw).
     // The dc bind-store trio shares the als id space.
     "als.new": "scr_als_new",
     "als.get": "scr_als_get",
@@ -547,13 +560,16 @@ const LIB_FN_SYMS = {
     "dc.chanUnbindStore": "scr_dc_chan_unbind_store",
     "dc.chanRunStores": "scr_dc_chan_run_stores",
     // process warning/rejection events (scr_lib.c / scr_async_dyn.c):
-    // DOM listeners are borrowed (the runtime retains its copy);
+    // dyn listeners are borrowed (the runtime retains its copy);
     // onUnhandledRejection marks the loop live (the loop-end report
     // dispatches the listeners).
     "process.onWarning": "scr_process_on_warning",
     "process.offWarning": "scr_process_off_warning",
     "process.emitWarning": "scr_process_emit_warning",
     "process.onUnhandledRejection": "scr_process_on_unhandled_rejection",
+    "process.offUnhandledRejection": "scr_process_off_unhandled_rejection",
+    "process.onRejectionHandled": "scr_process_on_rejection_handled",
+    "process.offRejectionHandled": "scr_process_off_rejection_handled",
     // The await lowering's loop hop and the dyn await (both park the
     // current fiber — USES_TIMERS_LIB_FNS marks the loop live).
     "async.hop": "scr_await_hop",
@@ -568,7 +584,7 @@ const LIB_FN_SYMS = {
     "regexp.escape": "scr_regexp_escape",
     // The dyn Object walks (throw on nullish receivers), structuredClone
     // (option/DataClone/cycle errors), and new RegExp's eager compile
-    // (catchable SyntaxError) — all may-throw generics over the DOM.
+    // (catchable SyntaxError) — all may-throw generics over the checked-dynamic tree.
     "dyn.objKeys": "scr_dyn_obj_keys",
     "dyn.hasOwn": "scr_dyn_has_own",
     "dyn.assign": "scr_dyn_assign",
@@ -631,12 +647,13 @@ const USES_TIMERS_LIB_FNS = new Set([
     "http.createServer", "http.createServerEmpty",
     "http.request", "http.requestCb", "http.requestUrl", "http.requestUrlCb",
     "http.requestConn", "http.requestConnCb",
+    "http.agentNew", "http.requestAgent", "http.requestAgentCb",
     // The dyn-async slice (emit-exprs.ts's markings): fiber parks, the
     // microtask/immediate mints, the tracing-promise reaction fiber, and
     // the loop-end unhandled-rejection report.
     "async.hop", "async.awaitDyn",
     "dc.tcTracePromise",
-    "process.onUnhandledRejection",
+    "process.onUnhandledRejection", "process.onRejectionHandled",
     "timers.queueMicrotaskDyn", "timers.setImmediateFnValue", "timers.immediatePromise",
 ]);
 /** ScrBytesElem (scr_runtime.h): U8, U32, F32, I32. */
@@ -719,7 +736,7 @@ class LlEmitter {
      * rewriter, union ToString/join) — interned per typeKey/unionId, defs
      * flushed with the shape helpers. */
     walkers = new LlWalkers(this);
-    /** The dyn (ScrDyn DOM) helper registry — dyn.ts's interned ports of
+    /** The dyn (ScrDyn dyn) helper registry — dyn.ts's interned ports of
      * emit-walkers.ts's dyn slice. */
     dyn = new LlDyn(this);
     /** External declarations, in first-use order. */
@@ -2036,7 +2053,7 @@ class LlEmitter {
                 return t;
             }
             case "dyn": {
-                // ToBoolean over the DOM kind (scr_dyn_truthy — JS-exact for
+                // ToBoolean over the dyn kind (scr_dyn_truthy — JS-exact for
                 // every kind; borrowed, never throws): `v || dflt` and condition
                 // descent on checked-dynamic values.
                 this.declare(`declare zeroext i1 @scr_dyn_truthy(ptr)`);
@@ -3714,7 +3731,7 @@ class LlEmitter {
                     return this.own({ name: t, type: e.type });
                 }
                 if (v.type.kind === "dyn") {
-                    // String(unknown): dispatch over the DOM kind (dyn.ts's sc_ds —
+                    // String(unknown): dispatch over the dyn kind (dyn.ts's sc_ds —
                     // Node's String() incl. arrays-join and "[object Object]").
                     const helper = this.dyn.dynToStrHelper();
                     const t = B.tmp();
@@ -4015,7 +4032,7 @@ class LlEmitter {
                 this.unionTagSwitch(u.name, def, (arm) => {
                     if (isUnitType(arm)) {
                         if (e.type.kind === "dyn") {
-                            // A dyn-typed chain: the unit path is the undefined DOM
+                            // A dyn-typed chain: the unit path is the undefined dyn
                             // value — dyn represents undefined directly.
                             this.declare(`declare ptr @scr_dyn_undefined()`);
                             this.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
@@ -4197,8 +4214,21 @@ class LlEmitter {
                 const lj = B.newLabel("ord.j");
                 B.condBr(truthy, lt, lf);
                 B.startBlock(lt);
-                B.line(`store ${ty} ${this.unionExtract(l.name, e.type)}, ptr ${slot}`);
-                this.releaseValue(l.name, e.left.type);
+                if (e.retag !== undefined) {
+                    // Retagged shape: the whole box goes to the union→union helper,
+                    // which CONSUMES it (callees own their params) — no release on
+                    // this side. The store precedes the pending check so an unwind
+                    // leaves only the NULL dummy behind, in a slot nothing reads.
+                    const t = B.tmp();
+                    B.line(`${t} = call ${ty} @${this.callTarget(e.retag)}(${this.llType(e.left.type)} ${l.name})`);
+                    B.line(`store ${ty} ${t}, ptr ${slot}`);
+                    if (this.mayThrow.has(e.retag))
+                        this.emitPendingCheck();
+                }
+                else {
+                    B.line(`store ${ty} ${this.unionExtract(l.name, e.type)}, ptr ${slot}`);
+                    this.releaseValue(l.name, e.left.type);
+                }
                 B.br(lj);
                 B.startBlock(lf);
                 this.releaseValue(l.name, e.left.type);
@@ -4311,9 +4341,9 @@ class LlEmitter {
                 // the frame's release is a no-op) and the body reads it through
                 // chainRecv.
                 if (e.receiver.type.kind === "dyn") {
-                    // A dyn (DOM) receiver — the `rawName?.match(re)` step: the
+                    // A dyn (dyn) receiver — the `rawName?.match(re)` step: the
                     // nullish test reads the node's kind tag; the unit path is the
-                    // undefined DOM singleton (dyn results) or nothing (void
+                    // undefined dyn singleton (dyn results) or nothing (void
                     // bodies), the body runs over the bound receiver otherwise.
                     const r = this.emitExpr(e.receiver);
                     const kd = this.dynKind(r.name);
@@ -4465,7 +4495,7 @@ class LlEmitter {
                 }
                 if (e.type.kind === "dyn") {
                     // A dyn-typed chain (`pricing?.[key]` over an unknown-valued
-                    // index signature): the unit path is the undefined DOM value —
+                    // index signature): the unit path is the undefined dyn value —
                     // dyn represents undefined directly, no union wrapper exists.
                     const slotD = B.slot();
                     B.entryAllocas.push(`${slotD} = alloca ptr`);
@@ -4912,14 +4942,14 @@ class LlEmitter {
             }
             case "jsonStringify": {
                 // Type-directed serialization: the STATIC type picks an emitted
-                // serializer (interned per typeKey) — no DOM, no runtime dispatch.
+                // serializer (interned per typeKey) — no dyn, no runtime dispatch.
                 // The value temp is BORROWED (released with this statement's
                 // frame); the result string is owned (+1). Never throws — except
                 // the dyn root below.
                 const v = this.emitExpr(e.value);
                 let compact;
                 if (e.value.type.kind === "dyn") {
-                    // A dyn root: the runtime's DOM walker (scr_dyn_format_j — the
+                    // A dyn root: the runtime's dyn walker (scr_dyn_format_j — the
                     // C backend's dispatch exactly): number/string/bool/null/array/
                     // object exact, dropped members omitted, and a dropped ROOT
                     // becomes the TEXT "undefined" (JSON.stringify(undefined) is
@@ -5084,7 +5114,7 @@ class LlEmitter {
                     if (e.arg === null) {
                         if (genT.nextT.kind === "dyn") {
                             // Valueless resume on a dyn channel: JS's undefined — the
-                            // DOM singleton rides the IN slot (+1 moves in).
+                            // dyn singleton rides the IN slot (+1 moves in).
                             this.declare(`declare ptr @scr_dyn_undefined()`);
                             this.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
                             this.declare(`declare void @scr_dyn_release_v(ptr)`);
@@ -5552,10 +5582,10 @@ class LlEmitter {
                 return { name: "", type: e.type };
             }
             case "dynFrom": {
-                // Static value → fresh DOM tree (+1) through the interned per-type
+                // Static value → fresh dyn tree (+1) through the interned per-type
                 // converter; the operand stays borrowed (frame-released as usual).
                 // Bare unit literals (an `undefined`/`null` stored under an
-                // `unknown` index signature) are the DOM unit values directly.
+                // `unknown` index signature) are the dyn unit values directly.
                 if (e.value.kind === "unitLit") {
                     const t = B.tmp();
                     if (e.value.unit === "undefined") {
@@ -5573,7 +5603,7 @@ class LlEmitter {
                 }
                 const v = this.emitExpr(e.value);
                 if (v.type.kind === "func") {
-                    // A closure boxes as the DOM's function kind: retained closure +
+                    // A closure boxes as the checked-dynamic tree's function kind: retained closure +
                     // the per-signature call thunk + the interned signature key. The
                     // best-effort name rides along (null when the lowering had none).
                     const name = e.fnName !== undefined && e.fnName !== "" ? this.cstr(e.fnName) : "null";
@@ -5589,8 +5619,8 @@ class LlEmitter {
                 return this.own({ name: t, type: e.type });
             }
             case "dynFromJsval": {
-                // Island value → DOM: the by-reference wrap (scr_dyn_from_jsval
-                // retains the cell in; engine scalars normalize to native DOM
+                // Island value → dyn: the by-reference wrap (scr_dyn_from_jsval
+                // retains the cell in; engine scalars normalize to native dyn
                 // kinds at wrap time). Operand borrowed, result +1, never throws.
                 const v = this.emitExpr(e.value);
                 this.declare(`declare ptr @scr_dyn_from_jsval(ptr)`);
@@ -5609,7 +5639,7 @@ class LlEmitter {
                 return this.own({ name: t, type: e.type });
             }
             case "dynCheck": {
-                // The dynamic boundary: validate the DOM against the target type
+                // The dynamic boundary: validate the checked-dynamic tree against the target type
                 // and BUILD the typed value (+1) — or throw the catchable
                 // path-annotated TypeError. The dyn temp is BORROWED; the result
                 // joins the frame BEFORE the pending check so an unwind releases
@@ -5630,11 +5660,11 @@ class LlEmitter {
                 // spelling rides along for Node's "<name> is not a function".
                 const callee = this.emitExpr(e.callee);
                 if (e.spreads !== undefined && e.spreads.length > 0) {
-                    // The RUNTIME-ARITY form (`f(...args)`): one fresh DOM array
+                    // The RUNTIME-ARITY form (`f(...args)`): one fresh dyn array
                     // collects the arguments left-to-right — plain args move in
                     // (push takes ownership), spread args FLATTEN (push_spread
                     // retains elements in and throws V8's spread-call TypeError for
-                    // non-iterable DOM kinds, checked per spread — JS's
+                    // non-iterable dyn kinds, checked per spread — JS's
                     // ArgumentListEvaluation order) — then apply calls through the
                     // array's elements (borrowed, exactly scr_dyn_call).
                     this.declare(`declare ptr @scr_dyn_new_arr()`);
@@ -5707,7 +5737,7 @@ class LlEmitter {
                 return out;
             }
             case "dynArrLit": {
-                // A DOM array built element-by-element: ownership of each dyn
+                // A dyn array built element-by-element: ownership of each dyn
                 // element MOVES into the array (scr_dyn_arr_push's contract).
                 this.declare(`declare ptr @scr_dyn_new_arr()`);
                 this.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
@@ -5722,7 +5752,7 @@ class LlEmitter {
                 return out;
             }
             case "dynObjLit": {
-                // A DOM object built member-by-member: key then value, source
+                // A dyn object built member-by-member: key then value, source
                 // order. scr_dyn_key_set BORROWS all three (the member retains the
                 // value in); the receiver is a fresh OBJ, so the non-object throw
                 // paths are unreachable here.
@@ -5739,7 +5769,7 @@ class LlEmitter {
                 return out;
             }
             case "dynKeyGet": {
-                // Keyed read on the DOM through the one interned helper — the
+                // Keyed read on the checked-dynamic tree through the one interned helper — the
                 // non-optional form throws JS's TypeError on an undefined/null
                 // receiver, and HANDLE receivers can throw the loud unmodeled-
                 // property ladder on EITHER form; the result is owned (+1).
@@ -5824,7 +5854,7 @@ class LlEmitter {
                 const [d, s, st] = e.left.type.kind === "dyn" ? [l, r, e.right.type] : [r, l, e.left.type];
                 let test;
                 if (st.kind === "dyn") {
-                    // dyn vs dyn: whole-DOM strict equality.
+                    // dyn vs dyn: whole-dyn strict equality.
                     this.declare(`declare zeroext i1 @scr_dyn_strict_eq(ptr, ptr)`);
                     test = B.tmp();
                     B.line(`${test} = call zeroext i1 @scr_dyn_strict_eq(ptr ${l.name}, ptr ${r.name})`);
@@ -5877,7 +5907,7 @@ class LlEmitter {
                 return { name: neg, type: e.type };
             }
             case "dynTest": {
-                // A pure kind compare on the DOM node — borrowed; only the truthy
+                // A pure kind compare on the dyn node — borrowed; only the truthy
                 // form also reads a scalar payload (the runtime's ToBoolean).
                 const d = this.emitExpr(e.value);
                 let test;
@@ -5887,7 +5917,7 @@ class LlEmitter {
                     B.line(`${test} = call zeroext i1 @scr_dyn_truthy(ptr ${d.name})`);
                 }
                 else if (e.test === "error") {
-                    // `u instanceof Error`: the DOM's error encoding — an object
+                    // `u instanceof Error`: the checked-dynamic tree's error encoding — an object
                     // carrying the reserved "%error" marker key — or a real engine
                     // Error held by reference (the isl helper answers false for
                     // every non-JSVAL kind, so the call is unconditional).
@@ -5954,7 +5984,7 @@ class LlEmitter {
                         test = orIsl(oneOf([DK.OBJ, DK.ARR, DK.BYTES, DK.HANDLE, DK.PROMISE, DK.NULL]), "scr_dyn_isl_typeof_is", this.cstr("object"));
                     }
                     else if (e.test === "array") {
-                        // Array.isArray: the DOM's array kind, or the engine's own
+                        // Array.isArray: the checked-dynamic tree's array kind, or the engine's own
                         // answer for an engine-held value.
                         test = orIsl(oneOf([DK.ARR]), "scr_dyn_isl_is_array");
                     }
@@ -5980,7 +6010,7 @@ class LlEmitter {
                 return { name: neg, type: e.type };
             }
             case "dynDestrCheck": {
-                // RequireObjectCoercible with V8's destructuring TypeError. DOM
+                // RequireObjectCoercible with V8's destructuring TypeError. dyn
                 // values check in the runtime helper and pass through unchanged
                 // (same temp, same ownership); island values check in the engine
                 // (a fresh +1 cell for the same value comes back).
@@ -6001,7 +6031,7 @@ class LlEmitter {
             }
             case "dynIterN": {
                 // GetIterator + first-N steps as a fresh array (V8's exact
-                // not-iterable TypeError on non-iterables): the DOM helper for
+                // not-iterable TypeError on non-iterables): the dyn helper for
                 // dyn operands, the engine's real iterator protocol for island
                 // ones.
                 const v = this.emitExpr(e.value);
@@ -6033,7 +6063,9 @@ class LlEmitter {
                 const v = this.emitExpr(e.value);
                 const payload = e.type.kind === "promise" && e.type.inner.kind === "void"
                     ? 0 // SCR_ISLP_VOID
-                    : 4; // SCR_ISLP_JSVAL
+                    : e.type.kind === "promise" && e.type.inner.kind === "array" && e.type.inner.elem.kind === "jsval"
+                        ? 5 // SCR_ISLP_JSVAL_ARR: the Array.isArray-gated by-reference exit at settle
+                        : 4; // SCR_ISLP_JSVAL
                 this.declare(`declare ptr @scr_jsval_bridge_promise(ptr, i32)`);
                 const t = B.tmp();
                 B.line(`${t} = call ptr @scr_jsval_bridge_promise(ptr ${v.name}, i32 ${payload})`);
@@ -6081,7 +6113,7 @@ class LlEmitter {
             case "string":
                 return simple("scr_jsval_from_str", "ptr", false);
             case "dyn":
-                // A CHECKED-DYNAMIC (DOM) value entering the island: deep copy,
+                // A CHECKED-DYNAMIC (dyn) value entering the island: deep copy,
                 // data kinds only — boxed functions/handles/promises throw the
                 // catchable TypeError in the runtime, and a wrapped island value
                 // unwraps to the SAME engine value (the identity round trip).
@@ -6093,6 +6125,25 @@ class LlEmitter {
             case "url":
                 // A URL crossing IN: an engine URL instance built from href.
                 return simple("scr_jsval_from_url", "ptr", true);
+            case "promise": {
+                // A STATIC promise crossing IN: a real engine thenable settled
+                // when the scriptc promise settles (the async-callback return
+                // bridge). from_promise takes ownership of a +1 — retain past
+                // the borrowed frame temp. The C emitter's rule, mirrored.
+                const tag = islandPromisePayloadTag(e.value.type.inner);
+                if (!tag)
+                    throw new Error("llvm emitter bug: jsMarshal of a promise outside the bridge payload domain");
+                const tagN = { void: 0, f64: 1, bool: 2, string: 3, jsval: 4, jsvalArr: 5 }[tag];
+                this.declare(`declare ptr @scr_promise_retain(ptr)`);
+                this.declare(`declare ptr @scr_jsval_from_promise(ptr, i32)`);
+                const pr = B.tmp();
+                B.line(`${pr} = call ptr @scr_promise_retain(ptr ${v.name})`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_jsval_from_promise(ptr ${pr}, i32 ${tagN})`);
+                const out = this.own({ name: t, type: e.type });
+                this.emitPendingCheck();
+                return out;
+            }
             case "func": {
                 // A closure entering the island as a host function: from_closure
                 // retains it; the engine's finalizer releases it at teardown. The
@@ -6424,6 +6475,17 @@ class LlEmitter {
                 return out;
             }
             default: {
+                // `any[]`-declared slot: Array.isArray-gated, elements BY
+                // REFERENCE (identity crosses; the spine is a snapshot copy).
+                // JSON-safe element types keep the round trip below.
+                if (e.type.kind === "array" && e.type.elem.kind === "jsval") {
+                    this.declare(`declare ptr @scr_jsval_exit_jsval_arr(ptr)`);
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_jsval_exit_jsval_arr(ptr ${v.name})`);
+                    const out = this.own({ name: t, type: e.type });
+                    this.emitPendingCheck();
+                    return out;
+                }
                 // An undefined-armed union target: the engine's undefined takes
                 // the undefined arm FIRST (JSON cannot spell it); then null and
                 // data ride the round trip into the union's dynCheck like any
@@ -6460,11 +6522,31 @@ class LlEmitter {
                     B.br(lj);
                     B.startBlock(ld);
                     this.frames.push([]);
-                    const t = roundTrip();
-                    this.own({ name: t, type: e.type });
-                    this.emitPendingCheck();
-                    this.moveTemp({ name: t, type: e.type });
-                    B.line(`store ptr ${t}, ptr ${slot}`);
+                    const unionDef = this.unionsById.get(e.type.unionId);
+                    const dataArms = unionDef ? unionDef.arms.flatMap((a, i) => (isUnitType(a) ? [] : [{ a, i }])) : [];
+                    const jsvalArr = dataArms.length === 1 && dataArms[0].a.kind === "array" && dataArms[0].a.elem.kind === "jsval" ? dataArms[0] : null;
+                    let t;
+                    if (jsvalArr) {
+                        // The `any[] | undefined` defaulted-parameter spelling: the
+                        // engine array exits BY REFERENCE into the data arm.
+                        this.declare(`declare ptr @scr_jsval_exit_jsval_arr(ptr)`);
+                        this.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
+                        this.declare(`declare ptr @scr_arr_retain_v(ptr)`);
+                        this.declare(`declare void @scr_arr_release_v(ptr)`);
+                        const arr = B.tmp();
+                        B.line(`${arr} = call ptr @scr_jsval_exit_jsval_arr(ptr ${v.name})`);
+                        this.emitPendingCheck();
+                        t = B.tmp();
+                        B.line(`${t} = call ptr @scr_union_new_ref(i32 ${jsvalArr.i}, ptr ${arr}, ptr @scr_arr_retain_v, ptr @scr_arr_release_v, ptr null)`);
+                        B.line(`store ptr ${t}, ptr ${slot}`);
+                    }
+                    else {
+                        t = roundTrip();
+                        this.own({ name: t, type: e.type });
+                        this.emitPendingCheck();
+                        this.moveTemp({ name: t, type: e.type });
+                        B.line(`store ptr ${t}, ptr ${slot}`);
+                    }
                     this.releaseFrame(this.frames.pop());
                     B.br(lj);
                     B.startBlock(lj);
@@ -6677,7 +6759,7 @@ class LlEmitter {
                     d.push(`  %r = call ptr %fn(${passed.join(", ")})`, `  %rn = icmp eq ptr %r, null`, `  br i1 %rn, label %snull, label %sok`, `snull:`, `  ret ptr null`, `sok:`, `  %j = call ptr @scr_jsval_from_str(ptr %r)`, `  call void @scr_str_release(ptr %r)`, `  ret ptr %j`);
                     break;
                 case "dyn":
-                    // A checked-dynamic (+1 DOM) result: deep copy into the engine
+                    // A checked-dynamic (+1 dyn) result: deep copy into the engine
                     // (the jsMarshal dyn rule); NULL is the throw-path dummy.
                     this.declare(`declare ptr @scr_jsval_from_dyn(ptr)`);
                     this.declare(`declare void @scr_dyn_release(ptr)`);
@@ -6708,7 +6790,7 @@ class LlEmitter {
         this.resolveThunkDefs.push(...d);
         return sym;
     }
-    /** Loads a DOM node's kind tag (i32 at +8) — the dyn expression tests'
+    /** Loads a dyn node's kind tag (i32 at +8) — the dyn expression tests'
      * shared read. */
     dynKind(d) {
         const B = this.B;
@@ -8537,7 +8619,7 @@ class LlEmitter {
             // A dyn JOIN (the C helper's `surface` dyn arm): declared hits
             // convert through the per-type toDyn walker (borrowed read → fresh
             // +1 tree), a dyn-valued overflow hit passes through (+1 from the
-            // map get), and a miss is JS's undefined — the DOM singleton.
+            // map get), and a miss is JS's undefined — the dyn singleton.
             this.declare(`declare zeroext i1 @scr_str_eq(ptr, ptr)`);
             for (const f of overflowOnly ? [] : shape.fields) {
                 const lit = this.internLiteral(f.name);
@@ -8615,7 +8697,7 @@ class LlEmitter {
                 B.br(join);
                 B.startBlock(ln);
             }
-            // The miss path: JS's undefined — the DOM singleton, retained.
+            // The miss path: JS's undefined — the dyn singleton, retained.
             this.declare(`declare ptr @scr_dyn_undefined()`);
             this.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
             const u = B.tmp();
@@ -10544,9 +10626,11 @@ class LlEmitter {
             B.line(`call void @${entry}(ptr ${args[0].name}, ptr ${args[1].name}, ptr @${adapter}, i1 ${args[2].name})`);
             return { name: "", type: e.type };
         }
-        if (e.fn === "http.request" || e.fn === "http.requestCb" || e.fn === "http.requestUrl" || e.fn === "http.requestUrlCb") {
+        if (e.fn === "http.request" || e.fn === "http.requestCb" || e.fn === "http.requestUrl" || e.fn === "http.requestUrlCb" ||
+            e.fn === "http.requestAgent" || e.fn === "http.requestAgentCb") {
             const isUrl = e.fn.startsWith("http.requestUrl");
-            const cbIdx = isUrl ? 3 : 7;
+            const isAgent = e.fn.startsWith("http.requestAgent");
+            const cbIdx = isUrl ? 3 : isAgent ? 8 : 7;
             const hasCb = e.fn.endsWith("Cb");
             const args = e.args.map((a) => this.emitExpr(a));
             let cb = "null";
@@ -10563,7 +10647,7 @@ class LlEmitter {
             }
             const head = args.slice(0, cbIdx);
             const decls = head.map((a) => (this.llType(a.type) === "i1" ? "i1 zeroext" : this.llType(a.type)));
-            const entry = isUrl ? "scr_http_request_url" : "scr_http_request";
+            const entry = isUrl ? "scr_http_request_url" : isAgent ? "scr_http_request_agent" : "scr_http_request";
             this.declare(`declare ptr @${entry}(${[...decls, "ptr", "ptr"].join(", ")})`);
             const t = B.tmp();
             B.line(`${t} = call ptr @${entry}(${[...head.map((a) => `${this.llType(a.type)} ${a.name}`), `ptr ${cb}`, `ptr ${adapter}`].join(", ")})`);
@@ -10598,6 +10682,13 @@ class LlEmitter {
             B.line(`call void @scr_http_res_on_finish(ptr ${args[0].name}, ptr ${args[1].name})`);
             return { name: "", type: e.type };
         }
+        if (e.fn === "net.sockOnFinish") {
+            const args = e.args.map((a) => this.emitExpr(a));
+            this.moveTemp(args[1]);
+            this.declare(`declare void @scr_net_sock_on_finish(ptr, ptr)`);
+            B.line(`call void @scr_net_sock_on_finish(ptr ${args[0].name}, ptr ${args[1].name})`);
+            return { name: "", type: e.type };
+        }
         if (e.fn === "island.castFail") {
             // The deferred boundary failure: the island value was evaluated
             // (its side effects are real), the throw is unconditional