@scriptc/compiler 0.3.5 → 0.4.0

package/dist/frontend/lowering/lower-calls.js

@@ -1,4 +1,12 @@
+import { isForwardedTupleSpread, lowerForwardingApply } from "./typed-arguments.js";
+import { guardNullProto, nullProtoRecordShape } from "./null-prototype.js";
+import { lowerDynStreamMemberCall } from "./dyn-streams.js";
+import { lowerBuiltinClassCall } from "./builtins/builtin-class-dyn.js";
+import { refuseModuleMemberThis } from "./module-member-this.js";
 import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
+import { lowerHashStreamCall } from "./builtins/hash-stream.js";
+import { lowerWebAssemblyValueOf } from "./builtins/webassembly.js";
+import { lowerResponseStaticJson } from "./lower-stdlib.js";
 import { lowerArrayCallbackCall } from "./containers/array-callback-call.js";
 /** Dispatch source calls, builtin members and receiver-specific operations.
  * Signature collection, argument completion and function bodies have their
@@ -7,45 +15,56 @@ import { dynUndefinedExpr, nodeThrowExpr, countedFor, numLit, varRef } from "../
 import { lowerBuiltinCall } from "./builtin-calls.js";
 import { threadsImportOf } from "../threads-import.js";
 import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS, } from "./lower-timers.js";
+import { lowerMockTimersElementCall } from "./lower-test.js";
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
 import { isFsStreamMember, lowerFsStreamMethodCall } from "./builtins/fs-streams.js";
 import * as ts from "../ts7/adapter.js";
-import { isZlibStreamMember, lowerZlibStreamMethodCall } from "./builtins/compression.js";
+import { isZlibStreamMember, lowerPromisifiedZlibCall, lowerZlibStreamMethodCall, } from "./builtins/compression.js";
+import { inlineNamespaceRequireOf, lowerInlineRequireValue, lowerUncompiledRequireCall, lowerWithInlineRequireInit, } from "./cjs-inline-require.js";
+import { cjsExportCallIgnoresThis, cjsInFileExportGlobalOf } from "./cjs-exports-object.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
 import { lowerClassSymbolMethodCall } from "./symbol-methods.js";
+import { lowerReadlineDisposeCall } from "./builtins/readline.js";
 import { errorToStringCall } from "./error-methods.js";
 import { lowerClassPrototypeAssign, lowerClassPrototypeDescriptors } from "./class-prototypes.js";
-import { BYTES_ELEMENT_NAME, BIGINT_T, BOOL, CAUGHT, DYN, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, funcOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
+import { BYTES_ELEMENT_NAME, BIGINT_T, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, funcOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, RUNTIME_EMITTER_CLASS, } from "../../ir/ir.js";
 import { lowerProtocolMethodCall } from "./class-protocol-dispatch.js";
 import { isJsSourceFile, locOf, requireSpecOf } from "../program.js";
+import { lowerJsonRequireCall } from "./json-require.js";
 import { lowerAssertInstanceCall } from "./assert-instances.js";
-import { isGenericCallableMemberType, typeKey } from "../type-mapper.js";
+import { isGenericCallableMemberType, isOverloadedCallableMemberType, typeKey, } from "../type-mapper.js";
 import { dynFallbackType, jsFuncNameOf, newFnCtx, staticImportNamespaceType } from "./lowerer.js";
 import { NARROW_FIRST, STRING_INDEX_METHODS, STR_METHODS, UTIL_TYPES_KEYS, stdlibGlobalNameOf, } from "./surfaces.js";
 import { dynStringReceiver } from "./containers/dynamic-receivers.js";
 import { lowerArrayConstructor, lowerArrayFromCall, lowerArrayOfCall, } from "./containers/array-construction.js";
+import { lowerArrayFromAsyncCall } from "./containers/array-from-async.js";
 import { lowerDynArrayFilterCall, lowerDynArrayFlatMapCall } from "./containers/array-callbacks.js";
 import { lowerGroupByStaticCall } from "./containers/collection-grouping.js";
-import { lowerIteratorHelperCall } from "./containers/iterator-helpers.js";
+import { lowerGeneratorHelperCall, lowerHelperReturnCall, lowerIteratorFromCall, lowerIteratorHelperCall, } from "./containers/iterator-helpers.js";
 import { lowerObjectAssignIndexShape, lowerObjectConstructor, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, } from "./containers/indexed-objects.js";
 import { lowerTupleReadMethodCall } from "./containers/array-methods.js";
 import { tryFuseIndexRead } from "./array-values.js";
 import { lowerBytesStaticCall } from "./containers/bytes.js";
-import { lowerRegexMethodCall, lowerStringIndexCall, lowerStringMethodCall, lowerStringPaddingCall, lowerStringSplitCall, } from "./containers/string-and-regexp.js";
+import { lowerRegexMethodCall, lowerStringIndexCall, lowerStringMethodCall, lowerStringPaddingCall, lowerStringSplitCall, isDynPrimitiveKindMethod, lowerDynPrimitiveMethodCall, lowerExtraNumberMethodCall, } from "./containers/string-and-regexp.js";
 import { createRequireSpecOf } from "./builtins/module-bindings.js";
 import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, } from "./builtins/child-process-methods.js";
 import { lowerCreateRequireCall, lowerImportMetaResolveCall, lowerRequireResolveCall, } from "./builtins/module-resolution.js";
-import { lowerCipherMethodCall, lowerCryptoHashMethodCall } from "./builtins/crypto.js";
+import { isWebCryptoReceiver, lowerCipherMethodCall, lowerCryptoGetRandomValues, lowerCryptoHashMethodCall, lowerPromisifiedCryptoCall, } from "./builtins/crypto.js";
+import { lowerErrorIsErrorCall } from "./builtins/errors.js";
+import { lowerPromisifiedDnsCall } from "./lower-dgram.js";
+import { lowerDisposableStackUseCall } from "./builtins/disposable-stack.js";
 import { lowerDirentMethodCall, lowerFileHandleMethodCall, lowerDirMethodCall, lowerWatcherMethodCall, } from "./builtins/filesystem.js";
-import { fencePerfEntryKeyWalk, isPerfEntryType, lowerPerfHooksCall, perfEntryTag, } from "./builtins/performance.js";
-import { lowerProcStreamMethodCall } from "./builtins/process.js";
+import { fencePerfEntryKeyWalk, isPerfEntryType, lowerHistogramMethodCall, lowerPerfHooksCall, perfEntryTag, } from "./builtins/performance.js";
+import { lowerProcStreamMethodCall, lowerProcessBuiltinModuleNamespace, } from "./builtins/process.js";
 import { recordMayKeepSource, throughRecordSource } from "./record-sources.js";
 import { lowerReflectCall } from "./builtins/reflection.js";
-import { lowerAbsenceProbe, lowerOptionalNumber, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, } from "./lower-exprs.js";
+import { lowerAbsenceProbe, v8CalleeText, lowerOptionalNumber, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
+import { classToNumberConversion } from "./class-to-primitive.js";
 import { hasRuntimeStatics } from "./class-runtime-statics.js";
+import { structuralReadType } from "./class-unions.js";
 import { httpClientFnBindingOf, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall, } from "./lower-server.js";
 import { EMITTER_API_MEMBERS, exactClassOfReceiver, exactInstanceClassOf, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall, lowerStaticFieldRead, returnsOnlyThis, storedClassValueType, } from "./lower-classes.js";
 import { classCallbackCall, isClassCallback } from "./class-callbacks.js";
@@ -59,13 +78,17 @@ import { fenceNodeModuleMutationCall, lowerRequireCacheKeys } from "./lower-node
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, positionNumber, } from "./optional-arguments.js";
 import { fenceSymbolFieldCopy } from "./symbol-fields.js";
 import { lowerClassDataDescriptor, lowerClassDescriptorRead } from "./class-descriptors.js";
+import { lowerClassFieldDefine, lowerClassIntegrity } from "./class-attributes.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { lowerUrlFactory } from "./lower-url.js";
 import { nullishValueUnitOf } from "./binding-analysis.js";
 import { spreadNeedsRuntimeArity, completeFuncValueArgs, lowerSpreadArgsCall, completeArgs, } from "./call-arguments.js";
 import { isThisParameter } from "./call-signatures.js";
+import { lowerStringIteratorValue } from "./iterator-adapters.js";
 import { checkedArmExtraction } from "./coercions/unions.js";
+import { maybePromiseReturnStmt, promiseArmedUnionOf } from "./maybe-promise.js";
 import { requireObjLitGenericReceiver, objLitGenericFnNodeOf, objLitGenericFnInfoOf, genericCallInstance, } from "./generic-functions.js";
+import { codeGenerationCalleeOf, lowerCodeGenerationCall } from "./code-generation.js";
 const ZLIB_STREAM_METHODS = new Set(["flush", "params", "close", "reset"]);
 export function lowerCall(lowerer, expr) {
     const loc = locOf(expr);
@@ -74,10 +97,46 @@ export function lowerCall(lowerer, expr) {
     if (ts.isIdentifier(expr.expression) &&
         expr.expression.text === "Object" &&
         lowerer.isStdlibGlobal(expr.expression, "Object")) {
-        const object = lowerObjectConstructor(lowerer, expr.arguments, loc);
+        const object = lowerObjectConstructor(lowerer, expr.arguments.nodes, loc);
         if (object)
             return object;
     }
+    // `EventEmitter.call(this)` in a constructor function: the untyped
+    // EventEmitter constructor initializes the receiver.
+    const builtinClassCall = lowerBuiltinClassCall(lowerer, expr);
+    if (builtinClassCall)
+        return builtinClassCall;
+    // require() of a JSON document: the shared parsed object.
+    const json = lowerJsonRequireCall(lowerer, expr);
+    if (json)
+        return json;
+    // eval(...) and Function(...): Node's EvalError under
+    // --disallow-code-generation-from-strings (code-generation.ts).
+    {
+        const codeGeneration = codeGenerationCalleeOf(lowerer, expr.expression);
+        if (codeGeneration !== null)
+            return lowerCodeGenerationCall(lowerer, expr, codeGeneration);
+    }
+    // Inline require() of a program module (cjs-inline-require.ts): a
+    // member call over its export table resolves like a binding's member
+    // call after the module's %init at this position; the require itself
+    // as a value answers the module's whole-export value.
+    if (ts.isPropertyAccessExpression(expr.expression) && !expr.expression.questionDotToken) {
+        const req = inlineNamespaceRequireOf(lowerer, expr.expression.expression);
+        if (req !== null && !lowerer.inlineRequireInitDone.has(req.call)) {
+            // Node calls the member with `this` bound to the module's exports.
+            if (ts.isIdentifier(expr.expression.name) &&
+                !cjsExportCallIgnoresThis(lowerer, req.dep, expr.expression.name.text)) {
+                lowerer.unsupported("SC1090", expr, `calling '${expr.expression.name.text}' through require(${JSON.stringify(req.spec)}) when the function may read 'this' (Node binds it to the module's exports object, which compiles to a static table — bind the module and call a local function instead)`);
+            }
+            return lowerWithInlineRequireInit(lowerer, req, () => lowerCall(lowerer, expr));
+        }
+    }
+    {
+        const inlineValue = lowerInlineRequireValue(lowerer, expr);
+        if (inlineValue)
+            return inlineValue;
+    }
     // A call whose chain ROOTS at an ambient-undefined name (`declare
     // const value: Y | undefined; value?.foo("a")`, `declare function
     // chain...; chain(o).mapValues(f).value()`, a trap binding's read):
@@ -138,10 +197,21 @@ export function lowerCall(lowerer, expr) {
         if (resolved)
             return resolved;
     }
+    // Any other require() call of the CommonJS global: MODULE_NOT_FOUND for
+    // packages nothing installed resolves, a named refusal otherwise.
+    {
+        const uncompiled = lowerUncompiledRequireCall(lowerer, expr);
+        if (uncompiled)
+            return uncompiled;
+    }
     // `process.getuid?.()` — intercepted BEFORE the optional-chain
     // machinery (the member always exists on a POSIX target, so the
     // optional call IS the call; `process.getuid` itself has no value
     // lowering for the chain to guard).
+    // `h.return!()` / `h.return?.()` on a helper object: the method exists.
+    const helperReturn = lowerHelperReturnCall(lowerer, expr);
+    if (helperReturn)
+        return helperReturn;
     const processOptional = lowerer.lowerProcessOptionalMethodCall(expr);
     if (processOptional)
         return processOptional;
@@ -186,6 +256,15 @@ export function lowerCall(lowerer, expr) {
         }
         return { kind: "libCall", fn: "http2.streamNoop", args: [], type: VOID, loc };
     }
+    // `process.getBuiltinModule("node:os")` typed as the module namespace,
+    // including pi's cast-and-probe spelling
+    // `(process as P).getBuiltinModule?.("node:os")` (the member always
+    // exists on Node 24's process object).
+    {
+        const namespace = lowerProcessBuiltinModuleNamespace(lowerer, expr);
+        if (namespace)
+            return namespace;
+    }
     // Optional-chain call forms: `f?.()` (the token on the call) and
     // `a?.m()` (the token on the member access). The handled markers keep
     // the chain lowering's re-entrant dispatch from looping.
@@ -278,7 +357,7 @@ export function lowerCall(lowerer, expr) {
     if (ts.isIdentifier(expr.expression) &&
         expr.expression.text === "queueMicrotask" &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-        if (expr.arguments.length === 0) {
+        if (expr.arguments.nodes.length === 0) {
             // Node: queueMicrotask() throws ERR_INVALID_ARG_TYPE at runtime
             // (the undefined callback) — the Dyn form delivers exactly that.
             return {
@@ -289,7 +368,7 @@ export function lowerCall(lowerer, expr) {
                 loc,
             };
         }
-        const raw = expr.arguments[0];
+        const raw = expr.arguments.nodes[0];
         const cb = lowerer.lowerExpr(raw);
         if (cb.type.kind === "dyn") {
             return { kind: "libCall", fn: "timers.queueMicrotaskDyn", args: [cb], type: VOID, loc };
@@ -322,11 +401,11 @@ export function lowerCall(lowerer, expr) {
     if (ts.isIdentifier(expr.expression) &&
         expr.expression.text === "structuredClone" &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-        if (expr.arguments.length === 0) {
+        if (expr.arguments.nodes.length === 0) {
             return { kind: "libCall", fn: "dyn.cloneMissing", args: [], type: DYN, loc };
         }
-        if (expr.arguments.length > 2) {
-            lowerer.noLowering(`structuredClone with ${expr.arguments.length} arguments`, expr);
+        if (expr.arguments.nodes.length > 2) {
+            lowerer.noLowering(`structuredClone with ${expr.arguments.nodes.length} arguments`, expr);
         }
         const toDynArg = (a) => {
             if (!a)
@@ -338,26 +417,26 @@ export function lowerCall(lowerer, expr) {
             }
             return conv;
         };
-        const valueNode = expr.arguments[0];
+        const valueNode = expr.arguments.nodes[0];
         // A NON-EMPTY transfer array of static values: nothing static is
         // transferable, so the call is Node's DataCloneError — decided here
         // (the list's values need no dyn representation to fail). An EMPTY
         // literal transfer list is a no-op member and drops.
         {
-            let optNode = expr.arguments[1];
+            let optNode = expr.arguments.nodes[1];
             while (optNode && ts.isParenthesizedExpression(optNode))
                 optNode = optNode.expression;
             if (optNode && ts.isObjectLiteralExpression(optNode)) {
-                const tr = optNode.properties.find((p) => ts.isPropertyAssignment(p) &&
+                const tr = optNode.properties.nodes.find((p) => ts.isPropertyAssignment(p) &&
                     p.name !== undefined &&
                     (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
                     p.name.text === "transfer");
                 if (tr &&
                     ts.isArrayLiteralExpression(tr.initializer) &&
-                    tr.initializer.elements.length > 0) {
+                    tr.initializer.elements.nodes.length > 0) {
                     // An ArrayBuffer first member may be a Buffer pool slab, which
                     // Node reports as untransferable.
-                    const first = tr.initializer.elements[0];
+                    const first = tr.initializer.elements.nodes[0];
                     const firstType = ts.isSpreadElement(first) ? undefined : lowerer.typeOf(first);
                     const parts = !firstType
                         ? []
@@ -366,7 +445,7 @@ export function lowerCall(lowerer, expr) {
                             : [firstType];
                     const isStorage = parts.length > 0 &&
                         parts.every((part) => {
-                            const name = part.getSymbol()?.name;
+                            const name = ts.symbolNameOf(part.getSymbol());
                             return name === "ArrayBuffer" || name === "SharedArrayBuffer";
                         });
                     if (isStorage) {
@@ -382,7 +461,7 @@ export function lowerCall(lowerer, expr) {
                 }
             }
         }
-        const optsArg = toDynArg(expr.arguments[1]);
+        const optsArg = toDynArg(expr.arguments.nodes[1]);
         // A DOMException value clones through its own runtime arm — the
         // typed result keeps the class (instanceof, .code, throwability).
         const valueT = lowerer.mapTypeOf(lowerer.typeOf(valueNode));
@@ -406,11 +485,20 @@ export function lowerCall(lowerer, expr) {
         };
         // The declared result is the value's own type (the generic's T):
         // validate the dyn copy back into it when the type can be checked;
-        // dyn-typed and unmappable results stay dyn values (JS files).
+        // dyn-typed and unmappable results stay dyn values (JS files). An
+        // empty record (`{}` inferred from a JavaScript `payload = {}`
+        // default) is the checker's supertype of whatever arrives, not a
+        // layout: checking into it would drop every member of the copy.
         const resultT = lowerer.mapTypeOf(lowerer.typeOf(expr));
+        const resultShape = resultT?.kind === "record" ? lowerer.shapes.get(resultT.shapeId) : undefined;
+        const emptyRecord = resultShape !== undefined &&
+            !resultShape.tuple &&
+            resultShape.indexValue === undefined &&
+            resultShape.fields.length === 0;
         if (resultT !== null &&
             resultT.kind !== "dyn" &&
             resultT.kind !== "void" &&
+            !emptyRecord &&
             canDynCheckTo(resultT, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
             return { kind: "dynCheck", value: cloned, type: resultT, loc };
         }
@@ -435,10 +523,10 @@ export function lowerCall(lowerer, expr) {
     // constants ("", false, 0). Wrapper objects stay fenced except where
     // the receiver is immediately converted by a direct String method call.
     if (lowerer.isStdlibGlobal(expr.expression, "BigInt")) {
-        if (expr.arguments.length !== 1) {
-            lowerer.noLowering(`BigInt with ${expr.arguments.length} arguments`, expr);
+        if (expr.arguments.nodes.length !== 1) {
+            lowerer.noLowering(`BigInt with ${expr.arguments.nodes.length} arguments`, expr);
         }
-        const argNode = expr.arguments[0];
+        const argNode = expr.arguments.nodes[0];
         // Captured optional storage can change after TypeScript's guard.
         // BigInt consumes the stored value, including its nullish tag.
         const arg = optionalCallValue(lowerer, argNode) ?? lowerer.lowerExpr(argNode);
@@ -455,10 +543,10 @@ export function lowerCall(lowerer, expr) {
             : lowerer.isStdlibGlobal(expr.expression, "Boolean")
                 ? "Boolean"
                 : "Number";
-        if (expr.arguments.length > 1) {
-            lowerer.noLowering(`${name} with ${expr.arguments.length} arguments`, expr);
+        if (expr.arguments.nodes.length > 1) {
+            lowerer.noLowering(`${name} with ${expr.arguments.nodes.length} arguments`, expr);
         }
-        const argNode = expr.arguments[0];
+        const argNode = expr.arguments.nodes[0];
         if (!argNode) {
             if (name === "String")
                 return { kind: "strLit", value: "", type: STRING, loc };
@@ -513,7 +601,7 @@ export function lowerCall(lowerer, expr) {
             (source.type.kind === "dyn" ||
                 source.type.kind === "func" ||
                 (source.type.kind === "union" &&
-                    isJsSourceFile(expr.getSourceFile()) &&
+                    isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
                     lowerer.dynConvertible(source.type)) ||
                 ((source.type.kind === "map" || source.type.kind === "set") &&
                     lowerer.dynConvertible(source.type)) ||
@@ -524,8 +612,8 @@ export function lowerCall(lowerer, expr) {
             const receiver = varRef(local.id, DYN, loc);
             const key = lowerer.lowerExprExpecting(access.argumentExpression, DYN);
             const callee = { kind: "dynKeyGet", value: receiver, key, type: DYN, loc };
-            const args = expr.arguments.map((arg) => lowerer.lowerExprExpecting(ts.isSpreadElement(arg) ? arg.expression : arg, DYN));
-            const spreads = expr.arguments.flatMap((arg, index) => ts.isSpreadElement(arg) ? [{ arg: index, what: arg.expression.getText() }] : []);
+            const args = expr.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(ts.isSpreadElement(arg) ? arg.expression : arg, DYN));
+            const spreads = expr.arguments.nodes.flatMap((arg, index) => ts.isSpreadElement(arg) ? [{ arg: index, what: ts.getTextOfNode(arg.expression) }] : []);
             return {
                 kind: "seqExpr",
                 stmts: [
@@ -535,7 +623,7 @@ export function lowerCall(lowerer, expr) {
                     kind: "dynCall",
                     callee,
                     receiver,
-                    calleeName: access.getText(),
+                    calleeName: ts.getTextOfNode(access),
                     args,
                     ...(spreads.length > 0 ? { spreads } : {}),
                     type: DYN,
@@ -556,7 +644,7 @@ export function lowerCall(lowerer, expr) {
     // all (fs.watch, os.cpus, ...) fence with the module-qualified name.
     if (ts.isIdentifier(expr.expression)) {
         if (expr.expression.text === "Array" && lowerer.isStdlibGlobal(expr.expression, "Array")) {
-            return lowerArrayConstructor(lowerer, expr, expr.arguments);
+            return lowerArrayConstructor(lowerer, expr, expr.arguments.nodes);
         }
         // A call through a compile-time util.promisify projection. execFile
         // keeps its custom result helper; ordinary builtins route through
@@ -570,6 +658,15 @@ export function lowerCall(lowerer, expr) {
             if (projection?.kind === "promisified-exec") {
                 return lowerer.lowerExecFileAsyncCall(expr, loc, true);
             }
+            if (projection?.kind === "promisified-zlib") {
+                return lowerPromisifiedZlibCall(lowerer, expr, projection.member, loc);
+            }
+            if (projection?.kind === "promisified-crypto") {
+                return lowerPromisifiedCryptoCall(lowerer, expr, projection.member, loc);
+            }
+            if (projection?.kind === "promisified-dns") {
+                return lowerPromisifiedDnsCall(lowerer, expr, projection.member, loc);
+            }
             if (projection?.kind === "promisified-builtin") {
                 return lowerBuiltinCall(lowerer, expr, { module: projection.module, member: projection.member }, loc);
             }
@@ -586,9 +683,9 @@ export function lowerCall(lowerer, expr) {
         if (threadsImportOf(lowerer.program, expr.expression) === "publish") {
             // @scriptc/threads publish(value): the same value, its graph made
             // immortal and immutable (backend/llvm/publish.ts).
-            if (expr.arguments.length !== 1 || ts.isSpreadElement(expr.arguments[0]))
-                lowerer.noLowering(`publish with ${expr.arguments.length} arguments`, expr);
-            const value = lowerer.lowerExpr(expr.arguments[0]);
+            if (expr.arguments.nodes.length !== 1 || ts.isSpreadElement(expr.arguments.nodes[0]))
+                lowerer.noLowering(`publish with ${expr.arguments.nodes.length} arguments`, expr);
+            const value = lowerer.lowerExpr(expr.arguments.nodes[0]);
             return { kind: "intrinsic", name: "threads.publish", args: [value], type: value.type, loc };
         }
         const bi = lowerer.builtinImportOf(expr.expression);
@@ -620,10 +717,10 @@ export function lowerCall(lowerer, expr) {
         // generic new fence keeps it.
         if (expr.expression.text === "Symbol" &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-            if (expr.arguments.length > 1) {
-                lowerer.noLowering(`Symbol with ${expr.arguments.length} arguments`, expr);
+            if (expr.arguments.nodes.length > 1) {
+                lowerer.noLowering(`Symbol with ${expr.arguments.nodes.length} arguments`, expr);
             }
-            const argNode = expr.arguments[0];
+            const argNode = expr.arguments.nodes[0];
             // A literal `undefined` argument IS the no-description form
             // (Symbol(undefined).description is undefined, like Symbol()).
             if (!argNode || (ts.isIdentifier(argNode) && argNode.text === "undefined")) {
@@ -650,7 +747,7 @@ export function lowerCall(lowerer, expr) {
             expr.expression.text === "parseFloat" ||
             expr.expression.text === "isFinite") &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-            const parsed = lowerStaticNumberGlobal(lowerer, expr.expression.text, expr, expr.arguments, loc);
+            const parsed = lowerStaticNumberGlobal(lowerer, expr.expression.text, expr, expr.arguments.nodes, loc);
             if (parsed !== null)
                 return parsed;
         }
@@ -670,11 +767,11 @@ export function lowerCall(lowerer, expr) {
             expr.expression.text === "decodeURIComponent") &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
             const name = expr.expression.text;
-            if (expr.arguments.length !== 1) {
-                lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
+            if (expr.arguments.nodes.length !== 1) {
+                lowerer.noLowering(`${name} with ${expr.arguments.nodes.length} argument${expr.arguments.nodes.length === 1 ? "" : "s"}`, expr);
             }
             const loc = locOf(expr);
-            const argNode = expr.arguments[0];
+            const argNode = expr.arguments.nodes[0];
             if (name === "decodeURIComponent" || name === "decodeURI") {
                 const d = optionalCallValue(lowerer, argNode) ?? lowerer.lowerExpr(argNode);
                 const s = lowerer.ensureString(d, argNode);
@@ -707,13 +804,13 @@ export function lowerCall(lowerer, expr) {
         if ((expr.expression.text === "atob" || expr.expression.text === "btoa") &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
             const name = expr.expression.text;
-            if (expr.arguments.length === 0) {
+            if (expr.arguments.nodes.length === 0) {
                 return { kind: "libCall", fn: "str.b64Missing", args: [], type: STRING, loc };
             }
-            if (expr.arguments.length > 1) {
-                lowerer.noLowering(`${name} with ${expr.arguments.length} arguments`, expr);
+            if (expr.arguments.nodes.length > 1) {
+                lowerer.noLowering(`${name} with ${expr.arguments.nodes.length} arguments`, expr);
             }
-            const argNode = expr.arguments[0];
+            const argNode = expr.arguments.nodes[0];
             const v = lowerer.lowerExpr(argNode);
             let data;
             if (v.type.kind === "dyn") {
@@ -737,17 +834,17 @@ export function lowerCall(lowerer, expr) {
         // result exits to the declared static type. A user function
         // shadowing the name has a different, non-stdlib symbol.
         const islFn = lowerer.stdlibGlobalFnOf(expr.expression);
-        if (islFn && expr.arguments.length !== islFn.args.length) {
+        if (islFn && expr.arguments.nodes.length !== islFn.args.length) {
             const name = expr.expression.text;
-            lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
+            lowerer.noLowering(`${name} with ${expr.arguments.nodes.length} argument${expr.arguments.nodes.length === 1 ? "" : "s"}`, expr);
         }
-        if (islFn && expr.arguments.length === islFn.args.length) {
+        if (islFn && expr.arguments.nodes.length === islFn.args.length) {
             // The static forms above already took the exactly-typed argument
             // (a string for parseFloat, a number for isFinite): name the
             // argument type that refused the call, so the message states the
             // condition rather than reading as if the global itself were
             // unsupported.
-            const argText = loweredArgumentText(lowerer, expr.arguments[0]);
+            const argText = loweredArgumentText(lowerer, expr.arguments.nodes[0]);
             const exact = expr.expression.text === "isFinite" ? "number" : "string";
             lowerer.refuseUnsupportedApi(`'${expr.expression.text}' with a '${argText}' argument`, expr, exact === "string"
                 ? "only a string argument compiles statically: convert the argument explicitly first (for example String(x), or narrow the union)"
@@ -762,8 +859,8 @@ export function lowerCall(lowerer, expr) {
     // typeof tests) applies inside it, tsc's call-site narrowing types
     // the guarded branch, and a body construct with no caught lowering
     // fences per site at its own location.
-    if (ts.isIdentifier(expr.expression) && expr.arguments.length === 1) {
-        const caughtArg = lowerer.caughtLocalOf(expr.arguments[0]);
+    if (ts.isIdentifier(expr.expression) && expr.arguments.nodes.length === 1) {
+        const caughtArg = lowerer.caughtLocalOf(expr.arguments.nodes[0]);
         if (caughtArg) {
             const inlined = lowerCaughtPredicateCall(lowerer, expr, caughtArg);
             if (inlined)
@@ -791,7 +888,8 @@ export function lowerCall(lowerer, expr) {
         // VALUE path — the runtime-arity lane (lowerSpreadArgsCall) boxes
         // the declaration's value and applies through a runtime-built
         // argument list. Typed .ts spreads keep completeArgs' rest packing.
-        const jsSpreadArgs = expr.arguments.some((a) => ts.isSpreadElement(a)) && isJsSourceFile(expr.getSourceFile());
+        const jsSpreadArgs = expr.arguments.nodes.some((a) => ts.isSpreadElement(a)) &&
+            isJsSourceFile(ts.getSourceFileOfNode(expr));
         if (lowerer.isTopLevelFnSymbol(expr.expression) && !lowerer.peekLocal(expr.expression)) {
             // `import g = N.f; g()` — the alias's own source-order guards
             // (a no-op for every non-import= binding).
@@ -803,17 +901,18 @@ export function lowerCall(lowerer, expr) {
             if (generic && !(jsSpreadArgs && generic.implicitParams))
                 return lowerer.lowerGenericCall(expr, generic);
             const sig = generic ? null : lowerer.fnSigOf(expr.expression);
-            if (sig && !(jsSpreadArgs && spreadNeedsRuntimeArity(lowerer, sig.params, expr.arguments))) {
+            if (sig &&
+                !(jsSpreadArgs && spreadNeedsRuntimeArity(lowerer, sig.params, expr.arguments.nodes))) {
                 lowerer.noteEdge(sig.name);
-                const args = lowerer.completeArgs(expr.arguments, sig.params, loc, expr);
+                const args = lowerer.completeArgs(expr.arguments.nodes, sig.params, loc, expr);
                 const symbol = lowerer.resolveValueSymbol(expr.expression);
-                const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+                const declaration = symbol ? symbol.valueDeclaration : undefined;
                 // A bare call supplies undefined as this, even inside a callback
                 // currently carrying a receiver. The value-call ABI saves and
                 // restores that ambient receiver around the function invocation.
                 if (declaration &&
                     ts.isFunctionDeclaration(declaration) &&
-                    declaration.parameters.some(isThisParameter)) {
+                    declaration.parameters.nodes.some(isThisParameter)) {
                     const callee = lowerer.lowerExpr(expr.expression);
                     return reconcileOverloadReturn(lowerer, expr, {
                         kind: "callValue",
@@ -897,13 +996,14 @@ export function lowerCall(lowerer, expr) {
             const memberSym = lowerer.checker.getSymbolAtLocation(nsMember);
             if (memberSym)
                 fenceEarlyNsMemberRef(lowerer, expr.expression, memberSym);
+            refuseModuleMemberThis(lowerer, expr, nsMember);
             const generic = lowerer.genericFnOf(nsMember);
             if (generic)
                 return lowerer.lowerGenericCall(expr, generic);
             const sig = lowerer.fnSigOf(nsMember);
             if (sig) {
                 lowerer.noteEdge(sig.name);
-                const args = lowerer.completeArgs(expr.arguments, sig.params, loc, expr);
+                const args = lowerer.completeArgs(expr.arguments.nodes, sig.params, loc, expr);
                 return reconcileOverloadReturn(lowerer, expr, {
                     kind: "call",
                     callee: sig.name,
@@ -961,13 +1061,14 @@ export function lowerCall(lowerer, expr) {
         if (!ts.isIdentifier(nameId)) {
             lowerer.unsupported("SC1090", nameId, "private-named module members");
         }
+        refuseModuleMemberThis(lowerer, expr, nameId);
         const generic = lowerer.genericFnOf(nameId);
         if (generic)
             return lowerer.lowerGenericCall(expr, generic);
         const sig = lowerer.fnSigOf(nameId);
         if (sig) {
             lowerer.noteEdge(sig.name);
-            const args = lowerer.completeArgs(expr.arguments, sig.params, loc, expr);
+            const args = lowerer.completeArgs(expr.arguments.nodes, sig.params, loc, expr);
             return reconcileOverloadReturn(lowerer, expr, {
                 kind: "call",
                 callee: sig.name,
@@ -987,8 +1088,35 @@ export function lowerCall(lowerer, expr) {
         const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
         return { kind: "callValue", callee, args, type: callee.type.ret, loc };
     }
+    // `exports.f(x)` / `module.exports.f(x)` inside the module: a call of
+    // the member's export global (cjs-exports-object.ts), the value every
+    // `exports.f =` statement assigns.
+    if (ts.isPropertyAccessExpression(expr.expression) && !expr.questionDotToken) {
+        const g = cjsInFileExportGlobalOf(lowerer, expr.expression);
+        if (g &&
+            (g.type.kind === "func" || g.type.kind === "dyn") &&
+            !cjsExportCallIgnoresThis(lowerer, ts.getSourceFileOfNode(expr), expr.expression.name.text)) {
+            lowerer.unsupported("SC1090", expr, `calling '${ts.getTextOfNode(expr.expression)}' through the module's exports object when the function may read 'this' (Node binds it to the exports object, which compiles to a static table — call a local function instead)`);
+        }
+        if (g && (g.type.kind === "func" || g.type.kind === "dyn")) {
+            const callee = { kind: "varRef", localId: g.id, type: g.type, loc };
+            const checked = lowerCheckedCallableValue(lowerer, expr, callee, loc);
+            if (checked)
+                return checked;
+            if (callee.type.kind === "func") {
+                const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
+                return { kind: "callValue", callee, args, type: callee.type.ret, loc };
+            }
+        }
+    }
     if (ts.isPropertyAccessExpression(expr.expression)) {
-        const intrinsic = fenceNodeModuleMutationCall(lowerer, expr, expr.expression) ??
+        const intrinsic = 
+        // Checked-dynamic stream slots dispatch per value (dyn-streams.ts).
+        lowerDynStreamMemberCall(lowerer, expr, expr.expression) ??
+            fenceNodeModuleMutationCall(lowerer, expr, expr.expression) ??
+            // `f.apply(thisArg, args)` forwarding a fixed argument tuple (typed
+            // `arguments`, a tuple rest parameter): a direct call.
+            lowerForwardingApply(lowerer, expr, expr.expression) ??
             // Builtin namespace imports first (`fs.readFileSync(...)` where fs
             // is `import * as fs from "node:fs"`): the same tables and fences
             // as named builtin imports — before anything below tries to lower
@@ -1000,6 +1128,7 @@ export function lowerCall(lowerer, expr) {
             // .bind(performance) function value over the runtime's
             // process-start-anchored monotonic clock.
             lowerPerfHooksCall(lowerer, expr, expr.expression) ??
+            lowerHistogramMethodCall(lowerer, expr, expr.expression) ??
             // The composed crypto pattern (randomBytes(n).toString(enc))
             // — its receiver is a Buffer-typed CALL no other lowering claims.
             lowerer.lowerCryptoComposedCall(expr, expr.expression) ??
@@ -1026,6 +1155,7 @@ export function lowerCall(lowerer, expr) {
             lowerer.lowerUrlMethodCall(expr, expr.expression) ??
             lowerer.lowerSearchParamsMethodCall(expr, expr.expression) ??
             lowerer.lowerStatsMethodCall(expr, expr.expression) ??
+            lowerHashStreamCall(lowerer, expr, expr.expression) ??
             lowerCryptoHashMethodCall(lowerer, expr, expr.expression) ??
             lowerCipherMethodCall(lowerer, expr, expr.expression) ??
             lowerFileHandleMethodCall(lowerer, expr, expr.expression) ??
@@ -1092,6 +1222,8 @@ export function lowerCall(lowerer, expr) {
             // compile-time-known, so a literal key folds to a constant.
             lowerClassHasOwnPropertyCall(lowerer, expr, expr.expression) ??
             lowerObjectOwnMethodCall(lowerer, expr, expr.expression) ??
+            // Static Response.json(data, init?) builds a native Response.
+            lowerResponseStaticJson(lowerer, expr) ??
             // Refuse Response constructor operations before generic-call
             // fallbacks can report an unrelated SC1090 diagnostic.
             lowerer.fenceUnsupportedFetchConstructorMember(expr.expression) ??
@@ -1101,7 +1233,11 @@ export function lowerCall(lowerer, expr) {
             lowerer.fenceStaticResponseMember(expr.expression, "call") ??
             lowerer.fenceStaticHeadersMember(expr.expression, "call") ??
             lowerer.fenceStaticReadableStreamMember(expr.expression, "call") ??
+            lowerDisposableStackUseCall(lowerer, expr, expr.expression) ??
             lowerer.lowerStdlibMethodCall(expr, expr.expression) ??
+            // crypto.getRandomValues on the WebCrypto global (untyped in
+            // fallback builds, so before the dyn receiver path) or webcrypto.
+            lowerWebCryptoGetRandomValues(lowerer, expr, expr.expression) ??
             // Dyn receivers (JSON.parse-derived `unknown`/`any` values) —
             lowerDynReceiverMethodCall(lowerer, expr, expr.expression) ??
             // Narrowing filters (inferred predicates, filter(Boolean)) claim
@@ -1109,6 +1245,7 @@ export function lowerCall(lowerer, expr) {
             // by the receiver's own element.
             lowerer.lowerFilterNarrowCall(expr, expr.expression) ??
             lowerArrayIsArrayCall(lowerer, expr, expr.expression) ??
+            lowerErrorIsErrorCall(lowerer, expr, expr.expression) ??
             lowerBigIntMethodCall(lowerer, expr, expr.expression) ??
             lowerSymbolStaticCall(lowerer, expr, expr.expression) ??
             lowerSymbolMethodCall(lowerer, expr, expr.expression) ??
@@ -1121,10 +1258,13 @@ export function lowerCall(lowerer, expr) {
             // array method paths (the terminal names collide with array
             // methods, but only iterator-typed receivers reach this).
             lowerIteratorHelperCall(lowerer, expr, expr.expression) ??
+            // Helper calls on generators and other iterator objects.
+            lowerGeneratorHelperCall(lowerer, expr, expr.expression) ??
             lowerIteratorStaticFence(lowerer, expr, expr.expression) ??
             lowerObjectStaticCall(lowerer, expr, expr.expression) ??
             lowerObjectFromEntriesCall(lowerer, expr, expr.expression) ??
             lowerArrayFromCall(lowerer, expr, expr.expression) ??
+            lowerArrayFromAsyncCall(lowerer, expr, expr.expression) ??
             lowerArrayOfCall(lowerer, expr, expr.expression) ??
             lowerer.lowerArrayMethodCall(expr, expr.expression) ??
             // Tuple reads preserve the receiver through argument evaluation;
@@ -1143,15 +1283,20 @@ export function lowerCall(lowerer, expr) {
             lowerObjLitGenericMethodCall(lowerer, expr, expr.expression);
         if (intrinsic)
             return intrinsic;
-        if (isJsSourceFile(expr.getSourceFile())) {
+        {
+            const boxed = lowerDynReceiverMethodCall(lowerer, expr, expr.expression, true);
+            if (boxed)
+                return boxed;
+        }
+        if (isJsSourceFile(ts.getSourceFileOfNode(expr))) {
             const staticField = lowerStaticFieldRead(lowerer, expr.expression);
-            if (staticField?.type.kind === "dyn" && !expr.arguments.some(ts.isSpreadElement)) {
+            if (staticField?.type.kind === "dyn" && !expr.arguments.nodes.some(ts.isSpreadElement)) {
                 return {
                     kind: "dynCall",
                     callee: staticField,
                     receiver: lowerer.lowerExprExpecting(expr.expression.expression, DYN),
-                    calleeName: expr.expression.getText(),
-                    args: expr.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    calleeName: v8CalleeText(expr.expression),
+                    args: expr.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc: locOf(expr),
                 };
@@ -1164,12 +1309,13 @@ export function lowerCall(lowerer, expr) {
                 const args = completeFuncValueArgs(lowerer, expr, callee.type, locOf(expr));
                 return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(expr) };
             }
-            if (callee.type.kind === "dyn" && !expr.arguments.some((arg) => ts.isSpreadElement(arg))) {
-                const args = expr.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+            if (callee.type.kind === "dyn" &&
+                !expr.arguments.nodes.some((arg) => ts.isSpreadElement(arg))) {
+                const args = expr.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
                 return {
                     kind: "dynCall",
                     callee,
-                    calleeName: expr.expression.getText(),
+                    calleeName: v8CalleeText(expr.expression),
                     args,
                     type: DYN,
                     loc: locOf(expr),
@@ -1206,7 +1352,7 @@ export function lowerCall(lowerer, expr) {
         {
             const recvT = lowerer.typeOf(expr.expression.expression);
             if (recvT.isIntersectionType() && lowerer.checker.getCallSignatures(recvT).length > 0) {
-                lowerer.unsupported("SC1090", expr, `calls through function-with-properties values ('${expr.expression.expression.getText()}' is callable AND carries members — the chalk shape; no hybrid representation exists yet: export the base and the property as separate functions)`);
+                lowerer.unsupported("SC1090", expr, `calls through function-with-properties values ('${ts.getTextOfNode(expr.expression.expression)}' is callable AND carries members — the chalk shape; no hybrid representation exists yet: export the base and the property as separate functions)`);
             }
         }
         // A GENERIC method no lowering above claimed — an ambient `declare
@@ -1221,14 +1367,29 @@ export function lowerCall(lowerer, expr) {
                 lowerer.unsupported("SC1090", expr, `calls of the generic method '${expr.expression.name.text}' through this receiver (no compiled declaration with a body resolves statically here — ambient 'declare class' and interface-only methods are signature-only, and only class, static, and object-literal generic methods with bodies monomorphize)`);
             }
         }
-        lowerer.unsupported("SC1090", expr, `method calls like '${expr.expression.getText()}'`);
+        lowerer.unsupported("SC1090", expr, `method calls like '${ts.getTextOfNode(expr.expression)}'`);
+    }
+    // `s[Symbol.iterator]()` on a string: the string iterator as a value.
+    if (ts.isElementAccessExpression(expr.expression) &&
+        !expr.expression.questionDotToken &&
+        !expr.questionDotToken &&
+        expr.arguments.nodes.length === 0) {
+        const iterator = lowerStringIteratorCall(lowerer, expr, expr.expression);
+        if (iterator)
+            return iterator;
     }
     // The element spelling of an unsupported native Web method must fence
     // before lowering the callee into a checked-dynamic keyed read.
     if (ts.isElementAccessExpression(expr.expression)) {
+        const timersDispose = lowerMockTimersElementCall(lowerer, expr, expr.expression);
+        if (timersDispose)
+            return timersDispose;
         const symbolMethod = lowerClassSymbolMethodCall(lowerer, expr);
         if (symbolMethod)
             return symbolMethod;
+        const readlineDispose = lowerReadlineDisposeCall(lowerer, expr);
+        if (readlineDispose)
+            return readlineDispose;
         lowerer.fenceUnsupportedFetchConstructorMember(expr.expression);
         lowerer.fenceStaticResponseMember(expr.expression, "call");
         lowerer.fenceStaticHeadersMember(expr.expression, "call");
@@ -1242,7 +1403,7 @@ export function lowerCall(lowerer, expr) {
         !symbolFieldInfo(lowerer, expr.expression)) {
         const access = expr.expression;
         const value = tryLowerExpression(lowerer, access.expression);
-        if (value?.type.kind === "array" && !isJsSourceFile(expr.getSourceFile())) {
+        if (value?.type.kind === "array" && !isJsSourceFile(ts.getSourceFileOfNode(expr))) {
             const callback = lowerArrayCallbackCall(lowerer, expr, access, value);
             if (callback)
                 return callback;
@@ -1262,7 +1423,7 @@ export function lowerCall(lowerer, expr) {
             const raw = lowerer.lowerExpr(access.argumentExpression);
             const key = raw.type.kind === "string" ? raw : lowerer.coerceInto(access.argumentExpression, raw, DYN);
             const callee = { kind: "dynKeyGet", value: receiver, key, type: DYN, loc };
-            const spread = expr.arguments.some(ts.isSpreadElement)
+            const spread = expr.arguments.nodes.some(ts.isSpreadElement)
                 ? lowerSpreadArgsCall(lowerer, expr, callee, loc)
                 : null;
             if (spread && spread.kind !== "dynCall")
@@ -1273,8 +1434,8 @@ export function lowerCall(lowerer, expr) {
                     kind: "dynCall",
                     callee,
                     receiver,
-                    calleeName: access.getText(),
-                    args: expr.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    calleeName: ts.getTextOfNode(access),
+                    args: expr.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
                 };
@@ -1315,7 +1476,7 @@ export function lowerCall(lowerer, expr) {
                 else
                     lowerer.noteEdge(`%${found.declarer.def.name}.${memberName}`);
                 const receiver = lowerer.lowerExpr(expr.expression.expression);
-                const args = lowerer.completeArgs(expr.arguments, found.sig.params, locOf(expr), expr);
+                const args = lowerer.completeArgs(expr.arguments.nodes, found.sig.params, locOf(expr), expr);
                 const callArgs = [
                     lowerer.upcastTo(receiver, virtual ? info.def.name : found.declarer.def.name),
                     ...args,
@@ -1366,7 +1527,7 @@ export function lowerCall(lowerer, expr) {
     // function" TypeError. The result is dyn (checked per use like every
     // any-origin value). Spread arguments keep their fence.
     if (callee.type.kind === "dyn") {
-        if (expr.arguments.some((a) => ts.isSpreadElement(a))) {
+        if (expr.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
             // The runtime-arity lane: a dyn callee is already boxed — the
             // spread-marked dynCall applies through a fresh dyn argument
             // array (lowerSpreadArgsCall). Sources outside it keep the fence.
@@ -1375,10 +1536,10 @@ export function lowerCall(lowerer, expr) {
                 return spreadServed;
             lowerer.unsupported("SC1090", expr, "spread arguments in calls through 'unknown' values");
         }
-        const args = expr.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
+        const args = expr.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN));
         const calleeName = ts.isPropertyAccessExpression(expr.expression) ||
             ts.isElementAccessExpression(expr.expression)
-            ? expr.expression.getText()
+            ? ts.getTextOfNode(expr.expression)
             : ts.isIdentifier(expr.expression)
                 ? expr.expression.text
                 : "value";
@@ -1390,8 +1551,8 @@ export function lowerCall(lowerer, expr) {
         return {
             kind: "dynCall",
             callee: lowerer.coerceToExpected(callee, DYN),
-            calleeName: expr.expression.getText(),
-            args: expr.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+            calleeName: v8CalleeText(expr.expression),
+            args: expr.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
             type: DYN,
             loc,
         };
@@ -1412,7 +1573,16 @@ export function lowerCall(lowerer, expr) {
     // or marshals the callee and applies through a runtime-built argument
     // list (lowerSpreadArgsCall). Shapes outside its lanes fall through
     // to the historical fences.
-    if (expr.arguments.some((a) => ts.isSpreadElement(a))) {
+    // Forwarded fixed tuples (`fn(...args)` over a tuple rest parameter or a
+    // typed `arguments`) have a compile-time arity: complete them into the
+    // callee's positional slots directly, without the runtime-arity lane.
+    if (callee.type.rest !== true &&
+        expr.arguments.nodes.some(ts.isSpreadElement) &&
+        expr.arguments.nodes.every((a) => !ts.isSpreadElement(a) || isForwardedTupleSpread(lowerer, a.expression))) {
+        const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
+        return { kind: "callValue", callee, args, type: callee.type.ret, loc };
+    }
+    if (expr.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
         const spreadServed = lowerSpreadArgsCall(lowerer, expr, callee, loc);
         if (spreadServed)
             return spreadServed;
@@ -1423,12 +1593,12 @@ export function lowerCall(lowerer, expr) {
     // checked-dynamic boundary — box the callee, dynCall — which delivers
     // JS arity exactly (the thunk ignores extras). Result dyn, checked
     // per use like every any-origin value.
-    if ((expr.arguments.length > callee.type.params.length || callee.type.rest === true) &&
-        (isJsSourceFile(expr.getSourceFile()) ||
+    if ((expr.arguments.nodes.length > callee.type.params.length || callee.type.rest === true) &&
+        (isJsSourceFile(ts.getSourceFileOfNode(expr)) ||
             (callee.type.rest === true && callee.type.restAbi === undefined)) &&
-        !expr.arguments.some((a) => ts.isSpreadElement(a)) &&
+        !expr.arguments.nodes.some((a) => ts.isSpreadElement(a)) &&
         canBoxFuncIntoDyn(callee.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-        const args = expr.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
+        const args = expr.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN));
         const calleeName = ts.isIdentifier(expr.expression) ? expr.expression.text : "value";
         const boxed = { kind: "dynFrom", value: callee, type: DYN, loc };
         return { kind: "dynCall", callee: boxed, calleeName, args, type: DYN, loc };
@@ -1443,12 +1613,13 @@ function lowerCheckedCallableValue(lowerer, call, value, loc) {
     if (callee.type.kind !== "dyn") {
         if (callee.type.kind !== "func" ||
             !((callee.type.rest === true && callee.type.restAbi === undefined) ||
-                (isJsSourceFile(call.getSourceFile()) && call.arguments.length > callee.type.params.length)) ||
+                (isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+                    call.arguments.nodes.length > callee.type.params.length)) ||
             !lowerer.dynConvertible(callee.type))
             return null;
         callee = { kind: "dynFrom", value: callee, type: DYN, loc };
     }
-    if (call.arguments.some(ts.isSpreadElement)) {
+    if (call.arguments.nodes.some(ts.isSpreadElement)) {
         const spread = lowerSpreadArgsCall(lowerer, call, callee, loc);
         if (spread)
             return spread;
@@ -1457,8 +1628,8 @@ function lowerCheckedCallableValue(lowerer, call, value, loc) {
     return {
         kind: "dynCall",
         callee,
-        calleeName: call.expression.getText(),
-        args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+        calleeName: v8CalleeText(call.expression),
+        args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
         type: DYN,
         loc,
     };
@@ -1467,19 +1638,19 @@ function lowerRegexMethodCallWithOptionalArg(lowerer, call, access) {
     const lowered = lowerer.lowerRegexMethodCall(call, access);
     if (lowered?.kind !== "regexIntrinsic" ||
         lowered.method !== "test" ||
-        call.arguments.length !== 1)
+        call.arguments.nodes.length !== 1)
         return lowered;
     const subject = lowered.args[0];
     if (subject?.type.kind !== "union" || lowerer.armTag(subject.type.unionId, UNDEFINED_T) < 0)
         return lowered;
-    if (lowerer.mapTypeOf(lowerer.typeOf(call.arguments[0]))?.kind !== "string")
+    if (lowerer.mapTypeOf(lowerer.typeOf(call.arguments.nodes[0]))?.kind !== "string")
         return lowered;
     const present = lowerer.stripUndefinedArm(subject.type);
     if (present.kind !== "string")
         return lowered;
     return {
         ...lowered,
-        args: [lowerer.ensureString(subject, call.arguments[0])],
+        args: [lowerer.ensureString(subject, call.arguments.nodes[0])],
     };
 }
 function optionalCallValue(lowerer, node) {
@@ -1496,17 +1667,17 @@ function lowerBufferStaticCallWithNarrowedArg(lowerer, call, access) {
     // A callback can store a wider union than the checker sees at this use
     // (including an added undefined arm). Extract the exact arm proven by
     // control-flow narrowing, not merely the union with undefined removed.
-    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(call.arguments[0]));
+    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(call.arguments.nodes[0]));
     if (!narrowed ||
         !(narrowed.kind === "f64" ||
             (narrowed.kind === "array" && narrowed.elem.kind === "f64") ||
             (narrowed.kind === "bytes" && narrowed.elem === "u8")) ||
         lowerer.armTag(lowered.source.type.unionId, narrowed) < 0) {
-        lowerer.unsupported("SC1090", call.arguments[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
+        lowerer.unsupported("SC1090", call.arguments.nodes[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
     }
     const helper = lowerer.narrowedArmHelper(lowered.source.type.unionId, narrowed, lowered.source.loc);
     if (!helper) {
-        lowerer.unsupported("SC1090", call.arguments[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
+        lowerer.unsupported("SC1090", call.arguments.nodes[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
     }
     const narrowedValue = {
         ...lowered,
@@ -1567,7 +1738,7 @@ function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
     }
     return { kind: "call", callee: helper, args: [value], type: F64, loc };
 }
-function lowerStringMethodCallWithOptionalArgs(lowerer, call, access, receiver, argumentNodes = call.arguments) {
+function lowerStringMethodCallWithOptionalArgs(lowerer, call, access, receiver, argumentNodes = call.arguments.nodes) {
     const lowered = lowerStringMethodCall(lowerer, call, access, receiver, argumentNodes);
     if (lowered?.kind !== "strIntrinsic")
         return lowered;
@@ -1664,6 +1835,10 @@ function lowerNumberConstructorValue(lowerer, argNode, loc) {
     const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
     if (optionalNumber)
         return optionalNumber;
+    // A program class instance converts through its own methods.
+    const classNumber = classToNumberConversion(lowerer, arg, argNode);
+    if (classNumber)
+        return classNumber;
     const scalarUnionNumber = lowerScalarUnionNumber(lowerer, arg, argNode, loc);
     if (scalarUnionNumber)
         return scalarUnionNumber;
@@ -1769,7 +1944,7 @@ function immediatePrimitiveWrapperToString(lowerer, node) {
     if ((name !== "Boolean" && name !== "Number") ||
         !lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(wrapped.expression) ?? undefined))
         return null;
-    const args = wrapped.arguments ?? [];
+    const args = wrapped.arguments?.nodes ?? [];
     if (args.length > 1 || args.some(ts.isSpreadElement))
         return null;
     const loc = locOf(wrapped);
@@ -1836,7 +2011,7 @@ function immediateObjectTagReceiver(lowerer, node) {
     if ((ts.isCallExpression(value) || ts.isNewExpression(value)) &&
         ts.isIdentifier(value.expression) &&
         (value.expression.text === "Array" || value.expression.text === "Error") &&
-        (value.arguments?.length ?? 0) === 0 &&
+        (value.arguments?.nodes.length ?? 0) === 0 &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(value.expression) ?? undefined)) {
         return { tag: value.expression.text, effect: { kind: "numLit", value: 0, type: F64, loc } };
     }
@@ -1844,7 +2019,7 @@ function immediateObjectTagReceiver(lowerer, node) {
         ts.isIdentifier(value.expression) &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(value.expression) ?? undefined)) {
         const name = value.expression.text;
-        const args = value.arguments ?? [];
+        const args = value.arguments?.nodes ?? [];
         // JavaScript dates use checked native handles, so their IR type alone
         // cannot recover the tag through an immediate Object(...) wrapper.
         if (name === "Date")
@@ -1875,7 +2050,7 @@ function immediateObjectTagReceiver(lowerer, node) {
         ts.isIdentifier(value.expression) &&
         value.expression.text === "Object" &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(value.expression) ?? undefined)) {
-        const args = value.arguments ?? [];
+        const args = value.arguments?.nodes ?? [];
         if (args.some(ts.isSpreadElement))
             return null;
         const first = args[0];
@@ -1930,12 +2105,12 @@ const ARRAY_BORROW_METHODS = new Set([
     "some",
 ]);
 function lowerArrayPrototypeBorrowCall(lowerer, call, access) {
-    if (!isJsSourceFile(call.getSourceFile()) ||
+    if (!isJsSourceFile(ts.getSourceFileOfNode(call)) ||
         call.questionDotToken ||
         access.questionDotToken ||
         access.name.text !== "call" ||
         !ts.isPropertyAccessExpression(access.expression) ||
-        call.arguments.some(ts.isSpreadElement))
+        call.arguments.nodes.some(ts.isSpreadElement))
         return null;
     const method = access.expression;
     if (method.questionDotToken ||
@@ -1947,10 +2122,10 @@ function lowerArrayPrototypeBorrowCall(lowerer, call, access) {
         !lowerer.isStdlibMember(method))
         return null;
     const loc = locOf(call);
-    const receiver = call.arguments[0]
-        ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+    const receiver = call.arguments.nodes[0]
+        ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
         : dynUndefinedExpr(loc);
-    const args = call.arguments.slice(1).map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+    const args = call.arguments.nodes.slice(1).map((arg) => lowerer.lowerExprExpecting(arg, DYN));
     return {
         kind: "libCall",
         fn: "dyn.arrayProtoCall",
@@ -1975,23 +2150,23 @@ function lowerObjectOwnPrototypeCall(lowerer, call, access) {
         prototype.name.text !== "prototype" ||
         !lowerer.isStdlibGlobal(prototype.expression, "Object") ||
         !lowerer.isStdlibMember(method) ||
-        call.arguments.some(ts.isSpreadElement))
+        call.arguments.nodes.some(ts.isSpreadElement))
         return null;
-    return lowerObjectOwnCall(lowerer, call, call.arguments[0], call.arguments[1], call.arguments.slice(2), method.name.text);
+    return lowerObjectOwnCall(lowerer, call, call.arguments.nodes[0], call.arguments.nodes[1], call.arguments.nodes.slice(2), method.name.text);
 }
 function lowerObjectOwnMethodCall(lowerer, call, access) {
     const method = access.name.text;
     if (call.questionDotToken ||
         access.questionDotToken ||
         (method !== "hasOwnProperty" && method !== "propertyIsEnumerable") ||
-        call.arguments.some(ts.isSpreadElement))
+        call.arguments.nodes.some(ts.isSpreadElement))
         return null;
     if (!lowerer.isStdlibMember(access)) {
         const receiver = tryLowerExpression(lowerer, access.expression);
         if (receiver?.type.kind !== "dyn")
             return null;
     }
-    return lowerObjectOwnCall(lowerer, call, access.expression, call.arguments[0], call.arguments.slice(1), method);
+    return lowerObjectOwnCall(lowerer, call, access.expression, call.arguments.nodes[0], call.arguments.nodes.slice(1), method, access);
 }
 /** ToPropertyKey for the scalar keys represented by native own-key
  * probes. A lowered array-loop key may carry an undefined arm even when
@@ -2017,7 +2192,10 @@ function ownPropertyKey(lowerer, key) {
     }
     return null;
 }
-function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, method) {
+function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, method, 
+// The `receiver.method` access of a method call (null for the
+// Object.prototype.method.call form).
+methodAccess = null) {
     const enumerable = method === "propertyIsEnumerable";
     const loc = locOf(call);
     const stmts = [];
@@ -2089,6 +2267,8 @@ function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, me
         if (!shape || shape.tuple || shapeHasAccessorSlots(shape)) {
             lowerer.noLowering("Object.prototype." + method + " over this record shape", receiverNode ?? call);
         }
+        // A null-prototype record (Object.groupBy) has no such method: Node
+        // throws after evaluating the arguments.
         result = {
             kind: "call",
             callee: recordHasOwnHelper(lowerer, type.shapeId, loc),
@@ -2096,6 +2276,9 @@ function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, me
             type: BOOL,
             loc,
         };
+        if (methodAccess && nullProtoRecordShape(lowerer, type)) {
+            result = guardNullProto(receiverRef, type.shapeId, `${ts.getTextOfNode(methodAccess)} is not a function`, result, loc);
+        }
     }
     else if (type.kind === "dyn") {
         result = {
@@ -2209,16 +2392,17 @@ function lowerObjectPrototypeCall(lowerer, call, access) {
         prototype.name.text !== "prototype" ||
         !lowerer.isStdlibGlobal(prototype.expression, "Object") ||
         !lowerer.isStdlibMember(method) ||
-        call.arguments.some(ts.isSpreadElement))
+        call.arguments.nodes.some(ts.isSpreadElement))
         return null;
     const loc = locOf(call);
-    if (call.arguments.length === 0)
+    if (call.arguments.nodes.length === 0)
         return { kind: "strLit", value: "[object Undefined]", type: STRING, loc };
-    const receiverNode = call.arguments[0];
+    const receiverNode = call.arguments.nodes[0];
     const immediate = immediateObjectTagReceiver(lowerer, receiverNode);
     const receiver = immediate?.effect ?? lowerer.lowerExpr(receiverNode);
     const tag = immediate?.tag ?? objectToStringTag(lowerer, receiver.type);
-    if (tag === null && receiver.type.kind !== "dyn") {
+    // A generator object answers its tag through its checked capsule.
+    if (tag === null && receiver.type.kind !== "dyn" && receiver.type.kind !== "generator") {
         lowerer.noLowering("Object.prototype.toString.call over a " + lowerer.fmt(receiver.type) + " receiver", receiverNode);
     }
     const stmts = [];
@@ -2232,11 +2416,17 @@ function lowerObjectPrototypeCall(lowerer, call, access) {
         stmts.push({ kind: "varDecl", localId: local.id, init: receiver, loc });
         ref = varRef(local.id, receiver.type, loc);
     }
-    for (const extra of call.arguments.slice(1)) {
+    for (const extra of call.arguments.nodes.slice(1)) {
         stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(extra), loc: locOf(extra) });
     }
     const result = tag === null
-        ? { kind: "libCall", fn: "dyn.objectTag", args: [ref], type: STRING, loc }
+        ? {
+            kind: "libCall",
+            fn: "dyn.objectTag",
+            args: [ref.type.kind === "generator" ? lowerer.coerceToExpected(ref, DYN) : ref],
+            type: STRING,
+            loc,
+        }
         : { kind: "strLit", value: "[object " + tag + "]", type: STRING, loc };
     return { kind: "seqExpr", stmts, result, type: STRING, loc };
 }
@@ -2258,7 +2448,7 @@ function lowerDynamicStringPrototypeCall(lowerer, call, methodAccess, receiver,
     };
     const overrides = [];
     try {
-        for (const node of call.arguments.slice(1)) {
+        for (const node of call.arguments.nodes.slice(1)) {
             const undefinedValue = lowerStaticallyUndefinedArgument(lowerer, node);
             const value = undefinedValue ?? lowerer.lowerExpr(node);
             let ref;
@@ -2280,7 +2470,7 @@ function lowerDynamicStringPrototypeCall(lowerer, call, methodAccess, receiver,
             overrides.push({ node, previous: lowerer.chainRecvByNode.get(node) });
             lowerer.chainRecvByNode.set(node, ref);
         }
-        const result = lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => converted, call.arguments.slice(1));
+        const result = lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => converted, call.arguments.nodes.slice(1));
         return result ? { kind: "seqExpr", stmts, result, type: result.type, loc } : null;
     }
     finally {
@@ -2305,7 +2495,7 @@ function lowerStringPrototypeCall(lowerer, call, access) {
             !STRING_INDEX_METHODS.has(methodAccess.name.text)) ||
         !lowerer.isStdlibMember(methodAccess))
         return null;
-    if (call.arguments.some(ts.isSpreadElement))
+    if (call.arguments.nodes.some(ts.isSpreadElement))
         return null;
     const entry = STR_METHODS[methodAccess.name.text];
     const indexMethod = STRING_INDEX_METHODS.has(methodAccess.name.text)
@@ -2323,12 +2513,12 @@ function lowerStringPrototypeCall(lowerer, call, access) {
             : methodAccess.name.text;
     const loc = locOf(call);
     const nullishError = nodeThrowExpr(1, "", `String.prototype.${method} called on null or undefined`, resultType, loc);
-    const receiverNode = call.arguments[0];
+    const receiverNode = call.arguments.nodes[0];
     if (!receiverNode)
         return nullishError;
     // Receiver coercion runs after .call has evaluated its arguments; keep
     // contextual wrapper lowering on forms without later method arguments.
-    const immediateWrapper = entry?.maxArgs === 0 && call.arguments.length === 1
+    const immediateWrapper = entry?.maxArgs === 0 && call.arguments.nodes.length === 1
         ? immediatePrimitiveWrapperToString(lowerer, receiverNode)
         : null;
     const receiverValue = immediateWrapper ?? lowerer.lowerExpr(receiverNode);
@@ -2341,7 +2531,10 @@ function lowerStringPrototypeCall(lowerer, call, access) {
                 ?.arms.every((arm) => isUnitType(arm) || arm.kind === "void") ??
                 false));
     if (nullish) {
-        const values = [receiverValue, ...call.arguments.slice(1).map((arg) => lowerer.lowerExpr(arg))];
+        const values = [
+            receiverValue,
+            ...call.arguments.nodes.slice(1).map((arg) => lowerer.lowerExpr(arg)),
+        ];
         return {
             kind: "seqExpr",
             stmts: values
@@ -2371,28 +2564,28 @@ function lowerStringPrototypeCall(lowerer, call, access) {
     // Other methods convert object receivers before lowering their arguments;
     // padding uses a helper that delays conversion until every argument is ready.
     const objectWithoutMethodArgs = entry?.maxArgs === 0 &&
-        call.arguments.length === 1 &&
+        call.arguments.nodes.length === 1 &&
         (receiverType.kind === "record" ||
             receiverType.kind === "array" ||
             receiverType.kind === "object");
     if (padding && !scalar && lowerer.dynConvertible(receiverType)) {
-        return lowerStringPaddingCall(lowerer, call, entry.method, lowerer.coerceToExpected(receiverValue, DYN), receiverNode, call.arguments.slice(1));
+        return lowerStringPaddingCall(lowerer, call, entry.method, lowerer.coerceToExpected(receiverValue, DYN), receiverNode, call.arguments.nodes.slice(1));
     }
     if (!scalar && !objectWithoutMethodArgs) {
         lowerer.noLowering(`String.prototype.${methodAccess.name.text}.call with ${lowerer.fmt(receiverType)} receivers`, call);
     }
     if (indexMethod)
-        return lowerStringIndexCall(lowerer, call, indexMethod, receiverValue, receiverNode, call.arguments.slice(1));
+        return lowerStringIndexCall(lowerer, call, indexMethod, receiverValue, receiverNode, call.arguments.nodes.slice(1));
     if (!entry)
         return null;
     if (padding) {
-        return lowerStringPaddingCall(lowerer, call, entry.method, receiverValue, receiverNode, call.arguments.slice(1));
+        return lowerStringPaddingCall(lowerer, call, entry.method, receiverValue, receiverNode, call.arguments.nodes.slice(1));
     }
     if (entry.method === "split") {
-        return lowerStringSplitCall(lowerer, call, receiverValue, receiverNode, call.arguments.slice(1));
+        return lowerStringSplitCall(lowerer, call, receiverValue, receiverNode, call.arguments.nodes.slice(1));
     }
     const receiver = lowerer.ensureString(receiverValue, receiverNode);
-    return lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => receiver, call.arguments.slice(1));
+    return lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => receiver, call.arguments.nodes.slice(1));
 }
 function lowerScalarUnionNumber(lowerer, arg, node, loc) {
     if (arg.type.kind !== "union" ||
@@ -2507,6 +2700,49 @@ function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", lab
     }
     return { kind: "call", callee: helper, args: [arg], type: F64, loc };
 }
+/** `s[Symbol.iterator]()` on a string-typed receiver: the generator over
+ * its code points. Null for other element calls. */
+function lowerStringIteratorCall(lowerer, call, access) {
+    let key = access.argumentExpression;
+    while (ts.isParenthesizedExpression(key))
+        key = key.expression;
+    if (!ts.isPropertyAccessExpression(key) ||
+        lowerer.stdlibGlobalMember(key, "Symbol") !== "iterator")
+        return null;
+    if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "string")
+        return null;
+    const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+    if (type?.kind !== "generator")
+        return null;
+    const receiver = lowerer.lowerExpr(access.expression);
+    const value = lowerStringIteratorValue(lowerer, receiver, type, locOf(call));
+    if (!value)
+        lowerer.unsupported("SC1090", call, "this string iterator type");
+    return value;
+}
+/** Iterator types with checked runtime receivers, whose helper calls lower
+ * in lowerGeneratorHelperCall. */
+const CHECKED_ITERATOR_TYPES = new Set(["MapIterator", "SetIterator"]);
+const ITERATOR_HELPER_METHODS = new Set([
+    "map",
+    "filter",
+    "take",
+    "drop",
+    "flatMap",
+    "toArray",
+    "forEach",
+    "reduce",
+    "some",
+    "every",
+    "find",
+]);
+/** A call expression, through parentheses: its value has no other holder. */
+function isFreshCallResult(node) {
+    let e = node;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return ts.isCallExpression(e);
+}
 /** METHOD calls on dyn receivers (`pkg.name.replace(...)`, `rawName.split`,
  * `ws.packages.filter(...)` — JSON.parse-derived values): validate the
  * receiver's dyn kind, extract, and ride the STATIC method machinery — the
@@ -2520,7 +2756,7 @@ function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", lab
  * the dyn array and validated-extracts the survivors into the element type
  * the checker committed the result to. Null when the receiver isn't a dyn
  * value or the method isn't claimable (the method-call fence stays). */
