@scriptc/compiler 0.0.21 → 0.0.23

package/dist/backend/llvm/emitter.js

@@ -1,4 +1,4 @@
-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 { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, islandCallbackRet, islandPromisePayloadTag, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, 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";
@@ -129,13 +129,36 @@ const LIB_FN_SYMS = {
     "process.stderrWrite": "scr_process_stderr_write",
     "process.isTTY": "scr_process_is_tty",
     "date.now": "scr_date_now",
+    "date.newNow": "scr_date_now",
+    "date.newMs": "scr_date_new_ms",
+    "date.newString": "scr_date_parse_get_time",
+    "date.getTime": "scr_date_get_time",
+    "date.valueOf": "scr_date_get_time",
     "date.parseGetTime": "scr_date_parse_get_time",
     "date.utc": "scr_date_utc",
+    "date.getFullYear": "scr_date_get_full_year_local",
+    "date.getUTCFullYear": "scr_date_get_full_year_utc",
+    "date.getMonth": "scr_date_get_month_local",
+    "date.getUTCMonth": "scr_date_get_month_utc",
+    "date.getDate": "scr_date_get_date_local",
+    "date.getUTCDate": "scr_date_get_date_utc",
+    "date.getDay": "scr_date_get_day_local",
+    "date.getUTCDay": "scr_date_get_day_utc",
+    "date.getHours": "scr_date_get_hours_local",
+    "date.getUTCHours": "scr_date_get_hours_utc",
+    "date.getMinutes": "scr_date_get_minutes_local",
+    "date.getUTCMinutes": "scr_date_get_minutes_utc",
+    "date.getSeconds": "scr_date_get_seconds_local",
+    "date.getUTCSeconds": "scr_date_get_seconds_utc",
+    "date.getMilliseconds": "scr_date_get_milliseconds",
+    "date.getUTCMilliseconds": "scr_date_get_milliseconds",
+    "date.getTimezoneOffset": "scr_date_get_timezone_offset",
     "fs.existsSync": "scr_fs_exists",
     // ── the throwing slice (MAY_THROW_LIB_FNS members): the generic path
     // emits the standard pending check after each — emit-exprs.ts's finish.
     "process.cpuPrevValidate": "scr_cpu_prev_validate",
     "date.toISOString": "scr_date_to_iso",
+    "date.toISOStringValue": "scr_date_to_iso",
     "process.chdir": "scr_process_chdir",
     "fs.writeFileSync": "scr_fs_write_file",
     "fs.appendFileSync": "scr_fs_append_file",
@@ -351,6 +374,18 @@ const LIB_FN_SYMS = {
     // defineProps throw Node's TypeErrors (all in the may-throw seed set —
     // the generic path emits the standard pending check). typeof and the
     // ambient-this read never throw. The fs dyn read is the sync-fs story.
+    "fetch.start": "scr_fetch_static",
+    "fetch.responseNew": "scr_fetch_response_new",
+    "fetch.responseJson": "scr_fetch_response_json",
+    "fetch.responseText": "scr_fetch_response_text",
+    "fetch.responseBytes": "scr_fetch_response_bytes",
+    "fetch.abortControllerNew": "scr_fetch_abort_controller_new",
+    "fetch.abortTimeout": "scr_fetch_abort_timeout",
+    "fetch.abortNow": "scr_fetch_abort_now",
+    "fetch.abortAny": "scr_fetch_abort_any",
+    "fetch.streamNew": "scr_fetch_stream_new",
+    "fetch.streamFrom": "scr_fetch_stream_from",
+    "fetch.readerRead": "scr_fetch_reader_read",
     "json.parse": "scr_json_parse",
     "dyn.keySet": "scr_dyn_key_set",
     "dyn.iterPack": "scr_dyn_iter_pack",
@@ -626,6 +661,8 @@ const STREAM_CANONICAL_CBS = {
  * the stream/emitter slice of emit-exprs.ts's markings, applied before
  * dispatch so generic and special shapes share one table. */
 const USES_TIMERS_LIB_FNS = new Set([
+    "fetch.start",
+    "fetch.abortTimeout", "fetch.streamNew", "fetch.streamFrom",
     "readable.new", "writable.new", "duplex.new", "transform.new", "passthrough.new",
     "readable.init", "writable.init", "duplex.init", "transform.init", "passthrough.init",
     "readable.newDyn", "writable.newDyn", "duplex.newDyn", "transform.newDyn", "passthrough.newDyn",
@@ -770,6 +807,15 @@ class LlEmitter {
      * typeKey → thunk symbol (CEmitter.resolveThunks). */
     resolveThunks = new Map();
     resolveThunkDefs = [];
+    /** ReadableStream.from adapters keep typed arrays by reference and box
+     * one current element per pull. */
+    streamFromArrayAdapters = new Map();
+    /** Identity-preserving static→dyn capsules used by Web APIs whose values
+     * remain directly observable (stream chunks and AbortSignal reasons). */
+    liveDynRefAdapters = new Map();
+    /** Runtime-arm dispatchers for live union values. */
+    liveDynUnionRefAdapters = new Map();
+    dynPromiseAdapters = new Map();
     unionsById = new Map();
     recordsById = new Map();
     tracedShapes;
@@ -919,6 +965,7 @@ class LlEmitter {
     llType(t) {
         switch (t.kind) {
             case "f64":
+            case "date":
                 return "double";
             case "bool":
                 return "i1";
@@ -1038,6 +1085,7 @@ class LlEmitter {
         // any island entry (the engine's lazy boot consults it) — cc.ts
         // compiles scr_fetch.c on the same predicate.
         const usesFetch = moduleUsesFetch(this.mod);
+        const snapshotsTlsCa = moduleUsesTls(this.mod) || moduleUsesTlsCa(this.mod);
         const hasRefGlobals = globals.some((g) => isRefCounted(g.type)) || fnValueProps.length > 0;
         // Declared NOW — the extern block flushes before main assembles.
         if (usesEvents)
@@ -1054,6 +1102,9 @@ class LlEmitter {
             this.declare(`declare void @scr_http_dyn_install()`);
         if (usesFetch)
             this.declare(`declare void @scr_fetch_install()`);
+        if (snapshotsTlsCa) {
+            this.declare(`declare void @scr_tls_ca_install()`);
+        }
         if (usesEvents && hasRefGlobals) {
             this.declare(`declare void @scr_run_exit_listeners(double)`);
             this.declare(`declare i32 @scr_exit_code_hint_get()`);
@@ -1167,6 +1218,11 @@ class LlEmitter {
             // scr_runtime.h's natural alignment: kind at 8, f64 at 16, b at 24,
             // payload at 32).
             `%ScrCaught = type { i64, i32, double, i8, ptr, ptr, ptr, ptr }`,
+            // ScrBytes { rc, len, elem(i32+pad), data, backing }. Indexed
+            // typed-array access GEPs through this directly: the IR type already
+            // fixes elem, so the hot path needs neither a runtime kind load nor
+            // the generic scr_bytes_get/set call.
+            `%ScrBytes = type { i64, i64, i32, ptr, ptr }`,
             // The capture box { rc, kind, obj_retain, obj_release, obj_trace,
             // slot } — TDZ reads peek the payload slot (offset 40) directly.
             `%ScrBox = type { i64, i32, ptr, ptr, ptr, i64 }`,
@@ -1298,7 +1354,7 @@ class LlEmitter {
         ...(usesEvents ? [`  call void @scr_events_install()`] : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
-        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(asyncEntry
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(asyncEntry
             ? [`  %top = call ptr @${mangleAsyncSpawn(this.mod.entry)}()`]
             : [`  call void @${mangleFunction(this.mod.entry)}()`]), 
         // Uncaught exception from top-level code: Node exits 1.
@@ -1671,6 +1727,7 @@ class LlEmitter {
                     tr.push(`  call void @scr_promise_fulfill_void(ptr %pr)`);
                     break;
                 case "f64":
+                case "date":
                     this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
                     tr.push(`  call void @scr_promise_fulfill_f64(ptr %pr, double %r)`);
                     break;
@@ -1826,6 +1883,7 @@ class LlEmitter {
                     tr.push(`  br label %done ; void body: the done value is undefined (NONE)`);
                     break;
                 case "f64":
+                case "date":
                     this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
                     tr.push(`  call void @scr_gen_out_f64(ptr %g, double %r)`, `  br label %done`);
                     break;
@@ -2047,7 +2105,7 @@ class LlEmitter {
         const t = this.currentReturnType;
         if (t.kind === "void")
             this.B.terminate("ret void");
-        else if (t.kind === "f64")
+        else if (t.kind === "f64" || t.kind === "date")
             this.B.terminate(`ret double ${f64Lit(0)}`);
         else if (t.kind === "bool")
             this.B.terminate("ret i1 false");
@@ -2079,7 +2137,10 @@ class LlEmitter {
     emitThrowValue(v) {
         const B = this.B;
         const t = v.type;
-        if (t.kind === "f64") {
+        if (t.kind === "date") {
+            throw new Error("LLVM emitter bug: Date throw reached backend");
+        }
+        else if (t.kind === "f64") {
             this.declare(`declare void @scr_throw_f64(double)`);
             B.line(`call void @scr_throw_f64(double ${v.name})`);
         }
@@ -2128,6 +2189,8 @@ class LlEmitter {
                 B.line(`${t} = icmp ne i64 ${len}, 0`);
                 return t;
             }
+            case "date":
+                return "true";
             case "array":
             case "record":
             case "object":
@@ -2222,6 +2285,9 @@ class LlEmitter {
                             B.line(`store i1 ${t}, ptr ${slot}`);
                             break;
                         }
+                        case "date":
+                            B.line(`store i1 true, ptr ${slot} ; Date objects are truthy`);
+                            break;
                         case "array":
                         case "record":
                         case "object":
@@ -2766,13 +2832,16 @@ class LlEmitter {
             }
             case "bytesSet": {
                 // Typed-array element write: same evaluation order as arraySet;
-                // the value is a scalar (the runtime coerces JS-exactly), so no
-                // ownership moves. Any invalid index traps — no append.
-                const arr = this.emitExpr(s.arr);
+                // the value is a scalar (the kind-specific inline path coerces
+                // JS-exactly), so no ownership moves. Any invalid index traps — no
+                // append. IrBytesElem is static, so never rediscover it through the
+                // generic runtime switch in a hot loop.
+                const arr = this.emitBytesReceiver(s.arr, [s.index, s.value]);
                 const idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
-                this.declare(`declare void @scr_bytes_set(ptr, double, double)`);
-                B.line(`call void @scr_bytes_set(ptr ${arr.name}, double ${idx.name}, double ${v.name})`);
+                if (s.arr.type.kind !== "bytes")
+                    throw new Error("llvm emitter bug: bytesSet on non-bytes");
+                this.emitBytesSet(s.arr.type.elem, arr.name, idx.name, v.name);
                 break;
             }
             case "fieldSet":
@@ -5255,7 +5324,7 @@ class LlEmitter {
                     throw new Error("llvm emitter bug: yieldExpr with no operand (frontend fills undefined)");
                 const v = this.emitExpr(e.value);
                 const yt = e.value.type;
-                if (yt.kind === "f64") {
+                if (yt.kind === "f64" || yt.kind === "date") {
                     this.declare(`declare void @scr_gen_yield_f64(double)`);
                     B.line(`call void @scr_gen_yield_f64(double ${v.name})`);
                 }
@@ -5275,7 +5344,7 @@ class LlEmitter {
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
-                if (e.type.kind === "f64") {
+                if (e.type.kind === "f64" || e.type.kind === "date") {
                     this.declare(`declare double @scr_gen_take_in_f64()`);
                     B.line(`${t} = call double @scr_gen_take_in_f64()`);
                     return { name: t, type: e.type };
@@ -5307,7 +5376,7 @@ class LlEmitter {
                     store(a.name, e.arg.type);
                 };
                 const parkIn = (name, t) => {
-                    if (t.kind === "f64") {
+                    if (t.kind === "f64" || t.kind === "date") {
                         this.declare(`declare void @scr_gen_in_f64(ptr, double)`);
                         B.line(`call void @scr_gen_in_f64(ptr ${g.name}, double ${name})`);
                     }
@@ -5353,7 +5422,7 @@ class LlEmitter {
                     }
                     else {
                         sendArg((name, t) => {
-                            if (t.kind === "f64") {
+                            if (t.kind === "f64" || t.kind === "date") {
                                 this.declare(`declare void @scr_gen_ret_f64(ptr, double)`);
                                 B.line(`call void @scr_gen_ret_f64(ptr ${g.name}, double ${name})`);
                             }
@@ -5406,7 +5475,7 @@ class LlEmitter {
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
-                if (e.type.kind === "f64") {
+                if (e.type.kind === "f64" || e.type.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
                     B.line(`${t} = call double @scr_await_f64(ptr ${pr.name})`);
                 }
@@ -5486,7 +5555,7 @@ class LlEmitter {
                 B.startBlock(lp);
                 const peek = this.unionPeek(u.name);
                 let awaited;
-                if (inner.kind === "f64") {
+                if (inner.kind === "f64" || inner.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
                     const x = B.tmp();
                     B.line(`${x} = call double @scr_await_f64(ptr ${peek})`);
@@ -5563,7 +5632,7 @@ class LlEmitter {
                     return out;
                 }
                 let resolve;
-                const kindNums = { f64: 0, bool: 1, string: 2, void: 3 };
+                const kindNums = { f64: 0, date: 0, bool: 1, string: 2, void: 3 };
                 const kindNum = kindNums[inner.kind];
                 if (kindNum !== undefined) {
                     this.declare(`declare ptr @scr_make_resolve(ptr, i32)`);
@@ -5609,7 +5678,7 @@ class LlEmitter {
                 this.declare(`declare ptr @scr_make_reject(ptr)`);
                 const p = B.tmp();
                 B.line(`${p} = call ptr @scr_promise_new()`);
-                const kindNums = { f64: 0, bool: 1, string: 2, void: 3 };
+                const kindNums = { f64: 0, date: 0, bool: 1, string: 2, void: 3 };
                 const kindNum = kindNums[inner.kind];
                 const resolve = B.tmp();
                 if (kindNum !== undefined) {
@@ -5724,7 +5793,7 @@ class LlEmitter {
                     }
                     const v = this.emitExpr(e.args[0]);
                     const t = e.args[0].type;
-                    if (t.kind === "f64") {
+                    if (t.kind === "f64" || t.kind === "date") {
                         this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
                         B.line(`call void @scr_promise_fulfill_f64(ptr ${p}, double ${v.name})`);
                     }
@@ -5821,6 +5890,29 @@ class LlEmitter {
                     return this.own({ name: t, type: e.type });
                 }
                 const v = this.emitExpr(e.value);
+                if (e.liveRef) {
+                    if (v.type.kind === "union") {
+                        const adapter = this.liveDynUnionRefAdapter(v.type);
+                        const boxed = B.tmp();
+                        B.line(`${boxed} = call ptr @${adapter}(ptr ${v.name})`);
+                        return this.own({ name: boxed, type: e.type });
+                    }
+                    if (!this.streamTypedRefEligible(v.type)) {
+                        throw new Error(`llvm emitter bug: live dyn ref of ${typeKey(v.type)}`);
+                    }
+                    const key = typeKey(v.type);
+                    let adapter = this.liveDynRefAdapters.get(key);
+                    if (!adapter) {
+                        const prefix = `sc_ldr_${this.liveDynRefAdapters.size}`;
+                        adapter = this.streamTypedRefMaterializeAdapter(v.type, { prefix, adapters: new Map() }, `${prefix}_materialize`);
+                        this.liveDynRefAdapters.set(key, adapter);
+                    }
+                    const rc = vAdapters(this, v.type);
+                    this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+                    const boxed = B.tmp();
+                    B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, i64 ${Buffer.byteLength(key, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+                    return this.own({ name: boxed, type: e.type });
+                }
                 if (v.type.kind === "func") {
                     // A closure boxes as the checked-dynamic tree's function kind: retained closure +
                     // the per-signature call thunk + the interned signature key. The
@@ -6560,6 +6652,15 @@ class LlEmitter {
                     return t;
                 });
             }
+            case "callFnThis": {
+                const pack = argPack(args.slice(2).map((x) => x.name));
+                this.declare(`declare ptr @scr_jsval_call_this(ptr, ptr, i32, ptr)`);
+                return fallible(() => {
+                    const t = B.tmp();
+                    B.line(`${t} = call ptr @scr_jsval_call_this(ptr ${a(0)}, ptr ${a(1)}, i32 ${args.length - 2}, ptr ${pack})`);
+                    return t;
+                });
+            }
             case "callSpread": {
                 // Spread application (`f(...pre, ...s)`): the prelude helper's
                 // real spread syntax — iterator protocols are the engine's own,
@@ -8568,6 +8669,233 @@ class LlEmitter {
             }
         }
     }
+    /** Whether an index/value expression can overwrite the bytes receiver
+     * binding. Kept deliberately conservative; uncertain or calling shapes
+     * retain the ordinary owned-receiver snapshot. */
+    isStableBytesOperand(e, receiverLocalId) {
+        switch (e.kind) {
+            case "numLit":
+            case "boolLit":
+            case "varRef":
+            case "incDec":
+                return true;
+            case "assignExpr":
+                // A bytes assignment nested under truthiness/ternary can still
+                // produce the numeric index/value expected by the outer access.
+                return (e.localId !== receiverLocalId &&
+                    this.isStableBytesOperand(e.value, receiverLocalId));
+            case "bin":
+                return (this.isStableBytesOperand(e.left, receiverLocalId) &&
+                    this.isStableBytesOperand(e.right, receiverLocalId));
+            case "unary":
+            case "toBool":
+                return this.isStableBytesOperand(e.operand, receiverLocalId);
+            case "logical":
+                return (this.isStableBytesOperand(e.left, receiverLocalId) &&
+                    this.isStableBytesOperand(e.right, receiverLocalId));
+            case "ternary":
+                return (this.isStableBytesOperand(e.cond, receiverLocalId) &&
+                    this.isStableBytesOperand(e.then, receiverLocalId) &&
+                    this.isStableBytesOperand(e.else_, receiverLocalId));
+            case "bytesIntrinsic":
+                return ((e.method === "get" || e.method === "length" || e.method === "byteLength") &&
+                    e.receiver.kind === "varRef" &&
+                    e.args.every((arg) => this.isStableBytesOperand(arg, receiverLocalId)));
+            default:
+                return false;
+        }
+    }
+    /** Borrow a direct, unboxed bytes binding when later operands are stable.
+     * Its scope/global owner keeps it alive through the access. */
+    emitBytesReceiver(receiver, following) {
+        if (receiver.kind === "varRef" &&
+            following.every((operand) => this.isStableBytesOperand(operand, receiver.localId))) {
+            const b = this.binding(receiver.localId);
+            if (b.kind !== "boxed") {
+                const value = this.B.tmp();
+                this.B.line(`${value} = load ptr, ptr ${b.slot}`);
+                return { name: value, type: receiver.type };
+            }
+        }
+        return this.emitExpr(receiver);
+    }
+    /** Bounds-check a typed-array element index without an out-of-line call
+     * on the valid path. The range test rejects NaN/infinity before fptoui;
+     * the integer round trip then rejects fractions. The error block retains
+     * the runtime's exact trap text. Leaves the builder in the valid block. */
+    emitBytesIndex(receiver, index) {
+        const B = this.B;
+        const lenPtr = B.tmp();
+        const len = B.tmp();
+        const lenF64 = B.tmp();
+        const nonnegative = B.tmp();
+        const belowLen = B.tmp();
+        const inRange = B.tmp();
+        B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
+        B.line(`${len} = load i64, ptr ${lenPtr}`);
+        B.line(`${lenF64} = uitofp i64 ${len} to double`);
+        B.line(`${nonnegative} = fcmp oge double ${index}, ${f64Lit(0)}`);
+        B.line(`${belowLen} = fcmp olt double ${index}, ${lenF64}`);
+        B.line(`${inRange} = and i1 ${nonnegative}, ${belowLen}`);
+        const rangeOk = B.newLabel("bytes.index.range");
+        const invalid = B.newLabel("bytes.index.invalid");
+        const valid = B.newLabel("bytes.index.valid");
+        B.condBr(inRange, rangeOk, invalid);
+        B.startBlock(rangeOk);
+        const idx = B.tmp();
+        const roundTrip = B.tmp();
+        const integral = B.tmp();
+        B.line(`${idx} = fptoui double ${index} to i64`);
+        B.line(`${roundTrip} = uitofp i64 ${idx} to double`);
+        B.line(`${integral} = fcmp oeq double ${roundTrip}, ${index}`);
+        B.condBr(integral, valid, invalid);
+        B.startBlock(invalid);
+        this.declare(`declare double @scr_bytes_get(ptr, double)`);
+        B.line(`call double @scr_bytes_get(ptr ${receiver}, double ${index})`);
+        B.terminate("unreachable");
+        B.startBlock(valid);
+        return idx;
+    }
+    /** Load the raw data pointer from ScrBytes after the bounds check. */
+    emitBytesData(receiver) {
+        const p = this.B.tmp();
+        const data = this.B.tmp();
+        this.B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 3`);
+        this.B.line(`${data} = load ptr, ptr ${p}`);
+        return data;
+    }
+    /** Static typed-array length/byteLength load. */
+    emitBytesLength(elem, receiver, bytes) {
+        const B = this.B;
+        const p = B.tmp();
+        const len = B.tmp();
+        B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
+        B.line(`${len} = load i64, ptr ${p}`);
+        const count = bytes && elem !== "u8" ? B.tmp() : len;
+        if (count !== len)
+            B.line(`${count} = shl i64 ${len}, 2`);
+        const out = B.tmp();
+        B.line(`${out} = uitofp i64 ${count} to double`);
+        return { name: out, type: F64 };
+    }
+    /** Kind-specialized typed-array load. */
+    emitBytesGet(elem, receiver, index) {
+        const B = this.B;
+        const idx = this.emitBytesIndex(receiver, index);
+        const data = this.emitBytesData(receiver);
+        const p = B.tmp();
+        if (elem === "u8") {
+            const raw = B.tmp();
+            const wide = B.tmp();
+            const out = B.tmp();
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`${raw} = load i8, ptr ${p}, align 1`);
+            B.line(`${wide} = zext i8 ${raw} to i32`);
+            B.line(`${out} = uitofp i32 ${wide} to double`);
+            return { name: out, type: F64 };
+        }
+        if (elem === "f32") {
+            const raw = B.tmp();
+            const out = B.tmp();
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`${raw} = load float, ptr ${p}, align 1`);
+            B.line(`${out} = fpext float ${raw} to double`);
+            return { name: out, type: F64 };
+        }
+        const raw = B.tmp();
+        const out = B.tmp();
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`${raw} = load i32, ptr ${p}, align 1`);
+        B.line(`${out} = ${elem === "i32" ? "sitofp" : "uitofp"} i32 ${raw} to double`);
+        return { name: out, type: F64 };
+    }
+    /** ToUint32/ToInt32 coercion with the overwhelmingly common finite,
+     * exactly-representable JS-number range on a cast-only path. Exceptional
+     * and huge values remain inline in the program TU so unrelated runtime
+     * binaries do not acquire another exported helper. */
+    emitBytesU32(value) {
+        const B = this.B;
+        const aboveMin = B.tmp();
+        const belowMax = B.tmp();
+        const fast = B.tmp();
+        B.line(`${aboveMin} = fcmp oge double ${value}, ${f64Lit(-9007199254740992)}`);
+        B.line(`${belowMax} = fcmp ole double ${value}, ${f64Lit(9007199254740992)}`);
+        B.line(`${fast} = and i1 ${aboveMin}, ${belowMax}`);
+        const fastLabel = B.newLabel("bytes.coerce.fast");
+        const slowLabel = B.newLabel("bytes.coerce.slow");
+        const done = B.newLabel("bytes.coerce.done");
+        B.condBr(fast, fastLabel, slowLabel);
+        B.startBlock(fastLabel);
+        const signed = B.tmp();
+        const fastU32 = B.tmp();
+        B.line(`${signed} = fptosi double ${value} to i64`);
+        B.line(`${fastU32} = trunc i64 ${signed} to i32`);
+        B.br(done);
+        B.startBlock(slowLabel);
+        const ordered = B.tmp();
+        const belowInf = B.tmp();
+        const aboveNegInf = B.tmp();
+        const finiteRange = B.tmp();
+        const finite = B.tmp();
+        B.line(`${ordered} = fcmp ord double ${value}, ${value}`);
+        B.line(`${belowInf} = fcmp olt double ${value}, ${F64_INF}`);
+        B.line(`${aboveNegInf} = fcmp ogt double ${value}, ${f64Lit(-Infinity)}`);
+        B.line(`${finiteRange} = and i1 ${belowInf}, ${aboveNegInf}`);
+        B.line(`${finite} = and i1 ${ordered}, ${finiteRange}`);
+        const finiteLabel = B.newLabel("bytes.coerce.finite");
+        const nonfiniteLabel = B.newLabel("bytes.coerce.nonfinite");
+        const slowDone = B.newLabel("bytes.coerce.slow.done");
+        B.condBr(finite, finiteLabel, nonfiniteLabel);
+        B.startBlock(finiteLabel);
+        this.declare(`declare double @llvm.trunc.f64(double)`);
+        const truncated = B.tmp();
+        const residue = B.tmp();
+        const negative = B.tmp();
+        const wrapped = B.tmp();
+        const normalized = B.tmp();
+        const finiteU32 = B.tmp();
+        B.line(`${truncated} = call double @llvm.trunc.f64(double ${value})`);
+        B.line(`${residue} = frem double ${truncated}, ${f64Lit(4294967296)}`);
+        B.line(`${negative} = fcmp olt double ${residue}, ${f64Lit(0)}`);
+        B.line(`${wrapped} = fadd double ${residue}, ${f64Lit(4294967296)}`);
+        B.line(`${normalized} = select i1 ${negative}, double ${wrapped}, double ${residue}`);
+        B.line(`${finiteU32} = fptoui double ${normalized} to i32`);
+        B.br(slowDone);
+        B.startBlock(nonfiniteLabel);
+        B.br(slowDone);
+        B.startBlock(slowDone);
+        const slowU32 = B.tmp();
+        B.line(`${slowU32} = phi i32 [ ${finiteU32}, %${finiteLabel} ], [ 0, %${nonfiniteLabel} ]`);
+        B.br(done);
+        B.startBlock(done);
+        const out = B.tmp();
+        B.line(`${out} = phi i32 [ ${fastU32}, %${fastLabel} ], [ ${slowU32}, %${slowDone} ]`);
+        return out;
+    }
+    /** Kind-specialized typed-array store. */
+    emitBytesSet(elem, receiver, index, value) {
+        const B = this.B;
+        const idx = this.emitBytesIndex(receiver, index);
+        const stored = elem === "f32" ? null : this.emitBytesU32(value);
+        const data = this.emitBytesData(receiver);
+        const p = B.tmp();
+        if (elem === "u8") {
+            const byte = B.tmp();
+            B.line(`${byte} = trunc i32 ${stored} to i8`);
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`store i8 ${byte}, ptr ${p}, align 1`);
+            return;
+        }
+        if (elem === "f32") {
+            const narrowed = B.tmp();
+            B.line(`${narrowed} = fptrunc double ${value} to float`);
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`store float ${narrowed}, ptr ${p}, align 1`);
+            return;
+        }
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`store i32 ${stored}, ptr ${p}, align 1`);
+    }
     /** The bytesIntrinsic surface (emit-exprs.ts's switch, .ll flavored).
      * Receiver and args are borrowed frame temps; string/bytes results come
      * back +1. The MAY_THROW methods get the standard pending check after
@@ -8615,18 +8943,30 @@ class LlEmitter {
                 ? call("scr_bytes_read_var", "double (ptr, double, double, i1 zeroext, i1 zeroext)", `ptr ${r0.name}, double ${rest[0].name}, double ${rest[1].name}, i1 ${spec.sign}, i1 ${spec.le}`, false, true)
                 : call("scr_bytes_write_var", "double (ptr, double, double, double, i1 zeroext, i1 zeroext)", `ptr ${r0.name}, double ${rest[0].name}, double ${rest[1].name}, double ${rest[2].name}, i1 ${spec.sign}, i1 ${spec.le}`, false, true);
         }
-        const r = this.emitExpr(e.receiver);
-        const args = e.args.map((a) => this.emitExpr(a));
         const method = e.method;
+        const directElementAccess = method === "length" || method === "byteLength" || method === "get";
+        const r = directElementAccess
+            ? this.emitBytesReceiver(e.receiver, e.args)
+            : this.emitExpr(e.receiver);
+        const args = e.args.map((a) => this.emitExpr(a));
         const NAN = f64Lit(NaN);
         switch (method) {
             case "length":
-                return call("scr_bytes_len", "double (ptr)", `ptr ${r.name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic length on non-bytes");
+                }
+                return this.emitBytesLength(e.receiver.type.elem, r.name, false);
             case "byteLength":
-                return call("scr_bytes_byte_len", "double (ptr)", `ptr ${r.name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic byteLength on non-bytes");
+                }
+                return this.emitBytesLength(e.receiver.type.elem, r.name, true);
             case "get":
                 // Any invalid index traps (the array runtime's discipline).
-                return call("scr_bytes_get", "double (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic get on non-bytes");
+                }
+                return this.emitBytesGet(e.receiver.type.elem, r.name, args[0].name);
             case "slice":
                 return call("scr_bytes_slice", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, true, false);
             case "subarray":
@@ -9119,6 +9459,410 @@ class LlEmitter {
         B.line(`call void @sc_bad_key()`);
         B.terminate(`unreachable`);
     }
+    dynPromiseAdapter(inner) {
+        if (!isRefCounted(inner) || inner.kind === "dyn") {
+            throw new Error(`dynamic promise adapter requires a concrete reference type, got ${typeKey(inner)}`);
+        }
+        const key = typeKey(inner);
+        const existing = this.dynPromiseAdapters.get(key);
+        if (existing)
+            return existing;
+        const sym = `sc_dpa_${this.dynPromiseAdapters.size}`;
+        this.dynPromiseAdapters.set(key, sym);
+        this.declare(`declare ptr @scr_promise_payload_ref(ptr)`);
+        this.declare(`declare void @scr_dyn_release_v(ptr)`);
+        this.declare(`declare zeroext i1 @scr_exc_pending()`);
+        this.declare(`declare void @scr_promise_reject_pending(ptr)`);
+        const B = new BlockBuilder();
+        const dyn = B.tmp();
+        const value = B.tmp();
+        const pending = B.tmp();
+        B.line(`${dyn} = call ptr @scr_promise_payload_ref(ptr %src)`);
+        B.line(`${value} = call ptr @${this.dyn.dynCheckHelper(inner)}(ptr ${dyn}, ptr null)`);
+        B.line(`call void @scr_dyn_release_v(ptr ${dyn})`);
+        B.line(`${pending} = call zeroext i1 @scr_exc_pending()`);
+        const fail = B.newLabel("sra.fail");
+        const ok = B.newLabel("sra.ok");
+        B.condBr(pending, fail, ok);
+        B.startBlock(fail);
+        B.line(`call void @scr_promise_reject_pending(ptr %dst)`);
+        B.terminate(`ret void`);
+        B.startBlock(ok);
+        if (inner.kind === "string") {
+            this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
+            B.line(`call void @scr_promise_fulfill_str(ptr %dst, ptr ${value})`);
+        }
+        else {
+            const rc = vAdapters(this, inner);
+            this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
+            B.line(`call void @scr_promise_fulfill_ref(ptr %dst, ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, inner)})`);
+        }
+        B.terminate(`ret void`);
+        this.resolveThunkDefs.push(`define internal void @${sym}(ptr %dst, ptr %src) ${FN_ATTRS} { ; checked-dynamic promise exit ${key}`, B.render(), `}`, ``);
+        return sym;
+    }
+    streamTypedRefCommitAdapter(t, snapshot) {
+        if (t.kind === "bytes") {
+            const commit = `${snapshot}_commit`;
+            const check = this.dyn.dynCheckHelper(t);
+            this.declare(`declare void @scr_bytes_copy_contents(ptr, ptr)`);
+            this.declare(`declare void @scr_bytes_release(ptr)`);
+            this.resolveThunkDefs.push(`define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`, `entry:`, `  %next = call ptr @${check}(ptr %d, ptr null)`, `  %missing = icmp eq ptr %next, null`, `  br i1 %missing, label %done, label %copy`, `copy:`, `  call void @scr_bytes_copy_contents(ptr %target, ptr %next)`, `  call void @scr_bytes_release(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
+            return `@${commit}`;
+        }
+        if (t.kind === "array") {
+            const commit = `${snapshot}_commit`;
+            const check = this.dyn.dynCheckHelper(t);
+            this.declare(`declare void @scr_arr_release(ptr)`);
+            this.resolveThunkDefs.push(`define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`, `entry:`, `  %next = call ptr @${check}(ptr %d, ptr null)`, `  %missing = icmp eq ptr %next, null`, `  br i1 %missing, label %done, label %swap`, `swap:`, `  %target_len_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 1`, `  %next_len_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 1`, `  %target_len = load i64, ptr %target_len_ptr`, `  %next_len = load i64, ptr %next_len_ptr`, `  store i64 %next_len, ptr %target_len_ptr`, `  store i64 %target_len, ptr %next_len_ptr`, `  %target_cap_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 2`, `  %next_cap_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 2`, `  %target_cap = load i64, ptr %target_cap_ptr`, `  %next_cap = load i64, ptr %next_cap_ptr`, `  store i64 %next_cap, ptr %target_cap_ptr`, `  store i64 %target_cap, ptr %next_cap_ptr`, `  %target_data_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 7`, `  %next_data_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 7`, `  %target_data = load ptr, ptr %target_data_ptr`, `  %next_data = load ptr, ptr %next_data_ptr`, `  store ptr %next_data, ptr %target_data_ptr`, `  store ptr %target_data, ptr %next_data_ptr`, `  call void @scr_arr_release(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
+            return `@${commit}`;
+        }
+        if (t.kind !== "record")
+            return "null";
+        const shape = this.recordsById.get(t.shapeId);
+        if (!shape) {
+            throw new Error(`llvm emitter bug: stream typed-ref commit of unknown shape ${t.shapeId}`);
+        }
+        const commit = `${snapshot}_commit`;
+        const check = this.dyn.dynCheckHelper(t);
+        const lines = [
+            `define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`,
+            `entry:`,
+            `  %next = call ptr @${check}(ptr %d, ptr null)`,
+            `  %missing = icmp eq ptr %next, null`,
+            `  br i1 %missing, label %done, label %swap`,
+            `swap:`,
+        ];
+        const members = [
+            ...shape.fields.map((field, index) => ({
+                index: index + 1,
+                type: llFieldType(field.type),
+                name: field.name,
+            })),
+            ...(shape.indexValue
+                ? [{
+                        index: shape.fields.length + 1,
+                        type: "ptr",
+                        name: "[key: string] overflow",
+                    }]
+                : []),
+        ];
+        members.forEach((member, index) => {
+            lines.push(`  %tp${index} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %target, i64 0, i32 ${member.index}`, `  %np${index} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %next, i64 0, i32 ${member.index}`, `  %old${index} = load ${member.type}, ptr %tp${index} ; ${member.name}`, `  %new${index} = load ${member.type}, ptr %np${index}`, `  store ${member.type} %new${index}, ptr %tp${index}`, `  store ${member.type} %old${index}, ptr %np${index}`);
+        });
+        lines.push(`  call void ${releaseSym(this, t)}(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
+        this.resolveThunkDefs.push(...lines);
+        return `@${commit}`;
+    }
+    /** Box the mutable payload of a union directly, preserving the identity
+     * that AbortSignal reasons and stream chunks expose. Scalar/unit arms use
+     * the ordinary union-to-dyn converter. */
+    liveDynUnionRefAdapter(t) {
+        const key = typeKey(t);
+        const existing = this.liveDynUnionRefAdapters.get(key);
+        if (existing)
+            return existing;
+        const union = this.unionsById.get(t.unionId);
+        if (!union) {
+            throw new Error(`llvm emitter bug: live dyn ref of unknown union ${t.unionId}`);
+        }
+        const mutableArms = union.arms
+            .map((arm, tag) => ({ arm, tag }))
+            .filter(({ arm }) => this.streamTypedRefEligible(arm));
+        if (mutableArms.length === 0) {
+            throw new Error(`llvm emitter bug: live dyn ref of immutable union ${key}`);
+        }
+        const sym = `sc_ldu_${this.liveDynUnionRefAdapters.size}`;
+        this.liveDynUnionRefAdapters.set(key, sym);
+        this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+        const adapters = new Map();
+        for (const { arm, tag } of mutableArms) {
+            const prefix = `${sym}_${tag}`;
+            adapters.set(tag, this.streamTypedRefMaterializeAdapter(arm, { prefix, adapters: new Map() }, `${prefix}_materialize`));
+        }
+        const B = new BlockBuilder();
+        const tagPtr = B.tmp();
+        const tagValue = B.tmp();
+        B.line(`${tagPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 1`);
+        B.line(`${tagValue} = load i32, ptr ${tagPtr}`);
+        const fallback = B.newLabel("ldu.dyn");
+        const armLabels = mutableArms.map(() => B.newLabel("ldu.ref"));
+        B.terminate(`switch i32 ${tagValue}, label %${fallback} [ ${mutableArms.map(({ tag }, index) => `i32 ${tag}, label %${armLabels[index]}`).join(" ")} ]`);
+        mutableArms.forEach(({ arm, tag }, index) => {
+            const adapter = adapters.get(tag);
+            const rc = vAdapters(this, arm);
+            const armKey = typeKey(arm);
+            B.startBlock(armLabels[index]);
+            const payloadPtr = B.tmp();
+            const payload = B.tmp();
+            const boxed = B.tmp();
+            B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 5`);
+            B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
+            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(armKey)}, i64 ${Buffer.byteLength(armKey, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+            B.terminate(`ret ptr ${boxed}`);
+        });
+        B.startBlock(fallback);
+        const boxed = B.tmp();
+        B.line(`${boxed} = call ptr @${this.dyn.toDynHelper(t)}(ptr %u)`);
+        B.terminate(`ret ptr ${boxed}`);
+        this.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %u) ${FN_ATTRS} { ; materialize live union value ${key}`, B.render(), `}`, ``);
+        return sym;
+    }
+    streamTypedRefEligible(t) {
+        return t.kind === "record" || t.kind === "array" || t.kind === "bytes";
+    }
+    streamTypedRefBoxValue(B, t, value, ctx) {
+        const boxed = B.tmp();
+        if (!this.streamTypedRefEligible(t)) {
+            const valueTy = t.kind === "f64"
+                ? "double"
+                : t.kind === "bool"
+                    ? "i1"
+                    : "ptr";
+            B.line(`${boxed} = call ptr @${this.dyn.toDynHelper(t)}(${valueTy} ${value})`);
+            return boxed;
+        }
+        const nested = this.streamTypedRefMaterializeAdapter(t, ctx);
+        const rc = vAdapters(this, t);
+        const key = typeKey(t);
+        this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+        B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, i64 ${Buffer.byteLength(key, "utf8")}, ptr @${nested.snapshot}, ptr ${nested.commit})`);
+        return boxed;
+    }
+    /** LLVM twin of the C stream materializer: mutable reference children
+     * are their own typed capsules, so writes through a nested alias commit
+     * to the nested static source immediately. */
+    streamTypedRefMaterializeAdapter(t, ctx, preferredSnapshot) {
+        const key = typeKey(t);
+        const existing = ctx.adapters.get(key);
+        if (existing)
+            return existing;
+        const snapshot = preferredSnapshot ??
+            `${ctx.prefix}_nested_${ctx.adapters.size}`;
+        const adapter = { snapshot, commit: "null" };
+        ctx.adapters.set(key, adapter);
+        adapter.commit = this.streamTypedRefCommitAdapter(t, snapshot);
+        const B = new BlockBuilder();
+        if (t.kind === "record") {
+            const shape = this.recordsById.get(t.shapeId);
+            if (!shape) {
+                throw new Error(`llvm emitter bug: stream typed-ref materialize of unknown shape ${t.shapeId}`);
+            }
+            /* Keep the ordinary converter for index-signature/listener records;
+             * their source-identity and overflow walks have extra contracts.
+             * Declared-field records and tuples cover the live stream values. */
+            const ordinary = shape.indexValue || shape.fields.some((field) => field.name === "handleEvent" && field.type.kind === "func");
+            if (ordinary) {
+                const out = B.tmp();
+                B.line(`${out} = call ptr @${this.dyn.toDynHelper(t)}(ptr %p)`);
+                B.terminate(`ret ptr ${out}`);
+            }
+            else if (shape.tuple) {
+                this.declare(`declare ptr @scr_dyn_new_arr()`);
+                this.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
+                const out = B.tmp();
+                B.line(`${out} = call ptr @scr_dyn_new_arr()`);
+                const fields = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
+                for (const field of fields) {
+                    const index = shape.fields.indexOf(field) + 1;
+                    const fieldPtr = B.tmp();
+                    const fieldValue = B.tmp();
+                    B.line(`${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`);
+                    B.line(`${fieldValue} = load ${llFieldType(field.type)}, ptr ${fieldPtr}`);
+                    const boxed = this.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
+                    B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${boxed})`);
+                }
+                B.terminate(`ret ptr ${out}`);
+            }
+            else {
+                this.declare(`declare ptr @scr_dyn_new_obj()`);
+                this.declare(`declare void @scr_dyn_obj_set(ptr, ptr, i64, ptr)`);
+                const out = B.tmp();
+                B.line(`${out} = call ptr @scr_dyn_new_obj()`);
+                const byName = new Map(shape.fields.map((field) => [field.name, field]));
+                const order = shape.declaredOrder ?? shape.fields.map((field) => field.name);
+                const inOrder = new Set(order);
+                const fields = [
+                    ...order.map((name) => byName.get(name)).filter((field) => field !== undefined),
+                    ...shape.fields.filter((field) => !inOrder.has(field.name)),
+                ];
+                for (const field of fields) {
+                    const index = shape.fields.indexOf(field) + 1;
+                    const fieldPtr = B.tmp();
+                    const fieldValue = B.tmp();
+                    B.line(`${fieldPtr} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %p, i64 0, i32 ${index}`);
+                    B.line(`${fieldValue} = load ${llFieldType(field.type)}, ptr ${fieldPtr}`);
+                    const boxed = this.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
+                    B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${this.cstr(field.name)}, i64 ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
+                }
+                B.terminate(`ret ptr ${out}`);
+            }
+        }
+        else if (t.kind === "array") {
+            const elem = t.elem;
+            this.declare(`declare ptr @scr_dyn_new_arr()`);
+            this.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
+            this.declare(`declare double @scr_arr_len(ptr)`);
+            const out = B.tmp();
+            B.line(`${out} = call ptr @scr_dyn_new_arr()`);
+            const len = B.tmp();
+            B.line(`${len} = call double @scr_arr_len(ptr %p)`);
+            const iSlot = B.slot();
+            B.entryAllocas.push(`${iSlot} = alloca double`);
+            B.line(`store double ${f64Lit(0)}, ptr ${iSlot}`);
+            const condition = B.newLabel("strm.c");
+            const body = B.newLabel("strm.b");
+            const done = B.newLabel("strm.e");
+            B.br(condition);
+            B.startBlock(condition);
+            const index = B.tmp();
+            const more = B.tmp();
+            B.line(`${index} = load double, ptr ${iSlot}`);
+            B.line(`${more} = fcmp olt double ${index}, ${len}`);
+            B.condBr(more, body, done);
+            B.startBlock(body);
+            let value;
+            if (elem.kind === "f64" || elem.kind === "bool") {
+                const valueTy = elem.kind === "f64" ? "double" : "i1";
+                this.declare(`declare ${elem.kind === "bool" ? "zeroext i1" : valueTy} @scr_arr_get_${elem.kind}(ptr, double)`);
+                value = B.tmp();
+                B.line(`${value} = call ${valueTy} @scr_arr_get_${elem.kind}(ptr %p, double ${index})`);
+            }
+            else {
+                this.declare(`declare ptr @scr_arr_get_ref(ptr, double)`);
+                value = B.tmp();
+                B.line(`${value} = call ptr @scr_arr_get_ref(ptr %p, double ${index}) ; +1`);
+            }
+            const boxed = this.streamTypedRefBoxValue(B, elem, value, ctx);
+            B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${boxed})`);
+            if (isRefCounted(elem)) {
+                B.line(`call void ${releaseSym(this, elem)}(ptr ${value})`);
+            }
+            const next = B.tmp();
+            B.line(`${next} = fadd double ${index}, ${f64Lit(1)}`);
+            B.line(`store double ${next}, ptr ${iSlot}`);
+            B.br(condition);
+            B.startBlock(done);
+            B.terminate(`ret ptr ${out}`);
+        }
+        else {
+            const out = B.tmp();
+            B.line(`${out} = call ptr @${this.dyn.toDynHelper(t)}(ptr %p)`);
+            B.terminate(`ret ptr ${out}`);
+        }
+        this.resolveThunkDefs.push(`define internal ptr @${snapshot}(ptr %p) ${FN_ATTRS} { ; materialize live stream value ${key}`, B.render(), `}`, ``);
+        return adapter;
+    }
+    streamFromArrayAdapter(t) {
+        const elem = t.elem;
+        const key = typeKey(elem);
+        const existing = this.streamFromArrayAdapters.get(key);
+        if (existing)
+            return existing;
+        const sym = `sc_sfa_${this.streamFromArrayAdapters.size}`;
+        this.streamFromArrayAdapters.set(key, sym);
+        const B = new BlockBuilder();
+        const unionDef = elem.kind === "union"
+            ? this.unionsById.get(elem.unionId)
+            : undefined;
+        if (elem.kind === "union" && !unionDef) {
+            throw new Error(`llvm emitter bug: streamFrom of unknown union ${elem.unionId}`);
+        }
+        const unionRefArms = unionDef?.arms
+            .map((arm, tag) => ({ arm, tag }))
+            .filter(({ arm }) => isRefCounted(arm) && arm.kind !== "dyn" && arm.kind !== "string") ?? [];
+        const typedRef = isRefCounted(elem) &&
+            elem.kind !== "dyn" &&
+            elem.kind !== "string" &&
+            elem.kind !== "union";
+        const snapshot = `${sym}_materialize`;
+        let value;
+        if (elem.kind === "f64") {
+            this.declare(`declare double @scr_arr_get_f64(ptr, double)`);
+            value = B.tmp();
+            B.line(`${value} = call double @scr_arr_get_f64(ptr %a, double %i)`);
+        }
+        else if (elem.kind === "bool") {
+            this.declare(`declare zeroext i1 @scr_arr_get_bool(ptr, double)`);
+            value = B.tmp();
+            B.line(`${value} = call i1 @scr_arr_get_bool(ptr %a, double %i)`);
+        }
+        else {
+            this.declare(`declare ptr @scr_arr_get_ref(ptr, double)`);
+            value = B.tmp();
+            B.line(`${value} = call ptr @scr_arr_get_ref(ptr %a, double %i) ; +1`);
+        }
+        let boxed;
+        const valueTy = elem.kind === "f64" ? "double" : elem.kind === "bool" ? "i1" : "ptr";
+        if (elem.kind === "union") {
+            if (unionRefArms.length === 0) {
+                boxed = B.tmp();
+                B.line(`${boxed} = call ptr @${this.dyn.toDynHelper(elem)}(ptr ${value})`);
+            }
+            else {
+                this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+                const boxedSlot = B.slot();
+                B.entryAllocas.push(`${boxedSlot} = alloca ptr`);
+                const tagPtr = B.tmp();
+                const tagValue = B.tmp();
+                B.line(`${tagPtr} = getelementptr inbounds %ScrUnion, ptr ${value}, i64 0, i32 1`);
+                B.line(`${tagValue} = load i32, ptr ${tagPtr}`);
+                const fallback = B.newLabel("sfa.union.dyn");
+                const join = B.newLabel("sfa.union.join");
+                const armLabels = unionRefArms.map(() => B.newLabel("sfa.union.ref"));
+                B.terminate(`switch i32 ${tagValue}, label %${fallback} [ ${unionRefArms.map(({ tag }, i) => `i32 ${tag}, label %${armLabels[i]}`).join(" ")} ]`);
+                unionRefArms.forEach(({ arm, tag }, i) => {
+                    const armKey = typeKey(arm);
+                    const armSnapshot = `${snapshot}_${tag}`;
+                    const armCommit = this.streamTypedRefCommitAdapter(arm, armSnapshot);
+                    const rc = vAdapters(this, arm);
+                    B.startBlock(armLabels[i]);
+                    const payloadPtr = B.tmp();
+                    const payload = B.tmp();
+                    const armBoxed = B.tmp();
+                    B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr ${value}, i64 0, i32 5`);
+                    B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
+                    B.line(`${armBoxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(armKey)}, i64 ${Buffer.byteLength(armKey, "utf8")}, ptr @${armSnapshot}, ptr ${armCommit})`);
+                    B.line(`store ptr ${armBoxed}, ptr ${boxedSlot}`);
+                    B.br(join);
+                    this.resolveThunkDefs.push(`define internal ptr @${armSnapshot}(ptr %p) ${FN_ATTRS} { ; materialize stream union arm ${armKey}`, `entry:`, `  %d = call ptr @${this.dyn.toDynHelper(arm)}(ptr %p)`, `  ret ptr %d`, `}`, ``);
+                });
+                B.startBlock(fallback);
+                const dynBoxed = B.tmp();
+                B.line(`${dynBoxed} = call ptr @${this.dyn.toDynHelper(elem)}(ptr ${value})`);
+                B.line(`store ptr ${dynBoxed}, ptr ${boxedSlot}`);
+                B.br(join);
+                B.startBlock(join);
+                boxed = B.tmp();
+                B.line(`${boxed} = load ptr, ptr ${boxedSlot}`);
+            }
+        }
+        else if (typedRef) {
+            boxed = B.tmp();
+            const rc = vAdapters(this, elem);
+            const keyPtr = this.cstr(key);
+            let commit;
+            if (this.streamTypedRefEligible(elem)) {
+                commit = this.streamTypedRefMaterializeAdapter(elem, { prefix: snapshot, adapters: new Map() }, snapshot).commit;
+            }
+            else {
+                commit = this.streamTypedRefCommitAdapter(elem, snapshot);
+                this.resolveThunkDefs.push(`define internal ptr @${snapshot}(ptr %p) ${FN_ATTRS} { ; materialize stream element ${key}`, `entry:`, `  %d = call ptr @${this.dyn.toDynHelper(elem)}(ptr %p)`, `  ret ptr %d`, `}`, ``);
+            }
+            this.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, i64, ptr, ptr)`);
+            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyPtr}, i64 ${Buffer.byteLength(key, "utf8")}, ptr @${snapshot}, ptr ${commit})`);
+        }
+        else {
+            boxed = B.tmp();
+            B.line(`${boxed} = call ptr @${this.dyn.toDynHelper(elem)}(${valueTy} ${value})`);
+        }
+        if (isRefCounted(elem)) {
+            B.line(`call void ${releaseSym(this, elem)}(ptr ${value})`);
+        }
+        B.terminate(`ret ptr ${boxed}`);
+        this.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %a, double %i) ${FN_ATTRS} { ; ReadableStream.from array<${key}>`, B.render(), `}`, ``);
+        return sym;
+    }
     /** The claimed libCall slice: args are BORROWED (owned temps of the
      * current frame), refcounted results come back +1. LLVM types derive
      * from the call site's IR types (exactly the contract the C prototypes
@@ -9131,6 +9875,70 @@ class LlEmitter {
         // Loop liveness first (one table for generic and special shapes).
         if (USES_TIMERS_LIB_FNS.has(e.fn))
             this.usesTimers = true;
+        if (e.fn === "fetch.responseText" || e.fn === "fetch.responseBytes") {
+            if (e.type.kind !== "promise") {
+                throw new Error(`llvm emitter bug: ${e.fn} result`);
+            }
+            const response = this.emitExpr(e.args[0]);
+            const runtimeFn = e.fn === "fetch.responseText"
+                ? "scr_fetch_response_text"
+                : "scr_fetch_response_bytes";
+            this.declare(`declare ptr @${runtimeFn}(ptr)`);
+            this.declare(`declare ptr @scr_promise_new()`);
+            this.declare(`declare void @scr_promise_race_add(ptr, ptr, ptr)`);
+            const sourceRaw = B.tmp();
+            B.line(`${sourceRaw} = call ptr @${runtimeFn}(ptr ${response.name})`);
+            const source = this.own({
+                name: sourceRaw,
+                type: { kind: "promise", inner: DYN },
+            });
+            const resultRaw = B.tmp();
+            B.line(`${resultRaw} = call ptr @scr_promise_new()`);
+            const result = this.own({ name: resultRaw, type: e.type });
+            B.line(`call void @scr_promise_race_add(ptr ${result.name}, ptr ${source.name}, ptr @${this.dynPromiseAdapter(e.type.inner)})`);
+            return result;
+        }
+        if (e.fn === "fetch.readerRead") {
+            if (e.type.kind !== "promise" || e.type.inner.kind !== "record") {
+                throw new Error("llvm emitter bug: fetch.readerRead result");
+            }
+            const reader = this.emitExpr(e.args[0]);
+            this.declare(`declare ptr @scr_fetch_reader_read(ptr)`);
+            this.declare(`declare ptr @scr_promise_new()`);
+            this.declare(`declare void @scr_promise_race_add(ptr, ptr, ptr)`);
+            const sourceRaw = B.tmp();
+            B.line(`${sourceRaw} = call ptr @scr_fetch_reader_read(ptr ${reader.name})`);
+            const source = this.own({
+                name: sourceRaw,
+                type: { kind: "promise", inner: DYN },
+            });
+            const resultRaw = B.tmp();
+            B.line(`${resultRaw} = call ptr @scr_promise_new()`);
+            const result = this.own({ name: resultRaw, type: e.type });
+            B.line(`call void @scr_promise_race_add(ptr ${result.name}, ptr ${source.name}, ptr @${this.dynPromiseAdapter(e.type.inner)})`);
+            return result;
+        }
+        if (e.fn === "fetch.streamFrom") {
+            const source = this.emitExpr(e.args[0]);
+            let sym = "scr_fetch_stream_from";
+            let extra = "";
+            if (source.type.kind === "array") {
+                sym = "scr_fetch_stream_from_array";
+                extra = `, ptr @${this.streamFromArrayAdapter(source.type)}`;
+            }
+            else if (source.type.kind === "bytes") {
+                sym = "scr_fetch_stream_from_bytes";
+            }
+            else if (source.type.kind === "string") {
+                sym = "scr_fetch_stream_from_string";
+            }
+            this.declare(`declare ptr @${sym}(ptr${source.type.kind === "array" ? ", ptr" : ""})`);
+            const raw = B.tmp();
+            B.line(`${raw} = call ptr @${sym}(ptr ${source.name}${extra})`);
+            const out = this.own({ name: raw, type: e.type });
+            this.emitPendingCheck();
+            return out;
+        }
         // The handful with non-generic shapes first.
         if (e.fn === "error.argTypeThrow") {
             // Always throws with the runtime-rendered Received tail (the