@scriptc/compiler 0.4.2 → 0.4.3

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,6 @@
+import { isDeclBoundaryFile } from "../decl-projection.js";
 import { relieveHeapPressure } from "../../heap-pressure.js";
+import { moduleNamespaceObject } from "./module-namespace-elements.js";
 import { keyedHelperName } from "./stable-names.js";
 import { positionTag, StructuralPositions } from "./structural-positions.js";
 import { onlyForwarded, stripTypeWrappers } from "./typed-arguments.js";
@@ -39,6 +41,7 @@ import { valueStreamOf } from "./builtins/hash-stream.js";
 import { lowerNetAddressCall, lowerNetAddressNew } from "./builtins/net-address.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
 import { iteratorSlotAdapter } from "./iterator-adapters.js";
+import { iterableSlotValue } from "./iterable-values.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
 import { CoercionState } from "./coercions/state.js";
 import { widthLiftPlan, unitOnlyElem, recordWidthPlan, describeRecordWidthBlocker, objToRecordPlan, recordToClassPlan, } from "./coercions/structural-plans.js";
@@ -68,6 +71,7 @@ import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optio
 import {} from "./class-protocol-dispatch.js";
 import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
 import { guardClassAttributeWrites } from "./class-attributes.js";
+import { guardFrozenWrites, markSloppyRecordWrites } from "./frozen-records.js";
 import { applyHandleProperties } from "./handle-properties.js";
 import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
@@ -97,14 +101,14 @@ export { newFnCtx } from "./function-context.js";
  */
 import { dirname, relative, resolve } from "node:path";
 import { bindingSource } from "../binding-source.js";
-import { tsgoPath } from "../dts-paths.js";
+import { compilerOwnedFileName, tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
 import { isBundledShimForwarder } from "../package-shims.js";
 import { erasedTypeOnlyImport } from "../type-only-imports.js";
 import { literalValues } from "../literal-values.js";
 import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
-import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
+import { arrayOf, BOOL, canAdaptDynFuncTo, canBoxFuncIntoDyn, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCheckedJsSourceFile, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, erasedOverloadMemberType, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isOverloadedCallableMemberType, isUnitOnlyTsType, isWorkerHandleType, isFetchHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
@@ -127,7 +131,7 @@ import { completeArgs, wrappedUndefined, undefinedArgFor } from "./call-argument
 import { bodyReturnType, declaredReturnType } from "./function-returns.js";
 import { lowerCall, lowerPromiseMethodCall, lowerFilterNarrowCall } from "./lower-calls.js";
 import { lowerFfiCall, validateFfiImports } from "./native-ffi.js";
-import { isTopLevelFnSymbol, lowerNestedFunctionDecl, lowerLambda, lowerFunction, } from "./lower-functions.js";
+import { isTopLevelFnSymbol, lowerNestedFunctionDecl, lowerLambda, lowerFunction, blockedBodyDiagnostics, } from "./lower-functions.js";
 import { lowerArrayMethodCall } from "./containers/array-methods.js";
 import { fuseArrayPipelines } from "./containers/array-pipelines.js";
 import { lowerMapMethodCall, lowerMapForEachCall, lowerSetMethodCall, lowerSetForEachCall, } from "./containers/collection-methods.js";
@@ -152,7 +156,7 @@ import { lowerBuiltinExtraProperty } from "./builtins/properties.js";
 import { registerPromisifiedBuiltinDecl } from "./builtins/callable-aliases.js";
 import { lowerExecFileAsyncCall } from "./builtins/child-process-async.js";
 import { lowerStringDecoderMethodCall, lowerTextCodecCall } from "./builtins/text-codecs.js";
-import { lowerReadlineMethodCall } from "./builtins/readline.js";
+import { isOptionalReadlineCursorRead, lowerReadlineMethodCall } from "./builtins/readline.js";
 import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, lowerAsyncLocalStorageMethodCall, lowerTracingChannelMethodCall, lowerTracingChannelProperty, } from "./builtins/async-context.js";
 import { lowerDisposableStackNew } from "./builtins/disposable-stack.js";
 import { lowerErrorCodeProperty, lowerErrorFunctionCall } from "./builtins/errors.js";
@@ -165,7 +169,7 @@ import { dateJsonType, isDateJsonSource, lowerDateCall } from "./builtins/dates.
 import { fsConstantMemberRead, fsConstantsObject, 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, lowerLiveWebValue, 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, lowerStaticTransformStreamNew, 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";
@@ -173,7 +177,7 @@ import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js"
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerSystemErrorMapValue } from "./lower-system-errors.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr, } from "./lower-comptime.js";
-import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, } from "./lower-stmts.js";
+import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, holdsEvolvingArray, } from "./lower-stmts.js";
 import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, matchCallbackParamGroupsOf, } from "./lower-exprs.js";
 import { finishOptionalChain, isOptionalChainTail, lowerOptionalChain, } from "./expressions/optional-chains.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, } from "./expressions/object-literals.js";
