@scriptc/compiler 0.1.7 → 0.2.1

package/dist/backend/llvm/expr-stream-bridges.d.ts

@@ -1,13 +1,13 @@
-import { IrType } from "../../ir/ir.js";
+import { type IrType } from "../../ir/ir.js";
 import { BlockBuilder } from "./blocks.js";
-import type { LlvmEmitterContext, LlStreamTypedRefAdapter, LlStreamTypedRefContext } from "./expr-context.js";
+import type { LlvmEmitterContext, LlStreamTypedRefAdapter } from "./expr-context.js";
 export declare function dynPromiseAdapter(host: LlvmEmitterContext, inner: IrType): string;
 export declare function streamTypedRefCommitAdapter(host: LlvmEmitterContext, t: IrType, snapshot: string): string;
 export declare function liveDynUnionRefAdapter(host: LlvmEmitterContext, t: IrType & {
     kind: "union";
 }): string;
-export declare function streamTypedRefBoxValue(host: LlvmEmitterContext, B: BlockBuilder, t: IrType, value: string, ctx: LlStreamTypedRefContext): string;
-export declare function streamTypedRefMaterializeAdapter(host: LlvmEmitterContext, t: IrType, ctx: LlStreamTypedRefContext, preferredSnapshot?: string): LlStreamTypedRefAdapter;
+export declare function streamTypedRefBoxValue(host: LlvmEmitterContext, B: BlockBuilder, t: IrType, value: string): string;
+export declare function streamTypedRefMaterializeAdapter(host: LlvmEmitterContext, t: IrType): LlStreamTypedRefAdapter;
 export declare function streamFromArrayAdapter(host: LlvmEmitterContext, t: IrType & {
     kind: "array";
 }): string;

package/dist/backend/llvm/expr-stream-bridges.js

@@ -1,14 +1,15 @@
+import { typedRefConstructor } from "./shapes.js";
 /* Focused LLVM expression emission extracted from emitter.ts. */
 import { InternalCompilerError } from "../../errors.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
