@scriptc/compiler 0.0.8 → 0.0.10

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

@@ -10,15 +10,16 @@ import { BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KIN
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf } from "../program.js";
 import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModuleFnOf, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
 import { blockedBindingUseDiag, recordShapeMismatchDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
-import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, own } from "./lowerer.js";
+import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, nodeThrowExpr, own } from "./lowerer.js";
 import { lowerIndexMergeHelper, lowerNpmStaticSafeIndexRead, strCharsCall } from "./lower-containers.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
+import { unsupportedModuleFeatureOf } from "../shared.js";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, lowerNsIdentifierValue, nsMemberIdentOf, nsUndefRead, nsWritableTarget } from "./lower-namespaces.js";
 import { expandoMemberRead, expandoWritableTarget } from "./lower-expando.js";
 import { lowerSocketInstanceOf } from "./lower-server.js";
 import { findGenericMethodOn, lowerStaticFieldRead } from "./lower-classes.js";
-import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
+import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
 import { isConstAssertionTypeNode, isGenericCallableMemberType, underConstAssertion, unitOnlyUnion } from "../types.js";
 import { lowerYield } from "./lower-generators.js";
@@ -692,7 +693,7 @@ function lowerExprInner(L, expr) {
         {
             const spec = L.fencedBuiltinImportOf(expr);
             if (spec !== null) {
-                L.pushDiag(unsupportedDiag("SC1010", loc, `the '${spec}' module`));
+                L.pushDiag(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(spec)));
                 throw new PoisonError();
             }
         }
@@ -748,8 +749,9 @@ function lowerExprInner(L, expr) {
                     BigInt: "arbitrary-precision integers have no static representation — f64 is the one number type (Number.MAX_SAFE_INTEGER bounds exact integers)",
                     Proxy: "property-access metaprogramming has no static lowering (every property read must resolve at compile time)",
                     Reflect: "reflective property access has no static lowering — read and call members directly",
-                    Intl: "locale- and ICU-backed behavior lives outside the static runtime (the localeCompare stance: code-unit order, no collation/locale data)",
+                    Intl: "locale- and ICU-backed behavior lives outside the static runtime (the localeCompare stance: code-unit order, no collation/locale data) — what lowers: the composed new Intl.NumberFormat(\"en-US\").format(x) and x.toLocaleString(\"en-US\") with default options",
                     SharedArrayBuffer: "no shared-memory threads exist in a compiled program — Uint8Array is the byte storage",
+                    ArrayBuffer: "no free-standing ArrayBuffer value exists — typed arrays own their storage (new Uint8Array(n) allocates; new Uint8Array(new ArrayBuffer(n)) erases the buffer into the view)",
                     WeakRef: "deref()-after-collect exposes GC timing — genuinely dynamic; hold a strong reference instead",
                     FinalizationRegistry: "finalization callbacks expose GC timing — genuinely dynamic; release resources explicitly instead",
                     eval: "runtime code evaluation cannot be compiled ahead of time",
@@ -794,6 +796,18 @@ function lowerExprInner(L, expr) {
                     return nsUndefRead(L, expr.text, expr, t);
             }
         }
+        // A read of a TRAP binding — a declaration whose own initializer
+        // provably threw (module init unwound there), so this reference can
+        // never execute: any lowering is sound, and the trap keeps the
+        // shape honest. Typed by the use site when it maps, the F64 dummy
+        // otherwise (never observed — never even reached).
+        {
+            const sym = L.resolveValueSymbol(expr);
+            if (sym !== null && L.trapBindings.has(sym)) {
+                const t = ambientUndefReadType(L, expr) ?? contextualUndefReadType(L, expr) ?? F64;
+                return nsUndefRead(L, expr.text, expr, t);
+            }
+        }
         // A program CLASS NAME as a value: the classRef over the class's
         // immortal class object (member accesses and construction never
         // reach here — their hooks claim the property/new forms first).