-function lowerDynReceiverMethodCall(lowerer, call, access) {
+function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = false) {
     if (lowerer.chainBlocked(call, access))
         return null;
     if (stdlibGlobalNameOf(lowerer, access.expression) !== null) {
@@ -2538,7 +2774,12 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     // array — scalar narrowings bridge through maybeNarrow's dynCheck and
     // take the ordinary typed paths, but there is no static home for an
     // any-elemented array). Typed receivers keep their own lowerings.
-    const recvTs = lowerer.typeOf(access.expression);
+    // An optional step the chain already guarded (`s?.m(x)`) has a receiver
+    // proven non-nullish.
+    const rawRecvTs = lowerer.typeOf(access.expression);
+    const recvTs = access.questionDotToken !== undefined && lowerer.chainHandled.has(access)
+        ? lowerer.checker.getNonNullableType(rawRecvTs)
+        : rawRecvTs;
     if (lowerer.classImplementedProtocol(recvTs)) {
         const property = lowerer.checker.getPropertyOfType(recvTs, access.name.text);
         if (property &&
@@ -2547,23 +2788,14 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     }
     const recvSymbol = recvTs.getSymbol();
     if (recvSymbol &&
-        ["MapIterator", "SetIterator"].includes(recvSymbol.name) &&
+        CHECKED_ITERATOR_TYPES.has(ts.symbolName(recvSymbol)) &&
         lowerer.isStdlibSymbol(recvSymbol) &&
-        [
-            "map",
-            "filter",
-            "take",
-            "drop",
-            "flatMap",
-            "toArray",
-            "forEach",
-            "reduce",
-            "some",
-            "every",
-            "find",
-        ].includes(access.name.text) &&
+        ITERATOR_HELPER_METHODS.has(access.name.text) &&
         lowerer.isStdlibMember(access)) {
-        lowerer.noLowering(`collection iterator .${access.name.text}()`, call, "stored Map/Set iterators support .next() and iteration; iterator helper methods have no lowering");
+        const helper = lowerGeneratorHelperCall(lowerer, call, access);
+        if (helper)
+            return helper;
+        lowerer.noLowering(`collection iterator .${access.name.text}()`, call, "iterator helpers on Map/Set iterators are called directly on the iterator, without optional chaining");
     }
     const arrayReceiver = lowerer.checker.isArrayType(recvTs);
     const anyArray = arrayReceiver &&
@@ -2603,7 +2835,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
                 type: DYN,
                 loc,
             };
-            if (call.arguments.some(ts.isSpreadElement)) {
+            if (call.arguments.nodes.some(ts.isSpreadElement)) {
                 lowerer.unsupported("SC1090", call, "spread arguments in callable property calls");
             }
             return {
@@ -2613,8 +2845,8 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
                     kind: "dynCall",
                     callee: member,
                     receiver,
-                    calleeName: access.getText(),
-                    args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    calleeName: ts.getTextOfNode(access),
+                    args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
                 },
@@ -2627,8 +2859,14 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
             if (info)
                 return lowerStaticMethodCall(lowerer, call, access);
         }
+        // A possibly missing element of a class-typed array (`items[i]`) is
+        // the receiver's class or undefined. The class method call checks for
+        // undefined itself, as it does in TypeScript.
+        const presentArm = probed?.type.kind === "union" ? lowerer.stripUndefinedArm(probed.type) : null;
+        if (presentArm?.kind === "object" && typeEquals(presentArm, lowerer.mapTypeOf(recvTs) ?? DYN))
+            return null;
         if (probed?.type.kind === "union" &&
-            isJsSourceFile(call.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(call)) &&
             lowerer.unions
                 .get(probed.type.unionId)
                 ?.arms.every((arm) => isUnitType(arm) ||
@@ -2663,13 +2901,47 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
         return (lowerRegexMethodCall(lowerer, call, access, () => recv) ??
             lowerStringMethodCall(lowerer, call, access, () => recv));
     }
+    // A checker-untyped JS binding holding `string | undefined` (string-
+    // width's `const visibleSegment = baseVisible(segment)` after an
+    // `=== undefined` guard the checker cannot see through): no typed
+    // lowering claims the union, so a String method boxes it and takes the
+    // dyn receiver path, whose undefined/null arms throw Node's read errors.
+    if (checkerUntyped &&
+        recv.type.kind === "union" &&
+        isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+        isStringMethodName(access.name.text) &&
+        lowerer.unions
+            .get(recv.type.unionId)
+            ?.arms.every((arm) => arm.kind === "string" || isUnitType(arm)) === true &&
+        lowerer.dynConvertible(recv.type)) {
+        recv = lowerer.coerceToExpected(recv, DYN);
+    }
+    // A native handle read through `as any` (`(hash as any).update(x)`)
+    // dispatches through the handle, as the same value held in an
+    // 'unknown' slot does.
+    if (checkerUntyped && DYN_HANDLE_KINDS.has(recv.type.kind))
+        recv = lowerer.coerceToExpected(recv, DYN);
+    // The last-resort retry (boxTypedTemporary — every other lowering
+    // already declined): a checker-`any` receiver whose value is a FRESH
+    // typed result of an earlier step in the chain (`out.split("\n")`
+    // extracted the string and answered a native string[]) has no typed
+    // home under its `any` spelling, so it boxes into the checked-dynamic
+    // tree and the call dispatches on the runtime kind — `.map`, `.pop`,
+    // `.filter` on that array run JS-exact. Only call results qualify:
+    // the box copies, and a temporary has no other holder to observe it.
+    if (boxTypedTemporary &&
+        checkerUntyped &&
+        recv.type.kind !== "dyn" &&
+        isFreshCallResult(access.expression) &&
+        lowerer.dynConvertible(recv.type))
+        recv = lowerer.coerceToExpected(recv, DYN);
     if (recv.type.kind !== "dyn")
         return null;
     if (access.name.text === "normalize" &&
-        call.arguments.length <= 1 &&
-        !call.arguments.some(ts.isSpreadElement)) {
+        call.arguments.nodes.length <= 1 &&
+        !call.arguments.nodes.some(ts.isSpreadElement)) {
         const loc = locOf(call);
-        const hasArgument = call.arguments.length === 1;
+        const hasArgument = call.arguments.nodes.length === 1;
         const name = `%dyn.string.normalize:${hasArgument ? 1 : 0}`;
         if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
             const value = varRef("receiver", DYN, loc);
@@ -2718,7 +2990,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
                             kind: "dynInvoke",
                             recv: value,
                             method: "normalize",
-                            calleeName: access.getText(),
+                            calleeName: ts.getTextOfNode(access),
                             args: hasArgument ? [argument] : [],
                             type: DYN,
                             loc,
@@ -2733,8 +3005,8 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
             callee: name,
             args: [
                 recv,
-                call.arguments[0]
-                    ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                call.arguments.nodes[0]
+                    ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
                     : dynUndefinedExpr(loc),
             ],
             type: DYN,
@@ -2753,9 +3025,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
             // Those are not stored members of a checked-dynamic object, so
             // dynKeyGet cannot stand in for JavaScript's prototype lookup. Only
             // an authored declaration can justify the own-member path.
-            const authored = lowerer.checker
-                .declarationsOf(prop)
-                .some((decl) => !lowerer.isStdlibFile(decl.getSourceFile()));
+            const authored = prop.declarations.some((decl) => !lowerer.isStdlibFile(ts.getSourceFileOfNode(decl)));
             return (authored &&
                 lowerer.checker.getCallSignatures(lowerer.checker.getTypeOfSymbol(prop)).length > 0);
         })();
@@ -2779,22 +3049,53 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
         return (lowerRegexMethodCall(lowerer, call, access, checked) ??
             lowerStringMethodCall(lowerer, call, access, checked));
     }
+    // String/Number methods the runtime dispatch has no answer for
+    // (codePointAt, substr, toLocaleLowerCase, toPrecision, ...): a string
+    // or number receiver runs the typed lowering, every other kind keeps the
+    // runtime dispatch.
+    if (!ownCallable &&
+        !call.questionDotToken &&
+        !access.questionDotToken &&
+        isDynPrimitiveKindMethod(access.name.text) &&
+        !lowerer.chainBlocked(access, call)) {
+        const primitive = lowerDynPrimitiveMethodCall(lowerer, call, access.name.text, ts.getTextOfNode(access), recv);
+        if (primitive)
+            return primitive;
+    }
     // The argument is a radix for bigint and an encoding for Buffer.
     // Preserve its runtime value so receiver dispatch can choose correctly.
-    if (access.name.text === "toString" && call.arguments.length <= 1) {
-        const argument = call.arguments[0];
+    if (access.name.text === "toString" && call.arguments.nodes.length <= 1) {
+        const argument = call.arguments.nodes[0];
         return {
             kind: "libCall",
             fn: "dyn.toString",
             args: [
                 recv,
                 argument ? lowerer.lowerExprExpecting(argument, DYN) : dynUndefinedExpr(locOf(call)),
-                { kind: "strLit", value: access.getText(), type: STRING, loc: locOf(call) },
+                { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc: locOf(call) },
             ],
             type: STRING,
             loc: locOf(call),
         };
     }
+    // Every dyn kind's prototype chain declares valueOf, and the runtime
+    // answers each kind's own: primitives and plain objects themselves, a
+    // Date its time value, an own or inherited valueOf member its result.
+    if (access.name.text === "valueOf" && call.arguments.nodes.length === 0) {
+        const webAssembly = lowerWebAssemblyValueOf(lowerer, access.expression, recv, locOf(call));
+        if (webAssembly !== null)
+            return webAssembly;
+        return {
+            kind: "libCall",
+            fn: "dyn.valueOf",
+            args: [
+                recv,
+                { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc: locOf(call) },
+            ],
+            type: DYN,
+            loc: locOf(call),
+        };
+    }
     // SHARED prototype names with a runtime dispatch (scr_dyn_invoke):
     // push/slice/join/forEach/map/apply/... dispatch on the receiver's
     // RUNTIME kind — the honest answer for names more than one dyn-
@@ -2816,9 +3117,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
                 lowerer.classes.get(arm.className)?.fields.has(access.name.text)))
             return true;
         return (prop !== undefined &&
-            lowerer.checker
-                .declarationsOf(prop)
-                .some((decl) => ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl)));
+            prop.declarations.some((decl) => ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl)));
     })();
     // Protocol methods keep their static signature: instances of the
     // implementing classes call the native method.
