@scriptc/compiler 0.2.0 → 0.2.1

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 } 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,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). */
@@ -197,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)`);
@@ -338,10 +368,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_url_is(ptr %d)`);
+                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;
             }
@@ -354,15 +393,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;
@@ -465,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);
                 }
@@ -625,6 +666,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 +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");
@@ -735,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 {
@@ -743,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}`);
@@ -765,10 +817,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 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_url_check(ptr %d, ptr %path)`);
+                B.line(`${r} = call ptr @scr_dyn_native_${native}_check(ptr %d, ptr %path)`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -781,9 +842,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 +917,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 +1049,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 +1080,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.
@@ -1194,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);
@@ -1255,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)`);
@@ -1351,10 +1398,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 +1417,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}`);
@@ -1676,6 +1729,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 +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}`);
@@ -2833,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();
@@ -2857,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");
@@ -3036,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) ────────────────── */