-import { isClassOwnEnumerableFieldName, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
-import { mangleRecordStruct } from "../mangle.js";
+import { DYN_CLASS_PROPERTIES, RUNTIME_STREAM_CLASSES, SYMBOL_T, classDynViewSupported, isClassOwnEnumerableFieldName, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
+import { mangleFunction, mangleGlobal, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { classFieldIndex, classStructSym } from "./classes.js";
 import { llvmCommentText } from "./common.js";
 import { FN_ATTRS, llFieldType, releaseSym, traceArg, vAdapters } from "./shapes.js";
 export function dynPromiseAdapter(host, inner) {
-    if (!isRefCounted(inner) || inner.kind === "dyn") {
+    if (inner.kind === "dyn") {
         throw new InternalCompilerError(`dynamic promise adapter requires a concrete reference type, got ${typeKey(inner)}`);
     }
     const key = typeKey(inner);
@@ -26,7 +27,7 @@ export function dynPromiseAdapter(host, inner) {
     const value = B.tmp();
     const pending = B.tmp();
     B.line(`${dyn} = call ptr @scr_promise_payload_ref(ptr %src)`);
-    B.line(`${value} = call ptr @${host.dyn.dynCheckHelper(inner)}(ptr ${dyn}, ptr null)`);
+    B.line(inner.kind === "void" ? `; void fulfillment ignores the checked payload` : `${value} = call ${host.llType(inner)} @${host.dyn.dynCheckHelper(inner)}(ptr ${dyn}, ptr null)`);
     B.line(`call void @scr_dyn_release_v(ptr ${dyn})`);
     B.line(`${pending} = call zeroext i1 @scr_exc_pending()`);
     const fail = B.newLabel("sra.fail");
@@ -36,14 +37,23 @@ export function dynPromiseAdapter(host, inner) {
     B.line(`call void @scr_promise_reject_pending(ptr %dst)`);
     B.terminate(`ret void`);
     B.startBlock(ok);
-    if (inner.kind === "string") {
+    if (inner.kind === "void") {
+        host.declare(`declare void @scr_promise_fulfill_void(ptr)`);
+        B.line(`call void @scr_promise_fulfill_void(ptr %dst)`);
+    }
+    else if (inner.kind === "f64" || inner.kind === "date" || inner.kind === "bool") {
+        const fn = inner.kind !== "bool" ? "scr_promise_fulfill_f64" : "scr_promise_fulfill_bool";
+        host.declare(`declare void @${fn}(ptr, ${host.llType(inner)}${inner.kind === "bool" ? " zeroext" : ""})`);
+        B.line(`call void @${fn}(ptr %dst, ${host.llType(inner)}${inner.kind === "bool" ? " zeroext" : ""} ${value})`);
+    }
+    else if (inner.kind === "string") {
         host.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
         B.line(`call void @scr_promise_fulfill_str(ptr %dst, ptr ${value})`);
     }
     else {
-        const rc = vAdapters(host, inner);
+        const rc = vAdapters(host.shapeHost, inner);
         host.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
-        B.line(`call void @scr_promise_fulfill_ref(ptr %dst, ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, inner)})`);
+        B.line(`call void @scr_promise_fulfill_ref(ptr %dst, ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host.shapeHost, inner)})`);
     }
     B.terminate(`ret void`);
     host.resolveThunkDefs.push(`define internal void @${sym}(ptr %dst, ptr %src) ${FN_ATTRS} { ; checked-dynamic promise exit ${key}`, B.render(), `}`, ``);
@@ -81,6 +91,7 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             { name: "props", index: 12, type: "ptr" },
             { name: "prop_len", index: 13, type: host.sizeType },
             { name: "prop_cap", index: 14, type: host.sizeType },
+            { name: "metadata", index: 15, type: "ptr" },
         ];
         for (const member of storageMembers) {
             lines.push(`  %target_${member.name}_ptr = getelementptr inbounds %ScrArr, ptr %target, i64 0, i32 ${member.index}`, `  %next_${member.name}_ptr = getelementptr inbounds %ScrArr, ptr %next, i64 0, i32 ${member.index}`, `  %target_${member.name} = load ${member.type}, ptr %target_${member.name}_ptr`, `  %next_${member.name} = load ${member.type}, ptr %next_${member.name}_ptr`, `  store ${member.type} %next_${member.name}, ptr %target_${member.name}_ptr`, `  store ${member.type} %target_${member.name}, ptr %next_${member.name}_ptr`);
@@ -102,7 +113,9 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             `define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit unknown class ${typeKey(t)}`,
             `entry:`,
         ];
-        const fields = meta.def.fields.filter((field) => isClassOwnEnumerableFieldName(field.name));
+        const symbols = new Map((meta.def.symbolFields ?? []).map((symbol) => [symbol.field, symbol.globalId]));
+        const fields = meta.def.fields.filter((field) => (isClassOwnEnumerableFieldName(field.name) || symbols.has(field.name)) &&
+            !(meta.root.def.name === "%Error" && (field.name === "message" || field.name === "name")));
         for (const [index, field] of fields.entries()) {
             const next = `f${index}_next`;
             const raw = `f${index}_raw`;
@@ -115,7 +128,23 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
             const { index: fieldIndex } = classFieldIndex(meta, field.name);
             const fieldTy = llFieldType(field.type);
             const checkTy = field.type.kind === "f64" ? "double" : field.type.kind === "bool" ? "i1" : "ptr";
-            lines.push(`  %${raw} = call ptr @scr_dyn_obj_get(ptr %d, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")})`, `  %${missing} = icmp eq ptr %${raw}, null`, `  %${undef} = call ptr @scr_dyn_undefined()`, `  %${input} = select i1 %${missing}, ptr %${undef}, ptr %${raw}`, `  %${next} = call ${field.type.kind === "bool" ? "zeroext " : ""}${checkTy} @${host.dyn.dynCheckHelper(field.type)}(ptr %${input}, ptr null)`, `  %${pending} = call zeroext i1 @scr_exc_pending()`, `  br i1 %${pending}, label %done, label %${store}`, `${store}:`, `  %f${index}_ptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${fieldIndex}`, `  %f${index}_old = load ${fieldTy}, ptr %f${index}_ptr`);
+            const symbolGlobal = symbols.get(field.name);
+            if (symbolGlobal) {
+                host.declare(`declare ptr @scr_dyn_symbol_key_get(ptr, ptr, i1 zeroext)`);
+                host.declare(`declare void @scr_dyn_release_v(ptr)`);
+                lines.push(`  %f${index}_keyraw = load ptr, ptr @${mangleGlobal(symbolGlobal)}`, `  %f${index}_key = call ptr @${host.dyn.toDynHelper(SYMBOL_T)}(ptr %f${index}_keyraw)`);
+                if (field.type.kind === "symbol") {
+                    // A base constructor can mutate the instance before this
+                    // derived field initializes. An absent snapshot entry leaves
+                    // that native slot uninitialized until its declaration runs.
+                    host.declare(`declare zeroext i1 @scr_dyn_has_own_computed(ptr, ptr)`);
+                    lines.push(`  %f${index}_present = call zeroext i1 @scr_dyn_has_own_computed(ptr %d, ptr %f${index}_key)`, `  %f${index}_priorptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${fieldIndex}`, `  %f${index}_prior = load ptr, ptr %f${index}_priorptr`, `  %f${index}_initialized = icmp ne ptr %f${index}_prior, null`, `  %f${index}_read = or i1 %f${index}_present, %f${index}_initialized`, `  br i1 %f${index}_read, label %f${index}_read_symbol, label %f${index}_absent_symbol`, `f${index}_absent_symbol:`, `  call void @scr_dyn_release_v(ptr %f${index}_key)`, `  br label %${after}`, `f${index}_read_symbol:`);
+                }
+                lines.push(`  %${raw} = call ptr @scr_dyn_symbol_key_get(ptr %d, ptr %f${index}_key, i1 zeroext false)`, `  call void @scr_dyn_release_v(ptr %f${index}_key)`);
+            }
+            else
+                lines.push(`  %${raw} = call ptr @scr_dyn_obj_get(ptr %d, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")})`);
+            lines.push(`  %${missing} = icmp eq ptr %${raw}, null`, `  %${undef} = call ptr @scr_dyn_undefined()`, `  %${input} = select i1 %${missing}, ptr %${undef}, ptr %${raw}`, `  %${next} = call ${field.type.kind === "bool" ? "zeroext " : ""}${checkTy} @${host.dyn.dynCheckHelper(field.type)}(ptr %${input}, ptr null)`, ...(symbolGlobal ? [`  call void @scr_dyn_release_v(ptr %${raw})`] : []), `  %${pending} = call zeroext i1 @scr_exc_pending()`, `  br i1 %${pending}, label %done, label %${store}`, `${store}:`, `  %f${index}_ptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${fieldIndex}`, `  %f${index}_old = load ${fieldTy}, ptr %f${index}_ptr`);
             if (field.type.kind === "bool") {
                 lines.push(`  %f${index}_stored = zext i1 %${next} to i8`, `  store i8 %f${index}_stored, ptr %f${index}_ptr`);
             }
@@ -123,10 +152,36 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
                 lines.push(`  store ${fieldTy} %${next}, ptr %f${index}_ptr`);
             }
             if (isRefCounted(field.type)) {
-                lines.push(`  call void ${releaseSym(host, field.type)}(ptr %f${index}_old)`);
+                lines.push(`  call void ${releaseSym(host.shapeHost, field.type)}(ptr %f${index}_old)`);
             }
             lines.push(`  br label %${after}`, `${after}:`);
         }
+        if (meta.def.fields.some((field) => field.name === DYN_CLASS_PROPERTIES)) {
+            host.declare(`declare ptr @scr_dyn_new_obj()`);
+            host.declare(`declare ptr @scr_dyn_copy_property_descriptors(ptr, ptr)`);
+            host.declare(`declare void @scr_dyn_release_v(ptr)`);
+            host.declare(`declare ptr @scr_str_new(ptr, ${host.sizeType})`);
+            host.declare(`declare void @scr_str_release(ptr)`);
+            host.declare(`declare void @scr_dyn_key_delete(ptr, ptr, i1 zeroext)`);
+            lines.push(`  %bag = call ptr @scr_dyn_new_obj()`, `  %bag_copy = call ptr @scr_dyn_copy_property_descriptors(ptr %bag, ptr %d)`, `  call void @scr_dyn_release_v(ptr %bag_copy)`, `  %bag_pending = call zeroext i1 @scr_exc_pending()`, `  br i1 %bag_pending, label %bag_fail, label %bag_keys`, `bag_fail:`, `  call void @scr_dyn_release_v(ptr %bag)`, `  br label %done`, `bag_keys:`);
+            if (meta.def.instancePrototypeHelper || meta.def.prototypeDataHelper) {
+                host.declare(`declare ptr @scr_dyn_set_prototype(ptr, ptr)`);
+                lines.push(...(meta.def.instancePrototypeHelper ? [
+                    `  %prototype_receiver = call ptr ${vAdapters(host.shapeHost, t).retain}(ptr %target)`,
+                    `  %prototype = call ptr @${mangleFunction(meta.def.instancePrototypeHelper)}(ptr %prototype_receiver)`,
+                ] : [`  %prototype = call ptr @${mangleFunction(meta.def.prototypeDataHelper)}()`]), `  %with_prototype = call ptr @scr_dyn_set_prototype(ptr %bag, ptr %prototype)`, `  call void @scr_dyn_release_v(ptr %prototype)`, `  call void @scr_dyn_release_v(ptr %with_prototype)`);
+            }
+            fields.filter((field) => !symbols.has(field.name)).forEach((field, index) => lines.push(`  %bag_key${index} = call ptr @scr_str_new(ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")})`, `  call void @scr_dyn_key_delete(ptr %bag, ptr %bag_key${index}, i1 zeroext false)`, `  call void @scr_str_release(ptr %bag_key${index})`));
+            if (symbols.size > 0)
+                host.declare(`declare void @scr_dyn_key_delete_computed(ptr, ptr, i1 zeroext)`);
+            [...symbols.values()].forEach((globalId, index) => lines.push(`  %bag_symraw${index} = load ptr, ptr @${mangleGlobal(globalId)}`, `  %bag_sym${index} = call ptr @${host.dyn.toDynHelper(SYMBOL_T)}(ptr %bag_symraw${index})`, `  call void @scr_dyn_key_delete_computed(ptr %bag, ptr %bag_sym${index}, i1 zeroext false)`, `  call void @scr_dyn_release_v(ptr %bag_sym${index})`));
+            const { index } = classFieldIndex(meta, DYN_CLASS_PROPERTIES);
+            lines.push(`  %bag_ptr = getelementptr inbounds %${classStructSym(t.className)}, ptr %target, i64 0, i32 ${index}`, `  %bag_old = load ptr, ptr %bag_ptr`, `  store ptr %bag, ptr %bag_ptr`, `  call void @scr_dyn_release_v(ptr %bag_old)`);
+        }
+        if (meta.root.def.name === "%Error") {
+            host.declare(`declare void @scr_error_commit_dyn(ptr, ptr)`);
+            lines.push(`  call void @scr_error_commit_dyn(ptr %target, ptr %d)`);
+        }
         lines.push(`  br label %done`, `done:`, `  ret void`, `}`, ``);
         host.resolveThunkDefs.push(...lines);
         return `@${commit}`;
@@ -164,7 +219,7 @@ export function streamTypedRefCommitAdapter(host, t, snapshot) {
     members.forEach((member, index) => {
         lines.push(`  %tp${index} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %target, i64 0, i32 ${member.index}`, `  %np${index} = getelementptr inbounds %${mangleRecordStruct(t.shapeId)}, ptr %next, i64 0, i32 ${member.index}`, `  %old${index} = load ${member.type}, ptr %tp${index} ; ${llvmCommentText(member.name)}`, `  %new${index} = load ${member.type}, ptr %np${index}`, `  store ${member.type} %new${index}, ptr %tp${index}`, `  store ${member.type} %old${index}, ptr %np${index}`);
     });
-    lines.push(`  call void ${releaseSym(host, t)}(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
+    lines.push(`  call void ${releaseSym(host.shapeHost, t)}(ptr %next)`, `  br label %done`, `done:`, `  ret void`, `}`, ``);
     host.resolveThunkDefs.push(...lines);
     return `@${commit}`;
 }
@@ -179,17 +234,15 @@ export function liveDynUnionRefAdapter(host, t) {
     }
     const mutableArms = union.arms
         .map((arm, tag) => ({ arm, tag }))
-        .filter(({ arm }) => streamTypedRefEligible(arm) || isDynTypedRefType(arm));
-    if (mutableArms.length === 0) {
+        .filter(({ arm }) => arm.kind !== "bytes" && (streamTypedRefEligible(arm) || isDynTypedRefType(arm)));
+    if (mutableArms.length === 0 && !union.arms.some((arm) => arm.kind === "bytes")) {
         throw new InternalCompilerError(`llvm emitter bug: live dyn ref of immutable union ${key}`);
     }
     const sym = `sc_ldu_${host.liveDynUnionRefAdapters.size}`;
     host.liveDynUnionRefAdapters.set(key, sym);
-    host.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${host.sizeType}, ptr, ptr)`);
     const adapters = new Map();
     for (const { arm, tag } of mutableArms) {
-        const prefix = `${sym}_${tag}`;
-        adapters.set(tag, host.streamTypedRefMaterializeAdapter(arm, { prefix, adapters: new Map() }, `${prefix}_materialize`));
+        adapters.set(tag, host.liveDynRefAdapter(arm));
     }
     const B = new BlockBuilder();
     const tagPtr = B.tmp();
@@ -209,7 +262,7 @@ export function liveDynUnionRefAdapter(host, t) {
     ].join(" ")} ]`);
     mutableArms.forEach(({ arm, tag }, index) => {
         const adapter = adapters.get(tag);
-        const rc = vAdapters(host, arm);
+        const rc = vAdapters(host.shapeHost, arm);
         const armKey = typeKey(arm);
         B.startBlock(armLabels[index]);
         const payloadPtr = B.tmp();
@@ -217,7 +270,7 @@ export function liveDynUnionRefAdapter(host, t) {
         const boxed = B.tmp();
         B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 5`);
         B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
-        B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(armKey)}, ${host.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
+        B.line(`${boxed} = call ptr ${typedRefConstructor(host.shapeHost, arm)}(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(armKey)}, ${host.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
         B.terminate(`ret ptr ${boxed}`);
     });
     valueArms.forEach(({ arm }, index) => {
@@ -272,99 +325,14 @@ export function liveDynUnionRefAdapter(host, t) {
     host.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %u) ${FN_ATTRS} { ; materialize live union value ${key}`, B.render(), `}`, ``);
     return sym;
 }
-function nestedTypedRefUnionAdapter(host, t, ctx) {
-    const key = typeKey(t);
-    const unions = (ctx.unions ??= new Map());
-    const existing = unions.get(key);
-    if (existing)
-        return existing;
-    const def = host.unionsById.get(t.unionId);
-    if (!def) {
-        throw new InternalCompilerError(`llvm emitter bug: typed-ref union ${t.unionId} is undeclared`);
-    }
-    const sym = `${ctx.prefix}_union_${unions.size}`;
-    unions.set(key, sym);
-    host.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${host.sizeType}, ptr, ptr)`);
-    const B = new BlockBuilder();
-    const tagPtr = B.tmp();
-    const tagValue = B.tmp();
-    B.line(`${tagPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 1`);
-    B.line(`${tagValue} = load i32, ptr ${tagPtr}`);
-    const bad = B.newLabel("tr.union.bad");
-    const labels = def.arms.map(() => B.newLabel("tr.union.arm"));
-    B.terminate(`switch i32 ${tagValue}, label %${bad} [ ${def.arms.map((_, index) => `i32 ${index}, label %${labels[index]}`).join(" ")} ]`);
-    def.arms.forEach((arm, index) => {
-        B.startBlock(labels[index]);
-        if (streamTypedRefEligible(arm) || isDynTypedRefType(arm)) {
-            const adapter = host.streamTypedRefMaterializeAdapter(arm, ctx);
-            const rc = vAdapters(host, arm);
-            const armKey = typeKey(arm);
-            const payloadPtr = B.tmp();
-            const payload = B.tmp();
-            const boxed = B.tmp();
-            B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 5`);
-            B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
-            B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(armKey)}, ${host.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`);
-            B.terminate(`ret ptr ${boxed}`);
-        }
-        else if (arm.kind === "undefinedT") {
-            host.declare(`declare ptr @scr_dyn_undefined()`);
-            host.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
-            const undef = B.tmp();
-            const boxed = B.tmp();
-            B.line(`${undef} = call ptr @scr_dyn_undefined()`);
-            B.line(`${boxed} = call ptr @scr_dyn_retain_v(ptr ${undef})`);
-            B.terminate(`ret ptr ${boxed}`);
-        }
-        else if (arm.kind === "nullT") {
-            host.declare(`declare ptr @scr_dyn_new_null()`);
-            const boxed = B.tmp();
-            B.line(`${boxed} = call ptr @scr_dyn_new_null()`);
-            B.terminate(`ret ptr ${boxed}`);
-        }
-        else if (arm.kind === "f64") {
-            host.declare(`declare double @scr_union_get_f64(ptr)`);
-            host.declare(`declare ptr @scr_dyn_new_num(double)`);
-            const value = B.tmp();
-            const boxed = B.tmp();
-            B.line(`${value} = call double @scr_union_get_f64(ptr %u)`);
-            B.line(`${boxed} = call ptr @scr_dyn_new_num(double ${value})`);
-            B.terminate(`ret ptr ${boxed}`);
-        }
-        else if (arm.kind === "bool") {
-            host.declare(`declare zeroext i1 @scr_union_get_bool(ptr)`);
-            host.declare(`declare ptr @scr_dyn_new_bool(i1 zeroext)`);
-            const value = B.tmp();
-            const boxed = B.tmp();
-            B.line(`${value} = call zeroext i1 @scr_union_get_bool(ptr %u)`);
-            B.line(`${boxed} = call ptr @scr_dyn_new_bool(i1 ${value})`);
-            B.terminate(`ret ptr ${boxed}`);
-        }
-        else {
-            const payloadPtr = B.tmp();
-            const payload = B.tmp();
-            const boxed = B.tmp();
-            B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr %u, i64 0, i32 5`);
-            B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
-            B.line(`${boxed} = call ptr @${host.dyn.toDynHelper(arm)}(ptr ${payload})`);
-            B.terminate(`ret ptr ${boxed}`);
-        }
-    });
-    B.startBlock(bad);
-    host.declare(`declare void @scr_trap(ptr)`);
-    B.line(`call void @scr_trap(ptr ${host.cstr("scriptc: internal error: invalid union tag\n")})`);
-    B.terminate(`unreachable`);
-    host.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %u) ${FN_ATTRS} { ; typed-ref union ${key}`, B.render(), `}`, ``);
-    return sym;
-}
-export function streamTypedRefBoxValue(host, B, t, value, ctx) {
+export function streamTypedRefBoxValue(host, B, t, value) {
     const boxed = B.tmp();
     if (t.kind === "union" &&
         (host.unionsById.get(t.unionId)?.arms.some((arm) => streamTypedRefEligible(arm) || isDynTypedRefType(arm)) ?? false)) {
-        B.line(`${boxed} = call ptr @${nestedTypedRefUnionAdapter(host, t, ctx)}(ptr ${value})`);
+        B.line(`${boxed} = call ptr @${host.liveDynUnionRefAdapter(t)}(ptr ${value})`);
         return boxed;
     }
-    if (!streamTypedRefEligible(t) && !isDynTypedRefType(t)) {
+    if (t.kind === "bytes" || !streamTypedRefEligible(t) && !isDynTypedRefType(t)) {
         const valueTy = t.kind === "f64"
             ? "double"
             : t.kind === "bool"
@@ -373,22 +341,33 @@ export function streamTypedRefBoxValue(host, B, t, value, ctx) {
         B.line(`${boxed} = call ptr @${host.dyn.toDynHelper(t)}(${valueTy} ${value})`);
         return boxed;
     }
-    const nested = host.streamTypedRefMaterializeAdapter(t, ctx);
-    const rc = vAdapters(host, t);
+    const nested = host.liveDynRefAdapter(t);
+    const rc = vAdapters(host.shapeHost, t);
     const key = typeKey(t);
-    host.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${host.sizeType}, ptr, ptr)`);
-    B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${nested.snapshot}, ptr ${nested.commit})`);
+    B.line(`${boxed} = call ptr ${typedRefConstructor(host.shapeHost, t)}(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${nested.snapshot}, ptr ${nested.commit})`);
     return boxed;
 }
-export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot) {
+export function streamTypedRefMaterializeAdapter(host, t) {
     const key = typeKey(t);
-    const existing = ctx.adapters.get(key);
+    const existing = host.liveDynRefAdapters.get(key);
     if (existing)
         return existing;
-    const snapshot = preferredSnapshot ??
-        `${ctx.prefix}_nested_${ctx.adapters.size}`;
+    // The converter depends only on the static type. Intern the complete
+    // graph across roots and union arms so recursive types emit once.
+    const snapshot = `sc_ldr_${host.liveDynRefAdapters.size}_materialize`;
     const adapter = { snapshot, commit: "null" };
-    ctx.adapters.set(key, adapter);
+    host.liveDynRefAdapters.set(key, adapter);
+    if (isDynTypedRefType(t)) {
+        const fields = host.classMeta.get(t.className)?.def.fields;
+        if (fields && !classDynViewSupported(fields, (id) => host.recordsById.get(id), (id) => host.unionsById.get(id))) {
+            host.declare(`declare ptr @scr_dyn_class_view_unavailable(ptr)`);
+            adapter.snapshot = "scr_dyn_class_view_unavailable";
+            return adapter;
+        }
+    }
+    // Publish both symbols before their bodies: class-array and callback
+    // converters can request this same adapter while emitting the commit.
+    adapter.commit = `@${snapshot}_commit`;
     adapter.commit = host.streamTypedRefCommitAdapter(t, snapshot);
     const B = new BlockBuilder();
     if (isDynTypedRefType(t)) {
@@ -396,11 +375,56 @@ export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot
         if (!meta) {
             throw new InternalCompilerError(`llvm emitter bug: typed-ref materialize of unknown class ${t.className}`);
         }
+        if (meta.hierarchy && meta.children.length) {
+            const vtSlot = B.tmp(), vt = B.tmp(), preSlot = B.tmp(), pre = B.tmp();
+            B.line(`${vtSlot} = getelementptr inbounds %${classStructSym(t.className)}, ptr %p, i64 0, i32 1`);
+            B.line(`${vt} = load ptr, ptr ${vtSlot}`);
+            B.line(`${preSlot} = getelementptr inbounds %ScrVt, ptr ${vt}, i64 0, i32 0`);
+            B.line(`${pre} = load ${host.sizeType}, ptr ${preSlot}`);
+            const descendants = (current) => current.children.flatMap((child) => [child, ...descendants(child)]);
+            for (const child of descendants(meta).reverse()) {
+                const childAdapter = host.liveDynRefAdapter({ kind: "object", className: child.def.name });
+                const exact = B.tmp(), yes = B.newLabel("class.derived"), next = B.newLabel("class.next");
+                B.line(`${exact} = icmp eq ${host.sizeType} ${pre}, ${child.pre}`);
+                B.condBr(exact, yes, next);
+                B.startBlock(yes);
+                const result = B.tmp();
+                B.line(`${result} = call ptr @${childAdapter.snapshot}(ptr %p)`);
+                B.terminate(`ret ptr ${result}`);
+                B.startBlock(next);
+            }
+        }
         host.declare(`declare ptr @scr_dyn_new_obj()`);
         host.declare(`declare void @scr_dyn_obj_set(ptr, ptr, ${host.sizeType}, ptr)`);
         const out = B.tmp();
-        B.line(`${out} = call ptr @scr_dyn_new_obj()`);
-        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name))) {
+        if (meta.root.def.name === "%Error") {
+            host.declare(`declare ptr @scr_error_dyn_fields(ptr)`);
+            B.line(`${out} = call ptr @scr_error_dyn_fields(ptr %p)`);
+        }
+        else if (meta.def.runtime && RUNTIME_STREAM_CLASSES.has(t.className) &&
+            !meta.def.instancePrototypeHelper && !meta.def.prototypeDataHelper) {
+            host.declare(`declare ptr @scr_stream_dyn_view(ptr)`);
+            B.line(`${out} = call ptr @scr_stream_dyn_view(ptr %p)`);
+        }
+        else
+            B.line(`${out} = call ptr @scr_dyn_new_obj()`);
+        if (meta.def.instancePrototypeHelper || meta.def.prototypeDataHelper) {
+            host.declare(`declare ptr @scr_dyn_set_prototype(ptr, ptr)`);
+            host.declare(`declare void @scr_dyn_release_v(ptr)`);
+            const prototype = B.tmp(), attached = B.tmp();
+            if (meta.def.instancePrototypeHelper) {
+                const receiver = B.tmp();
+                B.line(`${receiver} = call ptr ${vAdapters(host.shapeHost, t).retain}(ptr %p)`);
+                B.line(`${prototype} = call ptr @${mangleFunction(meta.def.instancePrototypeHelper)}(ptr ${receiver})`);
+            }
+            else
+                B.line(`${prototype} = call ptr @${mangleFunction(meta.def.prototypeDataHelper)}()`);
+            B.line(`${attached} = call ptr @scr_dyn_set_prototype(ptr ${out}, ptr ${prototype})`);
+            B.line(`call void @scr_dyn_release_v(ptr ${prototype})`);
+            B.line(`call void @scr_dyn_release_v(ptr ${attached})`);
+        }
+        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name) &&
+            !(meta.root.def.name === "%Error" && (f.name === "message" || f.name === "name")))) {
             const { index } = classFieldIndex(meta, field.name);
             const fieldPtr = B.tmp();
             let fieldValue = B.tmp();
@@ -411,9 +435,51 @@ export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot
                 B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
                 fieldValue = boolValue;
             }
-            const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
+            const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue);
             B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
         }
+        for (const symbol of meta.def.symbolFields ?? []) {
+            const field = meta.def.fields.find((field) => field.name === symbol.field);
+            const { index } = classFieldIndex(meta, symbol.field);
+            const fieldPtr = B.tmp(), rawKey = B.tmp();
+            let fieldValue = B.tmp();
+            B.line(`${fieldPtr} = getelementptr inbounds %${classStructSym(t.className)}, ptr %p, i64 0, i32 ${index}`);
+            B.line(`${fieldValue} = load ${llFieldType(field.type)}, ptr ${fieldPtr}`);
+            const afterSymbol = field.type.kind === "symbol" ? B.newLabel("symbol.after") : null;
+            if (afterSymbol) {
+                const initialized = B.tmp(), present = B.newLabel("symbol.present");
+                B.line(`${initialized} = icmp ne ptr ${fieldValue}, null`);
+                B.condBr(initialized, present, afterSymbol);
+                B.startBlock(present);
+            }
+            if (llFieldType(field.type) === "i8") {
+                const boolValue = B.tmp();
+                B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
+                fieldValue = boolValue;
+            }
+            B.line(`${rawKey} = load ptr, ptr @${mangleGlobal(symbol.globalId)}`);
+            const key = host.streamTypedRefBoxValue(B, SYMBOL_T, rawKey);
+            const value = host.streamTypedRefBoxValue(B, field.type, fieldValue);
+            host.declare(`declare void @scr_dyn_symbol_key_set(ptr, ptr, ptr)`);
+            host.declare(`declare void @scr_dyn_release_v(ptr)`);
+            B.line(`call void @scr_dyn_symbol_key_set(ptr ${out}, ptr ${key}, ptr ${value})`);
+            B.line(`call void @scr_dyn_release_v(ptr ${key})`);
+            B.line(`call void @scr_dyn_release_v(ptr ${value})`);
+            if (afterSymbol) {
+                B.terminate(`br label %${afterSymbol}`);
+                B.startBlock(afterSymbol);
+            }
+        }
+        if (meta.def.fields.some((field) => field.name === DYN_CLASS_PROPERTIES)) {
+            host.declare(`declare ptr @scr_dyn_copy_property_descriptors(ptr, ptr)`);
+            host.declare(`declare void @scr_dyn_release_v(ptr)`);
+            const { index } = classFieldIndex(meta, DYN_CLASS_PROPERTIES);
+            const slot = B.tmp(), bag = B.tmp(), copied = B.tmp();
+            B.line(`${slot} = getelementptr inbounds %${classStructSym(t.className)}, ptr %p, i64 0, i32 ${index}`);
+            B.line(`${bag} = load ptr, ptr ${slot}`);
+            B.line(`${copied} = call ptr @scr_dyn_copy_property_descriptors(ptr ${out}, ptr ${bag})`);
+            B.line(`call void @scr_dyn_release_v(ptr ${copied})`);
+        }
         B.terminate(`ret ptr ${out}`);
     }
     else if (t.kind === "record") {
@@ -447,7 +513,7 @@ export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot
                     B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
                     fieldValue = boolValue;
                 }
-                const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
+                const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue);
                 B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${boxed})`);
             }
             B.terminate(`ret ptr ${out}`);
