@scriptc/compiler 0.1.7 → 0.2.1

package/dist/backend/llvm/dyn.js

@@ -1,6 +1,8 @@
+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, undefinedArmTag } from "../../ir/analysis.js";
+import { dynDesc } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
@@ -17,6 +19,7 @@ const DYN_HANDLE_TAG_NUM = {
     http2Stream: 5,
     httpClientReq: 6,
     child: 16,
+    fileHandle: 17,
 };
 export const DYN_KIND = {
     NULL: 0,
@@ -32,13 +35,10 @@ export const DYN_KIND = {
     PROMISE: 10,
     JSVAL: 11, /* SCR_DYN_JSVAL — island values held by reference */
     TYPED_REF: 12, /* SCR_DYN_TYPED_REF — static Web-stream transit capsule */
+    PROXY: 13,
+    BIGINT: 14,
+    SYMBOL: 15,
 };
-/** Exact double literal (the emitter's f64Lit — the walkers' copy). */
-function f64Lit(n) {
-    const buf = new ArrayBuffer(8);
-    new DataView(buf).setFloat64(0, n);
-    return `0x${[...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase()}`;
-}
 const FN_ATTRS = "#0";
 export class LlDyn {
     host;
@@ -49,13 +49,41 @@ export class LlDyn {
     dynFuncBoxes = new Map();
     dynFuncAdapters = new Map();
     promiseDynAdapters = new Map();
+    mapDynOps = new Map();
     dynToStrFn = null;
     caughtToDynFn = null;
+    helperMemo = new Map();
     /** Emitted function definitions, in interning order. */
     defs = [];
     constructor(host) {
         this.host = host;
     }
+    /** 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) {
+        const guard = def.discriminant?.cases.find((candidate) => candidate.tag === tag);
+        if (guard && def.discriminant) {
+            const structure = B.newLabel("du.shape");
+            const field = this.host.internLiteral(def.discriminant.field);
+            guard.values.forEach((value, index) => {
+                const suffix = typeof value === "string" ? "str" : typeof value === "boolean" ? "bool" : "num";
+                const ty = typeof value === "string" ? "ptr" : typeof value === "boolean" ? "i1" : "double";
+                const operand = typeof value === "string" ? this.host.internLiteral(value)
+                    : typeof value === "boolean" ? String(value) : f64Lit(value);
+                this.host.declare(`declare zeroext i1 @scr_dyn_field_eq_${suffix}(ptr, ptr, ${ty}${ty === "i1" ? " zeroext" : ""})`);
+                const matches = B.tmp();
+                B.line(`${matches} = call zeroext i1 @scr_dyn_field_eq_${suffix}(ptr %d, ptr ${field}, ${ty} ${operand})`);
+                const next = index === guard.values.length - 1 ? no : B.newLabel("du.literal");
+                B.condBr(matches, structure, next);
+                if (index !== guard.values.length - 1)
+                    B.startBlock(next);
+            });
+            B.startBlock(structure);
+        }
+        const matches = B.tmp();
+        B.line(`${matches} = call zeroext i1 @${this.dynMatchHelper(def.arms[tag])}(ptr %d)`);
+        B.condBr(matches, yes, no);
+    }
     get S() { return this.host.sizeType; }
     abiOffset(native64, wasm32) {
         return this.S === "i32" ? wasm32 : native64;
@@ -65,7 +93,29 @@ export class LlDyn {
     }
     /** The value LLVM type of a dynCheck result / toDyn operand for `t`. */
     valTy(t) {
-        return t.kind === "f64" ? "double" : t.kind === "bool" ? "i1" : "ptr";
+        return t.kind === "f64" || t.kind === "date" ? "double" : t.kind === "bool" ? "i1" : "ptr";
+    }
+    collectionDynOps(t) {
+        const key = typeKey(t);
+        const prior = this.mapDynOps.get(key);
+        if (prior)
+            return prior;
+        const name = `sc_map_dyn_${this.mapDynOps.size}`;
+        this.mapDynOps.set(key, name);
+        const keyType = t.kind === "map" ? t.key : t.elem;
+        const valueType = t.kind === "map" ? t.value : { kind: "f64" };
+        const emitSlot = (type, role) => {
+            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);
+            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`, `}`, "");
+        };
+        emitSlot(keyType, "key");
+        emitSlot(valueType, "value");
+        this.defs.push(`@${name} = internal constant { ptr, ptr, ptr, ptr, ptr, ptr } { ptr ${this.host.cstr(key)}, ptr @${name}_key_box, ptr @${name}_key_unbox, ptr @${this.dynMatchHelper(keyType)}, ptr @${name}_value_box, ptr @${name}_value_unbox }`, "");
+        return name;
     }
     /* ── dyn node plumbing ─────────────────────────────────────────────── */
     /** Loads a dyn node's kind tag (after the size_t rc word). */
@@ -118,12 +168,12 @@ export class LlDyn {
         B.line(`${e} = load ptr, ptr ${p}`);
         return e;
     }
-    /** Object entry field addresses: entries + i*24 (+0 key, +8 key_len,
-     * +16 value). */
+    /** Object entry field addresses: entries + i*sizeof(ScrDynEntry), with
+     * key, key_len, and value at offsets 0, 8, and 16 on 64-bit targets. */
     entryAt(B, entries, i) {
         const off = B.tmp();
         const base = B.tmp();
-        B.line(`${off} = mul ${this.S} ${i}, ${this.abiOffset(24, 12)} ; sizeof(ScrDynEntry)`);
+        B.line(`${off} = mul ${this.S} ${i}, ${this.abiOffset(48, 24)} ; sizeof(ScrDynEntry)`);
         B.line(`${base} = getelementptr inbounds i8, ptr ${entries}, ${this.S} ${off}`);
         const key = B.tmp();
         B.line(`${key} = load ptr, ptr ${base}`);
@@ -170,6 +220,13 @@ export class LlDyn {
         B.line(`${t} = call ptr @scr_dyn_obj_get(ptr ${d}, ptr ${this.host.cstr(key)}, ${this.S} ${len}) ; .${llvmCommentText(key)}`);
         return t;
     }
+    /** Ordinary property lookup, including inherited data and accessors (+1). */
+    objReadLit(B, d, key) {
+        this.host.declare(`declare ptr @scr_dyn_obj_read(ptr, ptr, ${this.S})`);
+        const value = B.tmp();
+        B.line(`${value} = call ptr @scr_dyn_obj_read(ptr ${d}, ptr ${this.host.cstr(key)}, ${this.S} ${Buffer.byteLength(key, "utf8")})`);
+        return value;
+    }
     /** Appends an ScrStr's bytes into a ScrJsonBuf (walkers' putScrStr). */
     putScrStr(B, buf, s) {
         this.host.declare(`declare void @scr_jb_putc(ptr, i8)`);
@@ -245,6 +302,29 @@ export class LlDyn {
         B.startBlock(lk);
     }
     /* ── dynMatchHelper (walkers.ts, ported) ──────────────────────── */
+    /** Native subclass capsules also satisfy a checked base-class slot.
+     * Class layouts share their base prefix, so unboxing retains the same
+     * pointer and virtual dispatch still uses the object's original vtable. */
+    typedRefMatches(B, t) {
+        this.host.declare(`declare zeroext i1 @scr_dyn_typed_ref_is(ptr, ptr, ${this.S})`);
+        const types = isDynTypedRefType(t)
+            ? this.host.classSubtypes(t.className).map((className) => ({ kind: "object", className }))
+            : [t];
+        let matched = "false";
+        for (const type of types) {
+            const key = typeKey(type);
+            const next = B.tmp();
+            B.line(`${next} = call zeroext i1 @scr_dyn_typed_ref_is(ptr %d, ptr ${this.host.cstr(key)}, ${this.S} ${Buffer.byteLength(key, "utf8")})`);
+            if (matched === "false")
+                matched = next;
+            else {
+                const either = B.tmp();
+                B.line(`${either} = or i1 ${matched}, ${next}`);
+                matched = either;
+            }
+        }
+        return matched;
+    }
     /** `sc_dm_<n>(ptr d) -> i1` — does this dyn fit T? Never throws. */
     dynMatchHelper(t) {
         const key = typeKey(t);
@@ -255,9 +335,7 @@ export class LlDyn {
         this.dynMatchers.set(key, name);
         const B = new BlockBuilder();
         if (isRefCounted(t) && t.kind !== "dyn") {
-            this.host.declare(`declare zeroext i1 @scr_dyn_typed_ref_is(ptr, ptr, ${this.S})`);
-            const matched = B.tmp();
-            B.line(`${matched} = call zeroext i1 @scr_dyn_typed_ref_is(ptr %d, ptr ${this.host.cstr(key)}, ${this.S} ${Buffer.byteLength(key, "utf8")})`);
+            const matched = this.typedRefMatches(B, t);
             const lRef = B.newLabel("dm.tr");
             const lNext = B.newLabel("dm.nt");
             B.condBr(matched, lRef, lNext);
@@ -290,6 +368,47 @@ export class LlDyn {
             B.terminate(`ret i1 ${r}`);
         };
         switch (t.kind) {
+            case "date": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_native_date_is(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_date_is(ptr %d)`);
+                B.terminate(`ret i1 ${r}`);
+                break;
+            }
+            case "url":
+            case "searchParams": {
+                const native = t.kind === "url" ? "url" : "search_params";
+                this.host.declare(`declare zeroext i1 @scr_dyn_native_${native}_is(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_${native}_is(ptr %d)`);
+                B.terminate(`ret i1 ${r}`);
+                break;
+            }
+            case "regex": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_native_regex_is(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_regex_is(ptr %d)`);
+                B.terminate(`ret i1 ${r}`);
+                break;
+            }
+            case "map":
+            case "set": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_native_collection_is(ptr, i32, ptr)`);
+                const r = B.tmp();
+                const typed = t.kind === "map" ? t.key.kind !== "dyn" || t.value.kind !== "dyn" : t.elem.kind !== "dyn";
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_collection_is(ptr %d, i32 ${t.kind === "map" ? 1 : 0}, ptr ${typed ? this.host.cstr(typeKey(t)) : "null"})`);
+                B.terminate(`ret i1 ${r}`);
+                break;
+            }
+            case "bigint":
+                kindIs(DYN_KIND.BIGINT);
+                break;
+            case "promise":
+                kindIs(DYN_KIND.PROMISE);
+                break;
+            case "symbol":
+                kindIs(DYN_KIND.SYMBOL);
+                break;
             case "f64":
                 kindIs(DYN_KIND.NUM);
                 break;
@@ -309,14 +428,27 @@ export class LlDyn {
                 // An `unknown` target: every dyn value fits, undefined included.
                 B.terminate(`ret i1 true`);
                 break;
-            case "bytes":
-                if (t.elem !== "u8")
-                    throw new InternalCompilerError(`llvm emitter bug: dynMatch of bytes<${t.elem}>`);
-                kindIs(DYN_KIND.BYTES);
+            case "bytes": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_bytes_is(ptr, i32)`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_dyn_bytes_is(ptr %d, i32 ${BYTES_ELEM_NUM[t.elem]})`);
+                B.terminate(`ret i1 ${matched}`);
                 break;
+            }
             case "func":
                 kindIs(DYN_KIND.FUNC);
                 break;
+            case "classval": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_class_is(ptr, ptr)`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_dyn_class_is(ptr %d, ptr ${this.host.cstr(key)})`);
+                B.terminate(`ret i1 ${matched}`);
+                break;
+            }
+            case "generator":
+                // Only an exact native capsule carries these channel types.
+                B.terminate(`ret i1 false`);
+                break;
             case "object": {
                 if (t.className !== "%Error") {
                     // Exact class capsules returned true before materialization.
@@ -376,28 +508,26 @@ export class LlDyn {
                 const isObj = B.tmp();
                 B.line(`${isObj} = icmp eq i32 ${kd}, ${DYN_KIND.OBJ}`);
                 const l0 = B.newLabel("dm.o");
-                B.condBr(isObj, l0, fail);
+                let readable = isObj;
+                if (!shape.indexValue) {
+                    const proxy = B.tmp();
+                    readable = B.tmp();
+                    B.line(`${proxy} = icmp eq i32 ${kd}, ${DYN_KIND.PROXY}`);
+                    B.line(`${readable} = or i1 ${isObj}, ${proxy}`);
+                }
+                B.condBr(readable, l0, fail);
                 B.startBlock(l0);
                 // dyn ('unknown') fields match ANY value, present or missing.
                 for (const f of shape.fields) {
                     if (f.type.kind === "dyn")
                         continue;
-                    const m = this.objGetLit(B, "%d", f.name);
-                    const has = B.tmp();
-                    B.line(`${has} = icmp ne ptr ${m}, null`);
-                    const lTest = B.newLabel("dm.t");
+                    const m = this.objReadLit(B, "%d", f.name);
                     const lNext = B.newLabel("dm.n");
-                    if (undefinedArmTag(f.type, this.host.unionsById) >= 0) {
-                        // Optional-flavored field: a MISSING key is the undefined arm
-                        // (a match); a PRESENT key must fit the union as usual.
-                        B.condBr(has, lTest, lNext);
-                    }
-                    else {
-                        B.condBr(has, lTest, fail);
-                    }
-                    B.startBlock(lTest);
+                    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(`call void @scr_dyn_release(ptr ${m})`);
                     B.condBr(ok, lNext, fail);
                     B.startBlock(lNext);
                 }
@@ -473,11 +603,9 @@ export class LlDyn {
                     throw new InternalCompilerError(`llvm emitter bug: dynCheck of unknown union ${t.unionId}`);
                 // Arms in canonical order; any full match answers true.
                 const yes = B.newLabel("dm.y");
-                for (const arm of def.arms) {
-                    const ok = B.tmp();
-                    B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(arm)}(ptr %d)`);
+                for (let tag = 0; tag < def.arms.length; tag++) {
                     const ln = B.newLabel("dm.n");
-                    B.condBr(ok, yes, ln);
+                    this.unionArmMatch(B, def, tag, yes, ln);
                     B.startBlock(ln);
                 }
                 B.terminate(`ret i1 false`);
