@scriptc/compiler 0.2.0 → 0.2.2

package/dist/backend/llvm/dyn.js

@@ -2,7 +2,7 @@ import { typedRefConstructor } from "./shapes.js";
 import { BYTES_ELEM_NUM, f64Lit } from "./common.js";
 import { InternalCompilerError } from "../../errors.js";
 import { DYN_HANDLE_KINDS, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
-import { dynDesc, undefinedArmTag } from "../../ir/analysis.js";
+import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
@@ -49,6 +49,7 @@ export class LlDyn {
     dynFuncBoxes = new Map();
     dynFuncAdapters = new Map();
     promiseDynAdapters = new Map();
+    mapDynOps = new Map();
     dynToStrFn = null;
     caughtToDynFn = null;
     helperMemo = new Map();
@@ -92,7 +93,45 @@ 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";
+            // Collection reads expose the original mutable element, including
+            // records/arrays inside unions, rather than a detached dyn snapshot.
+            const B = new BlockBuilder();
+            B.line(`%value = ${unpack}`);
+            if (type.kind === "union" && this.host.unionsById.get(type.unionId)?.arms.some(streamTypedRefEligible)) {
+                B.line(`%result = call ptr @${this.host.liveDynUnionRefAdapter(type)}(ptr %value)`);
+            }
+            else if (type.kind === "record" || type.kind === "array") {
+                const adapter = this.host.liveDynRefAdapter(type);
+                const rc = vAdapters(this.host, type);
+                const typeId = typeKey(type);
+                B.line(`%result = call ptr ${typedRefConstructor(this.host, type)}(ptr %value, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.host.cstr(typeId)}, ${this.S} ${Buffer.byteLength(typeId, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+            }
+            else {
+                B.line(`%result = call ptr @${this.toDynHelper(type)}(${ty} %value)`);
+            }
+            B.terminate("ret ptr %result");
+            const unbox = this.dynCheckHelper(type);
+            this.defs.push(`define internal ptr @${name}_${role}_box(i64 %slot) ${FN_ATTRS} {`, B.render(), `}`, "", `define internal i64 @${name}_${role}_unbox(ptr %d) ${FN_ATTRS} {`, `  %value = call ${ty === "i1" ? "zeroext i1" : ty} @${unbox}(ptr %d, ptr null)`, `  %result = ${pack}`, `  ret i64 %result`, `}`, "");
+        };
+        emitSlot(keyType, "key");
+        emitSlot(valueType, "value");
+        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). */
@@ -197,6 +236,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)`);
@@ -338,10 +384,19 @@ 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)`);
+            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_url_is(ptr %d)`);
+                B.line(`${r} = call zeroext i1 @scr_dyn_native_${native}_is(ptr %d)`);
                 B.terminate(`ret i1 ${r}`);
                 break;
             }
@@ -354,15 +409,19 @@ export class LlDyn {
             }
             case "map":
             case "set": {
-                this.host.declare(`declare zeroext i1 @scr_dyn_native_${t.kind}_is(ptr)`);
+                this.host.declare(`declare zeroext i1 @scr_dyn_native_collection_is(ptr, i32, ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call zeroext i1 @scr_dyn_native_${t.kind}_is(ptr %d)`);
+                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;
@@ -393,7 +452,12 @@ export class LlDyn {
                 break;
             }
             case "func":
-                kindIs(DYN_KIND.FUNC);
+                this.host.declare(`declare zeroext i1 @scr_dyn_is_callable(ptr)`);
+                {
+                    const matched = B.tmp();
+                    B.line(`${matched} = call zeroext i1 @scr_dyn_is_callable(ptr %d)`);
+                    B.terminate(`ret i1 ${matched}`);
+                }
                 break;
             case "classval": {
                 this.host.declare(`declare zeroext i1 @scr_dyn_class_is(ptr, ptr)`);
@@ -465,28 +529,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);
                 }