@@ -475,7 +541,7 @@ export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot
                     B.line(`${boolValue} = trunc i8 ${fieldValue} to i1`);
                     fieldValue = boolValue;
                 }
-                const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue, ctx);
+                const boxed = host.streamTypedRefBoxValue(B, field.type, fieldValue);
                 B.line(`call void @scr_dyn_obj_set(ptr ${out}, ptr ${host.cstr(field.name)}, ${host.sizeType} ${Buffer.byteLength(field.name, "utf8")}, ptr ${boxed})`);
             }
             B.terminate(`ret ptr ${out}`);
@@ -491,6 +557,25 @@ export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot
         const len = B.tmp();
         B.line(`${len} = call double @scr_arr_len(ptr %p)`);
         B.countedLoop(len, (index) => {
+            host.declare(`declare double @scr_arr_state(ptr, double)`);
+            host.declare(`declare ptr @scr_dyn_undefined()`);
+            host.declare(`declare ptr @scr_dyn_retain_v(ptr)`);
+            const state = B.tmp();
+            const present = B.tmp();
+            const valueLabel = B.newLabel("live.array.value");
+            const absentLabel = B.newLabel("live.array.absent");
+            const doneLabel = B.newLabel("live.array.done");
+            B.line(`${state} = call double @scr_arr_state(ptr %p, double ${index})`);
+            B.line(`${present} = fcmp oeq double ${state}, 1.0`); // SCR_ARR_VALUE
+            B.condBr(present, valueLabel, absentLabel);
+            B.startBlock(absentLabel);
+            const undefinedValue = B.tmp();
+            const retained = B.tmp();
+            B.line(`${undefinedValue} = call ptr @scr_dyn_undefined()`);
+            B.line(`${retained} = call ptr @scr_dyn_retain_v(ptr ${undefinedValue})`);
+            B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${retained})`);
+            B.br(doneLabel);
+            B.startBlock(valueLabel);
             let value;
             if (elem.kind === "f64" || elem.kind === "bool") {
                 const valueTy = elem.kind === "f64" ? "double" : "i1";
@@ -503,12 +588,16 @@ export function streamTypedRefMaterializeAdapter(host, t, ctx, preferredSnapshot
                 value = B.tmp();
                 B.line(`${value} = call ptr @scr_arr_get_ref(ptr %p, double ${index}) ; +1`);
             }
-            const boxed = host.streamTypedRefBoxValue(B, elem, value, ctx);
+            const boxed = host.streamTypedRefBoxValue(B, elem, value);
             B.line(`call void @scr_dyn_arr_push(ptr ${out}, ptr ${boxed})`);
             if (isRefCounted(elem)) {
-                B.line(`call void ${releaseSym(host, elem)}(ptr ${value})`);
+                B.line(`call void ${releaseSym(host.shapeHost, elem)}(ptr ${value})`);
             }
+            B.br(doneLabel);
+            B.startBlock(doneLabel);
         });
+        host.declare(`declare void @scr_arr_copy_metadata(ptr, ptr)`);
+        B.line(`call void @scr_arr_copy_metadata(ptr %p, ptr ${out})`);
         B.terminate(`ret ptr ${out}`);
     }
     else {
@@ -541,7 +630,7 @@ export function streamFromArrayAdapter(host, t) {
         elem.kind !== "dyn" &&
         elem.kind !== "string" &&
         elem.kind !== "union";
-    const snapshot = `${sym}_materialize`;
+    let snapshot = `${sym}_materialize`;
     let value;
     if (elem.kind === "f64") {
         host.declare(`declare double @scr_arr_get_f64(ptr, double)`);
@@ -566,7 +655,6 @@ export function streamFromArrayAdapter(host, t) {
             B.line(`${boxed} = call ptr @${host.dyn.toDynHelper(elem)}(ptr ${value})`);
         }
         else {
-            host.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${host.sizeType}, ptr, ptr)`);
             const boxedSlot = B.slot();
             B.entryAllocas.push(`${boxedSlot} = alloca ptr`);
             const tagPtr = B.tmp();