@@ -1404,12 +1418,25 @@ function lowerExprInner(L, expr) {
         // read (ARR answers length; everything else JS's own-property
         // answer). Mapped receivers keep the fence-first order: their
         // members' gaps are real surface gaps ([1,2].entries), not
-        // representation artifacts.
-        if (isJsSourceFile(expr.getSourceFile()) &&
+        // representation artifacts. `.length` on a receiver whose checker
+        // ARRAY type lowers to the checked-dynamic representation —
+        // `unknown[]`, the collapsed `(string | object)[]`, and the `any[]`
+        // an Array.isArray guard narrows a collapsed union to — is the DOM
+        // array's OWN length (a keyed read the ARR kind answers exactly),
+        // never an `Array.prototype` surface gap; both source languages.
+        // Prototype-method VALUE reads (`ps.map` unparenthesized) keep the
+        // fence-first order: a stored-member undefined would mis-answer
+        // them, and calls dispatch through the dyn method machinery
+        // instead.
+        if ((isJsSourceFile(expr.getSourceFile()) &&
             (L.mapTypeOf(L.typeOf(expr.expression)) === null ||
                 // A never-tainted receiver type maps (never rides as f64) but
                 // its VALUE lowered checked-dynamic — same DOM read.
-                neverTaintedJsType(L, expr.expression, L.typeOf(expr.expression)))) {
+                neverTaintedJsType(L, expr.expression, L.typeOf(expr.expression)))) ||
+            (expr.name.text === "length" &&
+                (L.checkerAnyArray(expr.expression) ||
+                    (L.checker.isArrayType(L.typeOf(expr.expression)) &&
+                        L.mapTypeOf(L.typeOf(expr.expression))?.kind === "dyn")))) {
             const recv = L.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
@@ -1477,6 +1504,17 @@ function lowerExprInner(L, expr) {
                     return nsUndefRead(L, ambientRoot.text, expr, t);
             }
         }
+        // A member read through a NULLISH generic binding (`const i: I<A &
+        // B> = null as any; const _i: I<A> = i.something` — the receiver
+        // provably holds null/undefined forever): the read throws Node's
+        // exact TypeError at the access.
+        if (ts.isIdentifier(expr.expression) && expr.questionDotToken === undefined) {
+            const unit = nullishGenericBindingUnitOf(L, L.resolveValueSymbol(expr.expression));
+            if (unit !== null) {
+                const t = ambientUndefReadType(L, expr) ?? contextualUndefReadType(L, expr) ?? F64;
+                return nodeThrowExpr(1, "", `Cannot read properties of ${unit} (reading '${expr.name.text}')`, t, loc);
+            }
+        }
         // The lib fence's PROPERTY chokepoint: a stdlib-declared member that
         // no lowering above claimed ([1,2].entries, Math.SQRT2, Promise.all,
         // re.exec as a value, ...) reports SC2020 here.
@@ -2152,7 +2190,18 @@ function pureCondExpr(e) {
 export function lowerNullishCoalesce(L, expr, loc) {
     const left = L.lowerExpr(expr.left);
     if (left.type.kind === "dyn") {
-        L.unsupported("SC1100", expr, "nullish coalescing on 'unknown' values");
+        // `a ?? b` on a CHECKED-DYNAMIC left: the deciding test is the
+        // runtime kind (scr_dyn_is_nullish — UNDEF/NULL take the default;
+        // a wrapped island value routes to the engine's test, defensively:
+        // the wrap constructor scalar-normalizes engine null/undefined
+        // away). Both sides live in the DOM — the right converts through
+        // the usual boundary and evaluates lazily in its branch; a default
+        // with no dyn representation keeps the fence.
+        const right = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
+        if (right.type.kind !== "dyn") {
+            L.unsupported("SC1100", expr, "nullish coalescing on 'unknown' values against defaults with no dynamic representation");
+        }
+        return { kind: "nullish", left, right, type: DYN, loc };
     }
     if (left.type.kind === "jsval") {
         // `a ?? b` on an ISLAND value: the engine's own nullish test — the
@@ -2986,6 +3035,24 @@ export function lowerIntrinsicProperty(L, expr) {
                 return read;
             return { kind: "jsExit", value: read, type: F64, loc: locOf(expr) };
         }
+        // A CHECKED-DYNAMIC value behind an array-typed checker spelling
+        // (`Object.keys(u).length` — the dyn walk answers a DOM array while
+        // tsc spells string[]): the runtime-world dispatch — a DOM keyed
+        // read validated into the declared number (a lying length throws
+        // the catchable TypeError, the dynCheck stance).
+        if (receiver.type.kind === "dyn") {
+            const read = {
+                kind: "dynKeyGet",
+                key: { kind: "strLit", value: "length", type: STRING, loc: locOf(expr) },
+                ...(expr.questionDotToken ? { optional: true } : {}),
+                value: receiver,
+                type: DYN,
+                loc: locOf(expr),
+            };
+            if (expr.questionDotToken)
+                return read;
+            return { kind: "dynCheck", value: read, type: F64, loc: locOf(expr) };
+        }
         return kind === "string"
             ? { kind: "strIntrinsic", method: "length", receiver, args: [], type: F64, loc: locOf(expr) }
             : { kind: "arrIntrinsic", method: "length", receiver, args: [], type: F64, loc: locOf(expr) };
@@ -3146,8 +3213,12 @@ export function lowerArrayLiteral(L, expr, expected) {
         // []) builds as a DOM ARRAY — one dyn value whose elements each
         // convert through the usual boundary (dynFrom's JSON-safe domain);
         // an element that cannot convert fences per element. length/index
-        // reads and dynamic consumers ride the keyed-DOM paths.
-        if (isJsSourceFile(expr.getSourceFile())) {
+        // reads and dynamic consumers ride the keyed-DOM paths. TS literals
+        // take the same build when the slot ITSELF is checked-dynamic — an
+        // `unknown[]` annotation or a collapsed `(string | object)[]` maps
+        // to DYN wholesale now (mapType's dyn-element array rule), so the
+        // literal IS the DOM array.
+        if (isJsSourceFile(expr.getSourceFile()) || mapped?.kind === "dyn") {
             const elems = expr.elements.map((el) => {
                 if (ts.isSpreadElement(el)) {
                     L.unsupported("SC1090", el, "spread elements in a dynamic (unknown[]) array literal");
@@ -4158,7 +4229,9 @@ export function lowerObjectLiteral(L, expr) {
     }
     const shapeMismatch = (node) => {
         const own = L.mapTypeOf(L.typeOf(expr));
-        L.pushDiag(recordShapeMismatchDiag(L.fmt(type), own ? L.fmt(own) : L.checker.typeToString(L.typeOf(expr)), locOf(node)));
+        L.pushDiag(recordShapeMismatchDiag(L.fmt(type), own ? L.fmt(own) : L.checker.typeToString(L.typeOf(expr)), locOf(node), own?.kind === "record"
+            ? (L.describeRecordWidthBlocker(own.shapeId, type.shapeId) ?? undefined)
+            : undefined));
         throw new PoisonError();
     };
     const fields = [];
@@ -4340,7 +4413,7 @@ export function lowerObjectLiteral(L, expr) {
                         if (targetType.kind === "union") {
                             const retag = L.unionRetagHelper(f.type.unionId, targetType.unionId, locOf(prop));
                             if (!retag) {
-                                L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(recArm), locOf(prop)));
+                                L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(recArm), locOf(prop), `spread field '${f.name}': '${L.fmt(f.type)}' cannot re-tag into '${L.fmt(targetType)}' behind the present-test`));
                                 throw new PoisonError();
                             }
                             thenVal = { kind: "call", callee: retag, args: [fRead()], type: targetType, loc: locOf(prop) };
@@ -4349,7 +4422,7 @@ export function lowerObjectLiteral(L, expr) {
                             thenVal = { kind: "unionNarrow", unionId: f.type.unionId, tag: L.armTag(f.type.unionId, targetType), value: fRead(), type: targetType, loc: locOf(prop) };
                         }
                         else {
-                            L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(recArm), locOf(prop)));
+                            L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(recArm), locOf(prop), `spread field '${f.name}': '${L.fmt(f.type)}' cannot narrow into '${L.fmt(targetType)}' behind the present-test`));
                             throw new PoisonError();
                         }
                     }
@@ -4361,7 +4434,7 @@ export function lowerObjectLiteral(L, expr) {
                         // undefined trap must not shadow.
                         const lift = L.widthLiftPlan(f.type, targetType);
                         if (!lift) {
-                            L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(recArm), locOf(prop)));
+                            L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(recArm), locOf(prop), `spread field '${f.name}': '${L.fmt(f.type)}' does not lift into '${L.fmt(targetType)}'`));
                             throw new PoisonError();
                         }
                         thenVal = L.applyWidthLift(lift, fRead(), targetType, locOf(prop));
