@scriptc/compiler 0.4.8 → 0.4.9

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

@@ -36,6 +36,7 @@ import { InternalCompilerError } from "../../errors.js";
 import { isFsStreamMember, lowerFsStreamCall, lowerFsStreamMethodCall, } from "./builtins/fs-streams.js";
 import * as ts from "../ts7/adapter.js";
 import { isZlibStreamMember, lowerPromisifiedZlibCall, lowerZlibStreamMethodCall, } from "./builtins/compression.js";
+import { callableMemberFieldTarget, lowerCallableAssign } from "./callable-properties.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";
@@ -83,11 +84,11 @@ import { lowerAbsenceProbe, v8CalleeText, lowerPromiseAllTupleCall, lowerPromise
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { nullishLiteral, nullishReadTypeError, throwAfterEach } from "./primitive-throws.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
-import { lowerChildMethodValue, lowerChildPropertyCall } from "./handle-properties.js";
+import { boxedHandleReceiver, lowerChildMethodValue, lowerChildPropertyCall, lowerHandleMemberCall, refuseShadowedImplicitReader, } from "./handle-properties.js";
 import { classObjectTag, 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 { httpClientFnBindingOf, httpClientFnRefOf, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall, lowerHttpClientFnRefCall, } 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";
 import { emitOverrideAtOrAbove, emitterRooted, lowerEmitterMethodCall, } from "./lower-event-emitter.js";
@@ -97,7 +98,7 @@ import { lowerConsoleInstanceCall, lowerConsoleMethodCall, lowerConsoleOutput, }
 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";
 import { hostGlobalNameOfRead, hostGlobalPrototypeMemberOf } from "./host-globals.js";
-import { expandoMemberRead } from "./lower-expando.js";
+import { fenceExpandoRead } from "./lower-expando.js";
 import { fenceNodeModuleMutationCall, isCjsRequireGlobal, lowerRequireCacheKeys, } from "./lower-node-module.js";
 import { pathModuleValue } from "./lower-builtin-values.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, positionNumber, } from "./optional-arguments.js";
@@ -186,6 +187,29 @@ function receiverlessCalleeOf(callee) {
         right = right.expression;
     return right;
 }
+/** `fn.member(args)` where `member` is a key of the callable's own-property
+ * table: the member read through the table (checked back into the declared
+ * member type, like every other table read) yields the function value, and
+ * the call goes through that value. A function's own data property shadows
+ * an inherited `Function.prototype` member (`fn.toString` above all), so
+ * this is the call form of that shadowing. */
+function lowerCallableMemberCall(lowerer, call) {
+    const access = call.expression;
+    if (!ts.isPropertyAccessExpression(access))
+        return null;
+    if (access.questionDotToken || call.questionDotToken)
+        return null;
+    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    if (receiverIr?.kind !== "func")
+        return null;
+    const target = callableMemberFieldTarget(lowerer, access, receiverIr);
+    if (!target || target.fieldType.kind !== "func")
+        return null;
+    const callee = lowerer.fieldGetExpr(target, locOf(access), access);
+    if (callee.type.kind !== "func")
+        return null;
+    return lowerCallThroughValue(lowerer, call, callee, locOf(call));
+}
 export function lowerCall(lowerer, expr) {
     const loc = locOf(expr);
     // A JavaScript source calling a member that resizes, grows or detaches a
@@ -824,6 +848,7 @@ export function lowerCall(lowerer, expr) {
         const arg = lowerer.lowerExpr(argNode);
         if (name === "String" &&
             (arg.type.kind === "dyn" ||
+                arg.type.kind === "symbol" ||
                 (arg.type.kind === "union" &&
                     lowerer.unions.get(arg.type.unionId)?.arms.some((arm) => arm.kind === "symbol") &&
                     lowerer.dynConvertible(arg.type)))) {
@@ -873,7 +898,7 @@ export function lowerCall(lowerer, expr) {
                     kind: "dynCall",
                     callee,
                     receiver,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args,
                     ...(spreads.length > 0 ? { spreads } : {}),
                     type: DYN,
@@ -923,6 +948,11 @@ export function lowerCall(lowerer, expr) {
             if (projection?.kind === "builtin-function") {
                 return lowerBuiltinCall(lowerer, expr, { module: projection.module, member: projection.member }, loc);
             }
+            // A call through an immutable alias of an http/https client
+            // function (`const httpsRequest = https.request`).
+            if (projection?.kind === "client-function") {
+                return lowerHttpClientFnRefCall(lowerer, expr, { module: projection.module, member: projection.member }, loc);
+            }
             // A call through a `const requestFn = tls ? https.request :
             // http.request` binding (the client-function ternary): the http
             // client lowering with the RUNTIME-secure dial.
@@ -941,6 +971,13 @@ export function lowerCall(lowerer, expr) {
         const bi = lowerer.builtinImportOf(expr.expression);
         if (bi)
             return lowerBuiltinCall(lowerer, expr, bi, loc);
+        // A call through an alias of an http/https client function whose
+        // declaration is another module's (`import { request } from "./net"`).
+        {
+            const ref = httpClientFnRefOf(lowerer, expr.expression);
+            if (ref)
+                return lowerHttpClientFnRefCall(lowerer, expr, ref, loc);
+        }
         // A constant bound to an assert method (`const ok = assert.ok`) called
         // directly is that assertion, with the message Node quotes the call for.
         {
@@ -1202,18 +1239,13 @@ export function lowerCall(lowerer, expr) {
         }
     }
     // Expando member calls (`example.isFoo('test')` after `example.isFoo
-    // = fn`): read the member's global and call through the value —
-    // lower-expando.ts owns the member storage.
+    // = fn`): the member read goes through the closure's own-property table
+    // like any other member (lowering/callable-properties.ts); only the
+    // source-order fence lives here (lower-expando.ts).
     if ((ts.isPropertyAccessExpression(expr.expression) ||
         ts.isElementAccessExpression(expr.expression)) &&
         !expr.expression.questionDotToken) {
-        const callee = expandoMemberRead(lowerer, expr.expression);
-        if (callee) {
-            if (callee.type.kind !== "func")
-                lowerer.badType(expr.expression, lowerer.typeOf(expr.expression));
-            const args = completeFuncValueArgs(lowerer, expr, callee.type, loc);
-            return { kind: "callValue", callee, args, type: callee.type.ret, loc };
-        }
+        fenceExpandoRead(lowerer, expr.expression);
     }
     // Namespace-qualified calls (`N.f(1)`, `A.B.g()`, calls through
     // import= alias chains): the member resolves like a bare identifier —
@@ -1354,6 +1386,11 @@ export function lowerCall(lowerer, expr) {
         const intrinsic = 
         // Checked-dynamic stream slots dispatch per value (dyn-streams.ts).
         lowerDynStreamMemberCall(lowerer, expr, expr.expression) ??
+            // A class member the program's JavaScript shadows on a typed handle
+            // (`d.getTime = () => 42; d.getTime()`): the own property's call on
+            // the handle's checked-dynamic box, before the typed method lowerings
+            // below claim the name (handle-properties.ts).
+            lowerHandleMemberCall(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.
@@ -1604,6 +1641,11 @@ export function lowerCall(lowerer, expr) {
             if (childCall)
                 return childCall;
         }
+        {
+            const tableCall = lowerCallableMemberCall(lowerer, expr);
+            if (tableCall)
+                return tableCall;
+        }
         // The lib fence's METHOD-CALL chokepoint: a stdlib-declared member
         // that every lowering above declined — an unlowered member
         // (m.keys(), p.then(f), Object.keys(o)) or an unlowered call FORM of
@@ -1711,7 +1753,7 @@ export function lowerCall(lowerer, expr) {
                     kind: "dynCall",
                     callee,
                     receiver,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: expr.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
@@ -1737,6 +1779,12 @@ export function lowerCall(lowerer, expr) {
         const memberName = ts.isNumericLiteral(expr.expression.argumentExpression)
             ? String(Number(expr.expression.argumentExpression.text))
             : expr.expression.argumentExpression.text;
+        // `d["getTime"]()` over a typed handle whose member the program shadows:
+        // the own property's call on the checked-dynamic box, before the typed
+        // member lowering below claims the name (handle-properties.ts).
+        const shadowed = lowerHandleMemberCall(lowerer, expr, expr.expression, memberName);
+        if (shadowed)
+            return shadowed;
         const receiverType = lowerer.mapTypeOf(lowerer.typeOf(expr.expression.expression));
         if (receiverType?.kind === "object") {
             const info = lowerer.classes.get(receiverType.className);
@@ -2000,12 +2048,9 @@ function lowerCallThroughValueRaw(lowerer, expr, callee, loc) {
             lowerer.unsupported("SC1090", expr, "spread arguments in calls through 'unknown' values");
         }
         const args = expr.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN));
-        const calleeName = ts.isPropertyAccessExpression(expr.expression) ||
-            ts.isElementAccessExpression(expr.expression)
-            ? ts.getTextOfNode(expr.expression)
-            : ts.isIdentifier(expr.expression)
-                ? expr.expression.text
-                : "value";
+        // V8 names the callee it could not call with the source spelling minus
+        // the type-only syntax the running JavaScript never had.
+        const calleeName = v8CalleeText(expr.expression);
         return { kind: "dynCall", callee, calleeName, args, type: DYN, loc };
     }
     if (callee.type.kind === "union" &&
@@ -2062,7 +2107,7 @@ function lowerCallThroughValueRaw(lowerer, expr, callee, loc) {
         !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.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN));
-        const calleeName = ts.isIdentifier(expr.expression) ? expr.expression.text : "value";
+        const calleeName = v8CalleeText(expr.expression);
         const boxed = { kind: "dynFrom", value: callee, type: DYN, loc };
         return { kind: "dynCall", callee: boxed, calleeName, args, type: DYN, loc };
     }
@@ -2351,9 +2396,13 @@ function lowerNumberConstructorValue(lowerer, argNode, loc) {
     const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
     if (optionalNumber)
         return optionalNumber;
-    // A Date's number hint answers its time value.
-    if (arg.type.kind === "date")
+    // A Date's number hint answers its time value. The number hint reads
+    // valueOf, which the program may have replaced with an own property this
+    // typed path cannot see.
+    if (arg.type.kind === "date") {
+        refuseShadowedImplicitReader(lowerer, argNode, arg.type, "valueOf", "number conversion");
         return { kind: "libCall", fn: "date.valueOf", args: [arg], type: F64, loc };
+    }
     // A program class instance converts through its own methods.
     const classNumber = classToNumberConversion(lowerer, arg, argNode);
     if (classNumber)
@@ -2752,7 +2801,9 @@ function lowerObjectOwnMethodCall(lowerer, call, access) {
         return null;
     if (!lowerer.isStdlibMember(access)) {
         const receiver = tryLowerExpression(lowerer, access.expression);
-        if (receiver?.type.kind !== "dyn")
+        // A typed handle in a program that adds properties to handles answers
+        // from its own property table (scr_dyn_handle_props.c).
+        if (receiver?.type.kind !== "dyn" && !boxedHandleReceiver(lowerer, receiver))
             return null;
     }
     return lowerObjectOwnCall(lowerer, call, access.expression, call.arguments.nodes[0], call.arguments.nodes.slice(1), method, access);
@@ -2801,6 +2852,9 @@ methodAccess = null) {
         stmts.push({ kind: "varDecl", localId: local.id, init: receiver, loc });
         receiverRef = varRef(local.id, receiver.type, loc);
     }
+    // A typed handle in a program that adds properties to handles answers
+    // from its own property table (scr_dyn_handle_props.c).
+    const handleBox = boxedHandleReceiver(lowerer, receiverRef);
     const rawKey = keyNode ? lowerer.lowerExpr(keyNode) : null;
     let keyRef = rawKey;
     if (rawKey && (isUnitType(rawKey.type) || rawKey.type.kind === "void")) {
@@ -2961,6 +3015,18 @@ methodAccess = null) {
             : no;
         result = { kind: "logical", op: "||", left: lengthOwn, right: indexOwn, type: BOOL, loc };
     }
+    else if (handleBox) {
+        if (enumerable)
+            result = {
+                kind: "libCall",
+                fn: "dyn.propertyIsEnumerable",
+                args: [handleBox, key],
+                type: BOOL,
+                loc,
+            };
+        else
+            result = { kind: "libCall", fn: "dyn.hasOwn", args: [handleBox, key], type: BOOL, loc };
+    }
     else if (type.kind === "f64" ||
         type.kind === "bool" ||
         type.kind === "bigint" ||
@@ -3150,6 +3216,14 @@ function lowerStringPrototypeCall(lowerer, call, access) {
     if (receiverType.kind === "dyn") {
         return lowerDynamicStringPrototypeCall(lowerer, call, methodAccess, receiverValue, method);
     }
+    // A symbol receiver is no String wrapper, and every method admitted above
+    // begins with ToString(this): Node throws
+    // "TypeError: Cannot convert a Symbol value to a string" after evaluating
+    // the arguments. The dynamic string-method lowering performs exactly that
+    // conversion, in that order.
+    if (receiverType.kind === "symbol") {
+        return lowerDynamicStringPrototypeCall(lowerer, call, methodAccess, lowerer.coerceToExpected(receiverValue, DYN), method);
+    }
     const padding = entry?.method === "padStart" || entry?.method === "padEnd";
     const scalar = receiverType.kind === "string" ||
         receiverType.kind === "f64" ||
@@ -3377,9 +3451,15 @@ function isFreshCallResult(node) {
  * and calls it. Box the receiver into the checked-dynamic value and lower
  * the read and the call dynamically, so the member lookup and the call stay
  * checked (a missing member throws V8's own TypeError) and the result
- * crosses back through the expected type's checked conversion. Null when
- * the receiver is not a union of object/record arms with a dyn-safe layout,
- * leaving the method-call fence in place. */
+ * crosses back through the expected type's checked conversion.
+ *
+ * A non-object arm joins the union when it does not declare the member at
+ * all (commander's `string | Command` from `name()`, whose JSDoc returns
+ * both): calling the member there is the same "is not a function" TypeError
+ * the dynamic call throws, so the result is Node-exact. An arm that DOES
+ * declare it (a string's toUpperCase) stays fenced: the dynamic tier cannot
+ * run a primitive's own methods, and calling through would throw where Node
+ * succeeds. Null for anything else, leaving the method-call fence in place. */
 function lowerUnionReceiverMethodCall(lowerer, call, access) {
     if (access.questionDotToken || call.questionDotToken)
         return null;
@@ -3389,9 +3469,8 @@ function lowerUnionReceiverMethodCall(lowerer, call, access) {
     if (value?.type.kind !== "union")
         return null;
     const union = lowerer.unions.get(value.type.unionId);
-    if (!union || !union.arms.every((arm) => arm.kind === "object" || arm.kind === "record")) {
+    if (!union || !unionArmsDispatchMember(lowerer, union.arms, access))
         return null;
-    }
     if (!lowerer.dynConvertible(value.type))
         return null;
     const loc = locOf(call);
@@ -3412,7 +3491,7 @@ function lowerUnionReceiverMethodCall(lowerer, call, access) {
             kind: "dynCall",
             callee: member,
             receiver,
-            calleeName: ts.getTextOfNode(access),
+            calleeName: v8CalleeText(access),
             args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
             type: DYN,
             loc,
@@ -3421,6 +3500,40 @@ function lowerUnionReceiverMethodCall(lowerer, call, access) {
         loc,
     };
 }
+/** Primitive arms a union receiver may carry next to its object/record
+ * arms (commander's `string | Command`): the dynamic value holds each one
+ * as its own kind, so a member the arm does not have reads as undefined. */
+const UNION_RECEIVER_PRIMITIVE_ARMS = new Set([
+    "string",
+    "f64",
+    "bool",
+    "bigint",
+    "undefinedT",
+    "nullT",
+]);
+/** True when every arm of the receiver union can ride the dynamic call:
+ * object and record arms always (the lookup and the call stay checked), and
+ * a primitive arm only when its static type does not declare the member at
+ * all — the call there is V8's "is not a function" TypeError, which the
+ * dynamic call reproduces. An arm with the member (a string's toUpperCase)
+ * keeps the fence: the dynamic tier cannot run a primitive's own methods. */
+function unionArmsDispatchMember(lowerer, arms, access) {
+    if (arms.every((arm) => arm.kind === "object" || arm.kind === "record"))
+        return true;
+    if (!arms.every((arm) => arm.kind === "object" ||
+        arm.kind === "record" ||
+        UNION_RECEIVER_PRIMITIVE_ARMS.has(arm.kind)))
+        return false;
+    const receiver = lowerer.typeOf(access.expression);
+    const parts = receiver.isUnionType() ? ts.constituentTypes(receiver) : [receiver];
+    for (const part of parts) {
+        if ((part.flags & ts.TypeFlags.Object) !== 0)
+            continue;
+        if (lowerer.checker.getPropertyOfType(part, access.name.text) !== undefined)
+            return false;
+    }
+    return true;
+}
 /** 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
@@ -3535,7 +3648,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
                     kind: "dynCall",
                     callee: member,
                     receiver,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
@@ -3695,7 +3808,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
                             kind: "dynInvoke",
                             recv: value,
                             method: "normalize",
-                            calleeName: ts.getTextOfNode(access),
+                            calleeName: v8CalleeText(access),
                             args: hasArgument ? [argument] : [],
                             type: DYN,
                             loc,
@@ -3957,7 +4070,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
             kind: "dynCall",
             callee,
             receiver,
-            calleeName: ts.getTextOfNode(access),
+            calleeName: v8CalleeText(access),
             args,
             type: DYN,
             loc,
@@ -4070,7 +4183,7 @@ function lowerStringOrMemberCall(lowerer, call, access, recv) {
         kind: "dynCall",
         callee,
         receiver,
-        calleeName: ts.getTextOfNode(access),
+        calleeName: v8CalleeText(access),
         args: args.map((arg) => lowerer.coerceToExpected(arg.value, DYN)),
         type: DYN,
         loc,
@@ -4498,7 +4611,7 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
                         kind: "dynInvoke",
                         recv: { kind: "varRef", localId: saved.id, type: DYN, loc: locOf(access.expression) },
                         method,
-                        calleeName: ts.getTextOfNode(access),
+                        calleeName: v8CalleeText(access),
                         args: [dynUndefinedExpr(locOf(call.arguments.nodes[0]))],
                         type: DYN,
                         loc: locOf(call),
@@ -4533,7 +4646,7 @@ export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayRec
         kind: "dynInvoke",
         recv,
         method,
-        calleeName: ts.getTextOfNode(access),
+        calleeName: v8CalleeText(access),
         args,
         type: DYN,
         loc: locOf(call),
@@ -5094,7 +5207,7 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
                 kind: "dynInvoke",
                 recv: lowerer.coerceToExpected(operand, DYN),
                 method: name,
-                calleeName: `${ts.getTextOfNode(recv)}.${name}`,
+                calleeName: `${v8CalleeText(recv)}.${name}`,
                 args: call.arguments.nodes.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
                 type: DYN,
                 loc: locOf(call),
@@ -5534,11 +5647,7 @@ export function lowerTaggedTemplate(lowerer, expr) {
             loweredTemplateStrings(lowerer, expr, pieces.map((piece) => piece.text), loc, pieces.map(templateRawTextOf)),
             ...values.map((a) => lowerer.lowerExprExpecting(a, DYN)),
         ];
-        const calleeName = ts.isPropertyAccessExpression(expr.tag) || ts.isElementAccessExpression(expr.tag)
-            ? ts.getTextOfNode(expr.tag)
-            : ts.isIdentifier(expr.tag)
-                ? expr.tag.text
-                : "value";
+        const calleeName = v8CalleeText(expr.tag);
         return { kind: "dynCall", callee, calleeName, args, type: DYN, loc };
     }
     lowerer.unsupported("SC1090", expr, "tagged templates with this tag form (top-level functions and dynamic values tag; call the function directly otherwise)");
@@ -5840,7 +5949,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                     kind: "dynInvoke",
                     recv: lowerer.coerceToExpected(receiver, DYN),
                     method: "then",
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: [
                         lowerer.lowerExprExpecting(fulfilledNode, DYN),
                         lowerer.lowerExprExpecting(rejectedNode, DYN),
@@ -6288,7 +6397,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 kind: "dynInvoke",
                 recv: lowerer.coerceToExpected(receiver, DYN),
                 method: "finally",
-                calleeName: ts.getTextOfNode(access),
+                calleeName: v8CalleeText(access),
                 args: [lowerer.coerceToExpected(cb, DYN)],
                 type: DYN,
                 loc,
@@ -6498,12 +6607,6 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     if (param && (!ts.isIdentifier(param.name) || param.dotDotDotToken || param.initializer)) {
         lowerer.unsupported("SC1062", param);
     }
-    if (param?.type &&
-        param.type.kind !== ts.SyntaxKind.AnyKeyword &&
-        param.type.kind !== ts.SyntaxKind.UnknownKeyword) {
-        lowerer.unsupported("SC1090", param, "catch handlers with a typed parameter (the reject payload can be any thrown " +
-            "value — take `(e)` or `(e: unknown)` and narrow with instanceof)");
-    }
     const resultT = callResultType();
     if (resultT?.kind !== "promise") {
         lowerer.noLowering("catch with this handler's result type", call, "the combined result must be representable — a handler with no return value over a " +
@@ -6531,13 +6634,61 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             ]
             : [{ kind: "return", value: lowerer.coerceInto(call, awaitE, R), loc }];
         // The handler body lowers as the catch clause, its parameter bound
-        // as the CAUGHT local — exactly `catch (e) { ... }`.
+        // as the CAUGHT local — exactly `catch (e) { ... }`. An ANNOTATED
+        // parameter (`.catch((error: Error) => ...)`) is a claim the checker
+        // cannot verify — the reject payload is whatever was thrown — so it
+        // is never trusted: the snapshot binds as a hidden CAUGHT local and
+        // the parameter as an ordinary local of the claimed class, converted
+        // by the checked extraction (`caughtCheck`: an instanceof match
+        // extracts the payload, anything else raises the catchable TypeError
+        // at handler entry). Reads inside the handler are then plain typed
+        // reads of a verified value.
         let catchLocalId = null;
+        let claimInit = null;
         let catchBody;
         lowerer.scopes.push(new Map());
         try {
             if (param && ts.isIdentifier(param.name)) {
-                catchLocalId = lowerer.declareLocal(param.name, param.name.text, CAUGHT, false).id;
+                const claim = param.type;
+                const annotated = claim !== undefined &&
+                    claim.kind !== ts.SyntaxKind.AnyKeyword &&
+                    claim.kind !== ts.SyntaxKind.UnknownKeyword;
+                if (annotated) {
+                    const target = lowerer.mapTypeOf(lowerer.checker.getTypeFromTypeNode(claim));
+                    const info = target?.kind === "object" ? lowerer.classes.get(target.className) : undefined;
+                    if (target === null || target.kind !== "object" || info === undefined) {
+                        lowerer.unsupported("SC1090", claim, "catch parameters annotated with a type other than a class (the reject payload " +
+                            "is whatever was thrown, so an annotation is a claim the checker cannot " +
+                            "verify — it is accepted only as a checked conversion against a class) — take " +
+                            "`(e)` and narrow with instanceof, or assert `e as C` inside the handler");
+                    }
+                    const snapshot = lowerer.declareHiddenLocal("%catch", CAUGHT);
+                    catchLocalId = snapshot.id;
+                    const local = lowerer.declareLocal(param.name, param.name.text, target, false);
+                    const caught = { kind: "varRef", localId: snapshot.id, type: CAUGHT, loc };
+                    // caughtCheck tests the class's preorder interval, which only
+                    // classes in an inheritance relation have; a standalone class
+                    // converts the payload as an untyped value, whose checked
+                    // conversion recovers a thrown instance and raises a catchable
+                    // TypeError for anything else.
+                    claimInit = {
+                        kind: "varDecl",
+                        localId: local.id,
+                        init: lowerer.inHierarchy(info)
+                            ? {
+                                kind: "caughtCheck",
+                                value: caught,
+                                className: target.className,
+                                type: target,
+                                loc,
+                            }
+                            : lowerer.coerceToExpected({ kind: "caughtToDyn", value: caught, type: DYN, loc }, target),
+                        loc,
+                    };
+                }
+                else {
+                    catchLocalId = lowerer.declareLocal(param.name, param.name.text, CAUGHT, false).id;
+                }
             }
             const hb = handlerNode.body;
             if (ts.isBlock(hb)) {
@@ -6558,6 +6709,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         finally {
             lowerer.scopes.pop();
         }
+        if (claimInit !== null)
+            catchBody.unshift(claimInit);
         // A handler falling off its end resolves with undefined — the
         // checker already typed R with the undefined arm; the appended wrap
         // also satisfies the validator's always-returns analysis.
@@ -7822,9 +7975,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const onError = lowerObjectAssignOntoError(lowerer, call);
         if (onError)
             return onError;
-        const hybrid = lowerObjectAssignHybrid(lowerer, call);
-        if (hybrid)
-            return hybrid;
+        // `Object.assign(fn, ...)` on a TYPED callable: the source keys land on
+        // the closure's own-property table and the expression is that function
+        // (one representation — no record stands for it).
+        const callableAssign = lowerCallableAssign(lowerer, call);
+        if (callableAssign)
+            return callableAssign;
         // `Object.assign({}, lit)` — an EMPTY fresh-literal target and one
         // object-literal source: the result is a fresh object carrying
         // exactly the source literal's properties, which IS the source
@@ -8179,6 +8335,13 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const descriptorPrimitive = member === "getOwnPropertyDescriptor" &&
             target &&
             (target.type.kind === "bool" || target.type.kind === "f64" || target.type.kind === "string");
+        // A typed handle target in a program that adds properties to handles:
+        // its property table answers (scr_dyn_handle_props.c).
+        if (target && target.type.kind !== "dyn") {
+            const boxed = boxedHandleReceiver(lowerer, target);
+            if (boxed)
+                target = boxed;
+        }
         if (!target || (target.type.kind !== "dyn" && !isUnitType(target.type) && !descriptorPrimitive))
             return null;
         if (target.type.kind !== "dyn")
@@ -8258,6 +8421,13 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     lowerer.dynConvertible(target.type)))) {
             target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments.nodes[0]) };
         }
+        // A typed handle target in a program that adds properties to handles:
+        // its property table answers (scr_dyn_handle_props.c).
+        if (target && target.type.kind !== "dyn") {
+            const boxed = boxedHandleReceiver(lowerer, target);
+            if (boxed)
+                target = boxed;
+        }
         if (target?.type.kind === "dyn") {
             const descs = lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN);
             if (descs.type.kind === "dyn") {
@@ -8303,6 +8473,29 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const fnIntegrity = functionIntegrity(lowerer, member, value, call.arguments.nodes[0], locOf(call));
         if (fnIntegrity)
             return fnIntegrity;
+        // A typed handle in a program that adds properties to handles: the
+        // table holds the integrity state, so the checked-dynamic entries
+        // answer (scr_dyn_handle_props.c). The queries are the hook-carrying
+        // entries; with the table installed they answer from it.
+        {
+            const boxed = boxedHandleReceiver(lowerer, value);
+            if (boxed) {
+                const operation = {
+                    preventExtensions: "dyn.preventExtensions",
+                    isExtensible: "dyn.isExtensibleQuery",
+                    seal: "dyn.seal",
+                    isSealed: "dyn.isSealedQuery",
+                };
+                const query = member.startsWith("is");
+                return {
+                    kind: "libCall",
+                    fn: operation[member],
+                    args: [boxed],
+                    type: query ? BOOL : DYN,
+                    loc: locOf(call),
+                };
+            }
+        }
         // 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") {
@@ -8378,7 +8571,15 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // reference would need a runtime frozen bit (strict mode throws).
     if (member === "isFrozen" && call.arguments.nodes.length === 1) {
         const argNode = call.arguments.nodes[0];
-        const probedKind = tryLowerExpression(lowerer, argNode)?.type.kind;
+        const probed = tryLowerExpression(lowerer, argNode);
+        // A typed handle in a program that adds properties to handles: the
+        // table holds the integrity state (scr_dyn_handle_props.c).
+        {
+            const boxed = boxedHandleReceiver(lowerer, probed);
+            if (boxed)
+                return { kind: "libCall", fn: "dyn.isFrozen", args: [boxed], type: BOOL, loc: locOf(call) };
+        }
+        const probedKind = probed?.type.kind;
         if (probedKind === "record" ||
             probedKind === "array" ||
             probedKind === "map" ||
@@ -8429,6 +8630,13 @@ function lowerObjectStaticCall(lowerer, call, access) {
             noteUntypedIntegrity(lowerer, argNode);
             return { kind: "libCall", fn: "dyn.freeze", args: [value], type: DYN, loc: locOf(call) };
         }
+        // A typed handle in a program that adds properties to handles freezes
+        // its own property table (scr_dyn_handle_props.c).
+        {
+            const boxed = boxedHandleReceiver(lowerer, value);
+            if (boxed)
+                return { kind: "libCall", fn: "dyn.freeze", args: [boxed], type: DYN, loc: locOf(call) };
+        }
         if (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner)) {
             // A fresh literal can still reach untyped code, which observes and
             // must honor its frozen state: records and arrays keep the bit.
@@ -8695,18 +8903,22 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // 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);
+        // A typed handle in a program that adds properties to handles reads its
+        // own property table through the checked-dynamic walk.
+        const isHandle = probed ? boxedHandleReceiver(lowerer, probed) : null;
         if (isDyn ||
             isPrimitive ||
             isFunction ||
             isJsUnion ||
             isArray ||
+            isHandle !== null ||
             (probed && isDynTypedRefType(probed.type))) {
             const fn = member === "keys"
                 ? "dyn.objKeys"
                 : member === "values"
                     ? "dyn.objValues"
                     : "dyn.objEntries";
-            let v = lowerer.lowerExpr(argNode);
+            let v = isHandle ?? lowerer.lowerExpr(argNode);
             if (v.type.kind !== "dyn")
                 v = {
                     kind: "dynFrom",
@@ -8902,9 +9114,33 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     if (tag >= 0) {
                         return { kind: "unionWrap", unionId: valueT.unionId, tag, value, type: valueT, loc };
                     }
+                    // A field value the element union has no arm for, but which
+                    // WIDTH-LIFTS into one: a concrete record field enumerated
+                    // against a checker-typed element that is a shared record's
+                    // union of layouts (a table of metric definitions whose value
+                    // type is the declared `counter | histogram` shape, a settings
+                    // map whose declared value type is the option record). The
+                    // lift picks the arm and copies the value into it — the same
+                    // conversion coerceToExpected applies at a union slot.
+                    const lift = lowerer.widthLiftPlan(vt, valueT);
+                    if (lift)
+                        return lowerer.applyWidthLift(lift, value, valueT, loc);
                 }
                 return null;
             };
+            // A field whose own type is a union (`ColorValue` = `string | number`)
+            // flows into a result element union that may be wider: `Object.entries`
+            // over a record with optional fields yields `string | number |
+            // undefined` for every key. That is the same conversion an assignment
+            // of the value to such a slot performs, so it re-tags at runtime
+            // through the interned helper; an arm the destination cannot take
+            // still refuses with the flat story.
+            const retagInto = (from) => {
+                if (!valueT || valueT.kind !== "union")
+                    return null;
+                const helper = lowerer.unionRetagHelper(from.unionId, valueT.unionId, loc);
+                return helper ? { kind: "call", callee: helper, args: [raw], type: valueT, loc } : null;
+            };
             // Undefined-armed fields: the push is guarded by the field's
             // presence; a narrowed push re-tags the non-undefined arm.
             let guardUndefTag = null;
@@ -8943,13 +9179,22 @@ function lowerObjectStaticCall(lowerer, call, access) {
                             };
                     }
                     else {
-                        return `field '${f.name}' is a multi-arm union that cannot re-tag into the result element type`;
+                        const retagged = retagInto(f.type);
+                        if (!retagged)
+                            return `field '${f.name}' is a multi-arm union that cannot re-tag into the result element type`;
+                        value = retagged;
+                        vt = valueT;
                     }
                 }
-                else if (valueT?.kind !== "dyn" &&
-                    !typeEquals(f.type, valueT ?? f.type) &&
-                    !(valueT?.kind === "union" && lowerer.unionRetagMappable(f.type.unionId, valueT.unionId))) {
-                    return `field '${f.name}' is a union that cannot re-tag into the result element type`;
+                else if (valueT?.kind !== "dyn" && !typeEquals(f.type, valueT ?? f.type)) {
+                    const retagged = retagInto(f.type);
+                    if (retagged) {
+                        value = retagged;
+                        vt = valueT;
+                    }
+                    else if (!(valueT?.kind === "union" && lowerer.unionRetagMappable(f.type.unionId, valueT.unionId))) {
+                        return `field '${f.name}' is a union that cannot re-tag into the result element type`;
+                    }
                 }
             }
             const coerced = elemOf(value, vt);
@@ -9033,6 +9278,17 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     loc,
                 };
             }
+            else if (f.optional === true && f.type.kind === "dyn") {
+                // An optional checked-dynamic field with the ABSENT marker
+                // contributes no key either.
+                stmt = {
+                    kind: "if",
+                    cond: lowerer.recordFieldPresent(obj, shapeId, f.name, loc),
+                    then: [stmt],
+                    else_: null,
+                    loc,
+                };
+            }
             return stmt;
         };
         // The walk that pushes the fields of `obj` (of `current`) into out.0,
@@ -9236,70 +9492,6 @@ function runtimeOptionalEntriesType(lowerer, record, resultT) {
  * ordinary indirect call through the field's closure value. Deliberately
  * record-only — calling a func-typed CLASS field stays rejected (the
  * generic method-call rejection in lowerCall). */
-/** `Object.assign(fn, { bold, ... })` → a HYBRID record literal: the
- * reserved %call field takes the function, each source object literal's
- * properties fill their declared fields (later sources override, JS's
- * last-write-wins — one entry per name, source values still evaluate in
- * order through the literal lowering's shared rules). Bounded to the
- * chalk shape on purpose: the RESULT type must map to a %call-carrying
- * record, sources must be plain object literals (an `as` cast unwraps),
- * and every declared field must be filled. REPRESENTATION NOTE
- * (SEMANTICS.md): the result is a FRESH record, not the mutated `fn` —
- * `assigned === fn` is false here where JS answers true, and `typeof`
- * would answer object; portless's colors.ts never observes either.
- * Null (→ the stdlib fence) for every other Object.assign form. */
-function lowerObjectAssignHybrid(lowerer, call) {
-    const mapped = lowerer.mapTypeOf(lowerer.typeOf(call));
-    if (mapped?.kind !== "record")
-        return null;
-    const shape = lowerer.shapes.get(mapped.shapeId);
-    const callField = shape?.fields.find((f) => f.name === "%call");
-    if (!shape || !callField || callField.type.kind !== "func")
-        return null;
-    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.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.nodes) {
-            const nameOk = (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) &&
-                (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name));
-            if (!nameOk) {
-                lowerer.unsupported("SC1090", prop, "this property form in an Object.assign source building a function-with-properties value");
-            }
-            const name = prop.name.text;
-            const fieldType = shape.fields.find((f) => f.name === name)?.type;
-            if (!fieldType) {
-                lowerer.unsupported("SC1090", prop, `the property '${name}' missing from the assigned result type '${lowerer.fmt(mapped)}'`);
-            }
-            const value = ts.isPropertyAssignment(prop)
-                ? lowerer.lowerExprExpecting(prop.initializer, fieldType)
-                : lowerer.coerceInto(prop, lowerer.lowerShorthandValue(prop), fieldType);
-            values.set(name, value);
-        }
-    }
-    const fields = [];
-    for (const f of shape.fields) {
-        const v = values.get(f.name);
-        if (!v) {
-            const absent = lowerer.absentFieldValue(f.type, loc);
-            if (!absent) {
-                lowerer.unsupported("SC1090", call, `Object.assign leaving the required field '${f.name}' of '${lowerer.fmt(mapped)}' unfilled`);
-            }
-            fields.push({ name: f.name, value: absent });
-            continue;
-        }
-        fields.push({ name: f.name, value: v });
-    }
-    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) {
@@ -9406,7 +9598,7 @@ export function lowerRecordFieldCall(lowerer, call, access) {
                 kind: "dynCall",
                 callee,
                 ...(receiver ? { receiver } : {}),
-                calleeName: ts.getTextOfNode(access),
+                calleeName: v8CalleeText(access),
                 args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                 type: DYN,
                 loc,
@@ -9929,7 +10121,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
                     kind: "dynInvoke",
                     recv: value.type.kind === "dyn" ? value : { kind: "dynFrom", value, type: DYN, loc },
                     method: name,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
@@ -9942,7 +10134,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
                     kind: "dynInvoke",
                     recv: childMethod,
                     method: name,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
@@ -9974,7 +10166,7 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
                     kind: "dynInvoke",
                     recv: receiver,
                     method: name,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
@@ -10216,7 +10408,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                         kind: "dynCall",
                         callee: boxed,
                         ...receiver,
-                        calleeName: ts.getTextOfNode(access),
+                        calleeName: v8CalleeText(access),
                         args,
                         type: DYN,
                         loc,
@@ -10234,7 +10426,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     kind: "dynCall",
                     callee,
                     ...receiver,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args,
                     type: DYN,
                     loc,
@@ -10270,7 +10462,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     kind: "dynCall",
                     callee,
                     receiver,
-                    calleeName: ts.getTextOfNode(access),
+                    calleeName: v8CalleeText(access),
                     args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                     type: DYN,
                     loc,
@@ -10442,7 +10634,7 @@ function lowerUnionObjectMethodCall(lowerer, call, access, receiverT) {
                 kind: "dynCall",
                 callee,
                 receiver,
-                calleeName: ts.getTextOfNode(access),
+                calleeName: v8CalleeText(access),
                 args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
                 type: DYN,
                 loc,
@@ -10579,7 +10771,7 @@ function lowerUnionObjectDynFieldCall(lowerer, call, access, receiverT) {
             kind: "dynCall",
             callee,
             receiver: lowerer.coerceToExpected(receiverRef, DYN),
-            calleeName: ts.getTextOfNode(access),
+            calleeName: v8CalleeText(access),
             args,
             type: DYN,
             loc,
@@ -11292,7 +11484,7 @@ function lowerEmitterMethodValueCall(lowerer, call, access) {
             loc,
         },
         method: "call",
-        calleeName: ts.getTextOfNode(access),
+        calleeName: v8CalleeText(access),
         args: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
         type: DYN,
         loc,