@@ -528,11 +656,28 @@ export class LlDyn {
         host.declare(`declare void @scr_dyn_check_fail(ptr, ptr, ptr)`);
         const want = host.cstr(dynDesc(t, this.host.recordsById, this.host.unionsById));
         const B = new BlockBuilder();
+        if (t.kind === "classval") {
+            host.declare(`declare ptr @scr_dyn_class_check(ptr, ptr, ptr)`);
+            const checked = B.tmp();
+            B.line(`${checked} = call ptr @scr_dyn_class_check(ptr %d, ptr ${host.cstr(key)}, ptr %path)`);
+            B.terminate(`ret ptr ${checked}`);
+            this.defs.push(`define internal ptr @${name}(ptr %d, ptr %path) ${FN_ATTRS} {`, B.render(), `}`, ``);
+            return name;
+        }
         if (isRefCounted(t) && t.kind !== "dyn") {
-            host.declare(`declare zeroext i1 @scr_dyn_typed_ref_is(ptr, ptr, ${host.sizeType})`);
             host.declare(`declare ptr @scr_dyn_typed_ref_unbox(ptr)`);
-            const matched = B.tmp();
-            B.line(`${matched} = call zeroext i1 @scr_dyn_typed_ref_is(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")})`);
+            if (t.kind === "object" && t.className === "%Error") {
+                host.declare(`declare ptr @scr_errdyn_err_of(ptr)`);
+                const error = B.tmp(), found = B.tmp();
+                B.line(`${error} = call ptr @scr_errdyn_err_of(ptr %d)`);
+                B.line(`${found} = icmp ne ptr ${error}, null`);
+                const yes = B.newLabel("dc.error"), next = B.newLabel("dc.noterror");
+                B.condBr(found, yes, next);
+                B.startBlock(yes);
+                B.terminate(`ret ptr ${error}`);
+                B.startBlock(next);
+            }
+            const matched = this.typedRefMatches(B, t);
             const lRef = B.newLabel("dc.tr");
             const lNext = B.newLabel("dc.nt");
             B.condBr(matched, lRef, lNext);
@@ -544,7 +689,7 @@ export class LlDyn {
             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)`);
+                host.declare(`declare void @scr_dyn_typed_ref_cache_cast(ptr, ptr, ${host.sizeType}, ptr, ptr, ptr, i1)`);
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
                 const rc = vAdapters(host, t);
                 const kind = this.kindOf(B, "%d");
@@ -642,7 +787,7 @@ export class LlDyn {
                     B.line(`call void ${releaseSym(host, t)}(ptr ${checked})`);
                     B.terminate(`ret ptr ${cached}`);
                     B.startBlock(lCache);
-                    B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release})`);
+                    B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release}, i1 ${traceAdapter(host, t) !== null ? "true" : "false"})`);
                     B.terminate(`ret ptr ${checked}`);
                 }
                 else {
@@ -650,7 +795,7 @@ export class LlDyn {
                     const lReturn = B.newLabel("dc.tr.ret");
                     B.condBr(ok, lCache, lReturn);
                     B.startBlock(lCache);
-                    B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release})`);
+                    B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release}, i1 ${traceAdapter(host, t) !== null ? "true" : "false"})`);
                     B.br(lReturn);
                     B.startBlock(lReturn);
                     B.terminate(`ret ptr ${checked}`);
@@ -672,6 +817,56 @@ export class LlDyn {
             B.startBlock(lo);
         };
         switch (t.kind) {
+            case "date": {
+                host.declare(`declare double @scr_dyn_native_date_value(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call double @scr_dyn_native_date_value(ptr %d)`);
+                B.terminate(`ret double ${r}`);
+                break;
+            }
+            case "url":
+            case "searchParams": {
+                const native = t.kind === "url" ? "url" : "search_params";
+                host.declare(`declare ptr @scr_dyn_native_${native}_check(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_${native}_check(ptr %d, ptr %path)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "regex": {
+                host.declare(`declare ptr @scr_dyn_native_regex_check(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_regex_check(ptr %d, ptr %path)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "map":
+            case "set": {
+                host.declare(`declare ptr @scr_dyn_native_collection_check(ptr, i32, ptr, ptr)`);
+                const r = B.tmp();
+                const typed = t.kind === "map" ? t.key.kind !== "dyn" || t.value.kind !== "dyn" : t.elem.kind !== "dyn";
+                B.line(`${r} = call ptr @scr_dyn_native_collection_check(ptr %d, i32 ${t.kind === "map" ? 1 : 0}, ptr ${typed ? host.cstr(typeKey(t)) : "null"}, ptr %path)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "bigint": {
+                requireKind(DYN_KIND.BIGINT, "dc");
+                host.declare(`declare ptr @scr_bigint_retain(ptr)`);
+                const v = this.payloadOf(B, "%d", "ptr");
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_bigint_retain(ptr ${v})`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "symbol": {
+                requireKind(DYN_KIND.SYMBOL, "dc");
+                host.declare(`declare ptr @scr_sym_retain(ptr)`);
+                const v = this.payloadOf(B, "%d", "ptr");
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_sym_retain(ptr ${v})`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "f64": {
                 requireKind(DYN_KIND.NUM, "dc");
                 const v = this.payloadOf(B, "%d", "double");
@@ -702,16 +897,44 @@ export class LlDyn {
                 break;
             }
             case "bytes": {
-                // `u as Uint8Array`: kind check, then a fresh COPY out.
-                if (t.elem !== "u8")
-                    throw new InternalCompilerError(`llvm emitter bug: dynCheck of bytes<${t.elem}>`);
-                requireKind(DYN_KIND.BYTES, "dc");
-                host.declare(`declare ptr @scr_dyn_bytes_copy_out(ptr)`);
+                host.declare(`declare zeroext i1 @scr_dyn_bytes_is(ptr, i32)`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_dyn_bytes_is(ptr %d, i32 ${BYTES_ELEM_NUM[t.elem]})`);
+                const yes = B.newLabel("dc.bytes");
+                const no = B.newLabel("dc.bytes.fail");
+                B.condBr(matched, yes, no);
+                B.startBlock(no);
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                B.terminate(`ret ptr null`);
+                B.startBlock(yes);
+                host.declare(`declare ptr @scr_dyn_bytes_unbox(ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_bytes_copy_out(ptr %d)`);
+                B.line(`${r} = call ptr @scr_dyn_bytes_unbox(ptr %d)`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
+            case "generator":
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                B.terminate(`ret ptr null`);
+                break;
+            case "promise": {
+                requireKind(DYN_KIND.PROMISE, "dc");
+                host.declare(`declare ptr @scr_promise_retain(ptr)`);
+                const promise = this.payloadOf(B, "%d", "ptr"), retained = B.tmp();
+                if (t.inner.kind !== "dyn") {
+                    host.declare(`declare ptr @scr_promise_new()`);
+                    host.declare(`declare void @scr_promise_race_add(ptr, ptr, ptr)`);
+                    B.line(`${retained} = call ptr @scr_promise_new()`);
+                    host.declare(`declare void @scr_promise_share_identity(ptr, ptr)`);
+                    B.line(`call void @scr_promise_share_identity(ptr ${retained}, ptr ${promise})`);
+                    B.line(`call void @scr_promise_race_add(ptr ${retained}, ptr ${promise}, ptr @${host.dynPromiseAdapter(t.inner)})`);
+                    B.terminate(`ret ptr ${retained}`);
+                    break;
+                }
+                B.line(`${retained} = call ptr @scr_promise_retain(ptr ${promise})`);
+                B.terminate(`ret ptr ${retained}`);
+                break;
+            }
             case "object": {
                 // The %Error extraction (an instanceof-Error narrow on unknown):
                 // validate the checked-dynamic tree's error encoding — the reserved "%error" marker
@@ -826,64 +1049,46 @@ export class LlDyn {
                     B.terminate(`ret ptr %r0`);
                     break;
                 }
-                requireKind(DYN_KIND.OBJ, "dcr");
+                if (shape.indexValue)
+                    requireKind(DYN_KIND.OBJ, "dcr");
+                else {
+                    const kind = this.kindOf(B, "%d"), object = B.tmp(), proxy = B.tmp(), readable = B.tmp();
+                    B.line(`${object} = icmp eq i32 ${kind}, ${DYN_KIND.OBJ}`);
+                    B.line(`${proxy} = icmp eq i32 ${kind}, ${DYN_KIND.PROXY}`);
+                    B.line(`${readable} = or i1 ${object}, ${proxy}`);
+                    const ok = B.newLabel("dcr.object"), fail = B.newLabel("dcr.fail");
+                    B.condBr(readable, ok, fail);
+                    B.startBlock(fail);
+                    B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                    B.terminate(`ret ptr null`);
+                    B.startBlock(ok);
+                }
+                if (shape.fields.length === 0 && !shape.indexValue) {
+                    const sourceAccessor = `${this.toDynHelper(t)}_source_access`;
+                    const rc = vAdapters(host, t);
+                    host.declare(`declare ptr @scr_dyn_obj_source_cast(ptr, ptr, ptr)`);
+                    const source = B.tmp();
+                    const found = B.tmp();
+                    const lSource = B.newLabel("dcr.source");
+                    const lCopy = B.newLabel("dcr.copy");
+                    B.line(`${source} = call ptr @scr_dyn_obj_source_cast(ptr %d, ptr @${sourceAccessor}, ptr ${rc.retain})`);
+                    B.line(`${found} = icmp ne ptr ${source}, null`);
+                    B.condBr(found, lSource, lCopy);
+                    B.startBlock(lSource);
+                    B.terminate(`ret ptr ${source}`);
+                    B.startBlock(lCopy);
+                }
                 B.line(`%r0 = call ptr @${mangleRecordNew(t.shapeId)}()`);
                 for (const f of shape.fields) {
-                    const fieldWant = host.cstr(dynDesc(f.type, this.host.recordsById, this.host.unionsById));
-                    const utag = f.type.kind === "union" ? undefinedArmTag(f.type, host.unionsById) : -1;
-                    const m = this.objGetLit(B, "%d", f.name);
-                    if (f.type.kind === "dyn") {
-                        // An `unknown` field: a present key passes through, a missing
-                        // one IS the undefined dyn value. Go through the dyn builder so
-                        // a Web-stream typed-ref capsule cannot escape inside a checked
-                        // record field.
-                        const has = B.tmp();
-                        B.line(`${has} = icmp ne ptr ${m}, null`);
-                        const sel = B.tmp();
-                        const u = this.undef(B);
-                        B.line(`${sel} = select i1 ${has}, ptr ${m}, ptr ${u}`);
-                        const value = B.tmp();
-                        B.line(`${value} = call ptr @${this.dynCheckHelper(f.type)}(ptr ${sel}, ptr ${pathSlot})`);
-                        storeInto(f.name, f.type, value);
-                    }
-                    else if (utag >= 0 && f.type.kind === "union") {
-                        const unit = host.unitInstanceRef(f.type.unionId, utag);
-                        const has = B.tmp();
-                        B.line(`${has} = icmp ne ptr ${m}, null`);
-                        const lp = B.newLabel("dcr.p");
-                        const la = B.newLabel("dcr.a");
-                        const lj = B.newLabel("dcr.j");
-                        B.condBr(has, lp, la);
-                        B.startBlock(la);
-                        storeInto(f.name, f.type, unit); // absent key -> the undefined arm
-                        B.br(lj);
-                        B.startBlock(lp);
-                        setPath(f.name, "0");
-                        const v = B.tmp();
-                        B.line(`${v} = call ptr @${this.dynCheckHelper(f.type)}(ptr ${m}, ptr ${pathSlot})`);
-                        storeInto(f.name, f.type, v);
-                        this.pendingBail(B, "dcr", releaseR, "ptr null");
-                        B.br(lj);
-                        B.startBlock(lj);
-                    }
-                    else {
-                        const has = B.tmp();
-                        B.line(`${has} = icmp ne ptr ${m}, null`);
-                        const lp = B.newLabel("dcr.p");
-                        const la = B.newLabel("dcr.a");
-                        B.condBr(has, lp, la);
-                        B.startBlock(la);
-                        setPath(f.name, "0");
-                        B.line(`call void @scr_dyn_check_fail(ptr ${pathSlot}, ptr ${fieldWant}, ptr null)`);
-                        releaseR();
-                        B.terminate(`ret ptr null`);
-                        B.startBlock(lp);
-                        setPath(f.name, "0");
-                        const v = B.tmp();
-                        B.line(`${v} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type)}(ptr ${m}, ptr ${pathSlot})`);
-                        storeInto(f.name, f.type, v);
-                        this.pendingBail(B, "dcr", releaseR, "ptr null");
-                    }
+                    const m = this.objReadLit(B, "%d", f.name);
+                    host.declare(`declare void @scr_dyn_release(ptr)`);
+                    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(`call void @scr_dyn_release(ptr ${m})`);
+                    storeInto(f.name, f.type, value);
+                    this.pendingBail(B, "dcr", releaseR, "ptr null");
                 }
                 // Index-signature shapes CAPTURE undeclared keys into the
                 // overflow map.
@@ -994,12 +1199,9 @@ export class LlDyn {
                 // Arms in CANONICAL order, first FULL match wins. The matched
                 // arm's builder can no longer fail.
                 def.arms.forEach((arm, i) => {
-                    const m = this.dynMatchHelper(arm);
-                    const hit = B.tmp();
-                    B.line(`${hit} = call zeroext i1 @${m}(ptr %d)`);
                     const lHit = B.newLabel("dcu.h");
                     const lNext = B.newLabel("dcu.n");
-                    B.condBr(hit, lHit, lNext);
+                    this.unionArmMatch(B, def, i, lHit, lNext);
                     B.startBlock(lHit);
                     if (arm.kind === "undefinedT" || arm.kind === "nullT") {
                         // A matched unit arm builds nothing: THE interned immortal
@@ -1039,7 +1241,7 @@ export class LlDyn {
                 // live narrowed alias).
                 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)`);
+                host.declare(`declare void @scr_dyn_typed_ref_cache_cast(ptr, ptr, ${host.sizeType}, ptr, ptr, ptr, i1)`);
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
                 host.declare(`declare void @scr_union_release(ptr)`);
                 const rc = vAdapters(host, t);
@@ -1078,13 +1280,14 @@ export class LlDyn {
                 const lCache = B.newLabel("dcu.put");
                 B.condBr(hasCached, lRefresh, lCache);
                 B.startBlock(lRefresh);
-                [
+                const fields = [
                     [1, "i32", "tag"],
                     [2, "ptr", "retain"],
                     [3, "ptr", "release"],
                     [4, "ptr", "trace"],
                     [5, "i64", "slot"],
-                ].forEach(([index, fieldType, fieldName]) => {
+                ];
+                fields.forEach(([index, fieldType, fieldName]) => {
                     const cachedPtr = B.tmp();
                     const checkedPtr = B.tmp();
                     const oldValue = B.tmp();
@@ -1099,7 +1302,7 @@ export class LlDyn {
                 B.line(`call void @scr_union_release(ptr ${checked})`);
                 B.terminate(`ret ptr ${cached}`);
                 B.startBlock(lCache);
-                B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release})`);
+                B.line(`call void @scr_dyn_typed_ref_cache_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr ${checked}, ptr ${rc.retain}, ptr ${rc.release}, i1 ${traceAdapter(host, t) !== null ? "true" : "false"})`);
                 B.terminate(`ret ptr ${checked}`);
                 B.startBlock(lFail);
                 B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
@@ -1140,11 +1343,20 @@ export class LlDyn {
                 host.declare(`declare ptr @scr_box_new_obj(ptr, ptr, ptr)`);
                 host.declare(`declare void @scr_box_set_ref(ptr, ptr)`);
                 host.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
+                host.declare(`declare void @scr_dyn_trace_v(ptr, ptr, ptr)`);
                 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();
+                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(`${targetKind} = getelementptr inbounds %ScrClosure, ptr ${a}, i64 0, i32 4`);
+                B.line(`store i32 ${functionKind}, 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 null)`);
+                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();
                 B.line(`${capp} = getelementptr inbounds %ScrClosure, ptr ${a}, i64 1 ; caps[0]`);
                 B.line(`store ptr ${box}, ptr ${capp}`);
@@ -1186,6 +1398,48 @@ export class LlDyn {
         const B = new BlockBuilder();
         let sourceAccessor = null;
         switch (t.kind) {
+            case "url":
+            case "searchParams": {
+                const native = t.kind === "url" ? "url" : "search_params";
+                host.declare(`declare ptr @scr_dyn_native_${native}(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_${native}(ptr %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "regex": {
+                host.declare(`declare ptr @scr_dyn_native_regex(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_regex(ptr %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "map":
+            case "set": {
+                host.declare(`declare ptr @scr_dyn_native_${t.kind}(ptr)`);
+                if (t.kind === "map" ? t.key.kind !== "dyn" || t.value.kind !== "dyn" : t.elem.kind !== "dyn") {
+                    host.declare(`declare void @scr_map_dyn_attach(ptr, ptr)`);
+                    B.line(`call void @scr_map_dyn_attach(ptr %v, ptr @${this.collectionDynOps(t)})`);
+                }
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_${t.kind}(ptr %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "bigint": {
+                host.declare(`declare ptr @scr_dyn_new_bigint(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_new_bigint(ptr %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
+            case "symbol": {
+                host.declare(`declare ptr @scr_dyn_new_symbol(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_new_symbol(ptr %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "f64": {
                 host.declare(`declare ptr @scr_dyn_new_num(double)`);
                 const r = B.tmp();
@@ -1207,9 +1461,22 @@ export class LlDyn {
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
+            case "generator": {
+                // Keep the suspended fiber and its channels by identity. Member
+                // calls are generated from the exact capsule key by the frontend.
+                const rc = vAdapters(host, t);
+                const r = B.tmp();
+                const snapshot = `${name}_snapshot`;
+                const message = "property reflection on a native generator through an untyped value is not supported yet";
+                host.declare(`declare void @scr_throw_error_msg_code(i32, ptr, ${host.sizeType}, ptr)`);
+                this.defs.push(`define internal ptr @${snapshot}(ptr %v) ${FN_ATTRS} {`, `entry:`, `  call void @scr_throw_error_msg_code(i32 0, ptr ${host.cstr(message)}, ${host.sizeType} ${Buffer.byteLength(message, "utf8")}, ptr ${host.cstr("SC1071")})`, `  ret ptr null`, `}`, ``);
+                B.line(`${r} = call ptr ${typedRefConstructor(host, t)}(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${snapshot}, ptr null)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "object": {
                 const className = t.className;
-                if (className === "%Error") {
+                if (host.isErrorClass(className)) {
                     host.declare(`declare ptr @scr_dyn_from_error(ptr)`);
                     const r = B.tmp();
                     B.line(`${r} = call ptr @scr_dyn_from_error(ptr %v)`);
@@ -1222,9 +1489,8 @@ export class LlDyn {
                 const adapter = host.liveDynRefAdapter(t);
                 const rc = vAdapters(host, t);
                 const keyLit = host.cstr(typeKey(t));
-                host.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${host.sizeType}, ptr, ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_new_typed_ref(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyLit}, ${host.sizeType} ${Buffer.byteLength(typeKey(t), "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+                B.line(`${r} = call ptr ${typedRefConstructor(host, t)}(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyLit}, ${host.sizeType} ${Buffer.byteLength(typeKey(t), "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -1233,6 +1499,13 @@ export class LlDyn {
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
+            case "classval": {
+                host.declare(`declare ptr @scr_dyn_new_class(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_new_class(ptr %v, ptr ${host.cstr(key)})`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "func": {
                 const r = B.tmp();
                 B.line(`${r} = call ptr @${this.dynFuncBoxHelper(t)}(ptr %v, ptr null)`);
@@ -1240,11 +1513,9 @@ export class LlDyn {
                 break;
             }
             case "bytes": {
-                if (t.elem !== "u8")
-                    throw new InternalCompilerError(`llvm emitter bug: to-dyn of bytes<${t.elem}>`);
-                host.declare(`declare ptr @scr_dyn_new_bytes_copy(ptr)`);
+                host.declare(`declare ptr @scr_dyn_new_bytes(ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_new_bytes_copy(ptr %v)`);
+                B.line(`${r} = call ptr @scr_dyn_new_bytes(ptr %v)`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -1268,7 +1539,7 @@ export class LlDyn {
                 host.declare(`declare void @scr_dyn_obj_set(ptr, ptr, ${host.sizeType}, ptr)`);
                 // CYCLE-CAPABLE shapes guard the deep copy: enter TRAPS on a value
                 // already being converted (a cyclic value has no finite dyn copy —
-                // SEMANTICS.md; the C emitter's contract exactly).
+                // SEMANTICS.md).
                 const cyclicRec = traceAdapter(host, t) !== null;
                 if (cyclicRec) {
                     host.declare(`declare void @scr_dyn_from_enter(ptr)`);
@@ -1290,12 +1561,14 @@ export class LlDyn {
                     }
                     if (cyclicRec)
                         B.line(`call void @scr_dyn_from_leave()`);
+                    host.declare(`declare ptr @scr_dyn_mark_snapshot(ptr)`);
+                    B.line(`call ptr @scr_dyn_mark_snapshot(ptr ${d})`);
                     B.terminate(`ret ptr ${d}`);
                     break;
                 }
                 const d = B.tmp();
                 const carriesListenerIdentity = shape.fields.some((f) => f.name === "handleEvent" && f.type.kind === "func");
-                if (carriesListenerIdentity) {
+                if ((shape.fields.length === 0 && !shape.indexValue) || carriesListenerIdentity) {
                     const rc = vAdapters(host, t);
                     sourceAccessor = {
                         name: `${name}_source_access`,
@@ -1391,6 +1664,8 @@ export class LlDyn {
                 }
                 if (cyclicRec)
                     B.line(`call void @scr_dyn_from_leave()`);
+                host.declare(`declare ptr @scr_dyn_mark_snapshot(ptr)`);
+                B.line(`call ptr @scr_dyn_mark_snapshot(ptr ${d})`);
                 B.terminate(`ret ptr ${d}`);
                 break;
             }
@@ -1411,6 +1686,20 @@ export class LlDyn {
                 const len = B.tmp();
                 B.line(`${len} = call double @scr_arr_len(ptr %v)`);
                 B.countedLoop(len, (i) => {
+                    host.declare(`declare double @scr_arr_state(ptr, double)`);
+                    const state = B.tmp();
+                    const undefinedState = B.tmp();
+                    const undefinedLabel = B.newLabel("tda.undefined");
+                    const valueLabel = B.newLabel("tda.value");
+                    const doneLabel = B.newLabel("tda.done");
+                    B.line(`${state} = call double @scr_arr_state(ptr %v, double ${i})`);
+                    B.line(`${undefinedState} = fcmp oeq double ${state}, 2.0`); // SCR_ARR_UNDEFINED
+                    B.terminate(`br i1 ${undefinedState}, label %${undefinedLabel}, label %${valueLabel}`);
+                    B.startBlock(undefinedLabel);
+                    const retained = this.retainDyn(B, this.undef(B));
+                    B.line(`call void @scr_dyn_arr_push(ptr ${d}, ptr ${retained})`);
+                    B.terminate(`br label %${doneLabel}`);
+                    B.startBlock(valueLabel);
                     if (elem.kind === "f64" || elem.kind === "bool") {
                         const acc = elem.kind;
                         const accTy = elem.kind === "f64" ? "double" : "i1";
@@ -1437,9 +1726,15 @@ export class LlDyn {
                         B.line(`call void @scr_dyn_arr_push(ptr ${d}, ptr ${conv})`);
                         B.line(`call void ${releaseSym(host, elem)}(ptr ${e})`);
                     }
+                    B.terminate(`br label %${doneLabel}`);
+                    B.startBlock(doneLabel);
                 });
+                host.declare(`declare void @scr_arr_copy_metadata(ptr, ptr)`);
+                B.line(`call void @scr_arr_copy_metadata(ptr %v, ptr ${d})`);
                 if (cyclicArr)
                     B.line(`call void @scr_dyn_from_leave()`);
+                host.declare(`declare ptr @scr_dyn_mark_snapshot(ptr)`);
+                B.line(`call ptr @scr_dyn_mark_snapshot(ptr ${d})`);
                 B.terminate(`ret ptr ${d}`);
                 break;
             }
@@ -1549,7 +1844,7 @@ export class LlDyn {
         }
         this.defs.push(`define internal ptr @${name}(${this.valTy(t)} %v) ${FN_ATTRS} { ; to-dyn ${key}`, B.render(), `}`, ``);
         if (sourceAccessor) {
-            this.defs.push(`define internal ptr @${sourceAccessor.name}(ptr %v, i1 %materialize) ${FN_ATTRS} { ; live listener source ${key}`, `entry:`, `  br i1 %materialize, label %snapshot, label %release`, `snapshot:`, `  %d = call ptr @${name}(ptr %v)`, `  ret ptr %d`, `release:`, `  call void ${sourceAccessor.release}(ptr %v)`, `  ret ptr null`, `}`, ``);
+            this.defs.push(`define internal ptr @${sourceAccessor.name}(ptr %v, i1 %materialize) ${FN_ATTRS} { ; record source ${key}`, `entry:`, `  br i1 %materialize, label %snapshot, label %release`, `snapshot:`, `  %d = call ptr @${name}(ptr %v)`, `  ret ptr %d`, `release:`, `  call void ${sourceAccessor.release}(ptr %v)`, `  ret ptr null`, `}`, ``);
         }
         return name;
     }
@@ -1571,9 +1866,10 @@ export class LlDyn {
         const B = new BlockBuilder();
         host.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
         host.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
+        host.declare(`declare void @scr_dyn_trace_v(ptr, ptr, ptr)`);
         host.declare(`declare void @scr_dyn_release_v(ptr)`);
         const fulfill = (dv) => {
-            B.line(`call void @scr_promise_fulfill_ref(ptr %dst, ptr ${dv}, ptr @scr_dyn_retain_v, ptr @scr_dyn_release_v, ptr null)`);
+            B.line(`call void @scr_promise_fulfill_ref(ptr %dst, ptr ${dv}, ptr @scr_dyn_retain_v, ptr @scr_dyn_release_v, ptr @scr_dyn_trace_v)`);
         };
         switch (inner.kind) {
             case "void":
@@ -1660,10 +1956,17 @@ export class LlDyn {
             const kd = this.kindOf(B, "%d");
             const done = B.newLabel("ds.d");
             const labels = new Map();
-            for (const k of [DYN_KIND.NULL, DYN_KIND.BOOL, DYN_KIND.NUM, DYN_KIND.STR, DYN_KIND.ARR, DYN_KIND.OBJ, DYN_KIND.UNDEF, DYN_KIND.BYTES, DYN_KIND.FUNC, DYN_KIND.HANDLE, DYN_KIND.PROMISE, DYN_KIND.JSVAL, DYN_KIND.TYPED_REF]) {
+            for (const k of [DYN_KIND.NULL, DYN_KIND.BOOL, DYN_KIND.NUM, DYN_KIND.STR, DYN_KIND.ARR, DYN_KIND.OBJ, DYN_KIND.UNDEF, DYN_KIND.BYTES, DYN_KIND.FUNC, DYN_KIND.HANDLE, DYN_KIND.PROMISE, DYN_KIND.JSVAL, DYN_KIND.TYPED_REF, DYN_KIND.PROXY, DYN_KIND.BIGINT, DYN_KIND.SYMBOL]) {
                 labels.set(k, B.newLabel(`ds.k${k}`));
             }
-            B.terminate(`switch i32 ${kd}, label %${done} [ ${[...labels].map(([k, l]) => `i32 ${k}, label %${l}`).join(" ")} ]`);
+            const branches = [];
+            for (const [kind, label] of labels)
+                branches.push(`i32 ${kind}, label %${label}`);
+            B.terminate(`switch i32 ${kd}, label %${done} [ ${branches.join(" ")} ]`);
+            B.startBlock(labels.get(DYN_KIND.PROXY));
+            host.declare(`declare void @scr_dyn_proxy_unsupported(ptr)`);
+            B.line(`call void @scr_dyn_proxy_unsupported(ptr ${host.cstr("string conversion")})`);
+            B.br(done);
             B.startBlock(labels.get(DYN_KIND.JSVAL));
             {
                 // Island-held: the engine's own ToString (a bridged failure
@@ -1696,6 +1999,24 @@ export class LlDyn {
                 B.line(`call void @scr_jb_puts(ptr %b, ptr ${s})`);
                 B.br(done);
             }
+            B.startBlock(labels.get(DYN_KIND.BIGINT));
+            {
+                host.declare(`declare ptr @scr_bigint_to_string(ptr, double)`);
+                const v = this.payloadOf(B, "%d", "ptr");
+                const s = B.tmp();
+                B.line(`${s} = call ptr @scr_bigint_to_string(ptr ${v}, double ${f64Lit(10)})`);
+                this.putScrStr(B, "%b", s);
+                B.line(`call void @scr_str_release(ptr ${s})`);
+                B.br(done);
+            }
+            B.startBlock(labels.get(DYN_KIND.SYMBOL));
+            {
+                host.declare(`declare ptr @scr_dyn_string_coerce(ptr)`);
+                const s = B.tmp();
+                B.line(`${s} = call ptr @scr_dyn_string_coerce(ptr %d)`);
+                B.line(`call void @scr_str_release(ptr ${s})`);
+                B.br(done);
+            }
             B.startBlock(labels.get(DYN_KIND.NUM));
             {
                 // String(n): NaN/Infinity spelled out, not the JSON null.
@@ -1862,35 +2183,11 @@ export class LlDyn {
                 B.br(done);
                 B.startBlock(lJoin);
                 const bts = this.payloadOf(B, "%d", "ptr");
-                const blenp = B.tmp();
-                const blen = B.tmp();
-                const bdatap = B.tmp();
-                const bdata = B.tmp();
-                B.line(`${blenp} = getelementptr inbounds i8, ptr ${bts}, i64 ${this.abiOffset(8, 4)} ; ->len`);
-                B.line(`${blen} = load ${this.S}, ptr ${blenp}`);
-                B.line(`${bdatap} = getelementptr inbounds i8, ptr ${bts}, i64 ${this.abiOffset(24, 12)} ; ->data`);
-                B.line(`${bdata} = load ptr, ptr ${bdatap}`);
-                this.i64Loop(B, "ds.by", blen, (i) => {
-                    const nz = B.tmp();
-                    B.line(`${nz} = icmp ugt ${this.S} ${i}, 0`);
-                    const lcm = B.newLabel("ds.bc");
-                    const lv = B.newLabel("ds.bv");
-                    B.condBr(nz, lcm, lv);
-                    B.startBlock(lcm);
-                    B.line(`call void @scr_jb_putc(ptr %b, i8 44)`);
-                    B.br(lv);
-                    B.startBlock(lv);
-                    const cp = B.tmp();
-                    const c = B.tmp();
-                    const cd = B.tmp();
-                    B.line(`${cp} = getelementptr inbounds i8, ptr ${bdata}, ${this.S} ${i}`);
-                    B.line(`${c} = load i8, ptr ${cp}`);
-                    B.line(`${cd} = uitofp i8 ${c} to double`);
-                    const s = B.tmp();
-                    B.line(`${s} = call ptr @scr_f64_to_scrstr(double ${cd})`);
-                    this.putScrStr(B, "%b", s);
-                    B.line(`call void @scr_str_release(ptr ${s})`);
-                });
+                host.declare(`declare ptr @scr_bytes_join(ptr, ptr)`);
+                const joined = B.tmp();
+                B.line(`${joined} = call ptr @scr_bytes_join(ptr ${bts}, ptr ${host.internLiteral(",")})`);
+                this.putScrStr(B, "%b", joined);
+                B.line(`call void @scr_str_release(ptr ${joined})`);
                 B.br(done);
             }
             B.startBlock(labels.get(DYN_KIND.FUNC));
@@ -1914,8 +2211,14 @@ export class LlDyn {
                 B.br(done);
             }
             B.startBlock(labels.get(DYN_KIND.HANDLE));
-            this.puts(B, "%b", "[object Object]");
-            B.br(done);
+            {
+                host.declare(`declare ptr @scr_dyn_to_string(ptr, ptr)`);
+                const s = B.tmp();
+                B.line(`${s} = call ptr @scr_dyn_to_string(ptr %d, ptr null)`);
+                this.putScrStr(B, "%b", s);
+                B.line(`call void @scr_str_release(ptr ${s})`);
+                B.br(done);
+            }
             B.startBlock(labels.get(DYN_KIND.PROMISE));
             // Object.prototype.toString with the Promise @@toStringTag.
             this.puts(B, "%b", "[object Promise]");
@@ -2062,6 +2365,47 @@ export class LlDyn {
     /* ── the keyed read (dynKeyGetHelper, ported) ──────────────────────── */
     /** `sc_dyn_key_get(ptr d, ptr k, i1 opt) -> ptr` — d[k] on a dyn value.
      * Result +1; throws on non-optional nullish receivers. */
+    dynComputedKeyGetHelper() {
+        const name = "sc_dyn_computed_key_get";
+        if (this.helperMemo.has(name))
+            return name;
+        this.helperMemo.set(name, name);
+        const B = new BlockBuilder();
+        const host = this.host;
+        const stringHelper = this.dynKeyGetHelper();
+        host.declare(`declare ptr @scr_dyn_property_key_value(ptr)`);
+        host.declare(`declare ptr @scr_dyn_symbol_key_get(ptr, ptr, i1 zeroext)`);
+        host.declare(`declare void @scr_dyn_release(ptr)`);
+        const key = B.tmp();
+        B.line(`${key} = call ptr @scr_dyn_property_key_value(ptr %key)`);
+        const missing = B.tmp();
+        B.line(`${missing} = icmp eq ptr ${key}, null`);
+        const fail = B.newLabel("kg.fail");
+        const dispatch = B.newLabel("kg.dispatch");
+        B.condBr(missing, fail, dispatch);
+        B.startBlock(fail);
+        B.terminate("ret ptr null");
+        B.startBlock(dispatch);
+        const kind = this.kindOf(B, key);
+        const symbol = B.tmp();
+        B.line(`${symbol} = icmp eq i32 ${kind}, ${DYN_KIND.SYMBOL}`);
+        const sym = B.newLabel("kg.symbol");
+        const str = B.newLabel("kg.string");
+        B.condBr(symbol, sym, str);
+        B.startBlock(sym);
+        const sv = B.tmp();
+        B.line(`${sv} = call ptr @scr_dyn_symbol_key_get(ptr %d, ptr ${key}, i1 %opt)`);
+        B.line(`call void @scr_dyn_release(ptr ${key})`);
+        B.terminate(`ret ptr ${sv}`);
+        B.startBlock(str);
+        const text = this.payloadOf(B, key, "ptr");
+        const value = B.tmp();
+        B.line(`${value} = call ptr @${stringHelper}(ptr %d, ptr ${text}, i1 %opt)`);
+        B.line(`call void @scr_dyn_release(ptr ${key})`);
+        B.terminate(`ret ptr ${value}`);
+        this.defs.push(`define internal ptr @${name}(ptr %d, ptr %key, i1 zeroext %opt) ${FN_ATTRS} {`, B.render(), "}", "");
+        return name;
+    }
     dynKeyGetHelper() {
         const memoKey = "%dynKeyGet";
         const existing = this.dynBuilders.get(memoKey);
@@ -2122,6 +2466,19 @@ export class LlDyn {
             B.terminate(`ret ptr null`);
             B.startBlock(lNext);
         }
+        {
+            const isSymbol = B.tmp();
+            B.line(`${isSymbol} = icmp eq i32 ${kd}, ${DYN_KIND.SYMBOL}`);
+            const lSymbol = B.newLabel("kg.sym");
+            const lNext = B.newLabel("kg.n");
+            B.condBr(isSymbol, lSymbol, lNext);
+            B.startBlock(lSymbol);
+            host.declare(`declare ptr @scr_dyn_symbol_get(ptr, ptr)`);
+            const r = B.tmp();
+            B.line(`${r} = call ptr @scr_dyn_symbol_get(ptr %d, ptr %k)`);
+            B.terminate(`ret ptr ${r}`);
+            B.startBlock(lNext);
+        }
         // Typed stream capsules expose their one cached, refreshed dyn view to
         // ordinary property reads while the capsule itself keeps identity.
         {
@@ -2144,6 +2501,19 @@ export class LlDyn {
         // ISLAND-held receivers: o[k] reads the REAL engine property (getters
         // included, throws bridged catchably) and the result wraps back
         // scalar-normalized — the routed keyed read that retired the fence.
+        {
+            const isProxy = B.tmp();
+            B.line(`${isProxy} = icmp eq i32 ${kd}, ${DYN_KIND.PROXY}`);
+            const lProxy = B.newLabel("kg.proxy");
+            const lNext = B.newLabel("kg.n");
+            B.condBr(isProxy, lProxy, lNext);
+            B.startBlock(lProxy);
+            host.declare(`declare ptr @scr_dyn_proxy_get(ptr, ptr)`);
+            const r = B.tmp();
+            B.line(`${r} = call ptr @scr_dyn_proxy_get(ptr %d, ptr %k)`);
+            B.terminate(`ret ptr ${r}`);
+            B.startBlock(lNext);
+        }
         {
             const isJv = B.tmp();
             B.line(`${isJv} = icmp eq i32 ${kd}, ${DYN_KIND.JSVAL}`);
@@ -2288,45 +2658,10 @@ export class LlDyn {
             const lNext = B.newLabel("kg.n");
             B.condBr(isB, lB, lNext);
             B.startBlock(lB);
-            host.declare(`declare ptr @scr_dyn_new_num(double)`);
-            const bts = this.payloadOf(B, "%d", "ptr");
-            const blenp = B.tmp();
-            const blen = B.tmp();
-            B.line(`${blenp} = getelementptr inbounds i8, ptr ${bts}, i64 ${this.abiOffset(8, 4)} ; ->len`);
-            B.line(`${blen} = load ${host.sizeType}, ptr ${blenp}`);
-            const lLen = B.newLabel("kg.bl");
-            const lIdx = B.newLabel("kg.bi");
-            B.condBr(lenHit, lLen, lIdx);
-            B.startBlock(lLen);
-            const lenD = B.tmp();
-            const r0 = B.tmp();
-            B.line(`${lenD} = uitofp ${host.sizeType} ${blen} to double`);
-            B.line(`${r0} = call ptr @scr_dyn_new_num(double ${lenD})`);
-            B.terminate(`ret ptr ${r0}`);
-            B.startBlock(lIdx);
-            const inRange = B.tmp();
-            const hit = B.tmp();
-            B.line(`${inRange} = icmp ult ${host.sizeType} ${idx}, ${blen}`);
-            B.line(`${hit} = and i1 ${digits}, ${inRange}`);
-            const lHit = B.newLabel("kg.bh");
-            const lMiss = B.newLabel("kg.bm");
-            B.condBr(hit, lHit, lMiss);
-            B.startBlock(lHit);
-            const bdatap = B.tmp();
-            const bdata = B.tmp();
-            B.line(`${bdatap} = getelementptr inbounds i8, ptr ${bts}, i64 ${this.abiOffset(24, 12)} ; ->data`);
-            B.line(`${bdata} = load ptr, ptr ${bdatap}`);
-            const bp = B.tmp();
-            const bv = B.tmp();
-            const bd = B.tmp();
-            const r1 = B.tmp();
-            B.line(`${bp} = getelementptr inbounds i8, ptr ${bdata}, ${host.sizeType} ${idx}`);
-            B.line(`${bv} = load i8, ptr ${bp}`);
-            B.line(`${bd} = uitofp i8 ${bv} to double`);
-            B.line(`${r1} = call ptr @scr_dyn_new_num(double ${bd})`);
-            B.terminate(`ret ptr ${r1}`);
-            B.startBlock(lMiss);
-            retainUndef();
+            host.declare(`declare ptr @scr_dyn_bytes_key_get(ptr, ptr)`);
+            const result = B.tmp();
+            B.line(`${result} = call ptr @scr_dyn_bytes_key_get(ptr %d, ptr %k)`);
+            B.terminate(`ret ptr ${result}`);
             B.startBlock(lNext);
         }
         // FUNC: own props (defineProperties writes), then name/length.
@@ -2429,6 +2764,15 @@ export class LlDyn {
                 B.line(`call void @scr_str_release(ptr ${ch})`);
                 B.terminate(`ret ptr ${r2}`);
                 B.startBlock(lMiss);
+                const lArrNamed = B.newLabel("kg.an");
+                const lOther = B.newLabel("kg.ao");
+                B.condBr(isA, lArrNamed, lOther);
+                B.startBlock(lArrNamed);
+                host.declare(`declare ptr @scr_dyn_arr_named_get(ptr, ptr)`);
+                const named = B.tmp();
+                B.line(`${named} = call ptr @scr_dyn_arr_named_get(ptr %d, ptr %k)`);
+                B.terminate(`ret ptr ${named}`);
+                B.startBlock(lOther);
                 retainUndef();
             }
             B.startBlock(lNext);
@@ -2529,14 +2873,13 @@ export class LlDyn {
             const materialized = B.tmp();
             const out = B.tmp();
             B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
-            B.line(`${out} = call ptr @${name}(ptr ${materialized}, ${host.sizeType} %n)`);
+            B.line(`${out} = call ptr @${name}(ptr ${materialized}, ${host.sizeType} %n, ptr %spelling)`);
             B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
             B.terminate(`ret ptr ${out}`);
             B.startBlock(lNext);
         }
-        // ISLAND-held sources: an engine array IS iterable — the not-iterable
-        // TypeError below would be a wrong claim. Loud fence (lane
-        // dyn-routing-ops).
+        // Island-held sources keep the engine's iterator and IteratorClose
+        // behavior while returning checked values for the destructuring slots.
         {
             const isJv = B.tmp();
             B.line(`${isJv} = icmp eq i32 ${kd}, ${DYN_KIND.JSVAL}`);
@@ -2544,10 +2887,12 @@ export class LlDyn {
             const lNotJv = B.newLabel("din.njv");
             B.condBr(isJv, lJv, lNotJv);
             B.startBlock(lJv);
-            host.declare(`declare zeroext i1 @scr_dyn_isl_fence(ptr, ptr)`);
-            const f = B.tmp();
-            B.line(`${f} = call zeroext i1 @scr_dyn_isl_fence(ptr %d, ptr ${host.cstr("iteration")})`);
-            B.terminate(`ret ptr null`);
+            host.declare(`declare ptr @scr_dyn_jsval_iter_n(ptr, double)`);
+            const count = B.tmp();
+            const out = B.tmp();
+            B.line(`${count} = uitofp ${host.sizeType} %n to double`);
+            B.line(`${out} = call ptr @scr_dyn_jsval_iter_n(ptr %d, double ${count})`);
+            B.terminate(`ret ptr ${out}`);
             B.startBlock(lNotJv);
         }
         const okA = B.tmp();
@@ -2568,6 +2913,17 @@ export class LlDyn {
         const buf = "%dib";
         B.entryAllocas.push(`${buf} = alloca %ScrJsonBuf`);
         B.line(`call void @scr_jb_init(ptr ${buf})`);
+        const hasSpelling = B.tmp();
+        B.line(`${hasSpelling} = icmp ne ptr %spelling, null`);
+        const named = B.newLabel("din.named"), unnamed = B.newLabel("din.unnamed");
+        B.condBr(hasSpelling, named, unnamed);
+        B.startBlock(named);
+        B.line(`call void @scr_jb_puts(ptr ${buf}, ptr %spelling)`);
+        const namedMessage = B.tmp();
+        B.line(`${namedMessage} = call ptr @scr_jb_finish(ptr ${buf})`);
+        B.line(`call void @scr_throw_error(i32 1, ptr ${namedMessage})`);
+        B.terminate(`ret ptr null`);
+        B.startBlock(unnamed);
         const lU = B.newLabel("din.u");
         const lN = B.newLabel("din.n");
         const lB2 = B.newLabel("din.b");
@@ -2647,7 +3003,7 @@ export class LlDyn {
                 B.line(`store ptr ${r2}, ptr ${itemSlot}`);
                 B.br(lPush);
             }
-            // BYTES: by byte.
+            // BYTES: by numeric element.
             B.startBlock(lBy);
             {
                 const bts = this.payloadOf(B, "%d", "ptr");
@@ -2661,17 +3017,12 @@ export class LlDyn {
                 const lMiss = B.newLabel("din.bm");
                 B.condBr(inR, lHit, lMiss);
                 B.startBlock(lHit);
-                const bdatap = B.tmp();
-                const bdata = B.tmp();
-                B.line(`${bdatap} = getelementptr inbounds i8, ptr ${bts}, i64 ${this.abiOffset(24, 12)} ; ->data`);
-                B.line(`${bdata} = load ptr, ptr ${bdatap}`);
-                const bp = B.tmp();
-                const bv = B.tmp();
+                host.declare(`declare double @scr_bytes_get(ptr, double)`);
+                const index = B.tmp();
                 const bd = B.tmp();
                 const r = B.tmp();
-                B.line(`${bp} = getelementptr inbounds i8, ptr ${bdata}, ${host.sizeType} ${i}`);
-                B.line(`${bv} = load i8, ptr ${bp}`);
-                B.line(`${bd} = uitofp i8 ${bv} to double`);
+                B.line(`${index} = uitofp ${host.sizeType} ${i} to double`);
+                B.line(`${bd} = call double @scr_bytes_get(ptr ${bts}, double ${index})`);
                 B.line(`${r} = call ptr @scr_dyn_new_num(double ${bd})`);
                 B.line(`store ptr ${r}, ptr ${itemSlot}`);
                 B.br(lPush);
@@ -2752,7 +3103,7 @@ export class LlDyn {
             B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${item}) ; push takes ownership`);
         });
         B.terminate(`ret ptr ${out}`);
-        this.defs.push(`define internal ptr @${name}(ptr %d, ${host.sizeType} %n) ${FN_ATTRS} { ; destructuring GetIterator + N steps`, B.render(), `}`, ``);
+        this.defs.push(`define internal ptr @${name}(ptr %d, ${host.sizeType} %n, ptr %spelling) ${FN_ATTRS} { ; destructuring GetIterator + N steps`, B.render(), `}`, ``);
         return name;
     }
     /* ── the checked-dynamic function boundary (ported) ────────────────── */
@@ -2793,7 +3144,55 @@ export class LlDyn {
         const host = this.host;
         const B = new BlockBuilder();
         const argNames = [];
+        const typedRest = t.rest === true && t.restAbi === "typed";
+        const packTail = (start) => {
+            host.declare(`declare ptr @scr_dyn_new_arr()`);
+            host.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
+            const packed = B.tmp();
+            B.line(`${packed} = call ptr @scr_dyn_new_arr()`);
+            const riSlot = B.slot();
+            B.entryAllocas.push(`${riSlot} = alloca ${host.sizeType}`);
+            B.line(`store ${host.sizeType} ${start}, ptr ${riSlot}`);
+            const lc = B.newLabel("dfk.rc");
+            const lb = B.newLabel("dfk.rb");
+            const le = B.newLabel("dfk.re");
+            B.br(lc);
+            B.startBlock(lc);
+            const ri = B.tmp();
+            const cont = B.tmp();
+            B.line(`${ri} = load ${host.sizeType}, ptr ${riSlot}`);
+            B.line(`${cont} = icmp ult ${host.sizeType} ${ri}, %argc`);
+            B.condBr(cont, lb, le);
+            B.startBlock(lb);
+            const ap = B.tmp();
+            const av = B.tmp();
+            B.line(`${ap} = getelementptr inbounds ptr, ptr %args, ${host.sizeType} ${ri}`);
+            B.line(`${av} = load ptr, ptr ${ap}`);
+            const rv = this.retainDyn(B, av);
+            B.line(`call void @scr_dyn_arr_push(ptr ${packed}, ptr ${rv})`);
+            const ri2 = B.tmp();
+            B.line(`${ri2} = add ${host.sizeType} ${ri}, 1`);
+            B.line(`store ${host.sizeType} ${ri2}, ptr ${riSlot}`);
+            B.br(lc);
+            B.startBlock(le);
+            return packed;
+        };
         t.params.forEach((p, i) => {
+            if (typedRest && i === t.params.length - 1) {
+                const packed = packTail(i);
+                const a = B.tmp();
+                B.line(`${a} = call ${this.valTy(p)} @${this.dynCheckHelper(p)}(ptr ${packed}, ptr null)`);
+                host.declare(`declare void @scr_dyn_release(ptr)`);
+                B.line(`call void @scr_dyn_release(ptr ${packed})`);
+                this.pendingBail(B, "dfk.rest", () => {
+                    t.params.slice(0, i).forEach((q, j) => {
+                        if (isRefCounted(q))
+                            B.line(`call void ${releaseSym(host, q)}(ptr ${argNames[j]})`);
+                    });
+                }, "ptr null");
+                argNames.push(a);
+                return;
+            }
             // JS arity: a missing argument IS the undefined dyn value.
             const adSlot = B.slot();
             B.entryAllocas.push(`${adSlot} = alloca ptr`);
@@ -2867,38 +3266,7 @@ export class LlDyn {
         });
         // VARIADIC (rest-marked) signatures: one extra trailing dyn-array
         // param carries the call's arguments from index params.length on.
-        let rest = null;
-        if (t.rest) {
-            host.declare(`declare ptr @scr_dyn_new_arr()`);
-            host.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
-            rest = B.tmp();
-            B.line(`${rest} = call ptr @scr_dyn_new_arr()`);
-            const riSlot = B.slot();
-            B.entryAllocas.push(`${riSlot} = alloca ${host.sizeType}`);
-            B.line(`store ${host.sizeType} ${t.argumentsAll ? 0 : t.params.length}, ptr ${riSlot}`);
-            const lc = B.newLabel("dfk.rc");
-            const lb = B.newLabel("dfk.rb");
-            const le = B.newLabel("dfk.re");
-            B.br(lc);
-            B.startBlock(lc);
-            const ri = B.tmp();
-            const cont = B.tmp();
-            B.line(`${ri} = load ${host.sizeType}, ptr ${riSlot}`);
-            B.line(`${cont} = icmp ult ${host.sizeType} ${ri}, %argc`);
-            B.condBr(cont, lb, le);
-            B.startBlock(lb);
-            const ap = B.tmp();
-            const av = B.tmp();
-            B.line(`${ap} = getelementptr inbounds ptr, ptr %args, ${host.sizeType} ${ri}`);
-            B.line(`${av} = load ptr, ptr ${ap}`);
-            const rv = this.retainDyn(B, av);
-            B.line(`call void @scr_dyn_arr_push(ptr ${rest}, ptr ${rv})`);
-            const ri2 = B.tmp();
-            B.line(`${ri2} = add ${host.sizeType} ${ri}, 1`);
-            B.line(`store ${host.sizeType} ${ri2}, ptr ${riSlot}`);
-            B.br(lc);
-            B.startBlock(le);
-        }
+        const rest = t.rest && !typedRest ? packTail(t.argumentsAll ? 0 : t.params.length) : null;
         // The closure CONSUMES its params (+1 each moved in).
         const fnp = B.tmp();
         const fn = B.tmp();
@@ -2948,7 +3316,7 @@ export class LlDyn {
         host.declare(`declare ptr @scr_closure_retain_v(ptr)`);
         host.declare(`declare ptr @scr_dyn_new_func(ptr, ptr, i32, ptr, ptr)`);
         const sigLit = host.cstr(key);
-        this.defs.push(`define internal ptr @${name}(ptr %v, ptr %fname) ${FN_ATTRS} { ; box ${key} into dyn`, `entry:`, `  %c = call ptr @scr_closure_retain_v(ptr %v)`, `  %r = call ptr @scr_dyn_new_func(ptr %c, ptr @${thunk}, i32 ${t.params.length}, ptr ${sigLit}, ptr %fname)`, `  ret ptr %r`, `}`, ``);
+        this.defs.push(`define internal ptr @${name}(ptr %v, ptr %fname) ${FN_ATTRS} { ; box ${key} into dyn`, `entry:`, `  %c = call ptr @scr_closure_retain_v(ptr %v)`, `  %r = call ptr @scr_dyn_new_func(ptr %c, ptr @${thunk}, i32 ${t.params.length - (t.restAbi === "typed" ? 1 : 0)}, ptr ${sigLit}, ptr %fname)`, `  ret ptr %r`, `}`, ``);
         return name;
     }
     /** The adapter closure body for one TARGET signature: caps[0] is an
@@ -2977,7 +3345,30 @@ export class LlDyn {
         // argument (borrowed by the conversion) and releases.
         let argsPtr = "null";
         const argVals = [];
-        if (t.params.length > 0) {
+        const checkedRest = t.rest === true && t.restAbi === undefined;
+        let packed = null;
+        if (checkedRest) {
+            host.declare(`declare ptr @scr_dyn_apply(ptr, ptr, ptr)`);
+            host.declare(`declare ptr @scr_dyn_new_arr()`);
+            host.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
+            host.declare(`declare void @scr_dyn_arr_push_spread(ptr, ptr, ptr)`);
+            packed = t.argumentsAll ? "%rest" : B.tmp();
+            if (!t.argumentsAll)
+                B.line(`${packed} = call ptr @scr_dyn_new_arr()`);
+            t.params.forEach((p, i) => {
+                if (!t.argumentsAll) {
+                    const v = this.toDynExpr(B, p, `%a${i}`);
+                    B.line(`call void @scr_dyn_arr_push(ptr ${packed}, ptr ${v})`);
+                }
+                if (isRefCounted(p))
+                    B.line(`call void ${releaseSym(host, p)}(ptr %a${i})`);
+            });
+            if (!t.argumentsAll) {
+                B.line(`call void @scr_dyn_arr_push_spread(ptr ${packed}, ptr %rest, ptr ${host.cstr("")})`);
+                B.line(`call void @scr_dyn_release(ptr %rest)`);
+            }
+        }
+        else if (t.params.length > 0) {
             const arr = B.slot();
             B.entryAllocas.push(`${arr} = alloca [${t.params.length} x ptr]`);
             t.params.forEach((p, i) => {
@@ -2994,7 +3385,12 @@ export class LlDyn {
         // The kind is FUNC by construction; `what` is unreachable — spelled
         // anyway (the C's "value").
         const r = B.tmp();
-        B.line(`${r} = call ptr @scr_dyn_call(ptr ${fnv}, ptr ${argsPtr}, ${host.sizeType} ${t.params.length}, ptr ${host.cstr("value")})`);
+        if (packed) {
+            B.line(`${r} = call ptr @scr_dyn_apply(ptr ${fnv}, ptr ${packed}, ptr ${host.cstr("value")})`);
+            B.line(`call void @scr_dyn_release(ptr ${packed})`);
+        }
+        else
+            B.line(`${r} = call ptr @scr_dyn_call(ptr ${fnv}, ptr ${argsPtr}, ${host.sizeType} ${t.params.length}, ptr ${host.cstr("value")})`);
         B.line(`call void @scr_dyn_release(ptr ${fnv})`);
         for (const v of argVals)
             B.line(`call void @scr_dyn_release(ptr ${v})`);
@@ -3014,7 +3410,7 @@ export class LlDyn {
             B.line(`call void @scr_dyn_release(ptr ${r})`);
             B.terminate(`ret ${this.valTy(t.ret)} ${out}`);
         }
-        const params = ["ptr %sc_env", ...t.params.map((p, i) => `${this.valTy(p)} %a${i}`)].join(", ");
+        const params = ["ptr %sc_env", ...t.params.map((p, i) => `${this.valTy(p)} %a${i}`), ...(checkedRest ? ["ptr %rest"] : [])].join(", ");
         this.defs.push(`define internal ${retTy === "i1" ? "zeroext i1" : retTy} @${name}(${params}) ${FN_ATTRS} { ; dyn fn adapter to ${key}`, B.render(), `}`, ``);
         return name;
     }