@@ -4441,7 +4514,7 @@ export function lowerObjectLiteral(L, expr) {
                     // it can render identically to the target while the spread
                     // source (the thing that actually mismatches) differs — an
                     // invisible difference is a diagnostics bug.
-                    L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(srcType), locOf(prop)));
+                    L.pushDiag(recordShapeMismatchDiag(L.fmt(type), L.fmt(srcType), locOf(prop), `spread field '${f.name}': '${L.fmt(f.type)}' does not lift into '${L.fmt(targetType)}'`));
                     throw new PoisonError();
                 }
                 const obj = srcLowered ?? L.lowerExpr(srcNode);
@@ -5049,7 +5122,24 @@ export function lowerElementAccess(L, expr) {
         ? null
         : L.mapTypeOf(L.typeOf(expr.expression));
     if (receiverIr?.kind === "jsval") {
-        return islandElementRead(L, expr, L.lowerExpr(expr.expression));
+        // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
+        // receiver whose value LOWERED checked-dynamic (`bag.list[0]` where
+        // bag.list is a routed keyed read off a wrapped island value) takes
+        // the DOM keyed read below — the routed JSVAL arm reads the real
+        // engine element; a jsval-lowered receiver keeps the island read.
+        const recv = L.lowerExpr(expr.expression);
+        if (recv.type.kind !== "dyn")
+            return islandElementRead(L, expr, recv);
+        const rawKey = L.lowerExpr(expr.argumentExpression);
+        const key = rawKey.type.kind === "string"
+            ? rawKey
+            : rawKey.type.kind === "f64"
+                ? { kind: "toString", operand: rawKey, type: STRING, loc: rawKey.loc }
+                : null;
+        if (key) {
+            const opt = chainGuardedByQuestionDot(expr.expression);
+            return L.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: recv, type: DYN, loc: locOf(expr) }, expr);
+        }
     }
     // Typed-array element read `b[i]` — like arrayGet with a scalar
     // result; any invalid index traps (the array discipline; JS would
