@scriptc/compiler 0.4.6 → 0.4.7

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

@@ -24,13 +24,16 @@
  * same vector handles varying or inference-unknown JavaScript emit tuples
  * when every known listener accepts checked-dynamic parameters or no
  * parameters. Typed listener constraints keep the fixed-tuple refusal.
- * The remaining cases are fenced:
- * unrestricted names, symbol names, conflicting literal tuples, the
- * meta-events' listener-function argument (meta listeners take at most
+ * Unrestricted names on plain emitters take the checked-dynamic receiver's
+ * bridge. The remaining cases are fenced:
+ * unrestricted names on streams, symbol names, conflicting literal tuples,
+ * the meta-events' listener-function argument (meta listeners take at most
  * the event name; dyn meta listeners fence — Node
  * passes the listener function second, which has no dyn conversion), and
  * listeners()/rawListeners() of an event with any dynamic
- * registration (the bucket has no one honest element type).
+ * registration, or, once the program registers a listener under an
+ * unrestricted name, of an event that literal names register with typed
+ * listeners (the bucket has no one honest element type).
  *
  * Two special names: 'error' is forced to the one-%Error tuple (emit
  * routes through emitter.emitError — no listener means the payload
@@ -44,9 +47,13 @@
  * super.emit as the prototype chain). */
 import { keyedHelperName } from "./stable-names.js";
 import { checkKeypressListener } from "./builtins/readline.js";
+import { stripTypeCasts } from "./builtins/arguments.js";
 import * as ts from "../ts7/adapter.js";
 import { dynFallbackType, newFnCtx } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
+import { bodyReadsArguments } from "../arguments-usage.js";
+import { functionUsesThis } from "./cjs-exports-object.js";
+import { isThisParameter } from "./call-signatures.js";
 import { arrayOf, BOOL, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, isDynTypedRefType, DYN, F64, isUnitType, STRING, typeEquals, typeKey, VOID, } from "../../ir/ir.js";
 import { STREAM_FORCED_EVENT_NAMES, streamForcedTuple, streamSidesOf } from "./lower-stream.js";
 import { boolLit, dynUndefinedExpr, strLit, varRef } from "../../ir/build.js";
@@ -70,6 +77,47 @@ const REGISTER_MEMBERS = new Set([
     "prependOnceListener",
 ]);
 const META_EVENTS = new Set(["newListener", "removeListener"]);