@@ -629,6 +633,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     // travel with them: a failed statement is never left unexplained.
     const covered = {
         ...result,
+        diagnostics: [...result.diagnostics, ...remainder.reachedBlockedBodyDiagnostics],
         stats: { ...result.stats, statementsDynamic },
         unreached: {
             diagnostics: rem.diagnostics,
@@ -1156,6 +1161,9 @@ export class Lowerer {
     /** Identifiers by spelling, per file, for the generic bindings' use
      * ordering (runsAfterDeclaration). */
     bindingIdentifiers = new Map();
+    /** Per JavaScript file, the declarations of the bindings it assigns an
+     * own `toString` (jsAssignsOwnToString in lower-calls.ts). */
+    ownToStringTargets = new Map();
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
@@ -1414,6 +1422,9 @@ export class Lowerer {
      * and erased instances). */
     erasingDepth = 0;
     localClassInstantiations = [];
+    /** The function-local classes of the program with an `extends` clause, whether lowering collected
+     * them yet or not (new-target.ts); found on first use. */
+    functionLocalSubclasses = undefined;
     /** Instance types (by checker type id) of the local classes generic
      * factory calls return, and the per-instance class each names. */
     localClassInstanceTypes = new Map();
@@ -1631,6 +1642,47 @@ export class Lowerer {
         }
         return fallback ?? null;
     }
+    /** A fresh TypeScript data literal (`{ message: "m" }`) passed to a
+     * checked-dynamic parameter of a callee implemented in JavaScript, whose
+     * contract lets it reshape the object: a call through an untyped value, an
+     * untyped parameter of a JavaScript function, or a package-declared
+     * parameter type (a non-library `.d.ts`) that makes one of the literal's
+     * properties optional (zod's `normalizeParams` deletes `params.message`).
+     * No typed alias of a fresh literal exists, so it is built as the plain
+     * object the callee receives instead of a view whose record layout refuses
+     * that delete. Standard-library and TypeScript callees, and literals with
+     * methods or accessors, keep their native storage. */
+    reshapeableContextualLiteral(literal, contextual) {
+        const call = literal.parent;
+        if (call === undefined ||
+            !(ts.isCallExpression(call) || ts.isNewExpression(call)) ||
+            !call.arguments?.nodes.includes(literal) ||
+            literal.properties.nodes.length === 0 ||
+            !literal.properties.nodes.every((prop) => (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) &&
+                (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))))
+            return false;
+        const declaration = this.checker.getResolvedSignature(call)?.declaration;
+        const file = declaration ? ts.getSourceFileOfNode(declaration) : undefined;
+        const untyped = contextual.some((part) => part.flags & ts.TypeFlags.Any);
+        if (file === undefined)
+            return untyped;
+        if (isJsSourceFile(file))
+            return untyped;
+        if (!file.isDeclarationFile || this.isStdlibFile(file))
+            return false;
+        if (untyped)
+            return true;
+        const objects = contextual.filter((part) => part.flags & ts.TypeFlags.Object);
+        if (objects.length === 0)
+            return false;
+        return literal.properties.nodes.some((prop) => {
+            const name = prop.name.text;
+            return objects.every((part) => {
+                const symbol = this.checker.getPropertyOfType(part, name);
+                return symbol !== undefined && (symbol.flags & ts.SymbolFlags.Optional) !== 0;
+            });
+        });
+    }
     /** A TypeScript object literal handed to a JavaScript checked-value
      * parameter whose inferred type is open (`constructor({ factory, ...options
      * } = {})` — the rest element admits any property): the literal names a
@@ -2142,10 +2194,32 @@ 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();
+    /** Every site the census found for a name in prototypeMethodAccesses (which
+     * keeps one): reads of the method and writes that may replace it. The
+     * key-order witness asks which replacements can return records. */
+    methodAccessSites = new Map();
+    /** Marks `name` as a method the program may read or replace at `site`. */
+    noteMethodAccess(name, site) {
+        this.prototypeMethodAccesses.set(name, site);
+        this.noteMethodSite(name, site);
+    }
+    /** Records a site for `name` without changing its prototypeMethodAccesses entry. */
+    noteMethodSite(name, site) {
+        const sites = this.methodAccessSites.get(name);
+        if (sites === undefined)
+            this.methodAccessSites.set(name, [site]);
+        else
+            sites.push(site);
+    }
     /** Whether the program reads `Error.prototype`, the checked-dynamic
-     * object an ES5 constructor function can inherit from: only then can a
-     * value that is not an Error instance be `instanceof Error`. */
+     * object an ES5 constructor function can inherit from, or has a class
+     * whose heritage is evaluated at run time (`extends (Base ?? Error)`):
+     * only then can a value that is not an Error instance be
+     * `instanceof Error`. */
     errorPrototypeValues = false;
+    /** The property names the program assigns on the global object
+     * (property-access.ts), collected on first use. */
+    globalThisWrittenNames = null;
     /** Well-known symbol methods (`sym:iterator`) the program may replace
      * through a symbol-keyed write: an instance or prototype property, or a
      * reflection call. */
@@ -2333,6 +2407,12 @@ export class Lowerer {
     // Stack of function contexts (bottom = the function being declared at
     // top level, top = the innermost nested function currently lowering).
     fnStack = [];
+    /** Source ranges of record writes in sloppy-mode code, and of the
+     * absent-state writes of `delete r.f` (markSloppyRecordWrites). */
+    sloppyRecordWrites = new Set();
+    recordFieldDeletes = new Set();
+    /** typeKeys of the array types the program may freeze (IrModule.freezableArrays). */
+    freezableArrays = new Set();
     liftedFns = [];
     /** The first lifted function of each name (liftedFnNamed), for the
      * liftedFns indexed so far. liftedFns only grows. */
@@ -2345,15 +2425,21 @@ export class Lowerer {
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision = null;
     errorPropertyDispatchRevision = null;
+    /** The program defines properties by reflection on an untyped or
+     * Error-shaped target, so an own accessor may replace an error's `name`
+     * or `message`: typed reads and writes of those slots check for one.
+     * Holds the first such call's location. */
+    errorAccessorReflection = null;
     /** Structural source positions (structural-positions.ts) for names that
      * stay the same when unrelated code moves. */
     /** Files are named by their path relative to the entry's directory, so
-     * names do not depend on where the program sits, and default library
-     * files by their base name: two checkers install them in different
-     * directories. */
+     * names do not depend on where the program sits, default library files
+     * by their base name (two checkers install them in different
+     * directories), and the files scriptc ships by their name inside scriptc,
+     * so names do not depend on where scriptc is installed either. */
     positions = new StructuralPositions((sf) => this.program.isSourceFileDefaultLibrary(sf)
         ? `lib:${sf.fileName.slice(sf.fileName.lastIndexOf("/") + 1)}`
-        : relative(dirname(this.entry.fileName), sf.fileName));
+        : (compilerOwnedFileName(sf.fileName) ?? relative(dirname(this.entry.fileName), sf.fileName)));
     /** The outermost node whose token span is exactly `loc`, or null. */
     nodeAtLoc(loc) {
         const sf = this.program.getSourceFile(loc.file);
@@ -2381,7 +2467,9 @@ export class Lowerer {
      * before it. */
     closureName(loc, suffix = "", prefix = "%fn") {
         const node = this.nodeAtLoc(loc);
-        const where = node === null ? `${loc.file}:${loc.start}:${loc.end}` : this.positions.of(node);
+        const where = node === null
+            ? `${compilerOwnedFileName(loc.file) ?? loc.file}:${loc.start}:${loc.end}`
+            : this.positions.of(node);
         const key = `${prefix}|${this.closureRoot}|${where}|${suffix}`;
         const first = keyedHelperName(this, prefix, key);
         const seen = this.closureNameCounts.get(first) ?? 0;
@@ -2443,6 +2531,9 @@ export class Lowerer {
      * the class and constructed-class counts, it tells caches over the class
      * graph when the graph changed. */
     subclassLinks = 0;
+    /** Function-local classes by the class node they extend, built on first
+     * use (localSubclassesOf in lower-classes.ts). */
+    localSubclassIndex = null;
     /** Set while a subclass constructor's super() call notes its base
      * constructor edge: that edge does not instantiate the base exactly. */
     superConstructorEdge = false;
@@ -2508,7 +2599,20 @@ export class Lowerer {
         if (this.sharedHelpers.size === 0)
             return;
         const shared = new Map([...this.sharedHelpers].map((fn) => [fn.name, fn]));
-        const earlier = (left, right) => left.file < right.file || (left.file === right.file && left.start < right.start);
+        // Files scriptc ships compare by their name inside scriptc, so the
+        // choice does not depend on where scriptc is installed.
+        const fileKeys = new Map();
+        const fileKey = (file) => {
+            let key = fileKeys.get(file);
+            if (key === undefined)
+                fileKeys.set(file, (key = compilerOwnedFileName(file) ?? file));
+            return key;
+        };
+        const earlier = (left, right) => {
+            if (left.file === right.file)
+                return left.start < right.start;
+            return fileKey(left.file) < fileKey(right.file);
+        };
         // The earliest use of each shared helper outside the shared helpers, and
         // which shared helpers each shared helper uses.
         const uses = new Map();
@@ -2705,6 +2809,20 @@ export class Lowerer {
         else if (kind === "failed")
             s.failed += 1;
     }
+    /** The program holds the declaration-typed boundary's projection
+     * (decl-projection.ts): user-file record and array values crossing into
+     * dynamic slots (package parameters) box as live capsules, so a value
+     * that comes back through a boundary cast keeps its identity. */
+    declBoundaryMemo = null;
+    get declBoundary() {
+        this.declBoundaryMemo ??= this.program
+            .getSourceFiles()
+            .some((sf) => isDeclBoundaryFile(sf.fileName));
+        return this.declBoundaryMemo;
+    }
+    /** Tracked classes' bag initializers over a typed `this`
+     * (class-dynamic-dispatch.ts recordBagInitializers). */
+    classBagInitializers = new Map();
     constructor(program, entry, moduleOrder, mode = {}) {
         this.program = program;
         this.entry = entry;
@@ -2808,7 +2926,10 @@ export class Lowerer {
             classImplementedProtocol: (type) => this.classImplementedProtocol(type),
             isStdlibFile: this.isStdlibFile,
             isNpmFile: this.isNpmFile,
-            isExternalTypeFile: (sf) => this.externalTypeSpecifiersByFile.has(tsgoPath(resolve(sf.fileName))),
+            // The declaration-typed boundary's generated types (decl-projection.ts)
+            // describe data, like an explicitly mapped external type surface.
+            isExternalTypeFile: (sf) => this.externalTypeSpecifiersByFile.has(tsgoPath(resolve(sf.fileName))) ||
+                isDeclBoundaryFile(sf.fileName),
             typeMemo: this.typeMemo,
             ...(this.generalNodeStreams ? { generalNodeStreams: true } : {}),
             ...(this.dynNodeStreams ? { dynNodeStreams: true } : {}),
@@ -4551,6 +4672,8 @@ export class Lowerer {
                 return true;
             if (ts.isPropertyAccessExpression(e) && isOptionalProcessStreamProperty(this, e))
                 return true;
+            if (ts.isPropertyAccessExpression(e) && isOptionalReadlineCursorRead(this, e))
+                return true;
             if (isOptionalProcessVersionsRead(this, e))
                 return true;
             if (ts.isPropertyAccessExpression(e) && isSettledIteratorValueRead(this, e))
@@ -5732,7 +5855,10 @@ export class Lowerer {
                 }
                 if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
                     const callbackIndices = hofCallbackIndices(node.expression.name.text, node.arguments.nodes.length >= 2);
-                    const callback = node.arguments.nodes[0];
+                    // `xs.map(((x) => x))`: the parenthesized callback is the arrow.
+                    let callback = node.arguments.nodes[0];
+                    while (callback !== undefined && ts.isParenthesizedExpression(callback))
+                        callback = callback.expression;
                     if (callbackIndices !== null && callback !== undefined && !ts.isSpreadElement(callback)) {
                         const receiverNode = node.expression.expression;
                         const receiverTs = this.typeOf(receiverNode);
@@ -5783,12 +5909,26 @@ export class Lowerer {
                             presentSites.set(node, elementsPresent && !reduce);
                             if (elementsPresent && reduce && retypeInlineCallback(callback, callbackIndices))
                                 changed = true;
-                            if ((method === "reduce" || method === "reduceRight") &&
-                                ((!elementsPresent && node.arguments.nodes.length < 2) ||
-                                    callbackReturnsOptional(callback))) {
-                                if (promoteHofCallback(callback, [0, 1]))
+                            // The accumulator holds undefined when the callback can return
+                            // it, when an initial value can be missing, or when elements can
+                            // be absent and there is no initial value. It holds another
+                            // primitive when the callback's result can be one at run time
+                            // (`missing[0] ?? "fallback"`).
+                            const initial = node.arguments.nodes[1];
+                            const optional = (!elementsPresent && initial === undefined) ||
+                                (initial !== undefined && !ts.isSpreadElement(initial) && mayBeOptional(initial)) ||
+                                callbackReturnsOptional(callback);
+                            const arithmetic = reduce && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))
+                                ? lambdaArithmeticReturn(callback)
+                                : null;
+                            if (reduce && (optional || arithmetic !== null)) {
+                                if (optional && promoteHofCallback(callback, [0, 1]))
                                     changed = true;
-                                const result = this.runtimeOptionalType(this.irTypeOf(node));
+                                let result = this.irTypeOf(node);
+                                if (arithmetic !== null)
+                                    result = joinPrimitiveTypes([result, arithmetic]) ?? result;
+                                if (optional)
+                                    result = this.runtimeOptionalType(result);
                                 siteDependencies?.read(node);
                                 const previous = this.runtimeOptionalReduceTypes.get(node);
                                 if (!previous || !typeEquals(previous, result)) {
@@ -6563,8 +6703,11 @@ export class Lowerer {
                 const fn = this.lowerFunction(decl);
                 if (fn)
                     functions.push(fn);
-                else if (this.countsSkips())
+                else if (this.countsSkips()) {
                     this.countSkippedBody(decl);
+                    if (this.remainder)
+                        this.reportBlockedBody(decl);
+                }
             }
             for (const decl of fp.classDecls) {
                 const info = this.classes.get(this.classNamer(decl));
@@ -6688,6 +6831,7 @@ export class Lowerer {
         finalizePrivateBrands(this, functions);
         trackClassFieldCreation(this, functions);
         guardClassAttributeWrites(this, functions);
+        guardFrozenWrites(this, functions);
         applyHandleProperties(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
         // collection fenced — Symbol-keyed fields, an unsupported base): the
@@ -6790,9 +6934,13 @@ export class Lowerer {
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
                 ...(this.usesLifetimeRegions ? { lifetimeRegions: true } : {}),
+                ...(this.declBoundary ? { declBoundary: true } : {}),
                 ...(this.threadSlotKeys.size > 0
                     ? { threadSlotKeys: [...this.threadSlotKeys].sort() }
                     : {}),
+                ...(this.freezableArrays.size > 0
+                    ? { freezableArrays: [...this.freezableArrays].sort() }
+                    : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
@@ -6893,6 +7041,20 @@ export class Lowerer {
             this.bumpFileStat(file, "failed");
         }
     }
+    /** Coverage remainder: the body diagnostics of a function whose
+     * signature blocked (blockedBodyDiagnostics). A function reachable emit
+     * reached (its signature's diagnostics flushed there) reports them with
+     * the reached diagnostics; any other reports them as unreached. */
+    reachedBlockedBodyDiagnostics = [];
+    reportBlockedBody(decl) {
+        const diags = blockedBodyDiagnostics(this, decl);
+        const symbol = declSymbolOf(this, decl);
+        if (symbol && this.alreadyFlushed.has(symbol))
+            this.reachedBlockedBodyDiagnostics.push(...diags);
+        else
+            for (const d of diags)
+                this.pushDiag(d);
+    }
     /** Whether run() counts a signature-blocked declaration in
      * stats.functionsSkipped: whole-program passes and the coverage
      * remainder do; an externally-gated emit pass leaves the counting to the
@@ -8190,6 +8352,22 @@ export class Lowerer {
      * type-mapper.ts's chalk-shape mapping — call paths and func-slot coercions
      * share it. */
     hybridCallUnwrap(expr) {
+        // A callable CLASS instance: a class whose merged interface carries a
+        // call signature stores its call behavior in a `%call` field (the
+        // chalk package shim's builder). Calls read the field.
+        if (expr.type.kind === "object") {
+            const callType = this.classes.get(expr.type.className)?.fields.get("%call");
+            if (callType === undefined || callType.kind !== "func")
+                return expr;
+            return {
+                kind: "fieldGet",
+                obj: expr,
+                className: expr.type.className,
+                field: "%call",
+                type: callType,
+                loc: expr.loc,
+            };
+        }
         if (expr.type.kind !== "record")
             return expr;
         const shape = this.shapes.get(expr.type.shapeId);
@@ -8272,6 +8450,20 @@ export class Lowerer {
         }
         if (expr.type.kind === "void" && expected.kind !== "void" && this.neverValued.has(expr))
             return this.divergentValue(expr, expected);
+        // A builtin error constructor global stored in a slot of its class value
+        // type (`{ Parent: Error }`): the class value itself, which a checked
+        // cast of the dynamic constructor value could not produce.
+        if (expected.kind === "classval" &&
+            expr.kind === "libCall" &&
+            expr.fn === "dyn.globalConstructor" &&
+            expr.args[0]?.kind === "strLit" &&
+            `%${expr.args[0].value}` === expected.className) {
+            const info = this.classes.get(expected.className);
+            if (info?.builtinError && info.valueCtorParams !== undefined) {
+                this.defineClassValueConstruct(info);
+                return { kind: "classRef", className: info.def.name, type: expected, loc: expr.loc };
+            }
+        }
         // process.stdout/stderr into a general Writable slot (general-streams.ts).
         const stdioStream = stdioIntoGeneralStream(this, expr, expected);
         if (stdioStream)
@@ -8283,6 +8475,12 @@ export class Lowerer {
             if (adapted)
                 return adapted;
         }
+        // Iterable-typed slots: other iterators enter the generator arm.
+        if (expected.kind === "union" && !typeEquals(expr.type, expected)) {
+            const iterable = iterableSlotValue(this, expr, expected);
+            if (iterable)
+                return iterable;
+        }
         // an any-typed slot marshals implicitly (tsc allows the assignment;
         // the marshal is where its semantics live). OUT: an 'any' value
         // flowing into a typed slot compiles to a VALIDATED exit — like every
@@ -8363,6 +8561,11 @@ export class Lowerer {
             // constructor. `require("events")` is the EventEmitter class itself,
             // so its module binding is too (`ReleaseEmitter = EventEmitter` over
             // `const EventEmitter = require("events")`).
+            if (expr.type.kind === "moduleNs" && isJsSourceFileName(expr.loc.file)) {
+                const object = moduleNamespaceObject(this, expr);
+                if (object)
+                    return object;
+            }
             if (expr.type.kind === "moduleNs" &&
                 expr.type.moduleId === "builtin:events" &&
                 isJsSourceFileName(expr.loc.file)) {
@@ -8470,10 +8673,19 @@ export class Lowerer {
         // A HYBRID (function-with-properties) record flowing into a plain
         // func slot extracts its reserved %call field — the chalk shape's
         // "the value IS callable" half (type-mapper.ts's hybrid mapping).
-        if (expected.kind === "func" && expr.type.kind === "record") {
+        if (expected.kind === "func" && (expr.type.kind === "record" || expr.type.kind === "object")) {
             const un = this.hybridCallUnwrap(expr);
             if (un !== expr && typeEquals(un.type, expected))
                 return un;
+            // A callable class instance (the chalk shim's variadic builder) in a
+            // narrower function slot: its call closure crosses the checked
+            // function boundary, which adapts the arity.
+            if (un !== expr &&
+                expr.type.kind === "object" &&
+                un.type.kind === "func" &&
+                canBoxFuncIntoDyn(un.type, (id) => this.shapes.get(id), (id) => this.unions.get(id))) {
+                return this.coerceToExpected({ kind: "dynFrom", value: un, type: DYN, loc: un.loc }, expected);
+            }
         }
         // A zero-param function whose RETURN is a wider record array than the
         // slot's (`getRoutes: () => cachedRoutes` against `() => Narrow[]`):
@@ -9170,6 +9382,40 @@ export class Lowerer {
         }
         return this.coerceInto(node, value, expected);
     }
+    /** The right side of a write to a member of a typed view of the global
+     * object (`(globalThis as typeof globalThis & { k?: T }).k = value`, also
+     * through `??=` and `||=`) that is `value` itself or wraps only it in
+     * parentheses or `satisfies`; null when `value` is not in such a write. */
+    globalViewSlot(value) {
+        let operand = value;
+        while (operand.parent !== undefined &&
+            (ts.isParenthesizedExpression(operand.parent) || ts.isSatisfiesExpression(operand.parent)))
+            operand = operand.parent;
+        const write = operand.parent;
+        if (write === undefined ||
+            !ts.isBinaryExpression(write) ||
+            write.right !== operand ||
+            (write.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
+                write.operatorToken.kind !== ts.SyntaxKind.QuestionQuestionEqualsToken &&
+                write.operatorToken.kind !== ts.SyntaxKind.BarBarEqualsToken))
+            return null;
+        let target = write.left;
+        while (ts.isParenthesizedExpression(target))
+            target = target.expression;
+        if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target))
+            return null;
+        const receiver = this.typeOf(target.expression);
+        const isGlobal = (type) => {
+            const symbol = type.getSymbol();
+            return (symbol !== undefined &&
+                ts.symbolName(symbol) === "globalThis" &&
+                symbol.declarations.length === 0);
+        };
+        return isGlobal(receiver) ||
+            (receiver.isIntersectionType() && ts.constituentTypes(receiver).some(isGlobal))
+            ? operand
+            : null;
+    }
     /** Lower for a known destination, then apply ordinary value coercion.
      * Fresh arrays and records use the destination layout directly. */
     lowerExprExpecting(node, expected) {
@@ -9237,6 +9483,20 @@ export class Lowerer {
             // belong to the array the program keeps, rather than a typed snapshot.
             if (ts.isArrayLiteralExpression(x) &&
                 x.elements.nodes.every((element) => !ts.isSpreadElement(element) && !ts.isOmittedExpression(element))) {
+                // A checked slot that the program declares as a native array (a
+                // member of a typed view of the global object, `typeof globalThis &
+                // { cache?: number[] }`) is read back through that declaration. Build
+                // the native array and store it boxed: every typed read then extracts
+                // that same array (a dynamic literal would be copied on each read,
+                // losing writes such as push).
+                const slot = this.globalViewSlot(x);
+                const slotType = slot ? this.checker.getContextualType(slot) : undefined;
+                const declared = slotType && this.checker.getNonNullableType(slotType);
+                const native = declared && !(declared.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
+                    ? this.mapTypeOf(declared)
+                    : null;
+                if (native?.kind === "array")
+                    return this.coerceInto(node, this.lowerArrayLiteral(x, native), DYN);
                 return {
                     kind: "dynArrLit",
                     elems: x.elements.nodes.map((element) => this.lowerExprExpecting(element, DYN)),
@@ -9263,7 +9523,9 @@ export class Lowerer {
                     builtinOption("UrlObject") ||
                     builtinOption("URLFormatOptions") ||
                     !this.mapTypeOf(this.typeOf(x)) ||
-                    this.excessJsContextualProperty(x, parts)) {
+                    this.excessJsContextualProperty(x, parts) ||
+                    this.reshapeableContextualLiteral(x, parts) ||
+                    holdsEvolvingArray(this, x)) {
                     return lowerDynObjectLiteral(this, x);
                 }
             }
@@ -9442,8 +9704,27 @@ export class Lowerer {
         // must not force an intermediate record with incompatible field slots.
         if (this.returnsLiteralIntoDyn(node, expected))
             return this.lowerExprExpecting(node, expected);
+        if (this.returnsFreshCollection(node) && expected.kind !== "void")
+            return this.lowerExprExpecting(node, expected);
         return this.asyncReturnValueOf(node, this.lowerExpr(node), expected);
     }
+    /** An array literal or a `new Map(...)`, `new Set(...)` or `new
+     * Array(...)` of the builtins: a fresh collection, never a thenable, so
+     * an async return takes the declared result type as its construction
+     * layout the way a synchronous return does (`return []` in a function
+     * whose inferred result is `Promise<string[]>`). */
+    returnsFreshCollection(node) {
+        let e = node;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isArrayLiteralExpression(e))
+            return true;
+        return (ts.isNewExpression(e) &&
+            ts.isIdentifier(e.expression) &&
+            (this.isStdlibGlobal(e.expression, "Map") ||
+                this.isStdlibGlobal(e.expression, "Set") ||
+                this.isStdlibGlobal(e.expression, "Array")));
+    }
     /** A fresh JS object literal returned into a checked-native (dyn) result,
      * which lowers straight into that storage. */
     returnsLiteralIntoDyn(node, expected) {
@@ -9569,7 +9850,9 @@ export class Lowerer {
                 loc,
             };
         }
-        if (this.adoptsReturnedPromise() && !this.returnsLiteralIntoDyn(node, expected)) {
+        if (this.adoptsReturnedPromise() &&
+            !this.returnsLiteralIntoDyn(node, expected) &&
+            !this.returnsFreshCollection(node)) {
             // The async return lowers its operand untyped first (a promise
             // adopts before its payload converts); a maybe-promise union needs
             // the statement form, which branches between adoption and fulfillment.
@@ -9955,8 +10238,8 @@ export class Lowerer {
             throw e;
         }
     }
-    lowerClassExpression(expr) {
-        return lowerClassExpression(this, expr);
+    lowerClassExpression(expr, binding) {
+        return lowerClassExpression(this, expr, binding);
     }
     /* ── the class graph (single inheritance) ─────────────────────────── */
     findMethodOn(info, name) {
@@ -11055,7 +11338,7 @@ export class Lowerer {
         return lowerRecordKeyRead(this, expr, shapeId, shape, includeUndefined);
     }
     lowerElementWrite(expr) {
-        return lowerElementWrite(this, expr);
+        return markSloppyRecordWrites(this, lowerElementWrite(this, expr), expr);
     }
     lowerLiveWebValue(node) {
         return lowerLiveWebValue(this, node);
@@ -11354,7 +11637,7 @@ export class Lowerer {
             : null;
     }
     fieldSetStmt(target, value, loc, blame) {
-        return fieldSetStmt(this, target, value, loc, blame);
+        return markSloppyRecordWrites(this, fieldSetStmt(this, target, value, loc, blame), blame);
     }
     lowerFieldCompound(access, op, rhsNode, loc) {
         return lowerFieldCompound(this, access, op, rhsNode, loc);
@@ -11384,6 +11667,7 @@ export class Lowerer {
             lowerBlobNew(this, expr) ??
             lowerNetAddressNew(this, expr) ??
             lowerStaticReadableStreamNew(this, expr) ??
+            lowerStaticTransformStreamNew(this, expr) ??
             lowerConsoleNew(this, expr);
         return (builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr)));
     }