@@ -2848,7 +3147,19 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     // its name overlaps a primitive prototype (`colors.bold(...)`): the
     // source value was compiled from that object shape, while genuinely
     // untyped/any receivers retain the runtime-kind ambiguity and fence.
-    if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable)
+    // A name only String.prototype declares (`bold`, `italics`, `link`,
+    // ...) on a checker-untyped receiver: every other dyn kind answers its
+    // own or inherited member exactly like a non-prototype name (chalk's
+    // `chalk.red.bold(...)` reads a prototype getter of a function), so
+    // only a string receiver keeps the refusal, deferred to run time.
+    // The same holds when only the MEMBER is checker-untyped: TypeScript
+    // importing chalk's JavaScript source types the default export as a
+    // plain function, so `chalk.bold` reads as `any` on a typed receiver.
+    const stringOnlyName = (checkerUntyped ||
+        (lowerer.typeOf(access).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) &&
+        !ownCallable &&
+        DYN_STRING_PROTO_ONLY_NAMES.has(access.name.text);
+    if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable && !stringOnlyName)
         return null;
     // Optional forms (`obj.cb?.()`, `obj?.cb()`) belong to the chain
     // machinery's short-circuit semantics — not modeled here yet.
@@ -2857,6 +3168,22 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     const loc = locOf(call);
     const receiverLocal = lowerer.declareHiddenLocal("%dynCallReceiver", DYN);
     const receiver = { kind: "varRef", localId: receiverLocal.id, type: DYN, loc };
