@scriptc/compiler 0.2.6 → 0.2.8

package/dist/backend/llvm/dense-array-access.test.js

@@ -0,0 +1,238 @@
+import { expect, test } from "vitest";
+import { BOOL, F64, STRING, VOID, arrayOf, } from "../../ir/ir.js";
+import { emitLlvmModule } from "./emitter.js";
+const loc = { file: "dense-array-access.ts", start: 0, end: 0 };
+const nums = arrayOf(F64);
+const flags = arrayOf(BOOL);
+const words = arrayOf(STRING);
+const ref = (localId, type) => ({
+    kind: "varRef",
+    localId,
+    type,
+    loc,
+});
+const index = ref("i", F64);
+function module(name, returnType, body) {
+    return {
+        irVersion: 15,
+        sourceFile: loc.file,
+        entry: "__main",
+        functions: [
+            { name: "__main", params: [], returnType: VOID, locals: [], body: [], loc },
+            {
+                name,
+                params: [
+                    { name: "a", localId: "a", type: nums },
+                    { name: "b", localId: "b", type: flags },
+                    { name: "s", localId: "s", type: words },
+                    { name: "i", localId: "i", type: F64 },
+                ],
+                returnType,
+                locals: [
+                    { id: "a", name: "a", type: nums, mutable: false },
+                    { id: "b", name: "b", type: flags, mutable: false },
+                    { id: "s", name: "s", type: words, mutable: false },
+                    { id: "i", name: "i", type: F64, mutable: false },
+                ],
+                body,
+                loc,
+            },
+        ],
+    };
+}
+function body(llvm, name) {
+    return new RegExp(`^define internal [^\\n]*@sc_bf_${name}\\([^]*?^}`, "m").exec(llvm)[0];
+}
+test.each([32, 64])("strict scalar reads check dense storage inline (%i-bit)", (bits) => {
+    const read = { kind: "arrayGet", arr: ref("a", nums), index, type: F64, loc };
+    const llvm = emitLlvmModule(module("get", F64, [{ kind: "return", value: read, loc }]), {
+        pointerBits: bits,
+    });
+    const fn = body(llvm, "get");
+    // A double index must round-trip exactly; NaN/out-of-range conversions are frozen.
+    expect(fn).toContain("fptosi double");
+    expect(fn).toContain("freeze i64");
+    expect(fn).toMatch(/icmp ult i64 .*/);
+    expect(fn).toMatch(/load i8, ptr /);
+    expect(fn).toMatch(/icmp eq i8 .*, 1$/m);
+    expect(fn).toMatch(/load double, ptr /);
+    expect(fn).toMatch(/call double @scr_arr_get_f64\(.*\) cold memory\(read, inaccessiblemem: readwrite\)/);
+    if (bits === 32)
+        expect(fn).toContain("trunc i64");
+});
+test("reference reads retain inline and keep a cold +1 runtime fallback", () => {
+    const read = { kind: "arrayGet", arr: ref("s", words), index, type: STRING, loc };
+    const llvm = emitLlvmModule(module("word", STRING, [{ kind: "return", value: read, loc }]));
+    const fn = body(llvm, "word");
+    expect(fn).toMatch(/icmp ne ptr .*, null/);
+    expect(fn).toContain("@scr_str_retain_v(");
+    // The retaining getter writes reference counts, so it gets no read-only effect.
+    expect(fn).toMatch(/call ptr @scr_arr_get_ref\(.*\) cold$/m);
+});
+test("element writes store inline, extend the length, and release replaced references", () => {
+    const set = (arr, value) => ({
+        kind: "arraySet",
+        arr,
+        index,
+        value,
+        loc,
+    });
+    const llvm = emitLlvmModule(module("store", VOID, [
+        set(ref("a", nums), { kind: "numLit", value: 2.5, type: F64, loc }),
+        set(ref("b", flags), { kind: "boolLit", value: true, type: BOOL, loc }),
+        set(ref("s", words), { kind: "strLit", value: "x", type: STRING, loc }),
+    ]));
+    const fn = body(llvm, "store");
+    expect(fn).toMatch(/store double 0x4004000000000000, ptr /);
+    expect(fn).toMatch(/zext i1 .* to i64/);
+    expect(fn).toMatch(/store i8 1, ptr /);
+    expect(fn).toMatch(/icmp uge i64 .*/);
+    expect(fn).toContain("call void @scr_str_release(");
+    for (const acc of ["f64", "bool", "ref"]) {
+        expect(fn).toMatch(new RegExp(`call void @scr_arr_set_${acc}\\(.*\\) cold$`, "m"));
+    }
+});
+test.each([32, 64])("push appends inline below the capacity and keeps a cold runtime append (%i-bit)", (bits) => {
+    const push = (receiver, value) => ({
+        kind: "exprStmt",
+        expr: { kind: "arrIntrinsic", method: "push", receiver, args: [value], type: F64, loc },
+        loc,
+    });
+    const llvm = emitLlvmModule(module("append", VOID, [
+        push(ref("a", nums), { kind: "numLit", value: 2.5, type: F64, loc }),
+        push(ref("b", flags), { kind: "boolLit", value: true, type: BOOL, loc }),
+        push(ref("s", words), { kind: "strLit", value: "x", type: STRING, loc }),
+    ]), { pointerBits: bits });
+    const fn = body(llvm, "append");
+    const size = bits === 32 ? "i32" : "i64";
+    expect(fn.match(new RegExp(`icmp ult ${size} `, "g"))).toHaveLength(3);
+    expect(fn).toMatch(/store double 0x4004000000000000, ptr /);
+    expect(fn).toMatch(/zext i1 .* to i64/);
+    expect(fn.match(/store i8 1, ptr /g)).toHaveLength(3);
+    expect(fn.match(new RegExp(`add nuw ${size} .*, 1$`, "gm"))).toHaveLength(3);
+    // Appends never release: the slot past the length holds no value.
+    expect(fn).not.toContain("_release(");
+    for (const acc of ["f64", "bool", "ref"]) {
+        expect(fn).toMatch(new RegExp(`call double @scr_arr_push_${acc}\\(.*\\) cold$`, "m"));
+    }
+});
+test("state and presence queries answer dense slots inline", () => {
+    const state = { kind: "arrayState", arr: ref("b", flags), index, type: F64, loc };
+    const has = { kind: "arrayHas", arr: ref("s", words), index, type: BOOL, loc };
+    const llvm = emitLlvmModule(module("query", BOOL, [
+        {
+            kind: "return",
+            value: {
+                kind: "logical",
+                op: "&&",
+                left: {
+                    kind: "bin",
+                    op: "===",
+                    left: state,
+                    right: { kind: "numLit", value: 1, type: F64, loc },
+                    type: BOOL,
+                    loc,
+                },
+                right: has,
+                type: BOOL,
+                loc,
+            },
+            loc,
+        },
+    ]));
+    const fn = body(llvm, "query");
+    expect(fn).toMatch(/uitofp i8 .* to double/);
+    expect(fn).toMatch(/icmp ne i8 .*, 0/);
+    expect(fn).toMatch(/call double @scr_arr_state\(.*\) cold memory\(read/);
+    expect(fn).toMatch(/call i1 @scr_arr_has\(.*\) cold memory\(read/);
+});
+test("statement-position splices insert values without result or item arrays", () => {
+    const num = (value) => ({ kind: "numLit", value, type: F64, loc });
+    const splice = (items) => ({
+        kind: "exprStmt",
+        expr: {
+            kind: "arrIntrinsic",
+            method: items ? "spliceInsert" : "splice",
+            receiver: ref("s", words),
+            args: [
+                index,
+                num(0),
+                ...(items ? [{ kind: "arrayLit", elems: items, type: words, loc }] : []),
+            ],
+            type: words,
+            loc,
+        },
+        loc,
+    });
+    const llvm = emitLlvmModule(module("insert", VOID, [
+        splice([{ kind: "strLit", value: "x", type: STRING, loc }]),
+        splice(null),
+    ]));
+    const fn = body(llvm, "insert");
+    expect(fn.match(/call void @scr_arr_splice_drop\(/g)).toHaveLength(2);
+    expect(fn).toMatch(/call void @scr_arr_splice_drop\(.*, i64 1, ptr %t\d+\)/);
+    expect(fn).toMatch(/call void @scr_arr_splice_drop\(.*, i64 0, ptr null\)/);
+    expect(fn).not.toContain("@scr_arr_new");
+    expect(fn).not.toContain("@scr_arr_splice_insert");
+    expect(fn).not.toContain("@scr_arr_release");
+});
+test("length assignments skip the runtime when the length is unchanged", () => {
+    const llvm = emitLlvmModule(module("reset", VOID, [{ kind: "arraySetLength", arr: ref("s", words), length: index, loc }]));
+    const fn = body(llvm, "reset");
+    expect(fn).toMatch(/uitofp i64 .* to double/);
+    expect(fn).toMatch(/fcmp oeq double %p?\S*, %t\d+/);
+    expect(fn.match(/call void @scr_arr_set_len\(/g)).toHaveLength(1);
+    expect(fn).toMatch(/br i1 %t\d+, label %arr\.len\.done\d*, label %arr\.len\.set\d*/);
+});
+test("a discarded conditional splice drops the result of its literal arm", () => {
+    const insert = (items) => ({
+        kind: "arrIntrinsic",
+        method: "spliceInsert",
+        receiver: ref("s", words),
+        args: [index, { kind: "numLit", value: 0, type: F64, loc }, items],
+        type: words,
+        loc,
+    });
+    const word = { kind: "strLit", value: "x", type: STRING, loc };
+    const llvm = emitLlvmModule(module("pick", VOID, [
+        {
+            kind: "exprStmt",
+            expr: {
+                kind: "seqExpr",
+                stmts: [],
+                result: {
+                    kind: "ternary",
+                    cond: { kind: "boolLit", value: true, type: BOOL, loc },
+                    then: insert({
+                        kind: "seqExpr",
+                        stmts: [],
+                        result: { kind: "arrayLit", elems: [word], type: words, loc },
+                        type: words,
+                        loc,
+                    }),
+                    else_: insert({ kind: "arrayLit", elems: [word], type: words, loc }),
+                    type: words,
+                    loc,
+                },
+                type: words,
+                loc,
+            },
+            loc,
+        },
+    ]));
+    const fn = body(llvm, "pick");
+    expect(fn.match(/call void @scr_arr_splice_drop\(/g)).toHaveLength(1);
+    expect(fn.match(/call ptr @scr_arr_splice_insert\(/g)).toHaveLength(1);
+    expect(fn).toMatch(/drop\.t\d*:/);
+});
+test("an empty literal's capacity hint sizes its first dense storage", () => {
+    const llvm = emitLlvmModule(module("fresh", words, [
+        {
+            kind: "return",
+            value: { kind: "arrayLit", elems: [], capacity: 3, type: words, loc },
+            loc,
+        },
+    ]));
+    expect(body(llvm, "fresh")).toMatch(/call ptr @scr_arr_new\(.*, i64 3\)/);
+});
+//# sourceMappingURL=dense-array-access.test.js.map

package/dist/backend/llvm/dense-array-access.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dense-array-access.test.js","sourceRoot":"","sources":["../../../src/backend/llvm/dense-array-access.test.ts"],"names":[],"mappings":"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"}

package/dist/backend/llvm/dyn.d.ts

@@ -22,6 +22,10 @@ export declare const DYN_KIND: {
  * unit instances (undefined-armed dynCheck targets build them). */
 export interface DynHost extends WalkerHost {
     unitInstanceRef(unionId: string, tag: number): string;
+    /** See ClassHost.virtualEntry. */
+    virtualEntry?(implFn: string): string;
+    /** The immortal ABSENT field-slot state of an undefined-armed union. */
+    absentInstanceRef(unionId: string): string;
     liveDynRefAdapter(t: IrType): {
         snapshot: string;
         commit: string;
@@ -32,6 +36,8 @@ export interface DynHost extends WalkerHost {
     dynPromiseAdapter(t: IrType): string;
     isErrorClass(className: string): boolean;
     classSubtypes(className: string): readonly string[];
+    /** emitter.ts's pendingTestLines: the inline pending-exception test. */
+    pendingTestLines(dest: string): string[];
 }
 export declare class LlDyn {
     private readonly host;
@@ -82,6 +88,19 @@ export declare class LlDyn {
     private undef;
     /** scr_dyn_obj_get with a compile-time key: borrowed member or null. */
     private objGetLit;
+    /** Branches past the caller's next emission when an undefined-armed
+     * field value is the ABSENT state. Returns the label the caller must branch
+     * to and start after its emission, or null when the type has no
+     * undefined arm. */
+    private skipIfAbsent;
+    /** A checked undefined-armed field value, or the field's ABSENT state
+     * when the value is undefined because the source object has no own
+     * property of that name (a missing JSON key stays missing; an explicit
+     * undefined stays present). Proxy sources answer through their reads, so
+     * they count as present. The checked value is a +1 union; replacing it
+     * with the immortal absent instance releases nothing (unit instances are
+     * immortal too). */
+    private presenceOf;
     /** Ordinary property lookup, including inherited data and accessors (+1). */
     private objReadLit;
     /** Appends a borrowed string, preserving its full byte length. */
@@ -99,6 +118,25 @@ export declare class LlDyn {
     private typedRefMatches;
     /** `sc_dm_<n>(ptr d) -> i1` — does this dyn fit T? Never throws. */
     dynMatchHelper(t: IrType, preserveRefs?: boolean): string;
+    private readonly jsonSchemas;
+    private readonly jsonParsers;
+    /** 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. */
+    private jsonSchemaSupported;
+    /** 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. */
+    private jsonSchema;
+    /** `sc_jp_<n>(ptr text) -> T` for `JSON.parse(text) as T`, or null when T
+     * is not a schema target. Tries the one-pass schema parser; when it
+     * declines (any input the checked route might reject or read
+     * differently), runs the checked-dynamic route — scr_json_parse plus the
+     * dynCheck builder — which reports the exact error. Returns +1, or null
+     * with the pending flag set. */
+    jsonParseHelper(t: IrType): string | null;
     /** `sc_dc_<n>(ptr d, ptr path) -> T` — validate the checked-dynamic tree against T and
      * BUILD the typed value (+1), or throw the catchable path-annotated
      * TypeError and return a dummy with the pending flag set. */

package/dist/backend/llvm/dyn.js

@@ -1,5 +1,6 @@
 import { typedRefConstructor } from "./shapes.js";
 import { BYTES_ELEM_NUM, f64Lit } from "./common.js";
+import { emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { InternalCompilerError } from "../../errors.js";
 import { DYN_HANDLE_KINDS, isDynTypedRefType, isRefCounted, typeKey } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
@@ -254,6 +255,61 @@ 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;
     }
+    /** Branches past the caller's next emission when an undefined-armed
+     * field value is the ABSENT state. Returns the label the caller must branch
+     * to and start after its emission, or null when the type has no
+     * undefined arm. */
+    skipIfAbsent(B, value, t) {
+        const def = this.host.unionsById.get(t.unionId);
+        const utag = def ? def.arms.findIndex((arm) => arm.kind === "undefinedT") : -1;
+        if (utag < 0)
+            return null;
+        const absent = this.host.fieldAbsentTestIn(B, value, t.unionId);
+        const lSkip = B.newLabel("tdr.absent");
+        const lSet = B.newLabel("tdr.set");
+        B.condBr(absent, lSkip, lSet);
+        B.startBlock(lSet);
+        return lSkip;
+    }
+    /** A checked undefined-armed field value, or the field's ABSENT state
+     * when the value is undefined because the source object has no own
+     * property of that name (a missing JSON key stays missing; an explicit
+     * undefined stays present). Proxy sources answer through their reads, so
+     * they count as present. The checked value is a +1 union; replacing it
+     * with the immortal absent instance releases nothing (unit instances are
+     * immortal too). */
+    presenceOf(B, d, key, t, value) {
+        const def = this.host.unionsById.get(t.unionId);
+        const utag = def ? def.arms.findIndex((arm) => arm.kind === "undefinedT") : -1;
+        if (utag < 0)
+            return value;
+        const tag = emitUnionTag(B, this.host.nullableUnions.get(t.unionId), value);
+        const isUndef = B.tmp();
+        B.line(`${isUndef} = icmp eq i32 ${tag}, ${utag}`);
+        const kind = this.kindOf(B, d);
+        const isObj = B.tmp();
+        B.line(`${isObj} = icmp eq i32 ${kind}, ${DYN_KIND.OBJ}`);
+        const probe = B.tmp();
+        B.line(`${probe} = and i1 ${isUndef}, ${isObj}`);
+        const slot = B.slot();
+        B.entryAllocas.push(`${slot} = alloca ptr`);
+        B.line(`store ptr ${value}, ptr ${slot}`);
+        const lProbe = B.newLabel("dcr.has");
+        const lJoin = B.newLabel("dcr.hasj");
+        B.condBr(probe, lProbe, lJoin);
+        B.startBlock(lProbe);
+        const own = this.objGetLit(B, d, key);
+        const missing = B.tmp();
+        const chosen = B.tmp();
+        B.line(`${missing} = icmp eq ptr ${own}, null`);
+        B.line(`${chosen} = select i1 ${missing}, ptr ${this.host.absentInstanceRef(t.unionId)}, ptr ${value}`);
+        B.line(`store ptr ${chosen}, ptr ${slot}`);
+        B.br(lJoin);
+        B.startBlock(lJoin);
+        const out = B.tmp();
+        B.line(`${out} = load ptr, ptr ${slot}`);
+        return out;
+    }
     /** 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})`);
@@ -300,9 +356,9 @@ export class LlDyn {
     /** Emit the standard in-helper pending check: on a pending exception
      * run `cleanup` and return `dummy`. */
     pendingBail(B, hint, cleanup, dummy) {
-        this.host.declare(`declare zeroext i1 @scr_exc_pending()`);
         const p = B.tmp();
-        B.line(`${p} = call zeroext i1 @scr_exc_pending()`);
+        for (const line of this.host.pendingTestLines(p))
+            B.line(line.trimStart());
         const lu = B.newLabel(`${hint}.u`);
         const lk = B.newLabel(`${hint}.k`);
         B.condBr(p, lu, lk);
@@ -676,6 +732,121 @@ export class LlDyn {
         this.defs.push(`define internal zeroext i1 @${name}(ptr %d) ${FN_ATTRS} { ; matches ${key}`, B.render(), `}`, ``);
         return name;
     }
+    /* ── schema-directed JSON.parse ───────────────────────────────── */
+    jsonSchemas = new Map();
+    jsonParsers = new Map();
+    /** 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) {
+        switch (t.kind) {
+            case "f64":
+            case "bool":
+            case "string":
+                return true;
+            case "array":
+                return this.jsonSchemaSupported(t.elem, visiting);
+            case "record": {
+                if (visiting.has(t.shapeId))
+                    return true;
+                const shape = this.host.recordsById.get(t.shapeId);
+                if (!shape || shape.tuple || shape.indexValue)
+                    return false;
+                if (shape.fields.length === 0 || shape.fields.length > 64)
+                    return false;
+                visiting.add(t.shapeId);
+                return shape.fields.every((f) => !f.name.startsWith("%") &&
+                    f.name !== "__proto__" &&
+                    this.jsonSchemaSupported(f.type, 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. */
+    jsonSchema(t) {
+        const key = typeKey(t);
+        const existing = this.jsonSchemas.get(key);
+        if (existing)
+            return existing;
+        const host = this.host;
+        const S = host.sizeType;
+        const name = `sc_jsch_${this.jsonSchemas.size}`;
+        this.jsonSchemas.set(key, name);
+        let body;
+        switch (t.kind) {
+            case "f64":
+            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`;
+                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}`;
+                break;
+            }
+            case "record": {
+                const shape = host.recordsById.get(t.shapeId);
+                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 order = [...(shape.declaredOrder ?? []).filter((n) => index.has(n))];
+                for (const f of shape.fields)
+                    if (!order.includes(f.name))
+                        order.push(f.name);
+                const fieldTy = `{ ptr, ${S}, ${S}, ptr }`;
+                const entries = order.map((fieldName) => {
+                    const field = shape.fields[index.get(fieldName) - 1];
+                    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}`;
+                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} }`, ``);
+        return name;
+    }
+    /** `sc_jp_<n>(ptr text) -> T` for `JSON.parse(text) as T`, or null when T
+     * is not a schema target. Tries the one-pass schema parser; when it
+     * declines (any input the checked route might reject or read
+     * differently), runs the checked-dynamic route — scr_json_parse plus the
+     * dynCheck builder — which reports the exact error. Returns +1, or null
+     * with the pending flag set. */
+    jsonParseHelper(t) {
+        if (t.kind !== "record" && t.kind !== "array")
+            return null;
+        const key = typeKey(t);
+        const existing = this.jsonParsers.get(key);
+        if (existing)
+            return existing;
+        if (!this.jsonSchemaSupported(t, new Set()))
+            return null;
+        const host = this.host;
+        const name = `sc_jp_${this.jsonParsers.size}`;
+        this.jsonParsers.set(key, name);
+        const schema = this.jsonSchema(t);
+        const check = this.dynCheckHelper(t);
+        host.declare(`declare ptr @scr_json_parse_schema(ptr, ptr)`);
+        host.declare(`declare ptr @scr_json_parse(ptr)`);
+        host.declare(`declare void @scr_dyn_release(ptr)`);
+        this.defs.push(`define internal ptr @${name}(ptr %text) ${FN_ATTRS} { ; JSON.parse as ${llvmCommentText(key)}`, `entry:`, `  %fast = call ptr @scr_json_parse_schema(ptr %text, ptr @${schema})`, `  %hit = icmp ne ptr %fast, null`, `  br i1 %hit, label %done, label %slow`, `done:`, `  ret ptr %fast`, `slow:`, `  %d = call ptr @scr_json_parse(ptr %text)`, `  %bad = icmp eq ptr %d, null`, `  br i1 %bad, label %fail, label %check`, `fail:`, `  ret ptr null`, `check:`, `  %v = call ptr @${check}(ptr %d, ptr null)`, `  call void @scr_dyn_release(ptr %d)`, `  ret ptr %v`, `}`, ``);
+        return name;
+    }
     /* ── dynCheckHelper (walkers.ts, ported) ──────────────────────── */
     /** `sc_dc_<n>(ptr d, ptr path) -> T` — validate the checked-dynamic tree against T and
      * BUILD the typed value (+1), or throw the catchable path-annotated
@@ -1147,6 +1318,11 @@ export class LlDyn {
                     B.line(`call void @scr_dyn_release(ptr ${m})`);
                     storeInto(f.name, f.type, value);
                     this.pendingBail(B, "dcr", releaseR, "ptr null");
+                    if (f.type.kind === "union") {
+                        const stored = this.presenceOf(B, "%d", f.name, f.type, value);
+                        if (stored !== value)
+                            storeInto(f.name, f.type, stored);
+                    }
                 }
                 // Index-signature shapes CAPTURE undeclared keys into the
                 // overflow map.
@@ -1300,6 +1476,12 @@ export class LlDyn {
                         B.line(`${u} = call ptr @scr_union_new_bool(i32 ${i}, i1 ${x})`);
                         B.terminate(`ret ptr ${u}`);
                     }
+                    else if (host.nullableUnions.has(t.unionId)) {
+                        // A nullable union is its (+1) reference payload.
+                        const x = B.tmp();
+                        B.line(`${x} = call ptr @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
+                        B.terminate(`ret ptr ${x}`);
+                    }
                     else {
                         const rc = vAdapters(host, arm);
                         host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
@@ -1333,6 +1515,21 @@ export class LlDyn {
                 const lFail = B.newLabel("dcu.fail");
                 B.condBr(capsule, lCapsule, lFail);
                 B.startBlock(lCapsule);
+                if (host.nullableUnions.has(t.unionId)) {
+                    // No box identity to cache: the structural snapshot's payload is
+                    // the value, and NULL is the undefined arm, so failure is the
+                    // pending exception rather than a NULL result.
+                    const materialized = B.tmp();
+                    const checked = B.tmp();
+                    B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                    B.line(`${checked} = call ptr @${name}(ptr ${materialized}, ptr %path)`);
+                    B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
+                    B.terminate(`ret ptr ${checked}`);
+                    B.startBlock(lFail);
+                    B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${want}, ptr %d)`);
+                    B.terminate(`ret ptr null`);
+                    break;
+                }
                 const cached = B.tmp();
                 B.line(`${cached} = call ptr @scr_dyn_typed_ref_cached_cast(ptr %d, ptr ${host.cstr(key)}, ${host.sizeType} ${Buffer.byteLength(key, "utf8")})`);
                 const hasCached = B.tmp();
@@ -1457,6 +1654,10 @@ export class LlDyn {
                 B.line(`store ptr ${box}, ptr ${capp}`);
                 const rd = this.retainDyn(B, "%d");
                 B.line(`call void @scr_box_set_ref(ptr ${box}, ptr ${rd})`);
+                // The shim is the same JS function under another signature: it
+                // takes the boxed closure's identity (kept alive through caps[0]).
+                host.declare(`declare void @scr_dyn_adopt_identity(ptr, ptr)`);
+                B.line(`call void @scr_dyn_adopt_identity(ptr ${a}, ptr %d)`);
                 B.terminate(`ret ptr ${a}`);
                 break;
             }
@@ -1695,9 +1896,15 @@ export class LlDyn {
                 for (const f of dynFields) {
                     const klen = Buffer.byteLength(f.name, "utf8");
                     const fv = loadFieldOf(f.name, f.type);
+                    // An ABSENT optional field contributes no key.
+                    const lSkip = f.type.kind === "union" ? this.skipIfAbsent(B, fv, f.type) : null;
                     const conv = B.tmp();
                     B.line(`${conv} = call ptr @${this.toDynHelper(f.type)}(${this.valTy(f.type)} ${fv})`);
                     B.line(`call void @scr_dyn_obj_set(ptr ${d}, ptr ${host.cstr(f.name)}, ${host.sizeType} ${klen}, ptr ${conv}) ; ${llvmCommentText(f.name)}`);
+                    if (lSkip !== null) {
+                        B.br(lSkip);
+                        B.startBlock(lSkip);
+                    }
                 }
                 if (shape.indexValue) {
                     const iv = shape.indexValue;
@@ -1854,10 +2061,8 @@ export class LlDyn {
                 const def = host.unionsById.get(t.unionId);
                 if (!def)
                     throw new InternalCompilerError(`llvm emitter bug: to-dyn of unknown union ${t.unionId}`);
-                const tagp = B.tmp();
-                const tag = B.tmp();
-                B.line(`${tagp} = getelementptr inbounds %ScrUnion, ptr %v, i64 0, i32 1`);
-                B.line(`${tag} = load i32, ptr ${tagp}`);
+                const nullable = host.nullableUnions.get(t.unionId);
+                const tag = emitUnionTag(B, nullable, "%v");
                 const bad = B.newLabel("tdu.bad");
                 const labels = def.arms.map(() => B.newLabel("tdu.a"));
                 B.terminate(`switch i32 ${tag}, label %${bad} [ ${def.arms.map((_, i) => `i32 ${i}, label %${labels[i]}`).join(" ")} ]`);
@@ -1894,19 +2099,13 @@ export class LlDyn {
                     else if (arm.kind === "func") {
                         // A boxable function arm crosses through the checked-dynamic
                         // function boundary (the dynFrom func special case, sans name).
-                        const pp = B.tmp();
-                        const p = B.tmp();
-                        B.line(`${pp} = getelementptr inbounds %ScrUnion, ptr %v, i64 0, i32 5`);
-                        B.line(`${p} = load ptr, ptr ${pp}`);
+                        const p = emitUnionPeek(B, nullable, "%v");
                         const r = B.tmp();
                         B.line(`${r} = call ptr @${this.dynFuncBoxHelper(arm)}(ptr ${p}, ptr null)`);
                         B.terminate(`ret ptr ${r}`);
                     }
                     else {
-                        const pp = B.tmp();
-                        const p = B.tmp();
-                        B.line(`${pp} = getelementptr inbounds %ScrUnion, ptr %v, i64 0, i32 5`);
-                        B.line(`${p} = load ptr, ptr ${pp}`);
+                        const p = emitUnionPeek(B, nullable, "%v");
                         const r = B.tmp();
                         B.line(`${r} = call ptr @${this.toDynHelper(arm)}(ptr ${p}) ; ${arm.kind}`);
                         B.terminate(`ret ptr ${r}`);