@@ -581,14 +669,14 @@ export function streamFromArrayAdapter(host, t) {
                 const armKey = typeKey(arm);
                 const armSnapshot = `${snapshot}_${tag}`;
                 const armCommit = host.streamTypedRefCommitAdapter(arm, armSnapshot);
-                const rc = vAdapters(host, arm);
+                const rc = vAdapters(host.shapeHost, arm);
                 B.startBlock(armLabels[i]);
                 const payloadPtr = B.tmp();
                 const payload = B.tmp();
                 const armBoxed = B.tmp();
                 B.line(`${payloadPtr} = getelementptr inbounds %ScrUnion, ptr ${value}, i64 0, i32 5`);
                 B.line(`${payload} = load ptr, ptr ${payloadPtr}`);
-                B.line(`${armBoxed} = call ptr @scr_dyn_new_typed_ref(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(armKey)}, ${host.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${armSnapshot}, ptr ${armCommit})`);
+                B.line(`${armBoxed} = call ptr ${typedRefConstructor(host.shapeHost, arm)}(ptr ${payload}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${host.cstr(armKey)}, ${host.sizeType} ${Buffer.byteLength(armKey, "utf8")}, ptr @${armSnapshot}, ptr ${armCommit})`);
                 B.line(`store ptr ${armBoxed}, ptr ${boxedSlot}`);
                 B.br(join);
                 host.resolveThunkDefs.push(`define internal ptr @${armSnapshot}(ptr %p) ${FN_ATTRS} { ; materialize stream union arm ${armKey}`, `entry:`, `  %d = call ptr @${host.dyn.toDynHelper(arm)}(ptr %p)`, `  ret ptr %d`, `}`, ``);
@@ -605,25 +693,26 @@ export function streamFromArrayAdapter(host, t) {
     }
     else if (typedRef) {
         boxed = B.tmp();
-        const rc = vAdapters(host, elem);
+        const rc = vAdapters(host.shapeHost, elem);
         const keyPtr = host.cstr(key);
         let commit;
         if (streamTypedRefEligible(elem)) {
-            commit = host.streamTypedRefMaterializeAdapter(elem, { prefix: snapshot, adapters: new Map() }, snapshot).commit;
+            const adapter = host.liveDynRefAdapter(elem);
+            snapshot = adapter.snapshot;
+            commit = adapter.commit;
         }
         else {
             commit = host.streamTypedRefCommitAdapter(elem, snapshot);
             host.resolveThunkDefs.push(`define internal ptr @${snapshot}(ptr %p) ${FN_ATTRS} { ; materialize stream element ${key}`, `entry:`, `  %d = call ptr @${host.dyn.toDynHelper(elem)}(ptr %p)`, `  ret ptr %d`, `}`, ``);
         }
-        host.declare(`declare ptr @scr_dyn_new_typed_ref(ptr, ptr, ptr, ptr, ${host.sizeType}, ptr, ptr)`);
-        B.line(`${boxed} = call ptr @scr_dyn_new_typed_ref(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyPtr}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${snapshot}, ptr ${commit})`);
+        B.line(`${boxed} = call ptr ${typedRefConstructor(host.shapeHost, elem)}(ptr ${value}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${keyPtr}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${snapshot}, ptr ${commit})`);
     }
     else {
         boxed = B.tmp();
         B.line(`${boxed} = call ptr @${host.dyn.toDynHelper(elem)}(${valueTy} ${value})`);
     }
     if (isRefCounted(elem)) {
-        B.line(`call void ${releaseSym(host, elem)}(ptr ${value})`);
+        B.line(`call void ${releaseSym(host.shapeHost, elem)}(ptr ${value})`);
     }
     B.terminate(`ret ptr ${boxed}`);
     host.resolveThunkDefs.push(`define internal ptr @${sym}(ptr %a, double %i) ${FN_ATTRS} { ; ReadableStream.from array<${key}>`, B.render(), `}`, ``);