@scriptc/compiler 0.3.2 → 0.3.4

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,5 @@
 import { lifetimeRegionType, lowerLifetimeRegionCall, lowerLifetimeRegionNew, } from "./lifetime-regions.js";
+import { internTableType, lowerInternTableCall, lowerInternTableNew } from "./intern-tables.js";
 import { isExperimentalDeclarationFile } from "../experimental-import.js";
 import { checkCycleBindingAccesses, refuseUncheckedCycleReads, } from "./cycle-initialization.js";
 import { identityPreservingWidening } from "./coercions/identity.js";
@@ -9,6 +10,8 @@ import { isOptionalProcessStreamProperty } from "./builtins/process.js";
 import { isSettledIteratorValueRead } from "./lower-generators.js";
 import { concreteCollectionNarrow } from "./collection-narrowing.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
+import { fenceStaticBlobMember, lowerBlobNew, lowerStaticBlobCall } from "./builtins/blob.js";
+import { lowerKeyObjectCall } from "./builtins/key-object.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
 import { iteratorSlotAdapter } from "./iterator-adapters.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
@@ -26,6 +29,7 @@ import { NarrowingStability } from "./narrowing-stability.js";
 import { ArrayElementStates } from "./runtime-optional-elements.js";
 import { indexReadInBounds } from "./runtime-optional-bounds.js";
 import { ArrayOwnership } from "./runtime-optional-ownership.js";
+import { RecordFlowClasses } from "./runtime-optional-records.js";
 import { StringIndexBounds } from "./string-index-bounds.js";
 import { NanCodedReads } from "./nan-coded-reads.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
@@ -35,6 +39,7 @@ import { UnregisteredClassTypes } from "./unregistered-class-types.js";
 import { bindingInContext, captureContextBinding, declareContextLocal, declareContextThis, } from "./function-context.js";
 import { InternalCompilerError } from "../../errors.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
+import {} from "./class-protocol-dispatch.js";
 import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
 import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