+    // The string refusal throws in place of the member read (a seqExpr
+    // statement cannot leave the expression).
+    const stringRefusal = (read) => {
+        if (!stringOnlyName)
+            return read;
+        const sf = ts.getSourceFileOfNode(call);
+        const line = ts.getLineAndCharacterOfPosition(sf, ts.tokenStartOfNode(call)).line + 1;
+        return {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "string", value: receiver, type: BOOL, loc },
+            then: nodeThrowExpr(0, "SC1090", `method calls like '${ts.getTextOfNode(access)}' on a string are not supported yet [SC1090 at ${sf.fileName}:${line}]`, DYN, loc),
+            else_: read,
+            type: DYN,
+            loc,
+        };
+    };
     const member = {
         kind: "dynKeyGet",
         key: { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access) },
@@ -2868,15 +3195,15 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     const callee = varRef(calleeLocal.id, DYN, loc);
     const stmts = [
         { kind: "varDecl", localId: receiverLocal.id, init: recv, loc },
-        { kind: "varDecl", localId: calleeLocal.id, init: member, loc },
+        { kind: "varDecl", localId: calleeLocal.id, init: stringRefusal(member), loc },
     ];
-    if (call.arguments.some(ts.isSpreadElement)) {
+    if (call.arguments.nodes.some(ts.isSpreadElement)) {
         const spread = lowerSpreadArgsCall(lowerer, call, callee, loc);
         if (spread?.kind === "dynCall")
             return { kind: "seqExpr", stmts, result: { ...spread, receiver }, type: DYN, loc };
         lowerer.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
     }
-    const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
+    const args = call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN));
     return {
         kind: "seqExpr",
         stmts,
@@ -2884,7 +3211,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
             kind: "dynCall",
             callee,
             receiver,
-            calleeName: access.getText(),
+            calleeName: ts.getTextOfNode(access),
             args,
             type: DYN,
             loc,
@@ -2975,6 +3302,30 @@ const DYN_PROTO_METHOD_NAMES = new Set([
     "toFixed",
     "toPrecision",
 ]);
+/** The DYN_PROTO_METHOD_NAMES that only String.prototype declares among
+ * the dyn-representable kinds' prototypes. */
+const DYN_STRING_PROTO_ONLY_NAMES = new Set([
+    "anchor",
+    "big",
+    "blink",
+    "bold",
+    "codePointAt",
+    "fixed",
+    "fontcolor",
+    "fontsize",
+    "isWellFormed",
+    "italics",
+    "link",
+    "localeCompare",
+    "normalize",
+    "small",
+    "strike",
+    "sub",
+    "sup",
+    "toLocaleLowerCase",
+    "toLocaleUpperCase",
+    "toWellFormed",
+]);
 /** The SHARED prototype names scr_dyn_invoke dispatches at runtime (the
  * subset of DYN_PROTO_METHOD_NAMES with a receiver-kind dispatch): the
  * runtime runs the real method for the receiver's kind, throws Node's
@@ -3139,10 +3490,10 @@ const DYN_DISPATCH_METHODS = new Set([
 ]);
 export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayReceiver) {
     const method = access.name.text;
-    if ((!DYN_DISPATCH_METHODS.has(method) && !isJsSourceFile(call.getSourceFile())) ||
+    if ((!DYN_DISPATCH_METHODS.has(method) && !isJsSourceFile(ts.getSourceFileOfNode(call))) ||
         lowerer.chainBlocked(call, access))
         return null;
-    if (call.arguments.some((arg) => ts.isSpreadElement(arg))) {
+    if (call.arguments.nodes.some((arg) => ts.isSpreadElement(arg))) {
         const loc = locOf(call);
         const local = lowerer.declareHiddenLocal("%spreadReceiver", DYN);
         const receiver = varRef(local.id, DYN, loc);
@@ -3171,9 +3522,11 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
             };
         lowerer.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
     }
-    const predicate = method === "filter" && call.arguments[0] ? lowerer.lowerExpr(call.arguments[0]) : null;
+    const predicate = method === "filter" && call.arguments.nodes[0]
+        ? lowerer.lowerExpr(call.arguments.nodes[0])
+        : null;
     if (arrayReceiver && predicate?.type.kind === "func" && predicate.type.ret.kind === "void") {
-        lowerer.unsupported("SC1090", call.arguments[0], "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
+        lowerer.unsupported("SC1090", call.arguments.nodes[0], "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
     }
     // A dynamic argument array consumed immediately by the fixed-arity arrow
     // apply lowering below never exposes its surplus tail. Keep a pushed
@@ -3182,14 +3535,14 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
     // invented. If the slot falls inside the typed prefix, its dynCheck fails
     // at the callback boundary; valid callers preserve the original prefix.
     if (method === "push" &&
-        call.arguments.length === 1 &&
+        call.arguments.nodes.length === 1 &&
         ts.isIdentifier(access.expression) &&
         ts.isExpressionStatement(call.parent) &&
         ts.isBlock(call.parent.parent)) {
         const receiverSymbol = lowerer.checker.getSymbolAtLocation(access.expression);
         const block = call.parent.parent;
-        const statementIndex = block.statements.indexOf(call.parent);
-        const next = statementIndex >= 0 ? block.statements[statementIndex + 1] : undefined;
+        const statementIndex = block.statements.nodes.indexOf(call.parent);
+        const next = statementIndex >= 0 ? block.statements.nodes[statementIndex + 1] : undefined;
         let returned = next && ts.isReturnStatement(next) ? next.expression : undefined;
         while (returned && ts.isParenthesizedExpression(returned))
             returned = returned.expression;
@@ -3199,7 +3552,7 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
             returned.expression.name.text === "apply"
             ? returned
             : null;
-        const argsNode = apply?.arguments[1];
+        const argsNode = apply?.arguments?.nodes[1];
         const sameArgs = receiverSymbol !== undefined &&
             argsNode !== undefined &&
             ts.isIdentifier(argsNode) &&
@@ -3213,7 +3566,7 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
             arrow !== null &&
             targetParams !== null &&
             targetParams.every((param) => canDynCheckTo(param, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
-            const value = lowerer.lowerExpr(call.arguments[0]);
+            const value = lowerer.lowerExpr(call.arguments.nodes[0]);
             if (value.type.kind !== "dyn" && !lowerer.dynConvertible(value.type)) {
                 const saved = lowerer.declareHiddenLocal("%applyTail", DYN);
                 return {
@@ -3226,8 +3579,8 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
                         kind: "dynInvoke",
                         recv: { kind: "varRef", localId: saved.id, type: DYN, loc: locOf(access.expression) },
                         method,
-                        calleeName: access.getText(),
-                        args: [dynUndefinedExpr(locOf(call.arguments[0]))],
+                        calleeName: ts.getTextOfNode(access),
+                        args: [dynUndefinedExpr(locOf(call.arguments.nodes[0]))],
                         type: DYN,
                         loc: locOf(call),
                     },
@@ -3237,7 +3590,7 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
             }
         }
     }
-    const args = call.arguments.map((arg, i) => {
+    const args = call.arguments.nodes.map((arg, i) => {
         if (i === 0 && predicate)
             return lowerer.coerceInto(arg, predicate, DYN);
         const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, arg);
@@ -3249,12 +3602,22 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
         kind: "dynInvoke",
         recv,
         method,
-        calleeName: access.getText(),
+        calleeName: ts.getTextOfNode(access),
         args,
         type: DYN,
         loc: locOf(call),
     };
 }
+/** Every String.prototype method name a typed or dyn string lowering
+ * answers. */
+function isStringMethodName(name) {
+    return (Object.hasOwn(STR_METHODS, name) ||
+        STRING_INDEX_METHODS.has(name) ||
+        DYN_STRING_ONLY_METHODS.has(name) ||
+        isDynPrimitiveKindMethod(name) ||
+        name === "normalize" ||
+        name === "lastIndexOf");
+}
 /** STR_METHODS ∪ the regex-form names, MINUS everything Array (or any
  * other dyn kind's prototype) also declares. */
 const DYN_STRING_ONLY_METHODS = new Set([
@@ -3290,9 +3653,9 @@ function lowerArrayIsArrayCall(lowerer, call, access) {
         return null;
     if (lowerer.stdlibGlobalMember(access, "Array") !== "isArray")
         return null;
-    if (call.arguments.length !== 1)
+    if (call.arguments.nodes.length !== 1)
         return null; // the stdlib chokepoint fences
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     const arg = lowerer.lowerExpr(argNode);
     const loc = locOf(call);
     if (arg.type.kind === "dyn") {
@@ -3364,22 +3727,26 @@ function lowerCaughtPredicateCall(lowerer, call, caughtLocal) {
     if (!ts.isIdentifier(callee))
         return null;
     const symbol = lowerer.resolveValueSymbol(callee);
-    const decl = symbol
-        ? lowerer.checker.declarationsOf(symbol).find(ts.isFunctionDeclaration)
-        : undefined;
+    const decl = symbol ? symbol.declarations.find(ts.isFunctionDeclaration) : undefined;
     if (!symbol || !decl || !decl.body)
         return null;
     if (!decl.type || !ts.isTypePredicateNode(decl.type))
         return null;
-    if (decl.parameters.length !== 1)
+    if (decl.parameters.nodes.length !== 1)
         return null;
-    const param = decl.parameters[0];
+    const param = decl.parameters.nodes[0];
     if (!ts.isIdentifier(param.name) || param.initializer || param.dotDotDotToken)
         return null;
     const paramSymbol = lowerer.checker.getSymbolAtLocation(param.name);
     if (!paramSymbol)
         return null;
-    const ret = decl.body.statements.length === 1 ? decl.body.statements[0] : undefined;
+    const ret = decl.body.statements.nodes.length === 1 ? decl.body.statements.nodes[0] : undefined;
+    // A longer guard whose parameter is `unknown` (or `any`) takes the caught
+    // value as an ordinary checked-dynamic argument: the call path converts
+    // the binding, and the narrowed binding reads through the same value.
+    if ((!ret || !ts.isReturnStatement(ret) || !ret.expression) &&
+        lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(paramSymbol))?.kind === "dyn")
+        return null;
     if (!ret || !ts.isReturnStatement(ret) || !ret.expression) {
         lowerer.unsupported("SC1090", call, `the type-guard '${callee.text}' on a catch binding (only single-'return' guard bodies inline over the caught value)`);
     }
@@ -3409,8 +3776,8 @@ function lowerNumberToStringCall(lowerer, call, access) {
     if (lowerer.chainBlocked(call, access))
         return null;
     if (access.name.text !== "toString" ||
-        call.arguments.length > 1 ||
-        call.arguments.some(ts.isSpreadElement))
+        call.arguments.nodes.length > 1 ||
+        call.arguments.nodes.some(ts.isSpreadElement))
         return null;
     const recvKind = lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind;
     if (recvKind !== "f64" && recvKind !== "bool" && recvKind !== "string")
@@ -3427,22 +3794,44 @@ function lowerNumberToStringCall(lowerer, call, access) {
             fn: "dyn.toString",
             args: [
                 operand,
-                call.arguments[0]
-                    ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                call.arguments.nodes[0]
+                    ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
                     : dynUndefinedExpr(locOf(call)),
-                { kind: "strLit", value: access.getText(), type: STRING, loc: locOf(call) },
+                { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc: locOf(call) },
             ],
             type: STRING,
             loc: locOf(call),
         };
     }
-    if (call.arguments.length === 1) {
+    if (call.arguments.nodes.length === 1) {
         if (operand.type.kind !== "f64")
             return null;
+        const arg = call.arguments.nodes[0];
+        // A number radix needs no box: ToIntegerOrInfinity of a number is a
+        // truncation, which the typed entry point applies itself.
+        if (!ts.isSpreadElement(arg) && lowerer.mapTypeOf(lowerer.typeOf(arg))?.kind === "f64") {
+            const radix = lowerer.lowerExpr(arg);
+            if (radix.type.kind === "f64") {
+                return {
+                    kind: "libCall",
+                    fn: "num.toStringRadixF64",
+                    args: [operand, radix],
+                    type: STRING,
+                    loc: locOf(call),
+                };
+            }
+            return {
+                kind: "libCall",
+                fn: "num.toStringRadix",
+                args: [operand, lowerer.coerceToExpected(radix, DYN)],
+                type: STRING,
+                loc: locOf(call),
+            };
+        }
         return {
             kind: "libCall",
             fn: "num.toStringRadix",
-            args: [operand, lowerer.lowerExprExpecting(call.arguments[0], DYN)],
+            args: [operand, lowerer.lowerExprExpecting(arg, DYN)],
             type: STRING,
             loc: locOf(call),
         };
@@ -3464,7 +3853,7 @@ function lowerNumberToStringCall(lowerer, call, access) {
 function lowerUnionToStringCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
-    if (access.name.text !== "toString" || call.arguments.length !== 0)
+    if (access.name.text !== "toString" || call.arguments.nodes.length !== 0)
         return null;
     const recvT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     if (recvT?.kind !== "union")
@@ -3478,9 +3867,17 @@ function lowerUnionToStringCall(lowerer, call, access) {
         (a.kind === "bytes" && a.elem === "u8"));
     if (!stringable)
         return null;
-    const operand = lowerer.lowerExpr(access.expression);
+    let operand = lowerer.lowerExpr(access.expression);
     if (operand.type.kind !== "union")
         return null;
+    // A flow-narrowed read keeps its wider storage union (`string | number`
+    // after `!Array.isArray(h.host)` over a `string | number | string[]`
+    // slot): retag it to the proven union before the per-union helper.
+    if (operand.type.unionId !== recvT.unionId) {
+        operand = lowerer.coerceInto(access.expression, operand, recvT);
+        if (operand.type.kind !== "union" || operand.type.unionId !== recvT.unionId)
+            return null;
+    }
     return { kind: "toString", operand, type: STRING, loc: locOf(call) };
 }
 /** `x.toString()` resolving to Object.prototype.toString (stdlib
@@ -3495,7 +3892,7 @@ function lowerUnionToStringCall(lowerer, call, access) {
 function lowerDefaultToStringCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
-    if (access.name.text !== "toString" || call.arguments.length !== 0)
+    if (access.name.text !== "toString" || call.arguments.nodes.length !== 0)
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
@@ -3526,20 +3923,33 @@ function lowerDefaultToStringCall(lowerer, call, access) {
     // `(<A>{}).toString()` — assertion-wrapped literals and plain reads
     // have nothing to evaluate; pureObjectToStringReceiver widens
     // pureReceiverNode with the empty object literal.
-    if (pureObjectToStringReceiver(access.expression))
+    // A null-prototype record (Object.groupBy) has no toString: Node
+    // throws "<callee> is not a function".
+    const nullProtoT = nullProtoRecordShape(lowerer, recvT);
+    const missing = nullProtoT ? `${ts.getTextOfNode(access)} is not a function` : null;
+    if (!missing && pureObjectToStringReceiver(access.expression))
         return constant;
     const recv = lowerer.lowerExpr(access.expression);
-    const key = `objToStr:${typeKey(recv.type)}`;
+    const key = `objToStr:${typeKey(recv.type)}${missing ? `:${missing}` : ""}`;
     let helper = lowerer.valueHelpers.get(key);
     if (!helper) {
         helper = `%obj.tostr.${lowerer.valueHelpers.size}`;
         lowerer.valueHelpers.set(key, helper);
+        const o = varRef("o.0", recv.type, loc);
         lowerer.liftedFns.push({
             name: helper,
             params: [{ localId: "o.0", name: "o", type: recv.type }],
             returnType: STRING,
             locals: [{ id: "o.0", name: "o", type: recv.type, mutable: false }],
-            body: [{ kind: "return", value: { ...constant }, loc }],
+            body: [
+                {
+                    kind: "return",
+                    value: nullProtoT && missing
+                        ? guardNullProto(o, nullProtoT.shapeId, missing, { ...constant }, loc)
+                        : { ...constant },
+                    loc,
+                },
+            ],
             loc,
         });
     }
@@ -3556,7 +3966,7 @@ function pureObjectToStringReceiver(node) {
         ts.isTypeAssertion(e)) {
         e = e.expression;
     }
-    if (ts.isObjectLiteralExpression(e) && e.properties.length === 0)
+    if (ts.isObjectLiteralExpression(e) && e.properties.nodes.length === 0)
         return true;
     return pureReceiverNode(e);
 }
@@ -3569,11 +3979,11 @@ function pureObjectToStringReceiver(node) {
 function lowerClassHasOwnPropertyCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
-    if (access.name.text !== "hasOwnProperty" || call.arguments.length !== 1)
+    if (access.name.text !== "hasOwnProperty" || call.arguments.nodes.length !== 1)
         return null;
     if (!ts.isIdentifier(access.expression))
         return null;
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (!ts.isStringLiteralLike(argNode))
         return null;
     if (!lowerer.isStdlibMember(access))
@@ -3584,7 +3994,7 @@ function lowerClassHasOwnPropertyCall(lowerer, call, access) {
         return null; // builtin/runtime classes keep the fence
     const key = argNode.text;
     const own = new Set(["prototype", "name", "length"]);
-    for (const m of info.decl.members) {
+    for (const m of info.decl.members.nodes) {
         const isStatic = ts.canHaveModifiers(m) &&
             (ts.getModifiers(m) ?? []).some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword);
         if (!isStatic)
@@ -3655,26 +4065,52 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
         return null;
     const recvKind = lowerer.mapTypeOf(lowerer.typeOf(recv))?.kind;
     if ((name === "toFixed" || name === "toExponential") &&
-        call.arguments.length <= 1 &&
-        !call.arguments.some(ts.isSpreadElement) &&
-        isJsSourceFile(call.getSourceFile())) {
+        call.arguments.nodes.length <= 1 &&
+        !call.arguments.nodes.some(ts.isSpreadElement) &&
+        isJsSourceFile(ts.getSourceFileOfNode(call))) {
         const operand = lowerer.lowerExpr(recv);
+        if (name === "toExponential" &&
+            call.arguments.nodes.length === 1 &&
+            (operand.type.kind === "dyn" ||
+                (operand.type.kind === "union" && lowerer.dynConvertible(operand.type)))) {
+            const dispatched = lowerDynPrimitiveMethodCall(lowerer, call, name, `${ts.getTextOfNode(recv)}.${name}`, lowerer.coerceToExpected(operand, DYN));
+            if (dispatched)
+                return dispatched;
+        }
         if (operand.type.kind === "dyn" ||
             (operand.type.kind === "union" && lowerer.dynConvertible(operand.type)))
             return {
                 kind: "dynInvoke",
                 recv: lowerer.coerceToExpected(operand, DYN),
                 method: name,
-                calleeName: `${recv.getText()}.${name}`,
-                args: call.arguments.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
+                calleeName: `${ts.getTextOfNode(recv)}.${name}`,
+                args: call.arguments.nodes.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
                 type: DYN,
                 loc: locOf(call),
             };
     }
+    if (name === "toPrecision" &&
+        call.arguments.nodes.length <= 1 &&
+        !call.arguments.nodes.some(ts.isSpreadElement) &&
+        isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+        recvKind === "union") {
+        const operand = lowerer.lowerExpr(recv);
+        if (operand.type.kind === "union" && lowerer.dynConvertible(operand.type)) {
+            const dispatched = lowerDynPrimitiveMethodCall(lowerer, call, name, `${ts.getTextOfNode(recv)}.${name}`, lowerer.coerceToExpected(operand, DYN));
+            if (dispatched)
+                return dispatched;
+        }
+    }
+    if (recvKind === "f64" &&
+        (name === "toPrecision" || (name === "toExponential" && call.arguments.nodes.length === 1))) {
+        const typed = lowerExtraNumberMethodCall(lowerer, call, name, lowerer.lowerExpr(recv));
+        if (typed)
+            return typed;
+    }
     if (recvKind !== "f64" && recvKind !== "bool" && recvKind !== "string")
         return null;
     const loc = locOf(call);
-    if (name === "toString" && call.arguments.length === 0) {
+    if (name === "toString" && call.arguments.nodes.length === 0) {
         const operand = lowerer.lowerExpr(recv);
         if (operand.type.kind === "string")
             return operand; // identity
@@ -3684,16 +4120,16 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
     }
     if ((name === "toExponential" || name === "toFixed") &&
         recvKind === "f64" &&
-        call.arguments.length === 0) {
+        call.arguments.nodes.length === 0) {
         const operand = lowerer.lowerExpr(recv);
         if (operand.type.kind !== "f64")
             return null;
         const fn = name === "toExponential" ? "num.toExponential" : "num.toFixed0";
         return { kind: "libCall", fn, args: [operand], type: STRING, loc };
     }
-    if (name === "toFixed" && recvKind === "f64" && call.arguments.length === 1) {
+    if (name === "toFixed" && recvKind === "f64" && call.arguments.nodes.length === 1) {
         const operand = lowerer.lowerExpr(recv);
-        let digits = lowerer.lowerExpr(call.arguments[0]);
+        let digits = lowerer.lowerExpr(call.arguments.nodes[0]);
         // The optional parameter also admits undefined. Exact unit values
         // become the default 0 after preserving any evaluation effects; an
         // optional number selects 0 at runtime through the same narrowed
@@ -3732,15 +4168,15 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
     // host environment's default, which a compiled binary cannot carry),
     // other locales (ICU data the binary does not embed), options bags.
     if (name === "toLocaleString" && recvKind === "f64") {
-        if (call.arguments.length === 0) {
+        if (call.arguments.nodes.length === 0) {
             lowerer.noLowering("Number.prototype.toLocaleString without a locale", call, "the default locale is the host environment's, which a compiled binary cannot carry — " +
                 'pass it explicitly: x.toLocaleString("en-US")');
         }
-        if (call.arguments.length > 1) {
+        if (call.arguments.nodes.length > 1) {
             lowerer.noLowering("Number.prototype.toLocaleString with an options bag", call, "the embedded data covers DEFAULT options only (decimal notation, up to 3 fraction " +
                 'digits, grouping) — x.toLocaleString("en-US")');
         }
-        const locNode = call.arguments[0];
+        const locNode = call.arguments.nodes[0];
         if (ts.isSpreadElement(locNode) ||
             !ts.isStringLiteralLike(locNode) ||
             locNode.text !== "en-US") {
@@ -3756,17 +4192,17 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
     }
     if (name === "charAt" &&
         recvKind === "string" &&
-        call.arguments.length === 1 &&
-        !ts.isSpreadElement(call.arguments[0])) {
+        call.arguments.nodes.length === 1 &&
+        !ts.isSpreadElement(call.arguments.nodes[0])) {
         const receiver = lowerer.lowerExpr(recv);
         if (receiver.type.kind !== "string")
             return null;
-        const idx = lowerer.lowerExprExpecting(call.arguments[0], F64);
+        const idx = lowerer.lowerExprExpecting(call.arguments.nodes[0], F64);
         return { kind: "strIntrinsic", method: "charAt", receiver, args: [idx], type: STRING, loc };
     }
-    if (name !== "hasOwnProperty" || call.arguments.length !== 1)
+    if (name !== "hasOwnProperty" || call.arguments.nodes.length !== 1)
         return null;
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (!ts.isStringLiteralLike(argNode))
         return null;
     const key = argNode.text;
@@ -3813,7 +4249,7 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
 function implicitReceiverOverloadReturn(lowerer, expr) {
     if (!ts.isCallExpression(expr) ||
         !ts.isPropertyAccessExpression(expr.expression) ||
-        expr.arguments.some(ts.isSpreadElement)) {
+        expr.arguments.nodes.some(ts.isSpreadElement)) {
         return null;
     }
     const access = expr.expression;
@@ -3828,14 +4264,14 @@ function implicitReceiverOverloadReturn(lowerer, expr) {
         return null;
     const signatures = lowerer.checker.getCallSignatures(lowerer.checker.getTypeOfSymbol(member));
     const matches = signatures.filter((signature) => {
-        const decl = lowerer.checker.signatureDeclaration(signature);
+        const decl = signature.declaration;
         if (!decl || !(ts.isFunctionDeclaration(decl) || ts.isMethodDeclaration(decl)) || decl.body) {
             return false;
         }
-        const params = decl.parameters.filter((param) => !isThisParameter(param));
+        const params = decl.parameters.nodes.filter((param) => !isThisParameter(param));
         const required = params.filter((param) => !param.questionToken && !param.initializer && !param.dotDotDotToken).length;
         const maximum = params.some((param) => param.dotDotDotToken) ? Infinity : params.length;
-        return expr.arguments.length >= required && expr.arguments.length <= maximum;
+        return expr.arguments.nodes.length >= required && expr.arguments.nodes.length <= maximum;
     });
     if (matches.length !== 1)
         return null;
@@ -3869,21 +4305,38 @@ function isSoleAbstractMethod(decl) {
     const owner = decl.parent;
     if (!ts.isClassDeclaration(owner) && !ts.isClassExpression(owner))
         return false;
-    const name = decl.name.getText();
-    return !owner.members.some((member) => member !== decl && ts.isMethodDeclaration(member) && member.name.getText() === name);
+    const name = ts.getTextOfNode(decl.name);
+    return !owner.members.nodes.some((member) => member !== decl && ts.isMethodDeclaration(member) && ts.getTextOfNode(member.name) === name);
 }
 function reconcileOverloadReturn(lowerer, expr, call) {
     const rsig = lowerer.checker.getResolvedSignature(expr);
-    const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
+    const rdecl = rsig ? rsig.declaration : undefined;
     // Nominal covariant overrides share the base's return ABI, but retain
     // their declared subclass result at the call site. Unannotated fluent
     // JS overrides use the same bridge for their proven receiver result.
     if (call.type.kind === "object" &&
         rdecl &&
         ts.isMethodDeclaration(rdecl) &&
-        (!isJsSourceFile(rdecl.getSourceFile()) || returnsOnlyThis(rdecl))) {
+        (!isJsSourceFile(ts.getSourceFileOfNode(rdecl)) || returnsOnlyThis(rdecl))) {
         call = lowerer.maybeNarrow(call, expr);
     }
+    // An override narrowed to part of its base's union return shares the
+    // union ABI; a call resolved to that override narrows the result back.
+    if (call.type.kind === "union" &&
+        rsig &&
+        rdecl &&
+        ts.isMethodDeclaration(rdecl) &&
+        lowerer.unionReturnOverrides.has(rdecl)) {
+        const declared = lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(rsig));
+        if (declared && !typeEquals(declared, call.type)) {
+            if (declared.kind !== "union") {
+                const helper = lowerer.narrowedArmHelper(call.type.unionId, declared, call.loc);
+                if (helper)
+                    return lowerer.checkedNarrowCall(helper, call, declared, call.loc);
+            }
+            return lowerer.coerceInto(expr, call, declared);
+        }
+    }
     const resolvedOverload = rsig &&
         rdecl &&
         (ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) &&
@@ -3963,7 +4416,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
     const loc = locOf(expr);
     const pieces = ts.isNoSubstitutionTemplateLiteral(expr.template)
         ? [expr.template]
-        : [expr.template.head, ...expr.template.templateSpans.map((s) => s.literal)];
+        : [expr.template.head, ...expr.template.templateSpans.nodes.map((s) => s.literal)];
     for (const p of pieces) {
         if (!templateEscapesValid(templateRawTextOf(p))) {
             lowerer.unsupported("SC1090", p, "tagged templates with invalid escape sequences (the span cooks to undefined, which the strings array cannot carry)");
@@ -3972,7 +4425,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
     const strings = () => loweredTemplateStrings(lowerer, expr, pieces.map((piece) => piece.text), loc);
     const values = ts.isNoSubstitutionTemplateLiteral(expr.template)
         ? []
-        : expr.template.templateSpans.map((s) => s.expression);
+        : expr.template.templateSpans.nodes.map((s) => s.expression);
     // Direct call of a top-level declared function — the plain-call fast
     // path with the strings array as the leading completed argument.
     if (ts.isIdentifier(expr.tag) && !lowerer.isSelfReference(expr.tag)) {
@@ -4017,7 +4470,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
     // tag throws Node's catchable "<name> is not a function" TypeError.
     let callee = lowerer.lowerExpr(expr.tag);
     if (callee.type.kind === "func" &&
-        isJsSourceFile(expr.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         lowerer.dynConvertible(callee.type)) {
         callee = { kind: "dynFrom", value: callee, type: DYN, loc };
     }
@@ -4027,7 +4480,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
             ...values.map((a) => lowerer.lowerExprExpecting(a, DYN)),
         ];
         const calleeName = ts.isPropertyAccessExpression(expr.tag) || ts.isElementAccessExpression(expr.tag)
-            ? expr.tag.getText()
+            ? ts.getTextOfNode(expr.tag)
             : ts.isIdentifier(expr.tag)
                 ? expr.tag.text
                 : "value";
@@ -4086,7 +4539,7 @@ function loweredTemplateStrings(lowerer, expr, cooked, loc, raw) {
             loc,
         })
         : null;
-    const key = `templateStringsGlobal:${loc.file}:${expr.template.getStart()}:${raw ? "checked" : "typed"}`;
+    const key = `templateStringsGlobal:${loc.file}:${ts.tokenStartOfNode(expr.template)}:${raw ? "checked" : "typed"}`;
     let getter = lowerer.valueHelpers.get(key);
     if (!getter) {
         const site = lowerer.globalsList.length;
@@ -4191,7 +4644,7 @@ function markModuleNsHandlerParams(lowerer, handler, type) {
         e = e.expression;
     if (!ts.isArrowFunction(e) && !ts.isFunctionExpression(e))
         return;
-    for (const p of e.parameters) {
+    for (const p of e.parameters.nodes) {
         if (ts.isIdentifier(p.name) && !p.dotDotDotToken && !p.initializer) {
             lowerer.moduleNsParamOverrides.set(p, type);
         }
@@ -4232,12 +4685,12 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 e.text === "undefined" &&
                 (lowerer.typeOf(e).flags & ts.TypeFlags.Undefined) !== 0));
     };
-    const passthrough = call.arguments.length === 0 ||
-        (call.arguments.length === 1 && isAbsentHandler(call.arguments[0]));
-    if (call.arguments.length !== 1 &&
+    const passthrough = call.arguments.nodes.length === 0 ||
+        (call.arguments.nodes.length === 1 && isAbsentHandler(call.arguments.nodes[0]));
+    if (call.arguments.nodes.length !== 1 &&
         !passthrough &&
-        !(member === "then" && call.arguments.length === 2)) {
-        lowerer.noLowering(`${member} with ${call.arguments.length} arguments`, call, member === "then"
+        !(member === "then" && call.arguments.nodes.length === 2)) {
+        lowerer.noLowering(`${member} with ${call.arguments.nodes.length} arguments`, call, member === "then"
             ? "the supported form takes a fulfillment handler and an optional rejection handler"
             : `the supported form takes exactly one ${member === "catch" ? "inline handler" : "callback"}`);
     }
@@ -4306,9 +4759,9 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         }
     }
     if (member === "then") {
-        if (call.arguments.length === 2) {
-            const fulfilledNode = call.arguments[0];
-            const rejectedNode = call.arguments[1];
+        if (call.arguments.nodes.length === 2) {
+            const fulfilledNode = call.arguments.nodes[0];
+            const rejectedNode = call.arguments.nodes[1];
             const fulfilledAbsent = isAbsentHandler(fulfilledNode);
             const rejectedAbsent = isAbsentHandler(rejectedNode);
             const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
@@ -4375,6 +4828,9 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 const resultOf = (value, returnsPromise = false) => {
                     if (value.type.kind === "promise")
                         return [lowerer.adoptingReturn(value, R, (e) => lowerer.coerceInto(call, e, R))];
+                    const flattened = maybePromiseHandlerResult(lowerer, call, value, R);
+                    if (flattened)
+                        return [flattened];
                     if (returnsPromise) {
                         // A boxed handler's promise result adopts too: the then job's
                         // turn after the call, then the await of the returned value.
@@ -4525,8 +4981,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         // contextual type spelled (a module-namespace type has no mapping —
         // the handle is the value's only story, isIslandExpr's local rule).
         if (inner.kind === "moduleNs")
-            markModuleNsHandlerParams(lowerer, call.arguments[0], inner);
-        let cb = lowerer.lowerExpr(call.arguments[0]);
+            markModuleNsHandlerParams(lowerer, call.arguments.nodes[0], inner);
+        let cb = lowerer.lowerExpr(call.arguments.nodes[0]);
         // A TYPED handler on a DYN-settling promise (the tracePromise
         // result's `.then((value) => ...)` — the checker's generic
         // instantiation typed the parameter, but the settled value is a
@@ -4555,7 +5011,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 if (canConvertToDyn(v.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
                     return { kind: "dynFrom", value: v, type: DYN, loc };
                 }
-                lowerer.unsupported("SC1090", call.arguments[0], `then handlers receiving '${lowerer.fmt(v.type)}' values through an untyped handler (the settled value cannot cross the checked-dynamic tree boundary)`);
+                lowerer.unsupported("SC1090", call.arguments.nodes[0], `then handlers receiving '${lowerer.fmt(v.type)}' values through an untyped handler (the settled value cannot cross the checked-dynamic tree boundary)`);
             };
             const resultT = { kind: "promise", inner: DYN };
             const fnName = `%fn${lowerer.lambdaCounter++}_then`;
@@ -4592,7 +5048,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                     value: {
                         kind: "dynCall",
                         callee: { kind: "varRef", localId: cbLocal.id, type: DYN, loc },
-                        calleeName: jsFuncNameOf(call.arguments[0], lowerer) ?? "onFulfilled",
+                        calleeName: jsFuncNameOf(call.arguments.nodes[0], lowerer) ?? "onFulfilled",
                         args: handlerArgs,
                         type: DYN,
                         loc,
@@ -4628,13 +5084,13 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             }
         }
         if (cb.type.kind !== "func" || cb.type.params.length > 1) {
-            lowerer.unsupported("SC1090", call.arguments[0], "then handlers with more than one parameter (the two-argument onRejected form has no lowering — chain .catch(...) instead)");
+            lowerer.unsupported("SC1090", call.arguments.nodes[0], "then handlers with more than one parameter (the two-argument onRejected form has no lowering — chain .catch(...) instead)");
         }
         const param = cb.type.params[0];
         if (param !== undefined &&
             !typeEquals(param, inner) &&
             !(param.kind === "dyn" && (inner.kind === "void" || lowerer.dynConvertible(inner)))) {
-            lowerer.unsupported("SC1090", call.arguments[0], `then handlers whose parameter is not the settled value's type (expected '${lowerer.fmt(inner)}', got '${lowerer.fmt(param)}')`);
+            lowerer.unsupported("SC1090", call.arguments.nodes[0], `then handlers whose parameter is not the settled value's type (expected '${lowerer.fmt(inner)}', got '${lowerer.fmt(param)}')`);
         }
         const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
         if (resultT?.kind !== "promise") {
@@ -4686,7 +5142,11 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             // The handler's result: promise returns flatten exactly like
             // `return p` in any async body (the spec's thenable adoption);
             // everything else coerces into R.
-            if (handlerCall.type.kind === "promise" && R.kind !== "promise") {
+            const flattened = maybePromiseHandlerResult(lowerer, call, handlerCall, R);
+            if (flattened) {
+                body.push(flattened);
+            }
+            else if (handlerCall.type.kind === "promise" && R.kind !== "promise") {
                 body.push(lowerer.adoptingReturn(handlerCall, R, (e) => lowerer.coerceInto(call, e, R)));
             }
             else if (R.kind === "void") {
@@ -4725,13 +5185,13 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         }
     }
     if (member === "finally") {
-        const cb = lowerer.lowerExpr(call.arguments[0]);
+        const cb = lowerer.lowerExpr(call.arguments.nodes[0]);
         if (lowerer.dynConvertible(promT) && lowerer.dynConvertible(cb.type)) {
             const result = {
                 kind: "dynInvoke",
                 recv: lowerer.coerceToExpected(receiver, DYN),
                 method: "finally",
-                calleeName: access.getText(),
+                calleeName: ts.getTextOfNode(access),
                 args: [lowerer.coerceToExpected(cb, DYN)],
                 type: DYN,
                 loc,
@@ -4739,7 +5199,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             return lowerer.coerceToExpected(result, promT);
         }
         if (cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void") {
-            lowerer.unsupported("SC1090", call.arguments[0], "finally callbacks with parameters or a return value (use () => { ... })");
+            lowerer.unsupported("SC1090", call.arguments.nodes[0], "finally callbacks with parameters or a return value (use () => { ... })");
         }
         const fnName = `%fn${lowerer.lambdaCounter++}_finally`;
         const funcType = {
@@ -4828,9 +5288,9 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     // snapshot (the dyn-then desugar's catch twin).
     if (member === "catch" &&
         (inner.kind === "dyn" ||
-            (isJsSourceFile(call.getSourceFile()) &&
+            (isJsSourceFile(ts.getSourceFileOfNode(call)) &&
                 (inner.kind === "void" || lowerer.dynConvertible(inner))))) {
-        let cb = lowerer.lowerExpr(call.arguments[0]);
+        let cb = lowerer.lowerExpr(call.arguments.nodes[0]);
         if (cb.type.kind === "func" &&
             canBoxFuncIntoDyn(cb.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
             cb = { kind: "dynFrom", value: cb, type: DYN, loc };
@@ -4875,7 +5335,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                         value: {
                             kind: "dynCall",
                             callee: { kind: "varRef", localId: cbLocal.id, type: DYN, loc },
-                            calleeName: jsFuncNameOf(call.arguments[0], lowerer) ?? "onRejected",
+                            calleeName: jsFuncNameOf(call.arguments.nodes[0], lowerer) ?? "onRejected",
                             args: [
                                 {
                                     kind: "caughtToDyn",
@@ -4924,20 +5384,20 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     }
     // .catch: the handler must be INLINE — its parameter becomes the
     // catch binding.
-    let handlerNode = call.arguments[0];
+    let handlerNode = call.arguments.nodes[0];
     while (ts.isParenthesizedExpression(handlerNode))
         handlerNode = handlerNode.expression;
     if (!ts.isArrowFunction(handlerNode) && !ts.isFunctionExpression(handlerNode)) {
-        lowerer.unsupported("SC1090", call.arguments[0], "catch handlers that are not inline function literals (the handler's parameter " +
+        lowerer.unsupported("SC1090", call.arguments.nodes[0], "catch handlers that are not inline function literals (the handler's parameter " +
             "becomes a typed-catch binding, which only an inline `(e) => ...` can receive)");
     }
-    if (handlerNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
+    if (handlerNode.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
         lowerer.unsupported("SC1090", handlerNode, "async catch handlers");
     }
-    if (handlerNode.parameters.length > 1) {
+    if (handlerNode.parameters.nodes.length > 1) {
         lowerer.unsupported("SC1090", handlerNode, "catch handlers with more than one parameter");
     }
-    const param = handlerNode.parameters[0];
+    const param = handlerNode.parameters.nodes[0];
     if (param && (!ts.isIdentifier(param.name) || param.dotDotDotToken || param.initializer)) {
         lowerer.unsupported("SC1062", param);
     }
@@ -4984,7 +5444,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             }
             const hb = handlerNode.body;
             if (ts.isBlock(hb)) {
-                catchBody = lowerer.lowerStmts(hb.statements);
+                catchBody = lowerer.lowerStmts(hb.statements.nodes);
             }
             else if (R.kind === "void") {
                 catchBody = [{ kind: "exprStmt", expr: lowerer.lowerExpr(hb), loc: locOf(hb) }];
@@ -5082,10 +5542,10 @@ export function lowerFilterNarrowCall(lowerer, call, access) {
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
-    if (call.arguments.length !== 1)
+    if (call.arguments.nodes.length !== 1)
         return null; // the generic path's arity fence
     const elem = receiverIr.elem;
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     const loc = locOf(call);
     const isBooleanArg = ts.isIdentifier(argNode) &&
         argNode.text === "Boolean" &&
@@ -5287,19 +5747,19 @@ function lowerSymbolStaticCall(lowerer, call, access) {
     const member = access.name.text;
     const loc = locOf(call);
     if (member === "for") {
-        if (call.arguments.length !== 1) {
-            lowerer.noLowering(`Symbol.for with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length !== 1) {
+            lowerer.noLowering(`Symbol.for with ${call.arguments.nodes.length} arguments`, call);
         }
-        const key = lowerer.lowerExprExpecting(call.arguments[0], STRING);
+        const key = lowerer.lowerExprExpecting(call.arguments.nodes[0], STRING);
         return { kind: "libCall", fn: "sym.for", args: [key], type: SYMBOL_T, loc };
     }
     if (member === "keyFor") {
-        if (call.arguments.length !== 1) {
-            lowerer.noLowering(`Symbol.keyFor with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length !== 1) {
+            lowerer.noLowering(`Symbol.keyFor with ${call.arguments.nodes.length} arguments`, call);
         }
-        const sym = lowerer.lowerExpr(call.arguments[0]);
+        const sym = lowerer.lowerExpr(call.arguments.nodes[0]);
         if (sym.type.kind !== "symbol") {
-            lowerer.noLowering(`Symbol.keyFor of a '${lowerer.fmt(sym.type)}' value`, call.arguments[0], "the argument must be symbol-typed");
+            lowerer.noLowering(`Symbol.keyFor of a '${lowerer.fmt(sym.type)}' value`, call.arguments.nodes[0], "the argument must be symbol-typed");
         }
         // The checker types the call `string | undefined`, which interns
         // the result union (the map.get pattern); the backend builds the
@@ -5320,12 +5780,12 @@ function lowerBigIntStaticCall(lowerer, call, access) {
     const name = access.name.text;
     if (name !== "asUintN" && name !== "asIntN")
         return null;
-    if (call.arguments.length !== 2) {
-        lowerer.noLowering(`BigInt.${name} with ${call.arguments.length} arguments`, call);
+    if (call.arguments.nodes.length !== 2) {
+        lowerer.noLowering(`BigInt.${name} with ${call.arguments.nodes.length} arguments`, call);
     }
     const loc = locOf(call);
-    const bits = lowerer.lowerExprExpecting(call.arguments[0], F64);
-    const value = lowerer.lowerExprExpecting(call.arguments[1], BIGINT_T);
+    const bits = lowerer.lowerExprExpecting(call.arguments.nodes[0], F64);
+    const value = lowerer.lowerExprExpecting(call.arguments.nodes[1], BIGINT_T);
     return {
         kind: "libCall",
         fn: name === "asUintN" ? "bigint.asUintN" : "bigint.asIntN",
@@ -5344,12 +5804,12 @@ function lowerBigIntMethodCall(lowerer, call, access) {
     const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "bigint")
         return null;
-    if (name === "valueOf" && call.arguments.length === 0)
+    if (name === "valueOf" && call.arguments.nodes.length === 0)
         return receiver;
-    if (name === "toString" && call.arguments.length <= 1) {
+    if (name === "toString" && call.arguments.nodes.length <= 1) {
         const defaultRadix = { kind: "numLit", value: 10, type: F64, loc };
-        const radix = call.arguments[0]
-            ? lowerOptionalArgument(lowerer, call.arguments[0], F64, defaultRadix)
+        const radix = call.arguments.nodes[0]
+            ? lowerOptionalArgument(lowerer, call.arguments.nodes[0], F64, defaultRadix)
             : defaultRadix;
         return { kind: "libCall", fn: "bigint.toString", args: [receiver, radix], type: STRING, loc };
     }
@@ -5367,13 +5827,13 @@ function lowerSymbolMethodCall(lowerer, call, access) {
         return null;
     const name = access.name.text;
     const loc = locOf(call);
-    if (name === "toString" && call.arguments.length === 0) {
+    if (name === "toString" && call.arguments.nodes.length === 0) {
         const receiver = lowerer.lowerExpr(access.expression);
         if (receiver.type.kind !== "symbol")
             return null;
         return { kind: "libCall", fn: "sym.toString", args: [receiver], type: STRING, loc };
     }
-    if (name === "valueOf" && call.arguments.length === 0) {
+    if (name === "valueOf" && call.arguments.nodes.length === 0) {
         const receiver = lowerer.lowerExpr(access.expression);
         if (receiver.type.kind !== "symbol")
             return null;
@@ -5390,6 +5850,7 @@ function lowerSymbolMethodCall(lowerer, call, access) {
  * for-in iterates exactly the keys Object.keys answers. */
 export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
     const resultT = arrayOf(STRING);
+    lowerer.keyOrder.observe(argIr);
     const key = `obj.keys:${argIr.shapeId}:${typeKey(resultT)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
@@ -5505,6 +5966,90 @@ function recordHasOwnHelper(lowerer, shapeId, loc) {
     });
     return helper;
 }
+/** Whether `Object.assign(instance, record)` can copy every field of the
+ * record shape into a field the class declares with the same type: a plain
+ * record (no tuple, index signature or accessor slots) and a compiled
+ * class whose chain has no builtin or runtime-provided storage and no
+ * accessor for the written names. */
+function classAssignPlan(lowerer, className, srcShapeId) {
+    const info = lowerer.classes.get(className);
+    const shape = lowerer.shapes.get(srcShapeId);
+    if (!info || !shape || shape.tuple || shape.indexValue || shapeHasAccessorSlots(shape))
+        return false;
+    for (let c = info; c; c = c.base) {
+        if (c.builtinError || c.builtinEmitter || c.builtinStream !== undefined || c.def.runtime)
+            return false;
+    }
+    return shape.fields.every((f) => {
+        const declared = info.fields.get(f.name);
+        return (declared !== undefined &&
+            (typeEquals(declared, f.type) || lowerer.widthLiftPlan(f.type, declared) !== null) &&
+            !lowerer.findMethodOn(info, f.name) &&
+            !lowerer.findMethodOn(info, `get:${f.name}`) &&
+            !lowerer.findMethodOn(info, `set:${f.name}`));
+    });
+}
+/** Interned `%obj.assignClass.<n>(o, s)` — Object.assign's per-field
+ * write of a record into a class instance (classAssignPlan's gate):
+ * optional source fields write only when present, and the instance
+ * returns. */
+function classAssignHelper(lowerer, className, srcShapeId, loc) {
+    if (!classAssignPlan(lowerer, className, srcShapeId))
+        return null;
+    const key = `obj.assignClass:${className}:${srcShapeId}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const helper = `%obj.assignClass.${lowerer.arrHofHelpers.size}`;
+    lowerer.arrHofHelpers.set(key, helper);
+    const sShape = lowerer.shapes.get(srcShapeId);
+    const oT = { kind: "object", className };
+    const sT = { kind: "record", shapeId: srcShapeId };
+    const oRef = { kind: "varRef", localId: "o.0", type: oT, loc };
+    const sRef = { kind: "varRef", localId: "s.0", type: sT, loc };
+    const body = [];
+    const info = lowerer.classes.get(className);
+    for (const f of sShape.fields) {
+        const declared = info.fields.get(f.name);
+        const read = {
+            kind: "recordGet",
+            obj: sRef,
+            shapeId: srcShapeId,
+            field: f.name,
+            type: f.type,
+            loc,
+        };
+        const lift = typeEquals(declared, f.type) ? null : lowerer.widthLiftPlan(f.type, declared);
+        const set = {
+            kind: "fieldSet",
+            obj: oRef,
+            className,
+            field: f.name,
+            value: lift === null ? read : lowerer.applyWidthLift(lift, read, declared, loc),
+            loc,
+        };
+        const present = lowerer.recordFieldPresent(sRef, srcShapeId, f.name, loc);
+        body.push(present.kind === "recordHas"
+            ? { kind: "if", cond: present, then: [set], else_: null, loc }
+            : set);
+    }
+    body.push({ kind: "return", value: oRef, loc });
+    lowerer.liftedFns.push({
+        name: helper,
+        params: [
+            { localId: "o.0", name: "o", type: oT },
+            { localId: "s.0", name: "s", type: sT },
+        ],
+        returnType: oT,
+        locals: [
+            { id: "o.0", name: "o", type: oT, mutable: true },
+            { id: "s.0", name: "s", type: sT, mutable: true },
+        ],
+        body,
+        loc,
+    });
+    return helper;
+}
 /** Interned `%obj.assign.<n>(t, s)` — Object.assign's per-field copy
  * over signature-free records (every source field lands on a same-named,
  * same-typed target field — the caller's gate): optional source fields
@@ -5519,6 +6064,7 @@ function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
     const helper = `%obj.assign.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, helper);
     const sShape = lowerer.shapes.get(srcShapeId);
+    const tShape = lowerer.shapes.get(targetShapeId);
     const tT = { kind: "record", shapeId: targetShapeId };
     const sT = { kind: "record", shapeId: srcShapeId };
     const tRef = { kind: "varRef", localId: "t.0", type: tT, loc };
@@ -5533,12 +6079,13 @@ function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
             type: f.type,
             loc,
         };
+        const targetType = tShape.fields.find((x) => x.name === f.name).type;
         const set = {
             kind: "recordSet",
             obj: tRef,
             shapeId: targetShapeId,
             field: f.name,
-            value: get,
+            value: typeEquals(targetType, f.type) ? get : lowerer.coerceToExpected(get, targetType),
             loc,
         };
         const present = lowerer.recordFieldPresent(sRef, srcShapeId, f.name, loc);
@@ -5563,17 +6110,22 @@ function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
     });
     return helper;
 }
-/** The `Iterator` global's statics (ES2025 — Iterator.from, and the
- * abstract constructor as a value): no first-class iterator objects
- * exist here, so every member fences with the working spelling named
- * instead of the generic-method fence's monomorphization wording. */
+/** The `Iterator` global's statics (ES2025): `Iterator.from` over a typed
+ * built-in iterable lowers (lowerIteratorFromCall); every other member,
+ * and other arguments, fence with the working spelling named instead of
+ * the generic-method fence's monomorphization wording. */
 function lowerIteratorStaticFence(lowerer, call, access) {
     if (!lowerer.isStdlibGlobal(access.expression, "Iterator"))
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
-    lowerer.noLowering(`Iterator.${access.name.text}`, call, "first-class iterator objects have no lowering — iterator helpers compile as one chain on an " +
-        "array iterator, consumed in place: arr.values().map(f).take(n).toArray()");
+    const from = lowerIteratorFromCall(lowerer, call, access);
+    if (from)
+        return from;
+    lowerer.noLowering(`Iterator.${access.name.text}`, call, access.name.text === "from"
+        ? "Iterator.from accepts arrays, strings, typed arrays, Sets, Maps and iterator objects such as generators"
+        : "iterator helpers apply directly to generators and to array, Map and Set iterators: " +
+            "arr.values().map(f).take(n).toArray()");
 }
 /** `RegExp.escape(s)` (ES2025) — the one RegExp static with a lowering:
  * a total string→string libCall (scr_regexp_escape). The lib pins the
@@ -5589,12 +6141,12 @@ function lowerRegExpStaticCall(lowerer, call, access) {
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
-    if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0])) {
-        lowerer.noLowering(`RegExp.escape with ${call.arguments.length} arguments`, call);
+    if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0])) {
+        lowerer.noLowering(`RegExp.escape with ${call.arguments.nodes.length} arguments`, call);
     }
-    const arg = lowerer.lowerExprExpecting(call.arguments[0], STRING);
+    const arg = lowerer.lowerExprExpecting(call.arguments.nodes[0], STRING);
     if (arg.type.kind !== "string")
-        lowerer.badType(call.arguments[0], lowerer.typeOf(call.arguments[0]));
+        lowerer.badType(call.arguments.nodes[0], lowerer.typeOf(call.arguments.nodes[0]));
     return { kind: "libCall", fn: "regexp.escape", args: [arg], type: STRING, loc: locOf(call) };
 }
 /** The composed en-US Intl.NumberFormat form: `new Intl.NumberFormat(
@@ -5626,7 +6178,7 @@ function lowerIntlNumberFormatCall(lowerer, call, access) {
             !lowerer.isStdlibGlobal(ctor.expression, "Intl")) {
             return null;
         }
-        ctorArgs = recv.arguments ?? [];
+        ctorArgs = recv.arguments?.nodes ?? [];
     }
     else {
         return null;
@@ -5647,10 +6199,10 @@ function lowerIntlNumberFormatCall(lowerer, call, access) {
             : "Intl.NumberFormat with a non-literal locale", locArg, '"en-US" (Node\'s default-build locale) is the one locale whose data the runtime embeds — ' +
             "everything else is ICU data the binary does not carry");
     }
-    if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0])) {
-        lowerer.noLowering(`Intl.NumberFormat("en-US").format with ${call.arguments.length} arguments`, call);
+    if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0])) {
+        lowerer.noLowering(`Intl.NumberFormat("en-US").format with ${call.arguments.nodes.length} arguments`, call);
     }
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     if (lowerer.mapTypeOf(lowerer.typeOf(argNode))?.kind !== "f64") {
         lowerer.noLowering(`Intl.NumberFormat("en-US").format over a '${lowerer.checker.typeToString(lowerer.typeOf(argNode))}'`, argNode, "a number argument is the lowered form (bigint and numeric-string inputs have no representation)");
     }
@@ -5693,9 +6245,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
     if ((member === "getOwnPropertyNames" ||
         member === "getOwnPropertySymbols" ||
         member === "getOwnPropertyDescriptors") &&
-        call.arguments.length === 1 &&
-        !call.arguments.some(ts.isSpreadElement)) {
-        let object = lowerer.lowerExpr(call.arguments[0]);
+        call.arguments.nodes.length === 1 &&
+        !call.arguments.nodes.some(ts.isSpreadElement)) {
+        let object = lowerer.lowerExpr(call.arguments.nodes[0]);
         if (object.type.kind === "string" ||
             object.type.kind === "f64" ||
             object.type.kind === "bool" ||
@@ -5715,11 +6267,11 @@ function lowerObjectStaticCall(lowerer, call, access) {
             };
     }
     if ((member === "getPrototypeOf" || member === "setPrototypeOf") &&
-        call.arguments.length === (member === "getPrototypeOf" ? 1 : 2) &&
-        !call.arguments.some(ts.isSpreadElement)) {
-        let object = lowerer.lowerExpr(call.arguments[0]);
+        call.arguments.nodes.length === (member === "getPrototypeOf" ? 1 : 2) &&
+        !call.arguments.nodes.some(ts.isSpreadElement)) {
+        let object = lowerer.lowerExpr(call.arguments.nodes[0]);
         if (object.type.kind === "func") {
-            const fnName = jsFuncNameOf(call.arguments[0], lowerer);
+            const fnName = jsFuncNameOf(call.arguments.nodes[0], lowerer);
             object = {
                 kind: "dynFrom",
                 value: object,
@@ -5730,7 +6282,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         }
         if (object.type.kind !== "dyn" &&
             canConvertToDyn(object.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
-            object = lowerer.coerceInto(call.arguments[0], object, DYN);
+            object = lowerer.coerceInto(call.arguments.nodes[0], object, DYN);
         if (object.type.kind === "dyn") {
             const loc = locOf(call);
             if (member === "getPrototypeOf") {
@@ -5752,7 +6304,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     ...(identityOnly ? { prototypeIdentityOnly: true } : {}),
                 };
             }
-            const prototype = lowerer.lowerExprExpecting(call.arguments[1], DYN);
+            const prototype = lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN);
             if (prototype.type.kind === "dyn")
                 return {
                     kind: "libCall",
@@ -5763,8 +6315,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 };
         }
     }
-    if (member === "getOwnPropertyDescriptor" && call.arguments.length === 2) {
-        const [receiver, key] = call.arguments;
+    if (member === "getOwnPropertyDescriptor" && call.arguments.nodes.length === 2) {
+        const [receiver, key] = call.arguments.nodes;
         if (receiver &&
             key &&
             ts.isPropertyAccessExpression(receiver) &&
@@ -5797,12 +6349,13 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // with the operands still evaluated (tsc admits any pair — Object.is
     // is (any, any) — and JS evaluates the arguments either way).
     if (member === "is") {
-        if (call.arguments.length !== 2 || call.arguments.some((a) => ts.isSpreadElement(a))) {
-            lowerer.noLowering(`Object.is with ${call.arguments.length} arguments`, call, "exactly two arguments are the lowered form (JS treats a missing one as undefined — pass it explicitly)");
+        if (call.arguments.nodes.length !== 2 ||
+            call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
+            lowerer.noLowering(`Object.is with ${call.arguments.nodes.length} arguments`, call, "exactly two arguments are the lowered form (JS treats a missing one as undefined — pass it explicitly)");
         }
         const loc = locOf(call);
-        const leftNode = call.arguments[0];
-        const rightNode = call.arguments[1];
+        const leftNode = call.arguments.nodes[0];
+        const rightNode = call.arguments.nodes[1];
         const left = lowerer.lowerExpr(leftNode);
         const right = lowerer.lowerExpr(rightNode);
         const lk = left.type.kind;
@@ -5908,18 +6461,18 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // Native checked objects retain a live prototype and can install an
     // own-property descriptor table during creation.
     if (member === "create") {
-        if (call.arguments.some((a) => ts.isSpreadElement(a))) {
+        if (call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
             lowerer.noLowering("Object.create with spread arguments", call);
         }
-        if (call.arguments.length < 1 || call.arguments.length > 2) {
-            lowerer.noLowering(`Object.create with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length < 1 || call.arguments.nodes.length > 2) {
+            lowerer.noLowering(`Object.create with ${call.arguments.nodes.length} arguments`, call);
         }
         const loc = locOf(call);
-        let protoNode = call.arguments[0];
+        let protoNode = call.arguments.nodes[0];
         while (ts.isParenthesizedExpression(protoNode))
             protoNode = protoNode.expression;
         const nullProto = protoNode.kind === ts.SyntaxKind.NullKeyword;
-        if (nullProto && call.arguments.length === 1) {
+        if (nullProto && call.arguments.nodes.length === 1) {
             return { kind: "libCall", fn: "dyn.objCreateNullProto", args: [], type: DYN, loc };
         }
         let proto = nullProto
@@ -5944,9 +6497,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
             canConvertToDyn(proto.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
             proto = lowerer.coerceInto(protoNode, proto, DYN);
         if (proto.type.kind === "dyn") {
-            if (call.arguments.length === 1)
+            if (call.arguments.nodes.length === 1)
                 return { kind: "libCall", fn: "dyn.objCreate", args: [proto], type: DYN, loc };
-            const descriptors = lowerer.lowerExprExpecting(call.arguments[1], DYN);
+            const descriptors = lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN);
             if (descriptors.type.kind === "dyn")
                 return {
                     kind: "libCall",
@@ -5964,10 +6517,10 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const prototype = lowerClassPrototypeAssign(lowerer, call);
         if (prototype)
             return prototype;
-        if (isJsSourceFile(call.getSourceFile()) &&
-            call.arguments.length > 0 &&
-            !call.arguments.some(ts.isSpreadElement)) {
-            const target = tryLowerExpression(lowerer, call.arguments[0]);
+        if (isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+            call.arguments.nodes.length > 0 &&
+            !call.arguments.nodes.some(ts.isSpreadElement)) {
+            const target = tryLowerExpression(lowerer, call.arguments.nodes[0]);
             if (target &&
                 ((target.type.kind === "func" && lowerer.dynConvertible(target.type)) ||
                     (target.type.kind === "object" && lowerer.dynConvertible(target.type)))) {
@@ -5979,7 +6532,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
                         lowerer.coerceToExpected(target, DYN),
                         {
                             kind: "dynArrLit",
-                            elems: call.arguments.slice(1).map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                            elems: call.arguments.nodes
+                                .slice(1)
+                                .map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                             type: DYN,
                             loc,
                         },
@@ -5989,6 +6544,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 };
             }
         }
+        const onError = lowerObjectAssignOntoError(lowerer, call);
+        if (onError)
+            return onError;
         const hybrid = lowerObjectAssignHybrid(lowerer, call);
         if (hybrid)
             return hybrid;
@@ -5997,15 +6555,16 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // exactly the source literal's properties, which IS the source
         // literal evaluated (both fresh, no alias can tell them apart).
         // Everything else keeps the spread hint (stdlibMemberFence).
-        if (call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
-            let target = call.arguments[0];
+        if (call.arguments.nodes.length === 2 &&
+            !call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
+            let target = call.arguments.nodes[0];
             while (ts.isParenthesizedExpression(target))
                 target = target.expression;
-            let source = call.arguments[1];
+            let source = call.arguments.nodes[1];
             while (ts.isParenthesizedExpression(source))
                 source = source.expression;
             if (ts.isObjectLiteralExpression(target) &&
-                target.properties.length === 0 &&
+                target.properties.nodes.length === 0 &&
                 ts.isObjectLiteralExpression(source)) {
                 return lowerer.lowerExpr(source);
             }
@@ -6025,22 +6584,40 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // optional field must not erase the target's value — Node copies own
         // keys only — while an explicit `k: undefined` does). Everything
         // else keeps the spread hint.
-        if (call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
-            const tProbe = tryLowerExpression(lowerer, call.arguments[0]);
-            const sProbe = tryLowerExpression(lowerer, call.arguments[1]);
+        if (call.arguments.nodes.length === 2 &&
+            !call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
+            const tProbe = tryLowerExpression(lowerer, call.arguments.nodes[0]);
+            const sProbe = tryLowerExpression(lowerer, call.arguments.nodes[1]);
             // CHECKED-DYNAMIC target and source (the JS file-scope
             // object-literal identity story): the runtime dyn copy — own
             // members of the source land on the target, which returns.
             if (tProbe?.type.kind === "dyn") {
                 const loc = locOf(call);
-                const target = lowerer.lowerExpr(call.arguments[0]);
-                const rawSource = lowerer.lowerExpr(call.arguments[1]);
-                fenceSymbolFieldCopy(lowerer, call.arguments[1], rawSource.type);
+                const target = lowerer.lowerExpr(call.arguments.nodes[0]);
+                const rawSource = lowerer.lowerExpr(call.arguments.nodes[1]);
+                fenceSymbolFieldCopy(lowerer, call.arguments.nodes[1], rawSource.type);
                 const source = lowerer.coerceToExpected(rawSource, DYN);
                 if (target.type.kind === "dyn" && source.type.kind === "dyn") {
                     return { kind: "libCall", fn: "dyn.assign", args: [target, source], type: DYN, loc };
                 }
             }
+            // A CLASS-INSTANCE target and a plain record source whose fields are
+            // all fields the class declares with the same types
+            // (`Object.assign(this, { retries: 3 })`): the per-field write into
+            // the instance, returning it — the instance mutates in place.
+            if (tProbe?.type.kind === "object" && sProbe?.type.kind === "record") {
+                const helper = classAssignPlan(lowerer, tProbe.type.className, sProbe.type.shapeId);
+                if (helper) {
+                    const loc = locOf(call);
+                    const target = lowerer.lowerExpr(call.arguments.nodes[0]);
+                    const source = lowerer.lowerExpr(call.arguments.nodes[1]);
+                    if (target.type.kind === "object" && source.type.kind === "record") {
+                        const name = classAssignHelper(lowerer, target.type.className, source.type.shapeId, loc);
+                        if (name)
+                            return { kind: "call", callee: name, args: [target, source], type: target.type, loc };
+                    }
+                }
+            }
             if (tProbe?.type.kind === "record" && sProbe?.type.kind === "record") {
                 const tShape = lowerer.shapes.get(tProbe.type.shapeId);
                 const sShape = lowerer.shapes.get(sProbe.type.shapeId);
@@ -6054,12 +6631,15 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     !shapeHasAccessorSlots(sShape) &&
                     sShape.fields.every((sf) => {
                         const tf = tShape.fields.find((x) => x.name === sf.name);
-                        return tf !== undefined && typeEquals(tf.type, sf.type);
+                        // A source value converts into a wider target field (`{ bail:
+                        // true }` into `bail?: boolean`).
+                        return (tf !== undefined &&
+                            (typeEquals(tf.type, sf.type) || lowerer.coercibleValue(sf.type, tf.type)));
                     });
                 if (ok) {
                     const loc = locOf(call);
-                    const target = lowerer.lowerExpr(call.arguments[0]);
-                    const source = lowerer.lowerExpr(call.arguments[1]);
+                    const target = lowerer.lowerExpr(call.arguments.nodes[0]);
+                    const source = lowerer.lowerExpr(call.arguments.nodes[1]);
                     if (target.type.kind === "record" && source.type.kind === "record") {
                         const helper = recordAssignHelper(lowerer, target.type.shapeId, source.type.shapeId, loc);
                         return { kind: "call", callee: helper, args: [target, source], type: target.type, loc };
@@ -6067,6 +6647,34 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 }
             }
         }
+        // `throw Object.assign(record, { extra })`: an error-shaped record given
+        // a member its type lacks, thrown at once. A fixed record cannot grow
+        // the member, so the throw carries a checked-dynamic copy of the target
+        // with the source's members added. The copy is unobservable: control
+        // leaves with the throw, so nothing on that path reads the target again.
+        {
+            let parent = call.parent;
+            while (parent && ts.isParenthesizedExpression(parent))
+                parent = parent.parent;
+            const argNodes = call.arguments.nodes;
+            if (parent &&
+                ts.isThrowStatement(parent) &&
+                argNodes.length === 2 &&
+                !argNodes.some((a) => ts.isSpreadElement(a))) {
+                const tProbe = tryLowerExpression(lowerer, argNodes[0]);
+                const sProbe = tryLowerExpression(lowerer, argNodes[1]);
+                if (tProbe?.type.kind === "record" &&
+                    lowerer.dynConvertible(tProbe.type) &&
+                    sProbe &&
+                    (sProbe.type.kind === "dyn" || lowerer.dynConvertible(sProbe.type))) {
+                    const loc = locOf(call);
+                    const target = lowerer.coerceToExpected(lowerer.lowerExpr(argNodes[0]), DYN);
+                    const source = lowerer.coerceToExpected(lowerer.lowerExpr(argNodes[1]), DYN);
+                    if (target.type.kind === "dyn" && source.type.kind === "dyn")
+                        return { kind: "libCall", fn: "dyn.assign", args: [target, source], type: DYN, loc };
+                }
+            }
+        }
         // `Object.assign(target, ...sources)` over a CHECKED-DYNAMIC target
         // — the n-ary/spread form (`Object.assign({}, ...plugins.map(p =>
         // p.options), coreOptions)`, support.js's option-table merge). The
@@ -6086,16 +6694,18 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // unobservable), or a nullish unit (Node's ToObject TypeError
         // throws at the call, catchably); aliased record targets keep the
         // fence — their identity could not survive the conversion.
-        if (call.arguments.length >= 1 && !ts.isSpreadElement(call.arguments[0])) {
-            let targetNode = call.arguments[0];
+        if (call.arguments.nodes.length >= 1 && !ts.isSpreadElement(call.arguments.nodes[0])) {
+            let targetNode = call.arguments.nodes[0];
             while (ts.isParenthesizedExpression(targetNode))
                 targetNode = targetNode.expression;
             const freshLiteralTarget = ts.isObjectLiteralExpression(targetNode);
-            const tProbe = freshLiteralTarget ? null : tryLowerExpression(lowerer, call.arguments[0]);
+            const tProbe = freshLiteralTarget
+                ? null
+                : tryLowerExpression(lowerer, call.arguments.nodes[0]);
             const tKind = tProbe?.type.kind;
             if (freshLiteralTarget || tKind === "dyn" || tKind === "nullT" || tKind === "undefinedT") {
                 const loc = locOf(call);
-                const target = lowerer.lowerExprExpecting(call.arguments[0], DYN);
+                const target = lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN);
                 if (target.type.kind === "dyn") {
                     const t = lowerer.declareHiddenLocal("%oat", DYN);
                     const p = lowerer.declareHiddenLocal("%oap", DYN);
@@ -6115,7 +6725,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     // SINGLE LAST argument; every other spread position drives
                     // the real iterator protocol, whose failure describes the
                     // value — the two runtime variants, picked here by position.
-                    const sources = call.arguments.slice(1);
+                    const sources = call.arguments.nodes.slice(1);
                     const spreadCount = sources.filter((a) => ts.isSpreadElement(a)).length;
                     let ok = true;
                     for (let i = 0; i < sources.length; i++) {
@@ -6124,6 +6734,19 @@ function lowerObjectStaticCall(lowerer, call, access) {
                         const srcNode = spread ? argNode.expression : argNode;
                         const rawSource = lowerer.lowerExpr(srcNode);
                         fenceSymbolFieldCopy(lowerer, srcNode, rawSource.type, spread);
+                        // A class instance copied into a fresh object
+                        // (`Object.assign({}, instance)`): the result is a plain
+                        // object holding the instance's own fields, never an
+                        // instance, so a result the checker types as the class has
+                        // no representation (the checked cast would throw).
+                        if (rawSource.type.kind === "object" &&
+                            freshLiteralTarget &&
+                            !ts.isExpressionStatement(call.parent)) {
+                            const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+                            if (resultT !== null && resultT.kind === "object") {
+                                lowerer.unsupported("SC1090", srcNode, `Object.assign copying a '${lowerer.fmt(rawSource.type)}' instance into a fresh object typed as the class (the copy is a plain object holding the instance's own fields, not an instance — build the object literal from the fields you need)`);
+                            }
+                        }
                         const src = lowerer.coerceToExpected(rawSource, DYN);
                         if (src.type.kind !== "dyn") {
                             ok = false;
@@ -6141,7 +6764,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
                                         args: [
                                             pRef(),
                                             src,
-                                            { kind: "strLit", value: srcNode.getText(), type: STRING, loc: argLoc },
+                                            {
+                                                kind: "strLit",
+                                                value: ts.getTextOfNode(srcNode),
+                                                type: STRING,
+                                                loc: argLoc,
+                                            },
                                         ],
                                         type: VOID,
                                         loc: argLoc,
@@ -6183,24 +6811,29 @@ function lowerObjectStaticCall(lowerer, call, access) {
         }
         return null;
     }
-    if ((member === "defineProperty" && call.arguments.length === 3) ||
-        (member === "getOwnPropertyDescriptor" && call.arguments.length === 2)) {
-        if (call.arguments.some((a) => ts.isSpreadElement(a)))
+    if ((member === "defineProperty" && call.arguments.nodes.length === 3) ||
+        (member === "getOwnPropertyDescriptor" && call.arguments.nodes.length === 2)) {
+        if (call.arguments.nodes.some((a) => ts.isSpreadElement(a)))
             return null;
-        let target = tryLowerExpression(lowerer, call.arguments[0]);
-        const targetNode = call.arguments[0];
+        let target = tryLowerExpression(lowerer, call.arguments.nodes[0]);
+        const targetNode = call.arguments.nodes[0];
         // The checker gives C.prototype the instance type, but its lowered
         // value is the shared prototype table, not an instance to unbox.
         const prototypeTarget = ts.isPropertyAccessExpression(targetNode) &&
             targetNode.name.text === "prototype" &&
             (exactClassOfReceiver(lowerer, targetNode.expression) !== null ||
                 storedClassValueType(lowerer, targetNode.expression)?.kind === "classval");
-        const declaredTarget = target?.type.kind === "dyn" && !prototypeTarget && !isJsSourceFile(targetNode.getSourceFile())
+        const declaredTarget = target?.type.kind === "dyn" &&
+            !prototypeTarget &&
+            !isJsSourceFile(ts.getSourceFileOfNode(targetNode))
             ? lowerer.mapTypeOf(lowerer.typeOf(targetNode))
             : null;
         if (target && declaredTarget && isDynTypedRefType(declaredTarget))
             target = lowerer.coerceToExpected(target, declaredTarget);
         if (target && member === "defineProperty") {
+            const field = lowerClassFieldDefine(lowerer, call, target);
+            if (field)
+                return field;
             const native = lowerClassDataDescriptor(lowerer, call, member, target);
             if (native)
                 return native;
@@ -6212,7 +6845,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             target = lowerer.coerceToExpected(target, DYN);
         }
         // Error instances share a live property table with their checked view.
-        const keyNode = call.arguments[1];
+        const keyNode = call.arguments.nodes[1];
         if (target?.type.kind === "object" &&
             target.type.className !== "%DOMException" &&
             lowerer.errorHierarchyClassOf(target.type.className) &&
@@ -6221,12 +6854,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
             target = lowerer.coerceToExpected(target, DYN);
         }
         if (target?.type.kind === "func" && lowerer.dynConvertible(target.type)) {
-            const fnName = jsFuncNameOf(call.arguments[0], lowerer);
+            const fnName = jsFuncNameOf(call.arguments.nodes[0], lowerer);
             target = {
                 kind: "dynFrom",
                 value: target,
                 type: DYN,
-                loc: locOf(call.arguments[0]),
+                loc: locOf(call.arguments.nodes[0]),
                 ...(fnName !== null ? { fnName } : {}),
             };
         }
@@ -6236,8 +6869,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
         if (!target || (target.type.kind !== "dyn" && !isUnitType(target.type) && !descriptorPrimitive))
             return null;
         if (target.type.kind !== "dyn")
-            target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments[0]) };
-        const key = lowerer.lowerExprExpecting(call.arguments[1], DYN);
+            target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments.nodes[0]) };
+        const key = lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN);
         if (key.type.kind !== "dyn")
             return null;
         if (member === "getOwnPropertyDescriptor") {
@@ -6249,7 +6882,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 loc: locOf(call),
             };
         }
-        const descriptor = lowerer.lowerExprExpecting(call.arguments[2], DYN);
+        const descriptor = lowerer.lowerExprExpecting(call.arguments.nodes[2], DYN);
         if (descriptor.type.kind !== "dyn")
             return null;
         return {
@@ -6268,12 +6901,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // The result is the target, like JS. Typed targets keep the fence:
     // static shapes have no property table to extend.
     if (member === "defineProperties" &&
-        call.arguments.length === 2 &&
-        !call.arguments.some((a) => ts.isSpreadElement(a))) {
+        call.arguments.nodes.length === 2 &&
+        !call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
         const prototype = lowerClassPrototypeDescriptors(lowerer, call, member);
         if (prototype)
             return prototype;
-        let target = tryLowerExpression(lowerer, call.arguments[0]);
+        let target = tryLowerExpression(lowerer, call.arguments.nodes[0]);
         if (target) {
             const native = lowerClassDataDescriptor(lowerer, call, member, target);
             if (native)
@@ -6286,20 +6919,20 @@ function lowerObjectStaticCall(lowerer, call, access) {
         if (target &&
             target.type.kind === "func" &&
             canBoxFuncIntoDyn(target.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-            const fnName = jsFuncNameOf(call.arguments[0], lowerer);
+            const fnName = jsFuncNameOf(call.arguments.nodes[0], lowerer);
             target = {
                 kind: "dynFrom",
                 value: target,
                 type: DYN,
-                loc: locOf(call.arguments[0]),
+                loc: locOf(call.arguments.nodes[0]),
                 ...(fnName !== null ? { fnName } : {}),
             };
         }
         if (target && isUnitType(target.type)) {
-            target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments[0]) };
+            target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments.nodes[0]) };
         }
         if (target?.type.kind === "dyn") {
-            const descs = lowerer.lowerExprExpecting(call.arguments[1], DYN);
+            const descs = lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN);
             if (descs.type.kind === "dyn") {
                 return {
                     kind: "libCall",
@@ -6313,9 +6946,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
         return null;
     }
     if (["preventExtensions", "isExtensible", "seal", "isSealed"].includes(member) &&
-        call.arguments.length === 1 &&
-        !ts.isSpreadElement(call.arguments[0])) {
-        const value = lowerer.lowerExpr(call.arguments[0]);
+        call.arguments.nodes.length === 1 &&
+        !ts.isSpreadElement(call.arguments.nodes[0])) {
+        const value = lowerer.lowerExpr(call.arguments.nodes[0]);
         if (value.type.kind === "string" ||
             value.type.kind === "f64" ||
             value.type.kind === "bool" ||
@@ -6335,6 +6968,21 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     loc,
                 };
         }
+        if (member === "preventExtensions" || member === "seal") {
+            const integrity = lowerClassIntegrity(lowerer, call, member, value);
+            if (integrity)
+                return integrity;
+        }
+        else if (isDynTypedRefType(value.type)) {
+            // The instance's checked view carries its integrity state.
+            return {
+                kind: "libCall",
+                fn: member === "isSealed" ? "dyn.isSealed" : "dyn.isExtensible",
+                args: [lowerer.coerceToExpected(value, DYN)],
+                type: BOOL,
+                loc: locOf(call),
+            };
+        }
         if (value.type.kind === "dyn") {
             const operation = {
                 preventExtensions: "dyn.preventExtensions",
@@ -6358,19 +7006,19 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // other reference can write). Primitives pass through per ES2015.
     // Aliased objects keep a fence: a later write through the original
     // reference would need the runtime frozen bit (strict mode throws).
-    if (member === "isFrozen" && call.arguments.length === 1) {
-        const value = lowerer.lowerExprExpecting(call.arguments[0], DYN);
+    if (member === "isFrozen" && call.arguments.nodes.length === 1) {
+        const value = lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN);
         return { kind: "libCall", fn: "dyn.isFrozen", args: [value], type: BOOL, loc: locOf(call) };
     }
     if (member === "freeze") {
-        if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0])) {
-            lowerer.noLowering(`Object.freeze with ${call.arguments.length} arguments`, call);
+        if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0])) {
+            lowerer.noLowering(`Object.freeze with ${call.arguments.nodes.length} arguments`, call);
         }
-        const argNode = call.arguments[0];
+        const argNode = call.arguments.nodes[0];
         let inner = argNode;
         while (ts.isParenthesizedExpression(inner) || ts.isAsExpression(inner))
             inner = inner.expression;
-        const value = isJsSourceFile(call.getSourceFile()) &&
+        const value = isJsSourceFile(ts.getSourceFileOfNode(call)) &&
             (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner))
             ? lowerer.lowerExprExpecting(argNode, DYN)
             : lowerer.lowerExpr(argNode);
@@ -6397,6 +7045,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 arm.kind === "string" ||
                 arm.kind === "symbol"))
             return value;
+        const integrity = lowerClassIntegrity(lowerer, call, "freeze", value);
+        if (integrity)
+            return integrity;
         lowerer.noLowering("Object.freeze of a possibly-aliased value", call, "freeze of a FRESH object/array literal (and of primitives) compiles — frozen-ness is unobservable there; an aliased target's later writes would need the runtime frozen bit");
     }
     // `Object.hasOwn(r, k)` over a RECORD receiver: a record's own-key set
@@ -6408,10 +7059,10 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // records additionally probe the overflow map; non-record receivers
     // do too.
     if (member === "hasOwn" &&
-        call.arguments.length === 2 &&
-        !call.arguments.some((a) => ts.isSpreadElement(a))) {
-        const recvNode = call.arguments[0];
-        const keyNode = call.arguments[1];
+        call.arguments.nodes.length === 2 &&
+        !call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
+        const recvNode = call.arguments.nodes[0];
+        const keyNode = call.arguments.nodes[1];
         const probed = tryLowerExpression(lowerer, recvNode);
         const arrayKey = probed?.type.kind === "array" ? lowerer.lowerExpr(keyNode) : null;
         if (probed?.type.kind === "array" && arrayKey?.type.kind === "f64") {
@@ -6470,9 +7121,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     if (member !== "keys" && member !== "values" && member !== "entries")
         return null;
-    if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0]))
+    if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0]))
         return null;
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     // util.types and node:util/types list Node's pinned key census
     // (UTIL_TYPES_KEYS): the object's own keys in Node's order, or the module
     // namespace's export names sorted with "default". values/entries would
@@ -6487,7 +7138,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             ? lowerer.checker.getSymbolAtLocation(argNode)
             : undefined;
         const namespace = symbol
-            ? lowerer.checker.declarationsOf(symbol).some((decl) => ts.isNamespaceImport(decl))
+            ? symbol.declarations.some((decl) => ts.isNamespaceImport(decl))
             : false;
         const names = namespace ? [...UTIL_TYPES_KEYS, "default"].sort() : UTIL_TYPES_KEYS;
         const loc = locOf(call);
@@ -6562,7 +7213,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 probed.type.kind === "f64" ||
                 probed.type.kind === "bool");
         const isJsUnion = probed?.type.kind === "union" &&
-            isJsSourceFile(call.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(call)) &&
             lowerer.dynConvertible(probed.type);
         if (isDyn ||
             isPrimitive ||
@@ -6581,7 +7232,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             // entries as a native [string, any][]: the checker keeps every later
             // write to the arrays well typed. JavaScript may store anything into
             // them, so it keeps the checked-dynamic arrays.
-            const resultT = member !== "values" && !isJsSourceFile(call.getSourceFile())
+            const resultT = member !== "values" && !isJsSourceFile(ts.getSourceFileOfNode(call))
                 ? lowerer.mapTypeOf(lowerer.typeOf(call))
                 : null;
             if (member === "keys" && resultT?.kind === "array" && resultT.elem.kind === "string")
@@ -6604,7 +7255,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
             // program only iterates or indexes the result, or passes it to a
             // read-only array method, a native vector of the checked values skips
             // building that array and, for for-of, the iterator protocol.
-            if (member === "values" && !isJsSourceFile(call.getSourceFile()) && consumesValueList(call))
+            if (member === "values" &&
+                !isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+                consumesValueList(call))
                 return {
                     kind: "libCall",
                     fn: "dyn.objValueList",
@@ -6639,7 +7292,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     const enumerationType = lowerer.mapTypeOf(lowerer.typeOf(call));
     if ((member === "values" || member === "entries") &&
         (enumerationType?.kind === "dyn" ||
-            (enumerationType === null && isJsSourceFile(call.getSourceFile())))) {
+            (enumerationType === null && isJsSourceFile(ts.getSourceFileOfNode(call))))) {
         let receiver = lowerer.coerceToExpected(lowerer.lowerExpr(argNode), DYN);
         if (receiver.type.kind !== "dyn")
             lowerer.badType(argNode, lowerer.typeOf(argNode));
@@ -6707,6 +7360,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             lowerer.badType(call, lowerer.typeOf(call));
         valueT = tupleShape.fields.find((f) => f.name === "1").type;
     }
+    lowerer.keyOrder.observe(argIr);
     const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
@@ -7011,19 +7665,19 @@ function lowerObjectAssignHybrid(lowerer, call) {
     const callField = shape?.fields.find((f) => f.name === "%call");
     if (!shape || !callField || callField.type.kind !== "func")
         return null;
-    if (call.arguments.length < 2 || call.arguments.some((a) => ts.isSpreadElement(a)))
+    if (call.arguments.nodes.length < 2 || call.arguments.nodes.some((a) => ts.isSpreadElement(a)))
         return null;
     const loc = locOf(call);
     const values = new Map();
-    values.set("%call", lowerer.lowerExprExpecting(call.arguments[0], callField.type));
-    for (const argNode of call.arguments.slice(1)) {
+    values.set("%call", lowerer.lowerExprExpecting(call.arguments.nodes[0], callField.type));
+    for (const argNode of call.arguments.nodes.slice(1)) {
         let src = argNode;
         while (ts.isParenthesizedExpression(src) || ts.isAsExpression(src) || ts.isTypeAssertion(src))
             src = src.expression;
         if (!ts.isObjectLiteralExpression(src)) {
             lowerer.unsupported("SC1090", argNode, "Object.assign sources other than plain object literals when building a function-with-properties value");
         }
-        for (const prop of src.properties) {
+        for (const prop of src.properties.nodes) {
             const nameOk = (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) &&
                 (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name));
             if (!nameOk) {
@@ -7055,6 +7709,25 @@ function lowerObjectAssignHybrid(lowerer, call) {
     }
     return { kind: "recordLit", fields, type: mapped, loc };
 }
+/** The accessed member is an overload set (isOverloadedCallableMemberType),
+ * also under an optional chain whose access still spells `| undefined`. */
+function isOverloadedMemberAccess(lowerer, access) {
+    return isOverloadedCallableMemberType(lowerer.checker.getNonNullableType(lowerer.typeOf(access)), lowerer.checker);
+}
+/** The result type of the overload a call through an overloaded member
+ * resolved to: the erased slot's result converts to it. A non-generic
+ * overload answers through its declaration, because the resolved signature
+ * of an optional-chain call (`api?.m(x)`) also carries the chain's
+ * undefined; a generic one answers through its instantiation. */
+function resolvedOverloadResultType(lowerer, call) {
+    const { checker } = lowerer;
+    const signature = checker.getResolvedSignature(call);
+    const decl = signature ? signature.declaration : undefined;
+    const declared = decl ? checker.getSignatureFromDeclaration(decl) : undefined;
+    const source = declared && declared.getTypeParameters().length === 0 ? declared : signature;
+    const result = source ? lowerer.mapTypeOf(checker.getReturnTypeOfSignature(source)) : null;
+    return result ?? lowerer.irTypeOf(call);
+}
 export function lowerRecordFieldCall(lowerer, call, access) {
     if (lowerer.chainBlocked(call))
         return null;
@@ -7080,11 +7753,22 @@ export function lowerRecordFieldCall(lowerer, call, access) {
         if (callee?.type.kind !== "func")
             return null;
         const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
-        return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(call) };
+        const value = {
+            kind: "callValue",
+            callee,
+            args,
+            type: callee.type.ret,
+            loc: locOf(call),
+        };
+        // An overloaded member's erased result converts to the resolved
+        // overload's type, as on a single record receiver below.
+        return isOverloadedMemberAccess(lowerer, access)
+            ? lowerer.coerceInto(call, value, resolvedOverloadResultType(lowerer, call))
+            : value;
     }
     const target = lowerer.fieldTarget(access);
     const loc = locOf(call);
-    const receiverLocal = target && isJsSourceFile(call.getSourceFile())
+    const receiverLocal = target && isJsSourceFile(ts.getSourceFileOfNode(call))
         ? lowerer.declareHiddenLocal("%callReceiver", target.obj.type)
         : null;
     const init = target && receiverLocal
@@ -7105,10 +7789,10 @@ export function lowerRecordFieldCall(lowerer, call, access) {
     // TypeScript reaches here for callable library types that are checked
     // values (util.DebugLogger).
     if (callee.type.kind === "dyn" &&
-        (isJsSourceFile(call.getSourceFile()) ||
+        (isJsSourceFile(ts.getSourceFileOfNode(call)) ||
             lowerer.checker.getCallSignatures(lowerer.typeOf(access)).length > 0)) {
         const receiver = target && receiverLocal ? lowerer.coerceToExpected(target.obj, DYN) : undefined;
-        const spread = call.arguments.some(ts.isSpreadElement)
+        const spread = call.arguments.nodes.some(ts.isSpreadElement)
             ? lowerSpreadArgsCall(lowerer, call, callee, loc)
             : null;
         if (spread && spread.kind !== "dynCall")
@@ -7121,24 +7805,48 @@ export function lowerRecordFieldCall(lowerer, call, access) {
                 kind: "dynCall",
                 callee,
                 ...(receiver ? { receiver } : {}),
-                calleeName: access.getText(),
-                args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                calleeName: ts.getTextOfNode(access),
+                args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                 type: DYN,
                 loc,
             };
         return init ? { kind: "seqExpr", stmts: [init], result, type: result.type, loc } : result;
     }
+    // An optional callback field the checker narrowed at this call
+    // (`o.cb ? o.cb(x) : …`, `if (o.cb) o.cb(x)`): extract the func arm.
+    if (callee.type.kind === "union")
+        callee = lowerer.maybeNarrow(callee, access);
     if (callee.type.kind !== "func")
         lowerer.badType(access, lowerer.typeOf(access));
+    // JavaScript passes the record as `this`. A record with no dynamic form
+    // cannot be that receiver; the library's own function fields (the
+    // resolve/reject of Promise.withResolvers) never read it.
+    let receiver;
+    if (target && receiverLocal) {
+        if (lowerer.dynConvertible(target.obj.type)) {
+            receiver = lowerer.coerceToExpected(target.obj, DYN);
+        }
+        else if (!lowerer.isStdlibMember(access)) {
+            lowerer.unsupported("SC1090", call, `calling a function field of a '${lowerer.fmt(target.obj.type)}' record (the record has no dynamic form to pass as 'this')`);
+        }
+    }
     const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
-    const result = {
+    let result = {
         kind: "callValue",
         callee,
-        ...(target && receiverLocal ? { receiver: lowerer.coerceToExpected(target.obj, DYN) } : {}),
+        ...(receiver ? { receiver } : {}),
         args,
         type: callee.type.ret,
         loc,
     };
+    // A generic member's field holds its erased instance, and an overloaded
+    // member's field its erased function (the overloads joined): the result
+    // converts to this call's instantiated or resolved return type.
+    const memberType = lowerer.typeOf(access);
+    if (isGenericCallableMemberType(memberType, lowerer.checker))
+        result = lowerer.coerceInto(call, result, lowerer.irTypeOf(call));
+    else if (isOverloadedMemberAccess(lowerer, access))
+        result = lowerer.coerceInto(call, result, resolvedOverloadResultType(lowerer, call));
     return init ? { kind: "seqExpr", stmts: [init], result, type: result.type, loc } : result;
 }
 /** `o.m(args)` where `m` is an object-literal GENERIC method (own type
@@ -7164,12 +7872,12 @@ function lowerUrlStaticCall(lowerer, call, callee) {
     if (!ts.isIdentifier(callee.expression))
         return null;
     const sym = lowerer.resolveValueSymbol(callee.expression);
-    if (!sym || !lowerer.isStdlibSymbol(sym) || sym.name !== "URL")
+    if (!sym || !lowerer.isStdlibSymbol(sym) || ts.symbolName(sym) !== "URL")
         return null;
     if (callee.name.text === "canParse" || callee.name.text === "parse") {
         return lowerUrlFactory(lowerer, call, callee.name.text);
     }
-    if (callee.name.text !== "revokeObjectURL" || call.arguments.length !== 0)
+    if (callee.name.text !== "revokeObjectURL" || call.arguments.nodes.length !== 0)
         return null;
     return nodeThrowExpr(1, "ERR_MISSING_ARGS", 'The "url" argument must be specified', VOID, locOf(call));
 }
@@ -7191,7 +7899,7 @@ function arrowSignatureOf(lowerer, node) {
     const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(node));
     if (signatures.length !== 1)
         return null;
-    const declaration = lowerer.checker.signatureDeclaration(signatures[0]);
+    const declaration = signatures[0].declaration;
     return declaration !== undefined && ts.isArrowFunction(declaration) ? signatures[0] : null;
 }
 /** An inline arrow has lexical `this` and no observable own properties
@@ -7200,8 +7908,8 @@ function arrowSignatureOf(lowerer, node) {
  * other receivers and rest/preset-argument forms on the named fence. */
 function lowerInlineArrowBind(lowerer, call, access) {
     if (access.name.text !== "bind" ||
-        call.arguments.length > 1 ||
-        call.arguments.some(ts.isSpreadElement))
+        call.arguments.nodes.length > 1 ||
+        call.arguments.nodes.some(ts.isSpreadElement))
         return null;
     let arrow = access.expression;
     while (ts.isParenthesizedExpression(arrow))
@@ -7215,8 +7923,8 @@ function lowerInlineArrowBind(lowerer, call, access) {
         return null;
     const type = callee.type;
     const loc = locOf(call);
-    const firstDefault = arrow.parameters.findIndex((p) => p.initializer !== undefined);
-    const length = firstDefault < 0 ? arrow.parameters.length : firstDefault;
+    const firstDefault = arrow.parameters.nodes.findIndex((p) => p.initializer !== undefined);
+    const length = firstDefault < 0 ? arrow.parameters.nodes.length : firstDefault;
     const key = `arrow.bind:${typeKey(type)}:${length}`;
     const existing = lowerer.arrHofHelpers.get(key);
     const name = existing ?? `%arrow.bind.${lowerer.arrHofHelpers.size}`;
@@ -7309,8 +8017,8 @@ function lowerInlineArrowBind(lowerer, call, access) {
     const stmts = [{ kind: "varDecl", localId: saved.id, init: callee, loc }];
     // The receiver is ignored by the arrow, but its effects and throws
     // happen after creating the arrow and before returning the bound value.
-    if (call.arguments[0])
-        stmts.push(lowerer.lowerExprStatement(call.arguments[0]));
+    if (call.arguments.nodes[0])
+        stmts.push(lowerer.lowerExprStatement(call.arguments.nodes[0]));
     const result = {
         kind: "call",
         callee: name,
@@ -7325,8 +8033,8 @@ function lowerInlineArrowBind(lowerer, call, access) {
  * parameters validate from the dynamic array in order. */
 function lowerArrowFunctionApply(lowerer, call, access) {
     if (access.name.text !== "apply" ||
-        call.arguments.length !== 2 ||
-        call.arguments.some(ts.isSpreadElement) ||
+        call.arguments.nodes.length !== 2 ||
+        call.arguments.nodes.some(ts.isSpreadElement) ||
         arrowSignatureOf(lowerer, access.expression) === null) {
         return null;
     }
@@ -7336,7 +8044,7 @@ function lowerArrowFunctionApply(lowerer, call, access) {
     if (!callee.type.params.every((param) => canDynCheckTo(param, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))) {
         return null;
     }
-    const argsList = lowerer.lowerExpr(call.arguments[1]);
+    const argsList = lowerer.lowerExpr(call.arguments.nodes[1]);
     if (argsList.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
@@ -7344,7 +8052,7 @@ function lowerArrowFunctionApply(lowerer, call, access) {
     const savedArgs = lowerer.declareHiddenLocal("%applyArgs", DYN);
     const stmts = [
         { kind: "varDecl", localId: savedCallee.id, init: callee, loc },
-        { kind: "exprStmt", expr: lowerer.lowerExpr(call.arguments[0]), loc },
+        { kind: "exprStmt", expr: lowerer.lowerExpr(call.arguments.nodes[0]), loc },
         { kind: "varDecl", localId: savedArgs.id, init: argsList, loc },
     ];
     const args = callee.type.params.map((param, index) => {
@@ -7355,7 +8063,7 @@ function lowerArrowFunctionApply(lowerer, call, access) {
             type: DYN,
             loc,
         };
-        return lowerer.coerceInto(call.arguments[1], read, param);
+        return lowerer.coerceInto(call.arguments.nodes[1], read, param);
     });
     const invoked = {
         kind: "callValue",
@@ -7391,7 +8099,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
         lowerer.mapTypeOf(lowerer.typeOf(access.expression.expression))?.kind === "searchParams" &&
         SP_BRAND_METHODS.has(access.expression.name.text) &&
         lowerer.isStdlibMember(access.expression)) {
-        const thisArg = call.arguments[0];
+        const thisArg = call.arguments.nodes[0];
         const thisT = thisArg
             ? lowerer.mapTypeOf(lowerer.typeOf(thisArg))
             : { kind: "undefinedT" };
@@ -7411,7 +8119,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
     const propSym = lowerer.checker.getPropertyOfType(recvT, name);
     if (!propSym)
         return null;
-    const propertyDecl = lowerer.checker.valueDeclarationOf(propSym);
+    const propertyDecl = propSym.valueDeclaration;
     if (propertyDecl &&
         ts.isShorthandPropertyAssignment(propertyDecl) &&
         ts.isIdentifier(propertyDecl.name) &&
@@ -7431,9 +8139,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
     // CLASS members belong to the class path (lowerClassGenericMethodCall
     // claimed compilable ones; a class that failed collection keeps its
     // own diagnostics and the generic method-call fence downstream).
-    if (lowerer.checker
-        .declarationsOf(propSym)
-        .some((d) => d.parent !== undefined &&
+    if (propSym.declarations.some((d) => d.parent !== undefined &&
         (ts.isClassDeclaration(d.parent) || ts.isClassExpression(d.parent)))) {
         return null;
     }
@@ -7470,19 +8176,19 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
             const value = tryLowerExpression(lowerer, access.expression);
             if (value?.type.kind === "func" &&
                 lowerer.dynConvertible(value.type) &&
-                !call.arguments.some(ts.isSpreadElement)) {
+                !call.arguments.nodes.some(ts.isSpreadElement)) {
                 const loc = locOf(call);
                 return {
                     kind: "dynInvoke",
                     recv: { kind: "dynFrom", value, type: DYN, loc },
                     method: name,
-                    calleeName: access.getText(),
-                    args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    calleeName: ts.getTextOfNode(access),
+                    args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
                 };
             }
-            lowerer.unsupported("SC1090", call, `Function.prototype.${name} on a function whose signature cannot cross the checked-value boundary (call '${access.expression.getText()}(...)' directly)`);
+            lowerer.unsupported("SC1090", call, `Function.prototype.${name} on a function whose signature cannot cross the checked-value boundary (call '${ts.getTextOfNode(access.expression)}(...)' directly)`);
         }
         // STANDARD-LIBRARY generic members (Promise.then, Object.
         // defineProperty, Array-augmentation methods) are the lib fence's
@@ -7495,9 +8201,27 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
         // receiver's runtime class must be provable — name that discipline
         // instead of the object-literal wording when the method lives on an
         // interface.
-        const onInterface = lowerer.checker
-            .declarationsOf(propSym)
-            .some((d) => d.parent !== undefined && ts.isInterfaceDeclaration(d.parent));
+        const onInterface = propSym.declarations.some((d) => d.parent !== undefined && ts.isInterfaceDeclaration(d.parent));
+        // A receiver held as a checked-dynamic value (a class-backed interface)
+        // dispatches by name to the runtime object's member, which a generic
+        // method answers with its erased instance; the result converts to this
+        // call's instantiated return type.
+        if (onInterface && !call.arguments.nodes.some(ts.isSpreadElement)) {
+            const receiver = lowerer.lowerExpr(access.expression);
+            if (receiver.type.kind === "dyn") {
+                const loc = locOf(call);
+                const invoked = {
+                    kind: "dynInvoke",
+                    recv: receiver,
+                    method: name,
+                    calleeName: ts.getTextOfNode(access),
+                    args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    type: DYN,
+                    loc,
+                };
+                return lowerer.coerceInto(call, invoked, lowerer.irTypeOf(call));
+            }
+        }
         if (onInterface) {
             lowerer.unsupported("SC1090", call, `calls of the generic method '${name}' through this receiver (the interface declaration is signature-only and generic methods dispatch statically, so the receiver's runtime class must be provable — bind the receiver to a const initialized with its 'new' expression, e.g. 'const r: ${lowerer.checker.typeToString(recvT)} = new C(...)')`);
         }
@@ -7507,7 +8231,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
     const info = objLitGenericFnInfoOf(lowerer, call, name, found);
     const instance = genericCallInstance(lowerer, call, info);
     const loc = locOf(call);
-    const args = lowerer.completeArgs(call.arguments, instance.params, loc, call);
+    const args = lowerer.completeArgs(call.arguments.nodes, instance.params, loc, call);
     return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
 }
 /** `obj.method(args)` — whole-program devirtualization decides the form:
@@ -7519,7 +8243,17 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
 export function lowerObjectMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
-    let mappedReceiver = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let mappedReceiver = lowerer.receiverTypeOverrides.get(access.expression) ??
+        structuralReadType(lowerer, access.expression) ??
+        lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    // EventEmitter's static side (the class, a value of it, or the events
+    // module, which is the class) keeps its static surface on the emitter
+    // dispatch (`EventEmitter.setMaxListeners(n)`), which tells the statics
+    // apart by the receiver's construct signatures. The stream classes
+    // inherit the same statics.
+    if (mappedReceiver?.kind === "classval" && mappedReceiver.className === RUNTIME_EMITTER_CLASS) {
+        mappedReceiver = { kind: "object", className: RUNTIME_EMITTER_CLASS };
+    }
     // A specialized JS parameter can expose a native field whose checker
     // type still belongs to the unspecialized body (plane.normal.dot()).
     // Use the lowered receiver's representation and retain its evaluation.
@@ -7527,7 +8261,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         (lowerer.implicitParamTypes !== null ||
             lowerer.classImplementedProtocol(lowerer.typeOf(access.expression)) ||
             ts.isNewExpression(access.expression) ||
-            isJsSourceFile(call.getSourceFile()))
+            isJsSourceFile(ts.getSourceFileOfNode(call)))
         ? ts.isNewExpression(access.expression)
             ? lowerer.lowerExpr(access.expression)
             : tryLowerExpression(lowerer, access.expression)
@@ -7545,7 +8279,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         if (dispatched)
             return dispatched;
         const arms = lowerer.unions.get(mappedReceiver.unionId)?.arms;
-        if (isJsSourceFile(call.getSourceFile()) &&
+        if (isJsSourceFile(ts.getSourceFileOfNode(call)) &&
             arms?.every((arm) => arm.kind === "object" && !lowerer.classes.get(arm.className)?.def.runtime) &&
             lowerer.dynConvertible(mappedReceiver)) {
             return lowerDynReceiverMethodCall(lowerer, call, access);
@@ -7615,7 +8349,13 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     // The EventEmitter surface: API-named calls on emitter-rooted
     // receivers lower through the emitter spoke (subclass members with
     // these names are fenced at collection, so `found` never shadows).
-    if (info && !found && EMITTER_API_MEMBERS.has(access.name.text) && emitterRooted(lowerer, info)) {
+    if (info &&
+        !found &&
+        (EMITTER_API_MEMBERS.has(access.name.text) ||
+            // A static with no instance twin (events.getEventListeners).
+            (access.name.text === "getEventListeners" &&
+                lowerer.checker.getConstructSignatures(lowerer.typeOf(access.expression)).length > 0)) &&
+        emitterRooted(lowerer, info)) {
         return lowerEmitterMethodCall(lowerer, call, access, info);
     }
     // The inherited EventTarget/Event methods of a class rooted at those
@@ -7674,7 +8414,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             let callee = target ? lowerer.fieldGetExpr(target, locOf(access), access) : null;
             if (callee?.type.kind === "union" && callableType !== null) {
                 // Calling a cleared callback field throws Node's call TypeError.
-                const inPlace = checkedArmExtraction(lowerer, callee, lowerer.armTag(callee.type.unionId, callableType), callableType, () => `${access.getText()} is not a function`);
+                const inPlace = checkedArmExtraction(lowerer, callee, lowerer.armTag(callee.type.unionId, callableType), callableType, () => `${ts.getTextOfNode(access)} is not a function`);
                 const helper = inPlace
                     ? null
                     : lowerer.narrowedArmHelper(callee.type.unionId, callableType, locOf(access));
@@ -7686,19 +8426,19 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             }
             if (callee?.type.kind === "func") {
                 if (((callee.type.rest === true && callee.type.restAbi === undefined) ||
-                    call.arguments.length > callee.type.params.length) &&
-                    isJsSourceFile(call.getSourceFile()) &&
+                    call.arguments.nodes.length > callee.type.params.length) &&
+                    isJsSourceFile(ts.getSourceFileOfNode(call)) &&
                     lowerer.dynConvertible(callee.type)) {
                     const boxed = { kind: "dynFrom", value: callee, type: DYN, loc };
                     const spread = lowerSpreadArgsCall(lowerer, call, boxed, loc);
                     if (spread?.kind === "dynCall")
                         return finish({ ...spread, ...receiver });
-                    const args = call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+                    const args = call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
                     return finish({
                         kind: "dynCall",
                         callee: boxed,
                         ...receiver,
-                        calleeName: access.getText(),
+                        calleeName: ts.getTextOfNode(access),
                         args,
                         type: DYN,
                         loc,
@@ -7708,15 +8448,15 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 return finish({ kind: "callValue", callee, ...receiver, args, type: callee.type.ret, loc });
             }
             if (callee?.type.kind === "dyn") {
-                if (call.arguments.some((a) => ts.isSpreadElement(a))) {
+                if (call.arguments.nodes.some((a) => ts.isSpreadElement(a))) {
                     lowerer.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
                 }
-                const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
+                const args = call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN));
                 return finish({
                     kind: "dynCall",
                     callee,
                     ...receiver,
-                    calleeName: access.getText(),
+                    calleeName: ts.getTextOfNode(access),
                     args,
                     type: DYN,
                     loc,
@@ -7724,7 +8464,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             }
         }
         if (!fieldType &&
-            isJsSourceFile(call.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(call)) &&
             !info.def.runtime &&
             !info.builtinError &&
             !info.builtinEmitter &&
@@ -7741,7 +8481,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 type: DYN,
                 loc,
             };
-            const spread = call.arguments.some(ts.isSpreadElement)
+            const spread = call.arguments.nodes.some(ts.isSpreadElement)
                 ? lowerSpreadArgsCall(lowerer, call, callee, loc)
                 : null;
             if (spread && spread.kind !== "dynCall")
@@ -7752,8 +8492,8 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     kind: "dynCall",
                     callee,
                     receiver,
-                    calleeName: access.getText(),
-                    args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                    calleeName: ts.getTextOfNode(access),
+                    args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
                 };
@@ -7775,7 +8515,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         const receiver = lowerReceiver();
         const local = lowerer.declareHiddenLocal("%callbackReceiver", receiver.type);
         const value = { kind: "varRef", localId: local.id, type: receiver.type, loc };
-        const args = lowerer.completeArgs(call.arguments, found.sig.params, loc, call);
+        const args = lowerer.completeArgs(call.arguments.nodes, found.sig.params, loc, call);
         const virtual = lowerer.overrideBelow(info, method);
         if (virtual)
             lowerer.noteVirtualEdge(info, method);
@@ -7797,7 +8537,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 type: found.sig.ret,
                 loc,
             };
-        const result = classCallbackCall(lowerer, value, method, call.arguments, fallback, loc, access.getText());
+        const result = classCallbackCall(lowerer, value, method, call.arguments.nodes, fallback, loc, ts.getTextOfNode(access));
         return {
             kind: "seqExpr",
             stmts: [{ kind: "varDecl", localId: local.id, init: receiver, loc }],
@@ -7818,12 +8558,34 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     if (found.sig.abstract === true && !lowerer.overrideBelow(info, method)) {
         lowerer.unsupported("SC1090", call, `calls of the abstract method '${method}' with no concrete implementation below the receiver's static class`);
     }
+    // The static receiver's nearest declaration is an override adapted to
+    // the inherited ABI, and nothing below overrides it: call its body
+    // directly under its declared signature (exact parameters and result).
+    // The slot function stays reachable; it lifts the body.
+    const adapted = found.declarer.returnAdapters?.get(method);
+    // A TypeScript override's own entry answers its declared result. A
+    // JavaScript body's result is inferred, so its callers keep the slot.
+    const declarerDecl = found.declarer.decl;
+    if (adapted &&
+        !(declarerDecl && isJsSourceFile(ts.getSourceFileOfNode(declarerDecl))) &&
+        !lowerer.overrideBelow(info, method)) {
+        lowerer.noteEdge(`%${found.declarer.def.name}.${method}`);
+        const receiver = lowerReceiver();
+        const args = lowerer.completeArgs(call.arguments.nodes, adapted.params, locOf(call), call);
+        return {
+            kind: "call",
+            callee: `%${found.declarer.def.name}.${method}$own`,
+            args: [lowerer.upcastTo(receiver, found.declarer.def.name), ...args],
+            type: adapted.ret,
+            loc: locOf(call),
+        };
+    }
     if (lowerer.overrideBelow(info, method))
         lowerer.noteVirtualEdge(info, method);
     else
         lowerer.noteEdge(`%${found.declarer.def.name}.${method}`);
     const receiver = lowerReceiver();
-    const args = lowerer.completeArgs(call.arguments, found.sig.params, locOf(call), call);
+    const args = lowerer.completeArgs(call.arguments.nodes, found.sig.params, locOf(call), call);
     if (lowerer.overrideBelow(info, method)) {
         return reconcileOverloadReturn(lowerer, call, {
             kind: "virtualCall",
@@ -7877,7 +8639,7 @@ function lowerUnionObjectMethodCall(lowerer, call, access, receiverT) {
             type: DYN,
             loc,
         };
-        const spread = call.arguments.some(ts.isSpreadElement)
+        const spread = call.arguments.nodes.some(ts.isSpreadElement)
             ? lowerSpreadArgsCall(lowerer, call, callee, loc)
             : null;
         if (spread && spread.kind !== "dynCall")
@@ -7888,8 +8650,8 @@ function lowerUnionObjectMethodCall(lowerer, call, access, receiverT) {
                 kind: "dynCall",
                 callee,
                 receiver,
-                calleeName: access.getText(),
-                args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+                calleeName: ts.getTextOfNode(access),
+                args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                 type: DYN,
                 loc,
             };
@@ -7917,7 +8679,7 @@ function lowerUnionObjectMethodCall(lowerer, call, access, receiverT) {
         return null;
     const loc = locOf(call);
     const receiver = lowerer.coerceInto(access.expression, lowerer.lowerExpr(access.expression), receiverT);
-    const args = lowerer.completeArgs(call.arguments, shapes, loc, call);
+    const args = lowerer.completeArgs(call.arguments.nodes, shapes, loc, call);
     const helper = unionObjectMethodHelper(lowerer, call, receiverT, method, plans, shapes, resultT, loc);
     return { kind: "call", callee: helper, args: [receiver, ...args], type: resultT, loc };
 }
@@ -7949,7 +8711,7 @@ function lowerUnionObjectDynFieldCall(lowerer, call, access, receiverT) {
             return null;
         plans.push({ arm, info });
     }
-    if (call.arguments.some(ts.isSpreadElement)) {
+    if (call.arguments.nodes.some(ts.isSpreadElement)) {
         lowerer.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
     }
     const loc = locOf(call);
@@ -8017,7 +8779,7 @@ function lowerUnionObjectDynFieldCall(lowerer, call, access, receiverT) {
         lowerer.liftedFns.push({ name: helper, params, returnType: DYN, locals, body, loc });
     }
     const callee = { kind: "call", callee: helper, args: [receiverRef], type: DYN, loc };
-    const args = call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+    const args = call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
     return {
         kind: "seqExpr",
         stmts: [{ kind: "varDecl", localId: receiverLocal.id, init: receiver, loc }],
@@ -8025,7 +8787,7 @@ function lowerUnionObjectDynFieldCall(lowerer, call, access, receiverT) {
             kind: "dynCall",
             callee,
             receiver: lowerer.coerceToExpected(receiverRef, DYN),
-            calleeName: access.getText(),
+            calleeName: ts.getTextOfNode(access),
             args,
             type: DYN,
             loc,
@@ -8041,6 +8803,18 @@ function unionObjectMethodHelper(lowerer, sourceCall, receiverT, method, plans,
         return existing;
     const name = `%union.call.${lowerer.unionCallHelpers.size}`;
     lowerer.unionCallHelpers.set(key, name);
+    // A probe that catches a refusal while the body lowers must not leave
+    // the name registered for a helper that was never emitted.
+    try {
+        lowerer.liftedFns.push(unionObjectMethodFunction(lowerer, name, sourceCall, receiverT, method, plans, shapes, resultT, loc));
+    }
+    catch (e) {
+        lowerer.unionCallHelpers.delete(key);
+        throw e;
+    }
+    return name;
+}
+function unionObjectMethodFunction(lowerer, name, sourceCall, receiverT, method, plans, shapes, resultT, loc) {
     const receiver = varRef("this.0", receiverT, loc);
     const argRefs = shapes.map((shape, i) => varRef(`a.${i}`, shape.type, loc));
     const branch = (plan) => {
@@ -8117,8 +8891,7 @@ function unionObjectMethodHelper(lowerer, sourceCall, receiverT, method, plans,
         type: param.type,
         mutable: false,
     }));
-    lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc });
-    return name;
+    return { name, params, returnType: resultT, locals, body, loc };
 }
 /** The argument's lowered type for a message (what the static form saw),
  * or the checker's text when the argument itself does not lower. */
@@ -8288,4 +9061,77 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
     }
     return null;
 }
+/** `crypto.getRandomValues(view)` on the WebCrypto global or webcrypto. */
+function lowerWebCryptoGetRandomValues(lowerer, call, access) {
+    if (access.name.text !== "getRandomValues" ||
+        call.questionDotToken ||
+        access.questionDotToken ||
+        !isWebCryptoReceiver(lowerer, access.expression))
+        return null;
+    return lowerCryptoGetRandomValues(lowerer, call);
+}
+/** A then handler's promise-armed result (`.then(() => cached ?? load())`
+ * typed `T | Promise<T>`, or a `Promise<void> | void` callback's result):
+ * the lifted async body adopts the promise arm and fulfills with the
+ * others, like `return u` in an async function. Null for other results. */
+function maybePromiseHandlerResult(lowerer, call, value, R) {
+    const mp = promiseArmedUnionOf(lowerer, value.type);
+    if (!mp || promiseArmedUnionOf(lowerer, R))
+        return null;
+    const stmt = maybePromiseReturnStmt(lowerer, value, mp, R, (e) => lowerer.coerceInto(call, e, R));
+    if (stmt === null) {
+        lowerer.unsupported("SC1090", call, `then handlers returning '${lowerer.fmt(value.type)}' into '${lowerer.fmt(R)}' (an arm does not convert to the result)`);
+    }
+    return stmt;
+}
+/** `Object.assign(err, ...sources)` in TypeScript onto an error-hierarchy
+ * target (`Object.assign(new Error(message), details)`): the sources'
+ * own members land on the error — the runtime copy over its
+ * checked-dynamic node, whose name, message, stack, cause and code feed
+ * back into the typed slots — and the call answers the error itself.
+ * Null for every other target. */
+function lowerObjectAssignOntoError(lowerer, call) {
+    const argNodes = call.arguments.nodes;
+    if (isJsSourceFile(ts.getSourceFileOfNode(call)) ||
+        argNodes.length < 2 ||
+        argNodes.some((a) => ts.isSpreadElement(a)))
+        return null;
+    const probe = tryLowerExpression(lowerer, argNodes[0]);
+    if (probe?.type.kind !== "object" || !lowerer.isErrorRootedClass(probe.type.className))
+        return null;
+    const loc = locOf(call);
+    const target = lowerer.lowerExpr(argNodes[0]);
+    const slot = lowerer.declareHiddenLocal("%assignErr", target.type);
+    const sources = [];
+    for (const node of argNodes.slice(1)) {
+        const raw = lowerer.lowerExpr(node);
+        fenceSymbolFieldCopy(lowerer, node, raw.type);
+        const source = lowerer.coerceToExpected(raw, DYN);
+        if (source.type.kind !== "dyn") {
+            lowerer.unsupported("SC1090", node, `Object.assign onto an Error from a '${lowerer.fmt(raw.type)}' source (sources enter the error's dynamic properties)`);
+        }
+        sources.push(source);
+    }
+    const ref = () => ({ kind: "varRef", localId: slot.id, type: target.type, loc });
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: slot.id, init: target, loc },
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "error.assign",
+                    args: [ref(), { kind: "dynArrLit", elems: sources, type: DYN, loc }],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            },
+        ],
+        result: ref(),
+        type: target.type,
+        loc,
+    };
+}
 //# sourceMappingURL=lower-calls.js.map