@scriptc/compiler 0.3.5 → 0.4.0

package/dist/backend/llvm/dyn.js

@@ -4,12 +4,12 @@ import { BYTES_ELEM_NUM, SCR_ARR_FIELD, f64Lit, sizeToDouble } from "./common.js
 import { emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { INLINE_UNION_FIELD, loadInlineUnion, stackUnionBox, storeInlineUnion, unionBoxBits, } from "./inline-unions.js";
 import { InternalCompilerError } from "../../errors.js";
-import { DYN_HANDLE_KINDS, isDirentShape, isDynTypedRefType, isRefCounted, typeKey, } from "../../ir/ir.js";
+import { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, isDynTypedRefType, isRefCounted, typeKey, } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { llvmCommentText } from "./common.js";
-import { arrNewCall, elemAccess, llFieldType, releaseSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, elemAccess, llFieldType, mapFlagsOffset, releaseSym, traceAdapter, traceArg, vAdapters, } from "./shapes.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { recordMayKeepSource, recordSourceFieldOrder } from "./record-sources.js";
 /** Whether to-dyn of a record shape keeps the record itself: an empty shape
@@ -23,8 +23,8 @@ export function recordDynKeepsIdentity(shape) {
         shape.fields.some((f) => f.name === "handleEvent" && f.type.kind === "func"));
 }
 /** ScrDynKind values (scr_runtime.h). */
-/** ScrDynHandleTag numeric values (scr_runtime.h's enum order). */
-const DYN_HANDLE_TAG_NUM = {
+/** ScrDynHandleTag values (scr_dyn.h's explicit values; dyn-handle-tags.test.ts checks them). */
+export const DYN_HANDLE_TAG_NUM = {
     httpReq: 0,
     httpRes: 1,
     netSocket: 2,
@@ -35,6 +35,15 @@ const DYN_HANDLE_TAG_NUM = {
     child: 16,
     fileHandle: 17,
     dir: 44,
+    cryptoHash: 52,
+    cryptoHmac: 53,
+};
+/** Handle kinds whose runtime unit boxes them through its own function,
+ * which installs the tag's ops on first use (scr_crypto.h). Programs that
+ * never box one of these values do not link its dynamic members. */
+const DYN_HANDLE_BOX_FN = {
+    cryptoHash: "scr_crypto_hash_to_dyn",
+    cryptoHmac: "scr_crypto_hash_to_dyn",
 };
 export const DYN_KIND = {
     NULL: 0,
@@ -54,6 +63,18 @@ export const DYN_KIND = {
     SYMBOL: 15,
 };
 const FN_ATTRS = "#0";
+/** scr_dyn_builtin_stream_check's kind for a runtime stream class (the
+ * numbering of scr_dyn_builtin_class.c), or null. */
+function builtinStreamKind(className) {
+    const kinds = {
+        "%Readable": 2,
+        "%Writable": 3,
+        "%Duplex": 4,
+        "%Transform": 5,
+        "%PassThrough": 6,
+    };
+    return kinds[className] ?? null;
+}
 export class LlDyn {
     host;
     dynMatchers = new Map();
@@ -444,6 +465,16 @@ export class LlDyn {
      * tracking does not count the read's reference. Returns the value and
      * the matching release. */
     memberRead(B, key, t) {
+        // An accessor slot reads the getter or setter of the accessor property
+        // the checked-dynamic copy holds for it (see accessorSlotProp).
+        const slot = accessorSlotProp(key);
+        if (slot !== null) {
+            this.host.declare(`declare ptr @scr_dyn_obj_accessor_fn(ptr, ptr, ${this.S}, i1 zeroext)`);
+            this.host.declare(`declare void @scr_dyn_release(ptr)`);
+            const fn = B.tmp();
+            B.line(`${fn} = call ptr @scr_dyn_obj_accessor_fn(ptr %d, ptr ${this.host.cstr(slot.prop)}, ${this.S} ${Buffer.byteLength(slot.prop, "utf8")}, i1 ${slot.kind === "set" ? "true" : "false"})`);
+            return { value: fn, release: "scr_dyn_release" };
+        }
         const held = this.isRecursiveShape(t) || this.holdsRecursiveShape(t);
         const release = held ? "scr_dyn_release_held" : "scr_dyn_release";
         this.host.declare(`declare void @${release}(ptr)`);
@@ -575,7 +606,9 @@ export class LlDyn {
             B.terminate(`ret i1 true`);
             B.startBlock(lNext);
         }
-        if (t.kind !== "dyn") {
+        // A union matches a capsule of another type through its arms below: a
+        // class capsule in a `C | undefined` field matches the `C` arm.
+        if (t.kind !== "dyn" && t.kind !== "union") {
             const view = this.viewFn(wrapped);
             this.host.declare(`declare void @scr_dyn_release_v(ptr)`);
             const kind = this.kindOf(B, "%d");
@@ -902,12 +935,19 @@ export class LlDyn {
     jsonSchemas = new Map();
     jsonParsers = new Map();
     recordNameTables = new Map();
+    /** Some emitted helper can keep a record's undeclared source: a checked
+     * record builder that notes it, or a JSON schema of a closed record
+     * (alloc.ts RECORD_SOURCES_GATE). */
+    keepsRecordSources = false;
     /** Targets the one-pass parser (scr_json_parse_schema) can build
-     * directly: number, boolean and string leaves inside arrays and plain
-     * records (no tuple, index signature, internal '%' slot or `__proto__`
-     * member; 1..64 fields). Everything else keeps the checked-dynamic
-     * route alone. */
-    jsonSchemaSupported(t, visiting) {
+     * directly: number, boolean and string leaves inside arrays and records
+     * (no tuple, internal '%' slot or `__proto__` member; at most 64 declared
+     * fields, and at least one unless an index signature collects the
+     * members), record members typed as unions of those leaves, records and
+     * arrays, null and undefined (optional and nullable members; see
+     * jsonUnionSupported), and index signatures whose value type is not a
+     * union. Everything else keeps the checked-dynamic route alone. */
+    jsonSchemaSupported(t, visiting, member = false) {
         switch (t.kind) {
             case "f64":
             case "bool":
@@ -919,19 +959,51 @@ export class LlDyn {
                 if (visiting.has(t.shapeId))
                     return true;
                 const shape = this.host.recordsById.get(t.shapeId);
-                if (!shape || shape.tuple || shape.indexValue)
+                if (!shape || shape.tuple)
                     return false;
-                if (shape.fields.length === 0 || shape.fields.length > 64)
+                const index = shape.indexValue;
+                if (shape.fields.length > 64 || (shape.fields.length === 0 && !index))
                     return false;
                 visiting.add(t.shapeId);
-                return shape.fields.every((f) => !f.name.startsWith("%") &&
+                return (shape.fields.every((f) => !f.name.startsWith("%") &&
                     f.name !== "__proto__" &&
-                    this.jsonSchemaSupported(f.type, visiting));
+                    this.jsonSchemaSupported(f.type, visiting, true)) &&
+                    (!index || this.jsonSchemaSupported(index, visiting)));
             }
+            case "union":
+                return member && this.jsonUnionSupported(t, visiting);
             default:
                 return false;
         }
     }
+    /** A union record member the one-pass parser writes directly: every arm
+     * a number, boolean, string, null, undefined, or a supported record or
+     * array, with at most one record and one array arm and no discriminant.
+     * Each JSON value kind then selects at most one arm, so the checked
+     * route's first full match is that arm, and a value that arm rejects
+     * fails every arm. */
+    jsonUnionSupported(t, visiting) {
+        const def = this.host.unionsById.get(t.unionId);
+        if (!def || def.discriminant)
+            return false;
+        let records = 0, arrays = 0;
+        return def.arms.every((arm) => {
+            switch (arm.kind) {
+                case "f64":
+                case "bool":
+                case "string":
+                case "nullT":
+                case "undefinedT":
+                    return true;
+                case "record":
+                    return ++records === 1 && this.jsonSchemaSupported(arm, visiting);
+                case "array":
+                    return ++arrays === 1 && this.jsonSchemaSupported(arm, visiting);
+                default:
+                    return false;
+            }
+        });
+    }
     /** The ScrJsonSchema constant for t (scr_runtime.h layout). Records list
      * fields in declaration order — the order JSON.stringify writes — so the
      * runtime's next-field guess usually matches without a scan. */
@@ -950,14 +1022,14 @@ export class LlDyn {
             case "bool":
             case "string": {
                 const kind = t.kind === "f64" ? 0 : t.kind === "bool" ? 1 : 2;
-                body = `${S} ${kind}, ${S} 0, ptr null, ptr null, ptr null, ptr null, ptr null`;
+                body = `${S} ${kind}, ${S} 0, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ${S} 0`;
                 break;
             }
             case "array": {
                 const elem = this.jsonSchema(t.elem);
                 const ctor = `${name}_new`;
                 this.defs.push(`define internal ptr @${ctor}(${S} %cap) ${FN_ATTRS} {`, `entry:`, `  %a = ${arrNewCall(host, t.elem, "%cap")}`, `  ret ptr %a`, `}`, ``);
-                body = `${S} 4, ${S} 0, ptr null, ptr @${elem}, ptr null, ptr @${ctor}, ptr ${vAdapters(host, t).release}`;
+                body = `${S} 4, ${S} 0, ptr null, ptr @${elem}, ptr null, ptr @${ctor}, ptr ${vAdapters(host, t).release}, ptr null, ${S} 0`;
                 break;
             }
             case "record": {
@@ -965,27 +1037,99 @@ export class LlDyn {
                 if (!shape)
                     throw new InternalCompilerError(`llvm emitter bug: JSON schema of unknown shape ${t.shapeId}`);
                 const struct = mangleRecordStruct(t.shapeId);
-                const index = new Map(shape.fields.map((f, i) => [f.name, i + 1]));
+                const base = host.nullableUnions.fieldBase(t.shapeId);
+                const index = new Map(shape.fields.map((f, i) => [f.name, i + base]));
                 // The runtime names kept-source keys by this index (record-sources.ts).
                 const order = recordSourceFieldOrder(shape);
+                if (recordMayKeepSource(shape))
+                    this.keepsRecordSources = true;
                 const fieldTy = `{ ptr, ${S}, ${S}, ptr }`;
                 const entries = order.map((fieldName) => {
-                    const field = shape.fields[index.get(fieldName) - 1];
+                    const field = shape.fields[index.get(fieldName) - base];
                     const sub = this.jsonSchema(field.type);
                     const offset = `ptrtoint (ptr getelementptr (%${struct}, ptr null, i64 0, i32 ${index.get(fieldName)}) to ${S})`;
                     return `${fieldTy} { ptr ${host.cstr(fieldName)}, ${S} ${Buffer.byteLength(fieldName, "utf8")}, ${S} ${offset}, ptr @${sub} }`;
                 });
-                const fields = `${name}_fields`;
-                this.defs.push(`@${fields} = internal constant [${entries.length} x ${fieldTy}] [${entries.join(", ")}]`, ``);
-                body = `${S} 3, ${S} ${entries.length}, ptr @${fields}, ptr null, ptr @${mangleRecordNew(t.shapeId)}, ptr null, ptr ${vAdapters(host, t).release}`;
+                let fields = "null";
+                if (entries.length > 0) {
+                    fields = `@${name}_fields`;
+                    this.defs.push(`${fields} = internal constant [${entries.length} x ${fieldTy}] [${entries.join(", ")}]`, ``);
+                }
+                // An index signature's undeclared members go to the overflow map
+                // after the declared fields.
+                const overflow = shape.indexValue
+                    ? {
+                        elem: `@${this.jsonSchema(shape.indexValue)}`,
+                        offset: `ptrtoint (ptr getelementptr (%${struct}, ptr null, i64 0, i32 ${shape.fields.length + base}) to ${S})`,
+                    }
+                    : { elem: "null", offset: "0" };
+                body = `${S} 3, ${S} ${entries.length}, ptr ${fields}, ptr ${overflow.elem}, ptr @${mangleRecordNew(t.shapeId)}, ptr null, ptr ${vAdapters(host, t).release}, ptr null, ${S} ${overflow.offset}`;
                 break;
             }
+            case "union":
+                body = `${S} 5, ${S} 0, ptr null, ptr null, ptr null, ptr null, ptr null, ptr @${this.jsonUnionSchema(t, name)}, ${S} 0`;
+                break;
             default:
                 throw new InternalCompilerError(`llvm emitter bug: JSON schema of ${t.kind}`);
         }
-        this.defs.push(`@${name} = internal constant { ${S}, ${S}, ptr, ptr, ptr, ptr, ptr } { ${body} }`, ``);
+        this.defs.push(`@${name} = internal constant { ${S}, ${S}, ptr, ptr, ptr, ptr, ptr, ptr, ${S} } { ${body} }`, ``);
         return name;
     }
+    /** The ScrJsonUnion descriptor of a union member (scr_json.h layout):
+     * its slot representation, the arm each JSON value kind selects, and the
+     * values the runtime stores for null and for a missing member. Boxed
+     * unions build their boxes through `<name>_box`. */
+    jsonUnionSchema(t, name) {
+        const host = this.host;
+        const S = host.sizeType;
+        const def = host.unionsById.get(t.unionId);
+        if (!def)
+            throw new InternalCompilerError(`llvm emitter bug: JSON schema of ${t.unionId}`);
+        const nullable = host.nullableUnions.has(t.unionId);
+        const inline = host.inlineUnions.record(t);
+        const repr = nullable ? 0 : inline ? 1 : 2;
+        // Indexed by SCR_JARM_*: null, number, boolean, string, object, array, absent.
+        const armKinds = ["nullT", "f64", "bool", "string", "record", "array", "undefinedT"];
+        const tags = armKinds.map((kind) => def.arms.findIndex((arm) => arm.kind === kind));
+        const arms = armKinds.map((_, i) => i >= 1 && i <= 5 && tags[i] >= 0
+            ? `ptr @${this.jsonSchema(def.arms[tags[i]])}`
+            : "ptr null");
+        const nullTag = tags[0];
+        const absentTag = tags[6];
+        const nullValue = !inline && nullTag >= 0 ? host.unitInstanceRef(t.unionId, nullTag) : "null";
+        const absentValue = !inline && absentTag >= 0 ? host.absentInstanceRef(t.unionId) : "null";
+        let box = "null";
+        if (repr === 2) {
+            box = `@${name}_box`;
+            const lines = [`define internal ptr ${box}(i32 %tag, i64 %bits) ${FN_ATTRS} {`, `entry:`];
+            const cases = [];
+            const blocks = [];
+            def.arms.forEach((arm, tag) => {
+                if (arm.kind === "nullT" || arm.kind === "undefinedT")
+                    return;
+                cases.push(`i32 ${tag}, label %arm${tag}`);
+                blocks.push(`arm${tag}:`);
+                if (arm.kind === "f64") {
+                    host.declare(`declare ptr @scr_union_new_f64(i32, double)`);
+                    blocks.push(`  %f${tag} = bitcast i64 %bits to double`, `  %u${tag} = call ptr @scr_union_new_f64(i32 ${tag}, double %f${tag})`);
+                }
+                else if (arm.kind === "bool") {
+                    host.declare(`declare ptr @scr_union_new_bool(i32, i1 zeroext)`);
+                    blocks.push(`  %b${tag} = trunc i64 %bits to i1`, `  %u${tag} = call ptr @scr_union_new_bool(i32 ${tag}, i1 zeroext %b${tag})`);
+                }
+                else {
+                    const rc = vAdapters(host, arm);
+                    host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
+                    blocks.push(`  %p${tag} = inttoptr i64 %bits to ptr`, `  %u${tag} = call ptr @scr_union_new_ref(i32 ${tag}, ptr %p${tag}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`);
+                }
+                blocks.push(`  ret ptr %u${tag}`);
+            });
+            this.defs.push(...lines, `  switch i32 %tag, label %none [ ${cases.join(" ")} ]`, `none:`, `  unreachable`, ...blocks, `}`, ``);
+        }
+        const descriptor = `${name}_union`;
+        this.defs.push(`@${descriptor} = internal constant { ${S}, [7 x ${S}], [7 x ptr], ptr, ptr, ptr } { ${S} ${repr}, [7 x ${S}] [${tags.map((tag) => `${S} ${tag}`).join(", ")}], [7 x ptr] [${arms.join(", ")}], ptr ${nullValue}, ptr ${absentValue}, ptr ${box} }`, ``);
+        return descriptor;
+    }
     /** The declared-name tables scr_record_source_note scans: parallel
      * constant arrays of field-name bytes and byte lengths in declaration
      * order (the order the record serializes), interned per shape. Internal
@@ -1082,6 +1226,20 @@ export class LlDyn {
             B.line(`${ref} = call ptr @scr_dyn_typed_ref_unbox(ptr %d)`);
             B.terminate(`ret ptr ${ref}`);
             B.startBlock(lNext);
+            // A constructor-function stream (scr_dyn_builtin_stream.c) carries
+            // its runtime stream.
+            const streamKind = t.kind === "object" ? builtinStreamKind(t.className) : null;
+            if (streamKind !== null && this.host.usesDynBuiltinStream?.() === true) {
+                host.declare(`declare ptr @scr_dyn_builtin_stream_check(ptr, double)`);
+                const own = B.tmp(), hit = B.tmp();
+                B.line(`${own} = call ptr @scr_dyn_builtin_stream_check(ptr %d, double ${f64Lit(streamKind)})`);
+                B.line(`${hit} = icmp ne ptr ${own}, null`);
+                const lOwn = B.newLabel("dc.ctor"), lNotOwn = B.newLabel("dc.notctor");
+                B.condBr(hit, lOwn, lNotOwn);
+                B.startBlock(lOwn);
+                B.terminate(`ret ptr ${own}`);
+                B.startBlock(lNotOwn);
+            }
             if (t.kind !== "union" && preserveRefs) {
                 const kind = this.kindOf(B, "%d");
                 const capsule = B.tmp();
@@ -1162,17 +1320,18 @@ export class LlDyn {
                         B.line(`call void @scr_arr_outline(ptr ${cached})`);
                         B.line(`call void @scr_arr_outline(ptr ${checked})`);
                     }
+                    const base = t.kind === "record" ? host.nullableUnions.fieldBase(t.shapeId) : 1;
                     const members = t.kind === "record"
                         ? [
                             ...shape.fields.map((field, index) => ({
-                                index: index + 1,
+                                index: index + base,
                                 type: llFieldType(field.type, host.inlineUnions.record(field.type)),
                                 name: field.name,
                             })),
                             ...(shape.indexValue
                                 ? [
                                     {
-                                        index: shape.fields.length + 1,
+                                        index: shape.fields.length + base,
                                         type: "ptr",
                                         name: "[key: string] overflow",
                                     },
@@ -1412,7 +1571,8 @@ export class LlDyn {
                 if (!shape)
                     throw new InternalCompilerError(`llvm emitter bug: dynCheck of unknown shape ${t.shapeId}`);
                 const struct = mangleRecordStruct(t.shapeId);
-                const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + 1]));
+                const base = host.nullableUnions.fieldBase(t.shapeId);
+                const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base]));
                 const releaseR = () => {
                     B.line(`call void ${releaseSym(host, t)}(ptr %r0)`);
                 };
@@ -1555,6 +1715,7 @@ export class LlDyn {
                 // that has them stays beside the record so its reflective
                 // surfaces still observe them (scr_record_source_note).
                 if (recordMayKeepSource(shape)) {
+                    this.keepsRecordSources = true;
                     const names = this.recordNameTable(t.shapeId, shape);
                     host.declare(`declare void @scr_record_source_note(ptr, ptr, ptr, ptr, ${host.sizeType})`);
                     B.line(`call void @scr_record_source_note(ptr %r0, ptr %d, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`);
@@ -1568,8 +1729,19 @@ export class LlDyn {
                     host.declare(`declare void @scr_str_release(ptr)`);
                     const ovfp = B.tmp();
                     const ovf = B.tmp();
-                    B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${shape.fields.length + 1}`);
+                    B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %r0, i64 0, i32 ${shape.fields.length + base}`);
                     B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`);
+                    if (shape.fields.length === 0) {
+                        // Object.create(null)'s dictionary keeps its null prototype:
+                        // ScrDyn.null_proto becomes SCR_MAP_NULL_PROTO.
+                        const npp = B.tmp();
+                        const np = B.tmp();
+                        const flagsp = B.tmp();
+                        B.line(`${npp} = getelementptr inbounds i8, ptr %d, i64 ${this.abiOffset(13, 9)} ; ->null_proto`);
+                        B.line(`${np} = load i8, ptr ${npp}`);
+                        B.line(`${flagsp} = getelementptr inbounds i8, ptr ${ovf}, i64 ${mapFlagsOffset(host.sizeType)}`);
+                        B.line(`store i8 ${np}, ptr ${flagsp}`);
+                    }
                     const n = this.lenOf(B, "%d");
                     const entries = this.itemsOf(B, "%d");
                     this.i64Loop(B, "dcv", n, (i, brNext) => {
@@ -1936,6 +2108,15 @@ export class LlDyn {
         const B = new BlockBuilder();
         let sourceAccessor = null;
         switch (t.kind) {
+            case "date": {
+                // A Date handle holding the same time value; native Dates are
+                // immutable values, and so is the handle.
+                host.declare(`declare ptr @scr_dyn_native_date_from_ms(double)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_dyn_native_date_from_ms(double %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "url":
             case "searchParams": {
                 const native = t.kind === "url" ? "url" : "search_params";
@@ -2073,7 +2254,8 @@ export class LlDyn {
                 if (!shape)
                     throw new InternalCompilerError(`llvm emitter bug: to-dyn of unknown shape ${t.shapeId}`);
                 const struct = mangleRecordStruct(t.shapeId);
-                const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + 1]));
+                const base = host.nullableUnions.fieldBase(t.shapeId);
+                const fieldIndex = new Map(shape.fields.map((f, i) => [f.name, i + base]));
                 const loadFieldOf = (fname, ft) => {
                     const p = B.tmp();
                     B.line(`${p} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${fieldIndex.get(fname)} ; .${llvmCommentText(fname)}`);
@@ -2130,6 +2312,25 @@ export class LlDyn {
                     host.declare(`declare ptr @scr_dyn_new_obj_with_identity(ptr, ptr, ptr)`);
                     B.line(`${d} = call ptr @scr_dyn_new_obj_with_identity(ptr %v, ptr ${rc.retain}, ptr @${sourceAccessor.name})`);
                 }
+                else if (shape.indexValue && shape.fields.length === 0) {
+                    // A pure index-signature record keeps a null prototype
+                    // (SCR_MAP_NULL_PROTO on its overflow map; Object.groupBy).
+                    host.declare(`declare ptr @scr_dyn_new_obj()`);
+                    host.declare(`declare ptr @scr_dyn_new_obj_null_proto()`);
+                    const ovfp = B.tmp();
+                    const ovf = B.tmp();
+                    const flagsp = B.tmp();
+                    const flags = B.tmp();
+                    const np = B.tmp();
+                    const alloc = B.tmp();
+                    B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 1`);
+                    B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`);
+                    B.line(`${flagsp} = getelementptr inbounds i8, ptr ${ovf}, i64 ${mapFlagsOffset(host.sizeType)}`);
+                    B.line(`${flags} = load i8, ptr ${flagsp}`);
+                    B.line(`${np} = icmp ne i8 ${flags}, 0`);
+                    B.line(`${alloc} = select i1 ${np}, ptr @scr_dyn_new_obj_null_proto, ptr @scr_dyn_new_obj`);
+                    B.line(`${d} = call ptr ${alloc}()`);
+                }
                 else {
                     host.declare(`declare ptr @scr_dyn_new_obj()`);
                     B.line(`${d} = call ptr @scr_dyn_new_obj()`);
@@ -2137,13 +2338,43 @@ export class LlDyn {
                 // Keys insert in DECLARED order (JS insertion order); internal
                 // '%'-fields follow so a record→dyn→record round trip keeps them.
                 const byName = new Map(shape.fields.map((f) => [f.name, f]));
-                const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
+                // An accessor property is one key whose getter and setter are the
+                // slot closures (see accessorSlotProp), in accessorOrder's place.
+                const order = shape.accessorOrder ?? shape.declaredOrder ?? shape.fields.map((f) => f.name);
                 const inOrder = new Set(order);
+                const accessors = new Set(shape.accessorOrder === undefined
+                    ? []
+                    : shape.fields.flatMap((f) => {
+                        const slot = accessorSlotProp(f.name);
+                        return slot === null ? [] : [slot.prop];
+                    }));
                 const dynFields = [
-                    ...order.map((n) => byName.get(n)).filter((f) => f !== undefined),
-                    ...shape.fields.filter((f) => !inOrder.has(f.name)),
+                    ...order.flatMap((n) => {
+                        if (accessors.has(n))
+                            return [{ accessor: n }];
+                        const f = byName.get(n);
+                        return f === undefined ? [] : [f];
+                    }),
+                    ...shape.fields.filter((f) => !inOrder.has(f.name) && !(accessors.size > 0 && accessorSlotProp(f.name) !== null)),
                 ];
-                for (const f of dynFields) {
+                for (const entry of dynFields) {
+                    if ("accessor" in entry) {
+                        host.declare(`declare void @scr_dyn_obj_set_accessor(ptr, ptr, ${host.sizeType}, ptr, ptr)`);
+                        const boxed = (kind) => {
+                            const slot = byName.get(`%${kind}:${entry.accessor}`);
+                            if (slot === undefined)
+                                return "null";
+                            const fv = loadFieldOf(slot.name, slot.type);
+                            const conv = B.tmp();
+                            B.line(`${conv} = call ptr @${this.toDynHelper(slot.type)}(${this.valTy(slot.type)} ${fv})`);
+                            return conv;
+                        };
+                        const getter = boxed("get");
+                        const setter = boxed("set");
+                        B.line(`call void @scr_dyn_obj_set_accessor(ptr ${d}, ptr ${host.cstr(entry.accessor)}, ${host.sizeType} ${Buffer.byteLength(entry.accessor, "utf8")}, ptr ${getter}, ptr ${setter}) ; ${llvmCommentText(entry.accessor)}`);
+                        continue;
+                    }
+                    const f = entry;
                     const klen = Buffer.byteLength(f.name, "utf8");
                     const fv = loadFieldOf(f.name, f.type);
                     // An ABSENT optional field contributes no key.
@@ -2171,7 +2402,7 @@ export class LlDyn {
                     host.declare(`declare void @scr_arr_release(ptr)`);
                     const ovfp = B.tmp();
                     const ovf = B.tmp();
-                    B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${shape.fields.length + 1}`);
+                    B.line(`${ovfp} = getelementptr inbounds %${struct}, ptr %v, i64 0, i32 ${shape.fields.length + base}`);
                     B.line(`${ovf} = load ptr, ptr ${ovfp} ; overflow map`);
                     const ks = B.tmp();
                     const len = B.tmp();
@@ -2407,9 +2638,16 @@ export class LlDyn {
                 // tag's installed ops.
                 const h = DYN_HANDLE_KINDS.get(t.kind);
                 if (h) {
-                    host.declare(`declare ptr @scr_dyn_new_handle(ptr, i32)`);
+                    const box = DYN_HANDLE_BOX_FN[t.kind];
                     const r = B.tmp();
-                    B.line(`${r} = call ptr @scr_dyn_new_handle(ptr %v, i32 ${DYN_HANDLE_TAG_NUM[t.kind]})`);
+                    if (box) {
+                        host.declare(`declare ptr @${box}(ptr)`);
+                        B.line(`${r} = call ptr @${box}(ptr %v)`);
+                    }
+                    else {
+                        host.declare(`declare ptr @scr_dyn_new_handle(ptr, i32)`);
+                        B.line(`${r} = call ptr @scr_dyn_new_handle(ptr %v, i32 ${DYN_HANDLE_TAG_NUM[t.kind]})`);
+                    }
                     B.terminate(`ret ptr ${r}`);
                     break;
                 }
@@ -2660,88 +2898,26 @@ export class LlDyn {
                 this.puts(B, "%b", "[object Object]");
                 B.br(done);
                 B.startBlock(lErr);
-                const en = this.objGetLit(B, "%d", "name");
-                const em = this.objGetLit(B, "%d", "message");
-                // ens/ems: the member's ScrStr when it is a string, else null.
-                const strOf = (m, hint) => {
-                    const slot = B.slot();
-                    B.entryAllocas.push(`${slot} = alloca ptr`);
-                    B.line(`store ptr null, ptr ${slot}`);
-                    const nn = B.tmp();
-                    B.line(`${nn} = icmp ne ptr ${m}, null`);
-                    const lt = B.newLabel(`${hint}.t`);
-                    const lj = B.newLabel(`${hint}.j`);
-                    B.condBr(nn, lt, lj);
-                    B.startBlock(lt);
-                    const k = this.kindOf(B, m);
-                    const isStr = B.tmp();
-                    B.line(`${isStr} = icmp eq i32 ${k}, ${DYN_KIND.STR}`);
-                    const ls = B.newLabel(`${hint}.s`);
-                    B.condBr(isStr, ls, lj);
-                    B.startBlock(ls);
-                    const sv = this.payloadOf(B, m, "ptr");
-                    B.line(`store ptr ${sv}, ptr ${slot}`);
-                    B.br(lj);
-                    B.startBlock(lj);
-                    const out = B.tmp();
-                    B.line(`${out} = load ptr, ptr ${slot}`);
-                    return out;
-                };
-                const ens = strOf(en, "ds.en");
-                const ems = strOf(em, "ds.em");
-                const putIf = (s, hint) => {
-                    const nn = B.tmp();
-                    B.line(`${nn} = icmp ne ptr ${s}, null`);
-                    const lt = B.newLabel(`${hint}.t`);
-                    const lj = B.newLabel(`${hint}.j`);
-                    B.condBr(nn, lt, lj);
-                    B.startBlock(lt);
-                    this.putScrStr(B, "%b", s);
-                    B.br(lj);
-                    B.startBlock(lj);
-                };
-                putIf(ens, "ds.pn");
-                {
-                    // if (ens && ens->len && ems && ems->len) ": "
-                    const lenNz = (s, hint) => {
-                        const slot = B.slot();
-                        B.entryAllocas.push(`${slot} = alloca i1`);
-                        B.line(`store i1 false, ptr ${slot}`);
-                        const nn = B.tmp();
-                        B.line(`${nn} = icmp ne ptr ${s}, null`);
-                        const lt = B.newLabel(`${hint}.t`);
-                        const lj = B.newLabel(`${hint}.j`);
-                        B.condBr(nn, lt, lj);
-                        B.startBlock(lt);
-                        const { len } = this.strParts(B, s);
-                        const nz = B.tmp();
-                        B.line(`${nz} = icmp ne ${this.S} ${len}, 0`);
-                        B.line(`store i1 ${nz}, ptr ${slot}`);
-                        B.br(lj);
-                        B.startBlock(lj);
-                        const out = B.tmp();
-                        B.line(`${out} = load i1, ptr ${slot}`);
-                        return out;
-                    };
-                    const a = lenNz(ens, "ds.ln");
-                    const b2 = lenNz(ems, "ds.lm");
-                    const both = B.tmp();
-                    B.line(`${both} = and i1 ${a}, ${b2}`);
-                    const lt = B.newLabel("ds.cl");
-                    const lj = B.newLabel("ds.cj");
-                    B.condBr(both, lt, lj);
-                    B.startBlock(lt);
-                    this.puts(B, "%b", ": ");
-                    B.br(lj);
-                    B.startBlock(lj);
-                }
-                putIf(ems, "ds.pm");
+                // Error.prototype.toString, reading name and message through the
+                // prototype. Null leaves the exception its conversion threw pending.
+                host.declare(`declare ptr @scr_dyn_error_string(ptr)`);
+                host.declare(`declare void @scr_str_release(ptr)`);
+                const text = B.tmp();
+                B.line(`${text} = call ptr @scr_dyn_error_string(ptr %d)`);
+                const written = B.tmp();
+                B.line(`${written} = icmp ne ptr ${text}, null`);
+                const lPut = B.newLabel("ds.ep");
+                B.condBr(written, lPut, done);
+                B.startBlock(lPut);
+                this.putScrStr(B, "%b", text);
+                B.line(`call void @scr_str_release(ptr ${text})`);
                 B.br(done);
             }
             B.startBlock(labels.get(DYN_KIND.BYTES));
             {
-                // Buffer-flavored values coerce utf8; plain Uint8Array joins
-                // its elements.
+                // Buffer-flavored values coerce utf8; typed arrays join their
+                // elements and a DataView answers "[object DataView]" (the
+                // runtime's conversion).
                 const bufp = B.tmp();
                 const bufRaw = B.tmp();
                 const isBuf = B.tmp();
@@ -2761,10 +2937,9 @@ export class LlDyn {
                 B.line(`call void @scr_str_release(ptr ${txt})`);
                 B.br(done);
                 B.startBlock(lJoin);
-                const bts = this.payloadOf(B, "%d", "ptr");
-                host.declare(`declare ptr @scr_bytes_join(ptr, ptr)`);
+                host.declare(`declare ptr @scr_dyn_to_string(ptr, ptr)`);
                 const joined = B.tmp();
-                B.line(`${joined} = call ptr @scr_bytes_join(ptr ${bts}, ptr ${host.internLiteral(",")})`);
+                B.line(`${joined} = call ptr @scr_dyn_to_string(ptr %d, ptr null)`);
                 this.putScrStr(B, "%b", joined);
                 B.line(`call void @scr_str_release(ptr ${joined})`);
                 B.br(done);
@@ -3131,6 +3306,21 @@ export class LlDyn {
             B.terminate(`ret ptr ${r}`);
             B.startBlock(lNext);
         }
+        // PROMISE: Promise.prototype.then/catch/finally as function values;
+        // every other key is undefined (promises have no own properties).
+        {
+            const isP = B.tmp();
+            B.line(`${isP} = icmp eq i32 ${kd}, ${DYN_KIND.PROMISE}`);
+            const lP = B.newLabel("kg.p");
+            const lNext = B.newLabel("kg.n");
+            B.condBr(isP, lP, lNext);
+            B.startBlock(lP);
+            host.declare(`declare ptr @scr_dyn_promise_key_get(ptr, ptr)`);
+            const r = B.tmp();
+            B.line(`${r} = call ptr @scr_dyn_promise_key_get(ptr %d, ptr %k)`);
+            B.terminate(`ret ptr ${r}`);
+            B.startBlock(lNext);
+        }
         // The canonical-index parse, shared by BYTES/ARR/STR: digits only,
         // no leading zero. Leaves (digits, idx).
         const parseIndex = () => {
@@ -3425,14 +3615,9 @@ export class LlDyn {
         const name = "sc_dyn_iter_n";
         this.dynBuilders.set(memoKey, name);
         const host = this.host;
-        host.declare(`declare void @scr_jb_init(ptr)`);
-        host.declare(`declare ptr @scr_jb_finish(ptr)`);
-        host.declare(`declare void @scr_jb_puts(ptr, ptr)`);
-        host.declare(`declare void @scr_throw_error(i32, ptr)`);
         host.declare(`declare ptr @scr_dyn_new_arr()`);
         host.declare(`declare void @scr_dyn_arr_push(ptr, ptr)`);
         host.declare(`declare ptr @scr_dyn_new_num(double)`);
-        host.declare(`declare ptr @scr_f64_to_scrstr(double)`);
         host.declare(`declare void @scr_str_release(ptr)`);
         const B = new BlockBuilder();
         const kd = this.kindOf(B, "%d");
@@ -3444,6 +3629,19 @@ export class LlDyn {
             const lNext = B.newLabel("din.nt");
             B.condBr(isTyped, lTyped, lNext);
             B.startBlock(lTyped);
+            // Compiled generators step through the iterator protocol.
+            host.declare(`declare i1 @scr_dyn_iterates_by_protocol(ptr)`);
+            host.declare(`declare ptr @scr_dyn_iter_take(ptr, ${host.sizeType}, ptr)`);
+            const protocol = B.tmp();
+            const lProtocol = B.newLabel("din.pr");
+            const lView = B.newLabel("din.vw");
+            B.line(`${protocol} = call i1 @scr_dyn_iterates_by_protocol(ptr %d)`);
+            B.condBr(protocol, lProtocol, lView);
+            B.startBlock(lProtocol);
+            const stepped = B.tmp();
+            B.line(`${stepped} = call ptr @scr_dyn_iter_take(ptr %d, ${host.sizeType} %n, ptr %spelling)`);
+            B.terminate(`ret ptr ${stepped}`);
+            B.startBlock(lView);
             host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
             host.declare(`declare void @scr_dyn_release_v(ptr)`);
             const materialized = B.tmp();
@@ -3467,66 +3665,13 @@ export class LlDyn {
         const lGo = B.newLabel("din.g");
         const lThrow = B.newLabel("din.t");
         B.condBr(ok, lGo, lThrow);
-        // V8's exact not-iterable TypeError.
+        // Other iterables step through the iterator protocol; non-iterables
+        // throw V8's exact not-iterable TypeError.
         B.startBlock(lThrow);
-        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");
-        const lNum = B.newLabel("din.m");
-        const lF = B.newLabel("din.f");
-        const lDef = B.newLabel("din.d");
-        const lTail = B.newLabel("din.e");
-        B.terminate(`switch i32 ${kd}, label %${lDef} [ i32 ${DYN_KIND.UNDEF}, label %${lU} i32 ${DYN_KIND.NULL}, label %${lN} i32 ${DYN_KIND.BOOL}, label %${lB2} i32 ${DYN_KIND.NUM}, label %${lNum} i32 ${DYN_KIND.FUNC}, label %${lF} ]`);
-        B.startBlock(lU);
-        this.puts(B, buf, "undefined");
-        B.br(lTail);
-        B.startBlock(lN);
-        this.puts(B, buf, "object null");
-        B.br(lTail);
-        B.startBlock(lB2);
-        {
-            const bv = this.boolOf(B, "%d");
-            const s = B.tmp();
-            B.line(`${s} = select i1 ${bv}, ptr ${host.cstr("boolean true")}, ptr ${host.cstr("boolean false")}`);
-            B.line(`call void @scr_jb_puts(ptr ${buf}, ptr ${s})`);
-            B.br(lTail);
-        }
-        B.startBlock(lNum);
-        {
-            this.puts(B, buf, "number ");
-            const x = this.payloadOf(B, "%d", "double");
-            const s = B.tmp();
-            B.line(`${s} = call ptr @scr_f64_to_scrstr(double ${x})`);
-            this.putScrStr(B, buf, s);
-            B.line(`call void @scr_str_release(ptr ${s})`);
-            B.br(lTail);
-        }
-        B.startBlock(lF);
-        this.puts(B, buf, "function");
-        B.br(lTail);
-        B.startBlock(lDef);
-        this.puts(B, buf, "object");
-        B.br(lTail);
-        B.startBlock(lTail);
-        this.puts(B, buf, " is not iterable (cannot read property Symbol(Symbol.iterator))");
-        const msg = B.tmp();
-        B.line(`${msg} = call ptr @scr_jb_finish(ptr ${buf})`);
-        B.line(`call void @scr_throw_error(i32 1, ptr ${msg}) ; SCR_ERR_TYPE`);
-        B.terminate(`ret ptr null`);
+        host.declare(`declare ptr @scr_dyn_iter_take(ptr, ${host.sizeType}, ptr)`);
+        const taken = B.tmp();
+        B.line(`${taken} = call ptr @scr_dyn_iter_take(ptr %d, ${host.sizeType} %n, ptr %spelling)`);
+        B.terminate(`ret ptr ${taken}`);
         B.startBlock(lGo);
         const out = B.tmp();
         B.line(`${out} = call ptr @scr_dyn_new_arr()`);