@@ -543,7 +605,16 @@ export class LlDyn {
                 B.startBlock(l0);
                 const n = this.lenOf(B, "%d");
                 const items = this.itemsOf(B, "%d");
-                this.i64Loop(B, "dm.el", n, (i) => {
+                this.i64Loop(B, "dm.el", n, (i, brNext) => {
+                    this.host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
+                    const present = B.tmp();
+                    B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
+                    const valueLabel = B.newLabel("dm.present");
+                    const holeLabel = B.newLabel("dm.hole");
+                    B.condBr(present, valueLabel, holeLabel);
+                    B.startBlock(holeLabel);
+                    brNext();
+                    B.startBlock(valueLabel);
                     const e = this.itemAt(B, items, i);
                     const ok = B.tmp();
                     B.line(`${ok} = call zeroext i1 @${m}(ptr ${e})`);
@@ -625,6 +696,17 @@ export class LlDyn {
         }
         if (isRefCounted(t) && t.kind !== "dyn") {
             host.declare(`declare ptr @scr_dyn_typed_ref_unbox(ptr)`);
+            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");
@@ -637,7 +719,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");
@@ -735,7 +817,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 {
@@ -743,7 +825,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}`);
@@ -765,10 +847,19 @@ export class LlDyn {
             B.startBlock(lo);
         };
         switch (t.kind) {
-            case "url": {
-                host.declare(`declare ptr @scr_dyn_native_url_check(ptr, ptr)`);
+            case "date": {
+                host.declare(`declare double @scr_dyn_native_date_value(ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_native_url_check(ptr %d, ptr %path)`);
+                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;
             }
@@ -781,9 +872,10 @@ export class LlDyn {
             }
             case "map":
             case "set": {
-                host.declare(`declare ptr @scr_dyn_native_${t.kind}_check(ptr, ptr)`);
+                host.declare(`declare ptr @scr_dyn_native_collection_check(ptr, i32, ptr, ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_native_${t.kind}_check(ptr %d, ptr %path)`);
+                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;
             }
@@ -855,6 +947,24 @@ export class LlDyn {
                 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
@@ -969,7 +1079,20 @@ 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);
@@ -987,61 +1110,15 @@ export class LlDyn {
                 }
                 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.
@@ -1123,6 +1200,22 @@ export class LlDyn {
                 const accTy = acc === "f64" ? "double" : acc === "bool" ? "i1" : "ptr";
                 host.declare(`declare double @scr_arr_push_${acc}(ptr, ${acc === "bool" ? "i1 zeroext" : accTy})`);
                 this.i64Loop(B, "dca", n, (i) => {
+                    host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
+                    const present = B.tmp();
+                    B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
+                    const valueLabel = B.newLabel("dca.present");
+                    const holeLabel = B.newLabel("dca.hole");
+                    const doneLabel = B.newLabel("dca.done");
+                    B.condBr(present, valueLabel, holeLabel);
+                    B.startBlock(holeLabel);
+                    host.declare(`declare void @scr_arr_set_len(ptr, double)`);
+                    const index = B.tmp();
+                    const length = B.tmp();
+                    B.line(`${index} = uitofp ${this.S} ${i} to double`);
+                    B.line(`${length} = fadd double ${index}, 1.0`);
+                    B.line(`call void @scr_arr_set_len(ptr ${a}, double ${length})`);
+                    B.br(doneLabel);
+                    B.startBlock(valueLabel);
                     const pp = B.tmp();
                     const kp = B.tmp();
                     const ip = B.tmp();
@@ -1141,6 +1234,8 @@ export class LlDyn {
                     }, "ptr null");
                     const pushed = B.tmp();
                     B.line(`${pushed} = call double @scr_arr_push_${acc}(ptr ${a}, ${accTy} ${v})`);
+                    B.br(doneLabel);
+                    B.startBlock(doneLabel);
                 });
                 B.terminate(`ret ptr ${a}`);
                 break;
@@ -1194,7 +1289,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);
@@ -1255,7 +1350,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)`);
@@ -1269,7 +1364,22 @@ export class LlDyn {
                 // caps[0] obj-box owns the dyn value (untraced).
                 const adapter = this.dynFuncAdapterHelper(t);
                 const sigLit = host.cstr(key);
-                requireKind(DYN_KIND.FUNC, "dcf");
+                const lWrap = B.newLabel("dcf.w");
+                host.declare(`declare zeroext i1 @scr_dyn_is_callable(ptr)`);
+                const callable = B.tmp();
+                const valid = B.newLabel("dcf.k");
+                const invalid = B.newLabel("dcf.f");
+                B.line(`${callable} = call zeroext i1 @scr_dyn_is_callable(ptr %d)`);
+                B.condBr(callable, valid, invalid);
+                B.startBlock(invalid);
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                B.terminate(`ret ${dummy}`);
+                B.startBlock(valid);
+                const direct = B.tmp();
+                const lSignature = B.newLabel("dcf.signature");
+                B.line(`${direct} = icmp eq i32 ${this.kindOf(B, "%d")}, ${DYN_KIND.FUNC}`);
+                B.condBr(direct, lSignature, lWrap);
+                B.startBlock(lSignature);
                 host.declare(`declare i32 @strcmp(ptr, ptr)`);
                 const sigp = B.tmp();
                 const sig = B.tmp();
@@ -1280,7 +1390,6 @@ export class LlDyn {
                 B.line(`${cmp} = call i32 @strcmp(ptr ${sig}, ptr ${sigLit})`);
                 B.line(`${same} = icmp eq i32 ${cmp}, 0`);
                 const lSame = B.newLabel("dcf.s");
-                const lWrap = B.newLabel("dcf.w");
                 B.condBr(same, lSame, lWrap);
                 B.startBlock(lSame);
                 host.declare(`declare ptr @scr_closure_retain_v(ptr)`);
@@ -1300,14 +1409,14 @@ export class LlDyn {
                 host.declare(`declare void @scr_dyn_release_v(ptr)`);
                 const a = B.tmp();
                 B.line(`${a} = call ptr @scr_closure_new(ptr @${adapter}, ${host.sizeType} 1)`);
-                const sourceClosure = this.payloadOf(B, "%d", "ptr");
-                const sourceKind = B.tmp();
+                host.declare(`declare i32 @scr_dyn_function_kind(ptr)`);
                 const functionKind = B.tmp();
                 const targetKind = B.tmp();
-                B.line(`${sourceKind} = getelementptr inbounds %ScrClosure, ptr ${sourceClosure}, i64 0, i32 4`);
-                B.line(`${functionKind} = load i32, ptr ${sourceKind}`);
+                B.line(`${functionKind} = call i32 @scr_dyn_function_kind(ptr %d)`);
                 B.line(`${targetKind} = getelementptr inbounds %ScrClosure, ptr ${a}, i64 0, i32 4`);
-                B.line(`store i32 ${functionKind}, ptr ${targetKind}`);
+                const adapterKind = B.tmp();
+                B.line(`${adapterKind} = or i32 ${functionKind}, 8 ; preserves the checked callable in caps[0]`);
+                B.line(`store i32 ${adapterKind}, ptr ${targetKind}`);
                 const box = B.tmp();
                 B.line(`${box} = call ptr @scr_box_new_obj(ptr @scr_dyn_retain_v, ptr @scr_dyn_release_v, ptr @scr_dyn_trace_v)`);
                 const capp = B.tmp();
@@ -1351,10 +1460,12 @@ export class LlDyn {
         const B = new BlockBuilder();
         let sourceAccessor = null;
         switch (t.kind) {
-            case "url": {
-                host.declare(`declare ptr @scr_dyn_native_url(ptr)`);
+            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_url(ptr %v)`);
+                B.line(`${r} = call ptr @scr_dyn_native_${native}(ptr %v)`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -1368,6 +1479,10 @@ export class LlDyn {
             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}`);
@@ -1637,9 +1752,19 @@ export class LlDyn {
                     const state = B.tmp();
                     const undefinedState = B.tmp();
                     const undefinedLabel = B.newLabel("tda.undefined");
+                    const holeLabel = B.newLabel("tda.hole");
+                    const presentLabel = B.newLabel("tda.present");
                     const valueLabel = B.newLabel("tda.value");
                     const doneLabel = B.newLabel("tda.done");
                     B.line(`${state} = call double @scr_arr_state(ptr %v, double ${i})`);
+                    const hole = B.tmp();
+                    B.line(`${hole} = fcmp oeq double ${state}, 0.0`); // SCR_ARR_HOLE
+                    B.condBr(hole, holeLabel, presentLabel);
+                    B.startBlock(holeLabel);
+                    host.declare(`declare void @scr_dyn_arr_push_hole(ptr)`);
+                    B.line(`call void @scr_dyn_arr_push_hole(ptr ${d})`);
+                    B.br(doneLabel);
+                    B.startBlock(presentLabel);
                     B.line(`${undefinedState} = fcmp oeq double ${state}, 2.0`); // SCR_ARR_UNDEFINED
                     B.terminate(`br i1 ${undefinedState}, label %${undefinedLabel}, label %${valueLabel}`);
                     B.startBlock(undefinedLabel);
@@ -1676,6 +1801,8 @@ export class LlDyn {
                     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)`);
@@ -2818,14 +2945,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}`);
@@ -2833,10 +2959,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();
@@ -2857,6 +2985,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");
@@ -3036,7 +3175,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) ────────────────── */