@scriptc/compiler 0.2.6 → 0.2.8

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

@@ -1,8 +1,11 @@
+import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
+import { lowerArrayCallbackCall } from "./containers/array-callback-call.js";
 /** Dispatch source calls, builtin members and receiver-specific operations.
  * Signature collection, argument completion and function bodies have their
  * own owners; this module selects the applicable call path. */
 import { dynUndefinedExpr, nodeThrowExpr, countedFor, numLit, varRef } from "../../ir/build.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
+import { threadsImportOf } from "../threads-import.js";
 import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS, } from "./lower-timers.js";
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -24,6 +27,7 @@ import { lowerGroupByStaticCall } from "./containers/collection-grouping.js";
 import { lowerIteratorHelperCall } from "./containers/iterator-helpers.js";
 import { lowerObjectAssignIndexShape, lowerObjectConstructor, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, } from "./containers/indexed-objects.js";
 import { lowerTupleReadMethodCall } from "./containers/array-methods.js";
+import { tryFuseIndexRead } from "./array-values.js";
 import { lowerBytesStaticCall } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringIndexCall, lowerStringMethodCall, lowerStringPaddingCall, lowerStringSplitCall, } from "./containers/string-and-regexp.js";
 import { createRequireSpecOf } from "./builtins/module-bindings.js";