@@ -70,6 +75,7 @@ import { containsRecord, containsUnion, describeComponentBlocker, describeRecord
 import { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules, appendWorkerModules, } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.js";
+import { registerBuiltinEventTargetClasses } from "./lower-event-target.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorConstructorArgs, lowerNew, accessorCall, } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType, } from "./lower-mixins.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
@@ -117,7 +123,7 @@ import { lowerDateCall } from "./builtins/dates.js";
 import { lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
 import { lowerStringStaticCall, lowerStringLastIndexOfCall } from "./builtins/strings.js";
 import { lowerPromiseStaticCall } from "./builtins/promises.js";
-import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
+import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerLiveWebValue, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates, } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty, } from "./lower-test.js";
@@ -501,8 +507,8 @@ export function neverTaintedJsType(lowerer, node, t) {
  * per-statement runtime fence would have thrown (message + "[code at
  * file:line]"), rendered eagerly so the runtime can throw it verbatim
  * (scr_throw_lowering_fence). The diagnostic joins the runtime-fence
- * ledger exactly like a deferred statement fence — nothing silently
- * drops off the coverage report. */
+ * ledger exactly like a deferred statement fence, so every fence appears
+ * on the coverage report. */
 export function ladderFenceExpr(lowerer, surface, node, hint) {
     const loc = locOf(node);
     const d = noLoweringDiag(surface, loc, hint);
@@ -526,8 +532,18 @@ export function dynFallbackType(lowerer, node, t) {
         const args = symbol && lowerer.isStdlibSymbol(symbol)
             ? lowerer.checker.getTypeArguments(t)
             : [];
-        if (symbol?.name === "Promise" && args[0] && args[0].flags & ts.TypeFlags.Any)
-            return jsFallbackPromiseType(lowerer, t);
+        // Promise<any> and Promise<any[]> (an any[] is itself a checked
+        // value below): a promise of a checked value.
+        const anyArray = (x) => lowerer.checker.isArrayType(x) &&
+            ((lowerer.checker.getTypeArguments(x)[0]?.flags ?? 0) &
+                ts.TypeFlags.Any) !==
+                0;
+        if (symbol?.name === "Promise" &&
+            args[0] &&
+            (args[0].flags & ts.TypeFlags.Any || anyArray(args[0])))
+            return symbol.name === "Promise" && anyArray(args[0])
+                ? { kind: "promise", inner: DYN }
+                : jsFallbackPromiseType(lowerer, t);
         if (symbol &&
             ["Generator", "AsyncGenerator", "IterableIterator"].includes(symbol.name) &&
             args.some((arg) => arg.flags & ts.TypeFlags.Any))
@@ -836,6 +852,14 @@ export function jsFuncNameOf(node, lowerer) {
     return null;
 }
 /** Answers `fallback` when a checker query panics inside the type checker. */
+/** The storage of a global whose binding type widened. A lexical binding's
+ * TDZ guard needs pointer, record or checked-value storage, so a guarded
+ * function binding that may now hold undefined is a checked value. */
+function tdzStorage(global, type) {
+    return global.tdz && type.kind !== "record" && type.kind !== "func" && type.kind !== "dyn"
+        ? DYN
+        : type;
+}
 function panicSafe(query, fallback) {
     try {
         return query();
@@ -1107,6 +1131,9 @@ export class Lowerer {
     requestInitPropMutatedSyms = null;
     emitterEventTable = null;
     emitterComputedPatterns = [];
+    /** The EventTarget engine's handleEvent reader was lifted
+     * (lower-event-target.ts noteEventListeners). */
+    handleEventReader = false;
     /** Locals widened beyond the checker's type because an inferred indexed
      * read can be absent at runtime. Bare reads preserve that union until a
      * surrounding JavaScript guard/default consumes it. */
@@ -1138,6 +1165,11 @@ export class Lowerer {
      * prepass. This includes explicit annotations: unchecked TS annotations do
      * not prove that an array property read produced a value. */
     runtimeOptionalBindingTypes = new Map();
+    /** A pipeline() function stage's `source` parameter: the IR type of what
+     * the pipeline passes it (the previous stage as an async iterable), set
+     * while the stage lowers. Parameter typing and `for await` heads read
+     * it before the checker's `AsyncIterable<T>`. */
+    stageSourceTypes = new Map();
     /** Set when a match result lowers to execGroups/matchGroups, the inputs
      * of regex span folding. */
     regexGroupResults = false;
@@ -1159,6 +1191,10 @@ export class Lowerer {
     /** Record fields promoted to an undefined-armed union by an indexed-read
      * value. The key is the concrete emitted shape and field name. */
     runtimeOptionalFields = new Set();
+    /** Record bindings whose flow class reaches storage outside the class:
+     * they keep the declared layout, so an initializer from unchecked reads
+     * converts once instead of the binding adopting the widened variant. */
+    runtimeOptionalRecordsKeptDeclared = new Set();
     /** Callback pattern parameters carry an optional source without making
      * every name destructured from a present source optional. */
     runtimeOptionalPatternTypes = new Map();
@@ -1174,6 +1210,9 @@ export class Lowerer {
     /** for-of loops over arrays that can hold neither holes nor undefined:
      * each pass reads the element payload directly. */
     presentElementLoops = new Set();
+    /** The fs/promises glob() call lowerForOf is lowering as a for await
+     * head; other glob() calls have no lowering. */
+    fspGlobHead = null;
     /** Capture entries and their origin share one mutable box. Normalize each
      * entry to the origin so writes and flow proofs stay synchronized. */
     runtimeOptionalRoots = new Map();
@@ -1190,8 +1229,10 @@ export class Lowerer {
         if (!symbol)
             return fallback ?? null;
         const known = this.runtimeOptionalBindingTypes.get(symbol);
-        if (known)
-            return known;
+        if (known) {
+            const global = this.globalsBySymbol.get(symbol);
+            return global ? tdzStorage(global, known) : known;
+        }
         // A module-scope function alias is collected as a global before the
         // optional-read fixed point settles. Derive its promoted function ABI
         // directly from the aliased declaration as a final read-side hook, so
@@ -1451,6 +1492,10 @@ export class Lowerer {
             return type;
         }
         const shapeId = this.shapes.intern(shape.fields.map((f) => ({ name: f.name, type: f.name === field ? fieldType : f.type })), shape.tuple === true, shape.indexValue, shape.declaredOrder);
+        // The widened shape keeps the fields this one already widened.
+        for (const f of shape.fields)
+            if (this.isRuntimeOptionalField(type.shapeId, f.name))
+                this.runtimeOptionalFields.add(this.runtimeOptionalFieldKey(shapeId, f.name));
         this.runtimeOptionalFields.add(this.runtimeOptionalFieldKey(shapeId, field));
         return { kind: "record", shapeId };
     }
@@ -1516,6 +1561,12 @@ export class Lowerer {
      * typeKey, throws wrappers keyed by callback type + expected class) —
      * the valueHelpers pattern with its own namespace. */
     assertHelpers = new Map();
+    /** Static node:assert Assert instances by declaration (assert-instances.ts);
+     * null for declarations that are not one. */
+    assertInstances = new Map();
+    /** The options of the Assert instance whose method call is being lowered,
+     * or null for module calls. */
+    assertCallOptions = null;
     /** util.inspect's per-type traversal helpers (%util.insp.N), interned
      * by typeKey — the assertHelpers pattern with its own namespace. */
     inspectHelpers = new Map();
@@ -1534,8 +1585,9 @@ export class Lowerer {
      * runtime closure pointer: a coercion adapter allocates a different
      * closure at the registration and release sites, so lowerFfiCall must
      * refuse these forms at compile time (SC5003). Any new closure-minting
-     * adapter helper MUST add its name here, or the identity guard silently
-     * reopens and the mismatch surfaces as a runtime release trap instead. */
+     * adapter helper MUST add its name here, or the identity guard reopens
+     * without a diagnostic and the mismatch surfaces as a runtime release
+     * trap instead. */
     freshClosureAdapters = new Set();
     /** Symbols bound by `const process = globalThis.process` (and the other
      * stdlib-global snapshot spellings): pure alias plumbing — receiver
@@ -1611,6 +1663,11 @@ export class Lowerer {
     /** Named method slots observed before class collection need a callable
      * ABI and shared prototype descriptors instead of call-site specialization. */
     prototypeMethodAccesses = new Map();
+    /** Typed calls through class-backed protocols, by signature; class
+     * dynamic dispatch adds their native arms (class-protocol-dispatch.ts). */
+    protocolDispatches = new Map();
+    /** Bindings no other function assigns (class-protocol-dispatch.ts). */
+    protocolOwnedBindings = new Map();
     /** Field names whose complete source census stores only lexical arrows. */
     receiverFreeCallbackFields = new Set();
     /** Inferred JS methods participating in an override chain keep a vtable
@@ -1673,6 +1730,10 @@ export class Lowerer {
     experimentalFiles = new Map();
     /** Interned LifetimeRegion.run helpers, by callback type key. */
     regionRunHelpers = new Map();
+    /** Interned InternTable helpers, by member and type keys (intern-tables.ts). */
+    internTableHelpers = new Map();
+    /** Each InternTable name's type arguments and first construction site. */
+    internTableNames = new Map();
     forkTargetIdByPath = new Map();
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -1990,6 +2051,9 @@ export class Lowerer {
             lifetimeRegionClass: (decl) => isExperimentalDeclarationFile(decl.getSourceFile(), this.experimentalFiles)
                 ? lifetimeRegionType(this)
                 : null,
+            internTableClass: (decl) => isExperimentalDeclarationFile(decl.getSourceFile(), this.experimentalFiles)
+                ? internTableType(this)
+                : null,
             moduleNamespaceId: (type) => this.moduleNamespaceIdOfType(type),
         };
         // Modules reachable only through literal import() joined
@@ -2004,6 +2068,7 @@ export class Lowerer {
         this.registerBuiltinErrorClasses();
         registerBuiltinEmitterClass(this);
         registerBuiltinStreamClasses(this);
+        registerBuiltinEventTargetClasses(this);
     }
     registerBuiltinErrorClasses() {
         return registerBuiltinErrorClasses(this);
@@ -3049,6 +3114,57 @@ export class Lowerer {
             }
         }
         const mappedOrNull = (node) => panicSafe(() => this.mapTypeOf(this.typeOf(node)), null);
+        const admitsUndefined = (type) => typeEquals(addUndefined(type), type);
+        const plainRecordShape = (type) => {
+            if (type?.kind !== "record")
+                return null;
+            const shape = this.shapes.get(type.shapeId);
+            return shape && !shape.tuple && !shape.indexValue && shape.fields.length > 0
+                ? type.shapeId
+                : null;
+        };
+        // Parameters and results read the signatures collected above; bindings
+        // ask the checker, so the scan builds no layout of its own.
+        const parameterType = (node) => {
+            const parameter = node.parent;
+            if (!parameter || !ts.isParameter(parameter))
+                return null;
+            const fn = parameter.parent;
+            const symbol = (ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) && fn.name
+                ? symbolOf(fn.name)
+                : null;
+            const index = fn.parameters.indexOf(parameter);
+            return (symbol && signatureBySymbol.get(symbol)?.params[index]?.type) ?? null;
+        };
+        const returnTypeOf = (fn) => {
+            const symbol = fn.name ? symbolOf(fn.name) : null;
+            return (symbol && signatureBySymbol.get(symbol)?.returnType) ?? null;
+        };
+        const recordFlows = new RecordFlowClasses(sourceFiles, {
+            symbolOf,
+            declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
+            mayBeRecord: (node) => {
+                if (node.parent && ts.isParameter(node.parent))
+                    return plainRecordShape(parameterType(node)) !== null;
+                const t = panicSafe(() => this.typeOf(node), null);
+                return (t !== null &&
+                    (t.flags & ts.TypeFlags.Object) !== 0 &&
+                    !this.checker.isArrayType(t) &&
+                    this.checker.getCallSignatures(t).length === 0 &&
+                    this.checker.getConstructSignatures(t).length === 0);
+            },
+            prefetchTypes: (nodes) => this.checker.prefetchCollectionTypes(nodes),
+            mayReturnRecord: (fn) => plainRecordShape(returnTypeOf(fn)) !== null,
+            familyOf: (method) => familyBySymbol.get(method),
+            recordShape: (node) => plainRecordShape(node.parent && ts.isParameter(node.parent) ? parameterType(node) : mappedOrNull(node)),
+            returnShape: (fn) => plainRecordShape(returnTypeOf(fn)),
+            isGlobal: (node, name) => this.isStdlibGlobal(node, name),
+        });
+        /** Optional fields of the records a visible function returns. */
+        const returnFields = new Map();
+        /** Record parameters that receive a value with optional fields, by the
+         * parameter's own symbol. */
+        const recordParameterSlots = new Map();
         const nanCoded = new NanCodedReads({
             symbolOf,
             declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
@@ -3327,10 +3443,8 @@ export class Lowerer {
                 if (op === ts.SyntaxKind.AmpersandAmpersandToken)
                     return mayBeOptional(e.left) || mayBeOptional(e.right);
             }
-            if (ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression)) {
-                const symbol = symbolOf(e.expression);
-                const fields = symbol === null ? undefined : optionalFields.get(symbol);
-                return fields?.has(fieldName(e)) ?? false;
+            if (ts.isPropertyAccessExpression(e)) {
+                return fieldsOfValue(e.expression)?.has(fieldName(e)) ?? false;
             }
             return false;
         };
@@ -3439,10 +3553,40 @@ export class Lowerer {
         // a spread or a parameter receives the source's optional fields.
         const fieldsOfValue = (node) => {
             const e = peel(node);
-            if (!ts.isIdentifier(e))
-                return undefined;
-            const symbol = symbolOf(e);
-            return symbol === null ? undefined : optionalFields.get(symbol);
+            if (ts.isIdentifier(e)) {
+                const symbol = symbolOf(e);
+                // A binding whose class reaches other storage keeps the declared
+                // layout, so its fields read as present.
+                return symbol === null || recordFlows.opened(symbol)
+                    ? undefined
+                    : optionalFields.get(symbol);
+            }
+            // A fresh literal carries the fields its values can leave undefined.
+            if (ts.isObjectLiteralExpression(e)) {
+                const out = spreadFieldsOf(e);
+                for (const prop of e.properties) {
+                    if (!ts.isPropertyAssignment(prop) && !ts.isShorthandPropertyAssignment(prop))
+                        continue;
+                    const name = prop.name;
+                    if (!(ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)))
+                        continue;
+                    const value = ts.isPropertyAssignment(prop) ? prop.initializer : name;
+                    if (mayBeOptional(value))
+                        out.add(name.text);
+                }
+                return out.size > 0 ? out : undefined;
+            }
+            if (ts.isCallExpression(e) &&
+                (ts.isIdentifier(e.expression) || ts.isPropertyAccessExpression(e.expression))) {
+                const symbol = symbolOf(ts.isIdentifier(e.expression) ? e.expression : e.expression.name);
+                return symbol === null ? undefined : returnFields.get(symbol);
+            }
+            if (ts.isConditionalExpression(e)) {
+                const a = fieldsOfValue(e.whenTrue);
+                const b = fieldsOfValue(e.whenFalse);
+                return a && b ? new Set([...a, ...b]) : (a ?? b);
+            }
+            return undefined;
         };
         const noteFieldsFrom = (symbol, source) => {
             const fields = fieldsOfValue(source);
@@ -3852,7 +3996,19 @@ export class Lowerer {
         // Checker answers for the fixed point's repeated element-ABI queries.
         // Only a binding's widened storage can change between passes.
         const checkerTypes = new Map();
-        const arrayKeysOf = (node) => panicSafe(() => arrayKeysUnsafe(node), null);
+        // Mapping a type can lower a local class expression. When that class is
+        // unsupported, its diagnostic is already recorded and the element ABI
+        // is unknown here; the program fails with that diagnostic.
+        const arrayKeysOf = (node) => panicSafe(() => {
+            try {
+                return arrayKeysUnsafe(node);
+            }
+            catch (e) {
+                if (e instanceof PoisonError)
+                    return null;
+                throw e;
+            }
+        }, null);
         const arrayKeysUnsafe = (node) => {
             let checkerType = checkerTypes.get(node);
             if (checkerType === undefined) {
@@ -4470,23 +4626,21 @@ export class Lowerer {
                                 const bound = symbolOf(parameter.name);
                                 if (!bound)
                                     continue;
-                                let promoted = parameterShape.type;
+                                const declared = this.shapes.get(parameterShape.type.shapeId);
+                                // The parameter's layout settles with its flow class once
+                                // the fixed point ends. A literal or call argument only adds
+                                // fields the declaration calls present.
+                                const fresh = !ts.isIdentifier(peel(arg));
                                 for (const field of fields) {
-                                    const source = promoted.kind === "record"
-                                        ? this.shapes.get(promoted.shapeId)?.fields.find((f) => f.name === field)
-                                        : undefined;
-                                    if (source) {
-                                        promoted = this.runtimeOptionalRecordField(promoted, field, addUndefined(source.type));
-                                    }
-                                    if (noteFieldSymbol(bound, field))
+                                    const slot = declared?.fields.find((f) => f.name === field);
+                                    if (!slot || (fresh && admitsUndefined(slot.type)))
+                                        continue;
+                                    if (noteFieldSymbol(bound, field)) {
+                                        provenance?.note("record-parameter", parameter, arg);
                                         changed = true;
+                                    }
                                 }
-                                if (!typeEquals(promoted, parameterShape.type)) {
-                                    parameterShape.type = promoted;
-                                    this.runtimeOptionalBindingTypes.set(bound, promoted);
-                                    provenance?.note("record-parameter", parameter, arg);
-                                    changed = true;
-                                }
+                                recordParameterSlots.set(bound, { target, index: i });
                             }
                         }
                         if (ts.isSpreadElement(arg) || !shape)
@@ -4570,7 +4724,27 @@ export class Lowerer {
         };
         const scanReturns = (symbol, decl) => {
             let changed = false;
+            const recordReturn = recordFlows.returnClass(symbol) !== null;
+            const returned = signatureBySymbol.get(symbol)?.returnType;
+            const returnedShape = returned?.kind === "record" ? this.shapes.get(returned.shapeId) : null;
             for (const expression of returnsOf(decl)) {
+                const fields = recordReturn ? fieldsOfValue(expression) : undefined;
+                if (fields) {
+                    for (const field of fields) {
+                        // A result field that already admits undefined keeps the
+                        // checker's narrowing.
+                        const slot = returnedShape?.fields.find((f) => f.name === field);
+                        if (slot && admitsUndefined(slot.type))
+                            continue;
+                        const set = returnFields.get(symbol) ?? new Set();
+                        if (set.has(field))
+                            continue;
+                        set.add(field);
+                        returnFields.set(symbol, set);
+                        provenance?.note("record-return", decl.name ?? decl, expression);
+                        changed = true;
+                    }
+                }
                 if (mayBeOptional(expression) && !optionalReturns.has(symbol)) {
                     optionalReturns.add(symbol);
                     provenance?.note("return", decl.name ?? decl, expression);
@@ -4749,6 +4923,72 @@ export class Lowerer {
                 this.runtimeOptionalGlobals.add(global);
             }
         }
+        // Record layouts settle per flow class: a closed class widens every
+        // member to the union of its members' optional fields, and a class that
+        // reaches other storage keeps the declared layout for every member.
+        const classFields = new Map();
+        const addClassFields = (id, fields) => {
+            if (id === null)
+                return;
+            const set = classFields.get(id) ?? new Set();
+            for (const field of fields)
+                set.add(field);
+            classFields.set(id, set);
+        };
+        for (const [symbol, fields] of optionalFields)
+            addClassFields(recordFlows.bindingClass(symbol), fields);
+        for (const [symbol, fields] of returnFields)
+            addClassFields(recordFlows.returnClass(symbol), fields);
+        const settledFields = (id, own) => id === null
+            ? own
+            : classFields.has(id) && recordFlows.closed(id)
+                ? classFields.get(id)
+                : undefined;
+        const widenRecordFields = (type, fields) => {
+            let promoted = type;
+            for (const field of fields) {
+                const source = promoted.kind === "record"
+                    ? this.shapes.get(promoted.shapeId)?.fields.find((f) => f.name === field)
+                    : undefined;
+                if (source)
+                    promoted = this.runtimeOptionalRecordField(promoted, field, addUndefined(source.type));
+            }
+            return promoted;
+        };
+        for (const [symbol, id] of recordFlows.bindings())
+            if (classFields.has(id) && !recordFlows.closed(id))
+                this.runtimeOptionalRecordsKeptDeclared.add(symbol);
+        // Every tracked parameter settles with its class, including one that
+        // only receives plain records. An untracked one (a function used as a
+        // value, a method another member name or view can reach) widens to the
+        // fields its own arguments carry.
+        for (const { symbol, fn, index } of recordFlows.parameters())
+            recordParameterSlots.set(symbol, { target: fn, index });
+        for (const [bound, { target, index }] of recordParameterSlots) {
+            const shape = signatureBySymbol.get(target)?.params[index];
+            if (!shape || shape.type.kind !== "record")
+                continue;
+            const fields = settledFields(recordFlows.bindingClass(bound), optionalFields.get(bound));
+            if (!fields)
+                continue;
+            const promoted = widenRecordFields(shape.type, fields);
+            if (typeEquals(promoted, shape.type))
+                continue;
+            shape.type = promoted;
+            this.runtimeOptionalBindingTypes.set(bound, promoted);
+        }
+        for (const [symbol, sig] of signatureBySymbol) {
+            const id = recordFlows.returnClass(symbol);
+            const fields = id === null ? undefined : settledFields(id, undefined);
+            if (fields && sig.returnType.kind === "record") {
+                const next = widenRecordFields(sig.returnType, fields);
+                sig.returnType = next;
+                if (sig.top)
+                    sig.top.returnType = next;
+                if (sig.method)
+                    sig.method.ret = next;
+            }
+        }
         for (const [symbol, sig] of signatureBySymbol) {
             const params = optionalParams.get(symbol);
             if (params) {
@@ -4832,7 +5072,7 @@ export class Lowerer {
                             global.type = promoted;
                     }
                 }
-                const fields = optionalFields.get(symbol);
+                const fields = settledFields(recordFlows.bindingClass(symbol), optionalFields.get(symbol));
                 if (!dynamicObjectEntryRows.has(symbol) && !optionalSymbols.has(symbol) && !fields)
                     return;
                 const current = this.mapTypeOf(this.typeOf(node.name));
@@ -4851,23 +5091,15 @@ export class Lowerer {
                         };
                     }
                 }
-                if (fields && promoted.kind === "record") {
-                    for (const field of fields) {
-                        const source = promoted.kind === "record"
-                            ? this.shapes.get(promoted.shapeId)?.fields.find((f) => f.name === field)
-                            : undefined;
-                        if (!source)
-                            continue;
-                        promoted = this.runtimeOptionalRecordField(promoted, field, addUndefined(source.type));
-                    }
-                }
+                if (fields && promoted.kind === "record")
+                    promoted = widenRecordFields(promoted, fields);
                 if (!typeEquals(promoted, current)) {
                     this.runtimeOptionalBindingTypes.set(symbol, promoted);
                     const global = ts.isIdentifier(node.name)
                         ? this.globalOf(node.name)
                         : this.globalsBySymbol.get(symbol);
                     if (global) {
-                        global.type = promoted;
+                        global.type = tdzStorage(global, promoted);
                         this.runtimeOptionalGlobals.add(global);
                     }
                 }
@@ -5362,7 +5594,7 @@ export class Lowerer {
         for (const info of this.classes.values()) {
             if (info.builtinError)
                 continue; // runtime-provided; nothing lowers
-            if (info.lifetimeRegion)
+            if (info.lifetimeRegion || info.internTable)
                 continue; // synthesized with the class
             // Generic-class INSTANTIATIONS (and mixin instantiations) are
             // demand-driven, not units: their members lower unconditionally in
@@ -5803,7 +6035,7 @@ export class Lowerer {
             : diag;
         const pending = this.pendingFlushes.get(diag);
         // Deferred collection: the wrapper decides whether these ever report
-        // (a reference flushes them; unreferenced declarations stay silent in
+        // (a reference flushes them; unreferenced declarations report nothing in
         // builds and report under coverage's unreached group).
         if (this.diagSink) {
             if (pending && d !== diag)
@@ -6017,7 +6249,7 @@ export class Lowerer {
         return stdlibMemberFence(this, access);
     }
     fenceStaticResponseMember(access, use) {
-        return fenceStaticResponseMember(this, access, use);
+        return fenceStaticResponseMember(this, access, use) ?? fenceStaticBlobMember(this, access, use);
     }
     fenceUnsupportedFetchConstructorMember(access) {
         return fenceUnsupportedFetchConstructorMember(this, access);
@@ -6774,6 +7006,21 @@ export class Lowerer {
                     return this.checkedNarrowCall(helper, expr, expected, expr.loc);
                 }
             }
+            // A record arm beside unit arms flowing into another layout of that
+            // record (`R | undefined` into the runtime-optional variant of R): the
+            // same checked extraction of the record arm, then the record's width
+            // lift into the destination layout.
+            if (expr.type.kind === "union" && expected.kind === "record") {
+                const arms = this.unions.get(expr.type.unionId)?.arms ?? [];
+                const records = arms.filter((arm) => !isUnitType(arm));
+                const arm = records.length === 1 && records[0].kind === "record" ? records[0] : null;
+                const lift = arm ? this.widthLiftPlan(arm, expected) : null;
+                const helper = arm && lift ? this.narrowedArmHelper(expr.type.unionId, arm, expr.loc) : null;
+                if (arm && lift && helper) {
+                    const narrowed = this.checkedNarrowCall(helper, expr, arm, expr.loc);
+                    return this.applyWidthLift(lift, narrowed, expected, expr.loc);
+                }
+            }
             if (!typeEquals(expr.type, expected)) {
                 const w = this.widthCoerce(expr, expected);
                 if (w)
@@ -7372,6 +7619,8 @@ export class Lowerer {
                     builtinOption("RequestInit") ||
                     builtinOption("ErrorOptions") ||
                     builtinOption("SpawnOptions") ||
+                    builtinOption("UrlObject") ||
+                    builtinOption("URLFormatOptions") ||
                     !this.mapTypeOf(this.typeOf(x))) {
                     return lowerDynObjectLiteral(this, x);
                 }
@@ -7674,6 +7923,18 @@ export class Lowerer {
     paramShape(param) {
         return paramShape(this, param);
     }
+    /** The pipeline stage source type bound to `node` (a parameter name or
+     * a reference to it), or null. */
+    stageSourceType(node) {
+        if (this.stageSourceTypes.size === 0)
+            return null;
+        while (ts.isParenthesizedExpression(node))
+            node = node.expression;
+        if (!ts.isIdentifier(node))
+            return null;
+        const symbol = this.checker.getSymbolAtLocation(node);
+        return (symbol && this.stageSourceTypes.get(symbol)) ?? null;
+    }
     checkDefaultParamBodyType(param, bodyType) {
         return checkDefaultParamBodyType(this, param, bodyType);
     }
@@ -8695,7 +8956,7 @@ export class Lowerer {
      * lowered — set by lowerLabeled around lowering the labeled construct,
      * consumed exactly once by the construct's own lowering (takeLabels).
      * A lowering that never consumes them signals lowerLabeled to fence:
-     * silently dropping a label would compile `break lbl` wrong. */
+     * dropping a label without a diagnostic would compile `break lbl` wrong. */
     pendingLabels = null;
     takeLabels() {
         const labels = this.pendingLabels;
@@ -8902,6 +9163,9 @@ export class Lowerer {
     lowerElementWrite(expr) {
         return lowerElementWrite(this, expr);
     }
+    lowerLiveWebValue(node) {
+        return lowerLiveWebValue(this, node);
+    }
     ensureString(e, node) {
         return ensureString(this, e, node);
     }
@@ -9044,6 +9308,7 @@ export class Lowerer {
         // promise-returning ambient global, and `import` is a keyword callee no
         // identifier path matches.
         return (lowerLifetimeRegionCall(this, expr) ??
+            lowerInternTableCall(this, expr) ??
             lowerFfiCall(this, expr) ??
             lowerFetchCall(this, expr) ??
             lowerStaticFetchCompanionCall(this, expr) ??
@@ -9053,6 +9318,8 @@ export class Lowerer {
             lowerStaticReadableStreamControllerCall(this, expr) ??
             lowerStaticReadableStreamReaderCall(this, expr) ??
             lowerStaticResponseCall(this, expr) ??
+            lowerStaticBlobCall(this, expr) ??
+            lowerKeyObjectCall(this, expr) ??
             lowerFetchElementMethodCall(this, expr) ??
             lowerDynamicImportCall(this, expr) ??
             lowerCall(this, expr));
@@ -9180,10 +9447,12 @@ export class Lowerer {
     }
     lowerNew(expr) {
         const builtin = lowerLifetimeRegionNew(this, expr) ??
+            lowerInternTableNew(this, expr) ??
             lowerAbortControllerNew(this, expr) ??
             lowerEventTargetNew(this, expr) ??
             lowerFetchWebNew(this, expr) ??
             lowerResponseNew(this, expr) ??
+            lowerBlobNew(this, expr) ??
             lowerStaticReadableStreamNew(this, expr) ??
             lowerConsoleNew(this, expr);
         return (builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr)));