@@ -5127,9 +5217,12 @@ export function lowerElementAccess(L, expr) {
         const obj = L.lowerExpr(expr.expression);
         if (obj.type.kind === "dyn") {
             const rawKey = L.lowerExpr(expr.argumentExpression);
+            // Number, bool, and DYN keys stringify (ToPropertyKey) — the
+            // dyn-keyed read `catchWarning[warning.name]` where the property
+            // chain itself lowered dyn.
             const key = rawKey.type.kind === "string"
                 ? rawKey
-                : rawKey.type.kind === "f64"
+                : rawKey.type.kind === "f64" || rawKey.type.kind === "bool" || rawKey.type.kind === "dyn"
                     ? { kind: "toString", operand: rawKey, type: STRING, loc: rawKey.loc }
                     : null;
             if (key) {
@@ -5495,11 +5588,58 @@ export function lowerElementWrite(L, expr) {
     const receiverIr = L.mapTypeOf(L.typeOf(target.expression));
     if (receiverIr?.kind === "jsval") {
         const obj = L.lowerExpr(target.expression);
+        // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
+        // receiver whose value LOWERED checked-dynamic takes the DOM keyed
+        // write — the routed JSVAL arm lands it on the real engine object.
+        if (obj.type.kind === "dyn") {
+            const loc = locOf(expr);
+            const rawKey = L.lowerExpr(target.argumentExpression);
+            const key = rawKey.type.kind === "f64" || rawKey.type.kind === "bool" || rawKey.type.kind === "dyn"
+                ? { kind: "toString", operand: rawKey, type: STRING, loc: rawKey.loc }
+                : rawKey;
+            if (key.type.kind !== "string") {
+                L.unsupported("SC1090", target.argumentExpression, `'${L.fmt(key.type)}'-typed keys in keyed writes through 'unknown' values`);
+            }
+            const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
+            if (value.type.kind !== "dyn") {
+                L.unsupported("SC1100", expr.right, `assigning '${L.fmt(value.type)}' values through 'unknown' receivers`);
+            }
+            return {
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc },
+                loc,
+            };
+        }
         const key = L.jsvalIn(L.lowerExpr(target.argumentExpression), target.argumentExpression);
         const value = L.jsvalIn(L.lowerExpr(expr.right), expr.right);
         const loc = locOf(expr);
         return { kind: "exprStmt", expr: { kind: "jsOp", op: "setIdx", args: [obj, key, value], type: VOID, loc }, loc };
     }
+    // A checked-dynamic receiver TYPE (`unknown[]` and the collapsed
+    // `(string | object)[]` map to DYN wholesale now): the DOM keyed
+    // write — dyn.keySet. Number keys canonicalize through the JS-exact
+    // formatter; ARR receivers take canonical index keys as element
+    // set/extend (undefined-hole padding, JS's length growth exactly),
+    // OBJ receivers set the member, and the runtime throws Node's
+    // TypeErrors on every other kind. Values convert into the DOM;
+    // unconvertible ones fence per site (the dynFrom stance).
+    if (receiverIr?.kind === "dyn") {
+        const obj = L.lowerExpr(target.expression);
+        if (obj.type.kind === "dyn") {
+            const loc = locOf(expr);
+            let key = L.lowerExpr(target.argumentExpression);
+            if (key.type.kind === "f64")
+                key = L.ensureString(key, target.argumentExpression);
+            if (key.type.kind !== "string") {
+                L.unsupported("SC1090", target.argumentExpression, "indexing with non-string or non-number keys");
+            }
+            const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
+            if (value.type.kind !== "dyn") {
+                L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic array (the value cannot convert into the DOM)`);
+            }
+            return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc }, loc };
+        }
+    }
     // Typed-array element write `b[i] = v` — bytesSet: the value is an f64
     // the runtime coerces JS-exactly; invalid indices trap (no appends —
     // typed arrays are fixed-length; JS would ignore the write).
@@ -5676,6 +5816,39 @@ export function lowerElementWrite(L, expr) {
             };
         }
     }
+    // Keyed write `d[k] = v` on a CHECKED-DYNAMIC receiver (a JS `any`
+    // dictionary — the Object.create(null) memo-table idiom writes
+    // `result[key] = value`): dyn.keySet, exactly the record-mapped dyn
+    // arm above — later writes win in insertion order, number keys
+    // canonicalize through the JS-exact formatter (ToPropertyKey's string
+    // side), index keys on DOM arrays set/extend elements, and non-object
+    // receivers throw Node's TypeErrors at runtime. An UNMAPPED checker
+    // type (static `any` — mapTypeOf answers null without --dynamic)
+    // probes the receiver's own lowered world: a dyn value takes the same
+    // write, anything else falls through to the fences.
+    if (receiverIr?.kind === "dyn" || receiverIr === null) {
+        const obj = receiverIr !== null ? L.lowerExpr(target.expression) : probeLower(L, target.expression);
+        if (obj !== null && obj.type.kind === "dyn") {
+            const loc = locOf(expr);
+            const litKey = recordKeyLiteralText(target.argumentExpression);
+            let key = litKey !== null
+                ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(target.argumentExpression) }
+                : L.lowerExpr(target.argumentExpression);
+            if (key.type.kind === "f64")
+                key = L.ensureString(key, target.argumentExpression);
+            if (key.type.kind === "bool" || key.type.kind === "dyn") {
+                key = { kind: "toString", operand: key, type: STRING, loc: locOf(target.argumentExpression) };
+            }
+            if (key.type.kind !== "string") {
+                L.unsupported("SC1090", target.argumentExpression, "indexing checked-dynamic values with non-string or non-number keys");
+            }
+            const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
+            if (value.type.kind !== "dyn") {
+                L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the DOM)`);
+            }
+            return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc }, loc };
+        }
+    }
     if (receiverIr?.kind !== "array") {
         L.unsupported("SC1090", target, "assignment to non-array elements");
     }