@@ -332,7 +336,7 @@ export function lowerCall(lowerer, expr) {
             // inspect distinction, per arm), Maps/Sets, plain undefined/null,
             // regexes, symbols, error values, Buffers. Shapes inspect cannot
             // render fence honestly with the reason.
-            return lowerConsoleInspectArg(lowerer, a, lowered, surface, loc);
+            return lowerConsoleInspectArg(lowerer, a, lowerer.deferredFieldSlot(lowered) ?? lowered, surface, loc);
         });
         return withReceiver({
             kind: "intrinsic",
@@ -792,6 +796,14 @@ export function lowerCall(lowerer, expr) {
             if (rf)
                 return lowerHttpClientFnCall(lowerer, expr, rf, loc);
         }
+        if (threadsImportOf(lowerer.program, expr.expression) === "publish") {
+            // @scriptc/threads publish(value): the same value, its graph made
+            // immortal and immutable (backend/llvm/publish.ts).
+            if (expr.arguments.length !== 1 || ts.isSpreadElement(expr.arguments[0]))
+                lowerer.noLowering(`publish with ${expr.arguments.length} arguments`, expr);
+            const value = lowerer.lowerExpr(expr.arguments[0]);
+            return { kind: "intrinsic", name: "threads.publish", args: [value], type: value.type, loc };
+        }
         const bi = lowerer.builtinImportOf(expr.expression);
         if (bi)
             return lowerBuiltinCall(lowerer, expr, bi, loc);
@@ -847,138 +859,14 @@ export function lowerCall(lowerer, expr) {
         // 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).
-        if ((expr.expression.text === "parseInt" || expr.expression.text === "isNaN") &&
+        if ((expr.expression.text === "parseInt" ||
+            expr.expression.text === "isNaN" ||
+            expr.expression.text === "parseFloat" ||
+            expr.expression.text === "isFinite") &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-            const name = expr.expression.text;
-            const maxArgs = name === "parseInt" ? 2 : 1;
-            if (expr.arguments.length < 1 || expr.arguments.length > maxArgs) {
-                lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
-            }
-            if (name === "isNaN") {
-                const x = lowerer.lowerExprExpecting(expr.arguments[0], F64);
-                return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
-            }
-            const radix = expr.arguments[1]
-                ? lowerer.lowerExprExpecting(expr.arguments[1], F64)
-                : { kind: "numLit", value: 0, type: F64, loc };
-            const optional = optionalCallValue(lowerer, expr.arguments[0]);
-            if (optional?.type.kind === "union") {
-                const def = lowerer.unions.get(optional.type.unionId);
-                const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
-                if (def &&
-                    stringTag >= 0 &&
-                    def.arms.every((arm) => arm.kind === "string" || isUnitType(arm))) {
-                    const unionT = optional.type;
-                    const key = `parseInt.optional:${unionT.unionId}`;
-                    let helper = lowerer.valueHelpers.get(key);
-                    if (!helper) {
-                        helper = `%parseInt.optional.${lowerer.valueHelpers.size}`;
-                        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 };
-                        const body = def.arms.flatMap((arm, tag) => isUnitType(arm)
-                            ? [
-                                {
-                                    kind: "if",
-                                    cond: {
-                                        kind: "unionIsTag",
-                                        unionId: unionT.unionId,
-                                        tag,
-                                        negated: false,
-                                        value,
-                                        type: BOOL,
-                                        loc,
-                                    },
-                                    then: [
-                                        {
-                                            kind: "return",
-                                            value: { kind: "numLit", value: NaN, type: F64, loc },
-                                            loc,
-                                        },
-                                    ],
-                                    else_: null,
-                                    loc,
-                                },
-                            ]
-                            : []);
-                        body.push({
-                            kind: "return",
-                            value: {
-                                kind: "libCall",
-                                fn: "num.parseInt",
-                                args: [
-                                    {
-                                        kind: "unionNarrow",
-                                        unionId: unionT.unionId,
-                                        tag: stringTag,
-                                        value,
-                                        type: STRING,
-                                        loc,
-                                    },
-                                    radixRef,
-                                ],
-                                type: F64,
-                                loc,
-                            },
-                            loc,
-                        });
-                        lowerer.liftedFns.push({
-                            name: helper,
-                            params: [
-                                { localId: "value.0", name: "value", type: unionT },
-                                { localId: "radix.0", name: "radix", type: F64 },
-                            ],
-                            returnType: F64,
-                            locals: [
-                                { id: "value.0", name: "value", type: unionT, mutable: true },
-                                { id: "radix.0", name: "radix", type: F64, mutable: true },
-                            ],
-                            body,
-                            loc,
-                        });
-                    }
-                    return { kind: "call", callee: helper, args: [optional, radix], type: F64, loc };
-                }
-            }
-            const s = lowerer.lowerExprExpecting(expr.arguments[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 fall
-        // through to today's island path (--dynamic) or its SC2012 fence:
-        // the ToNumber/ToString coercions on arbitrary values stay engine
-        // territory. The probe never emits — lowering is IR construction.
-        if ((expr.expression.text === "parseFloat" || expr.expression.text === "isFinite") &&
-            expr.arguments.length === 1 &&
-            lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-            const name = expr.expression.text;
-            if (name === "parseFloat") {
-                const optional = optionalCallValue(lowerer, expr.arguments[0]);
-                if (optional) {
-                    const parsed = lowerOptionalStringNumber(lowerer, optional, loc, "num.parseFloat", "parseFloat");
-                    if (parsed)
-                        return parsed;
-                }
-            }
-            const probed = tryLowerExpression(lowerer, expr.arguments[0]);
-            if (name === "parseFloat" && probed?.type.kind === "string") {
-                return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
-            }
-            if (name === "parseFloat" && probed?.type.kind === "dyn") {
-                return {
-                    kind: "libCall",
-                    fn: "num.parseFloat",
-                    args: [{ kind: "libCall", fn: "dyn.toStringCoerce", args: [probed], type: STRING, loc }],
-                    type: F64,
-                    loc,
-                };
-            }
-            if (name === "isFinite" && probed?.type.kind === "f64") {
-                return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
-            }
+            const parsed = lowerStaticNumberGlobal(lowerer, expr.expression.text, expr, expr.arguments, loc);
+            if (parsed !== null)
+                return parsed;
         }
         // STATIC encodeURIComponent/encodeURI/decodeURIComponent
         // (str.encodeUriComponent / str.encodeUri / str.decodeUriComponent —
@@ -1071,7 +959,16 @@ export function lowerCall(lowerer, expr) {
             lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
         }
         if (islFn && expr.arguments.length === islFn.args.length) {
-            lowerer.requireDynamicApi(`'${expr.expression.text}'`, expr);
+            // The static forms above already took the exactly-typed argument
+            // (a string for parseFloat, a number for isFinite): name the
+            // argument type that sent this call to the engine, so the message
+            // states the condition rather than reading as if the global itself
+            // were unsupported.
+            const argText = lowerer.dynamic ? "" : loweredArgumentText(lowerer, expr.arguments[0]);
+            const exact = expr.expression.text === "isFinite" ? "number" : "string";
+            lowerer.requireDynamicApi(`'${expr.expression.text}' with a '${argText}' argument (only a ${exact} argument compiles statically)`, expr, exact === "string"
+                ? "convert the argument explicitly first (for example String(x), or narrow the union), or build with --dynamic to run the coercing call in the embedded engine (adds ~620KB to the binary)"
+                : "narrow the argument to a number first (isFinite over a number compiles statically), or build with --dynamic to run the coercing call in the embedded engine (adds ~620KB to the binary)");
             const callee = {
                 kind: "jsOp",
                 op: "globalGet",
@@ -1143,6 +1040,23 @@ export function lowerCall(lowerer, expr) {
             if (sig && !(jsSpreadArgs && spreadNeedsRuntimeArity(lowerer, sig.params, expr.arguments))) {
                 lowerer.noteEdge(sig.name);
                 const args = lowerer.completeArgs(expr.arguments, sig.params, loc, expr);
+                const symbol = lowerer.resolveValueSymbol(expr.expression);
+                const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+                // A bare call supplies undefined as this, even inside a callback
+                // currently carrying a receiver. The value-call ABI saves and
+                // restores that ambient receiver around the function invocation.
+                if (declaration &&
+                    ts.isFunctionDeclaration(declaration) &&
+                    declaration.parameters.some(isThisParameter)) {
+                    const callee = lowerer.lowerExpr(expr.expression);
+                    return reconcileOverloadReturn(lowerer, expr, {
+                        kind: "callValue",
+                        callee,
+                        args,
+                        type: sig.returnType,
+                        loc,
+                    });
+                }
                 return reconcileOverloadReturn(lowerer, expr, {
                     kind: "call",
                     callee: sig.name,
@@ -1573,6 +1487,11 @@ export function lowerCall(lowerer, expr) {
         !symbolFieldInfo(lowerer, expr.expression)) {
         const access = expr.expression;
         const value = tryLowerExpression(lowerer, access.expression);
+        if (value?.type.kind === "array" && !isJsSourceFile(expr.getSourceFile())) {
+            const callback = lowerArrayCallbackCall(lowerer, expr, access, value);
+            if (callback)
+                return callback;
+        }
         if (value?.type.kind === "dyn" ||
             value?.type.kind === "generator" ||
             (value &&
@@ -1864,13 +1783,7 @@ function lowerBufferStaticCallWithNarrowedArg(lowerer, call, access) {
     }
     const narrowedValue = {
         ...lowered,
-        source: {
-            kind: "call",
-            callee: helper,
-            args: [lowered.source],
-            type: narrowed,
-            loc: lowered.source.loc,
-        },
+        source: lowerer.checkedNarrowCall(helper, lowered.source, narrowed, lowered.source.loc),
     };
     return branded ? { ...branded, args: [narrowedValue] } : narrowedValue;
 }
@@ -1996,6 +1909,23 @@ function lowerNumberConstructorValue(lowerer, argNode, loc) {
         return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
     if (arg.type.kind === "dyn")
         return { kind: "libCall", fn: "dyn.numberConstructor", args: [arg], type: F64, loc };
+    // Number(strings[i]) without boxing `string | undefined`: a missing slot
+    // converts like undefined, to NaN.
+    const indexedString = arg.type.kind === "union" &&
+        arg.kind === "call" &&
+        arg.args[0]?.type.kind === "array" &&
+        arg.args[0].type.elem.kind === "string"
+        ? tryFuseIndexRead(lowerer, arg, F64, (read) => ({ kind: "libCall", fn: "num.fromString", args: [read], type: F64, loc }), {
+            kind: "bin",
+            op: "/",
+            left: { kind: "numLit", value: 0, type: F64, loc },
+            right: { kind: "numLit", value: 0, type: F64, loc },
+            type: F64,
+            loc,
+        })
+        : null;
+    if (indexedString)
+        return indexedString;
     if (arg.type.kind === "union" && lowerer.dynConvertible(arg.type))
         return {
             kind: "libCall",
@@ -4199,13 +4129,13 @@ function implicitReceiverOverloadReturn(lowerer, expr) {
 function reconcileOverloadReturn(lowerer, expr, call) {
     const rsig = lowerer.checker.getResolvedSignature(expr);
     const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
-    // Fluent JS overrides share the base's return ABI, but their result
-    // still has the receiver's subclass layout at the call site.
+    // Nominal covariant overrides share the base's return ABI, but retain
+    // their declared subclass result at the call site. Unannotated fluent
+    // JS overrides use the same bridge for their proven receiver result.
     if (call.type.kind === "object" &&
         rdecl &&
         ts.isMethodDeclaration(rdecl) &&
-        isJsSourceFile(rdecl.getSourceFile()) &&
-        returnsOnlyThis(rdecl)) {
+        (!isJsSourceFile(rdecl.getSourceFile()) || returnsOnlyThis(rdecl))) {
         call = lowerer.maybeNarrow(call, expr);
     }
     const resolvedOverload = rsig &&
@@ -4244,7 +4174,7 @@ function reconcileOverloadReturn(lowerer, expr, call) {
     if (call.type.kind === "union" && rt.kind !== "union") {
         const helper = lowerer.narrowedArmHelper(call.type.unionId, rt, call.loc);
         if (helper)
-            return { kind: "call", callee: helper, args: [call], type: rt, loc: call.loc };
+            return lowerer.checkedNarrowCall(helper, call, rt, call.loc);
     }
     return lowerer.coerceInto(expr, call, rt);
 }
@@ -5703,11 +5633,10 @@ function filterNarrowHelper(lowerer, test, elem, outElem, tag, loc) {
  * no runtime walk. ORDER is the shape's first-seen DECLARATION order
  * (threaded through the shape registry), which matches Node whenever
  * objects are constructed in declaration order — the divergence for
- * reordered construction is SEMANTICS.md 36. Fields holding the
- * undefined arm of their union are SKIPPED at runtime (Node's missing
- * key: an unset optional never made it into the object), which also
- * means an EXPLICIT `{ a: undefined }` key is dropped where Node lists
- * it — same rule as jsonStringify, same SEMANTICS entry. Values wrap
+ * reordered construction is SEMANTICS.md 36. Optional fields that are
+ * absent (omitted or deleted) are SKIPPED at runtime, Node's missing key,
+ * while an explicit `{ a: undefined }` is listed with its undefined
+ * value. Values wrap
  * into the checker's result-element type per field; a multi-arm field
  * union that differs from the result union would need a re-tag — fenced.
  * Null when this isn't an Object static over a fixed record (index
@@ -5826,9 +5755,9 @@ function lowerSymbolMethodCall(lowerer, call, access) {
 }
 /** The interned keys-array helper over a FIXED record shape: a call of a
  * lifted helper whose body pushes each declared field name in first-seen
- * DECLARATION order, skipping fields currently holding the undefined arm
- * of their union at runtime (Node's missing key — an unset optional
- * never made it into the object; SEMANTICS.md 37's rules). ONE
+ * DECLARATION order, skipping optional fields that are currently absent
+ * (omitted or deleted — Node's missing key; a field explicitly holding
+ * undefined is present and listed). ONE
  * construction, interned per shape, shared by Object.keys and for-in —
  * for-in iterates exactly the keys Object.keys answers. */
 export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
@@ -5877,32 +5806,11 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
                     },
                     loc,
                 };
-                // Undefined-armed fields: the push is guarded by a tag test (the
+                // Fields that can be absent push behind their presence test (the
                 // key exists exactly when Object.keys would list it).
-                const utag = f.type.kind === "union" ? lowerer.armTag(f.type.unionId, UNDEFINED_T) : -1;
-                body.push(utag >= 0 && f.type.kind === "union"
-                    ? {
-                        kind: "if",
-                        cond: {
-                            kind: "unionIsTag",
-                            unionId: f.type.unionId,
-                            tag: utag,
-                            negated: true,
-                            value: {
-                                kind: "recordGet",
-                                obj: ref,
-                                shapeId: argIr.shapeId,
-                                field: f.name,
-                                type: f.type,
-                                loc,
-                            },
-                            type: BOOL,
-                            loc,
-                        },
-                        then: [pushStmt],
-                        else_: null,
-                        loc,
-                    }
+                const present = lowerer.recordFieldPresent(ref, argIr.shapeId, f.name, loc);
+                body.push(present.kind === "recordHas"
+                    ? { kind: "if", cond: present, then: [pushStmt], else_: null, loc }
                     : pushStmt);
             }
             body.push({ kind: "return", value: outRef, loc });
@@ -5916,9 +5824,9 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
 }
 /** Interned `%obj.hasOwn.<n>(r, k)` — Object.hasOwn's membership walk
  * over a record shape: the key compares against each
- * declared field name, undefined-armed fields answering by their tag
+ * declared field name, optional fields answering by their presence
  * (a key is own exactly when Object.keys would list it — the two share
- * the guard), everything else true. Unmatched keys probe the overflow
+ * 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) {
     const key = `obj.hasOwn:${shapeId}`;
@@ -5933,18 +5841,7 @@ function recordHasOwnHelper(lowerer, shapeId, loc) {
     const kRef = { kind: "varRef", localId: "k.0", type: STRING, loc };
     const body = [];
     for (const f of shape.fields) {
-        const utag = f.type.kind === "union" ? lowerer.armTag(f.type.unionId, UNDEFINED_T) : -1;
-        const answer = utag >= 0 && f.type.kind === "union"
-            ? {
-                kind: "unionIsTag",
-                unionId: f.type.unionId,
-                tag: utag,
-                negated: true,
-                value: { kind: "recordGet", obj: rRef, shapeId, field: f.name, type: f.type, loc },
-                type: BOOL,
-                loc,
-            }
-            : { kind: "boolLit", value: true, type: BOOL, loc };
+        const answer = lowerer.recordFieldPresent(rRef, shapeId, f.name, loc);
         body.push({
             kind: "if",
             cond: {
@@ -5982,8 +5879,9 @@ function recordHasOwnHelper(lowerer, shapeId, loc) {
 }
 /** Interned `%obj.assign.<n>(t, s)` — Object.assign's per-field copy
  * over signature-free records (every source field lands on a same-named,
- * same-typed target field — the caller's gate): undefined-armed source
- * fields copy behind the not-undefined guard, everything else straight,
+ * same-typed target field — the caller's gate): optional source fields
+ * copy only when present (an explicit undefined copies), everything else
+ * straight,
  * and the TARGET returns (JS's aliasing). */
 function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
     const key = `obj.assign:${targetShapeId}:${srcShapeId}`;
@@ -6015,23 +5913,9 @@ function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
             value: get,
             loc,
         };
-        const utag = f.type.kind === "union" ? lowerer.armTag(f.type.unionId, UNDEFINED_T) : -1;
-        body.push(utag >= 0 && f.type.kind === "union"
-            ? {
-                kind: "if",
-                cond: {
-                    kind: "unionIsTag",
-                    unionId: f.type.unionId,
-                    tag: utag,
-                    negated: true,
-                    value: get,
-                    type: BOOL,
-                    loc,
-                },
-                then: [set],
-                else_: null,
-                loc,
-            }
+        const present = lowerer.recordFieldPresent(sRef, srcShapeId, f.name, loc);
+        body.push(present.kind === "recordHas"
+            ? { kind: "if", cond: present, then: [set], else_: null, loc }
             : set);
     }
     body.push({ kind: "return", value: tRef, loc });
@@ -6309,6 +6193,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
             };
         }
         if (left.type.kind === "union" || right.type.kind === "union") {
+            const compared = lowerUnionEquality(lowerer, left, right, false, true, loc);
+            if (compared)
+                return compared;
             const ut = left.type.kind === "union" ? left.type : right.type;
             const bothUnion = left.type.kind === "union" && right.type.kind === "union";
             const sameUnion = bothUnion && typeEquals(left.type, right.type);
@@ -6316,9 +6203,16 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 const plain = left.type.kind === "union" ? right : left;
                 const arms = lowerer.unions.get(ut.unionId)?.arms ?? [];
                 // The plain side wraps into the union exactly like === when the
-                // union holds its type; a plain PRIMITIVE the union has no arm
-                // for is the disjoint constant false (coercing it would strand).
-                if (bothUnion || arms.some((a) => typeEquals(a, plain.type))) {
+                // union holds its type, or when a plain class instance upcasts
+                // into exactly one class arm (the same pointer under a base tag);
+                // a plain PRIMITIVE the union has no arm for is the disjoint
+                // constant false (coercing it would strand).
+                const plainType = plain.type;
+                const upcastArm = plainType.kind === "object" &&
+                    arms.filter((a) => a.kind === "object" && lowerer.isSubclassOf(plainType.className, a.className)).length === 1;
+                if (bothUnion || upcastArm || arms.some((a) => typeEquals(a, plain.type))) {
+                    if (tagEqualityMayMissAlias(lowerer, ut))
+                        lowerer.noLowering("Object.is over related class values beside structural union members", call, NARROW_FIRST);
                     const sameValue = arms.some((a) => a.kind === "f64");
                     return {
                         kind: "unionEq",
@@ -6530,12 +6424,10 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // (the mockable-clock restore: `Object.assign(mocked,
         // implementations)` over one shape): the per-field copy helper,
         // returning the TARGET — JS's aliasing, the target mutates in
-        // place. Undefined-armed source fields copy behind the
-        // not-undefined guard (an omitted optional field holds the
-        // undefined arm and must not erase the target's value — Node
-        // copies own keys only; an EXPLICIT `k: undefined` source diverges,
-        // the explicit-undefined-is-absent stance). Everything else keeps
-        // the spread hint.
+        // place. Optional source fields copy only when present (an omitted
+        // optional field must not erase the target's value — Node copies own
+        // keys only — while an explicit `k: undefined` does). Everything
+        // else keeps the spread hint.
         if (call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
             const tProbe = tryLowerExpression(lowerer, call.arguments[0]);
             const sProbe = tryLowerExpression(lowerer, call.arguments[1]);
@@ -6912,11 +6804,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     // `Object.hasOwn(r, k)` over a RECORD receiver: a record's own-key set
     // is its declared field list, so membership is a compare chain against
-    // the field names (interned per shape). Undefined-armed (optional)
-    // fields answer by their runtime tag — the explicit-undefined-is-absent
-    // stance: an omitted optional field holds the undefined arm and reads
-    // as NOT own, exactly Node's absent key (an EXPLICIT `k: undefined`
-    // diverges — documented next to the child-env/JSON rule). Tuple
+    // the field names (interned per shape). Optional fields answer by
+    // their runtime presence: an omitted or deleted optional field is NOT
+    // own, while an explicit `k: undefined` is, exactly Node's keys. Tuple
     // and accessor-carrying shapes keep the SC2020 fence. Index-signature
     // records additionally probe the overflow map; non-record receivers
     // do too.
@@ -7113,9 +7003,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
         return lowerObjectIterOverIndexShape(lowerer, call, member, argIr, shape);
     }
     const loc = locOf(call);
-    const resultT = lowerer.irTypeOf(call);
-    if (resultT.kind !== "array")
+    const checkedT = lowerer.irTypeOf(call);
+    if (checkedT.kind !== "array")
         lowerer.badType(call, lowerer.typeOf(call)); // defensive
+    const resultT = member === "entries" && consumesEntryPairs(call)
+        ? runtimeOptionalEntriesType(lowerer, argIr, checkedT)
+        : checkedT;
     const receiver = objectEnumerationReceiver(lowerer, lowerer.lowerExpr(argNode), argIr, loc);
     if (member === "keys") {
         // The keys walk is shared with for-in (which iterates exactly the
@@ -7195,8 +7088,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     }
                     return null;
                 };
-                // Undefined-armed fields: the push is guarded by a tag test, and
-                // the pushed value is the narrowed non-undefined arm.
+                // Undefined-armed fields: the push is guarded by the field's
+                // presence; a narrowed push re-tags the non-undefined arm.
                 let guardUndefTag = null;
                 let value = raw;
                 let vt = f.type;
@@ -7247,46 +7140,83 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     lowerer.unsupported("SC1090", call, `Object.${member} over '${lowerer.fmt(argIr)}' (field '${f.name}' of type '${lowerer.fmt(f.type)}' ` +
                         `cannot flow into the '${lowerer.fmt(valueT)}' result element — read the fields directly)`);
                 }
-                const pushed = member === "values"
-                    ? coerced
-                    : {
-                        kind: "recordLit",
-                        fields: [
-                            { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
-                            { name: "1", value: coerced },
-                        ],
-                        type: tupleT,
-                        loc,
-                    };
-                const pushStmt = {
+                const pushOf = (element) => ({
                     kind: "exprStmt",
                     expr: {
                         kind: "arrIntrinsic",
                         method: "push",
                         receiver: outRef,
-                        args: [pushed],
+                        args: [
+                            member === "values"
+                                ? element
+                                : {
+                                    kind: "recordLit",
+                                    fields: [
+                                        { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
+                                        { name: "1", value: element },
+                                    ],
+                                    type: tupleT,
+                                    loc,
+                                },
+                        ],
                         type: F64,
                         loc,
                     },
                     loc,
-                };
-                body.push(guardUndefTag !== null && f.type.kind === "union"
-                    ? {
-                        kind: "if",
-                        cond: {
-                            kind: "unionIsTag",
-                            unionId: f.type.unionId,
-                            tag: guardUndefTag,
-                            negated: true,
-                            value: raw,
-                            type: BOOL,
+                });
+                let stmt = pushOf(coerced);
+                if (guardUndefTag !== null && f.type.kind === "union") {
+                    if (value !== raw) {
+                        // A narrowed push: a present field holding undefined pushes
+                        // the result element's own undefined when it has one; a values
+                        // array without one stores a present undefined element (a
+                        // runtime-optional field the checker typed as required). An
+                        // entries tuple slot has no spelling for it.
+                        const undefinedElement = valueT ? lowerer.wrappedUndefined(valueT, loc) : null;
+                        const undefinedPush = undefinedElement
+                            ? pushOf(undefinedElement)
+                            : member === "values"
+                                ? {
+                                    kind: "arraySetUndefined",
+                                    arr: outRef,
+                                    index: {
+                                        kind: "arrIntrinsic",
+                                        method: "length",
+                                        receiver: outRef,
+                                        args: [],
+                                        type: F64,
+                                        loc,
+                                    },
+                                    loc,
+                                }
+                                : null;
+                        stmt = {
+                            kind: "if",
+                            cond: {
+                                kind: "unionIsTag",
+                                unionId: f.type.unionId,
+                                tag: guardUndefTag,
+                                negated: true,
+                                value: raw,
+                                type: BOOL,
+                                loc,
+                            },
+                            then: [stmt],
+                            else_: undefinedPush ? [undefinedPush] : null,
                             loc,
-                        },
-                        then: [pushStmt],
+                        };
+                    }
+                    // Absent fields contribute nothing; present ones push their
+                    // value, undefined included.
+                    stmt = {
+                        kind: "if",
+                        cond: lowerer.recordFieldPresent(ref, argIr.shapeId, f.name, loc),
+                        then: [stmt],
                         else_: null,
                         loc,
-                    }
-                    : pushStmt);
+                    };
+                }
+                body.push(stmt);
             }
             body.push({ kind: "return", value: outRef, loc });
             fn.body = body;
@@ -7298,6 +7228,53 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
+/** An entries array consumed pair by pair right where it is built: a
+ * for-of loop or an array callback method. These consumers bind each pair
+ * from the array's own layout, so the pair's value slot can keep a
+ * runtime-optional field's undefined arm. */
+function consumesEntryPairs(call) {
+    let node = call;
+    while (ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    const parent = node.parent;
+    if (ts.isForOfStatement(parent))
+        return parent.expression === node;
+    return (ts.isPropertyAccessExpression(parent) &&
+        parent.expression === node &&
+        ENTRY_PAIR_CALLBACK_METHODS.has(parent.name.text) &&
+        ts.isCallExpression(parent.parent) &&
+        parent.parent.expression === parent);
+}
+const ENTRY_PAIR_CALLBACK_METHODS = new Set([
+    "every",
+    "filter",
+    "find",
+    "findIndex",
+    "flatMap",
+    "forEach",
+    "map",
+    "some",
+]);
+/** The entries array of a record whose runtime-optional fields (unchecked
+ * indexed reads the checker calls present) can hold undefined: the pair's
+ * value slot gains the undefined arm, so such an entry is listed with its
+ * undefined value as Node lists it. Reads of the slot follow the
+ * runtime-optional field rules. */
+function runtimeOptionalEntriesType(lowerer, record, resultT) {
+    const shape = lowerer.shapes.get(record.shapeId);
+    if (resultT.elem.kind !== "record" || !shape)
+        return resultT;
+    const pair = lowerer.shapes.get(resultT.elem.shapeId);
+    const slot = pair?.tuple ? pair.fields.find((f) => f.name === "1") : undefined;
+    if (!slot)
+        return resultT;
+    const optional = shape.fields.find((f) => lowerer.isRuntimeOptionalField(record.shapeId, f.name) &&
+        lowerer.runtimeOptionalWidening(f.type, slot.type) !== null);
+    if (!optional)
+        return resultT;
+    const widened = lowerer.runtimeOptionalWidening(optional.type, slot.type);
+    return { kind: "array", elem: lowerer.runtimeOptionalRecordField(resultT.elem, "1", widened) };
+}
 /** `r.f(args)` where `r` is a record and `f` a func-typed field: an
  * ordinary indirect call through the field's closure value. Deliberately
  * record-only — calling a func-typed CLASS field stays rejected (the
@@ -7355,7 +7332,7 @@ function lowerObjectAssignHybrid(lowerer, call) {
     for (const f of shape.fields) {
         const v = values.get(f.name);
         if (!v) {
-            const absent = lowerer.wrappedUndefined(f.type, loc);
+            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`);
             }
@@ -7883,13 +7860,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         if (receiver.type.kind === "union") {
             const helper = lowerer.narrowedArmHelper(receiver.type.unionId, receiverIr, locOf(access.expression));
             if (helper !== null)
-                return {
-                    kind: "call",
-                    callee: helper,
-                    args: [receiver],
-                    type: receiverIr,
-                    loc: locOf(access.expression),
-                };
+                return lowerer.checkedNarrowCall(helper, receiver, receiverIr, locOf(access.expression));
         }
         return receiver.type.kind === "dyn"
             ? lowerer.coerceInto(access.expression, receiver, receiverIr)
@@ -7955,7 +7926,9 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             const receiverLocal = lowerer.declareHiddenLocal("%callReceiver", target.obj.type);
             const init = { kind: "varDecl", localId: receiverLocal.id, init: target.obj, loc };
             target.obj = { kind: "varRef", localId: receiverLocal.id, type: receiverLocal.type, loc };
-            const receiver = lowerer.coerceToExpected(target.obj, DYN);
+            const receiver = {};
+            if (!lowerer.receiverFreeCallbackFields.has(access.name.text))
+                receiver.receiver = lowerer.coerceToExpected(target.obj, DYN);
             const finish = (result) => ({
                 kind: "seqExpr",
                 stmts: [init],
@@ -7967,13 +7940,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             if (callee?.type.kind === "union" && callableType !== null) {
                 const helper = lowerer.narrowedArmHelper(callee.type.unionId, callableType, locOf(access));
                 if (helper !== null) {
-                    callee = {
-                        kind: "call",
-                        callee: helper,
-                        args: [callee],
-                        type: callableType,
-                        loc: locOf(access),
-                    };
+                    callee = lowerer.checkedNarrowCall(helper, callee, callableType, locOf(access));
                 }
             }
             if (callee?.type.kind === "func") {
@@ -7984,12 +7951,12 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     const boxed = { kind: "dynFrom", value: callee, type: DYN, loc };
                     const spread = lowerSpreadArgsCall(lowerer, call, boxed, loc);
                     if (spread?.kind === "dynCall")
-                        return finish({ ...spread, receiver });
+                        return finish({ ...spread, ...receiver });
                     const args = call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
                     return finish({
                         kind: "dynCall",
                         callee: boxed,
-                        receiver,
+                        ...receiver,
                         calleeName: access.getText(),
                         args,
                         type: DYN,
@@ -7997,7 +7964,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     });
                 }
                 const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
-                return finish({ kind: "callValue", callee, receiver, args, type: callee.type.ret, loc });
+                return finish({ kind: "callValue", callee, ...receiver, args, type: callee.type.ret, loc });
             }
             if (callee?.type.kind === "dyn") {
                 if (call.arguments.some((a) => ts.isSpreadElement(a))) {
@@ -8007,7 +7974,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 return finish({
                     kind: "dynCall",
                     callee,
-                    receiver,
+                    ...receiver,
                     calleeName: access.getText(),
                     args,
                     type: DYN,
@@ -8089,7 +8056,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 type: found.sig.ret,
                 loc,
             };
-        const result = classCallbackCall(lowerer, value, method, call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), fallback, loc, access.getText());
+        const result = classCallbackCall(lowerer, value, method, call.arguments, fallback, loc, access.getText());
         return {
             kind: "seqExpr",
             stmts: [{ kind: "varDecl", localId: local.id, init: receiver, loc }],
@@ -8412,4 +8379,147 @@ function unionObjectMethodHelper(lowerer, sourceCall, receiverT, method, plans,
     lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc });
     return name;
 }
+/** The argument's lowered type for a message (what the static form saw),
+ * or the checker's text when the argument itself does not lower. */
+function loweredArgumentText(lowerer, arg) {
+    const probed = tryLowerExpression(lowerer, arg);
+    return probed !== null
+        ? lowerer.fmt(probed.type)
+        : lowerer.checker.typeToString(lowerer.checker.getTypeAtLocation(arg));
+}
+/** The static global number parsers (parseInt/parseFloat/isNaN/isFinite),
+ * shared by the globals and their Number.* aliases. `call` blames arity
+ * fences; null when the argument shape needs the engine (the caller keeps
+ * its island path or SC2012 fence). */
+export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
+    if (name === "parseInt" || name === "isNaN") {
+        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") {
+            const x = lowerer.lowerExprExpecting(args[0], F64);
+            return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
+        }
+        const radix = args[1]
+            ? lowerer.lowerExprExpecting(args[1], F64)
+            : { kind: "numLit", value: 0, type: F64, loc };
+        const optional = optionalCallValue(lowerer, args[0]);
+        if (optional?.type.kind === "union") {
+            const def = lowerer.unions.get(optional.type.unionId);
+            const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
+            if (def &&
+                stringTag >= 0 &&
+                def.arms.every((arm) => arm.kind === "string" || isUnitType(arm))) {
+                const unionT = optional.type;
+                const key = `parseInt.optional:${unionT.unionId}`;
+                let helper = lowerer.valueHelpers.get(key);
+                if (!helper) {
+                    helper = `%parseInt.optional.${lowerer.valueHelpers.size}`;
+                    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 };
+                    const body = def.arms.flatMap((arm, tag) => isUnitType(arm)
+                        ? [
+                            {
+                                kind: "if",
+                                cond: {
+                                    kind: "unionIsTag",
+                                    unionId: unionT.unionId,
+                                    tag,
+                                    negated: false,
+                                    value,
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: [
+                                    {
+                                        kind: "return",
+                                        value: { kind: "numLit", value: NaN, type: F64, loc },
+                                        loc,
+                                    },
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ]
+                        : []);
+                    body.push({
+                        kind: "return",
+                        value: {
+                            kind: "libCall",
+                            fn: "num.parseInt",
+                            args: [
+                                {
+                                    kind: "unionNarrow",
+                                    unionId: unionT.unionId,
+                                    tag: stringTag,
+                                    value,
+                                    type: STRING,
+                                    loc,
+                                },
+                                radixRef,
+                            ],
+                            type: F64,
+                            loc,
+                        },
+                        loc,
+                    });
+                    lowerer.liftedFns.push({
+                        name: helper,
+                        params: [
+                            { localId: "value.0", name: "value", type: unionT },
+                            { localId: "radix.0", name: "radix", type: F64 },
+                        ],
+                        returnType: F64,
+                        locals: [
+                            { id: "value.0", name: "value", type: unionT, mutable: true },
+                            { id: "radix.0", name: "radix", type: F64, mutable: true },
+                        ],
+                        body,
+                        loc,
+                    });
+                }
+                return { kind: "call", callee: helper, args: [optional, radix], type: F64, loc };
+            }
+        }
+        const s = 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 fall
+    // through to today's island path (--dynamic) or its SC2012 fence:
+    // the ToNumber/ToString coercions on arbitrary values stay engine
+    // territory. 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;
+            }
+        }
+        const probed = tryLowerExpression(lowerer, args[0]);
+        if (name === "parseFloat" && probed?.type.kind === "string") {
+            return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
+        }
+        if (name === "parseFloat" && probed?.type.kind === "dyn") {
+            return {
+                kind: "libCall",
+                fn: "num.parseFloat",
+                args: [{ kind: "libCall", fn: "dyn.toStringCoerce", args: [probed], type: STRING, loc }],
+                type: F64,
+                loc,
+            };
+        }
+        if (name === "isFinite" && probed?.type.kind === "f64") {
+            return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=lower-calls.js.map