+/** Whether `t` is an instance type of the Error hierarchy. */
+function rootsAtError(lowerer, t) {
+    if (t?.kind !== "object")
+        return false;
+    for (let c = lowerer.classes.get(t.className) ?? null; c; c = c.base) {
+        if (c.def.name === "%Error")
+            return true;
+    }
+    return false;
+}
+/** Whether the scan recorded a dyn-flavored 'newListener' or 'removeListener'
+ * listener. Then every listener registers through the adapter, typed meta
+ * listeners included, so each entry has a function value to pass. */
+function hasDynMetaListener(table) {
+    return [...META_EVENTS].some((meta) => table.get(meta)?.dynListener === true);
+}
+/** Whether a typed listener of `name` registers through the dyn adapter, so
+ * its entry holds a checked-dynamic function value: a dyn-flavored
+ * 'newListener' or 'removeListener' listener receives every added or
+ * removed listener as one, and a read listener array beside dyn-flavored
+ * listeners holds them. Listeners of 'error' and errorMonitor do when an
+ * emit passes a payload that is not an Error: the adapter's checked
+ * conversion admits it or throws a TypeError. */
+function registersAsDyn(lowerer, name, streamForced) {
+    const table = emitterEvents(lowerer);
+    if (hasDynMetaListener(table))
+        return true;
+    if ((name === "error" || name === ERROR_MONITOR_EVENT) && table.get("error")?.valueEmit === true)
+        return true;
+    const sig = streamForced ? undefined : table.get(name);
+    return sig?.dynListener === true && sig.listenersRead === true;
+}
+/** Whether the event's listener array is read as checked-dynamic values:
+ * its registrations all hold a checked-dynamic function value (flexible
+ * and computed-name events, or a dyn-flavored listener beside a read of
+ * the array). */
+function listenerArrayIsDyn(lowerer, name, sig) {
+    return ((sig?.dynListener === true && sig.listenersRead === true) ||
+        flexibleJsEvent(name, sig) ||
+        computedPatterns(lowerer).some((pattern) => pattern.listener && patternMatchesName(pattern, name)));
+}
 function flexibleJsEvent(name, sig) {
     // A stream may be upcast to EventEmitter. Its runtime-emitted payloads
     // keep their fixed ABI even when the static receiver looks ordinary.
@@ -115,6 +163,7 @@ function emitterEvents(lowerer) {
         return lowerer.emitterEventTable;
     const table = new Map();
     const computedPatterns = [];
+    let anyNameListener = false;
     const sigOf = (name) => {
         let sig = table.get(name);
         if (!sig)
@@ -223,14 +272,51 @@ function emitterEvents(lowerer) {
             }
         }
     };
+    // Events whose listener array is read; applied to the table after the
+    // walk, so a read alone adds no entry.
+    const listenersRead = new Set();
     for (const sf of lowerer.program.getImplementationSourceFiles()) {
         if (sf.isDeclarationFile)
             continue;
         const walk = (node) => {
             ts.forEachChild(node, walk);
-            if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression))
+            if (!ts.isCallExpression(node))
                 return;
-            const member = node.expression.name.text;
+            const callee = node.expression;
+            if ((ts.isIdentifier(callee) || ts.isPropertyAccessExpression(callee)) &&
+                (ts.isIdentifier(callee) ? callee : callee.name).text === "getEventListeners" &&
+                node.arguments.nodes.length === 2) {
+                const nameT = (() => {
+                    try {
+                        return lowerer.typeOf(node.arguments.nodes[1]);
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                if (nameT?.isStringLiteralType())
+                    listenersRead.add(literalEventKey(nameT.value));
+                return;
+            }
+            if (!ts.isPropertyAccessExpression(callee))
+                return;
+            const member = callee.name.text;
+            if (member === "listeners" || member === "rawListeners") {
+                const arg = node.arguments.nodes[0];
+                let nameT = null;
+                try {
+                    if (!arg ||
+                        !scannedEmitterInfo(lowerer, lowerer.mapTypeOf(lowerer.typeOf(callee.expression))))
+                        return;
+                    nameT = lowerer.typeOf(arg);
+                }
+                catch {
+                    return;
+                }
+                if (nameT.isStringLiteralType())
+                    listenersRead.add(literalEventKey(nameT.value));
+                return;
+            }
             const isEmit = member === "emit";
             if (!isEmit && !REGISTER_MEMBERS.has(member))
                 return;
@@ -240,7 +326,7 @@ function emitterEvents(lowerer) {
             let recvT = null;
             let nameT = null;
             try {
-                recvT = lowerer.mapTypeOf(lowerer.typeOf(node.expression.expression));
+                recvT = lowerer.mapTypeOf(lowerer.typeOf(callee.expression));
                 nameT = lowerer.typeOf(arg0);
             }
             catch {
@@ -261,9 +347,54 @@ function emitterEvents(lowerer) {
                     !computedPatternOverlapsReserved(pattern)) {
                     computedPatterns.push({ ...pattern, listener: !isEmit });
                 }
+                // A listener under an unrestricted name may receive any event
+                // (lowerFlexListenerCall's any-name path).
+                if (!pattern && !isEmit && streamSidesOf(lowerer, info) === null)
+                    anyNameListener = true;
                 return;
             }
             const name = literal;
+            if (META_EVENTS.has(name) && !isEmit && node.arguments.nodes[1]) {
+                // A dyn-flavored meta listener receives each added or removed
+                // listener as a checked-dynamic function value. The scan cannot
+                // lower the listener as dynListenerFlavor does, so it counts every
+                // listener that is not statically a typed function: a factory's
+                // result (a wrapper whose runtime value is checked-dynamic), a
+                // JavaScript function without parameters, and the dyn-flavored
+                // forms. Counting one too many only routes more registrations
+                // through the adapter.
+                const cbNode = node.arguments.nodes[1];
+                let typed = false;
+                try {
+                    const cbCt = lowerer.typeOf(cbNode);
+                    const cbT = lowerer.mapTypeOf(cbCt) ?? dynFallbackType(lowerer, cbNode, cbCt);
+                    typed =
+                        cbT?.kind === "func" &&
+                            !ts.isCallExpression(stripTypeCasts(cbNode)) &&
+                            !(cbT.params.length === 0 && isJsSourceFile(sf)) &&
+                            !cbT.params.some((p) => p.kind === "dyn") &&
+                            !readsArgumentsPack(lowerer, cbNode);
+                }
+                catch {
+                    typed = false;
+                }
+                if (!typed)
+                    table.get(name).dynListener = true;
+                return;
+            }
+            if (isEmit && name === "error") {
+                try {
+                    const payload = node.arguments.nodes.slice(1);
+                    if (payload.length !== 1 ||
+                        !rootsAtError(lowerer, lowerer.mapTypeOf(lowerer.typeOf(payload[0])))) {
+                        table.get("error").valueEmit = true;
+                    }
+                }
+                catch {
+                    table.get("error").valueEmit = true;
+                }
+                return;
+            }
             if (META_EVENTS.has(name) || name === "error" || name === ERROR_MONITOR_EVENT)
                 return; // forced tuples
             // Stream receivers' runtime-emitted events carry PER-BASE forced
@@ -279,11 +410,13 @@ function emitterEvents(lowerer) {
                 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);
+                    const pack = readsArgumentsPack(lowerer, node.arguments.nodes[1]);
                     // A TypeScript listener with no parameters is typed too: it
                     // registers without the adapter, so an untyped emit reaches it
                     // only through the event's fixed ABI. A JavaScript function
                     // without parameters can still read `arguments`.
-                    if (cbT?.kind !== "dyn" &&
+                    if (!pack &&
+                        cbT?.kind !== "dyn" &&
                         (cbT?.kind !== "func" ||
                             (cbT.params.length === 0 && !isJsSourceFile(sf)) ||
                             cbT.params.some((p) => p.kind !== "dyn"))) {
@@ -295,7 +428,8 @@ function emitterEvents(lowerer) {
                     // tuple position, and positions past the tuple read the boxed
                     // undefined (exactly JS's extra-parameter semantics).
                     if (cbT?.kind === "dyn" ||
-                        (cbT?.kind === "func" && cbT.params.some((p) => p.kind === "dyn"))) {
+                        (cbT?.kind === "func" && cbT.params.some((p) => p.kind === "dyn")) ||
+                        pack) {
                         const sig = sigOf(name);
                         sig.hasListener = true;
                         sig.dynListener = true;
@@ -311,8 +445,14 @@ function emitterEvents(lowerer) {
         };
         walk(sf);
     }
+    for (const name of listenersRead) {
+        const sig = table.get(name);
+        if (sig)
+            sig.listenersRead = true;
+    }
     lowerer.emitterEventTable = table;
     lowerer.emitterComputedPatterns = computedPatterns;
+    lowerer.emitterAnyNameListener = anyNameListener;
     return table;
 }
 function computedPatterns(lowerer) {
@@ -467,6 +607,16 @@ function patternMatchesName(pattern, key) {
     const name = eventKeyName(key);
     return name.startsWith(pattern.prefix) && name.endsWith(pattern.suffix);
 }
+/** Whether a listener registered under a computed name may sit in the
+ * bucket of the event keyed `key`: a pattern registration that matches it,
+ * or any registration under an unrestricted name (a string, so never the
+ * errorMonitor key). Such a listener crossed
+ * the checked-dynamic boundary, so the bucket has no one static signature. */
+function computedListenerMayHold(lowerer, key) {
+    emitterEvents(lowerer);
+    return ((lowerer.emitterAnyNameListener && key !== ERROR_MONITOR_EVENT) ||
+        computedPatterns(lowerer).some((pattern) => pattern.listener && patternMatchesName(pattern, key)));
+}
 /** A computed event can use the variable-arity dyn path only when its
  * syntax proves a nonempty prefix or suffix excluding internal events. */
 function computedEventPattern(lowerer, info, member, arg) {
@@ -483,7 +633,7 @@ function computedEventPattern(lowerer, info, member, arg) {
  * checked-dynamic function boundary, which validates typed parameters.
  * The runtime retains the original closure and its checked-dynamic thunk,
  * supplying the exact emit argc without a fixed-tuple or varargs ABI. */
-function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, registering, once, prepend, loc) {
+function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, registering, once, prepend, loc, onFn = "emitter.onFlex", bridge = false) {
     if (receiver.type.kind !== "object") {
         lowerer.noLowering(`${member} with a nullable or non-emitter receiver`, cbNode, "narrow the receiver to an EventEmitter instance before registering or removing a computed-name listener");
     }
@@ -507,10 +657,20 @@ function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, register
         lowerer.noLowering(`${member} with a non-function computed-name listener`, cbNode);
     }
     const recvT = receiver.type;
-    const key = `emitter.${registering ? "onFlex" : "offDyn"}:${typeKey(recvT)}`;
+    // An UNRESTRICTED name (`bridge`) may be any event, including 'error',
+    // the meta events, and the literal events typed code fixes a tuple for:
+    // register through the checked-dynamic receiver's bridge (typed adapters
+    // for those events, the thunk alone otherwise), which keeps Node's
+    // contract for each.
+    if (bridge && registering) {
+        const bridged = lowerDynamicEmitterOn(lowerer, receiver, name, boxed, once, prepend, loc);
+        if (bridged)
+            return bridged;
+    }
+    const key = `${registering ? onFn : "emitter.offDyn"}:${typeKey(recvT)}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
-        helper = keyedHelperName(lowerer, `%emitter.${registering ? "onFlex" : "offFlex"}`, key);
+        helper = keyedHelperName(lowerer, `%${registering ? onFn : "emitter.offFlex"}`, key);
         lowerer.arrHofHelpers.set(key, helper);
         const params = [
             { localId: "r.0", name: "r", type: recvT },
@@ -545,7 +705,7 @@ function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, register
                 kind: "return",
                 value: {
                     kind: "libCall",
-                    fn: registering ? "emitter.onFlex" : "emitter.offDyn",
+                    fn: registering ? onFn : "emitter.offDyn",
                     args: [
                         varRef("r.0", recvT, loc),
                         varRef("n.0", STRING, loc),
@@ -573,6 +733,44 @@ function lowerFlexListenerCall(lowerer, member, name, receiver, cbNode, register
         loc,
     };
 }
+/** A lowered value as a checked-dynamic payload: boxed as any untyped
+ * value is (records and arrays keep their identity), otherwise a refusal
+ * at the argument. */
+function boxedPayload(lowerer, value, node) {
+    if (value.type.kind === "dyn")
+        return value;
+    if (value.kind === "unitLit" ||
+        canConvertToDyn(value.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+        return lowerer.coerceToExpected(value, DYN);
+    }
+    lowerer.noLowering(`emit('error') with a '${lowerer.fmt(value.type)}' payload`, node, "the payload cannot box into a dynamic value");
+}
+/** The listener array of an event whose registrations all hold a checked-
+ * dynamic function value (listenerArrayIsDyn), each comparing equal to the
+ * function that was registered. JavaScript sources read the untyped array,
+ * whose functions take every argument a call passes. TypeScript sources
+ * read the element type the typed path declares, the event's tuple: a
+ * listener of exactly that signature unwraps to the original closure. An
+ * event no literal emit or listener gives a tuple (one registered only under
+ * computed names) reads the untyped array in both. */
+function dynListenerArray(lowerer, table, receiver, name, call, loc) {
+    const array = {
+        kind: "libCall",
+        fn: "emitter.listenersDyn",
+        args: [receiver, eventNameExpr(name, loc)],
+        type: DYN,
+        loc,
+    };
+    if (isJsSourceFile(ts.getSourceFileOfNode(call)) || !table.has(name))
+        return array;
+    const tuple = tupleOf(lowerer, table, name, call);
+    return {
+        kind: "dynCheck",
+        value: array,
+        type: arrayOf({ kind: "func", params: tuple, ret: { kind: "void" } }),
+        loc,
+    };
+}
 /** The event's unified tuple, with conflicts reported at this site. */
 function tupleOf(lowerer, table, name, blame) {
     const sig = table.get(name);
@@ -583,6 +781,24 @@ function tupleOf(lowerer, table, name, blame) {
     }
     return sig.tuple;
 }
+/** True when the listener is a function whose body reads `arguments`: it
+ * lowers with an arguments-pack ABI and takes every emitted argument,
+ * which the typed path's call with a prefix of the event's tuple would not
+ * pass, so it registers as a checked-dynamic listener. */
+function readsArgumentsPack(lowerer, node) {
+    let declaration;
+    try {
+        declaration = lowerer.checker.getCallSignatures(lowerer.typeOf(node))[0]?.declaration;
+    }
+    catch {
+        return false;
+    }
+    return (declaration !== undefined &&
+        ts.isFunctionLike(declaration) &&
+        !ts.isArrowFunction(declaration) &&
+        isJsSourceFile(ts.getSourceFileOfNode(declaration)) &&
+        bodyReadsArguments(declaration));
+}
 /** How a listener argument is dyn-flavored: "dyn" for a checked-dynamic
  * VALUE (a mustCall wrapper, a listener that rode an untyped binding),
  * "func" for a function whose parameters include dyn (the JS lane's
@@ -606,6 +822,8 @@ function dynListenerFlavor(lowerer, node) {
     if (t?.kind === "func") {
         if (t.params.some((p) => p.kind === "dyn"))
             return "func";
+        if (readsArgumentsPack(lowerer, node))
+            return "func";
         // The inferred signature of a wrapper can omit its runtime arguments
         // pack. Register the checked callable produced by the factory itself.
         return tryLowerExpression(lowerer, node)?.type.kind === "dyn" ? "dyn" : null;
@@ -648,7 +866,16 @@ function lowerDynListenerCall(lowerer, member, name, tuple, receiver, cbNode, fl
  * tuple is [DYN] — the adapter passes the boxed chunk through. */
 streamData) {
     if (META_EVENTS.has(name)) {
-        lowerer.noLowering(`'${member}' of '${name}' with a checked-dynamic listener`, cbNode, "Node passes the listener FUNCTION as the meta event's second argument, which has no dynamic conversion — annotate the listener's parameter as a string");
+        // The registration installs the registry's dynamic half: the listener
+        // receives the event name and the added or removed listener's
+        // checked-dynamic function value, as in Node. Every other listener
+        // then registers through the adapter (registersAsDyn), which the event
+        // table's scan arranges when it records a dyn-flavored listener of
+        // either meta event; a typed listener of the other one arrives here too.
+        if (registering && !hasDynMetaListener(emitterEvents(lowerer))) {
+            lowerer.noLowering(`'${member}' of '${name}' with a checked-dynamic listener the event table did not record`, cbNode, "register the listener directly at this call");
+        }
+        return lowerFlexListenerCall(lowerer, member, eventNameExpr(name, loc), receiver, cbNode, registering, once, prepend, loc, "emitter.onAny");
     }
     const getRecord = (id) => lowerer.shapes.get(id);
     const getUnion = (id) => lowerer.unions.get(id);
@@ -1087,7 +1314,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         }
         return receiver;
     };
-    const lowerFlexEmit = (name, kind = "computed-name") => {
+    const lowerFlexEmit = (name, kind = "computed-name", anyName = false) => {
         const below = [];
         collectEmitOverridesBelow(info, below);
         if (emitOverrideAtOrAbove(info) || below.length > 0) {
@@ -1098,6 +1325,18 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             lowerer.noLowering(`${kind} emit on a nullable or non-emitter receiver`, access.expression, "narrow the receiver to an EventEmitter instance before emitting");
         }
         const payload = args.slice(1).map((arg) => lowerer.lowerExprExpecting(arg, DYN));
+        if (anyName) {
+            // Any event name: the checked-dynamic receiver's emit, which keeps
+            // 'error' and the meta events' contracts and converts the arguments
+            // for listeners registered with a typed tuple.
+            return (lowerDynamicEmitterEmit(lowerer, receiver, name, payload, loc) ?? {
+                kind: "libCall",
+                fn: "emitter.emitAny",
+                args: [receiver, name, ...payload],
+                type: BOOL,
+                loc,
+            });
+        }
         return {
             kind: "libCall",
             fn: "emitter.emitFlex",
@@ -1182,10 +1421,14 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         }
         const registering = REGISTER_MEMBERS.has(member);
         if (literalEventName(lowerer, args[0]) === null) {
-            computedEventPattern(lowerer, info, member, args[0]);
+            // An unrestricted name on a plain emitter takes the any-name path;
+            // streams keep the fence (their runtime events carry fixed ABIs).
+            const anyName = computedEventPatternOf(lowerer, args[0]) === null && streamSidesOf(lowerer, info) === null;
+            if (!anyName)
+                computedEventPattern(lowerer, info, member, args[0]);
             const receiver = lowerReceiver();
             const name = lowerer.lowerExprExpecting(args[0], STRING);
-            return lowerFlexListenerCall(lowerer, member, name, receiver, args[1], registering, member === "once" || member === "prependOnceListener", member === "prependListener" || member === "prependOnceListener", loc);
+            return lowerFlexListenerCall(lowerer, member, name, receiver, args[1], registering, member === "once" || member === "prependOnceListener", member === "prependListener" || member === "prependOnceListener", loc, anyName ? "emitter.onAny" : "emitter.onFlex", anyName);
         }
         const name = eventNameOf(lowerer, member, args[0]);
         if (!META_EVENTS.has(name) &&
@@ -1216,7 +1459,8 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         // to the declared type, or take the value (dyn).
         const sides = streamSidesOf(lowerer, info);
         if (name === "data" && (sides === "r" || sides === "rw")) {
-            const dynFlavor = dynListenerFlavor(lowerer, args[1]);
+            const dynFlavor = dynListenerFlavor(lowerer, args[1]) ??
+                (registersAsDyn(lowerer, name, true) ? "func" : null);
             if (dynFlavor !== null) {
                 return lowerDynListenerCall(lowerer, member, name, [DYN], receiver, args[1], dynFlavor, registering, once, prepend, loc, true);
             }
@@ -1259,6 +1503,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                 args: [receiver, eventNameExpr(name, loc), cb, boolLit(once, loc), boolLit(prepend, loc)],
                 type: receiver.type,
                 loc,
+                ...(listenerReadsThis(lowerer, args[1]) ? { bindsThis: true } : {}),
             };
         }
         // Stream-rooted receivers consult the per-base FORCED tuples first
@@ -1273,7 +1518,10 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             if (probe)
                 checkKeypressListener(lowerer, args[1], probe);
         }
-        const dynFlavor = dynListenerFlavor(lowerer, args[1]) ?? (keypress ? "func" : null);
+        const dynFlavor = dynListenerFlavor(lowerer, args[1]) ??
+            (keypress || registersAsDyn(lowerer, name, streamForcedTuple(lowerer, info, name) !== null)
+                ? "func"
+                : null);
         if (dynFlavor !== null) {
             return lowerDynListenerCall(lowerer, member, name, tuple, receiver, args[1], dynFlavor, registering, once, prepend, loc, false);
         }
@@ -1286,6 +1534,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                 : [receiver, eventNameExpr(name, loc), cb],
             type: receiver.type,
             loc,
+            ...(registering && listenerReadsThis(lowerer, args[1]) ? { bindsThis: true } : {}),
         };
     }
     if (member === "emit") {
@@ -1295,6 +1544,7 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         if (literalEventName(lowerer, args[0]) === null) {
             const pattern = computedEventPatternOf(lowerer, args[0]);
             const mayBeObserved = pattern === null ||
+                lowerer.emitterAnyNameListener ||
                 computedPatternOverlapsReserved(pattern) ||
                 [...table].some(([candidate, sig]) => (candidate === "error" || sig.hasListener) && patternMatchesName(pattern, candidate)) ||
                 computedPatterns(lowerer).some((registered) => registered.listener && computedPatternsOverlap(pattern, registered));
@@ -1314,6 +1564,10 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
                     loc,
                 };
             }
+            if (pattern === null && streamSidesOf(lowerer, info) === null) {
+                const name = lowerer.lowerExprExpecting(args[0], STRING);
+                return lowerFlexEmit(name, "computed-name", true);
+            }
             computedEventPattern(lowerer, info, member, args[0]);
             const name = lowerer.lowerExprExpecting(args[0], STRING);
             return lowerFlexEmit(name);
@@ -1327,23 +1581,30 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
             return lowerFlexEmit(eventNameExpr(name, loc), flexibleJsEvent(name, table.get(name)) ? "variable-arity" : "computed-name");
         const receiver = lowerReceiver();
         if (name === "error") {
-            // The special event: exactly one %Error-rooted payload; no listener
-            // means the runtime THROWS it (emitter.emitError, may-throw).
-            if (args.length !== 2) {
-                lowerer.noLowering(`emit('error') with ${args.length - 1} payload arguments`, call, "the supported form is emit('error', err) with an Error-hierarchy payload (non-Error payloads would need Node's ERR_UNHANDLED_ERROR wrapping — no lowering yet)");
-            }
-            const err = lowerer.lowerExpr(args[1]);
-            const rootsAtError = (t) => {
-                if (t.kind !== "object")
-                    return false;
-                for (let c = lowerer.classes.get(t.className) ?? null; c; c = c.base) {
-                    if (c.def.name === "%Error")
-                        return true;
+            // The special event: one %Error-rooted payload; no listener means the
+            // runtime THROWS it (emitter.emitError, may-throw).
+            const err = args.length === 2 ? lowerer.lowerExpr(args[1]) : null;
+            if (err === null || !rootsAtError(lowerer, err.type)) {
+                // Any other payload, or another argument count: the arguments box
+                // to dyn. With no 'error' listener the runtime throws Node's
+                // ERR_UNHANDLED_ERROR (the payload's util.inspect in the message,
+                // the payload as `context`); listeners receive the arguments as
+                // given.
+                if (emitOverrideAtOrAbove(info) || superRecv !== undefined) {
+                    lowerer.noLowering(`emit('error') with a non-Error payload through an emit override`, call, "the override specialization takes the event's one Error payload");
                 }
-                return false;
-            };
-            if (!rootsAtError(err.type)) {
-                lowerer.noLowering(`emit('error') with a '${lowerer.fmt(err.type)}' payload`, args[1], "the supported payload is an Error-hierarchy instance");
+                const payload = args
+                    .slice(1)
+                    .map((arg, i) => i === 0 && err !== null
+                    ? boxedPayload(lowerer, err, arg)
+                    : lowerer.lowerExprExpecting(arg, DYN));
+                return {
+                    kind: "libCall",
+                    fn: "emitter.emitErrorValue",
+                    args: [receiver, ...payload],
+                    type: BOOL,
+                    loc,
+                };
             }
             return emitDispatchExpr(lowerer, info, name, [{ kind: "object", className: "%Error" }], receiver, [lowerer.upcastTo(err, "%Error")], superRecv?.cls, loc);
         }
@@ -1452,9 +1713,10 @@ export function lowerEmitterMethodCall(lowerer, call, access, info, superRecv) {
         }
         const name = eventNameOf(lowerer, member, args[0]);
         const sig = table.get(name);
-        if (sig?.dynListener ||
-            flexibleJsEvent(name, sig) ||
-            computedPatterns(lowerer).some((pattern) => pattern.listener && patternMatchesName(pattern, name))) {
+        if (listenerArrayIsDyn(lowerer, name, sig)) {
+            return dynListenerArray(lowerer, table, lowerReceiver(), name, call, loc);
+        }
+        if (sig?.dynListener || computedListenerMayHold(lowerer, name)) {
             // A dyn-adapted registration means the runtime bucket can hold
             // originals of MIXED signatures — no one honest element type.
             lowerer.noLowering(`${member} 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(name) counts");
@@ -2070,6 +2332,44 @@ export function lowerEventsOnce(lowerer, call, loc) {
     const arrayT = arrayOf(DYN);
     const resultT = { kind: "promise", inner: arrayT };
     let receiver = lowerer.lowerExpr(args[0]);
+    // events.once(process.stdout, "drain"): the next 'drain' of a stream
+    // whose writes are synchronous never comes (Node emits it only after a
+    // write returned false), so the promise stays pending. A pending promise
+    // holds nothing: the process exits when the loop is empty, as in Node.
+    {
+        let target = args[0];
+        while (ts.isParenthesizedExpression(target))
+            target = target.expression;
+        const stream = ts.isPropertyAccessExpression(target)
+            ? lowerer.stdlibGlobalMember(target, "process")
+            : null;
+        const nameT = lowerer.typeOf(args[1]);
+        if ((stream === "stdout" || stream === "stderr") &&
+            nameT.isStringLiteralType() &&
+            nameT.value === "drain" &&
+            args.length === 2) {
+            const pending = {
+                kind: "libCall",
+                fn: "events.pendingForever",
+                args: [],
+                type: resultT,
+                loc,
+            };
+            let name = args[1];
+            while (ts.isParenthesizedExpression(name))
+                name = name.expression;
+            if (ts.isStringLiteralLike(name))
+                return pending;
+            // A name expression typed "drain" still runs (`pick()`, `(log(), "drain")`).
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "exprStmt", expr: lowerer.lowerExpr(args[1]), loc }],
+                result: pending,
+                type: resultT,
+                loc,
+            };
+        }
+    }
     // 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" &&
@@ -2241,9 +2541,10 @@ export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
         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))) {
+        if (listenerArrayIsDyn(lowerer, name, sig)) {
+            return dynListenerArray(lowerer, table, receiver, name, call, loc);
+        }
+        if (sig?.dynListener || computedListenerMayHold(lowerer, 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);
@@ -2257,4 +2558,45 @@ export function lowerEventsEmitterHelper(lowerer, call, member, loc) {
     }
     return null;
 }
+/** Whether a typed listener can read the `this` its calls bind (Node calls
+ * listeners with the emitter as `this`): a function expression, or a
+ * function declaration or `const` function binding, whose own body reads
+ * `this`; any other listener value except an arrow in a JavaScript source;
+ * and in a TypeScript source, where a function reads `this` only through a
+ * declared `this` parameter, a value whose call signature declares one.
+ * Arrows read the enclosing `this`. */
+function listenerReadsThis(lowerer, node) {
+    let listener = node;
+    while (ts.isParenthesizedExpression(listener))
+        listener = listener.expression;
+    if (ts.isArrowFunction(listener))
+        return false;
+    if (ts.isFunctionExpression(listener))
+        return functionUsesThis(listener);
+    if (ts.isIdentifier(listener)) {
+        const decls = lowerer.checker.getSymbolAtLocation(listener)?.declarations ?? [];
+        // An overloaded function's implementation is the declaration with a
+        // body; its overload signatures have none.
+        const fn = decls.find((d) => ts.isFunctionDeclaration(d) && d.body !== undefined);
+        if (fn !== undefined)
+            return functionUsesThis(fn);
+        const binding = decls.find(ts.isVariableDeclaration);
+        let init = binding?.initializer;
+        while (init !== undefined && ts.isParenthesizedExpression(init))
+            init = init.expression;
+        if (binding !== undefined &&
+            init !== undefined &&
+            (ts.getCombinedNodeFlags(binding) & ts.NodeFlags.Const) !== 0) {
+            if (ts.isArrowFunction(init))
+                return false;
+            if (ts.isFunctionExpression(init))
+                return functionUsesThis(init);
+        }
+    }
+    if (isJsSourceFile(ts.getSourceFileOfNode(node)))
+        return true;
+    return lowerer.checker
+        .getCallSignatures(lowerer.typeOf(listener))
+        .some((signature) => (signature.declaration?.parameters?.nodes ?? []).some(isThisParameter));
+}
 //# sourceMappingURL=lower-event-emitter.js.map