@@ -6126,6 +6299,46 @@ export function lowerBinary(L, expr) {
             const value = L.lowerExprExpecting(expr.right, target.type);
             return { kind: "assignExpr", localId: target.id, value, type: target.type, loc };
         }
+        // `events.defaultMaxListeners = v` — the module-property write
+        // Node validates (validateNumber(n, 'defaultMaxListeners', 0)):
+        // the value crosses into the DOM and the runtime ladder throws
+        // ERR_INVALID_ARG_TYPE / ERR_OUT_OF_RANGE with Node's exact slot
+        // name; valid numbers apply. The expression's value is the RHS
+        // (JS's assignment yield).
+        if (op === ts.SyntaxKind.EqualsToken &&
+            ts.isPropertyAccessExpression(expr.left) &&
+            !expr.left.questionDotToken &&
+            expr.left.name.text === "defaultMaxListeners") {
+            const bi = L.builtinMemberOf(expr.left);
+            if (bi && bi.module === "events" && bi.member === "defaultMaxListeners") {
+                const rhs = L.lowerExpr(expr.right);
+                if (rhs.type.kind === "dyn" || rhs.kind === "unitLit" || L.dynConvertible(rhs.type)) {
+                    const valTmp = L.declareHiddenLocal("%setVal", rhs.type);
+                    const valRef = () => ({ kind: "varRef", localId: valTmp.id, type: rhs.type, loc });
+                    const dynVal = rhs.type.kind === "dyn" ? valRef() : { kind: "dynFrom", value: valRef(), type: DYN, loc };
+                    return {
+                        kind: "seqExpr",
+                        stmts: [
+                            { kind: "varDecl", localId: valTmp.id, init: rhs, loc },
+                            {
+                                kind: "exprStmt",
+                                expr: {
+                                    kind: "libCall",
+                                    fn: "emitter.setDefaultMaxChk",
+                                    args: [dynVal, { kind: "strLit", value: "defaultMaxListeners", type: STRING, loc }],
+                                    type: VOID,
+                                    loc,
+                                },
+                                loc,
+                            },
+                        ],
+                        result: valRef(),
+                        type: rhs.type,
+                        loc,
+                    };
+                }
+            }
+        }
         // Member targets whose storage IS a module global — namespace
         // members (`N.x`) and expando function members (`Foo.baz`): the
         // same assignExpr, since the "member" is a variable.
@@ -6611,6 +6824,7 @@ export function lowerBinary(L, expr) {
                         kind: "unionEq",
                         unionId: ut.unionId,
                         negated,
+                        sameValue: false,
                         left: L.coerceInto(expr.left, left, ut),
                         right: L.coerceInto(expr.right, right, ut),
                         type: BOOL,