@scriptc/compiler 0.4.3 → 0.4.5

package/dist/backend/llvm/dyn.js

@@ -5,7 +5,7 @@ import { BYTES_ELEM_NUM, SCR_ARR_FIELD, SCR_ARR_STATES, f64Lit, sizeToDouble } f
 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 { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, KEY_ORDER_FIELD, shapeKeyOrders, isDynTypedRefType, isRefCounted, isUnitType, recordTextCodecClass, textCodecRecordClass, typeKey, } from "../../ir/ir.js";
+import { accessorSlotProp, DYN_HANDLE_KINDS, isDirentShape, KEY_ORDER_FIELD, shapeKeyOrders, isDynTypedRefType, isRefCounted, isUnitType, recordHandleCodecClass, textCodecRecordClass, typeKey, } from "../../ir/ir.js";
 import { dynDesc, streamTypedRefEligible } from "../../ir/analysis.js";
 import { mangleRecordNew, mangleRecordStruct } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
@@ -13,6 +13,24 @@ import { llvmCommentText } from "./common.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";
+/** typeKey with `?` after every `(T | undefined)[]` (optionalElements),
+ * at any depth of arrays, Maps, Sets and promises: checked conversions to
+ * `number[][]` and `(number | undefined)[][]` need separate helpers, though
+ * the two types share a typeKey. */
+function checkedConversionKey(t) {
+    switch (t.kind) {
+        case "array":
+            return `array<${checkedConversionKey(t.elem)}>${t.optionalElements ? "?" : ""}`;
+        case "map":
+            return `map<${checkedConversionKey(t.key)},${checkedConversionKey(t.value)}>`;
+        case "set":
+            return `set<${checkedConversionKey(t.elem)}>`;
+        case "promise":
+            return `promise<${checkedConversionKey(t.inner)}>`;
+        default:
+            return typeKey(t);
+    }
+}
 /** Whether to-dyn of a record shape keeps the record itself: an empty shape
  * and an event-listener record (a `handleEvent` function field) box their
  * identity. Every other shape, tuples included, copies its fields into a
@@ -45,10 +63,12 @@ export const DYN_HANDLE_TAG_NUM = {
 export const TEXT_CODEC_TAG_NUM = {
     TextDecoder: 76,
     TextEncoder: 77,
+    StringDecoder: 78,
 };
 /** The decoder record fields scr_text_decoder_to_dyn reads, in its
  * parameter order. */
 const TEXT_DECODER_FIELDS = ["%TextDecoder", "%fatal", "%ignoreBOM", "%state"];
+const STRING_DECODER_FIELDS = ["%enc", "%pending"];
 /** 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. */
@@ -89,6 +109,17 @@ export const DYN_KIND = {
     BIGINT: 14,
     SYMBOL: 15,
 };
+/** Union arm kinds whose matchers reject every plain dyn object
+ * (trustedArmByLiteral). */
+const NON_OBJECT_ARM_KINDS = new Set([
+    "f64",
+    "string",
+    "bool",
+    "nullT",
+    "undefinedT",
+    "bigint",
+    "symbol",
+]);
 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. */
@@ -102,6 +133,10 @@ function builtinStreamKind(className) {
     };
     return kinds[className] ?? null;
 }
