@scriptc/compiler 0.1.7 → 0.2.0

package/dist/backend/llvm/dyn.js

@@ -1,3 +1,5 @@
+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";
@@ -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;
@@ -51,11 +51,38 @@ export class LlDyn {
     promiseDynAdapters = 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;
@@ -118,12 +145,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}`);
@@ -245,6 +272,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 +305,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 +338,34 @@ export class LlDyn {
             B.terminate(`ret i1 ${r}`);
         };
         switch (t.kind) {
+            case "url": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_native_url_is(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_url_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_${t.kind}_is(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_${t.kind}_is(ptr %d)`);
+                B.terminate(`ret i1 ${r}`);
+                break;
+            }
+            case "bigint":
+                kindIs(DYN_KIND.BIGINT);
+                break;
+            case "symbol":
+                kindIs(DYN_KIND.SYMBOL);
+                break;
             case "f64":
                 kindIs(DYN_KIND.NUM);
                 break;
@@ -309,14 +385,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.
@@ -473,11 +562,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 +615,17 @@ 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")})`);
+            const matched = this.typedRefMatches(B, t);
             const lRef = B.newLabel("dc.tr");
             const lNext = B.newLabel("dc.nt");
             B.condBr(matched, lRef, lNext);
@@ -672,6 +765,46 @@ export class LlDyn {
             B.startBlock(lo);
         };
         switch (t.kind) {
+            case "url": {
+                host.declare(`declare ptr @scr_dyn_native_url_check(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_url_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_${t.kind}_check(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_${t.kind}_check(ptr %d, 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 +835,26 @@ 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 "object": {
                 // The %Error extraction (an instanceof-Error narrow on unknown):
                 // validate the checked-dynamic tree's error encoding — the reserved "%error" marker
@@ -827,6 +970,21 @@ export class LlDyn {
                     break;
                 }
                 requireKind(DYN_KIND.OBJ, "dcr");
+                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));
@@ -994,12 +1152,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
@@ -1078,13 +1233,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();
@@ -1140,11 +1296,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 +1351,42 @@ export class LlDyn {
         const B = new BlockBuilder();
         let sourceAccessor = null;
         switch (t.kind) {
+            case "url": {
+                host.declare(`declare ptr @scr_dyn_native_url(ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_url(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)`);
+                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 +1408,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 +1436,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 +1446,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 +1460,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 +1486,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 +1508,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 +1611,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 +1633,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 +1673,13 @@ 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);
                 });
                 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 +1789,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 +1811,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 +1901,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 +1944,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 +2128,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 +2156,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 +2310,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 +2411,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 +2446,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 +2603,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 +2709,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);
@@ -2647,7 +2936,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 +2950,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);
@@ -2793,7 +3077,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 +3199,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 +3249,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 +3278,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 +3318,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 +3343,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;
     }