diff --git a/docs/content/limitations/builtin-apis/eventemitter.mdx b/docs/content/limitations/builtin-apis/eventemitter.mdx
index 4f71420944..a9f03b8575 100644
--- a/docs/content/limitations/builtin-apis/eventemitter.mdx
+++ b/docs/content/limitations/builtin-apis/eventemitter.mdx
@@ -1,4 +1,5 @@
 - **EventEmitter:** Literal event names use fixed argument tuples.
   Computed string names require a constant prefix or suffix that excludes `error`, meta events, and stream-internal events; their arguments must match the exact arity and support checked conversion.
   Unrestricted names, symbols, names that may reach internal events, and typed `listeners()`/`rawListeners()` results for names with possible computed registrations are unsupported.
+  `events.once` accepts EventEmitter and stream instances with a literal event name and an optional object-literal `{ signal }`; a stream's `data` event, other options values, and EventTarget emitters are unsupported.
   Reading `defaultMaxListeners` through a CommonJS destructured or member binding (`const { defaultMaxListeners } = require("events")`) is unsupported.
diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts
index 411291d94c..6dfcc90ef8 100644
--- a/packages/compiler/ambient/scriptc-node-fallback.d.ts
+++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts
@@ -6569,7 +6569,7 @@ declare module "events" {
     export { internal as EventEmitter };
     // The event's arguments, as checked-dynamic values.
     export function once(
-      emitter: EventEmitter,
+      emitter: EventEmitter | NodeJS.ReadableStream | NodeJS.WritableStream,
       eventName: string,
       options?: { signal?: AbortSignal },
     ): Promise<unknown[]>;
diff --git a/packages/compiler/src/backend/executable-features.ts b/packages/compiler/src/backend/executable-features.ts
index 9cbf030e77..2677aba951 100644
--- a/packages/compiler/src/backend/executable-features.ts
+++ b/packages/compiler/src/backend/executable-features.ts
@@ -27,6 +27,7 @@ export function executableLinkFeatures(mod: IrModule): NativeLinkFeatures {
     dynAsync: features.dynAsync,
     ...(features.dynTier ? { dynTier: true } : {}),
     ...(features.streamDyn ? { streamDyn: true } : {}),
+    ...(features.eventsOnceSignal ? { eventsOnceSignal: true } : {}),
     events: features.processEvents,
     emitter: features.emitter,
     symbol: features.symbol,
diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts
index b72a6e2260..a16567607d 100644
--- a/packages/compiler/src/backend/llvm/emitter.ts
+++ b/packages/compiler/src/backend/llvm/emitter.ts
@@ -5599,8 +5599,11 @@ export class LlEmitter {
     return emitterFixedAdapter(this, cbT);
   }
 
-  emitterOnceAdapter(boxerT: IrType & { kind: "func" }): { fn: string; shim: string } {
-    return emitterOnceAdapter(this, boxerT);
+  emitterOnceAdapter(
+    boxerT: IrType & { kind: "func" },
+    fire?: string,
+  ): { fn: string; shim: string } {
+    return emitterOnceAdapter(this, boxerT, fire);
   }
 
   wrapEmitterListener(target: string, adapterFn: string): string {
diff --git a/packages/compiler/src/backend/llvm/expr-callbacks.ts b/packages/compiler/src/backend/llvm/expr-callbacks.ts
index 28bd157593..b91cdc5437 100644
--- a/packages/compiler/src/backend/llvm/expr-callbacks.ts
+++ b/packages/compiler/src/backend/llvm/expr-callbacks.ts
@@ -864,23 +864,27 @@ export function emitterFixedAdapter(
  * (the event's tuple to any[]): the runtime-built listener closure holds
  * the boxer in caps[0], so the adapter calls it with the event's typed
  * arguments, as emitterFixedAdapter calls a listener, and hands the array
- * to scr_events_once_fire. */
+ * to scr_events_once_fire (or `fire`, the signal form's entry). */
 export function emitterOnceAdapter(
   host: LlvmEmitterContext,
   boxerT: IrType & { kind: "func" },
+  fire = "scr_events_once_fire",
 ): { fn: string; shim: string } {
   const cursor = boxerT.params.length > 4;
   const shim = cursor ? "scr_ee_inv_args" : `scr_ee_inv_fixed${boxerT.params.length}`;
   if (cursor) host.declare("declare ptr @scr_ee_arg_next(ptr)");
   host.declare(`declare void @${shim}(ptr, ptr)`);
-  const key = `eeOnce:${typeKey(boxerT)}`;
+  const key =
+    fire === "scr_events_once_fire"
+      ? `eeOnce:${typeKey(boxerT)}`
+      : `eeOnce:${fire}:${typeKey(boxerT)}`;
   let sym = host.resolveThunks.get(key);
   if (sym) return { fn: sym, shim };
   sym = `sc_ee_once_${host.resolveThunks.size}`;
   host.resolveThunks.set(key, sym);
   host.declare(`declare ptr @scr_box_get_ref(ptr)`);
   host.declare(`declare void @scr_closure_release(ptr)`);
-  host.declare(`declare void @scr_events_once_fire(ptr, ptr)`);
+  host.declare(`declare void @${fire}(ptr, ptr)`);
   const params = cursor ? "ptr %args" : boxerT.params.map((_, i) => `ptr %a${i}`).join(", ");
   const d: string[] = [
     `define internal void @${sym}(ptr %cb${params ? ", " + params : ""}) ${FN_ATTRS} { ; events.once adapter ${typeKey(boxerT)}`,
@@ -911,7 +915,7 @@ export function emitterOnceAdapter(
     `  %fn = load ptr, ptr %fnp`,
     `  %arr = call ptr %fn(${passed.join(", ")}) ; the boxed arguments, +1`,
     `  call void @scr_closure_release(ptr %boxer)`,
-    `  call void @scr_events_once_fire(ptr %cb, ptr %arr) ; moves %arr`,
+    `  call void @${fire}(ptr %cb, ptr %arr) ; moves %arr`,
     `  ret void`,
     `}`,
     ``,
diff --git a/packages/compiler/src/backend/llvm/lib-dispatch.ts b/packages/compiler/src/backend/llvm/lib-dispatch.ts
index 6cec9d4032..9e31e1b495 100644
--- a/packages/compiler/src/backend/llvm/lib-dispatch.ts
+++ b/packages/compiler/src/backend/llvm/lib-dispatch.ts
@@ -755,7 +755,8 @@ export function emitLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
   }
   const prefix = e.fn.slice(0, e.fn.indexOf(".")) as LibCallPrefix;
   // events.once builds typed listener adapters beside the emitter calls.
-  if (e.fn === "events.once") return host.emitErrorsEventsLibCall(e);
+  if (e.fn === "events.once" || e.fn === "events.onceSignal")
+    return host.emitErrorsEventsLibCall(e);
   switch (prefix) {
     case "fetch":
     case "abort":
diff --git a/packages/compiler/src/backend/llvm/lib-process.ts b/packages/compiler/src/backend/llvm/lib-process.ts
index 4a7be1a35f..097fcb4dea 100644
--- a/packages/compiler/src/backend/llvm/lib-process.ts
+++ b/packages/compiler/src/backend/llvm/lib-process.ts
@@ -731,27 +731,34 @@ export function emitErrorsEventsLibCall(host: LlvmEmitterContext, e: LibCallExpr
     host.emitAlwaysPendingUnwind();
     return out;
   }
-  if (e.fn === "events.once") {
-    // (recv, name, boxer, errorBoxer, listenForError): scr_events_once
-    // registers one-shot typed listeners behind adapters that box the
-    // event's tuple (and the 'error' tuple) into the fulfilled array. The
-    // runtime retains the boxers; the frame's temporaries release as usual.
-    // May-throw ('newListener' meta listeners run inside).
+  if (e.fn === "events.once" || e.fn === "events.onceSignal") {
+    // (recv, name, boxer, errorBoxer, listenForError[, signal]):
+    // scr_events_once registers one-shot typed listeners behind adapters
+    // that box the event's tuple (and the 'error' tuple) into the fulfilled
+    // array. The runtime retains the boxers; the frame's temporaries
+    // release as usual. May-throw ('newListener' meta listeners run
+    // inside). The signal form's adapters end in its own fire entry.
     const boxerT = e.args[2]!.type;
     const errorT = e.args[3]!.type;
     if (boxerT.kind !== "func" || errorT.kind !== "func")
-      throw new InternalCompilerError("llvm emitter bug: events.once boxer not a func");
+      throw new InternalCompilerError(`llvm emitter bug: ${e.fn} boxer not a func`);
+    const signal = e.fn === "events.onceSignal";
     const args = e.args.map((a) => host.emitExpr(a));
-    const event = host.emitterOnceAdapter(boxerT);
-    const error = host.emitterOnceAdapter(errorT);
-    host.declare(`declare ptr @scr_events_once(ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr)`);
+    const fire = signal ? "scr_events_once_signal_fire" : undefined;
+    const event = host.emitterOnceAdapter(boxerT, fire);
+    const error = host.emitterOnceAdapter(errorT, fire);
+    const entry = signal ? "scr_events_once_signal" : "scr_events_once";
+    host.declare(
+      `declare ptr @${entry}(ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr${signal ? ", ptr" : ""})`,
+    );
     const errorBoxer = B.tmp();
     B.line(`${errorBoxer} = select i1 ${args[4]!.name}, ptr ${args[3]!.name}, ptr null`);
     const t = B.tmp();
     B.line(
-      `${t} = call ptr @scr_events_once(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ` +
+      `${t} = call ptr @${entry}(ptr ${args[0]!.name}, ptr ${args[1]!.name}, ` +
         `ptr ${args[2]!.name}, ptr @${event.fn}, ptr @${event.shim}, ` +
-        `ptr ${errorBoxer}, ptr @${error.fn}, ptr @${error.shim})`,
+        `ptr ${errorBoxer}, ptr @${error.fn}, ptr @${error.shim}` +
+        `${signal ? `, ptr ${args[5]!.name}` : ""})`,
     );
     const out = host.own({ name: t, type: e.type });
     host.emitPendingCheck();
diff --git a/packages/compiler/src/backend/native-link-info-core.ts b/packages/compiler/src/backend/native-link-info-core.ts
index 704945c95d..314fcc9ddb 100644
--- a/packages/compiler/src/backend/native-link-info-core.ts
+++ b/packages/compiler/src/backend/native-link-info-core.ts
@@ -46,6 +46,9 @@ export interface NativeLinkFeatures {
   /** Checked-dynamic stream slots: the scr_stream_dyn.c unit. Absent (not
    * false) for programs without them. */
   streamDyn?: boolean;
+  /** events.once with options: scr_events_once_signal.c. Absent (not
+   * false) for programs without it. */
+  eventsOnceSignal?: boolean;
   events: boolean;
   emitter: boolean;
   symbol: boolean;
diff --git a/packages/compiler/src/backend/native/contracts.ts b/packages/compiler/src/backend/native/contracts.ts
index c7371077f6..0f8a39fedb 100644
--- a/packages/compiler/src/backend/native/contracts.ts
+++ b/packages/compiler/src/backend/native/contracts.ts
@@ -116,6 +116,9 @@ export interface CcOptions {
   /** Checked-dynamic stream slots (stream.dynNative / stream.pipeDyn):
    * compiles scr_stream_dyn.c. */
   streamDyn?: boolean;
+  /** events.once with options (events.onceSignal): compiles
+   * scr_events_once_signal.c. */
+  eventsOnceSignal?: boolean;
   /** The program constructs EventTarget/Event/CustomEvent values or
    * calls events.addAbortListener (the event.* libCalls), or uses the
    * native fetch AbortSignal built on the same engine: compiles
diff --git a/packages/compiler/src/backend/native/executable.ts b/packages/compiler/src/backend/native/executable.ts
index 5ee6b6abde..e497355d33 100644
--- a/packages/compiler/src/backend/native/executable.ts
+++ b/packages/compiler/src/backend/native/executable.ts
@@ -220,6 +220,9 @@ const RUNTIME_UNITS: readonly RuntimeUnit[] = [
   // measures with.
   unit((u) => u.opts.events && u.regex, "scr_readline_tty.c"),
   unit((u) => u.opts.emitter || u.opts.workers, "scr_events_emitter.c"),
+  // events.once with options registers through the emitter and
+  // event-target units.
+  unit((u) => u.opts.eventsOnceSignal === true, "scr_events_once_signal.c"),
   // The checked-dynamic HANDLE support unit (listener gate + runtime
   // adapter closures): every referencing unit is one of the emitter or
   // net families (http implies net), so handle-free binaries keep
diff --git a/packages/compiler/src/backend/runtime-pack-core.ts b/packages/compiler/src/backend/runtime-pack-core.ts
index 748de64fc4..5c9d417c57 100644
--- a/packages/compiler/src/backend/runtime-pack-core.ts
+++ b/packages/compiler/src/backend/runtime-pack-core.ts
@@ -85,6 +85,7 @@ export interface RuntimeFeatureSet extends NativeLinkFeatures {
   wasm: boolean;
   dynTier: boolean;
   streamDyn: boolean;
+  eventsOnceSignal: boolean;
   warningReplace: boolean;
   stdioExtended: boolean;
   nativeFetch: boolean;
@@ -277,6 +278,7 @@ export function effectiveRuntimeFeatures(
     wasm: features.wasm === true,
     dynTier: features.dynTier === true,
     streamDyn: features.streamDyn === true,
+    eventsOnceSignal: features.eventsOnceSignal === true,
     warningReplace: features.warningReplace === true,
     stdioExtended: features.stdioExtended === true,
     nativeFetch,
diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts
index f0be7e11f9..0632fbc7ec 100644
--- a/packages/compiler/src/executable/executable-cache.ts
+++ b/packages/compiler/src/executable/executable-cache.ts
@@ -67,6 +67,7 @@ export interface EarlyExecutableNativeFeatures {
   dynAsync: boolean;
   dynTier?: boolean;
   streamDyn?: boolean;
+  eventsOnceSignal?: boolean;
   events: boolean;
   emitter: boolean;
   symbol: boolean;
diff --git a/packages/compiler/src/frontend/lowering/builtins/promises.ts b/packages/compiler/src/frontend/lowering/builtins/promises.ts
index 55290f7206..6c4705f0ea 100644
--- a/packages/compiler/src/frontend/lowering/builtins/promises.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/promises.ts
@@ -187,7 +187,11 @@ function lowerTuplePromiseAll(
  * type is the checker's combined promise, and each entry's inner type
  * must be that inner type, one of its union arms, or a sub-union of it
  * (the backend's interned adapters wrap/re-tag fulfillments; a wider
- * entry would need machinery that doesn't exist and fences).
+ * entry would need machinery that doesn't exist and fences). A
+ * Promise<never> entry fits any result, and an entry whose payload widens
+ * into the result's converts. When the checker's combined type has no
+ * representation, the result takes the type the entries that can fulfill
+ * share, or 'unknown'.
  * Promise.all/allSettled/any fence with the sequential-await hint;
  * resolve/reject and the rest fall to the member fence. Null for
  * non-Promise receivers. */
@@ -214,14 +218,47 @@ export function lowerPromiseStaticCall(
         "a non-empty array LITERAL of promises is the supported form: Promise.race([p, q])",
       );
     }
-    const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
-    if (resultT?.kind !== "promise") {
-      lowerer.noLowering(
-        "Promise.race with this combined result type",
-        call,
-        "the entries' value types must combine into a representable union",
-      );
+    // A Promise<never> entry (the deadline idiom: `new Promise<never>((_,
+    // reject) => setTimeout(reject, ms))`) can only reject, so it races
+    // under any result type; its inner type maps to void.
+    const neverEntry = (el: ts.Expression): boolean => {
+      const t = lowerer.typeOf(el);
+      const arg =
+        t.getSymbol()?.name === "Promise"
+          ? lowerer.checker.getTypeArguments(t as ts.TypeReference)[0]
+          : undefined;
+      return arg !== undefined && (arg.flags & ts.TypeFlags.Never) !== 0;
+    };
+    const elements = argNode.elements.nodes;
+    let combined = lowerer.mapTypeOf(lowerer.typeOf(call));
+    let lowered: IrExpr[] | null = null;
+    if (combined?.kind !== "promise") {
+      // The checker's combined type has no representation (an 'any'
+      // element array such as events.once's any[], or 'void | any[]'): the
+      // result takes the one type the entries that can fulfill share, or
+      // else 'unknown' when each of them widens into it.
+      lowered = elements.map((el) => lowerer.lowerExpr(el));
+      const fulfilling = lowered.filter((_, i) => !neverEntry(elements[i]!));
+      const first = fulfilling[0]?.type;
+      const dynResult: IrType & { kind: "promise" } = { kind: "promise", inner: DYN };
+      if (first?.kind === "promise" && fulfilling.every((e) => typeEquals(e.type, first))) {
+        combined = first;
+      } else if (
+        fulfilling.length > 0 &&
+        fulfilling.every(
+          (e) => e.type.kind === "promise" && lowerer.promisePayloadWidens(e.type, dynResult),
+        )
+      ) {
+        combined = dynResult;
+      } else {
+        lowerer.noLowering(
+          "Promise.race with this combined result type",
+          call,
+          "the entries' value types must combine into a representable union",
+        );
+      }
     }
+    const resultT = combined;
     const resultArms =
       resultT.inner.kind === "union"
         ? (lowerer.unions.get(resultT.inner.unionId)?.arms ?? [])
@@ -238,19 +275,8 @@ export function lowerPromiseStaticCall(
       }
       return resultArms.some((a) => typeEquals(a, inner));
     };
-    // A Promise<never> entry (the deadline idiom: `new Promise<never>((_,
-    // reject) => setTimeout(reject, ms))`) can only reject, so it races
-    // under any result type; its inner type maps to void.
-    const neverEntry = (el: ts.Expression): boolean => {
-      const t = lowerer.typeOf(el);
-      const arg =
-        t.getSymbol()?.name === "Promise"
-          ? lowerer.checker.getTypeArguments(t as ts.TypeReference)[0]
-          : undefined;
-      return arg !== undefined && (arg.flags & ts.TypeFlags.Never) !== 0;
-    };
-    const entries = argNode.elements.nodes.map((el) => {
-      const entry = lowerer.lowerExpr(el);
+    const entries = elements.map((el, i) => {
+      const entry = lowered?.[i] ?? lowerer.lowerExpr(el);
       if (entry.type.kind !== "promise") {
         lowerer.noLowering(
           "Promise.race over non-promise entries",
@@ -259,6 +285,10 @@ export function lowerPromiseStaticCall(
         );
       }
       if (!compatible(entry.type.inner) && !(entry.type.inner.kind === "void" && neverEntry(el))) {
+        // A payload that widens into the result's (into 'unknown', or a
+        // checked conversion) keeps its promise and settlement turn.
+        if (lowerer.promisePayloadWidens(entry.type, resultT))
+          return lowerer.coerceToExpected(entry, resultT);
         lowerer.unsupported(
           "SC1090",
           el,
diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts
index 182a73f14e..169236c515 100644
--- a/packages/compiler/src/frontend/lowering/lower-classes.ts
+++ b/packages/compiler/src/frontend/lowering/lower-classes.ts
@@ -116,6 +116,7 @@ import {
 import {
   STREAM_API_MEMBERS,
   STREAM_PROP_MEMBERS,
+  STREAM_COMPLETION_CALLBACK_INDEX,
   UNDERSCORE_METHODS,
   lowerStreamNew,
   lowerStreamSuperCall,
@@ -2698,6 +2699,24 @@ export function collectClassShapeInner(
               );
             }
           }
+          // A completion callback declared with the broad `Function` type
+          // (`cb: Function`) takes the checked-dynamic callable the runtime
+          // passes implicitly typed callbacks; calls through it are
+          // dynamic calls of that callable.
+          const callbackIndex = STREAM_COMPLETION_CALLBACK_INDEX.get(name);
+          const callbackParam =
+            ts.isMethodDeclaration(member) && callbackIndex !== undefined
+              ? member.parameters.nodes[callbackIndex]
+              : undefined;
+          if (
+            callbackParam !== undefined &&
+            ts.isIdentifier(callbackParam.name) &&
+            !callbackParam.dotDotDotToken &&
+            !callbackParam.questionToken &&
+            !callbackParam.initializer &&
+            lowerer.checker.typeToString(lowerer.typeOf(callbackParam.name)) === "Function"
+          )
+            lowerer.checkedCallbackParams.add(callbackParam);
         }
       }
       if (ts.isPropertyDeclaration(member)) {
diff --git a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts
index 4b8b9ea14b..f2968cebdf 100644
--- a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts
+++ b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts
@@ -72,6 +72,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: Lowerer, info: ClassInfo | undefined | null): boolean {
@@ -2204,36 +2206,90 @@ function eventsOnceBoxer(
   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: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr {
-  const args = call.arguments.nodes;
-  if (args.length < 2 || args.some(ts.isSpreadElement)) {
-    lowerer.noLowering("events.once without an emitter and an event name", call);
-  }
-  if (args.length > 2) {
+/** 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: Lowerer, node: ts.Expression): IrExpr | null {
+  if (!ts.isObjectLiteralExpression(node)) {
     lowerer.noLowering(
-      "events.once with options",
-      args[2]!,
-      "the lowered form is events.once(emitter, name); AbortSignal options are not supported yet",
+      "events.once options that are not an object literal",
+      node,
+      "pass the options as an object literal: { signal }",
     );
+    return null;
+  }
+  let signal: IrExpr | null = 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 as ts.Identifier),
+        DYN,
+      );
+    } else {
+      lowerer.noLowering(
+        "events.once options other than one signal",
+        prop,
+        "the lowered options object takes signal: AbortSignal",
+      );
+    }
+  }
+  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: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr {
+  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: IrType = { 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) {
+  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 instance; EventTarget and stream receivers are not supported yet",
+      "the emitter must be an EventEmitter or stream instance; EventTarget receivers are not supported yet",
     );
   }
   const name = literalEventName(lowerer, args[1]!);
@@ -2245,6 +2301,14 @@ export function lowerEventsOnce(lowerer: Lowerer, call: ts.CallExpression, loc:
     );
   }
   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(
@@ -2252,14 +2316,22 @@ export function lowerEventsOnce(lowerer: Lowerer, call: ts.CallExpression, loc:
       args[1]!,
     );
   }
-  const tuple = tupleOf(lowerer, table, event, call);
+  const tuple = streamForcedTuple(lowerer, info, event) ?? tupleOf(lowerer, table, event, call);
   const errorTuple: IrType[] = [{ 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,
   };
diff --git a/packages/compiler/src/frontend/lowering/lower-stream.ts b/packages/compiler/src/frontend/lowering/lower-stream.ts
index 44027f65c4..51d1e0377a 100644
--- a/packages/compiler/src/frontend/lowering/lower-stream.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stream.ts
@@ -171,6 +171,16 @@ export const UNDERSCORE_METHODS: ReadonlyMap<string, string> = new Map([
   ["flush", "_flush"],
 ]);
 
+/** The completion callback's parameter position in each underscore
+ * method that takes one (cbTuples' "fn" positions). */
+export const STREAM_COMPLETION_CALLBACK_INDEX: ReadonlyMap<string, number> = new Map([
+  ["_write", 2],
+  ["_final", 0],
+  ["_destroy", 1],
+  ["_transform", 2],
+  ["_flush", 0],
+]);
+
 /** The accepted option-callback names (canonical flag order) and the
  * duplex-shaped-head answer for one runtime stream class. */
 export function streamCtorShape(cls: string): {
diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts
index 9c02cdd8b1..868b92f257 100644
--- a/packages/compiler/src/index.ts
+++ b/packages/compiler/src/index.ts
@@ -546,6 +546,7 @@ async function compileExecutableNative(
     dynAsync: features.dynAsync,
     ...(features.dynTier ? { dynTier: true } : {}),
     ...(features.streamDyn ? { streamDyn: true } : {}),
+    ...(features.eventsOnceSignal ? { eventsOnceSignal: true } : {}),
     events: features.events,
     emitter: features.emitter,
     symbol: features.symbol,
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index fc2ee2ce3a..4e76abb56f 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -4321,6 +4321,10 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
    * errorBoxer, listenForError] → a pending promise of any[]; the boxers
    * turn the event's and the 'error' tuple into that array. */
   "events.once": { argTypes: [null, STRING, null, null, BOOL], result: VOID },
+  /** events.once(emitter, name, { signal }) (scr_events_once_signal.c):
+   * events.once's arguments plus the checked-dynamic signal (an
+   * AbortSignal or undefined). */
+  "events.onceSignal": { argTypes: [null, STRING, null, null, BOOL, DYN], result: VOID },
   /** The resolve-value forms: [ms?, value, ref] → a pending promise of the
    * value's type that copies the borrowed already-resolved `value` promise
    * when the timer (or immediate) fires; ref false unrefs it. The result
diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts
index 0d680d7afe..79875dede7 100644
--- a/packages/compiler/src/ir/runtime-features.ts
+++ b/packages/compiler/src/ir/runtime-features.ts
@@ -130,6 +130,7 @@ const LEGACY_TEXT_DECODER_LIB_FNS: ReadonlySet<IrLibFn> = new Set([
 
 /** Signal-taking readline, stream and timers/promises entry points, which register abort listeners. */
 const ABORT_SIGNAL_LIB_FNS: ReadonlySet<IrLibFn> = new Set([
+  "events.onceSignal",
   "http.clientSignal",
   "http.requestDyn",
   "http.requestDynCb",
@@ -580,6 +581,8 @@ const RUNTIME_FEATURE_RULES = {
     fns: ["events.addAbortListener", ...ABORT_SIGNAL_LIB_FNS],
     prefixes: ["event."],
   }),
+  /** events.once(emitter, name, { signal }) (scr_events_once_signal.c). */
+  eventsOnceSignal: rule({ fns: ["events.onceSignal"] }),
   fetch: rule({ prefixes: ["fetch."] }),
   fileHandle: rule({ types: ["fileHandle"] }),
   fsWatch: rule({ prefixes: ["fs.watch", "watcher."], types: ["fsWatcher"] }),
@@ -721,6 +724,7 @@ function noRuntimeFeatures(): RuntimeFeatures {
     dynTier: false,
     emitter: false,
     eventTarget: false,
+    eventsOnceSignal: false,
     fetch: false,
     fileHandle: false,
     fsWatch: false,
diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts
index 69a08fb5a5..2a2ddbd2f1 100644
--- a/packages/compiler/src/ir/validate.ts
+++ b/packages/compiler/src/ir/validate.ts
@@ -4159,7 +4159,7 @@ function validateFunction(
       if (!ok) err(`libCall ${e.fn} must be a promise of its ${cryptoPromise} value`, e.loc);
       return true;
     }
-    if (e.fn === "events.once") {
+    if (e.fn === "events.once" || e.fn === "events.onceSignal") {
       const [recv, , boxer, errorBoxer] = e.args;
       const arrayT = e.type.kind === "promise" ? e.type.inner : null;
       const boxes = (b: IrExpr | undefined) =>
@@ -4170,7 +4170,7 @@ function validateFunction(
         !boxes(boxer) ||
         !boxes(errorBoxer)
       ) {
-        err(`libCall events.once must box its event tuples into the promised array`, e.loc);
+        err(`libCall ${e.fn} must box its event tuples into the promised array`, e.loc);
       }
       return true;
     }
diff --git a/packages/compiler/src/native/sanitizer.test.ts b/packages/compiler/src/native/sanitizer.test.ts
index 35dcbddca2..e3fc8fe105 100644
--- a/packages/compiler/src/native/sanitizer.test.ts
+++ b/packages/compiler/src/native/sanitizer.test.ts
@@ -78,6 +78,7 @@ test.skipIf(process.platform !== "linux" && process.platform !== "darwin")(
               wasm: false,
               dynTier: false,
               streamDyn: false,
+              eventsOnceSignal: false,
               warningReplace: false,
               stdioExtended: false,
               regex: true,
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6490-events-once-signal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6490-events-once-signal.ts.json
new file mode 100644
index 0000000000..9c99e2ab00
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6490-events-once-signal.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6490-events-once-signal.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6491-events-once-streams.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6491-events-once-streams.ts.json
new file mode 100644
index 0000000000..4fdbe7a1de
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6491-events-once-streams.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6491-events-once-streams.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6492-promise-race-combined.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6492-promise-race-combined.ts.json
new file mode 100644
index 0000000000..8fa2ceb9a8
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6492-promise-race-combined.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6492-promise-race-combined.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6493-stream-function-callbacks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6493-stream-function-callbacks.ts.json
new file mode 100644
index 0000000000..bb755b9a7e
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6493-stream-function-callbacks.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6493-stream-function-callbacks.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6494-events-once-dyn-stream-slot/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6494-events-once-dyn-stream-slot/main.ts.json
new file mode 100644
index 0000000000..77f43443ee
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6494-events-once-dyn-stream-slot/main.ts.json
@@ -0,0 +1,7 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6494-events-once-dyn-stream-slot/sources.js",
+  "<repo>/tests/corpus/6494-events-once-dyn-stream-slot/main.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/events-once-signal-race.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/events-once-signal-race.ts.json
new file mode 100644
index 0000000000..e5c444b78c
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/events-once-signal-race.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/fixtures/node-types/events-once-signal-race.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime-pack-common/runtime-pack-matrix.mjs b/packages/runtime-pack-common/runtime-pack-matrix.mjs
index a47ebc830b..9dee81d2c5 100644
--- a/packages/runtime-pack-common/runtime-pack-matrix.mjs
+++ b/packages/runtime-pack-common/runtime-pack-matrix.mjs
@@ -78,6 +78,8 @@ export const OPTIONAL_RUNTIME_SOURCES = [
   ["scr_readline.c", "events"],
   ["scr_readline_tty.c", all("events", "regex")],
   ["scr_events_emitter.c", "emitter"],
+  // events.once with options registers through the emitter and event-target units.
+  ["scr_events_once_signal.c", "eventsOnceSignal"],
   ["scr_dyn_handle.c", any("emitter", "netEffective")],
   ["scr_symbol.c", "symbol"],
   ["scr_bigint_assert.c", all("assert", "bigint")],
diff --git a/packages/runtime/src/scr_events_emitter.c b/packages/runtime/src/scr_events_emitter.c
index e0e305bde4..4ac7abdf18 100644
--- a/packages/runtime/src/scr_events_emitter.c
+++ b/packages/runtime/src/scr_events_emitter.c
@@ -518,8 +518,25 @@ static ScrClosure *scr_ee_once_closure(void *adapter, ScrClosure *boxer, ScrEeOn
   return c;
 }
 
+static ScrBox *scr_ee_once_promise_box(ScrPromise *p) {
+  ScrBox *box = scr_box_new_obj(&scr_promise_retain_v, &scr_promise_release_v, &scr_promise_trace_v);
+  scr_box_set_ref(box, scr_promise_retain(p));
+  return box;
+}
+
+static void scr_ee_once_adopt_job(ScrClosure *job) {
+  ScrPromise *outer = scr_box_get_ref(job->caps[0]);
+  ScrPromise *inner = scr_box_get_ref(job->caps[1]);
+  scr_promise_race_join(outer, inner, &scr_promise_adapt_copy);
+  scr_promise_release(inner);
+  scr_promise_release(outer);
+}
+
 /* boxer and err_boxer are borrowed; the result is +1. err_boxer is NULL
- * when the awaited event is 'error' itself. */
+ * when the awaited event is 'error' itself. Node's once is an async
+ * function returning the executor's promise, so the result adopts that
+ * promise through a thenable job queued here, whose reaction settles the
+ * result one turn after the executor's promise settles. */
 ScrPromise *scr_events_once(ScrEmitter *em, ScrStr *name, ScrClosure *boxer, void *adapter,
                             ScrEeInvoke inv, ScrClosure *err_boxer, void *err_adapter,
                             ScrEeInvoke err_inv) {
@@ -558,9 +575,13 @@ ScrPromise *scr_events_once(ScrEmitter *em, ScrStr *name, ScrClosure *boxer, voi
     scr_caught_release(thrown);
     scr_promise_reject_pending(st->promise);
   }
-  ScrPromise *p = scr_promise_retain(st->promise);
+  ScrPromise *outer = scr_promise_new();
+  ScrClosure *job = scr_closure_new((void *)&scr_ee_once_adopt_job, 2);
+  job->caps[0] = scr_ee_once_promise_box(outer);
+  job->caps[1] = scr_ee_once_promise_box(st->promise);
+  scr_queue_microtask(job);
   scr_ee_once_release(st);
-  return p;
+  return outer;
 }
 
 /* The adapter's tail: `cb` is the firing listener closure, `args` the
@@ -1130,3 +1151,9 @@ double scr_emitter_get_default_max(void) { return scr_emitter_default_max; }
 static SCR_TL double scr_emitter_esm_default_max = 10;
 double scr_emitter_esm_default_max_get(void) { return scr_emitter_esm_default_max; }
 void scr_emitter_esm_sync(void) { scr_emitter_esm_default_max = scr_emitter_default_max; }
+
+/* events.once with a signal (scr_events_once_signal.c) undoes an add whose
+ * 'newListener' announcement threw. */
+void scr_emitter_unadd_quiet(ScrEmitter *em, ScrStr *name, ScrClosure *cb) {
+  scr_ee_unadd(em, name, cb);
+}
diff --git a/packages/runtime/src/scr_events_emitter.h b/packages/runtime/src/scr_events_emitter.h
index a92ae1864b..39a7f4b5ba 100644
--- a/packages/runtime/src/scr_events_emitter.h
+++ b/packages/runtime/src/scr_events_emitter.h
@@ -64,6 +64,20 @@ ScrPromise *scr_events_once(ScrEmitter *em, ScrStr *name, ScrClosure *boxer, voi
                             ScrEeInvoke inv, ScrClosure *err_boxer, void *err_adapter,
                             ScrEeInvoke err_inv);
 void scr_events_once_fire(ScrClosure *cb, ScrArr *args);
+/* events.once(emitter, name, { signal }) (scr_events_once_signal.c): the
+ * scr_events_once arguments plus the checked-dynamic signal (borrowed;
+ * undefined for the plain form). Never throws: a non-AbortSignal value,
+ * an aborted signal or a throwing 'newListener' listener rejects the +1
+ * result. Its adapters end in scr_events_once_signal_fire. */
+typedef struct ScrDyn ScrDyn; /* full definition below (C11 repeat) */
+ScrPromise *scr_events_once_signal(ScrEmitter *em, ScrStr *name, ScrClosure *boxer, void *adapter,
+                                   ScrEeInvoke inv, ScrClosure *err_boxer, void *err_adapter,
+                                   ScrEeInvoke err_inv, ScrDyn *signal);
+void scr_events_once_signal_fire(ScrClosure *cb, ScrArr *args);
+/* Removes the listener entry whose closure is `cb` (borrowed) without a
+ * 'removeListener' event: the undo of an add whose 'newListener'
+ * announcement threw. */
+void scr_emitter_unadd_quiet(ScrEmitter *em, ScrStr *name, ScrClosure *cb);
 ScrEmitter *scr_emitter_on(ScrEmitter *em, ScrStr *name, ScrClosure *cb /*moves*/,
                             ScrEeInvoke inv, bool once, bool prepend);
 /* The dyn-adapted registration family (JS-lane checked-dynamic
diff --git a/packages/runtime/src/scr_events_once_signal.c b/packages/runtime/src/scr_events_once_signal.c
new file mode 100644
index 0000000000..c3c2db37dc
--- /dev/null
+++ b/packages/runtime/src/scr_events_once_signal.c
@@ -0,0 +1,303 @@
+/* events.once(emitter, name, { signal }) over typed listeners — Node 24's
+ * lib/events.js `once` with an options object. Linked only by programs
+ * that pass the options (the emitter and event-target units together).
+ *
+ * The signal is validated first: undefined is the plain form, a value that
+ * is not an AbortSignal rejects with ERR_INVALID_ARG_TYPE, and an aborted
+ * signal rejects with an AbortError whose cause is signal.reason, all
+ * without registering a listener. Otherwise the event's one-shot listener,
+ * the 'error' one (unless the event is 'error') and a once,
+ * resist-stop-propagation 'abort' listener on the signal share the state
+ * below. The event or the error removes the other emitter listener and the
+ * abort listener, then settles; the abort removes both emitter listeners
+ * and rejects with the AbortError.
+ *
+ * Ownership: the state owns the promise, the name and the signal. The
+ * emitter is weak in the state; the abort listener holds it strongly (the
+ * abort is the one settlement that does not come from the emitter itself,
+ * like the closure Node's abortListener keeps). The three listener closures
+ * reach the state through link objects; a link clears the state's pointer
+ * to its closure when that closure is freed, so removals never compare a
+ * stale identity. The cycle through the signal's listener ends when the
+ * promise settles or the signal aborts (or at the exit teardown of the
+ * signal's listeners). */
+#include "scr_runtime.h"
+
+#include <stdlib.h>
+
+typedef struct ScrEosState {
+  size_t rc;
+  ScrPromise *promise;  /* owned */
+  ScrEmitter *em;       /* weak: alive whenever a listener fires */
+  ScrStr *name;         /* owned */
+  ScrDyn *signal;       /* owned; undefined without an abort listener */
+  ScrClosure *event_cb; /* weak, NULL once freed */
+  ScrClosure *error_cb; /* weak, NULL once freed or for 'error' */
+  ScrDyn *listener;     /* weak abort listener, NULL once freed */
+  bool settled;
+} ScrEosState;
+
+enum { SCR_EOS_EVENT, SCR_EOS_ERROR, SCR_EOS_ABORT };
+
+typedef struct ScrEosLink {
+  size_t rc;
+  ScrEosState *st; /* owned */
+  int slot;
+} ScrEosLink;
+
+static void scr_eos_oom(void) { scr_trap("scriptc: out of memory in events.once\n"); }
+
+static void scr_eos_state_release(ScrEosState *st) {
+  if (--st->rc > 0) return;
+  scr_promise_release(st->promise);
+  scr_str_release(st->name);
+  scr_dyn_release(st->signal);
+  free(st);
+}
+
+static void *scr_eos_link_retain(void *p) {
+  ((ScrEosLink *)p)->rc++;
+  return p;
+}
+
+static void scr_eos_link_release(void *p) {
+  ScrEosLink *link = p;
+  if (--link->rc > 0) return;
+  ScrEosState *st = link->st;
+  if (link->slot == SCR_EOS_EVENT) st->event_cb = NULL;
+  else if (link->slot == SCR_EOS_ERROR) st->error_cb = NULL;
+  else st->listener = NULL;
+  scr_eos_state_release(st);
+  free(link);
+}
+
+static ScrBox *scr_eos_link_box(ScrEosState *st, int slot) {
+  ScrEosLink *link = calloc(1, sizeof *link);
+  if (!link) scr_eos_oom();
+  link->rc = 1;
+  link->st = st;
+  link->slot = slot;
+  st->rc++;
+  ScrBox *box = scr_box_new_obj(&scr_eos_link_retain, &scr_eos_link_release, NULL);
+  scr_box_set_ref(box, link);
+  return box;
+}
+
+/* An emitter listener: caps[0] its boxer (the compiled adapter calls it),
+ * caps[1] its link. */
+static ScrClosure *scr_eos_closure(void *adapter, ScrClosure *boxer, ScrEosState *st, int slot) {
+  ScrClosure *c = scr_closure_new(adapter, 2);
+  ScrBox *bx = scr_box_new(SCR_BOX_FUNC);
+  scr_box_set_ref(bx, scr_closure_retain(boxer));
+  c->caps[0] = bx;
+  c->caps[1] = scr_eos_link_box(st, slot);
+  return c;
+}
+
+/* new AbortError(undefined, { cause: signal.reason }), thrown. */
+static void scr_eos_throw_abort(ScrDyn *signal) {
+  ScrStr *message = scr_str_new("The operation was aborted", 25);
+  ScrError *e = scr_error_new(SCR_ERR_ERROR, message);
+  scr_str_release(message);
+  scr_str_release(e->name);
+  e->name = scr_str_new("AbortError", 10);
+  /* AbortError assigns code, then name: own enumerable properties */
+  scr_error_set_code(e, "ABORT_ERR");
+  e->name_present = true;
+  e->name_enumerable = true;
+  ScrStr *k = scr_str_new("reason", 6);
+  ScrDyn *reason = scr_dyn_handle_key_get(signal, k);
+  scr_str_release(k);
+  scr_error_define_cause(e, reason ? reason : scr_dyn_undefined());
+  if (reason) scr_dyn_release(reason);
+  scr_throw_obj(e, &scr_error_retain_v, &scr_error_release_v, scr_error_trace_arg());
+}
+
+/* removeEventListener('abort', listener) on the signal, when the listener
+ * is still registered. */
+static void scr_eos_remove_abort(ScrEosState *st) {
+  if (st->listener == NULL) return;
+  bool aborted;
+  ScrEventTargetCore *core = scr_et_signal_core_fn ? scr_et_signal_core_fn(st->signal, &aborted) : NULL;
+  if (!core) return;
+  ScrStr *abort = scr_str_new("abort", 5);
+  ScrDyn *type = scr_dyn_new_str(abort);
+  scr_str_release(abort);
+  ScrDyn *listener = scr_dyn_retain(st->listener);
+  ScrDyn *remove_args[2] = {type, listener};
+  ScrDyn *r = scr_et_remove_listener(core, remove_args, 2);
+  if (r) scr_dyn_release(r);
+  scr_dyn_release(type);
+  scr_dyn_release(listener);
+}
+
+/* emitter.removeListener(name, cb) for a listener closure still alive. */
+static bool scr_eos_off(ScrEmitter *em, ScrStr *name, ScrClosure *cb) {
+  if (cb == NULL) return true;
+  scr_emitter_release(scr_emitter_off(em, name, cb));
+  return !scr_exc_pending();
+}
+
+/* The compiled adapter's tail: `cb` is the firing emitter listener, `args`
+ * the boxed event arguments (moves in). */
+void scr_events_once_signal_fire(ScrClosure *cb, ScrArr *args) {
+  ScrEosLink *link = scr_box_get_ref(cb->caps[1]);
+  ScrEosState *st = link->st;
+  if (!st->settled) {
+    st->settled = true;
+    bool error = link->slot == SCR_EOS_ERROR;
+    /* Node's errorListener removes the event's listener and resolver the
+     * error's, each through removeListener; then the abort listener. */
+    bool ok;
+    if (error) {
+      ok = scr_eos_off(st->em, st->name, st->event_cb);
+    } else {
+      ScrStr *error_name = scr_str_new("error", 5);
+      ok = scr_eos_off(st->em, error_name, st->error_cb);
+      scr_str_release(error_name);
+    }
+    if (ok) {
+      scr_eos_remove_abort(st);
+      if (error) {
+        ScrDyn *reason = (ScrDyn *)scr_arr_get_ref(args, 0);
+        scr_dyn_throw(reason); /* moves reason */
+        scr_promise_reject_pending(st->promise);
+      } else {
+        scr_promise_fulfill_ref(st->promise, scr_arr_retain(args), scr_arr_retain_v,
+                                scr_arr_release_v, args->cyc ? scr_arr_trace_v : NULL);
+      }
+    }
+  }
+  scr_arr_release(args);
+  scr_eos_link_release(link);
+}
+
+/* The signal's 'abort' listener: caps[0] its link, caps[1] the emitter. */
+static ScrDyn *scr_eos_abort_thunk(ScrClosure *clo, ScrDyn *const *args, size_t argc) {
+  (void)args;
+  (void)argc;
+  ScrEosLink *link = scr_box_get_ref(clo->caps[0]);
+  ScrEmitter *em = scr_box_get_ref(clo->caps[1]);
+  ScrEosState *st = link->st;
+  bool ok = true;
+  if (!st->settled) {
+    st->settled = true;
+    ok = scr_eos_off(em, st->name, st->event_cb);
+    if (ok) {
+      ScrStr *error_name = scr_str_new("error", 5);
+      ok = scr_eos_off(em, error_name, st->error_cb);
+      scr_str_release(error_name);
+    }
+    if (ok) {
+      scr_eos_throw_abort(st->signal);
+      scr_promise_reject_pending(st->promise);
+    }
+  }
+  scr_emitter_release(em);
+  scr_eos_link_release(link);
+  return ok ? scr_dyn_retain(scr_dyn_undefined()) : NULL;
+}
+
+static ScrBox *scr_eos_promise_box(ScrPromise *p) {
+  ScrBox *box = scr_box_new_obj(&scr_promise_retain_v, &scr_promise_release_v, &scr_promise_trace_v);
+  scr_box_set_ref(box, scr_promise_retain(p));
+  return box;
+}
+
+static void scr_eos_adopt_job(ScrClosure *job) {
+  ScrPromise *outer = scr_box_get_ref(job->caps[0]);
+  ScrPromise *inner = scr_box_get_ref(job->caps[1]);
+  scr_promise_race_join(outer, inner, &scr_promise_adapt_copy);
+  scr_promise_release(inner);
+  scr_promise_release(outer);
+}
+
+/* Node's once is an async function returning the executor's promise: its
+ * result adopts that promise through a thenable job queued now, whose
+ * reaction settles the result one turn after the inner promise settles.
+ * Moves `inner` in; the result is +1. */
+static ScrPromise *scr_eos_adopt(ScrPromise *inner) {
+  ScrPromise *outer = scr_promise_new();
+  ScrClosure *job = scr_closure_new((void *)&scr_eos_adopt_job, 2);
+  job->caps[0] = scr_eos_promise_box(outer);
+  job->caps[1] = scr_eos_promise_box(inner);
+  scr_promise_release(inner);
+  scr_queue_microtask(job);
+  return outer;
+}
+
+/* boxer and err_boxer are borrowed (err_boxer is NULL when the awaited
+ * event is 'error'); signal is borrowed. The result is +1 and never throws:
+ * every failure rejects it, as Node's async function does. */
+ScrPromise *scr_events_once_signal(ScrEmitter *em, ScrStr *name, ScrClosure *boxer, void *adapter,
+                                   ScrEeInvoke inv, ScrClosure *err_boxer, void *err_adapter,
+                                   ScrEeInvoke err_inv, ScrDyn *signal) {
+  ScrPromise *result = scr_promise_new();
+  bool with_signal = signal->kind != SCR_DYN_UNDEF;
+  if (with_signal) {
+    bool aborted = false;
+    ScrEventTargetCore *core =
+        scr_et_signal_core_fn ? scr_et_signal_core_fn(signal, &aborted) : NULL;
+    if (!core) {
+      scr_dyn_prop_type_fail("options.signal", "an instance of AbortSignal", signal);
+      scr_promise_reject_pending(result);
+      return result;
+    }
+    if (aborted) {
+      scr_eos_throw_abort(signal);
+      scr_promise_reject_pending(result);
+      return result;
+    }
+  }
+  ScrEosState *st = calloc(1, sizeof *st);
+  if (!st) scr_eos_oom();
+  st->rc = 1;
+  st->promise = result;
+  st->em = em;
+  st->name = scr_str_retain(name);
+  st->signal = scr_dyn_retain(signal);
+  ScrClosure *event_cb = scr_eos_closure(adapter, boxer, st, SCR_EOS_EVENT);
+  ScrClosure *error_cb =
+      err_boxer != NULL ? scr_eos_closure(err_adapter, err_boxer, st, SCR_EOS_ERROR) : NULL;
+  st->event_cb = event_cb;
+  st->error_cb = error_cb;
+  /* Node registers inside the promise's executor: a throwing 'newListener'
+   * listener rejects the promise, and the listener it announced is never
+   * added (the event's listener stays when only the 'error' announcement
+   * throws). No abort listener follows a throw. */
+  ScrCaught *thrown = NULL;
+  scr_emitter_release(scr_emitter_on(em, name, event_cb, inv, true, false));
+  if (scr_exc_pending()) {
+    thrown = scr_exc_take();
+    scr_emitter_unadd_quiet(em, name, event_cb);
+    if (error_cb != NULL) scr_closure_release(error_cb); /* never registered */
+  } else if (error_cb != NULL) {
+    ScrStr *error = scr_str_new("error", 5);
+    scr_emitter_release(scr_emitter_on(em, error, error_cb, err_inv, true, false));
+    if (scr_exc_pending()) {
+      thrown = scr_exc_take();
+      scr_emitter_unadd_quiet(em, error, error_cb);
+    }
+    scr_str_release(error);
+  }
+  if (thrown != NULL) {
+    st->settled = true;
+    scr_rethrow(thrown);
+    scr_caught_release(thrown);
+    scr_promise_reject_pending(st->promise);
+  } else if (with_signal) {
+    ScrClosure *clo = scr_closure_new((void *)&scr_eos_abort_thunk, 2);
+    clo->caps[0] = scr_eos_link_box(st, SCR_EOS_ABORT);
+    clo->caps[1] = scr_box_new_obj(&scr_emitter_retain_v, &scr_emitter_release_v, NULL);
+    scr_box_set_ref(clo->caps[1], scr_emitter_retain(em));
+    ScrDyn *listener = scr_dyn_new_func(clo, &scr_eos_abort_thunk, 0, "()", "abortListener");
+    st->listener = listener;
+    ScrDyn *dispose = scr_events_add_abort_listener(signal, listener);
+    if (dispose) scr_dyn_release(dispose);
+    /* The signal's listener entry keeps it; the state's pointer is weak. */
+    scr_dyn_release(listener);
+  }
+  ScrPromise *inner = scr_promise_retain(st->promise);
+  scr_eos_state_release(st);
+  return scr_eos_adopt(inner);
+}
diff --git a/tests/corpus/6490-events-once-signal.ts b/tests/corpus/6490-events-once-signal.ts
new file mode 100644
index 0000000000..8535e1fecb
--- /dev/null
+++ b/tests/corpus/6490-events-once-signal.ts
@@ -0,0 +1,120 @@
+// events.once(emitter, name, { signal }) follows Node's lib/events.js: an
+// abort removes the event's and the 'error' listener and rejects with an
+// AbortError whose cause is signal.reason, an aborted signal rejects
+// without registering anything, and a settled once removes its abort
+// listener. The result settles on Node's microtask turn: once is an async
+// function returning the executor's promise.
+import { EventEmitter, once } from "node:events";
+
+async function main(): Promise<void> {
+  const ee = new EventEmitter();
+  const ac = new AbortController();
+  setTimeout(() => ee.emit("ready", 1, "two"), 1);
+  const args = await once(ee, "ready", { signal: ac.signal });
+  console.log("fulfilled", JSON.stringify(args), ee.listenerCount("ready"), ee.listenerCount("error"));
+
+  const ac2 = new AbortController();
+  const pending = once(ee, "ready", { signal: ac2.signal });
+  console.log("before abort", ee.listenerCount("ready"), ee.listenerCount("error"));
+  ac2.abort();
+  console.log("after abort", ee.listenerCount("ready"), ee.listenerCount("error"));
+  try {
+    await pending;
+  } catch (err) {
+    const e = err as NodeJS.ErrnoException;
+    console.log("rejected", e.name, e.message, e.code, (e.cause as Error).name);
+  }
+
+  const ac3 = new AbortController();
+  ac3.abort(new Error("already"));
+  try {
+    await once(ee, "ready", { signal: ac3.signal });
+  } catch (err) {
+    const e = err as Error;
+    console.log("pre-aborted", e.name, (e.cause as Error).message, ee.listenerCount("ready"));
+  }
+
+  const ac4 = new AbortController();
+  setTimeout(() => ee.emit("error", new Error("boom")), 1);
+  try {
+    await once(ee, "ready", { signal: ac4.signal });
+  } catch (err) {
+    console.log("error event", (err as Error).message, ee.listenerCount("ready"));
+  }
+  ac4.abort();
+  console.log("late abort changes nothing");
+
+  const errs = once(ee, "error", { signal: ac.signal });
+  ee.emit("error", new Error("as value"));
+  const [first] = await errs;
+  console.log("error as value", (first as Error).message);
+
+  // An undefined signal is the plain form.
+  const maybe: AbortSignal | undefined = undefined;
+  setTimeout(() => ee.emit("ready", 3, "four"), 1);
+  console.log("undefined signal", JSON.stringify(await once(ee, "ready", { signal: maybe })));
+
+  // Listeners registered before and after the once's abort listener.
+  const ac5 = new AbortController();
+  const ee5 = new EventEmitter();
+  ac5.signal.addEventListener("abort", () => {
+    console.log("first abort listener", ee5.listenerCount("z"));
+  });
+  const p5 = once(ee5, "z", { signal: ac5.signal });
+  ac5.signal.addEventListener("abort", () => {
+    console.log("second abort listener", ee5.listenerCount("z"));
+  });
+  ac5.abort("why");
+  await p5.catch((err: Error) => console.log("p5", err.name, String(err.cause)));
+
+  // The abort's removals emit 'removeListener'.
+  const ee6 = new EventEmitter();
+  ee6.on("removeListener", (name: string) => console.log("removed", name));
+  const ac6 = new AbortController();
+  const p6 = once(ee6, "w", { signal: ac6.signal });
+  ac6.abort();
+  await p6.catch(() => console.log("p6 rejected"));
+
+  // A 'newListener' listener that throws rejects the promise.
+  const ee7 = new EventEmitter();
+  ee7.on("newListener", (name: string) => {
+    if (name === "go") throw new Error("no " + name);
+  });
+  await once(ee7, "go", { signal: new AbortController().signal }).then(
+    () => console.log("fulfilled"),
+    (err: Error) => console.log("newListener rejected", err.message, ee7.listenerCount("go")),
+  );
+
+  // Settlement turns against plain promise chains.
+  const ee8 = new EventEmitter();
+  const ac8 = new AbortController();
+  void once(ee8, "x").then(() => console.log("plain"));
+  void once(ee8, "x", { signal: ac8.signal }).then(() => console.log("signal"));
+  void Promise.resolve()
+    .then(() => console.log("t1"))
+    .then(() => console.log("t2"))
+    .then(() => console.log("t3"))
+    .then(() => console.log("t4"));
+  ee8.emit("x");
+  const ac9 = new AbortController();
+  void once(ee8, "y", { signal: ac9.signal }).then(
+    () => console.log("fulfilled"),
+    () => console.log("aborted"),
+  );
+  ac9.abort();
+  const ac10 = new AbortController();
+  ac10.abort();
+  void once(ee8, "y", { signal: ac10.signal }).then(
+    () => console.log("fulfilled"),
+    () => console.log("pre-aborted turn"),
+  );
+  await new Promise((resolve) => setTimeout(resolve, 5));
+
+  // Pending onces whose signal never aborts keep their listeners.
+  const idle = new AbortController();
+  void once(ee, "never", { signal: idle.signal });
+  void once(new EventEmitter(), "never", { signal: idle.signal });
+  console.log("pending", ee.listenerCount("never"), ee.listenerCount("error"));
+}
+
+void main();
diff --git a/tests/corpus/6491-events-once-streams.ts b/tests/corpus/6491-events-once-streams.ts
new file mode 100644
index 0000000000..efe60c7372
--- /dev/null
+++ b/tests/corpus/6491-events-once-streams.ts
@@ -0,0 +1,87 @@
+// events.once over streams: file streams, Readable.from, a PassThrough
+// destroyed with an error, a Writable, and a NodeJS.ReadableStream slot
+// raced against its destination's 'close' with an AbortSignal that the
+// finally block aborts.
+import { once } from "node:events";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { PassThrough, Readable, Writable } from "node:stream";
+
+function copyPart(src: NodeJS.ReadableStream, out: PassThrough): Promise<unknown> {
+  const ac = new AbortController();
+  src.pipe(out, { end: false });
+  return Promise.race([
+    once(src, "end", { signal: ac.signal }),
+    once(src, "error", { signal: ac.signal }).then(([error]) => {
+      throw error;
+    }),
+    once(out, "close", { signal: ac.signal }).then(() => {
+      throw new Error("output closed before the part ended");
+    }),
+  ]).finally(() => {
+    ac.abort();
+    src.unpipe(out);
+    console.log("part done", out.listenerCount("close"), out.listenerCount("error"));
+  });
+}
+
+async function main(): Promise<void> {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "scriptc-once-streams-"));
+  const file = path.join(dir, "a.txt");
+  fs.writeFileSync(file, "part one\n");
+
+  const rs = fs.createReadStream(file);
+  rs.resume();
+  console.log("file end", JSON.stringify(await once(rs, "end")));
+  const ws = fs.createWriteStream(path.join(dir, "b.txt"));
+  ws.end("x");
+  await once(ws, "finish");
+  console.log("write stream finish");
+  await once(ws, "close");
+  console.log("write stream close");
+
+  const pt = new PassThrough();
+  setTimeout(() => pt.destroy(new Error("pt broke")), 1);
+  try {
+    await once(pt, "end");
+  } catch (err) {
+    console.log("passthrough error", (err as Error).message, pt.listenerCount("end"));
+  }
+  const r = Readable.from(["a", "b"]);
+  r.resume();
+  await once(r, "close");
+  console.log("readable close");
+  const w = new Writable({
+    write(_chunk, _encoding, callback) {
+      callback();
+    },
+  });
+  w.end("z");
+  await once(w, "finish");
+  console.log("writable finish");
+
+  const out = new PassThrough();
+  let text = "";
+  out.on("data", (chunk: Buffer) => {
+    text += chunk.toString();
+  });
+  await copyPart(fs.createReadStream(file), out);
+  await copyPart(fs.createReadStream(file), out);
+  console.log(JSON.stringify(text));
+  try {
+    await copyPart(fs.createReadStream(path.join(dir, "missing.txt")), out);
+  } catch (err) {
+    console.log("missing", (err as NodeJS.ErrnoException).code);
+  }
+  const closing = new PassThrough();
+  setTimeout(() => closing.destroy(), 1);
+  try {
+    await copyPart(new Readable({ read() {} }), closing);
+  } catch (err) {
+    console.log("closed", (err as Error).message);
+  }
+  fs.rmSync(dir, { recursive: true });
+}
+
+void main();
diff --git a/tests/corpus/6492-promise-race-combined.ts b/tests/corpus/6492-promise-race-combined.ts
new file mode 100644
index 0000000000..70f5399af9
--- /dev/null
+++ b/tests/corpus/6492-promise-race-combined.ts
@@ -0,0 +1,72 @@
+// Promise.race over events.once results: entries that only reject (a
+// handler that throws) fit any result, and entries of different value
+// types combine into 'unknown'.
+import { EventEmitter, once } from "node:events";
+
+function waitFor(a: EventEmitter, b: EventEmitter) {
+  let failed = false;
+  return Promise.race([
+    once(a, "done"),
+    once(a, "error").then(([error]) => {
+      failed = true;
+      throw error;
+    }),
+    once(b, "close").then(() => {
+      failed = true;
+      throw new Error("closed early");
+    }),
+  ]).finally(() => {
+    console.log("settled", failed);
+  });
+}
+
+function waitVoid(a: EventEmitter): Promise<void> {
+  return Promise.race([
+    once(a, "done").then((): void => undefined),
+    once(a, "error").then(([error]) => {
+      throw error;
+    }),
+  ]);
+}
+
+function waitMixed(a: EventEmitter): Promise<unknown> {
+  return Promise.race([once(a, "done").then((): void => undefined), once(a, "other")]);
+}
+
+async function main(): Promise<void> {
+  const a = new EventEmitter();
+  const b = new EventEmitter();
+  setTimeout(() => a.emit("done", 7), 1);
+  console.log("value", JSON.stringify(await waitFor(a, b)));
+  setTimeout(() => b.emit("close"), 1);
+  try {
+    await waitFor(a, b);
+  } catch (err) {
+    console.log("caught", (err as Error).message);
+  }
+  setTimeout(() => a.emit("error", new Error("bad")), 1);
+  try {
+    await waitFor(a, b);
+  } catch (err) {
+    console.log("caught", (err as Error).message);
+  }
+  setTimeout(() => a.emit("done", 8), 1);
+  await waitVoid(a);
+  console.log("void done");
+  setTimeout(() => a.emit("other", 1, "x"), 1);
+  console.log("mixed", JSON.stringify(await waitMixed(a)));
+  setTimeout(() => a.emit("done", 9), 1);
+  console.log("mixed undefined", await waitMixed(a));
+  // Turn order: the race settles one turn after its first entry.
+  const c = new EventEmitter();
+  void waitMixed(c).then(() => console.log("race settled"));
+  void Promise.resolve()
+    .then(() => console.log("u1"))
+    .then(() => console.log("u2"))
+    .then(() => console.log("u3"))
+    .then(() => console.log("u4"))
+    .then(() => console.log("u5"));
+  c.emit("other", 2, "y");
+}
+
+void main();
diff --git a/tests/corpus/6493-stream-function-callbacks.ts b/tests/corpus/6493-stream-function-callbacks.ts
new file mode 100644
index 0000000000..7d5ee45e1f
--- /dev/null
+++ b/tests/corpus/6493-stream-function-callbacks.ts
@@ -0,0 +1,66 @@
+// Stream subclasses that declare their completion callbacks with the broad
+// `Function` type: the runtime's callable arrives and calls through it
+// complete the chunk, pass data, or fail the stream.
+import { Transform, Writable } from "node:stream";
+
+class Prefixer extends Transform {
+  _s: string;
+  constructor() {
+    super();
+    this._s = "";
+  }
+  _transform(c: Buffer, _: string, cb: Function) {
+    const text = c.toString();
+    const lines = text.split("\n").map((line, index, all) => {
+      if (index === 0) return this._s === "" || this._s.endsWith("\n") ? "> " + line : line;
+      if (index === all.length - 1) return line !== "" ? "> " + line : line;
+      return "> " + line;
+    });
+    this._s += text;
+    this.push(lines.join("\n"));
+    cb();
+  }
+}
+
+class Upper extends Transform {
+  _transform(chunk: Buffer, _encoding: string, cb: Function) {
+    if (chunk.toString() === "bad") {
+      cb(new Error("bad chunk"));
+      return;
+    }
+    cb(null, chunk.toString().toUpperCase());
+  }
+  _flush(cb: Function) {
+    this.push("!");
+    cb();
+  }
+}
+
+class Sink extends Writable {
+  seen: string[] = [];
+  _write(chunk: Buffer, _encoding: string, cb: Function) {
+    this.seen.push(chunk.toString());
+    cb();
+  }
+  _final(cb: Function) {
+    this.seen.push("<final>");
+    cb();
+  }
+}
+
+const prefixer = new Prefixer();
+prefixer.pipe(process.stdout);
+prefixer.write("a\nb");
+prefixer.write("c\n");
+prefixer.end("d\n");
+
+const sink = new Sink();
+const upper = new Upper();
+upper.pipe(sink);
+sink.on("finish", () => console.log("sink", JSON.stringify(sink.seen)));
+upper.write("a");
+upper.end("b");
+
+const bad = new Upper();
+bad.on("error", (err: Error) => console.log("error", err.message));
+bad.write("bad");
diff --git a/tests/corpus/6494-events-once-dyn-stream-slot/main.ts b/tests/corpus/6494-events-once-dyn-stream-slot/main.ts
new file mode 100644
index 0000000000..501944ae3f
--- /dev/null
+++ b/tests/corpus/6494-events-once-dyn-stream-slot/main.ts
@@ -0,0 +1,59 @@
+// events.once over a checked-dynamic NodeJS.ReadableStream slot: the
+// program also moves a JavaScript stream object into such a slot, so the
+// slots hold native streams through their typed capsules.
+import { once } from "node:events";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { PassThrough } from "node:stream";
+import { part } from "./sources.js";
+
+function collect(src: NodeJS.ReadableStream): Promise<string> {
+  return new Promise((resolve) => {
+    let text = "";
+    src.on("data", (chunk: Buffer | string) => {
+      text += chunk.toString();
+    });
+    src.on("end", () => resolve(text));
+  });
+}
+
+function copyPart(src: NodeJS.ReadableStream, out: PassThrough) {
+  const ac = new AbortController();
+  src.pipe(out, { end: false });
+  return Promise.race([
+    once(src, "end", { signal: ac.signal }),
+    once(src, "error", { signal: ac.signal }).then(([error]) => {
+      throw error;
+    }),
+    once(out, "close", { signal: ac.signal }).then(() => {
+      throw new Error("output closed before the part ended");
+    }),
+  ]).finally(() => {
+    ac.abort();
+    src.unpipe(out);
+  });
+}
+
+async function main(): Promise<void> {
+  console.log("js part", await collect(part(["a", "b"])));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "scriptc-once-dyn-"));
+  const file = path.join(dir, "a.txt");
+  fs.writeFileSync(file, "native part\n");
+  const out = new PassThrough();
+  let text = "";
+  out.on("data", (chunk: Buffer) => {
+    text += chunk.toString();
+  });
+  await copyPart(fs.createReadStream(file), out);
+  await copyPart(fs.createReadStream(file), out);
+  console.log(JSON.stringify(text));
+  try {
+    await copyPart(fs.createReadStream(path.join(dir, "missing.txt")), out);
+  } catch (err) {
+    console.log("missing", (err as NodeJS.ErrnoException).code);
+  }
+  fs.rmSync(dir, { recursive: true });
+}
+
+void main();
diff --git a/tests/corpus/6494-events-once-dyn-stream-slot/sources.js b/tests/corpus/6494-events-once-dyn-stream-slot/sources.js
new file mode 100644
index 0000000000..e76e887859
--- /dev/null
+++ b/tests/corpus/6494-events-once-dyn-stream-slot/sources.js
@@ -0,0 +1,21 @@
+// A constructor-function stream with its own listener table.
+function Part(chunks) {
+  this.chunks = chunks;
+  this.listeners = {};
+  setImmediate(() => {
+    for (const chunk of this.chunks) this.emit("data", chunk);
+    this.emit("end");
+  });
+}
+Part.prototype.on = function (event, listener) {
+  (this.listeners[event] = this.listeners[event] || []).push(listener);
+  return this;
+};
+Part.prototype.emit = function (event, value) {
+  for (const listener of this.listeners[event] || []) listener(value);
+  return true;
+};
+
+export function part(chunks) {
+  return new Part(chunks);
+}
diff --git a/tests/diagnostics/events-once-fences.ts b/tests/diagnostics/events-once-fences.ts
index 2e5613f70e..97bc76254f 100644
--- a/tests/diagnostics/events-once-fences.ts
+++ b/tests/diagnostics/events-once-fences.ts
@@ -1,11 +1,14 @@
-// events.once lowers for EventEmitter instances and literal event names;
-// these forms stay refused.
+// events.once lowers for EventEmitter and stream instances, literal event
+// names and a literal { signal } options object; these forms stay refused.
 import { EventEmitter, once } from "node:events";
+import { PassThrough } from "node:stream";
 
 const ee = new EventEmitter();
 const name: string = process.argv[2] ?? "ready";
+const options = {};
 async function main(): Promise<void> {
-  await once(ee, "ready", { signal: AbortSignal.timeout(5) }); // options
+  await once(ee, "ready", options); // options that are not an object literal
   await once(ee, name); // computed event name
+  await once(new PassThrough(), "data"); // a stream's 'data' event
 }
 void main();
diff --git a/tests/fixtures/node-types/events-once-signal-race.ts b/tests/fixtures/node-types/events-once-signal-race.ts
new file mode 100644
index 0000000000..4bc1d2d36b
--- /dev/null
+++ b/tests/fixtures/node-types/events-once-signal-race.ts
@@ -0,0 +1,86 @@
+// events.once under @types/node, which types the result Promise<any[]>:
+// a NodeJS.ReadableStream slot and a PassThrough raced with an AbortSignal
+// that the finally block aborts (the entries that throw are
+// Promise<never>, so the race result is the any[] of the 'end' entry), an
+// EventEmitter race, and a Transform whose completion callback is declared
+// with the broad `Function` type.
+import { EventEmitter, once } from "node:events";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { PassThrough, Transform } from "node:stream";
+
+function copyPart(src: NodeJS.ReadableStream, out: PassThrough) {
+  const ac = new AbortController();
+  let failed = false;
+  src.pipe(out, { end: false });
+  return Promise.race([
+    once(src, "end", { signal: ac.signal }),
+    once(src, "error", { signal: ac.signal }).then(([error]) => {
+      failed = true;
+      throw error;
+    }),
+    once(out, "error", { signal: ac.signal }).then(([error]) => {
+      failed = true;
+      throw error;
+    }),
+    once(out, "close", { signal: ac.signal }).then(() => {
+      failed = true;
+      throw new Error("output closed before the part ended");
+    }),
+  ]).finally(() => {
+    ac.abort();
+    src.unpipe(out);
+    console.log("part done", failed);
+  });
+}
+
+function waitFor(a: EventEmitter) {
+  const ac = new AbortController();
+  return Promise.race([
+    once(a, "done", { signal: ac.signal }),
+    once(a, "error", { signal: ac.signal }).then(([error]) => {
+      throw error;
+    }),
+  ]).finally(() => ac.abort());
+}
+
+class Prefixer extends Transform {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  _transform(chunk: Buffer, _encoding: string, cb: Function) {
+    cb(null, "> " + chunk.toString());
+  }
+}
+
+async function main(): Promise<void> {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "scriptc-once-race-"));
+  const file = path.join(dir, "a.txt");
+  fs.writeFileSync(file, "part\n");
+  const out = new PassThrough();
+  let text = "";
+  out.on("data", (chunk: Buffer) => {
+    text += chunk.toString();
+  });
+  const ended = await copyPart(fs.createReadStream(file), out);
+  console.log("ended", ended.length);
+  await copyPart(fs.createReadStream(file).pipe(new Prefixer()), out);
+  console.log(JSON.stringify(text));
+  try {
+    await copyPart(fs.createReadStream(path.join(dir, "missing.txt")), out);
+  } catch (err) {
+    console.log("missing", (err as NodeJS.ErrnoException).code);
+  }
+  const a = new EventEmitter();
+  setTimeout(() => a.emit("done", 1, "two"), 1);
+  const args = (await waitFor(a)) as unknown[];
+  console.log("done", JSON.stringify(args), a.listenerCount("done"), a.listenerCount("error"));
+  setTimeout(() => a.emit("error", new Error("bad")), 1);
+  try {
+    await waitFor(a);
+  } catch (err) {
+    console.log("caught", (err as Error).message, a.listenerCount("done"));
+  }
+  fs.rmSync(dir, { recursive: true });
+}
+
+void main();
diff --git a/tests/harness/__snapshots__/events-once-fences.ts.txt b/tests/harness/__snapshots__/events-once-fences.ts.txt
index ffab538b01..60c499cfe1 100644
--- a/tests/harness/__snapshots__/events-once-fences.ts.txt
+++ b/tests/harness/__snapshots__/events-once-fences.ts.txt
@@ -1,17 +1,26 @@
-events-once-fences.ts:8:27 - error SC2020: 'events.once with options' is part of the standard library types but has no scriptc lowering yet
+events-once-fences.ts:10:27 - error SC2020: 'events.once options that are not an object literal' is part of the standard library types but has no scriptc lowering yet
 
-  7 | async function main(): Promise<void> {
-  8 |   await once(ee, "ready", { signal: AbortSignal.timeout(5) }); // options
-    |                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  9 |   await once(ee, name); // computed event name
+   9 | async function main(): Promise<void> {
+  10 |   await once(ee, "ready", options); // options that are not an object literal
+     |                           ^~~~~~~
+  11 |   await once(ee, name); // computed event name
 
-  hint: the lowered form is events.once(emitter, name); AbortSignal options are not supported yet
+  hint: pass the options as an object literal: { signal }
 
-events-once-fences.ts:9:18 - error SC2020: 'events.once with a computed or meta event name' is part of the standard library types but has no scriptc lowering yet
+events-once-fences.ts:11:18 - error SC2020: 'events.once with a computed or meta event name' is part of the standard library types but has no scriptc lowering yet
 
-   8 |   await once(ee, "ready", { signal: AbortSignal.timeout(5) }); // options
-   9 |   await once(ee, name); // computed event name
+  10 |   await once(ee, "ready", options); // options that are not an object literal
+  11 |   await once(ee, name); // computed event name
      |                  ^~~~
-  10 | }
+  12 |   await once(new PassThrough(), "data"); // a stream's 'data' event
 
-  hint: name the awaited event with a string literal
\ No newline at end of file
+  hint: name the awaited event with a string literal
+
+events-once-fences.ts:12:33 - error SC2020: 'events.once of a stream's 'data' event' is part of the standard library types but has no scriptc lowering yet
+
+  11 |   await once(ee, name); // computed event name
+  12 |   await once(new PassThrough(), "data"); // a stream's 'data' event
+     |                                 ^~~~~~
+  13 | }
+
+  hint: the chunk has no checked-dynamic boxing here; register stream.once('data', listener) instead
\ No newline at end of file
diff --git a/tests/harness/project-config.test.ts b/tests/harness/project-config.test.ts
index 1e19053689..b7c30a9104 100644
--- a/tests/harness/project-config.test.ts
+++ b/tests/harness/project-config.test.ts
@@ -205,6 +205,24 @@ test("node-types: events.once over typed EventEmitter listeners under @types/nod
   expect(comparableStderr(native.stderr)).toBe(node.stderr);
 });
 
+test("node-types: events.once with a signal over streams, raced, under @types/node", async () => {
+  const outDir = outDirFor("events-once-signal-race");
+  const entry = join(nodeTypesDir, "events-once-signal-race.ts");
+  const result = await compile(entry, {
+    outPath: join(outDir, "events-once-signal-race"),
+    outDir,
+    sanitize,
+  });
+  expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true);
+  if (!result.ok) return;
+  const [native, node] = await Promise.all([
+    execFileAsync(result.binaryPath),
+    execFileAsync(process.execPath, ["--disable-warning=MODULE_TYPELESS_PACKAGE_JSON", entry]),
+  ]);
+  expect(native.stdout).toBe(node.stdout);
+  expect(comparableStderr(native.stderr)).toBe(node.stderr);
+});
+
 test("node-types: socket.address and resetAndDestroy under @types/node", async () => {
   const outDir = outDirFor("net-reset-address");
   const entry = join(nodeTypesDir, "net-reset-address.ts");