+/** Unions whose discriminant has fewer string literals keep one literal test
+ * per arm (dispatchValues): one runtime lookup costs about what a few
+ * literal tests do. */
+const DISCRIMINANT_DISPATCH_VALUES = 4;
 export class LlDyn {
     host;
     dynMatchers = new Map();
@@ -276,6 +311,48 @@ export class LlDyn {
         this.host.declare(`declare void @scr_dyn_build_add(ptr, ptr, ptr)`);
         B.line(`call void @scr_dyn_build_add(ptr %d, ptr @${name}, ptr ${value})`);
     }
+    /** Whether a builder of `def` may pick a plain object's arm by its literal
+     * discriminator alone inside a trusted build (scr_dyn_trust_enter): the
+     * arms' literals are disjoint, and every arm without a literal has a kind
+     * no plain object matches. The value then matched exactly one arm with a
+     * literal, the arm whose literal it carries. */
+    trustedArmByLiteral(def) {
+        const discriminant = def.discriminant;
+        if (!discriminant)
+            return false;
+        const seen = new Set();
+        for (const { values } of discriminant.cases) {
+            for (const value of values) {
+                const key = `${typeof value}:${String(value)}`;
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+            }
+        }
+        return def.arms.every((arm, tag) => discriminant.cases.some((candidate) => candidate.tag === tag) ||
+            NON_OBJECT_ARM_KINDS.has(arm.kind));
+    }
+    /** Per arm of `def`, the dyn kind of the values a builder may convert into
+     * that arm without matching its structure inside a trusted build, or null.
+     * A value there already matched one of the union's arms, so the arm is
+     * known when it is the only arm that takes values of its kind: the arm
+     * whose literal a plain object carries (trustedArmByLiteral), or the one
+     * arm a plain object or an array can match at all. */
+    trustedArmKinds(def) {
+        const byLiteral = this.trustedArmByLiteral(def);
+        const objectArms = def.arms.flatMap((arm, tag) => NON_OBJECT_ARM_KINDS.has(arm.kind) ? [] : [tag]);
+        return def.arms.map((arm, tag) => {
+            if (def.discriminant?.cases.some((candidate) => candidate.tag === tag))
+                return byLiteral ? DYN_KIND.OBJ : null;
+            if (objectArms.length !== 1 || objectArms[0] !== tag)
+                return null;
+            if (arm.kind === "array")
+                return DYN_KIND.ARR;
+            if (arm.kind === "record" && this.host.recordsById.get(arm.shapeId)?.tuple !== true)
+                return DYN_KIND.OBJ;
+            return null;
+        });
+    }
     /** The order a dyn value tries a union's arms in: the canonical order,
      * except that among the record arms, those with more required fields go
      * first, then those with more fields. Records are width-tolerant, so an
@@ -304,9 +381,99 @@ export class LlDyn {
         records.forEach((slot, k) => (order[slot] = widest[k]));
         return order;
     }
+    /** The string literals of `def`'s discriminant when its arms are chosen
+     * by reading the discriminant once (unionArmsByDiscriminant), or null
+     * when the union keeps one literal test per arm: some literal is not a
+     * string, or there are fewer than DISCRIMINANT_DISPATCH_VALUES. */
+    dispatchValues(def) {
+        const values = [];
+        for (const guard of def.discriminant?.cases ?? []) {
+            if (guard.values.length === 0)
+                return null;
+            for (const value of guard.values) {
+                if (typeof value !== "string")
+                    return null;
+                if (!values.includes(value))
+                    values.push(value);
+            }
+        }
+        return values.length < DISCRIMINANT_DISPATCH_VALUES ? null : values;
+    }
+    /** Branches to `hits[tag]` for the first arm in `order` that `%d` matches
+     * (unionArmMatch), or to `none` when no arm does, for
+     * a union whose discriminant literals are `values` (dispatchValues). The
+     * discriminant is read once (scr_dyn_discriminant_case, against the
+     * constant `table`), and only the arms whose literal it holds and the arms
+     * without a literal are tested, in `order`: every other arm's literal test
+     * fails. An arm's failed check can run a getter that changes the
+     * discriminant, so it is read again after each one; when its case
+     * changed, the tests continue arm by arm after the failed arm, as they
+     * would have run from the first arm. A value the runtime cannot classify
+     * that way (a typed capsule, an accessor, an inherited discriminant) takes
+     * the tests arm by arm. */
+    unionArmsByDiscriminant(B, def, values, order, hits, none, preserveRefs, table, trustedKinds = def.arms.map(() => null)) {
+        const discriminant = def.discriminant;
+        const literalsOf = (tag) => discriminant.cases.find((candidate) => candidate.tag === tag)?.values ?? null;
+        const host = this.host;
+        this.defs.push(`${table} = private unnamed_addr constant [${values.length} x ptr] [${values.map((value) => `ptr ${host.internLiteral(value)}`).join(", ")}]`, ``);
+        host.declare(`declare i32 @scr_dyn_discriminant_case(ptr, ptr, ptr, ${host.sizeType})`);
+        const classify = () => {
+            const index = B.tmp();
+            B.line(`${index} = call i32 @scr_dyn_discriminant_case(ptr %d, ptr ${host.internLiteral(discriminant.field)}, ptr ${table}, ${host.sizeType} ${values.length})`);
+            return index;
+        };
+        // The arm-by-arm tests, entered at any arm (`from[i]` tests order[i]
+        // and the arms after it).
+        const tests = B.newLabel("du.tests");
+        const from = order.map((_, i) => (i === 0 ? tests : B.newLabel("du.t")));
+        const after = (position) => position + 1 < order.length ? from[position + 1] : none;
+        // Tests the arms a value in case `k` (-1: no literal) can match.
+        const tryCase = (k) => {
+            const value = k < 0 ? null : values[k];
+            const positions = order
+                .map((_, position) => position)
+                .filter((position) => {
+                const literals = literalsOf(order[position]);
+                return literals === null || (value !== null && literals.includes(value));
+            });
+            if (positions.length === 0) {
+                B.br(none);
+                return;
+            }
+            positions.forEach((position, index) => {
+                const tag = order[position];
+                const failed = B.newLabel("du.c.f");
+                this.unionArmStructure(B, def, tag, hits[tag], failed, preserveRefs, trustedKinds[tag]);
+                B.startBlock(failed);
+                const next = index === positions.length - 1 ? none : B.newLabel("du.c.n");
+                const same = B.tmp();
+                B.line(`${same} = icmp eq i32 ${classify()}, ${k}`);
+                B.condBr(same, next, after(position));
+                if (next !== none)
+                    B.startBlock(next);
+            });
+        };
+        const index = classify();
+        const unmatched = B.newLabel("du.none");
+        const cases = values.map(() => B.newLabel("du.case"));
+        B.terminate(`switch i32 ${index}, label %${tests} [ i32 -1, label %${unmatched} ${cases.map((label, k) => `i32 ${k}, label %${label}`).join(" ")} ]`);
+        values.forEach((_, k) => {
+            B.startBlock(cases[k]);
+            tryCase(k);
+        });
+        B.startBlock(unmatched);
+        tryCase(-1);
+        order.forEach((tag, position) => {
+            B.startBlock(from[position]);
+            this.unionArmMatch(B, def, tag, hits[tag], after(position), preserveRefs, trustedKinds[tag]);
+        });
+    }
     /** Branch to a variant only after its literal discriminator and complete
-     * structure match. Use the same path for predicates and builders. */
-    unionArmMatch(B, def, tag, yes, no, preserveRefs = false) {
+     * structure match. Use the same path for predicates and builders. With a
+     * `trustedKind` (builders, trustedArmKinds), a value of that dyn kind
+     * inside a trusted build skips the structure match once its literal
+     * matched. */
+    unionArmMatch(B, def, tag, yes, no, preserveRefs = false, trustedKind = null) {
         const guard = def.discriminant?.cases.find((candidate) => candidate.tag === tag);
         if (guard && def.discriminant) {
             const structure = B.newLabel("du.shape");
@@ -329,6 +496,25 @@ export class LlDyn {
             });
             B.startBlock(structure);
         }
+        this.unionArmStructure(B, def, tag, yes, no, preserveRefs, trustedKind);
+    }
+    /** The part of unionArmMatch past the arm's literal test. With a
+     * `trustedKind`, a value of that dyn kind inside a trusted build skips the
+     * structure match. */
+    unionArmStructure(B, def, tag, yes, no, preserveRefs, trustedKind = null) {
+        if (trustedKind !== null) {
+            this.host.declare(`declare zeroext i1 @scr_dyn_trusted_build()`);
+            const kind = this.kindOf(B, "%d");
+            const sameKind = B.tmp();
+            const trusted = B.tmp();
+            const skip = B.tmp();
+            B.line(`${sameKind} = icmp eq i32 ${kind}, ${trustedKind}`);
+            B.line(`${trusted} = call zeroext i1 @scr_dyn_trusted_build()`);
+            B.line(`${skip} = and i1 ${sameKind}, ${trusted}`);
+            const full = B.newLabel("du.full");
+            B.condBr(skip, yes, full);
+            B.startBlock(full);
+        }
         const matches = B.tmp();
         B.line(`${matches} = call zeroext i1 @${this.dynMatchHelper(def.arms[tag], preserveRefs)}(ptr %d)`);
         B.condBr(matches, yes, no);
@@ -344,7 +530,7 @@ export class LlDyn {
     }
     /** The value LLVM type of a dynCheck result / toDyn operand for `t`. */
     valTy(t) {
-        return t.kind === "f64" || t.kind === "date" || t.kind === "procStream"
+        return t.kind === "f64" || t.kind === "procStream"
             ? "double"
             : t.kind === "bool"
                 ? "i1"
@@ -403,6 +589,12 @@ export class LlDyn {
     }
     /* ── dyn node plumbing ─────────────────────────────────────────────── */
     /** Loads a dyn node's kind tag (after the size_t rc word). */
+    /** i1: the checked-dynamic value `d` is undefined. */
+    isUndefined(B, d) {
+        const is = B.tmp();
+        B.line(`${is} = icmp eq i32 ${this.kindOf(B, d)}, ${DYN_KIND.UNDEF}`);
+        return is;
+    }
     kindOf(B, d) {
         const p = B.tmp();
         const k = B.tmp();
@@ -732,7 +924,7 @@ export class LlDyn {
     }
     /** `sc_dm_<n>(ptr d) -> i1` — does this dyn fit T? Never throws. */
     dynMatchHelper(t, preserveRefs = false) {
-        const key = typeKey(t);
+        const key = checkedConversionKey(t);
         const matcherKey = preserveRefs ? `identity:${key}` : key;
         const existing = this.dynMatchers.get(matcherKey);
         if (existing)
@@ -774,7 +966,10 @@ export class LlDyn {
             const lPlain = B.newLabel("dm.tr.plain");
             B.condBr(capsule, lCapsule, lPlain);
             B.startBlock(lCapsule);
-            if (preserveRefs) {
+            // A class target matches only capsules of that class (tested above):
+            // a materialized view is a plain object, which never carries a class
+            // brand, so materializing one cannot change the answer.
+            if (preserveRefs || (t.kind === "object" && t.className !== "%Error")) {
                 B.terminate(`ret i1 false`);
             }
             else {
@@ -1022,7 +1217,7 @@ export class LlDyn {
                 B.startBlock(l0);
                 const n = this.lenOf(B, "%d");
                 const items = this.itemsOf(B, "%d");
-                this.i64Loop(B, "dm.el", n, (i, brNext) => {
+                this.i64Loop(B, "dm.el", n, (i, brNext, next) => {
                     this.host.declare(`declare zeroext i1 @scr_dyn_arr_has_index(ptr, ${this.S})`);
                     const present = B.tmp();
                     B.line(`${present} = call zeroext i1 @scr_dyn_arr_has_index(ptr %d, ${this.S} ${i})`);
@@ -1033,6 +1228,15 @@ export class LlDyn {
                     brNext();
                     B.startBlock(valueLabel);
                     const e = this.itemAt(B, items, i);
+                    if (t.optionalElements) {
+                        // A `(T | undefined)[]` stored as T elements takes undefined
+                        // elements as well.
+                        const undef = B.tmp();
+                        const checkLabel = B.newLabel("dm.check");
+                        B.line(`${undef} = icmp eq i32 ${this.kindOf(B, e)}, ${DYN_KIND.UNDEF}`);
+                        B.condBr(undef, next, checkLabel);
+                        B.startBlock(checkLabel);
+                    }
                     const ok = B.tmp();
                     B.line(`${ok} = call zeroext i1 @${m}(ptr ${e})`);
                     const lOk = B.newLabel("dm.eo");
@@ -1050,11 +1254,18 @@ export class LlDyn {
                     throw new InternalCompilerError(`llvm emitter bug: dynCheck of unknown union ${t.unionId}`);
                 // Arms in canonical order; any full match answers true.
                 const yes = B.newLabel("dm.y");
-                for (let tag = 0; tag < def.arms.length; tag++) {
-                    const ln = B.newLabel("dm.n");
-                    this.unionArmMatch(B, def, tag, yes, ln, preserveRefs);
-                    B.startBlock(ln);
+                const values = this.dispatchValues(def);
+                if (values !== null) {
+                    const no = B.newLabel("dm.n");
+                    this.unionArmsByDiscriminant(B, def, values, def.arms.map((_, tag) => tag), def.arms.map(() => yes), no, preserveRefs, `@${name}.cases`);
+                    B.startBlock(no);
                 }
+                else
+                    for (let tag = 0; tag < def.arms.length; tag++) {
+                        const ln = B.newLabel("dm.n");
+                        this.unionArmMatch(B, def, tag, yes, ln, preserveRefs);
+                        B.startBlock(ln);
+                    }
                 B.terminate(`ret i1 false`);
                 B.startBlock(yes);
                 B.terminate(`ret i1 true`);
@@ -1103,8 +1314,9 @@ export class LlDyn {
      * 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. */
+     * jsonUnionSupported), discriminated unions of records anywhere (see
+     * jsonDiscriminatedSupported), 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":
@@ -1129,12 +1341,45 @@ export class LlDyn {
                         this.jsonSchemaSupported(f.type, visiting, true))) &&
                     (!index || this.jsonSchemaSupported(index, visiting)));
             }
-            case "union":
+            case "union": {
+                const def = this.host.unionsById.get(t.unionId);
+                if (def?.discriminant)
+                    return this.jsonDiscriminatedSupported(def, visiting);
                 return member && this.jsonUnionSupported(t, visiting);
+            }
             default:
                 return false;
         }
     }
+    /** A discriminated union the one-pass parser writes directly, as a record
+     * member, an array element or the whole document: record arms that each
+     * name the string literals their discriminant member holds, every
+     * literal naming one arm, plus null and undefined arms. An object then
+     * selects the one arm whose literal its discriminant member holds, the
+     * only arm the checked route's literal tests leave to match
+     * (unionArmsByDiscriminant); an object holding no such literal declines. */
+    jsonDiscriminatedSupported(def, visiting) {
+        const discriminant = def.discriminant;
+        const literals = new Set();
+        let records = 0;
+        const supported = def.arms.every((arm, tag) => {
+            if (arm.kind === "nullT" || arm.kind === "undefinedT")
+                return true;
+            if (arm.kind !== "record")
+                return false;
+            records++;
+            const guard = discriminant.cases.find((candidate) => candidate.tag === tag);
+            if (!guard || guard.values.length === 0)
+                return false;
+            for (const value of guard.values) {
+                if (typeof value !== "string" || literals.has(value))
+                    return false;
+                literals.add(value);
+            }
+            return this.jsonSchemaSupported(arm, visiting);
+        });
+        return supported && records >= 2;
+    }
     /** 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.
@@ -1228,9 +1473,15 @@ export class LlDyn {
                 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`;
+            case "union": {
+                // A discriminated union can be a whole document, whose value the
+                // parser releases when text follows it.
+                const release = host.unionsById.get(t.unionId)?.discriminant
+                    ? vAdapters(host, t).release
+                    : "null";
+                body = `${S} 5, ${S} 0, ptr null, ptr null, ptr null, ptr null, ptr ${release}, ptr @${this.jsonUnionSchema(t, name)}, ${S} 0`;
                 break;
+            }
             default:
                 throw new InternalCompilerError(`llvm emitter bug: JSON schema of ${t.kind}`);
         }
@@ -1241,7 +1492,11 @@ export class LlDyn {
     /** 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`. */
+     * unions build their boxes through `<name>_box`. A discriminated union
+     * also lists its object arms by discriminant literal (`<name>_cases`),
+     * and, because it can be an array element or a whole document, whose
+     * values are boxes unless the union is a pointer union, it keeps its null
+     * value and box whatever its field representation. */
     jsonUnionSchema(t, name) {
         const host = this.host;
         const S = host.sizeType;
@@ -1259,10 +1514,11 @@ export class LlDyn {
             : "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";
+        const values = !inline || def.discriminant !== undefined;
+        const nullValue = values && nullTag >= 0 ? host.unitInstanceRef(t.unionId, nullTag) : "null";
+        const absentValue = values && absentTag >= 0 ? host.absentInstanceRef(t.unionId) : "null";
         let box = "null";
-        if (repr === 2) {
+        if (repr === 2 || (def.discriminant && !nullable)) {
             box = `@${name}_box`;
             const lines = [`define internal ptr ${box}(i32 %tag, i64 %bits) ${FN_ATTRS} {`, `entry:`];
             const cases = [];
@@ -1289,10 +1545,29 @@ export class LlDyn {
             });
             this.defs.push(...lines, `  switch i32 %tag, label %none [ ${cases.join(" ")} ]`, `none:`, `  unreachable`, ...blocks, `}`, ``);
         }
+        let cases = "null";
+        if (def.discriminant) {
+            const discriminant = def.discriminant;
+            const caseTy = `{ ptr, ${S}, ${S}, ptr }`;
+            const entries = discriminant.cases.flatMap((guard) => guard.values.map((value) => `${caseTy} { ptr ${host.cstr(String(value))}, ${S} ${Buffer.byteLength(String(value), "utf8")}, ${S} ${guard.tag}, ptr @${this.jsonSchema(def.arms[guard.tag])} }`));
+            const table = `@${name}_case_table`;
+            cases = `@${name}_cases`;
+            this.defs.push(`${table} = internal constant [${entries.length} x ${caseTy}] [${entries.join(", ")}]`, `${cases} = internal constant { ptr, ${S}, ${S}, ptr } { ptr ${host.cstr(discriminant.field)}, ${S} ${Buffer.byteLength(discriminant.field, "utf8")}, ${S} ${entries.length}, ptr ${table} }`, ``);
+        }
         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} }`, ``);
+        this.defs.push(`@${descriptor} = internal constant { ${S}, [7 x ${S}], [7 x ptr], 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}, ptr ${cases} }`, ``);
         return descriptor;
     }
+    /** `record.sourceSpread(built, value)`: the built record keeps value's
+     * kept-source order over its own declared names. */
+    emitRecordSourceSpread(B, built, value, shapeId) {
+        const host = this.host;
+        const shape = host.recordsById.get(shapeId);
+        this.keepsRecordSources = true;
+        const names = this.recordNameTable(shapeId, shape);
+        host.declare(`declare void @scr_record_source_spread(ptr, ptr, ptr, ptr, ${host.sizeType})`);
+        B.line(`call void @scr_record_source_spread(ptr ${built}, ptr ${value}, ptr ${names.names}, ptr ${names.lens}, ${host.sizeType} ${shape.fields.length})`);
+    }
     /** 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
@@ -1320,7 +1595,9 @@ export class LlDyn {
      * 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")
+        if (t.kind !== "record" &&
+            t.kind !== "array" &&
+            !(t.kind === "union" && this.host.unionsById.get(t.unionId)?.discriminant))
             return null;
         const key = typeKey(t);
         const existing = this.jsonParsers.get(key);
@@ -1346,7 +1623,8 @@ export class LlDyn {
      * BUILD the typed value (+1), or throw the catchable path-annotated
      * TypeError and return a dummy with the pending flag set. */
     dynCheckHelper(t, preserveRefs = false) {
-        const key = typeKey(t);
+        // A `(T | undefined)[]` stored as T elements also takes undefined ones.
+        const key = checkedConversionKey(t);
         const builderKey = preserveRefs ? `identity:${key}` : key;
         const existing = this.dynBuilders.get(builderKey);
         if (existing)
@@ -1364,6 +1642,26 @@ export class LlDyn {
         const B = new BlockBuilder();
         if (t.kind === "classval") {
             host.declare(`declare ptr @scr_dyn_class_check(ptr, ptr, ptr)`);
+            // A subclass's class value checks into the base class's slot when
+            // construction through the slot can call its thunk with the base
+            // constructor's arguments; any other subclass fails the check.
+            const subclasses = host.classValueSubtypes(t.className);
+            if (subclasses.length > 0) {
+                host.declare(`declare zeroext i1 @scr_dyn_class_is(ptr, ptr)`);
+                for (const className of subclasses) {
+                    const subKey = host.cstr(typeKey({ kind: "classval", className }));
+                    const matched = B.tmp();
+                    B.line(`${matched} = call zeroext i1 @scr_dyn_class_is(ptr %d, ptr ${subKey})`);
+                    const yes = B.newLabel("sub.yes");
+                    const no = B.newLabel("sub.no");
+                    B.condBr(matched, yes, no);
+                    B.startBlock(yes);
+                    const sub = B.tmp();
+                    B.line(`${sub} = call ptr @scr_dyn_class_check(ptr %d, ptr ${subKey}, ptr %path)`);
+                    B.terminate(`ret ptr ${sub}`);
+                    B.startBlock(no);
+                }
+            }
             const checked = B.tmp();
             B.line(`${checked} = call ptr @scr_dyn_class_check(ptr %d, ptr ${host.cstr(key)}, ptr %path)`);
             B.terminate(`ret ptr ${checked}`);
@@ -1374,9 +1672,15 @@ export class LlDyn {
         const codec = textCodecRecordClass(t, (id) => host.recordsById.get(id));
         if (codec !== null) {
             // The record the codec's handle box holds (+1), or the path TypeError.
-            host.declare(`declare ptr @scr_text_codec_from_dyn(ptr, i1 zeroext, ptr, ptr)`);
             const checked = B.tmp();
-            B.line(`${checked} = call ptr @scr_text_codec_from_dyn(ptr %d, i1 ${codec === "TextDecoder"}, ptr %path, ptr ${want})`);
+            if (codec === "StringDecoder") {
+                host.declare(`declare ptr @scr_string_decoder_from_dyn(ptr, ptr, ptr)`);
+                B.line(`${checked} = call ptr @scr_string_decoder_from_dyn(ptr %d, ptr %path, ptr ${want})`);
+            }
+            else {
+                host.declare(`declare ptr @scr_text_codec_from_dyn(ptr, i1 zeroext, ptr, ptr)`);
+                B.line(`${checked} = call ptr @scr_text_codec_from_dyn(ptr %d, i1 ${codec === "TextDecoder"}, ptr %path, ptr ${want})`);
+            }
             B.terminate(`ret ptr ${checked}`);
             this.defs.push(`define internal ptr @${name}(ptr %d, ptr %path) ${FN_ATTRS} {`, B.render(), `}`, ``);
             this.host.journalBuilt?.();
@@ -1604,10 +1908,10 @@ export class LlDyn {
         };
         switch (t.kind) {
             case "date": {
-                host.declare(`declare double @scr_dyn_native_date_value(ptr)`);
+                host.declare(`declare ptr @scr_dyn_native_date_check(ptr, ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call double @scr_dyn_native_date_value(ptr %d)`);
-                B.terminate(`ret double ${r}`);
+                B.line(`${r} = call ptr @scr_dyn_native_date_check(ptr %d, ptr %path)`);
+                B.terminate(`ret ptr ${r}`);
                 break;
             }
             case "url":
@@ -2043,6 +2347,21 @@ export class LlDyn {
                     B.line(`${ip} = getelementptr inbounds %ScrDynPath, ptr ${pathSlot}, i64 0, i32 2`);
                     B.line(`store ${host.sizeType} ${i}, ptr ${ip}`);
                     const e = this.itemAt(B, items, i);
+                    if (t.optionalElements) {
+                        // An undefined element is a present undefined element.
+                        const undef = B.tmp();
+                        const storeUndefined = B.newLabel("dca.undef");
+                        const checkLabel = B.newLabel("dca.check");
+                        B.line(`${undef} = icmp eq i32 ${this.kindOf(B, e)}, ${DYN_KIND.UNDEF}`);
+                        B.condBr(undef, storeUndefined, checkLabel);
+                        B.startBlock(storeUndefined);
+                        host.declare(`declare void @scr_arr_set_undefined(ptr, double)`);
+                        const at = B.tmp();
+                        B.line(`${at} = ${sizeToDouble(this.S)} ${this.S} ${i} to double`);
+                        B.line(`call void @scr_arr_set_undefined(ptr ${a}, double ${at})`);
+                        B.br(doneLabel);
+                        B.startBlock(checkLabel);
+                    }
                     const v = B.tmp();
                     B.line(`${v} = call ${this.valTy(elem)} @${c}(ptr ${e}, ptr ${pathSlot})`);
                     this.pendingBail(B, "dca", () => {
@@ -2062,13 +2381,20 @@ export class LlDyn {
                 if (!def)
                     throw new InternalCompilerError(`llvm emitter bug: dynCheck of unknown union ${t.unionId}`);
                 // Arms in unionArmOrder, first FULL match wins. The matched arm's
-                // builder can no longer fail.
-                for (const i of this.unionArmOrder(def)) {
+                // builder can no longer fail, and it runs as a trusted build: a
+                // nested union inside it picks the arm trustedArmKinds names without
+                // matching the structure that this match already checked.
+                const trustedKinds = preserveRefs ? def.arms.map(() => null) : this.trustedArmKinds(def);
+                const trustedCall = (call) => {
+                    host.declare(`declare zeroext i1 @scr_dyn_trust_enter()`);
+                    host.declare(`declare void @scr_dyn_trust_exit(i1 zeroext)`);
+                    const previous = B.tmp();
+                    B.line(`${previous} = call zeroext i1 @scr_dyn_trust_enter()`);
+                    call();
+                    B.line(`call void @scr_dyn_trust_exit(i1 zeroext ${previous})`);
+                };
+                const build = (i) => {
                     const arm = def.arms[i];
-                    const lHit = B.newLabel("dcu.h");
-                    const lNext = B.newLabel("dcu.n");
-                    this.unionArmMatch(B, def, i, lHit, lNext, preserveRefs);
-                    B.startBlock(lHit);
                     if (arm.kind === "undefinedT" || arm.kind === "nullT") {
                         // A matched unit arm builds nothing: THE interned immortal
                         // instance (rc == SIZE_MAX — no retain owed).
@@ -2093,7 +2419,7 @@ export class LlDyn {
                     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)`);
+                        trustedCall(() => B.line(`${x} = call ptr @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`));
                         B.terminate(`ret ptr ${x}`);
                     }
                     else {
@@ -2101,12 +2427,32 @@ export class LlDyn {
                         host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call ptr @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
+                        trustedCall(() => B.line(`${x} = call ptr @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`));
                         B.line(`${u} = call ptr @scr_union_new_ref(i32 ${i}, ptr ${x}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`);
                         B.terminate(`ret ptr ${u}`);
                     }
-                    B.startBlock(lNext);
+                };
+                const order = this.unionArmOrder(def);
+                const values = this.dispatchValues(def);
+                if (values !== null) {
+                    const hits = def.arms.map(() => B.newLabel("dcu.h"));
+                    const unmatched = B.newLabel("dcu.n");
+                    this.unionArmsByDiscriminant(B, def, values, order, hits, unmatched, preserveRefs, `@${name}.cases`, trustedKinds);
+                    for (const i of order) {
+                        B.startBlock(hits[i]);
+                        build(i);
+                    }
+                    B.startBlock(unmatched);
                 }
+                else
+                    for (const i of order) {
+                        const lHit = B.newLabel("dcu.h");
+                        const lNext = B.newLabel("dcu.n");
+                        this.unionArmMatch(B, def, i, lHit, lNext, preserveRefs, trustedKinds[i]);
+                        B.startBlock(lHit);
+                        build(i);
+                        B.startBlock(lNext);
+                    }
                 if (preserveRefs) {
                     B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${host.cstr("reference with its original layout")}, ptr %d)`);
                     B.terminate(`ret ptr null`);
@@ -2330,9 +2676,9 @@ export class LlDyn {
         B.line(`${matched} = phi i1 [ false, %${entry} ], [ ${same}, %${lHandle} ]`);
         return matched;
     }
-    /** A TextEncoder or TextDecoder record boxes as its handle (+1), which
-     * holds the record by reference. A decoder passes the byte offsets of the
-     * fields its boxed decode reads. */
+    /** A TextEncoder, TextDecoder or StringDecoder record boxes as its
+     * handle (+1), which holds the record by reference. The decoders pass
+     * the byte offsets of the fields their boxed methods read. */
     textCodecToDyn(B, t, shape, codec) {
         const host = this.host;
         const rc = vAdapters(host, t);
@@ -2346,10 +2692,11 @@ export class LlDyn {
             const base = host.nullableUnions.fieldBase(t.shapeId);
             const start = B.tmp();
             B.line(`${start} = ptrtoint ptr %v to ${this.S}`);
-            const offsets = TEXT_DECODER_FIELDS.map((field) => {
+            const fields = codec === "StringDecoder" ? STRING_DECODER_FIELDS : TEXT_DECODER_FIELDS;
+            const offsets = fields.map((field) => {
                 const index = shape.fields.findIndex((f) => f.name === field);
                 if (index < 0)
-                    throw new InternalCompilerError(`llvm emitter bug: TextDecoder record lacks ${field}`);
+                    throw new InternalCompilerError(`llvm emitter bug: ${codec} record lacks ${field}`);
                 const p = B.tmp();
                 const at = B.tmp();
                 const offset = B.tmp();
@@ -2358,8 +2705,9 @@ export class LlDyn {
                 B.line(`${offset} = sub ${this.S} ${at}, ${start}`);
                 return `${this.S} ${offset}`;
             });
-            host.declare(`declare ptr @scr_text_decoder_to_dyn(ptr, ptr, ptr, ${this.S}, ${this.S}, ${this.S}, ${this.S})`);
-            B.line(`${r} = call ptr @scr_text_decoder_to_dyn(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ${offsets.join(", ")})`);
+            const fn = codec === "StringDecoder" ? "scr_string_decoder_to_dyn" : "scr_text_decoder_to_dyn";
+            host.declare(`declare ptr @${fn}(ptr, ptr, ptr, ${fields.map(() => this.S).join(", ")})`);
+            B.line(`${r} = call ptr @${fn}(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ${offsets.join(", ")})`);
         }
         B.terminate(`ret ptr ${r}`);
     }
@@ -2380,11 +2728,10 @@ export class LlDyn {
         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)`);
+                // A Date handle holding the same Date object.
+                host.declare(`declare ptr @scr_dyn_native_date(ptr)`);
                 const r = B.tmp();
-                B.line(`${r} = call ptr @scr_dyn_native_date_from_ms(double %v)`);
+                B.line(`${r} = call ptr @scr_dyn_native_date(ptr %v)`);
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
@@ -2524,7 +2871,7 @@ export class LlDyn {
                 const shape = host.recordsById.get(t.shapeId);
                 if (!shape)
                     throw new InternalCompilerError(`llvm emitter bug: to-dyn of unknown shape ${t.shapeId}`);
-                const codec = recordTextCodecClass(shape);
+                const codec = recordHandleCodecClass(shape);
                 if (codec !== null) {
                     this.textCodecToDyn(B, t, shape, codec);
                     break;