@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/lower-event-emitter.js

@@ -51,6 +51,8 @@ import { STREAM_FORCED_EVENT_NAMES, streamForcedTuple, streamSidesOf } from "./l
 import { boolLit, strLit, varRef } from "../../ir/build.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerAddAbortListener } from "./builtin-calls.js";
+import { requestGeneralStreamSurface } from "./general-streams.js";
+import { nodeStreamInterfaceSide } from "./dyn-streams.js";
 /** True when the class descends from (or is) the runtime emitter. */
 export function emitterRooted(lowerer, info) {
     for (let c = info ?? null; c; c = c.base) {
@@ -231,7 +233,7 @@ function emitterEvents(lowerer) {
             const isEmit = member === "emit";
             if (!isEmit && !REGISTER_MEMBERS.has(member))
                 return;
-            const arg0 = node.arguments[0];
+            const arg0 = node.arguments.nodes[0];
             if (!arg0)
                 return;
             let recvT = null;
@@ -271,11 +273,11 @@ function emitterEvents(lowerer) {
                 return;
             try {
                 if (isEmit) {
-                    mergeEmit(name, node.arguments.slice(1).map((a) => lowerer.mapTypeOf(lowerer.typeOf(a))), isJsSourceFile(sf));
+                    mergeEmit(name, node.arguments.nodes.slice(1).map((a) => lowerer.mapTypeOf(lowerer.typeOf(a))), isJsSourceFile(sf));
                 }
-                else if (node.arguments[1]) {
-                    const cbCt = lowerer.typeOf(node.arguments[1]);
-                    const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, node.arguments[1], cbCt);
+                else if (node.arguments.nodes[1]) {
+                    const cbCt = lowerer.typeOf(node.arguments.nodes[1]);
+                    const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, node.arguments.nodes[1], cbCt);
                     if (cbT?.kind !== "dyn" &&
                         (cbT?.kind !== "func" || cbT.params.some((p) => p.kind !== "dyn"))) {
                         sigOf(name).typedListener = true;
@@ -344,7 +346,9 @@ function isErrorMonitorRef(lowerer, arg) {
         if (!(t.flags & ts.TypeFlags.UniqueESSymbol))
             return false;
         const symbol = t.getSymbol();
-        return symbol?.name === "errorMonitor" && lowerer.isStdlibSymbol(symbol);
+        return (symbol !== undefined &&
+            ts.symbolName(symbol) === "errorMonitor" &&
+            lowerer.isStdlibSymbol(symbol));
     };
     // The unique symbol TYPE names its declaration through any alias.
     if (isMonitorType(lowerer.typeOf(arg)))
@@ -354,7 +358,7 @@ function isErrorMonitorRef(lowerer, arg) {
     if (!ts.isIdentifier(arg))
         return false;
     const symbol = lowerer.resolveValueSymbol(arg);
-    const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+    const declaration = symbol ? symbol.valueDeclaration : undefined;
     if (!declaration || !ts.isBindingElement(declaration))
         return false;
     const pattern = declaration.parent;
@@ -401,7 +405,7 @@ function staticStringPrefixOf(lowerer, node, seen = new Set()) {
         if (!symbol || seen.has(symbol))
             return null;
         seen.add(symbol);
-        const declaration = lowerer.checker.valueDeclarationOf(symbol);
+        const declaration = symbol.valueDeclaration;
         if (declaration &&
             ts.isVariableDeclaration(declaration) &&
             declaration.initializer &&
@@ -423,13 +427,13 @@ function staticStringSuffixOf(lowerer, node, seen = new Set()) {
     if (ts.isStringLiteralLike(expression))
         return expression.text;
     if (ts.isTemplateExpression(expression))
-        return expression.templateSpans.at(-1)?.literal.text ?? "";
+        return expression.templateSpans.nodes.at(-1)?.literal.text ?? "";
     if (ts.isIdentifier(expression)) {
         const symbol = lowerer.resolveValueSymbol(expression);
         if (!symbol || seen.has(symbol))
             return null;
         seen.add(symbol);
-        const declaration = lowerer.checker.valueDeclarationOf(symbol);
+        const declaration = symbol.valueDeclaration;
         if (declaration &&
             ts.isVariableDeclaration(declaration) &&
             declaration.initializer &&
@@ -780,8 +784,9 @@ streamData) {
 function lowerListenerArg(lowerer, member, name, node, tuple) {
     // Unannotated non-empty parameter lists have no static types (checker
     // `any`; dyn in JS sources) — say so before the blanket type fence speaks.
-    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && node.parameters.length > 0) {
-        for (const p of node.parameters) {
+    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
+        node.parameters.nodes.length > 0) {
+        for (const p of node.parameters.nodes) {
             if (p.type === undefined && ts.isIdentifier(p.name)) {
                 const mapped = (() => {
                     try {
@@ -832,7 +837,7 @@ function lowerListenerArg(lowerer, member, name, node, tuple) {
 export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
     const member = access.name.text;
     const loc = locOf(call);
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     const lowerReceiver = () => {
         if (superRecv)
             return superRecv.thisRef;
@@ -883,27 +888,18 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         lowerer.checker.getConstructSignatures(lowerer.typeOf(access.expression)).length > 0) {
         if (member === "addAbortListener")
             return lowerAddAbortListener(lowerer, call, loc);
-        if (member === "setMaxListeners" && args.length === 1) {
-            if (lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind !== "f64") {
-                // Node's runtime ladder over the dyn value ("setMaxListeners" is
-                // the message's slot for the static form).
-                const raw = lowerer.lowerExpr(args[0]);
-                if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
-                    const n = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
-                    return {
-                        kind: "libCall",
-                        fn: "emitter.setDefaultMaxChk",
-                        args: [n, { kind: "strLit", value: "setMaxListeners", type: STRING, loc }],
-                        type: VOID,
-                        loc,
-                    };
-                }
-            }
-            const n = lowerer.lowerExprExpecting(args[0], F64);
-            if (n.type.kind !== "f64") {
-                lowerer.noLowering(`EventEmitter.setMaxListeners with a '${lowerer.fmt(n.type)}' argument`, args[0], "the lowered form takes a number (Node throws ERR_INVALID_ARG_TYPE at runtime for other values)");
-            }
-            return { kind: "libCall", fn: "emitter.setDefaultMax", args: [n], type: VOID, loc };
+        // The events module's functions are EventEmitter's statics too.
+        if (member === "once")
+            return lowerEventsOnce(lowerer, call, loc);
+        if (member === "setMaxListeners" && args.length === 1)
+            return lowerDefaultMaxListenersSet(lowerer, args[0], loc);
+        if (member === "listenerCount" ||
+            member === "getMaxListeners" ||
+            member === "getEventListeners" ||
+            (member === "setMaxListeners" &&
+                args.length > 1 &&
+                args.slice(1).every((arg) => lowerer.mapTypeOf(lowerer.typeOf(arg))?.kind === "object"))) {
+            return lowerEventsEmitterHelper(lowerer, call, member, loc);
         }
         if (member === "setMaxListeners") {
             // The per-target form with a target that is provably NOT an
@@ -1002,7 +998,14 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                 lowerer.noLowering(`a 'data' listener declaring ${cbT.params.length} parameters where the event carries one chunk`, args[1]);
             }
             const p = cbT.params[0];
-            if (p !== undefined && !(p.kind === "bytes" && p.elem === "u8") && p.kind !== "string") {
+            // A `Buffer | string` chunk (NodeJS.ReadableStream's listener
+            // shape) takes whichever side the stream delivers.
+            const chunkUnion = p?.kind === "union" &&
+                (lowerer.unions.get(p.unionId)?.arms ?? []).every((arm) => (arm.kind === "bytes" && arm.elem === "u8") || arm.kind === "string");
+            if (p !== undefined &&
+                !(p.kind === "bytes" && p.elem === "u8") &&
+                p.kind !== "string" &&
+                !chunkUnion) {
                 lowerer.noLowering(`a 'data' listener whose chunk parameter is '${lowerer.fmt(p)}'`, args[1], "chunks are Buffers — or strings once setEncoding/the encoding option applies");
             }
             if (!registering) {
@@ -1272,7 +1275,7 @@ export function emitOverrideShapeReason(lowerer, member) {
         return "optional method declarations have no lowering";
     if (member.typeParameters !== undefined)
         return "the compiled shape declares no type parameters";
-    for (const m of member.modifiers ?? []) {
+    for (const m of member.modifiers?.nodes ?? []) {
         if (m.kind === ts.SyntaxKind.AsyncKeyword)
             return "async methods answer a Promise, not emit's boolean";
         if (m.kind === ts.SyntaxKind.AbstractKeyword)
@@ -1280,21 +1283,21 @@ export function emitOverrideShapeReason(lowerer, member) {
         if (m.kind === ts.SyntaxKind.Decorator)
             return "decorated methods have no lowering";
     }
-    if (member.parameters.length !== 2)
+    if (member.parameters.nodes.length !== 2)
         return "it must declare exactly (event, ...args)";
-    const p0 = member.parameters[0];
-    const p1 = member.parameters[1];
+    const p0 = member.parameters.nodes[0];
+    const p1 = member.parameters.nodes[1];
     if (!ts.isIdentifier(p0.name) ||
         p0.dotDotDotToken !== undefined ||
         p0.questionToken !== undefined ||
         p0.initializer !== undefined ||
-        (p0.modifiers?.length ?? 0) > 0) {
+        (p0.modifiers?.nodes.length ?? 0) > 0) {
         return "the event parameter must be a plain identifier";
     }
     if (!p1.dotDotDotToken ||
         !ts.isIdentifier(p1.name) ||
         p1.initializer !== undefined ||
-        (p1.modifiers?.length ?? 0) > 0) {
+        (p1.modifiers?.nodes.length ?? 0) > 0) {
         return "the second parameter must be a plain rest parameter (...args)";
     }
     try {
@@ -1305,7 +1308,7 @@ export function emitOverrideShapeReason(lowerer, member) {
         // event names are compile-time literals program-wide.
         const p0T = lowerer.mapTypeOf(lowerer.typeOf(p0.name));
         const jsUnannotated = p0.type === undefined &&
-            isJsSourceFile(member.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(member)) &&
             (p0T === null || p0T.kind === "dyn");
         if (p0T?.kind !== "string" && !jsUnannotated) {
             return "the event parameter must be typed 'string' (symbol event names have no lowering)";
@@ -1344,9 +1347,9 @@ export function emitOverrideShapeReason(lowerer, member) {
                     "the event parameter cannot be reassigned (the forward's event name must stay pinned)";
             }
         }
-        n.forEachChild(visit);
+        ts.forEachChild(n, visit);
     };
-    member.body.forEachChild(visit);
+    ts.forEachChild(member.body, visit);
     return reason;
 }
 /** True when this rest-parameter reference is exactly the forward spread:
@@ -1358,7 +1361,9 @@ function isEmitForwardSpread(lowerer, method, id, eventSym) {
     if (!ts.isSpreadElement(sp) || sp.expression !== id)
         return false;
     const call = sp.parent;
-    if (!ts.isCallExpression(call) || call.arguments.length !== 2 || call.arguments[1] !== sp)
+    if (!ts.isCallExpression(call) ||
+        call.arguments.nodes.length !== 2 ||
+        call.arguments.nodes[1] !== sp)
         return false;
     const callee = call.expression;
     if (!ts.isPropertyAccessExpression(callee) ||
@@ -1366,7 +1371,7 @@ function isEmitForwardSpread(lowerer, method, id, eventSym) {
         callee.name.text !== "emit") {
         return false;
     }
-    const a0 = call.arguments[0];
+    const a0 = call.arguments.nodes[0];
     if (!ts.isIdentifier(a0))
         return false;
     try {
@@ -1516,7 +1521,7 @@ export function lowerEmitOverrideSpec(lowerer, req) {
             params.push({ localId: p.id, name: `%ee${i}`, type: t });
             return p;
         });
-        const eventDecl = ov.decl.parameters[0];
+        const eventDecl = ov.decl.parameters.nodes[0];
         const eventLocal = lowerer.declareLocal(eventDecl.name, ts.isIdentifier(eventDecl.name) ? eventDecl.name.text : "event", STRING, true);
         const prologue = [
             { kind: "varDecl", localId: eventLocal.id, init: eventNameExpr(event, loc), loc },
@@ -1529,7 +1534,7 @@ export function lowerEmitOverrideSpec(lowerer, req) {
             restSym: ov.restSym,
             tupleParams,
         };
-        const body = [...prologue, ...lowerer.lowerStmts(ov.decl.body.statements)];
+        const body = [...prologue, ...lowerer.lowerStmts(ov.decl.body.statements.nodes)];
         return {
             name: `%${className}.emit:${event}`,
             params,
@@ -1554,10 +1559,10 @@ export function lowerEmitOverrideSpec(lowerer, req) {
  * rides the general super-emitter route). */
 export function emitSpecSuperForward(lowerer, call, access) {
     const ctx = lowerer.emitSpecCtx;
-    if (!ctx || access.name.text !== "emit" || call.arguments.length !== 2)
+    if (!ctx || access.name.text !== "emit" || call.arguments.nodes.length !== 2)
         return null;
-    const a0 = call.arguments[0];
-    const a1 = call.arguments[1];
+    const a0 = call.arguments.nodes[0];
+    const a1 = call.arguments.nodes[1];
     if (!ts.isIdentifier(a0) || !ts.isSpreadElement(a1) || !ts.isIdentifier(a1.expression))
         return null;
     if (lowerer.checker.getSymbolAtLocation(a0) !== ctx.eventSym)
@@ -1778,48 +1783,231 @@ function eventsOnceBoxer(lowerer, call, tuple, arrayT, loc) {
     }
     return { kind: "closure", fnName: name, captures: [], type: fnType, loc };
 }
-/** events.once(emitter, name): a promise of the next `name` event's
- * arguments as an array, rejected by an earlier 'error' event (unless the
- * awaited event is 'error'). The emitter's listeners are typed by the
- * program-wide event table, so the runtime registers one-shot typed
- * listeners whose compiler-built boxers turn the event's tuple into the
- * array. EventTarget and stream receivers, computed names and options are
- * refused. */
-export function lowerEventsOnce(lowerer, call, loc) {
-    const args = call.arguments;
-    if (args.length < 2 || args.some(ts.isSpreadElement)) {
-        lowerer.noLowering("events.once without an emitter and an event name", call);
+/** The `signal` of an events.once options object literal (a checked-
+ * dynamic AbortSignal or undefined), or null when the literal names none.
+ * Other options forms are refused. */
+function eventsOnceSignal(lowerer, node) {
+    if (!ts.isObjectLiteralExpression(node)) {
+        lowerer.noLowering("events.once options that are not an object literal", node, "pass the options as an object literal: { signal }");
+        return null;
+    }
+    let signal = null;
+    for (const prop of node.properties.nodes) {
+        const name = prop.name && ts.isIdentifier(prop.name) ? prop.name.text : null;
+        if (name === "signal" &&
+            signal === null &&
+            (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop))) {
+            signal = lowerer.lowerExprExpecting(ts.isPropertyAssignment(prop) ? prop.initializer : prop.name, DYN);
+        }
+        else {
+            lowerer.noLowering("events.once options other than one signal", prop, "the lowered options object takes signal: AbortSignal");
+        }
     }
-    if (args.length > 2) {
-        lowerer.noLowering("events.once with options", args[2], "the lowered form is events.once(emitter, name); AbortSignal options are not supported yet");
+    return signal;
+}
+/** events.once(emitter, name[, { signal }]): a promise of the next `name`
+ * event's arguments as an array, rejected by an earlier 'error' event
+ * (unless the awaited event is 'error') or by the signal's abort with an
+ * AbortError. The emitter's listeners are typed by the program-wide event
+ * table (a stream's runtime-emitted events by their fixed tuples), so the
+ * runtime registers one-shot typed listeners whose compiler-built boxers
+ * turn the event's tuple into the array. EventTarget receivers, a stream's
+ * 'data' event, computed names and options other than a literal { signal }
+ * are refused. */
+export function lowerEventsOnce(lowerer, call, loc) {
+    const args = call.arguments.nodes;
+    if (args.length < 2 || args.length > 3 || args.some(ts.isSpreadElement)) {
+        lowerer.noLowering("events.once without an emitter, an event name and options", call);
     }
     // Node's Promise<any[]>: the arguments array of checked-dynamic values.
     const arrayT = arrayOf(DYN);
     const resultT = { kind: "promise", inner: arrayT };
-    const receiver = lowerer.lowerExpr(args[0]);
+    let receiver = lowerer.lowerExpr(args[0]);
+    // A checked-dynamic NodeJS stream slot (dyn-streams.ts): a native stream
+    // unboxes by identity; any other value throws the not-supported Error.
+    if (receiver.type.kind === "dyn" &&
+        lowerer.dynNodeStreams &&
+        nodeStreamInterfaceSide(lowerer, lowerer.typeOf(args[0])) !== null) {
+        receiver = {
+            kind: "libCall",
+            fn: "stream.unboxDyn",
+            args: [
+                receiver,
+                strLit("events.once over stream objects other than native streams is not supported yet", loc),
+            ],
+            type: { kind: "object", className: "%Duplex" },
+            loc,
+        };
+    }
     const info = receiver.type.kind === "object" ? lowerer.classes.get(receiver.type.className) : undefined;
-    if (!emitterRooted(lowerer, info) || streamSidesOf(lowerer, info) !== null) {
-        lowerer.noLowering("events.once over this value", args[0], "the emitter must be an EventEmitter instance; EventTarget and stream receivers are not supported yet");
+    if (!emitterRooted(lowerer, info)) {
+        // A NodeJS stream interface slot that holds a stdio handle here: the
+        // program lowers again with the runtime stream classes.
+        requestGeneralStreamSurface(lowerer, args[0]);
+        lowerer.noLowering("events.once over this value", args[0], "the emitter must be an EventEmitter or stream instance; EventTarget receivers are not supported yet");
     }
     const name = literalEventName(lowerer, args[1]);
     if (name === null || META_EVENTS.has(name) || name === ERROR_MONITOR_EVENT) {
         lowerer.noLowering("events.once with a computed or meta event name", args[1], "name the awaited event with a string literal");
     }
     const event = name ?? "";
+    const sides = streamSidesOf(lowerer, info);
+    if ((sides === "r" || sides === "rw") && (event === "data" || event === "keypress")) {
+        lowerer.noLowering(`events.once of a stream's '${event}' event`, args[1], `the chunk has no checked-dynamic boxing here; register stream.once('${event}', listener) instead`);
+    }
     const table = emitterEvents(lowerer);
     if (event !== "error" && flexibleJsEvent(event, table.get(event))) {
         lowerer.noLowering(`events.once of the event '${event}', which is emitted with computed names or checked-dynamic listeners`, args[1]);
     }
-    const tuple = tupleOf(lowerer, table, event, call);
+    const tuple = streamForcedTuple(lowerer, info, event) ?? tupleOf(lowerer, table, event, call);
     const errorTuple = [{ kind: "object", className: "%Error" }];
     const boxer = eventsOnceBoxer(lowerer, call, tuple, arrayT, loc);
     const errorBoxer = eventsOnceBoxer(lowerer, call, errorTuple, arrayT, loc);
+    const signal = args.length > 2 ? eventsOnceSignal(lowerer, args[2]) : null;
+    const common = [
+        receiver,
+        eventNameExpr(event, loc),
+        boxer,
+        errorBoxer,
+        boolLit(event !== "error", loc),
+    ];
     return {
         kind: "libCall",
-        fn: "events.once",
-        args: [receiver, eventNameExpr(event, loc), boxer, errorBoxer, boolLit(event !== "error", loc)],
+        fn: signal === null ? "events.once" : "events.onceSignal",
+        args: signal === null ? common : [...common, signal],
         type: resultT,
         loc,
     };
 }
+/** The EventEmitter argument of an events-module helper: an emitter
+ * instance (not a stream, whose listener tuples the runtime pins). */
+function helperEmitter(lowerer, member, node) {
+    const value = lowerer.lowerExpr(node);
+    const info = value.type.kind === "object" ? lowerer.classes.get(value.type.className) : undefined;
+    if (!emitterRooted(lowerer, info) || streamSidesOf(lowerer, info) !== null) {
+        lowerer.noLowering(`events.${member} over this value`, node, "the argument must be an EventEmitter instance; EventTarget and stream arguments are not supported yet");
+    }
+    return value;
+}
+/** setMaxListeners(n) with no targets: the process-wide default, through
+ * Node's validateNumber(n, 'setMaxListeners', 0) ladder. */
+function lowerDefaultMaxListenersSet(lowerer, node, loc) {
+    if (lowerer.mapTypeOf(lowerer.typeOf(node))?.kind !== "f64") {
+        // Node's runtime ladder over the dyn value ("setMaxListeners" is
+        // the message's slot for the static form).
+        const raw = lowerer.lowerExpr(node);
+        if (raw.type.kind === "dyn" || raw.kind === "unitLit" || lowerer.dynConvertible(raw.type)) {
+            const n = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
+            return {
+                kind: "libCall",
+                fn: "emitter.setDefaultMaxChk",
+                args: [n, { kind: "strLit", value: "setMaxListeners", type: STRING, loc }],
+                type: VOID,
+                loc,
+            };
+        }
+    }
+    const n = lowerer.lowerExprExpecting(node, F64);
+    if (n.type.kind !== "f64") {
+        lowerer.noLowering(`EventEmitter.setMaxListeners with a '${lowerer.fmt(n.type)}' argument`, node, "the lowered form takes a number (Node throws ERR_INVALID_ARG_TYPE at runtime for other values)");
+    }
+    return { kind: "libCall", fn: "emitter.setDefaultMax", args: [n], type: VOID, loc };
+}
+/** The events module's helpers over EventEmitter instances, also reachable
+ * as EventEmitter statics: listenerCount(emitter, name), getMaxListeners
+ * (emitter), setMaxListeners(n[, ...emitters]) and getEventListeners
+ * (emitter, name). Node answers each through the emitter's own method, so
+ * they lower as those methods do. EventTarget and stream arguments are
+ * refused. Null for other members. */
+export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
+    const args = call.arguments.nodes;
+    if (args.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`events.${member} with spread arguments`, call);
+    }
+    if (member === "listenerCount") {
+        if (args.length !== 2)
+            lowerer.noLowering(`events.listenerCount with ${args.length} arguments`, call);
+        const receiver = helperEmitter(lowerer, member, args[0]);
+        const name = isErrorMonitorRef(lowerer, args[1])
+            ? eventNameExpr(ERROR_MONITOR_EVENT, loc)
+            : lowerer.lowerExprExpecting(args[1], STRING);
+        if (name.type.kind !== "string") {
+            lowerer.noLowering(`events.listenerCount with a '${lowerer.fmt(name.type)}' event name`, args[1]);
+        }
+        return { kind: "libCall", fn: "emitter.count", args: [receiver, name], type: F64, loc };
+    }
+    if (member === "getMaxListeners") {
+        if (args.length !== 1)
+            lowerer.noLowering(`events.getMaxListeners with ${args.length} arguments`, call);
+        const receiver = helperEmitter(lowerer, member, args[0]);
+        return { kind: "libCall", fn: "emitter.getMax", args: [receiver], type: F64, loc };
+    }
+    if (member === "setMaxListeners") {
+        // An omitted n is the current default, assigned again.
+        if (args.length === 0) {
+            return {
+                kind: "libCall",
+                fn: "emitter.setDefaultMax",
+                args: [{ kind: "libCall", fn: "emitter.getDefaultMax", args: [], type: F64, loc }],
+                type: VOID,
+                loc,
+            };
+        }
+        if (args.length === 1)
+            return lowerDefaultMaxListenersSet(lowerer, args[0], loc);
+        // Node evaluates every argument, validates n, then sets each target.
+        const n = lowerer.lowerExprExpecting(args[0], F64);
+        if (n.type.kind !== "f64") {
+            lowerer.noLowering(`events.setMaxListeners with a '${lowerer.fmt(n.type)}' limit and targets`, args[0], "pass a number");
+        }
+        const limit = lowerer.declareHiddenLocal("%maxListeners", F64);
+        const stmts = [{ kind: "varDecl", localId: limit.id, init: n, loc }];
+        const targets = args.slice(1).map((node) => {
+            const value = helperEmitter(lowerer, member, node);
+            const slot = lowerer.declareHiddenLocal("%maxListenersTarget", value.type);
+            stmts.push({ kind: "varDecl", localId: slot.id, init: value, loc });
+            return varRef(slot.id, value.type, loc);
+        });
+        for (const target of targets) {
+            stmts.push({
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "emitter.setMax",
+                    args: [target, varRef(limit.id, F64, loc)],
+                    type: target.type,
+                    loc,
+                },
+                loc,
+            });
+        }
+        // The effects sit in the statements; the call answers undefined.
+        const tail = { kind: "libCall", fn: "console.noop", args: [], type: VOID, loc };
+        return { kind: "seqExpr", stmts, result: tail, type: VOID, loc };
+    }
+    if (member === "getEventListeners") {
+        if (args.length !== 2)
+            lowerer.noLowering(`events.getEventListeners with ${args.length} arguments`, call);
+        // emitter.listeners(name): the event's listener array, typed by the
+        // event's unified tuple (the instance method's rules).
+        const receiver = helperEmitter(lowerer, member, args[0]);
+        const name = eventNameOf(lowerer, "events.getEventListeners", args[1]);
+        const table = emitterEvents(lowerer);
+        const sig = table.get(name);
+        if (sig?.dynListener ||
+            flexibleJsEvent(name, sig) ||
+            computedPatterns(lowerer).some((pattern) => pattern.listener && patternMatchesName(pattern, name))) {
+            lowerer.noLowering(`events.getEventListeners of the event '${name}'`, call, "a listener of this event uses checked-dynamic dispatch, so the listener array has no one static element type — listenerCount(emitter, name) counts");
+        }
+        const tuple = tupleOf(lowerer, table, name, call);
+        return {
+            kind: "libCall",
+            fn: "emitter.listeners",
+            args: [receiver, eventNameExpr(name, loc)],
+            type: arrayOf({ kind: "func", params: tuple, ret: { kind: "void" } }),
+            loc,
+        };
+    }
+    return null;
+}
 //# sourceMappingURL=lower-event-emitter.js.map