@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -1,3 +1,5 @@
+import { keyedHelperName } from "./stable-names.js";
+import { perKeyOrder } from "./key-order-witness.js";
 import { isForwardedTupleSpread, lowerForwardingApply } from "./typed-arguments.js";
 import { guardNullProto, nullProtoRecordShape } from "./null-prototype.js";
 import { lowerDynStreamMemberCall } from "./dyn-streams.js";
@@ -28,9 +30,10 @@ 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, 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 { BYTES_ELEMENT_NAME, BYTES_U8, 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, shapeKeyOrders, typeEquals, RUNTIME_EMITTER_CLASS, } from "../../ir/ir.js";
 import { lowerProtocolMethodCall } from "./class-protocol-dispatch.js";
 import { isJsSourceFile, locOf, requireSpecOf } from "../program.js";
+import { isPackageShimFile, isShimIntrinsicName } from "../package-shims.js";
 import { lowerJsonRequireCall } from "./json-require.js";
 import { lowerAssertInstanceCall } from "./assert-instances.js";
 import { isGenericCallableMemberType, isOverloadedCallableMemberType, typeKey, } from "../type-mapper.js";
@@ -51,7 +54,7 @@ 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 { isWebCryptoReceiver, lowerCipherMethodCall, lowerCryptoGetRandomValues, lowerCryptoHashMethodCall, lowerPromisifiedCryptoCall, } from "./builtins/crypto.js";
-import { lowerErrorIsErrorCall } from "./builtins/errors.js";
+import { lowerErrorCaptureStackTraceCall, 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";
@@ -59,7 +62,7 @@ import { fencePerfEntryKeyWalk, isPerfEntryType, lowerHistogramMethodCall, lower
 import { lowerProcStreamMethodCall, lowerProcessBuiltinModuleNamespace, } from "./builtins/process.js";
 import { recordMayKeepSource, throughRecordSource } from "./record-sources.js";
 import { lowerReflectCall } from "./builtins/reflection.js";
-import { lowerAbsenceProbe, v8CalleeText, lowerOptionalNumber, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, } from "./lower-exprs.js";
+import { lowerAbsenceProbe, v8CalleeText, lowerPromiseAllTupleCall, lowerPromiseRejectCall, lowerToNumberArgument, stringWrapperToString, symbolFieldInfo, templateRawTextOf, primitiveCtorClosure, } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerChildMethodValue, lowerChildPropertyCall } from "./handle-properties.js";
@@ -71,6 +74,7 @@ import { EMITTER_API_MEMBERS, exactClassOfReceiver, exactInstanceClassOf, findGe
 import { classCallbackCall, isClassCallback } from "./class-callbacks.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-event-emitter.js";
 import { eventTargetApiMethod, lowerEventTargetMethodCall } from "./lower-event-target.js";
+import { dateRootOf, isDatePrototypeMethod, lowerInheritedDateMethodCall, } from "./builtins/date-classes.js";
 import { lowerConsoleInstanceCall, lowerConsoleMethodCall, lowerConsoleOutput, } from "./lower-console.js";
 import { STREAM_API_MEMBERS, STREAM_OPERATORS, lowerStreamMethodCall, lowerStreamStaticCall, streamSidesOf, } from "./lower-stream.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
@@ -80,6 +84,7 @@ import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedA
 import { fenceSymbolFieldCopy } from "./symbol-fields.js";
 import { lowerClassDataDescriptor, lowerClassDescriptorRead } from "./class-descriptors.js";
 import { lowerClassFieldDefine, lowerClassIntegrity } from "./class-attributes.js";
+import { freezableRecordType, lowerNativeFreeze } from "./frozen-records.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { lowerUrlFactory } from "./lower-url.js";
 import { nullishValueUnitOf } from "./binding-analysis.js";
@@ -91,8 +96,59 @@ 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"]);
+/** `Object.defineProperty(target, ...)`, `Object.defineProperties`,
+ * `Reflect.defineProperty`, and `target.__defineGetter__/__defineSetter__`
+ * over a target that may hold an Error can install an accessor over an
+ * error's `name` or `message` (error-methods.ts). */
+function noteErrorAccessorReflection(lowerer, expr) {
+    const callee = expr.expression;
+    if (!ts.isPropertyAccessExpression(callee))
+        return;
+    const member = callee.name.text;
+    const target = member === "defineProperty" || member === "defineProperties"
+        ? expr.arguments.nodes[0]
+        : member === "__defineGetter__" || member === "__defineSetter__"
+            ? callee.expression
+            : undefined;
+    if (!target)
+        return;
+    const error = lowerer.checker.resolveName("Error", ts.SymbolFlags.Type, target, false);
+    const errorType = error ? lowerer.checker.getDeclaredTypeOfSymbol(error) : null;
+    if (mayHoldError(lowerer, lowerer.checker.getTypeAtLocation(target), errorType))
+        lowerer.errorAccessorReflection = locOf(expr);
+}
+/** An untyped or generic type, a type Error is assignable to (`object`,
+ * `{}`, `Object`, `{ message?: string }`), or
+ * an Error-shaped type with both `name` and `message`, alone or in a
+ * union or intersection. */
+function mayHoldError(lowerer, type, errorType) {
+    if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Instantiable))
+        return true;
+    if (type.flags & (ts.TypeFlags.Union | ts.TypeFlags.Intersection))
+        return ts.constituentTypes(type).some((part) => mayHoldError(lowerer, part, errorType));
+    return ((lowerer.checker.getPropertyOfType(type, "message") !== undefined &&
+        lowerer.checker.getPropertyOfType(type, "name") !== undefined) ||
+        (errorType !== null && lowerer.checker.isTypeAssignableTo(errorType, type)));
+}
+/** The `f` of a `(0, f)` callee (a numeric left operand, so dropping it
+ * changes only the call's receiver), or null. */
+function receiverlessCalleeOf(callee) {
+    let e = callee;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    if (!ts.isBinaryExpression(e) ||
+        e.operatorToken.kind !== ts.SyntaxKind.CommaToken ||
+        !ts.isNumericLiteral(e.left))
+        return null;
+    let right = e.right;
+    while (ts.isParenthesizedExpression(right))
+        right = right.expression;
+    return right;
+}
 export function lowerCall(lowerer, expr) {
     const loc = locOf(expr);
+    if (lowerer.errorAccessorReflection === null)
+        noteErrorAccessorReflection(lowerer, expr);
     // Object's checker return type is `any`. Claim known object inputs
     // before generic checked-dynamic dispatch tries to load the constructor.
     if (ts.isIdentifier(expr.expression) &&
@@ -111,6 +167,17 @@ export function lowerCall(lowerer, expr) {
     const json = lowerJsonRequireCall(lowerer, expr);
     if (json)
         return json;
+    // `(0, ns.member)(...)` over a builtin module (tsc's and esbuild's call
+    // without a receiver): Node's module functions do not read `this`, so it
+    // is the member call.
+    {
+        const member = receiverlessCalleeOf(expr.expression);
+        if (member !== null && ts.isPropertyAccessExpression(member)) {
+            const builtin = lowerer.lowerNamespaceBuiltinCall(expr, member);
+            if (builtin)
+                return builtin;
+        }
+    }
     // eval(...) and Function(...): Node's EvalError under
     // --disallow-code-generation-from-strings (code-generation.ts).
     {
@@ -118,6 +185,13 @@ export function lowerCall(lowerer, expr) {
         if (codeGeneration !== null)
             return lowerCodeGenerationCall(lowerer, expr, codeGeneration);
     }
+    // A package shim's runtime intrinsic (a bodiless `declare function`
+    // named scriptcUnixDgram* in a shipped shim): a direct runtime call.
+    if (ts.isIdentifier(expr.expression) && isShimIntrinsicName(expr.expression.text)) {
+        const intrinsic = lowerShimIntrinsicCall(lowerer, expr, expr.expression, loc);
+        if (intrinsic)
+            return intrinsic;
+    }
     // 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
@@ -739,10 +813,9 @@ export function lowerCall(lowerer, expr) {
         // excludes shadowed names. parseInt's omitted radix completes
         // to 0 — the spec's "undefined" (base 10 with the 0x hex escape);
         // parseFloat lowers the STRING form only (Node would ToString other
-        // values — no static story); isNaN/isFinite's arguments are
-        // checker-pinned (or checked) to number, where the global's ToNumber
-        // coercion is the identity and the tests are Number.isNaN /
-        // Number.isFinite exactly (ms's `isFinite(val)` guard).
+        // values — no static story); isNaN/isFinite apply the global's
+        // ToNumber to any argument, then test like Number.isNaN /
+        // Number.isFinite.
         if ((expr.expression.text === "parseInt" ||
             expr.expression.text === "isNaN" ||
             expr.expression.text === "parseFloat" ||
@@ -841,15 +914,11 @@ export function lowerCall(lowerer, expr) {
         }
         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.
+            // (a string for parseFloat): 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.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)"
-                : "only a number argument compiles statically: narrow the argument to a number first");
+            lowerer.refuseUnsupportedApi(`'${expr.expression.text}' with a '${argText}' argument`, expr, "only a string argument compiles statically: convert the argument explicitly first (for example String(x), or narrow the union)");
         }
     }
     // A TYPE-GUARD call on a catch binding (`isErrnoException(err)` —
@@ -1237,9 +1306,10 @@ export function lowerCall(lowerer, expr) {
             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) ??
+            // crypto.getRandomValues / randomUUID on the WebCrypto global
+            // (untyped in fallback builds, so before the dyn receiver path) or
+            // webcrypto.
+            lowerWebCryptoMethodCall(lowerer, expr, expr.expression) ??
             // Dyn receivers (JSON.parse-derived `unknown`/`any` values) —
             lowerDynReceiverMethodCall(lowerer, expr, expr.expression) ??
             // Narrowing filters (inferred predicates, filter(Boolean)) claim
@@ -1248,6 +1318,7 @@ export function lowerCall(lowerer, expr) {
             lowerer.lowerFilterNarrowCall(expr, expr.expression) ??
             lowerArrayIsArrayCall(lowerer, expr, expr.expression) ??
             lowerErrorIsErrorCall(lowerer, expr, expr.expression) ??
+            lowerErrorCaptureStackTraceCall(lowerer, expr, expr.expression) ??
             lowerBigIntMethodCall(lowerer, expr, expr.expression) ??
             lowerSymbolStaticCall(lowerer, expr, expr.expression) ??
             lowerSymbolMethodCall(lowerer, expr, expr.expression) ??
@@ -1306,7 +1377,17 @@ export function lowerCall(lowerer, expr) {
         }
         const accessorTarget = lowerer.fieldTarget(expr.expression);
         if (accessorTarget?.container === "accessor") {
-            const callee = lowerer.fieldGetExpr(accessorTarget, locOf(expr.expression), expr.expression);
+            let callee = lowerer.fieldGetExpr(accessorTarget, locOf(expr.expression), expr.expression);
+            // A getter returning a callable class instance (chalk's
+            // `chalk.red("x")`): call through its `%call` field.
+            if (callee.type.kind === "object") {
+                const direct = callableInstanceStringCall(lowerer, expr, callee, locOf(expr));
+                if (direct)
+                    return direct;
+                callee = lowerer.hybridCallUnwrap(callee);
+                if (callee.type.kind === "func")
+                    return lowerCallThroughValue(lowerer, expr, callee, locOf(expr));
+            }
             if (callee.type.kind === "func") {
                 const args = completeFuncValueArgs(lowerer, expr, callee.type, locOf(expr));
                 return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(expr) };
@@ -1523,8 +1604,47 @@ export function lowerCall(lowerer, expr) {
     // a non-func IR type was already rejected while lowering the callee.
     // HYBRID (function-with-properties) values call through their %call slot.
     let callee = lowerer.lowerExpr(expr.expression);
-    if (callee.type.kind === "record")
+    {
+        const direct = callableInstanceStringCall(lowerer, expr, callee, loc);
+        if (direct)
+            return direct;
+    }
+    if (callee.type.kind === "record" || callee.type.kind === "object")
         callee = lowerer.hybridCallUnwrap(callee);
+    return lowerCallThroughValue(lowerer, expr, callee, loc);
+}
+/** A callable class instance called with one string: its `%call1` method
+ * when the class has one (the chalk shim's typed fast path), skipping the
+ * variadic closure's checked-dynamic arguments. */
+function callableInstanceStringCall(lowerer, expr, callee, loc) {
+    if (callee.type.kind !== "object" || expr.arguments.nodes.length !== 1)
+        return null;
+    const arg = expr.arguments.nodes[0];
+    if (ts.isSpreadElement(arg))
+        return null;
+    const info = lowerer.classes.get(callee.type.className);
+    if (info === undefined || !info.fields.has("%call") || !lowerer.findMethodOn(info, "%call1"))
+        return null;
+    const value = lowerer.lowerExpr(arg);
+    if (value.type.kind === "string")
+        return lowerer.accessorCall(callee.type.className, "%call1", callee, [value], STRING, loc);
+    // Any other argument (a number behind a cast): the variadic closure,
+    // through the checked-dynamic call as lowerCallThroughValue would.
+    const closure = lowerer.hybridCallUnwrap(callee);
+    if (closure.type.kind !== "func")
+        return null;
+    return {
+        kind: "dynCall",
+        callee: { kind: "dynFrom", value: closure, type: DYN, loc },
+        calleeName: ts.isIdentifier(expr.expression) ? expr.expression.text : "value",
+        args: [lowerer.coerceToExpected(value, DYN)],
+        type: DYN,
+        loc,
+    };
+}
+/** A call through an evaluated callee value: checked-dynamic callees,
+ * function unions, typed-rest and runtime-arity closures. */
+function lowerCallThroughValue(lowerer, expr, callee, loc) {
     // A CHECKED-DYNAMIC callee — `fn(a, b)` where fn is an implicit-any
     // JS binding (the mustCall body's `fn(...args)`), a dyn capture, or a
     // keyed read off a dyn value: the dynCall boundary. Arguments convert
@@ -1703,7 +1823,7 @@ function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
     const key = `number.optionalDefault:${widened.unionId}:${dflt}`;
     let helper = lowerer.valueHelpers.get(key);
     if (!helper) {
-        helper = `%number.optionalDefault.${lowerer.valueHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%number.optionalDefault", key);
         lowerer.valueHelpers.set(key, helper);
         const input = varRef("value.0", widened, loc);
         lowerer.liftedFns.push({
@@ -1804,7 +1924,7 @@ function primitiveConversionHandler(lowerer, node, inner) {
     const key = `then.${name}:${typeKey(inner)}`;
     let fnName = lowerer.arrHofHelpers.get(key);
     if (fnName === undefined) {
-        fnName = `%then.${name}.${lowerer.arrHofHelpers.size}`;
+        fnName = keyedHelperName(lowerer, `%then.${name}`, key);
         lowerer.arrHofHelpers.set(key, fnName);
         const value = varRef("v.0", inner, loc);
         let body;
@@ -1918,6 +2038,20 @@ function lowerBigIntConstructorValue(lowerer, arg, loc) {
         return { kind: "libCall", fn: "bigint.parse", args: [arg], type: BIGINT_T, loc };
     if (arg.type.kind === "f64")
         return { kind: "libCall", fn: "bigint.fromF64", args: [arg], type: BIGINT_T, loc };
+    // Byte storage converts through ToPrimitive, which BigInt then parses: a
+    // typed array's text is its elements joined with "," (one element reads
+    // as that element, none as 0n, several throw the SyntaxError for the
+    // joined text), a Buffer's is its UTF-8 decoding and a DataView's is
+    // "[object DataView]". The runtime value tells them apart, as for String.
+    if (arg.type.kind === "bytes") {
+        const text = {
+            kind: "toString",
+            operand: { kind: "dynFrom", value: arg, type: DYN, loc },
+            type: STRING,
+            loc,
+        };
+        return { kind: "libCall", fn: "bigint.parse", args: [text], type: BIGINT_T, loc };
+    }
     if (arg.type.kind === "bool") {
         return {
             kind: "ternary",
@@ -1953,12 +2087,13 @@ function lowerBigIntConstructorValue(lowerer, arg, loc) {
             arm.kind === "string" ||
             arm.kind === "f64" ||
             arm.kind === "bool" ||
+            arm.kind === "bytes" ||
             isUnitType(arm)))
         return null;
     const key = `bigint.scalar:${unionId}`;
     let helper = lowerer.valueHelpers.get(key);
     if (!helper) {
-        helper = `%bigint.scalar.${lowerer.valueHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%bigint.scalar", key);
         lowerer.valueHelpers.set(key, helper);
         const value = varRef("value.0", arg.type, loc);
         const body = [];
@@ -2647,6 +2782,12 @@ function lowerStringPrototypeCall(lowerer, call, access) {
     const receiver = lowerer.ensureString(receiverValue, receiverNode);
     return lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => receiver, call.arguments.nodes.slice(1));
 }
+/** ToNumber of a union of strings, numbers, booleans, null and undefined, as
+ * `Number(value)` converts it; null for other types. Unary `+` takes it too:
+ * the two conversions differ only for BigInt, which such unions don't hold. */
+export function lowerPrimitiveUnionNumber(lowerer, arg, node, loc) {
+    return (lowerOptionalStringNumber(lowerer, arg, loc) ?? lowerScalarUnionNumber(lowerer, arg, node, loc));
+}
 function lowerScalarUnionNumber(lowerer, arg, node, loc) {
     if (arg.type.kind !== "union" ||
         !lowerer.unions
@@ -2656,7 +2797,7 @@ function lowerScalarUnionNumber(lowerer, arg, node, loc) {
     const key = `number.scalar:${arg.type.unionId}`;
     let helper = lowerer.valueHelpers.get(key);
     if (!helper) {
-        helper = `%number.scalar.${lowerer.valueHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%number.scalar", key);
         lowerer.valueHelpers.set(key, helper);
         const value = varRef("value.0", arg.type, loc);
         const nan = {
@@ -2697,7 +2838,7 @@ function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", lab
     const key = `${label}.optionalString:${arg.type.unionId}`;
     let helper = lowerer.valueHelpers.get(key);
     if (!helper) {
-        helper = `%${label}.optionalString.${lowerer.valueHelpers.size}`;
+        helper = keyedHelperName(lowerer, `%${label}.optionalString`, key);
         lowerer.valueHelpers.set(key, helper);
         const value = varRef("value.0", arg.type, loc);
         lowerer.liftedFns.push({
@@ -2984,6 +3125,15 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
     // 'unknown' slot does.
     if (checkerUntyped && DYN_HANDLE_KINDS.has(recv.type.kind))
         recv = lowerer.coerceToExpected(recv, DYN);
+    // A typed array whose checker type collapsed to `any` (a JS binding
+    // referenced in its own initializer's inference — hono's etag digest
+    // `const nextChunk = new Uint8Array(new ArrayBuffer(f(chunk)))` beside
+    // `chunk = nextChunk`) still lowered to its native bytes. The typed
+    // lowerings key on the checker type and decline it, so it boxes by
+    // reference (the box shares the native storage, so writes through the
+    // call stay visible) and the call dispatches on the runtime kind.
+    if (checkerUntyped && recv.type.kind === "bytes")
+        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")`
@@ -3103,11 +3253,25 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
     if (access.name.text === "flatMap")
         return lowerDynArrayFlatMapCall(lowerer, call, access, recv);
     // String methods claim only names NO other dyn-representable kind's
-    // prototype declares (Array carries includes/indexOf/slice too): for
-    // these, "the receiver is a string, or the call throws V8's TypeError"
-    // IS Node's semantics for every possible dyn value. Shared names would
-    // need a receiver-kind dispatch — they keep the fence.
+    // prototype declares (Array carries includes/indexOf/slice too), so no
+    // other kind inherits them. Shared names would need a receiver-kind
+    // dispatch — they keep the fence.
     if (DYN_STRING_ONLY_METHODS.has(access.name.text) && !ownCallable) {
+        // A checked-dynamic object can still carry its OWN member of that
+        // name: zod's schemas assign `trim`, `toLowerCase` and `startsWith`
+        // in their constructors (`z.string().trim().min(1)`), an object's
+        // prototype can define `trim`, and a JavaScript module object can
+        // assign `repeat` in a function body (`common.repeat(" ", n)`, an
+        // object-typed receiver the member is missing from). An untyped
+        // receiver, or a member the checker cannot type, dispatches on the
+        // receiver's runtime kind: a string runs the string lowering, anything
+        // else calls its member as Node does.
+        if ((checkerUntyped ||
+            (lowerer.typeOf(access).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) &&
+            !call.questionDotToken &&
+            !access.questionDotToken &&
+            !call.arguments.nodes.some(ts.isSpreadElement))
+            return lowerStringOrMemberCall(lowerer, call, access, recv);
         const checked = () => dynStringReceiver(lowerer, recv, access);
         return (lowerRegexMethodCall(lowerer, call, access, checked) ??
             lowerStringMethodCall(lowerer, call, access, checked));
@@ -3127,7 +3291,12 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
     }
     // 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.nodes.length <= 1) {
+    // An authored own `toString` member (zod's `errorUtil.toString`, which
+    // answers string | undefined) is an ordinary method call instead.
+    if (access.name.text === "toString" &&
+        call.arguments.nodes.length <= 1 &&
+        !ownCallable &&
+        !(checkerUntyped && jsAssignsOwnToString(lowerer, access.expression))) {
         const argument = call.arguments.nodes[0];
         return {
             kind: "libCall",
@@ -3229,11 +3398,17 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
     // 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 ownToString = access.name.text === "toString" &&
+        checkerUntyped &&
+        jsAssignsOwnToString(lowerer, access.expression);
     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)
+    if (DYN_PROTO_METHOD_NAMES.has(access.name.text) &&
+        !ownCallable &&
+        !ownToString &&
+        !stringOnlyName)
         return null;
     // Optional forms (`obj.cb?.()`, `obj?.cb()`) belong to the chain
     // machinery's short-circuit semantics — not modeled here yet.
@@ -3294,6 +3469,79 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
         loc,
     };
 }
+/** `value.name(...args)` on a dyn receiver that may be a string or an
+ * object: a string runs the String.prototype lowering, any other value
+ * calls its member. The member is read before the arguments are
+ * evaluated, and the arguments are evaluated once for either branch. */
+function lowerStringOrMemberCall(lowerer, call, access, recv) {
+    const loc = locOf(call);
+    const receiverLocal = lowerer.declareHiddenLocal("%dynCallReceiver", DYN);
+    const receiver = varRef(receiverLocal.id, DYN, loc);
+    const isString = { kind: "dynTest", test: "string", value: receiver, type: BOOL, loc };
+    const calleeLocal = lowerer.declareHiddenLocal("%dynCallCallee", DYN);
+    const callee = varRef(calleeLocal.id, DYN, loc);
+    const stmts = [
+        { kind: "varDecl", localId: receiverLocal.id, init: recv, loc },
+        {
+            kind: "varDecl",
+            localId: calleeLocal.id,
+            init: {
+                kind: "ternary",
+                cond: isString,
+                then: dynUndefinedExpr(loc),
+                else_: {
+                    kind: "dynKeyGet",
+                    key: { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access) },
+                    value: receiver,
+                    type: DYN,
+                    loc: locOf(access),
+                },
+                type: DYN,
+                loc,
+            },
+            loc,
+        },
+    ];
+    const args = call.arguments.nodes.map((node) => {
+        const value = lowerer.lowerExpr(node);
+        const local = lowerer.declareHiddenLocal("%dynCallArg", value.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc });
+        return { node, value: varRef(local.id, value.type, value.loc) };
+    });
+    // String.prototype methods ignore arguments past the ones they read.
+    const arity = DYN_STRING_ONLY_ARITY[access.name.text] ?? call.arguments.nodes.length;
+    const stringReceiver = () => ({ kind: "dynCheck", value: receiver, type: STRING, loc });
+    const lowerString = () => (call.arguments.nodes.length <= arity
+        ? lowerRegexMethodCall(lowerer, call, access, stringReceiver)
+        : null) ??
+        lowerStringMethodCall(lowerer, call, access, stringReceiver, call.arguments.nodes.slice(0, arity));
+    const stringCall = lowerer.withExpressionOverrides(args, lowerString);
+    const memberCall = {
+        kind: "dynCall",
+        callee,
+        receiver,
+        calleeName: ts.getTextOfNode(access),
+        args: args.map((arg) => lowerer.coerceToExpected(arg.value, DYN)),
+        type: DYN,
+        loc,
+    };
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: {
+            kind: "ternary",
+            cond: isString,
+            then: stringCall
+                ? lowerer.coerceToExpected(stringCall, DYN)
+                : nodeThrowExpr(0, "SC1090", `method calls like '${ts.getTextOfNode(access)}' on a string are not supported yet [SC1090 at ${ts.getSourceFileOfNode(call).fileName}:${ts.getLineAndCharacterOfPosition(ts.getSourceFileOfNode(call), ts.tokenStartOfNode(call)).line + 1}]`, DYN, loc),
+            else_: memberCall,
+            type: DYN,
+            loc,
+        },
+        type: DYN,
+        loc,
+    };
+}
 /** Prototype method names of the checked-dynamic tree-representable kinds (String, Array,
  * Object, Function, Number prototypes): a dyn receiver call on one of
  * these could be a REAL method on a real value, which a stored-member
@@ -3421,6 +3669,7 @@ const DYN_DISPATCH_METHODS = new Set([
     "shift",
     "unshift",
     "slice",
+    "splice",
     "at",
     "indexOf",
     "lastIndexOf",
@@ -3455,6 +3704,12 @@ const DYN_DISPATCH_METHODS = new Set([
     "prependOnceListener",
     "listeners",
     "listenerCount",
+    // The rest of EventEmitter.prototype, which compiled emitters answer
+    // through the class dispatch (class-dynamic-dispatch.ts).
+    "rawListeners",
+    "eventNames",
+    "setMaxListeners",
+    "getMaxListeners",
     "write",
     "end",
     "destroy",
@@ -3556,6 +3811,9 @@ const DYN_DISPATCH_METHODS = new Set([
     "additionalHeaders",
     "altsvc",
     "origin",
+    // FinalizationRegistry's methods (scr_finalization_registry_new).
+    "register",
+    "unregister",
     // Worker and MessagePort methods use the owning context's handle adapter.
     "postMessage",
     "terminate",
@@ -3567,6 +3825,15 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
     if ((!DYN_DISPATCH_METHODS.has(method) && !isJsSourceFile(ts.getSourceFileOfNode(call))) ||
         lowerer.chainBlocked(call, access))
         return null;
+    // readable.compose lowers its stages from their syntax, so it needs the
+    // stream's class: a stream a JavaScript function returns untyped has none.
+    if (method === "compose") {
+        const recvT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+        if (recvT?.kind === "object" &&
+            streamSidesOf(lowerer, lowerer.classes.get(recvT.className)) !== null) {
+            lowerer.noLowering("readable.compose on a stream held as a checked-dynamic value", call, "type the stream where it comes from, such as a JSDoc @returns {Readable} on the function that returns it");
+        }
+    }
     if (call.arguments.nodes.some((arg) => ts.isSpreadElement(arg))) {
         const loc = locOf(call);
         const local = lowerer.declareHiddenLocal("%spreadReceiver", DYN);
@@ -3664,7 +3931,19 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
             }
         }
     }
+    // `String`, `Number` or `Boolean` as the callback of an array method
+    // (`values.map(String)` over an unknown array): the method calls it with
+    // each element, whatever its type, and cannot observe which function
+    // value it received, so it gets the constructor's form that converts any
+    // argument rather than the string-input form typed code stores.
+    const arrayCallbackReceiver = ARRAY_CALLBACK_METHODS.has(method) &&
+        lowerer.checker.isArrayType(lowerer.typeOf(access.expression));
     const args = call.arguments.nodes.map((arg, i) => {
+        const primitive = i === 0 && arrayCallbackReceiver && ts.isIdentifier(arg)
+            ? stdlibGlobalNameOf(lowerer, arg)
+            : null;
+        if (primitive === "String" || primitive === "Number" || primitive === "Boolean")
+            return lowerer.coerceInto(arg, primitiveCtorClosure(lowerer, primitive, locOf(arg), true), DYN);
         if (i === 0 && predicate)
             return lowerer.coerceInto(arg, predicate, DYN);
         const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, arg);
@@ -3682,6 +3961,20 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
         loc: locOf(call),
     };
 }
+/** Array.prototype methods whose first argument is a callback they call
+ * with the elements. */
+const ARRAY_CALLBACK_METHODS = new Set([
+    "map",
+    "filter",
+    "forEach",
+    "some",
+    "every",
+    "find",
+    "findIndex",
+    "findLast",
+    "findLastIndex",
+    "flatMap",
+]);
 /** Every String.prototype method name a typed or dyn string lowering
  * answers. */
 function isStringMethodName(name) {
@@ -3692,6 +3985,28 @@ function isStringMethodName(name) {
         name === "normalize" ||
         name === "lastIndexOf");
 }
+/** How many arguments each DYN_STRING_ONLY_METHODS method reads. */
+const DYN_STRING_ONLY_ARITY = {
+    charCodeAt: 1,
+    charAt: 1,
+    startsWith: 2,
+    endsWith: 2,
+    substring: 2,
+    repeat: 1,
+    trim: 0,
+    trimStart: 0,
+    trimEnd: 0,
+    split: 2,
+    padStart: 2,
+    padEnd: 2,
+    toLowerCase: 0,
+    toUpperCase: 0,
+    replace: 2,
+    replaceAll: 2,
+    match: 1,
+    matchAll: 1,
+    search: 1,
+};
 /** 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([
@@ -4013,7 +4328,7 @@ function lowerDefaultToStringCall(lowerer, call, access) {
     const key = `objToStr:${typeKey(recv.type)}${missing ? `:${missing}` : ""}`;
     let helper = lowerer.valueHelpers.get(key);
     if (!helper) {
-        helper = `%obj.tostr.${lowerer.valueHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%obj.tostr", key);
         lowerer.valueHelpers.set(key, helper);
         const o = varRef("o.0", recv.type, loc);
         lowerer.liftedFns.push({
@@ -4625,7 +4940,7 @@ function loweredTemplateStrings(lowerer, expr, cooked, loc, raw) {
         const site = lowerer.globalsList.length;
         const globalId = `%g.templateStrings.${site}`;
         const readyId = `%g.templateStringsReady.${site}`;
-        getter = `%templateStrings.get.${lowerer.valueHelpers.size}`;
+        getter = keyedHelperName(lowerer, "%templateStrings.get", key);
         lowerer.valueHelpers.set(key, getter);
         lowerer.globalsList.push({ id: globalId, name: "%templateStrings", type, mutable: true }, { id: readyId, name: "%templateStringsReady", type: BOOL, mutable: true });
         lowerer.liftedFns.push({
@@ -4794,7 +5109,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         // IS the spec's identity/thrower/no-op substitution for all three
         // members. An argument expression, when present, is undefined/null
         // by construction — nothing to evaluate.
-        const fnName = `%fn${lowerer.lambdaCounter++}_${member}pass`;
+        const fnName = lowerer.closureName(loc, `_${member}pass`);
         const funcType = { kind: "func", params: [promT], ret: promT };
         const fnCtx = newFnCtx(true, null, funcType, inner);
         fnCtx.isAsync = true;
@@ -4876,7 +5191,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             // Evaluate both callback expressions before the wrapper runs, in source order.
             const fulfilled = fulfilledAbsent ? null : boxHandler(fulfilledNode, true);
             const rejected = rejectedAbsent ? null : boxHandler(rejectedNode, false);
-            const fnName = `%fn${lowerer.lambdaCounter++}_then2`;
+            const fnName = lowerer.closureName(loc, "_then2");
             const paramTypes = [
                 promT,
                 ...(fulfilled ? [fulfilled.value.type] : []),
@@ -5095,7 +5410,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 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`;
+            const fnName = lowerer.closureName(loc, "_then");
             const funcType = {
                 kind: "func",
                 params: [promT, DYN],
@@ -5173,12 +5488,24 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             !(param.kind === "dyn" && (inner.kind === "void" || lowerer.dynConvertible(inner)))) {
             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));
+        let resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+        // JavaScript whose declared result type has no mapping (zod's
+        // `Promise.all(items).then((r) => ParseStatus.mergeArray(status, r))`,
+        // typed by a .d.ts union): the handler's value settles the promise as
+        // a checked-dynamic value, checked where it is used.
+        if (resultT?.kind !== "promise" &&
+            isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+            cb.type.kind === "func" &&
+            cb.type.ret.kind !== "promise" &&
+            cb.type.ret.kind !== "void" &&
+            (cb.type.ret.kind === "dyn" || lowerer.dynConvertible(cb.type.ret))) {
+            resultT = { kind: "promise", inner: DYN };
+        }
         if (resultT?.kind !== "promise") {
             lowerer.noLowering("then with this handler's result type", call, "the combined result must be a representable promise");
         }
         const R = resultT.inner;
-        const fnName = `%fn${lowerer.lambdaCounter++}_then`;
+        const fnName = lowerer.closureName(loc, "_then");
         const funcType = {
             kind: "func",
             params: [promT, cb.type],
@@ -5282,7 +5609,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         if (cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void") {
             lowerer.unsupported("SC1090", call.arguments.nodes[0], "finally callbacks with parameters or a return value (use () => { ... })");
         }
-        const fnName = `%fn${lowerer.lambdaCounter++}_finally`;
+        const fnName = lowerer.closureName(loc, "_finally");
         const funcType = {
             kind: "func",
             params: [promT, cb.type],
@@ -5378,7 +5705,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         }
         if (cb.type.kind === "dyn") {
             const resultT = { kind: "promise", inner: DYN };
-            const fnName = `%fn${lowerer.lambdaCounter++}_catchdyn`;
+            const fnName = lowerer.closureName(loc, "_catchdyn");
             const funcType = {
                 kind: "func",
                 params: [promT, DYN],
@@ -5495,7 +5822,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             "own type, or annotate the handler `(): undefined =>` for the T | undefined result");
     }
     const R = resultT.inner;
-    const fnName = `%fn${lowerer.lambdaCounter++}_catch`;
+    const fnName = lowerer.closureName(loc, "_catch");
     const funcType = { kind: "func", params: [promT], ret: resultT };
     const fnCtx = newFnCtx(true, null, funcType, R);
     fnCtx.isAsync = true;
@@ -5648,6 +5975,13 @@ export function lowerFilterNarrowCall(lowerer, call, access) {
     const narrowed = outElem !== null && !typeEquals(outElem, elem);
     if (!narrowed && !isBooleanArg)
         return null;
+    // A written predicate (`(p): p is Cat => ...`, a guard function value)
+    // proves nothing at run time: the generic array HOF path filters the
+    // receiver's elements and converts the kept ones checked
+    // (filterResultElem).
+    if (!isBooleanArg &&
+        ((!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) || argNode.type))
+        return null;
     const annotateEscape = "keep the receiver's element type instead — annotate the callback's return ': boolean' " +
         "(the checker then skips the predicate) or annotate the result with the receiver's own " +
         "element type — and narrow the elements after";
@@ -5657,6 +5991,10 @@ export function lowerFilterNarrowCall(lowerer, call, access) {
             lowerer.badType(call, callT); // defensive: a narrowed non-union receiver
         }
         tag = lowerer.armTag(elem.unionId, outElem);
+        // Several kept arms: the generic path converts the kept elements to
+        // the narrower union (filterResultElem).
+        if (tag < 0 && !isBooleanArg)
+            return null;
         if (tag < 0) {
             lowerer.unsupported("SC1090", call, `'.filter' narrowing '${lowerer.fmt(elem)}' elements to the multi-arm '${lowerer.fmt(outElem)}' ` +
                 `(only a SINGLE arm re-tags — ${annotateEscape})`);
@@ -5673,17 +6011,8 @@ export function lowerFilterNarrowCall(lowerer, call, access) {
         const helper = filterNarrowHelper(lowerer, "truthy", elem, outElem ?? elem, tag, loc);
         return { kind: "call", callee: helper, args: [receiver], type: arrayOf(outElem ?? elem), loc };
     }
-    // Inferred type predicate: inline function literal, NO return
-    // annotation (a written one is an unchecked assertion), and the
-    // checker reports a predicate over parameter 0.
-    if (!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) {
-        lowerer.unsupported("SC1090", argNode, `narrowing '.filter' through a callback VALUE ` +
-            `(only an inline callback whose predicate the checker inferred can re-tag — ${annotateEscape})`);
-    }
-    if (argNode.type) {
-        lowerer.unsupported("SC1090", argNode, `narrowing '.filter' with a hand-written type predicate ` +
-            `(a written 'x is T' is an unchecked assertion nothing validates at runtime — ${annotateEscape})`);
-    }
+    // An inferred type predicate: an inline function literal with no return
+    // annotation, over parameter 0 (written predicates returned above).
     // The receiver evaluates FIRST, in the enclosing function, like JS.
     const receiver = lowerer.lowerExpr(access.expression);
     const fnArg = lowerer.lowerExpr(argNode);
@@ -5713,7 +6042,7 @@ function filterNarrowHelper(lowerer, test, elem, outElem, tag, loc) {
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%arr.filterNarrow.${lowerer.arrHofHelpers.size}`;
+    const name = keyedHelperName(lowerer, "%arr.filterNarrow", key);
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
     const outT = arrayOf(outElem);
@@ -5935,7 +6264,7 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
     const key = `obj.keys:${argIr.shapeId}:${typeKey(resultT)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%obj.keys.${lowerer.arrHofHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%obj.keys", key);
         const ref = { kind: "varRef", localId: "r.0", type: argIr, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: resultT, loc };
         lowerer.arrHofHelpers.set(key, helper);
@@ -5961,8 +6290,10 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
                     loc,
                 },
             ];
-            const order = current.declaredOrder ?? current.fields.map((f) => f.name);
-            for (const name of order) {
+            // One walk per key order (see perKeyOrder).
+            const orders = shapeKeyOrders(current);
+            const walks = orders.map(() => []);
+            for (const [k, name] of orders.flatMap((order, k) => order.map((name) => [k, name]))) {
                 const f = current.fields.find((x) => x.name === name);
                 const pushStmt = {
                     kind: "exprStmt",
@@ -5979,10 +6310,11 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
                 // Fields that can be absent push behind their presence test (the
                 // key exists exactly when Object.keys would list it).
                 const present = lowerer.recordFieldPresent(ref, argIr.shapeId, f.name, loc);
-                body.push(present.kind === "recordHas"
+                walks[k].push(present.kind === "recordHas"
                     ? { kind: "if", cond: present, then: [pushStmt], else_: null, loc }
                     : pushStmt);
             }
+            body.push(...perKeyOrder(current, ref, walks, loc));
             body.push({ kind: "return", value: outRef, loc });
             fn.body = body;
         };
@@ -5998,12 +6330,12 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
  * (a key is own exactly when Object.keys would list it — the two share
  * the test), everything else true. Unmatched keys probe the overflow
  * map when present, so explicit undefined values remain own keys. */
-function recordHasOwnHelper(lowerer, shapeId, loc) {
+export function recordHasOwnHelper(lowerer, shapeId, loc) {
     const key = `obj.hasOwn:${shapeId}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const helper = `%obj.hasOwn.${lowerer.arrHofHelpers.size}`;
+    const helper = keyedHelperName(lowerer, "%obj.hasOwn", key);
     lowerer.arrHofHelpers.set(key, helper);
     const shape = lowerer.shapes.get(shapeId);
     const recT = { kind: "record", shapeId };
@@ -6081,7 +6413,7 @@ function classAssignHelper(lowerer, className, srcShapeId, loc) {
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const helper = `%obj.assignClass.${lowerer.arrHofHelpers.size}`;
+    const helper = keyedHelperName(lowerer, "%obj.assignClass", key);
     lowerer.arrHofHelpers.set(key, helper);
     const sShape = lowerer.shapes.get(srcShapeId);
     const oT = { kind: "object", className };
@@ -6142,7 +6474,7 @@ function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
-    const helper = `%obj.assign.${lowerer.arrHofHelpers.size}`;
+    const helper = keyedHelperName(lowerer, "%obj.assign", key);
     lowerer.arrHofHelpers.set(key, helper);
     const sShape = lowerer.shapes.get(srcShapeId);
     const tShape = lowerer.shapes.get(targetShapeId);
@@ -6323,6 +6655,33 @@ function lowerObjectStaticCall(lowerer, call, access) {
     if (!lowerer.isStdlibGlobal(access.expression, "Object"))
         return null;
     const member = access.name.text;
+    // `Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")` (Effect's
+    // isStackTraceLimitWritable): Error's own writable, enumerable,
+    // configurable data property holding the current limit. The interned
+    // Error value models no other statics (builtinGlobalValueAt).
+    const [first, second] = call.arguments.nodes;
+    if (member === "getOwnPropertyDescriptor" &&
+        call.arguments.nodes.length === 2 &&
+        lowerer.isStdlibGlobal(first, "Error") &&
+        ts.isStringLiteralLike(second) &&
+        second.text === "stackTraceLimit") {
+        const loc = locOf(call);
+        const dyn = (value) => ({ kind: "dynFrom", value, type: DYN, loc });
+        const yes = dyn({ kind: "boolLit", value: true, type: BOOL, loc });
+        const limit = { kind: "libCall", fn: "error.stackLimitGet", args: [], type: F64, loc };
+        return {
+            kind: "dynObjLit",
+            fields: [
+                { key: { kind: "strLit", value: "value", type: STRING, loc }, value: dyn(limit) },
+                ...["writable", "enumerable", "configurable"].map((key) => ({
+                    key: { kind: "strLit", value: key, type: STRING, loc },
+                    value: yes,
+                })),
+            ],
+            type: DYN,
+            loc,
+        };
+    }
     if ((member === "getOwnPropertyNames" ||
         member === "getOwnPropertySymbols" ||
         member === "getOwnPropertyDescriptors") &&
@@ -6677,6 +7036,11 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 const target = lowerer.lowerExpr(call.arguments.nodes[0]);
                 const rawSource = lowerer.lowerExpr(call.arguments.nodes[1]);
                 fenceSymbolFieldCopy(lowerer, call.arguments.nodes[1], rawSource.type);
+                let targetNode = call.arguments.nodes[0];
+                while (ts.isParenthesizedExpression(targetNode))
+                    targetNode = targetNode.expression;
+                if (ts.isObjectLiteralExpression(targetNode))
+                    fenceClassCopyIntoFreshObject(lowerer, call, call.arguments.nodes[1], rawSource);
                 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 };
@@ -6815,19 +7179,8 @@ 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)`);
-                            }
-                        }
+                        if (freshLiteralTarget)
+                            fenceClassCopyIntoFreshObject(lowerer, call, srcNode, rawSource);
                         const src = lowerer.coerceToExpected(rawSource, DYN);
                         if (src.type.kind !== "dyn") {
                             ok = false;
@@ -6944,6 +7297,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 ...(fnName !== null ? { fnName } : {}),
             };
         }
+        // A class value (`Object.defineProperty(Definition, "name", { value })`)
+        // boxes to its constructor function, whose own-property table holds the
+        // definition for every alias of the class.
+        if (target?.type.kind === "classval" && lowerer.dynConvertible(target.type)) {
+            target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments.nodes[0]) };
+        }
         const descriptorPrimitive = member === "getOwnPropertyDescriptor" &&
             target &&
             (target.type.kind === "bool" || target.type.kind === "f64" || target.type.kind === "string");
@@ -7049,6 +7408,25 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     loc,
                 };
         }
+        const fnIntegrity = functionIntegrity(lowerer, member, value, call.arguments.nodes[0], locOf(call));
+        if (fnIntegrity)
+            return fnIntegrity;
+        // A Map or Set has no own properties: freeze, seal and preventExtensions
+        // all only make it not extensible.
+        if (value.type.kind === "map" || value.type.kind === "set") {
+            if (member === "preventExtensions" || member === "seal")
+                return lowerNativeFreeze(lowerer, "collection.preventExtensions", value, locOf(call));
+            const extensible = {
+                kind: "libCall",
+                fn: "collection.isExtensible",
+                args: [value],
+                type: BOOL,
+                loc: locOf(call),
+            };
+            return member === "isExtensible"
+                ? extensible
+                : { kind: "unary", op: "!", operand: extensible, type: BOOL, loc: locOf(call) };
+        }
         if (member === "preventExtensions" || member === "seal") {
             const integrity = lowerClassIntegrity(lowerer, call, member, value);
             if (integrity)
@@ -7085,10 +7463,42 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // the argument — no alias exists, so the frozen bit is unobservable
     // (writes through the Readonly<T> result are compile errors, and no
     // 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).
+    // Aliased records get the frozen bit of their rc word (frozen-records.ts);
+    // other aliased objects keep a fence: a later write through the original
+    // reference would need a runtime frozen bit (strict mode throws).
     if (member === "isFrozen" && call.arguments.nodes.length === 1) {
-        const value = lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN);
+        const argNode = call.arguments.nodes[0];
+        const probedKind = tryLowerExpression(lowerer, argNode)?.type.kind;
+        if (probedKind === "record" ||
+            probedKind === "array" ||
+            probedKind === "map" ||
+            probedKind === "set") {
+            const native = lowerer.lowerExpr(argNode);
+            const loc = locOf(call);
+            if (native.type.kind === "record" || native.type.kind === "array")
+                return {
+                    kind: "libCall",
+                    fn: native.type.kind === "record" ? "record.isFrozen" : "array.isFrozen",
+                    args: [native],
+                    type: BOOL,
+                    loc,
+                };
+            if (native.type.kind === "map" || native.type.kind === "set")
+                return {
+                    kind: "unary",
+                    op: "!",
+                    operand: {
+                        kind: "libCall",
+                        fn: "collection.isExtensible",
+                        args: [native],
+                        type: BOOL,
+                        loc,
+                    },
+                    type: BOOL,
+                    loc,
+                };
+        }
+        const value = lowerer.lowerExprExpecting(argNode, DYN);
         return { kind: "libCall", fn: "dyn.isFrozen", args: [value], type: BOOL, loc: locOf(call) };
     }
     if (member === "freeze") {
@@ -7126,9 +7536,18 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 arm.kind === "string" ||
                 arm.kind === "symbol"))
             return value;
+        const fnIntegrity = functionIntegrity(lowerer, "freeze", value, argNode, locOf(call));
+        if (fnIntegrity)
+            return fnIntegrity;
         const integrity = lowerClassIntegrity(lowerer, call, "freeze", value);
         if (integrity)
             return integrity;
+        if (freezableRecordType(lowerer, value.type))
+            return lowerNativeFreeze(lowerer, "record.freeze", value, locOf(call));
+        if (value.type.kind === "array")
+            return lowerNativeFreeze(lowerer, "array.freeze", value, locOf(call));
+        if (value.type.kind === "map" || value.type.kind === "set")
+            return lowerNativeFreeze(lowerer, "collection.preventExtensions", value, locOf(call));
         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
@@ -7296,10 +7715,14 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const isJsUnion = probed?.type.kind === "union" &&
             isJsSourceFile(ts.getSourceFileOfNode(call)) &&
             lowerer.dynConvertible(probed.type);
+        // An array walks its live view: the present indices, then its numeric
+        // and named properties.
+        const isArray = probed?.type.kind === "array" && lowerer.dynConvertible(probed.type);
         if (isDyn ||
             isPrimitive ||
             isFunction ||
             isJsUnion ||
+            isArray ||
             (probed && isDynTypedRefType(probed.type))) {
             const fn = member === "keys"
                 ? "dyn.objKeys"
@@ -7308,7 +7731,13 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     : "dyn.objEntries";
             let v = lowerer.lowerExpr(argNode);
             if (v.type.kind !== "dyn")
-                v = { kind: "dynFrom", value: v, type: DYN, loc: locOf(call) };
+                v = {
+                    kind: "dynFrom",
+                    value: v,
+                    ...(isArray ? { liveRef: true } : {}),
+                    type: DYN,
+                    loc: locOf(call),
+                };
             // In TypeScript the keys come back as a native string[] and the
             // entries as a native [string, any][]: the checker keeps every later
             // write to the arrays well typed. JavaScript may store anything into
@@ -7445,7 +7874,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
     const key = `obj.${member}:${argIr.shapeId}:${typeKey(resultT)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%obj.${member}.${lowerer.arrHofHelpers.size}`;
+        helper = keyedHelperName(lowerer, `%obj.${member}`, key);
         const recT = argIr;
         const ref = { kind: "varRef", localId: "r.0", type: recT, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: resultT, loc };
@@ -7471,8 +7900,10 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     loc,
                 },
             ];
-            const order = current.declaredOrder ?? current.fields.map((f) => f.name);
-            for (const name of order) {
+            // One walk per key order (see perKeyOrder).
+            const orders = shapeKeyOrders(current);
+            const walks = orders.map(() => []);
+            for (const [k, name] of orders.flatMap((order, k) => order.map((name) => [k, name]))) {
                 const f = current.fields.find((x) => x.name === name);
                 const raw = {
                     kind: "recordGet",
@@ -7627,8 +8058,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
                         loc,
                     };
                 }
-                body.push(stmt);
+                walks[k].push(stmt);
             }
+            body.push(...perKeyOrder(current, ref, walks, loc));
             body.push({ kind: "return", value: outRef, loc });
             fn.body = body;
         };
@@ -7863,7 +8295,17 @@ export function lowerRecordFieldCall(lowerer, call, access) {
     // A HYBRID (function-with-properties) field is callable through its
     // reserved %call slot — `colors.blue("x")` where blue also carries
     // `.bold` (the chalk shape).
-    if (callee.type.kind === "record")
+    if (callee.type.kind === "object" && !init) {
+        const direct = callableInstanceStringCall(lowerer, call, callee, loc);
+        if (direct)
+            return direct;
+        // Other argument counts call the %call closure through its value, as
+        // a call on the builder itself does (`theme.error("a", "b")`).
+        const closure = lowerer.hybridCallUnwrap(callee);
+        if (closure !== callee)
+            return lowerCallThroughValue(lowerer, call, closure, loc);
+    }
+    if (callee.type.kind === "record" || callee.type.kind === "object")
         callee = lowerer.hybridCallUnwrap(callee);
     // Inferred JavaScript option records can retain checked callables in
     // fields even when the checker only describes those members as any.
@@ -8008,7 +8450,7 @@ function lowerInlineArrowBind(lowerer, call, access) {
     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}`;
+    const name = existing ?? keyedHelperName(lowerer, "%arrow.bind", key);
     if (!existing) {
         lowerer.arrHofHelpers.set(key, name);
         lowerer.freshClosureAdapters.add(name);
@@ -8439,7 +8881,9 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     // so both guards would pass an emitter-named call).
     if (info &&
         !found &&
-        (STREAM_API_MEMBERS.has(access.name.text) || STREAM_OPERATORS.has(access.name.text)) &&
+        (STREAM_API_MEMBERS.has(access.name.text) ||
+            STREAM_OPERATORS.has(access.name.text) ||
+            access.name.text === "compose") &&
         streamSidesOf(lowerer, info) !== null) {
         const stream = lowerStreamMethodCall(lowerer, call, access, info);
         if (stream)
@@ -8462,6 +8906,10 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     if (info && !found && eventTargetApiMethod(info, access.name.text)) {
         return lowerEventTargetMethodCall(lowerer, call, access, info, lowerReceiver());
     }
+    // The Date methods a class declared `extends Date` does not declare.
+    if (info && !found && dateRootOf(info) && isDatePrototypeMethod(access.name.text)) {
+        return lowerInheritedDateMethodCall(lowerer, call, access.name.text, info, lowerReceiver());
+    }
     // GENERIC methods (own type parameters) never enter the methods table:
     // they monomorphize per call site and dispatch statically
     // (lowerClassGenericMethodCall has the exactness rules).
@@ -8636,7 +9084,23 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 type: found.sig.ret,
                 loc,
             };
-        const result = classCallbackCall(lowerer, value, method, call.arguments.nodes, fallback, loc, ts.getTextOfNode(access));
+        // The declaring class's original value, built with the observed slot.
+        // An override below (a virtual call) keeps the dynamic call: a slot
+        // reassigned to an ancestor's method must not reach the override. So do
+        // methods declared in unchecked JavaScript, whose results are inferred,
+        // and calls with a spread argument: the dynamic call drains the spread
+        // through the iterator's current `next`, which may be a replacement.
+        const declarerFile = found.declarer.decl ? ts.getSourceFileOfNode(found.declarer.decl) : null;
+        const original = virtual ||
+            call.arguments.nodes.some(ts.isSpreadElement) ||
+            !declarerFile ||
+            (isJsSourceFile(declarerFile) && !lowerer.checkedJsFile(declarerFile))
+            ? undefined
+            : {
+                originalId: () => found.declarer.prototypeOriginals?.get(method),
+                directCall: () => fallback,
+            };
+        const result = classCallbackCall(lowerer, value, method, call.arguments.nodes, fallback, loc, ts.getTextOfNode(access), original);
         return {
             kind: "seqExpr",
             stmts: [{ kind: "varDecl", localId: local.id, init: receiver, loc }],
@@ -8820,7 +9284,7 @@ function lowerUnionObjectDynFieldCall(lowerer, call, access, receiverT) {
     const receiverRef = varRef(receiverLocal.id, receiverT, loc);
     let helper = lowerer.unionCallHelpers.get(key);
     if (!helper) {
-        helper = `%union.call.${lowerer.unionCallHelpers.size}`;
+        helper = keyedHelperName(lowerer, "%union.call", key);
         lowerer.unionCallHelpers.set(key, helper);
         const receiverRef = varRef("this.0", receiverT, loc);
         const branch = (plan) => {
@@ -8900,7 +9364,7 @@ function unionObjectMethodHelper(lowerer, sourceCall, receiverT, method, plans,
     const existing = lowerer.unionCallHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%union.call.${lowerer.unionCallHelpers.size}`;
+    const name = keyedHelperName(lowerer, "%union.call", key);
     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.
@@ -9005,15 +9469,17 @@ function loweredArgumentText(lowerer, arg) {
  * fences; null when the argument shape has no static form (the caller
  * reports the SC2012 refusal). */
 export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
-    if (name === "parseInt" || name === "isNaN") {
+    if (name === "parseInt" || name === "isNaN" || name === "isFinite") {
         const maxArgs = name === "parseInt" ? 2 : 1;
         if (args.length < 1 || args.length > maxArgs) {
             lowerer.noLowering(`${name} with ${args.length} argument${args.length === 1 ? "" : "s"}`, call);
         }
-        if (name === "isNaN") {
-            // The global's ToNumber turns a missing value into NaN.
+        if (name === "isNaN" || name === "isFinite") {
+            // The global's ToNumber turns a missing value into NaN, converts
+            // strings, booleans and null, and calls valueOf/toString on objects.
             const x = lowerToNumberArgument(lowerer, args[0]);
-            return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
+            const fn = name === "isNaN" ? "num.isNaN" : "number.isFinite";
+            return { kind: "libCall", fn, args: [x], type: BOOL, loc };
         }
         const radix = args[1]
             ? lowerer.lowerExprExpecting(args[1], F64)
@@ -9050,7 +9516,7 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
                 const key = `parseInt.optional:${unionT.unionId}`;
                 let helper = lowerer.valueHelpers.get(key);
                 if (!helper) {
-                    helper = `%parseInt.optional.${lowerer.valueHelpers.size}`;
+                    helper = keyedHelperName(lowerer, "%parseInt.optional", key);
                     lowerer.valueHelpers.set(key, helper);
                     const value = { kind: "varRef", localId: "value.0", type: unionT, loc };
                     const radixRef = { kind: "varRef", localId: "radix.0", type: F64, loc };
@@ -9139,27 +9605,32 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
             : lowerer.lowerExprExpecting(args[0], STRING);
         return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc };
     }
-    // STATIC parseFloat/isFinite over exactly-typed arguments —
-    // parseInt's siblings (num.parseFloat is ECMA 19.2.4's decimal-
-    // literal prefix parse in scr_string.c; a number-typed isFinite IS
-    // Number.isFinite — the global's ToNumber coercion is the identity
-    // there, ms's `isFinite(val)` guard). Other argument types retain
-    // their native coercion checks or the SC2012 refusal. The probe never
-    // emits — lowering is IR construction.
-    if ((name === "parseFloat" || name === "isFinite") && args.length === 1) {
-        if (name === "parseFloat") {
-            const optional = optionalCallValue(lowerer, args[0]);
-            if (optional) {
-                const parsed = lowerOptionalStringNumber(lowerer, optional, loc, "num.parseFloat", "parseFloat");
-                if (parsed)
-                    return parsed;
-            }
+    // parseFloat takes one argument; Node ignores the rest after evaluating
+    // them (`parseFloat(text, 10)`). Literal and identifier extras have
+    // nothing to evaluate.
+    if (name === "parseFloat" &&
+        args.length > 1 &&
+        args
+            .slice(1)
+            .every((arg) => ts.isNumericLiteral(arg) || ts.isStringLiteral(arg) || ts.isIdentifier(arg)))
+        return lowerStaticNumberGlobal(lowerer, name, call, args.slice(0, 1), loc);
+    // STATIC parseFloat over string arguments — parseInt's sibling
+    // (num.parseFloat is ECMA 19.2.4's decimal-literal prefix parse in
+    // scr_string.c). Other argument types retain their native coercion
+    // checks or the SC2012 refusal. The probe never emits — lowering is IR
+    // construction.
+    if (name === "parseFloat" && args.length === 1) {
+        const optional = optionalCallValue(lowerer, args[0]);
+        if (optional) {
+            const parsed = lowerOptionalStringNumber(lowerer, optional, loc, "num.parseFloat", "parseFloat");
+            if (parsed)
+                return parsed;
         }
         const probed = tryLowerExpression(lowerer, args[0]);
-        if (name === "parseFloat" && probed?.type.kind === "string") {
+        if (probed?.type.kind === "string") {
             return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
         }
-        if (name === "parseFloat" && probed?.type.kind === "dyn") {
+        if (probed?.type.kind === "dyn") {
             return {
                 kind: "libCall",
                 fn: "num.parseFloat",
@@ -9168,29 +9639,38 @@ export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
                 loc,
             };
         }
-        if (name === "isFinite" && probed?.type.kind === "f64") {
-            return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
-        }
-        // A number the checker trusts but storage may hold missing (an
-        // out-of-range read): the global's ToNumber makes undefined NaN.
-        if (name === "isFinite" &&
-            probed?.type.kind === "union" &&
-            lowerer.armTag(probed.type.unionId, UNDEFINED_T) >= 0 &&
-            lowerer.stripUndefinedArm(probed.type).kind === "f64") {
-            const x = lowerOptionalNumber(lowerer, probed, loc, args[0]);
-            return { kind: "libCall", fn: "number.isFinite", args: [x], type: BOOL, loc };
-        }
     }
     return null;
 }
-/** `crypto.getRandomValues(view)` on the WebCrypto global or webcrypto. */
-function lowerWebCryptoGetRandomValues(lowerer, call, access) {
-    if (access.name.text !== "getRandomValues" ||
+/** `crypto.getRandomValues(view)` and `crypto.randomUUID()` on the
+ * WebCrypto global or webcrypto. Other argument counts (JavaScript only)
+ * invoke the dynamic object's method, which ignores extra arguments and
+ * throws Node's missing-argument TypeError. */
+function lowerWebCryptoMethodCall(lowerer, call, access) {
+    const member = access.name.text;
+    if ((member !== "getRandomValues" && member !== "randomUUID") ||
         call.questionDotToken ||
         access.questionDotToken ||
         !isWebCryptoReceiver(lowerer, access.expression))
         return null;
-    return lowerCryptoGetRandomValues(lowerer, call);
+    const args = call.arguments.nodes;
+    if (member === "getRandomValues" && args.length === 1) {
+        return lowerCryptoGetRandomValues(lowerer, call);
+    }
+    if (member === "randomUUID" && args.length === 0) {
+        return { kind: "libCall", fn: "crypto.randomUUID", args: [], type: STRING, loc: locOf(call) };
+    }
+    if (args.some(ts.isSpreadElement))
+        return null;
+    return {
+        kind: "dynInvoke",
+        recv: lowerer.lowerExprExpecting(access.expression, DYN),
+        method: member,
+        calleeName: v8CalleeText(access),
+        args: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+        type: DYN,
+        loc: locOf(call),
+    };
 }
 /** A then handler's promise-armed result (`.then(() => cached ?? load())`
  * typed `T | Promise<T>`, or a `Promise<void> | void` callback's result):
@@ -9293,4 +9773,174 @@ function lowerObjectAssignOntoError(lowerer, call) {
         loc,
     };
 }
+/** `Object.freeze(fn)` and the other integrity operations on a function
+ * value: the function's checked-dynamic face holds its own properties (the
+ * ones a program assigns, `name`, `length`, `prototype`) and their
+ * integrity state, which the runtime keeps on its property table. The
+ * mutators answer the function itself; the queries answer from the table.
+ * Null for other values. */
+function functionIntegrity(lowerer, member, value, node, loc) {
+    if (value.type.kind !== "func" || !lowerer.dynConvertible(value.type))
+        return null;
+    const operations = {
+        freeze: "dyn.freeze",
+        seal: "dyn.seal",
+        preventExtensions: "dyn.preventExtensions",
+        isSealed: "dyn.isSealed",
+        isExtensible: "dyn.isExtensible",
+    };
+    if (!(member in operations))
+        return null;
+    const fn = operations[member];
+    // The first operation on a function creates its property table, whose
+    // `name` comes from the box: give the box the function's JS name, as a
+    // closure flowing into any checked-dynamic slot gets.
+    const name = jsFuncNameOf(node, lowerer);
+    const boxed = (e) => {
+        const box = lowerer.coerceToExpected(e, DYN);
+        return box.kind === "dynFrom" && name !== null ? { ...box, fnName: name } : box;
+    };
+    if (fn === "dyn.isSealed" || fn === "dyn.isExtensible") {
+        return { kind: "libCall", fn, args: [boxed(value)], type: BOOL, loc };
+    }
+    const held = lowerer.declareHiddenLocal("%integrityFn", value.type);
+    const ref = () => ({ kind: "varRef", localId: held.id, type: value.type, loc });
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: held.id, init: value, loc },
+            {
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn, args: [boxed(ref())], type: DYN, loc },
+                loc,
+            },
+        ],
+        result: ref(),
+        type: value.type,
+        loc,
+    };
+}
+/** 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). */
+function fenceClassCopyIntoFreshObject(lowerer, call, srcNode, rawSource) {
+    if (rawSource.type.kind !== "object" || ts.isExpressionStatement(call.parent))
+        return;
+    const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+    if (resultT === null || resultT.kind !== "object")
+        return;
+    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)`);
+}
+/** True when an untyped JavaScript receiver names a binding whose declaring
+ * file assigns it an own `toString` (the TypeScript namespace downlevel
+ * `errorUtil.toString = (message) => ...` in zod): its calls answer what
+ * that function returns, not Object.prototype.toString's string. */
+function jsAssignsOwnToString(lowerer, receiver) {
+    if (!ts.isIdentifier(receiver))
+        return false;
+    const decl = bindingDeclaration(lowerer, receiver);
+    if (decl === undefined)
+        return false;
+    const sf = ts.getSourceFileOfNode(decl);
+    if (!isJsSourceFile(sf))
+        return false;
+    let targets = lowerer.ownToStringTargets.get(sf);
+    if (targets === undefined) {
+        targets = ownToStringTargets(lowerer, sf);
+        lowerer.ownToStringTargets.set(sf, targets);
+    }
+    return targets.has(decl);
+}
+const unparenthesized = (e) => {
+    let out = e;
+    while (ts.isParenthesizedExpression(out))
+        out = out.expression;
+    return out;
+};
+/** The declaration of the binding an identifier names, through imports. */
+function bindingDeclaration(lowerer, id) {
+    let sym = lowerer.checker.getSymbolAtLocation(id);
+    if (sym !== undefined && (sym.flags & ts.SymbolFlags.Alias) !== 0)
+        sym = lowerer.checker.getAliasedSymbol(sym);
+    return sym?.valueDeclaration ?? sym?.declarations?.[0];
+}
+/** The declarations of the bindings a file's assignments `x.toString = ...`
+ * (or `x["toString"] = ...`) give an own `toString`. An assignment through
+ * the parameter of an immediately called function counts for the binding
+ * the call passes (`(function (ns) { ns.toString = f; })(ns || (ns = {}))`). */
+function ownToStringTargets(lowerer, sf) {
+    const targets = new Set();
+    const visit = (node) => {
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            const left = unparenthesized(node.left);
+            const named = (ts.isPropertyAccessExpression(left) && left.name.text === "toString") ||
+                (ts.isElementAccessExpression(left) &&
+                    ts.isStringLiteralLike(left.argumentExpression) &&
+                    left.argumentExpression.text === "toString");
+            const target = named
+                ? unparenthesized(left.expression)
+                : undefined;
+            if (target !== undefined && ts.isIdentifier(target)) {
+                const decl = bindingDeclaration(lowerer, target);
+                if (decl !== undefined) {
+                    targets.add(decl);
+                    const passed = iifeArgumentDeclaration(lowerer, decl);
+                    if (passed !== undefined)
+                        targets.add(passed);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return targets;
+}
+/** For a parameter of an immediately called function, the declaration of
+ * the binding its argument names: `x`, `x || (x = {})` or `(x = {})`. */
+function iifeArgumentDeclaration(lowerer, param) {
+    if (!ts.isParameter(param))
+        return undefined;
+    const fn = param.parent;
+    if (!ts.isFunctionExpression(fn) && !ts.isArrowFunction(fn))
+        return undefined;
+    let callee = fn;
+    while (ts.isParenthesizedExpression(callee.parent))
+        callee = callee.parent;
+    const call = callee.parent;
+    if (!ts.isCallExpression(call) || call.expression !== callee)
+        return undefined;
+    const index = fn.parameters.nodes.indexOf(param);
+    let arg = index < 0 ? undefined : call.arguments.nodes[index];
+    if (arg === undefined)
+        return undefined;
+    arg = unparenthesized(arg);
+    if (ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+        arg = unparenthesized(arg.left);
+    if (ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+        arg = unparenthesized(arg.left);
+    return ts.isIdentifier(arg) ? bindingDeclaration(lowerer, arg) : undefined;
+}
+/** The runtime calls package shims declare as bodiless functions. */
+const SHIM_INTRINSICS = new Map([
+    ["scriptcUnixDgramSocket", { fn: "dgram.unixSocket", args: [], ret: F64 }],
+    ["scriptcUnixDgramConnect", { fn: "dgram.unixConnect", args: [F64, STRING], ret: F64 }],
+    ["scriptcUnixDgramSend", { fn: "dgram.unixSend", args: [F64, BYTES_U8], ret: F64 }],
+    ["scriptcUnixDgramClose", { fn: "dgram.unixClose", args: [F64], ret: F64 }],
+    ["scriptcResponseLight", { fn: "fetch.responseLight", args: [DYN], ret: arrayOf(STRING) }],
+]);
+function lowerShimIntrinsicCall(lowerer, expr, callee, loc) {
+    const intrinsic = SHIM_INTRINSICS.get(callee.text);
+    if (intrinsic === undefined)
+        return null;
+    const decl = lowerer.checker.getSymbolAtLocation(callee)?.valueDeclaration;
+    if (decl === undefined ||
+        !ts.isFunctionDeclaration(decl) ||
+        decl.body ||
+        !isPackageShimFile(ts.getSourceFileOfNode(decl).fileName) ||
+        expr.arguments.nodes.length !== intrinsic.args.length)
+        return null;
+    const args = expr.arguments.nodes.map((arg, i) => lowerer.lowerExprExpecting(arg, intrinsic.args[i]));
+    return { kind: "libCall", fn: intrinsic.fn, args, type: intrinsic.ret, loc };
+}
 //# sourceMappingURL=lower-calls.js.map