@scriptc/compiler 0.2.1 → 0.2.3

package/dist/backend/llvm/dyn.js

@@ -2,7 +2,7 @@ import { typedRefConstructor } from "./shapes.js";
 import { BYTES_ELEM_NUM, f64Lit } from "./common.js";
 import { InternalCompilerError } from "../../errors.js";
 import { DYN_HANDLE_KINDS, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
-import { dynDesc } from "../../ir/analysis.js";
+import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
@@ -60,7 +60,7 @@ export class LlDyn {
     }
     /** Branch to a variant only after its literal discriminator and complete
      * structure match. Use the same path for predicates and builders. */
-    unionArmMatch(B, def, tag, yes, no) {
+    unionArmMatch(B, def, tag, yes, no, preserveRefs = false) {
         const guard = def.discriminant?.cases.find((candidate) => candidate.tag === tag);
         if (guard && def.discriminant) {
             const structure = B.newLabel("du.shape");
@@ -81,7 +81,7 @@ export class LlDyn {
             B.startBlock(structure);
         }
         const matches = B.tmp();
-        B.line(`${matches} = call zeroext i1 @${this.dynMatchHelper(def.arms[tag])}(ptr %d)`);
+        B.line(`${matches} = call zeroext i1 @${this.dynMatchHelper(def.arms[tag], preserveRefs)}(ptr %d)`);
         B.condBr(matches, yes, no);
     }
     get S() { return this.host.sizeType; }
@@ -93,7 +93,7 @@ export class LlDyn {
     }
     /** The value LLVM type of a dynCheck result / toDyn operand for `t`. */
     valTy(t) {
-        return t.kind === "f64" || t.kind === "date" ? "double" : t.kind === "bool" ? "i1" : "ptr";
+        return t.kind === "f64" || t.kind === "date" || t.kind === "procStream" ? "double" : t.kind === "bool" ? "i1" : "ptr";
     }
     collectionDynOps(t) {
         const key = typeKey(t);
@@ -108,9 +108,25 @@ export class LlDyn {
             const ty = this.valTy(type);
             const unpack = ty === "double" ? "bitcast i64 %slot to double" : ty === "i1" ? "trunc i64 %slot to i1" : "inttoptr i64 %slot to ptr";
             const pack = ty === "double" ? "bitcast double %value to i64" : ty === "i1" ? "zext i1 %value to i64" : "ptrtoint ptr %value to i64";
-            const box = this.toDynHelper(type);
+            // Collection reads expose the original mutable element, including
+            // records/arrays inside unions, rather than a detached dyn snapshot.
+            const B = new BlockBuilder();
+            B.line(`%value = ${unpack}`);
+            if (type.kind === "union" && this.host.unionsById.get(type.unionId)?.arms.some(streamTypedRefEligible)) {
+                B.line(`%result = call ptr @${this.host.liveDynUnionRefAdapter(type)}(ptr %value)`);
+            }
+            else if (type.kind === "record" || type.kind === "array") {
+                const adapter = this.host.liveDynRefAdapter(type);
+                const rc = vAdapters(this.host, type);
+                const typeId = typeKey(type);
+                B.line(`%result = call ptr ${typedRefConstructor(this.host, type)}(ptr %value, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.host.cstr(typeId)}, ${this.S} ${Buffer.byteLength(typeId, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+            }
+            else {
+                B.line(`%result = call ptr @${this.toDynHelper(type)}(${ty} %value)`);
+            }
+            B.terminate("ret ptr %result");
             const unbox = this.dynCheckHelper(type);
-            this.defs.push(`define internal ptr @${name}_${role}_box(i64 %slot) ${FN_ATTRS} {`, `  %value = ${unpack}`, `  %result = call ptr @${box}(${ty} %value)`, `  ret ptr %result`, `}`, "", `define internal i64 @${name}_${role}_unbox(ptr %d) ${FN_ATTRS} {`, `  %value = call ${ty === "i1" ? "zeroext i1" : ty} @${unbox}(ptr %d, ptr null)`, `  %result = ${pack}`, `  ret i64 %result`, `}`, "");
+            this.defs.push(`define internal ptr @${name}_${role}_box(i64 %slot) ${FN_ATTRS} {`, B.render(), `}`, "", `define internal i64 @${name}_${role}_unbox(ptr %d) ${FN_ATTRS} {`, `  %value = call ${ty === "i1" ? "zeroext i1" : ty} @${unbox}(ptr %d, ptr null)`, `  %result = ${pack}`, `  ret i64 %result`, `}`, "");
         };
         emitSlot(keyType, "key");
         emitSlot(valueType, "value");
@@ -326,13 +342,14 @@ export class LlDyn {
         return matched;
     }
     /** `sc_dm_<n>(ptr d) -> i1` — does this dyn fit T? Never throws. */
-    dynMatchHelper(t) {
+    dynMatchHelper(t, preserveRefs = false) {
         const key = typeKey(t);
-        const existing = this.dynMatchers.get(key);
+        const matcherKey = preserveRefs ? `identity:${key}` : key;
+        const existing = this.dynMatchers.get(matcherKey);
         if (existing)
             return existing;
         const name = `sc_dm_${this.dynMatchers.size}`;
-        this.dynMatchers.set(key, name);
+        this.dynMatchers.set(matcherKey, name);
         const B = new BlockBuilder();
         if (isRefCounted(t) && t.kind !== "dyn") {
             const matched = this.typedRefMatches(B, t);
@@ -353,12 +370,17 @@ export class LlDyn {
             const lPlain = B.newLabel("dm.tr.plain");
             B.condBr(capsule, lCapsule, lPlain);
             B.startBlock(lCapsule);
-            const materialized = B.tmp();
-            const matched = B.tmp();
-            B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
-            B.line(`${matched} = call zeroext i1 @${name}(ptr ${materialized})`);
-            B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
-            B.terminate(`ret i1 ${matched}`);
+            if (preserveRefs) {
+                B.terminate(`ret i1 false`);
+            }
+            else {
+                const materialized = B.tmp();
+                const matched = B.tmp();
+                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                B.line(`${matched} = call zeroext i1 @${name}(ptr ${materialized})`);
+                B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
+                B.terminate(`ret i1 ${matched}`);
+            }
             B.startBlock(lPlain);
         }
         const kindIs = (k) => {
@@ -406,6 +428,13 @@ export class LlDyn {
             case "promise":
                 kindIs(DYN_KIND.PROMISE);
                 break;
+            case "procStream": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_process_stdio_is(ptr)`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_dyn_process_stdio_is(ptr %d)`);
+                B.terminate(`ret i1 ${matched}`);
+                break;
+            }
             case "symbol":
                 kindIs(DYN_KIND.SYMBOL);
                 break;
@@ -436,7 +465,12 @@ export class LlDyn {
                 break;
             }
             case "func":
-                kindIs(DYN_KIND.FUNC);
+                this.host.declare(`declare zeroext i1 @scr_dyn_is_callable(ptr)`);
+                {
+                    const matched = B.tmp();
+                    B.line(`${matched} = call zeroext i1 @scr_dyn_is_callable(ptr %d)`);
+                    B.terminate(`ret i1 ${matched}`);
+                }
                 break;
             case "classval": {
                 this.host.declare(`declare zeroext i1 @scr_dyn_class_is(ptr, ptr)`);
@@ -495,7 +529,7 @@ export class LlDyn {
                     for (const [i, f] of byIndex.entries()) {
                         const e = this.itemAt(B, items, `${i}`);
                         const m = B.tmp();
-                        B.line(`${m} = call zeroext i1 @${this.dynMatchHelper(f.type)}(ptr ${e})`);
+                        B.line(`${m} = call zeroext i1 @${this.dynMatchHelper(f.type, preserveRefs)}(ptr ${e})`);
                         const ln = B.newLabel("dm.i");
                         B.condBr(m, ln, fail);
                         B.startBlock(ln);
@@ -526,7 +560,7 @@ export class LlDyn {
                     this.host.declare(`declare void @scr_dyn_release(ptr)`);
                     this.pendingBail(B, "dm.read", () => B.line(`call void @scr_dyn_release(ptr ${m})`), "i1 false");
                     const ok = B.tmp();
-                    B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(f.type)}(ptr ${m})`);
+                    B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(f.type, preserveRefs)}(ptr ${m})`);
                     B.line(`call void @scr_dyn_release(ptr ${m})`);
                     B.condBr(ok, lNext, fail);
                     B.startBlock(lNext);
@@ -562,7 +596,7 @@ export class LlDyn {
                             B.startBlock(lNo);
                         }
                         const ok = B.tmp();
-                        B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(shape.indexValue)}(ptr ${ent.value})`);
+                        B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(shape.indexValue, preserveRefs)}(ptr ${ent.value})`);
                         const lOk = B.newLabel("dm.vo");
                         B.condBr(ok, lOk, fail);
                         B.startBlock(lOk);
@@ -574,7 +608,7 @@ export class LlDyn {
                 break;
             }
             case "array": {
-                const m = this.dynMatchHelper(t.elem);
+                const m = this.dynMatchHelper(t.elem, preserveRefs);
                 const fail = B.newLabel("dm.f");
                 const kd = this.kindOf(B, "%d");
                 const isArr = B.tmp();
@@ -584,7 +618,16 @@ export class LlDyn {
                 B.startBlock(l0);
                 const n = this.lenOf(B, "%d");
                 const items = this.itemsOf(B, "%d");
-                this.i64Loop(B, "dm.el", n, (i) => {
+                this.i64Loop(B, "dm.el", n, (i, brNext) => {
+                    this.host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
+                    const present = B.tmp();
+                    B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
+                    const valueLabel = B.newLabel("dm.present");
+                    const holeLabel = B.newLabel("dm.hole");
+                    B.condBr(present, valueLabel, holeLabel);
+                    B.startBlock(holeLabel);
+                    brNext();
+                    B.startBlock(valueLabel);
                     const e = this.itemAt(B, items, i);
                     const ok = B.tmp();
                     B.line(`${ok} = call zeroext i1 @${m}(ptr ${e})`);
@@ -605,7 +648,7 @@ export class LlDyn {
                 const yes = B.newLabel("dm.y");
                 for (let tag = 0; tag < def.arms.length; tag++) {
                     const ln = B.newLabel("dm.n");
-                    this.unionArmMatch(B, def, tag, yes, ln);
+                    this.unionArmMatch(B, def, tag, yes, ln, preserveRefs);
                     B.startBlock(ln);
                 }
                 B.terminate(`ret i1 false`);
@@ -643,13 +686,14 @@ export class LlDyn {
     /** `sc_dc_<n>(ptr d, ptr path) -> T` — validate the checked-dynamic tree against T and
      * BUILD the typed value (+1), or throw the catchable path-annotated
      * TypeError and return a dummy with the pending flag set. */
-    dynCheckHelper(t) {
+    dynCheckHelper(t, preserveRefs = false) {
         const key = typeKey(t);
-        const existing = this.dynBuilders.get(key);
+        const builderKey = preserveRefs ? `identity:${key}` : key;
+        const existing = this.dynBuilders.get(builderKey);
         if (existing)
             return existing;
         const name = `sc_dc_${this.dynBuilders.size}`;
-        this.dynBuilders.set(key, name);
+        this.dynBuilders.set(builderKey, name);
         const host = this.host;
         const retTy = this.valTy(t);
         const dummy = retTy === "double" ? `double ${f64Lit(0)}` : retTy === "i1" ? "i1 false" : "ptr null";
@@ -686,7 +730,19 @@ export class LlDyn {
             B.line(`${ref} = call ptr @scr_dyn_typed_ref_unbox(ptr %d)`);
             B.terminate(`ret ptr ${ref}`);
             B.startBlock(lNext);
-            if (t.kind !== "union") {
+            if (t.kind !== "union" && preserveRefs) {
+                const kind = this.kindOf(B, "%d");
+                const capsule = B.tmp();
+                B.line(`${capsule} = icmp eq i32 ${kind}, ${DYN_KIND.TYPED_REF}`);
+                const reject = B.newLabel("dc.identity.reject");
+                const plain = B.newLabel("dc.identity.plain");
+                B.condBr(capsule, reject, plain);
+                B.startBlock(reject);
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${host.cstr("reference with its original layout")}, ptr %d)`);
+                B.terminate(`ret ${dummy}`);
+                B.startBlock(plain);
+            }
+            else if (t.kind !== "union") {
                 host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
                 host.declare(`declare ptr @scr_dyn_typed_ref_cached_cast(ptr, ptr, ${host.sizeType})`);
                 host.declare(`declare void @scr_dyn_typed_ref_cache_cast(ptr, ptr, ${host.sizeType}, ptr, ptr, ptr, i1)`);
@@ -896,6 +952,13 @@ export class LlDyn {
                 B.terminate(`ret ptr ${retained}`);
                 break;
             }
+            case "procStream": {
+                host.declare(`declare double @scr_dyn_process_stdio_fd(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call double @scr_dyn_process_stdio_fd(ptr %d, ptr %path)`);
+                B.terminate(`ret double ${r}`);
+                break;
+            }
             case "bytes": {
                 host.declare(`declare zeroext i1 @scr_dyn_bytes_is(ptr, i32)`);
                 const matched = B.tmp();
@@ -1042,7 +1105,7 @@ export class LlDyn {
                         setPath(null, `${i}`);
                         const e = this.itemAt(B, items, `${i}`);
                         const v = B.tmp();
-                        B.line(`${v} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type)}(ptr ${e}, ptr ${pathSlot})`);
+                        B.line(`${v} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type, preserveRefs)}(ptr ${e}, ptr ${pathSlot})`);
                         storeInto(f.name, f.type, v);
                         this.pendingBail(B, "dct", releaseR, "ptr null");
                     });
@@ -1085,7 +1148,7 @@ export class LlDyn {
                     this.pendingBail(B, "dcr.read", () => { B.line(`call void @scr_dyn_release(ptr ${m})`); releaseR(); }, "ptr null");
                     setPath(f.name, "0");
                     const value = B.tmp();
-                    B.line(`${value} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type)}(ptr ${m}, ptr ${pathSlot})`);
+                    B.line(`${value} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type, preserveRefs)}(ptr ${m}, ptr ${pathSlot})`);
                     B.line(`call void @scr_dyn_release(ptr ${m})`);
                     storeInto(f.name, f.type, value);
                     this.pendingBail(B, "dcr", releaseR, "ptr null");
@@ -1133,7 +1196,7 @@ export class LlDyn {
                         else {
                             setPathKeyPtr(ent.key);
                             ev = B.tmp();
-                            B.line(`${ev} = call ${this.valTy(iv)} @${this.dynCheckHelper(iv)}(ptr ${ent.value}, ptr ${pathSlot})`);
+                            B.line(`${ev} = call ${this.valTy(iv)} @${this.dynCheckHelper(iv, preserveRefs)}(ptr ${ent.value}, ptr ${pathSlot})`);
                             this.pendingBail(B, "dcv", releaseR, "ptr null");
                         }
                         const ek = B.tmp();
@@ -1158,7 +1221,7 @@ export class LlDyn {
             }
             case "array": {
                 const elem = t.elem;
-                const c = this.dynCheckHelper(elem);
+                const c = this.dynCheckHelper(elem, preserveRefs);
                 requireKind(DYN_KIND.ARR, "dca");
                 const n = this.lenOf(B, "%d");
                 const a = B.tmp();
@@ -1170,6 +1233,22 @@ export class LlDyn {
                 const accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
                 host.declare(`declare double @scr_arr_push_${acc}(ptr, ${acc === "bool" ? "i1 zeroext" : accTy})`);
                 this.i64Loop(B, "dca", n, (i) => {
+                    host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
+                    const present = B.tmp();
+                    B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
+                    const valueLabel = B.newLabel("dca.present");
+                    const holeLabel = B.newLabel("dca.hole");
+                    const doneLabel = B.newLabel("dca.done");
+                    B.condBr(present, valueLabel, holeLabel);
+                    B.startBlock(holeLabel);
+                    host.declare(`declare void @scr_arr_set_len(ptr, double)`);
+                    const index = B.tmp();
+                    const length = B.tmp();
+                    B.line(`${index} = uitofp ${this.S} ${i} to double`);
+                    B.line(`${length} = fadd double ${index}, 1.0`);
+                    B.line(`call void @scr_arr_set_len(ptr ${a}, double ${length})`);
+                    B.br(doneLabel);
+                    B.startBlock(valueLabel);
                     const pp = B.tmp();
                     const kp = B.tmp();
                     const ip = B.tmp();
@@ -1188,6 +1267,8 @@ export class LlDyn {
                     }, "ptr null");
                     const pushed = B.tmp();
                     B.line(`${pushed} = call double @scr_arr_push_${acc}(ptr ${a}, ${accTy} ${v})`);
+                    B.br(doneLabel);
+                    B.startBlock(doneLabel);
                 });
                 B.terminate(`ret ptr ${a}`);
                 break;
@@ -1201,18 +1282,18 @@ export class LlDyn {
                 def.arms.forEach((arm, i) => {
                     const lHit = B.newLabel("dcu.h");
                     const lNext = B.newLabel("dcu.n");
-                    this.unionArmMatch(B, def, i, lHit, lNext);
+                    this.unionArmMatch(B, def, i, lHit, lNext, preserveRefs);
                     B.startBlock(lHit);
                     if (arm.kind === "undefinedT" || arm.kind === "nullT") {
                         // A matched unit arm builds nothing: THE interned immortal
                         // instance (rc == SIZE_MAX — no retain owed).
                         B.terminate(`ret ptr ${host.unitInstanceRef(t.unionId, i)}`);
                     }
-                    else if (arm.kind === "f64") {
+                    else if (arm.kind === "f64" || arm.kind === "procStream") {
                         host.declare(`declare ptr @scr_union_new_f64(i32, double)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call double @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+                        B.line(`${x} = call double @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
                         B.line(`${u} = call ptr @scr_union_new_f64(i32 ${i}, double ${x})`);
                         B.terminate(`ret ptr ${u}`);
                     }
@@ -1220,7 +1301,7 @@ export class LlDyn {
                         host.declare(`declare ptr @scr_union_new_bool(i32, i1 zeroext)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call zeroext i1 @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+                        B.line(`${x} = call zeroext i1 @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
                         B.line(`${u} = call ptr @scr_union_new_bool(i32 ${i}, i1 ${x})`);
                         B.terminate(`ret ptr ${u}`);
                     }
@@ -1229,12 +1310,17 @@ export class LlDyn {
                         host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call ptr @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+                        B.line(`${x} = call ptr @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
                         B.line(`${u} = call ptr @scr_union_new_ref(i32 ${i}, ptr ${x}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`);
                         B.terminate(`ret ptr ${u}`);
                     }
                     B.startBlock(lNext);
                 });
+                if (preserveRefs) {
+                    B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${host.cstr("reference with its original layout")}, ptr %d)`);
+                    B.terminate(`ret ptr null`);
+                    break;
+                }
                 // Preserve an exact typed-ref arm above. If no producer tag matched,
                 // retry the union against the ordinary copy-based structural
                 // snapshot (the compiler's width-coercion stance, rather than a
@@ -1316,7 +1402,22 @@ export class LlDyn {
                 // caps[0] obj-box owns the dyn value (untraced).
                 const adapter = this.dynFuncAdapterHelper(t);
                 const sigLit = host.cstr(key);
-                requireKind(DYN_KIND.FUNC, "dcf");
+                const lWrap = B.newLabel("dcf.w");
+                host.declare(`declare zeroext i1 @scr_dyn_is_callable(ptr)`);
+                const callable = B.tmp();
+                const valid = B.newLabel("dcf.k");
+                const invalid = B.newLabel("dcf.f");
+                B.line(`${callable} = call zeroext i1 @scr_dyn_is_callable(ptr %d)`);
+                B.condBr(callable, valid, invalid);
+                B.startBlock(invalid);
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                B.terminate(`ret ${dummy}`);
+                B.startBlock(valid);
+                const direct = B.tmp();
+                const lSignature = B.newLabel("dcf.signature");
+                B.line(`${direct} = icmp eq i32 ${this.kindOf(B, "%d")}, ${DYN_KIND.FUNC}`);
+                B.condBr(direct, lSignature, lWrap);
+                B.startBlock(lSignature);
                 host.declare(`declare i32 @strcmp(ptr, ptr)`);
                 const sigp = B.tmp();
                 const sig = B.tmp();
@@ -1327,7 +1428,6 @@ export class LlDyn {
                 B.line(`${cmp} = call i32 @strcmp(ptr ${sig}, ptr ${sigLit})`);
                 B.line(`${same} = icmp eq i32 ${cmp}, 0`);
                 const lSame = B.newLabel("dcf.s");
-                const lWrap = B.newLabel("dcf.w");
                 B.condBr(same, lSame, lWrap);
                 B.startBlock(lSame);
                 host.declare(`declare ptr @scr_closure_retain_v(ptr)`);
@@ -1347,14 +1447,14 @@ export class LlDyn {
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
                 const a = B.tmp();
                 B.line(`${a} = call ptr @scr_closure_new(ptr @${adapter}, ${host.sizeType} 1)`);
-                const sourceClosure = this.payloadOf(B, "%d", "ptr");
-                const sourceKind = B.tmp();
+                host.declare(`declare i32 @scr_dyn_function_kind(ptr)`);
                 const functionKind = B.tmp();
                 const targetKind = B.tmp();
-                B.line(`${sourceKind} = getelementptr inbounds %ScrClosure, ptr ${sourceClosure}, i64 0, i32 4`);
-                B.line(`${functionKind} = load i32, ptr ${sourceKind}`);
+                B.line(`${functionKind} = call i32 @scr_dyn_function_kind(ptr %d)`);
                 B.line(`${targetKind} = getelementptr inbounds %ScrClosure, ptr ${a}, i64 0, i32 4`);
-                B.line(`store i32 ${functionKind}, ptr ${targetKind}`);
+                const adapterKind = B.tmp();
+                B.line(`${adapterKind} = or i32 ${functionKind}, 8 ; preserves the checked callable in caps[0]`);
+                B.line(`store i32 ${adapterKind}, ptr ${targetKind}`);
                 const box = B.tmp();
                 B.line(`${box} = call ptr @scr_box_new_obj(ptr @scr_dyn_retain_v, ptr @scr_dyn_release_v, ptr @scr_dyn_trace_v)`);
                 const capp = B.tmp();
@@ -1454,6 +1554,13 @@ export class LlDyn {
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
+            case "procStream": {
+                host.declare(`declare ptr @scr_process_stdio(double)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_process_stdio(double %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "string": {
                 host.declare(`declare ptr @scr_dyn_new_str(ptr)`);
                 const r = B.tmp();
@@ -1690,9 +1797,19 @@ export class LlDyn {
                     const state = B.tmp();
                     const undefinedState = B.tmp();
                     const undefinedLabel = B.newLabel("tda.undefined");
+                    const holeLabel = B.newLabel("tda.hole");
+                    const presentLabel = B.newLabel("tda.present");
                     const valueLabel = B.newLabel("tda.value");
                     const doneLabel = B.newLabel("tda.done");
                     B.line(`${state} = call double @scr_arr_state(ptr %v, double ${i})`);
+                    const hole = B.tmp();
+                    B.line(`${hole} = fcmp oeq double ${state}, 0.0`); // SCR_ARR_HOLE
+                    B.condBr(hole, holeLabel, presentLabel);
+                    B.startBlock(holeLabel);
+                    host.declare(`declare void @scr_dyn_arr_push_hole(ptr)`);
+                    B.line(`call void @scr_dyn_arr_push_hole(ptr ${d})`);
+                    B.br(doneLabel);
+                    B.startBlock(presentLabel);
                     B.line(`${undefinedState} = fcmp oeq double ${state}, 2.0`); // SCR_ARR_UNDEFINED
                     B.terminate(`br i1 ${undefinedState}, label %${undefinedLabel}, label %${valueLabel}`);
                     B.startBlock(undefinedLabel);
@@ -1762,13 +1879,12 @@ export class LlDyn {
                         B.line(`${r} = call ptr @scr_dyn_new_null()`);
                         B.terminate(`ret ptr ${r}`);
                     }
-                    else if (arm.kind === "f64") {
+                    else if (arm.kind === "f64" || arm.kind === "procStream") {
                         host.declare(`declare double @scr_union_get_f64(ptr)`);
-                        host.declare(`declare ptr @scr_dyn_new_num(double)`);
                         const x = B.tmp();
                         const r = B.tmp();
                         B.line(`${x} = call double @scr_union_get_f64(ptr %v)`);
-                        B.line(`${r} = call ptr @scr_dyn_new_num(double ${x})`);
+                        B.line(`${r} = call ptr @${this.toDynHelper(arm)}(double ${x})`);
                         B.terminate(`ret ptr ${r}`);
                     }
                     else if (arm.kind === "bool") {
@@ -1885,13 +2001,13 @@ export class LlDyn {
                 fulfill(dv);
                 break;
             }
+            case "procStream":
             case "f64": {
                 host.declare(`declare double @scr_promise_payload_f64(ptr)`);
-                host.declare(`declare ptr @scr_dyn_new_num(double)`);
                 const x = B.tmp();
                 const dv = B.tmp();
                 B.line(`${x} = call double @scr_promise_payload_f64(ptr %src)`);
-                B.line(`${dv} = call ptr @scr_dyn_new_num(double ${x})`);
+                B.line(`${dv} = call ptr @${this.toDynHelper(inner)}(double ${x})`);
                 fulfill(dv);
                 break;
             }