diff --git a/packages/compiler/src/backend/executable-features.ts b/packages/compiler/src/backend/executable-features.ts
index a565965f1c..7329257ebd 100644
--- a/packages/compiler/src/backend/executable-features.ts
+++ b/packages/compiler/src/backend/executable-features.ts
@@ -16,6 +16,8 @@ export function executableLinkFeatures(mod: IrModule): NativeLinkFeatures {
     fileHandle: features.fileHandle,
     fetch: features.fetch,
     ...(features.eventTarget ? { eventTarget: true } : {}),
+    ...(features.warningReplace ? { warningReplace: true } : {}),
+    ...(features.stdioExtended ? { stdioExtended: true } : {}),
     zlib: features.zlib,
     assert: features.assert,
     inspect: features.inspect,
diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts
index 9e2d3524ea..7f1fdf2dfa 100644
--- a/packages/compiler/src/backend/llvm/emitter.ts
+++ b/packages/compiler/src/backend/llvm/emitter.ts
@@ -5881,6 +5881,8 @@ export class LlEmitter {
       // Process streams use a numeric descriptor internally, including zero
       // for stdin. They remain JavaScript objects in boolean contexts.
       case "procStream":
+      // A module namespace object is always present.
+      case "moduleNs":
         return "true";
       case "array":
       case "record":
diff --git a/packages/compiler/src/backend/llvm/lib-process.ts b/packages/compiler/src/backend/llvm/lib-process.ts
index e6d8acdbed..eaf7f31cde 100644
--- a/packages/compiler/src/backend/llvm/lib-process.ts
+++ b/packages/compiler/src/backend/llvm/lib-process.ts
@@ -546,15 +546,24 @@ export function emitProcessLibCall(host: LlvmEmitterContext, e: LibCallExpr): Ll
       B.line(`call void @scr_stdin_on_end(ptr ${cb.name}, i1 ${once.name})`);
       return { name: "", type: e.type };
     }
+    // A string listener takes the setEncoding-decoded chunk.
+    const stringData = e.fn === "stdin.onData" && cbT.params[0]?.kind === "string";
     const adapter =
       e.fn === "stdin.onData"
         ? cbT.params.length === 0
           ? "scr_stdin_data_thunk0"
-          : "scr_stdin_data_thunk_bytes"
+          : stringData
+            ? "scr_stdin_data_thunk_str"
+            : "scr_stdin_data_thunk_bytes"
         : cbT.params.length === 0
           ? "scr_child_err_thunk0"
           : "scr_child_err_thunk_error";
-    const sym = e.fn === "stdin.onData" ? "scr_stdin_on_data" : "scr_stdin_on_error";
+    const sym =
+      e.fn === "stdin.onData"
+        ? stringData
+          ? "scr_stdin_on_data_str"
+          : "scr_stdin_on_data"
+        : "scr_stdin_on_error";
     host.declare(`declare void @${adapter}(ptr, ptr)`);
     host.declare(`declare void @${sym}(ptr, ptr, i1 zeroext)`);
     B.line(`call void @${sym}(ptr ${cb.name}, ptr @${adapter}, i1 ${once.name})`);
diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts
index 73b6d72e79..1bd8cae056 100644
--- a/packages/compiler/src/backend/llvm/lib-shared.ts
+++ b/packages/compiler/src/backend/llvm/lib-shared.ts
@@ -1336,6 +1336,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
   "process.emitWarningText": "scr_process_emit_warning_text",
   "process.deprecationFlag": "scr_process_deprecation_flag",
   "process.setDeprecationFlag": "scr_process_set_deprecation_flag",
+  "process.setEmitWarning": "scr_process_set_emit_warning",
   "process.onUncaughtException": "scr_process_on_uncaught_exception",
   "process.offUncaughtException": "scr_process_off_uncaught_exception",
   "process.onUnhandledRejection": "scr_process_on_unhandled_rejection",
diff --git a/packages/compiler/src/backend/native-link-info-core.ts b/packages/compiler/src/backend/native-link-info-core.ts
index 3beb84a20a..327ae84084 100644
--- a/packages/compiler/src/backend/native-link-info-core.ts
+++ b/packages/compiler/src/backend/native-link-info-core.ts
@@ -25,6 +25,12 @@ export interface NativeLinkFeatures {
   fileHandle: boolean;
   fetch: boolean;
   eventTarget?: boolean;
+  /** The program assigns process.emitWarning: links the
+   * SCR_WARNING_REPLACE variant of the dyn-async unit. */
+  warningReplace?: boolean;
+  /** The program uses process.stdin.setEncoding, string 'data' listeners
+   * or stdio 'resize' events: links the SCR_STDIO_EXTENDED events unit. */
+  stdioExtended?: boolean;
   zlib: boolean;
   assert: boolean;
   inspect: boolean;
diff --git a/packages/compiler/src/backend/native/contracts.ts b/packages/compiler/src/backend/native/contracts.ts
index 875a723bc4..0ead1e1823 100644
--- a/packages/compiler/src/backend/native/contracts.ts
+++ b/packages/compiler/src/backend/native/contracts.ts
@@ -114,6 +114,10 @@ export interface CcOptions {
    * native fetch AbortSignal built on the same engine: compiles
    * scr_event_target.c. */
   eventTarget?: boolean;
+  /** SCR_WARNING_REPLACE: process.emitWarning replacement support. */
+  warningReplace?: boolean;
+  /** SCR_STDIO_EXTENDED: stdin encoding, string data listeners, resize. */
+  stdioExtended?: boolean;
   /** The program uses the process-events surface (signal/exit listeners,
    * stdin events, for-await over stdin — moduleUsesProcessEvents on the
    * IR): compiles scr_events.c into the binary. Event-free binaries keep
diff --git a/packages/compiler/src/backend/native/executable.ts b/packages/compiler/src/backend/native/executable.ts
index 6c8673fe43..5b7a0354a7 100644
--- a/packages/compiler/src/backend/native/executable.ts
+++ b/packages/compiler/src/backend/native/executable.ts
@@ -445,6 +445,8 @@ export async function compileCInternal(
       : [optimization === "dev" ? "-O0" : "-O2"]),
     ...executableSectionFlags.compile,
     ...(opts.textDecoderLegacy ? ["-DSCR_TEXT_DECODER_LEGACY"] : []),
+    ...(opts.warningReplace ? ["-DSCR_WARNING_REPLACE"] : []),
+    ...(opts.stdioExtended ? ["-DSCR_STDIO_EXTENDED"] : []),
     ...(opts.youngNursery ? ["-DSCR_YIN"] : []),
     "-fno-math-errno",
     // The runtime object model uses type-punned C: a hierarchy
@@ -644,6 +646,8 @@ export async function compileCInternal(
       : [optimization === "dev" ? "-O0" : "-O2"]),
     ...executableSectionFlags.compile,
     ...(opts.textDecoderLegacy ? ["-DSCR_TEXT_DECODER_LEGACY"] : []),
+    ...(opts.warningReplace ? ["-DSCR_WARNING_REPLACE"] : []),
+    ...(opts.stdioExtended ? ["-DSCR_STDIO_EXTENDED"] : []),
     ...(opts.youngNursery ? ["-DSCR_YIN"] : []),
     "-fno-math-errno",
     "-fno-strict-aliasing", // the emitted object model type-puns — see buildArgs
diff --git a/packages/compiler/src/backend/runtime-pack-core.ts b/packages/compiler/src/backend/runtime-pack-core.ts
index 16fbc2a367..3fc2a1bbbc 100644
--- a/packages/compiler/src/backend/runtime-pack-core.ts
+++ b/packages/compiler/src/backend/runtime-pack-core.ts
@@ -82,6 +82,8 @@ export interface RuntimeFeatureSet extends NativeLinkFeatures {
   workers: boolean;
   youngNursery: boolean;
   eventTarget: boolean;
+  warningReplace: boolean;
+  stdioExtended: boolean;
   nativeFetch: boolean;
   netEffective: boolean;
   httpEffective: boolean;
@@ -269,6 +271,8 @@ export function effectiveRuntimeFeatures(
     workers: features.workers === true,
     youngNursery: features.youngNursery === true,
     eventTarget: features.eventTarget === true,
+    warningReplace: features.warningReplace === true,
+    stdioExtended: features.stdioExtended === true,
     nativeFetch,
     netEffective,
     httpEffective,
diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts
index ee9d84fcf2..62a79660f7 100644
--- a/packages/compiler/src/executable/executable-cache.ts
+++ b/packages/compiler/src/executable/executable-cache.ts
@@ -56,6 +56,8 @@ export interface EarlyExecutableNativeFeatures {
   fileHandle: boolean;
   fetch: boolean;
   eventTarget?: boolean;
+  warningReplace?: boolean;
+  stdioExtended?: boolean;
   zlib: boolean;
   assert: boolean;
   inspect: boolean;
diff --git a/packages/compiler/src/frontend/lowering/builtins/process.ts b/packages/compiler/src/frontend/lowering/builtins/process.ts
index e4e5004c19..555eaf84f0 100644
--- a/packages/compiler/src/frontend/lowering/builtins/process.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/process.ts
@@ -26,6 +26,7 @@ import {
   funcOf,
 } from "../../../ir/ir.js";
 import { lowerBuiltinLoaderValue } from "../lower-builtin-values.js";
+import { canonicalBuiltinModule } from "../../builtin-modules.js";
 import { lowerProcessIpcSend, ipcMessageListener, ipcDisconnectListener } from "./ipc.js";
 import { lowerDiagnosticsSubscriber, lowerTracingArguments } from "./async-context.js";
 
@@ -148,6 +149,18 @@ export function lowerProcessStreamProperty(
         loc: locOf(expr),
       };
   }
+  // `if (process.stdin.setRawMode)`: Node's stdin has the method only
+  // when it is a TTY. The runtime's stream object answers the same
+  // presence (the method or undefined); calls keep their direct lowering.
+  if (direct === "stdin" && member === "setRawMode") {
+    return {
+      kind: "dynKeyGet",
+      value: lowerer.lowerExpr(expr.expression),
+      key: strLit(member, locOf(expr.name)),
+      type: DYN,
+      loc: locOf(expr),
+    };
+  }
   if (member !== "isTTY" && member !== "columns" && member !== "rows") return null;
   let recv: ts.Expression = expr.expression;
   while (ts.isParenthesizedExpression(recv) || ts.isAsExpression(recv) || ts.isTypeAssertion(recv))
@@ -364,6 +377,11 @@ export function lowerProcessProperty(
   if (member === "versions") {
     return { kind: "libCall", fn: "process.versions", args: [], type: DYN, loc };
   }
+  // process.features as a value (`"sea" in process.features`): an object
+  // holding none of the flags, consistent with the member reads above.
+  if (member === "features") {
+    return { kind: "dynObjLit", type: DYN, loc };
+  }
   // process.noDeprecation / process.throwDeprecation: the values the
   // program assigned (undefined before that — no Node flags reach a
   // compiled binary).
@@ -627,6 +645,73 @@ export function lowerProcessMethodCall(
     }
     return { kind: "libCall", fn: "process.stdinSetRawMode", args: [mode], type: VOID, loc };
   }
+  // process.stdout.on("resize", cb) (and once/off/removeListener/
+  // addListener, stderr too): the terminal resize event, registered on the
+  // runtime's process stream object (a SIGWINCH listener that emits when a
+  // TTY's size changed; it never keeps the loop alive). Statement position:
+  // Node returns the stream.
+  if (
+    ["on", "once", "off", "removeListener", "addListener"].includes(access.name.text) &&
+    ts.isPropertyAccessExpression(access.expression) &&
+    call.arguments.nodes.length === 2 &&
+    !call.arguments.nodes.some(ts.isSpreadElement) &&
+    ts.isExpressionStatement(call.parent)
+  ) {
+    const stream = lowerer.stdlibGlobalMember(access.expression, "process");
+    const evT = lowerer.typeOf(call.arguments.nodes[0]!);
+    if (
+      (stream === "stdout" || stream === "stderr") &&
+      evT.isStringLiteralType() &&
+      evT.value === "resize"
+    ) {
+      const loc = locOf(call);
+      const receiverLocal = lowerer.declareHiddenLocal("%stdioReceiver", DYN);
+      const receiver = varRef(receiverLocal.id, DYN, loc);
+      const method =
+        access.name.text === "off"
+          ? "removeListener"
+          : access.name.text === "addListener"
+            ? "on"
+            : access.name.text;
+      return {
+        kind: "seqExpr",
+        stmts: [
+          {
+            kind: "varDecl",
+            localId: receiverLocal.id,
+            init: {
+              kind: "libCall",
+              fn: "process.stdio",
+              args: [numLit(stream === "stdout" ? 1 : 2, loc)],
+              type: DYN,
+              loc,
+            },
+            loc,
+          },
+        ],
+        result: {
+          kind: "dynCall",
+          callee: {
+            kind: "dynKeyGet",
+            value: receiver,
+            key: strLit(method, locOf(access.name)),
+            type: DYN,
+            loc,
+          },
+          receiver,
+          calleeName: access.getText(),
+          args: [
+            lowerer.lowerExprExpecting(call.arguments.nodes[0]!, DYN),
+            lowerer.lowerExprExpecting(call.arguments.nodes[1]!, DYN),
+          ],
+          type: DYN,
+          loc,
+        },
+        type: DYN,
+        loc,
+      };
+    }
+  }
   // process.stdin.on/once("data" | "end" | "error", cb): the piped-stdin
   // event slice. A 'data' listener keeps the event loop alive until EOF
   // (Node's flowing stdin); 'end'/'error' listeners alone do not. `once`
@@ -678,11 +763,18 @@ export function lowerProcessMethodCall(
     const param = cb.type.params[0];
     const onceArg: IrExpr = { kind: "boolLit", value: once, type: BOOL, loc };
     if (event === "data") {
-      if (param !== undefined && !(param.kind === "bytes" && param.elem === "u8")) {
+      // A string parameter receives the chunks process.stdin.setEncoding
+      // decodes (pi-tui's terminal input); the runtime refuses a delivery
+      // while no encoding is set, where Node would pass a Buffer.
+      if (
+        param !== undefined &&
+        !(param.kind === "bytes" && param.elem === "u8") &&
+        param.kind !== "string"
+      ) {
         lowerer.unsupported(
           "SC1090",
           call.arguments.nodes[1]!,
-          `data listeners whose parameter is not 'Uint8Array' (got '${lowerer.fmt(param)}')`,
+          `data listeners whose parameter is not 'Uint8Array' or 'string' (got '${lowerer.fmt(param)}')`,
         );
       }
       return { kind: "libCall", fn: "stdin.onData", args: [cb, onceArg], type: VOID, loc };
@@ -1537,3 +1629,36 @@ function processCredentialCall(member: string, loc: SrcLoc): IrExpr {
     loc,
   };
 }
+
+/** `process.getBuiltinModule("node:os")`: a string-literal id naming a
+ * supported builtin whose call the checker types as that module's
+ * namespace (@types/node's BuiltInModule map) answers the namespace value
+ * `import * as ns` binds, so its members key the builtin tables at their
+ * use sites. The receiver may be cast (`(process as P)`) and the call
+ * optional: Node 24's process always has the member, and the cast changes
+ * no runtime value. Other ids keep the dynamic loader (undefined for
+ * unknown ids, Node's argument errors). */
+export function lowerProcessBuiltinModuleNamespace(
+  lowerer: Lowerer,
+  call: ts.CallExpression,
+): IrExpr | null {
+  const callee = call.expression;
+  if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "getBuiltinModule")
+    return null;
+  const id = call.arguments.nodes[0];
+  if (call.arguments.nodes.length !== 1 || !id || !ts.isStringLiteralLike(id)) return null;
+  let receiver: ts.Expression = callee.expression;
+  while (
+    ts.isParenthesizedExpression(receiver) ||
+    ts.isAsExpression(receiver) ||
+    ts.isSatisfiesExpression(receiver) ||
+    ts.isNonNullExpression(receiver)
+  )
+    receiver = receiver.expression;
+  if (!lowerer.isStdlibGlobal(receiver, "process")) return null;
+  const module = canonicalBuiltinModule(id.text);
+  if (module === null) return null;
+  const type = lowerer.mapTypeOf(lowerer.checker.getNonNullableType(lowerer.typeOf(call)));
+  if (type?.kind !== "moduleNs" || type.moduleId !== `builtin:${module}`) return null;
+  return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc: locOf(call) };
+}
diff --git a/packages/compiler/src/frontend/lowering/function-returns.ts b/packages/compiler/src/frontend/lowering/function-returns.ts
index f413f46806..c0e70013c8 100644
--- a/packages/compiler/src/frontend/lowering/function-returns.ts
+++ b/packages/compiler/src/frontend/lowering/function-returns.ts
@@ -1,3 +1,4 @@
+import { mapAsyncGeneratorAnnotation } from "../type-mapper.js";
 import { dynUndefinedExpr } from "../../ir/build.js";
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
@@ -146,6 +147,12 @@ export function declaredReturnType(
   // (`.action(() => { throw ... })`). `never` VALUES stay unmapped.
   if (retTsType.flags & ts.TypeFlags.Never) return VOID;
   let mappedReturn = lowerer.mapTypeOf(retTsType);
+  if (
+    mappedReturn === null &&
+    decl.asteriskToken &&
+    decl.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword)
+  )
+    mappedReturn = mapAsyncGeneratorAnnotation(retTsType, lowerer.typeCtx);
   if (
     isJsSourceFile(decl.getSourceFile()) &&
     decl.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) &&
diff --git a/packages/compiler/src/frontend/lowering/lower-async-iteration.ts b/packages/compiler/src/frontend/lowering/lower-async-iteration.ts
index c20f32480b..f095c5b9c5 100644
--- a/packages/compiler/src/frontend/lowering/lower-async-iteration.ts
+++ b/packages/compiler/src/frontend/lowering/lower-async-iteration.ts
@@ -20,7 +20,7 @@ import {
   VOID,
 } from "../../ir/ir.js";
 import { locOf } from "../program.js";
-import { extractIteratorValue } from "./lower-generators.js";
+import { extractIteratorValue, type GenType } from "./lower-generators.js";
 import { streamSidesOf } from "./lower-stream.js";
 import { staticReadableStreamElementType } from "./lower-stdlib.js";
 import { genResultRecord } from "../type-mapper.js";
@@ -282,6 +282,43 @@ function classAsyncIteratorPlan(
   };
 }
 
+/** `for await (const x of obj)` where obj's class declares (or inherits)
+ * `async *[Symbol.asyncIterator]()`: the loop opens the iterator with that
+ * method call, evaluated once, and then drives the async generator it
+ * returns exactly like `for await (const x of obj[Symbol.asyncIterator]())`
+ * (pi's EventStream). Null for other sources. */
+export function classAsyncGeneratorIterator(
+  lowerer: Lowerer,
+  expression: ts.Expression,
+): (IrExpr & { type: GenType }) | null {
+  const sourceType = lowerer.mapTypeOf(lowerer.typeOf(expression));
+  if (sourceType?.kind !== "object") return null;
+  const info = lowerer.classes.get(sourceType.className);
+  const open = info ? lowerer.findMethodOn(info, "sym:asyncIterator") : null;
+  if (
+    !open ||
+    open.sig.abstract === true ||
+    open.sig.params.length !== 0 ||
+    open.sig.ret.kind !== "generator" ||
+    !open.sig.ret.async
+  )
+    return null;
+  const retT = open.sig.ret;
+  const source = lowerer.lowerExpr(expression);
+  if (source.type.kind !== "object") return null;
+  return {
+    ...lowerer.accessorCall(
+      sourceType.className,
+      "sym:asyncIterator",
+      source,
+      [],
+      retT,
+      locOf(expression),
+    ),
+    type: retT,
+  };
+}
+
 export function checkForAwaitBinding(
   lowerer: Lowerer,
   stmt: ts.ForOfStatement,
diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts
index e0d4493c1d..c57822d6b6 100644
--- a/packages/compiler/src/frontend/lowering/lower-calls.ts
+++ b/packages/compiler/src/frontend/lowering/lower-calls.ts
@@ -150,7 +150,10 @@ import {
   lowerPerfHooksCall,
   perfEntryTag,
 } from "./builtins/performance.js";
-import { lowerProcStreamMethodCall } from "./builtins/process.js";
+import {
+  lowerProcStreamMethodCall,
+  lowerProcessBuiltinModuleNamespace,
+} from "./builtins/process.js";
 import { recordMayKeepSource, throughRecordSource } from "./record-sources.js";
 import { lowerReflectCall } from "./builtins/reflection.js";
 import {
@@ -425,6 +428,15 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr {
     return { kind: "libCall", fn: "http2.streamNoop", args: [], type: VOID, loc };
   }
 
+  // `process.getBuiltinModule("node:os")` typed as the module namespace,
+  // including pi's cast-and-probe spelling
+  // `(process as P).getBuiltinModule?.("node:os")` (the member always
+  // exists on Node 24's process object).
+  {
+    const namespace = lowerProcessBuiltinModuleNamespace(lowerer, expr);
+    if (namespace) return namespace;
+  }
+
   // Optional-chain call forms: `f?.()` (the token on the call) and
   // `a?.m()` (the token on the member access). The handled markers keep
   // the chain lowering's re-entrant dispatch from looping.
@@ -3677,8 +3689,14 @@ function lowerDynReceiverMethodCall(
   // own or inherited member exactly like a non-prototype name (chalk's
   // `chalk.red.bold(...)` reads a prototype getter of a function), so
   // only a string receiver keeps the refusal, deferred to run time.
+  // The same holds when only the MEMBER is checker-untyped: TypeScript
+  // importing chalk's JavaScript source types the default export as a
+  // plain function, so `chalk.bold` reads as `any` on a typed receiver.
   const stringOnlyName =
-    checkerUntyped && !ownCallable && DYN_STRING_PROTO_ONLY_NAMES.has(access.name.text);
+    (checkerUntyped ||
+      (lowerer.typeOf(access).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) &&
+    !ownCallable &&
+    DYN_STRING_PROTO_ONLY_NAMES.has(access.name.text);
   if (DYN_PROTO_METHOD_NAMES.has(access.name.text) && !ownCallable && !stringOnlyName) return null;
   // Optional forms (`obj.cb?.()`, `obj?.cb()`) belong to the chain
   // machinery's short-circuit semantics — not modeled here yet.
diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts
index d4bcb85741..3c578fc912 100644
--- a/packages/compiler/src/frontend/lowering/lower-stmts.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts
@@ -46,7 +46,7 @@ import {
   lowerYieldStarStatement,
   type GenType,
 } from "./lower-generators.js";
-import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
+import { classAsyncGeneratorIterator, lowerForAwaitBuiltin } from "./lower-async-iteration.js";
 import {
   BOOL,
   BYTES_U8,
@@ -5980,6 +5980,28 @@ function lowerDeleteStatement(lowerer: Lowerer, expr: ts.DeleteExpression): IrSt
     };
   }
   let obj = lowerer.lowerExpr(target.expression);
+  // `delete this.stack` in an Error subclass that declares a `stack`
+  // accessor (quickjs-wasi's JSException): V8 gives each error an own
+  // `stack` that shadows the accessor, and the delete removes it so reads
+  // reach the accessor. Compiled errors keep the trace internally and
+  // class dispatch already reads the accessor, so only the receiver's
+  // evaluation remains.
+  if (
+    obj.type.kind === "object" &&
+    ts.isPropertyAccessExpression(target) &&
+    target.name.text === "stack"
+  ) {
+    let accessor = false;
+    let errorBase = false;
+    for (let c = lowerer.classes.get(obj.type.className); c; c = c.base ?? undefined) {
+      if (c.builtinError) {
+        errorBase = true;
+        break;
+      }
+      if (c.methods.has("get:stack")) accessor = true;
+    }
+    if (accessor && errorBase) return { kind: "exprStmt", expr: obj, loc };
+  }
   if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "object") {
     const info = lowerer.classes.get(obj.type.className);
     const keyType = ts.isElementAccessExpression(target)
@@ -7019,6 +7041,32 @@ export function lowerExprStatement(lowerer: Lowerer, expr: ts.Expression): IrStm
               loc,
             };
           }
+          // process.emitWarning = fn: an ordinary writable property. Later
+          // process.emitWarning(...) calls, and the warnings Node's own
+          // modules emit through process.emitWarning, call the replacement
+          // instead (silencing them when it does nothing).
+          if (flag === "emitWarning") {
+            const loc = locOf(expr);
+            let rhs: ts.Expression = expr.right;
+            while (
+              ts.isParenthesizedExpression(rhs) ||
+              ts.isAsExpression(rhs) ||
+              ts.isSatisfiesExpression(rhs)
+            )
+              rhs = rhs.expression;
+            const value = lowerer.lowerExprExpecting(rhs, DYN);
+            return {
+              kind: "exprStmt",
+              expr: {
+                kind: "libCall",
+                fn: "process.setEmitWarning",
+                args: [value],
+                type: VOID,
+                loc,
+              },
+              loc,
+            };
+          }
           // process.title = name: libuv's uv_set_process_title (the
           // runtime truncates to the original argument area on POSIX).
           if (flag === "title") {
@@ -8529,6 +8577,10 @@ export function lowerForOf(lowerer: Lowerer, stmt: ts.ForOfStatement): IrStmt {
         }
       }
     }
+    {
+      const opened = classAsyncGeneratorIterator(lowerer, stmt.expression);
+      if (opened) return lowerForAwaitGenerator(lowerer, stmt, opened, labels);
+    }
     if (
       ts.isPropertyAccessExpression(stmt.expression) &&
       lowerer.stdlibGlobalMember(stmt.expression, "process") === "stdin"
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index 1488d64b99..1520547596 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -3152,15 +3152,39 @@ export class Lowerer {
 
   /** Declared class fields may store a DYN value only when its static type
    * is `unknown` or `object` (also with `null` or `undefined`, or an array
-   * of those), names checked protocol identity, or is an owned runtime
-   * handle (a Worker or MessagePort, or a fetch Headers/Request/Response);
-   * `any` fields stay refused. */
+   * of those), names checked protocol identity, is an owned runtime
+   * handle (a Worker or MessagePort, or a fetch Headers/Request/Response),
+   * or is a WeakMap/WeakSet (native weak collections live in
+   * checked-dynamic storage, as locals of those types do); `any` fields
+   * stay refused. */
   classFieldStoresDyn(type: ts.Type): boolean {
     return (
       this.opaqueValueType(type) ||
       this.classImplementedProtocol(type) ||
       isWorkerHandleType(type, this.typeCtx) ||
-      isFetchHandleType(type, this.typeCtx)
+      isFetchHandleType(type, this.typeCtx) ||
+      this.weakCollectionType(type)
+    );
+  }
+
+  /** A stdlib WeakMap or WeakSet, alone or with `null`/`undefined`. */
+  private weakCollectionType(type: ts.Type): boolean {
+    const weak = (part: ts.Type): boolean => {
+      const symbol = part.getSymbol();
+      return (
+        (symbol?.name === "WeakMap" || symbol?.name === "WeakSet") &&
+        this.checker
+          .declarationsOf(symbol)
+          .some((d) => ts.isInterfaceDeclaration(d) && this.isStdlibFile(d.getSourceFile()))
+      );
+    };
+    if (!type.isUnionType()) return weak(type);
+    const parts = ts.constituentTypes(type);
+    return (
+      parts.some(weak) &&
+      parts.every(
+        (part) => (part.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0 || weak(part),
+      )
     );
   }
 
@@ -12057,6 +12081,18 @@ export class Lowerer {
     if (mapped?.kind === "moduleNs" && mapped.moduleId.startsWith("builtin:")) {
       return mapped.moduleId.slice("builtin:".length);
     }
+    // A nullable namespace binding (`const os: typeof NodeOs | null`, a
+    // probed process.getBuiltinModule result) read where the checker
+    // narrowed it present: its members key the same tables.
+    if (stored?.kind === "union") {
+      const present = this.unions.get(stored.unionId)?.arms.filter((arm) => !isUnitType(arm));
+      const only = present?.length === 1 ? present[0] : undefined;
+      if (only?.kind === "moduleNs" && only.moduleId.startsWith("builtin:")) {
+        const narrowed = this.mapTypeOf(this.typeOf(expr));
+        if (narrowed?.kind === "moduleNs" && narrowed.moduleId === only.moduleId)
+          return only.moduleId.slice("builtin:".length);
+      }
+    }
     if (ts.isIdentifier(expr)) {
       const symbol = this.checker.getSymbolAtLocation(expr);
       const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
diff --git a/packages/compiler/src/frontend/program.ts b/packages/compiler/src/frontend/program.ts
index bde168c38a..27c63ca62f 100644
--- a/packages/compiler/src/frontend/program.ts
+++ b/packages/compiler/src/frontend/program.ts
@@ -4081,6 +4081,12 @@ function resolveNpmImport7(
   if (isRelativeSpecifier(specifier) || specifier.startsWith("node:")) {
     return null;
   }
+  // Node resolves a bare core-module name (`string_decoder`, `events`,
+  // `fs/promises`) to the builtin before it looks in node_modules, so an
+  // installed npm package of the same name never answers it. Prefix-only
+  // builtins (`node:test`) are listed with their prefix, so a bare `test`
+  // still names the package.
+  if (nodeBuiltinNames.has(specifier)) return null;
   // --provenance-sources: a registered specifier is NOT an npm import —
   // its attested source compiles as program modules (resolveProjectModule
 
diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts
index 123a5d1a05..793ddea627 100644
--- a/packages/compiler/src/frontend/type-mapper.ts
+++ b/packages/compiler/src/frontend/type-mapper.ts
@@ -1339,6 +1339,32 @@ export function isWorkerHandleType(
   return handle;
 }
 
+/** The return annotation of an `async *` declaration spelled with the
+ * protocol interfaces the generator object implements —
+ * `AsyncIterator<T>`, `AsyncIterableIterator<T>` or `AsyncIterable<T>` (pi's
+ * `async *[Symbol.asyncIterator](): AsyncIterator<T>`): the body always
+ * produces an async generator, so the declaration maps exactly like an
+ * `AsyncGenerator<T, TReturn, TNext>` annotation. Values of these types
+ * elsewhere stay unmapped (they can hold any object implementing the
+ * protocol). Null when the annotation is not one of them. */
+export function mapAsyncGeneratorAnnotation(type: ts.Type, ctx: TypeMapperCtx): IrType | null {
+  const { checker } = ctx;
+  const symbol = type.getSymbol();
+  if (
+    !symbol ||
+    !["AsyncIterator", "AsyncIterableIterator", "AsyncIterable"].includes(symbol.name) ||
+    !checker
+      .declarationsOf(symbol)
+      .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))
+  )
+    return null;
+  const args = checker.getTypeArguments(type as ts.TypeReference);
+  const channels = genChannels(args[0], args[1], args[2], ctx);
+  if (!channels) return null;
+  if (!genResultRecord(channels.yieldT, channels.retT, ctx.shapes, ctx.unions)) return null;
+  return { kind: "generator", async: true, ...channels };
+}
+
 /** The native fetch handles (Headers, Request, Response), optionally in
  * arrays or with null/undefined: checked-dynamic handles wherever they are
  * stored, like the worker handles above. */
diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts
index ca9dc4d180..4a577d78b9 100644
--- a/packages/compiler/src/index.ts
+++ b/packages/compiler/src/index.ts
@@ -528,6 +528,8 @@ async function compileExecutableNative(
     fileHandle: features.fileHandle,
     fetch: features.fetch,
     ...(features.eventTarget ? { eventTarget: true } : {}),
+    ...(features.warningReplace ? { warningReplace: true } : {}),
+    ...(features.stdioExtended ? { stdioExtended: true } : {}),
     zlib: features.zlib,
     assert: features.assert,
     inspect: features.inspect,
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index 028b12c21f..e64477ca10 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -4176,6 +4176,7 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
    * warnings and DeprecationWarning emissions read their truthiness. */
   "process.deprecationFlag": { argTypes: [F64], result: DYN },
   "process.setDeprecationFlag": { argTypes: [F64, DYN], result: VOID },
+  "process.setEmitWarning": { argTypes: [DYN], result: VOID },
   /** AsyncLocalStorage (node:async_hooks — scr_async.c): stores are f64
    * handles; contexts are immutable fiber-carried snapshots (spawned
    * fibers inherit the spawner's — Node's init-time capture). run/exit
diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts
index 870ca14f0d..a8a8d464ad 100644
--- a/packages/compiler/src/ir/runtime-features.ts
+++ b/packages/compiler/src/ir/runtime-features.ts
@@ -17,6 +17,12 @@ export interface RuntimeFeatures {
   fetch: boolean;
   eventTarget: boolean;
   processEvents: boolean;
+  /** process.emitWarning is assigned (process.setEmitWarning). Declared
+   * in the literal's order: JSON.stringify of the features record must
+   * match between the Node-run and self-hosted compilers. */
+  warningReplace: boolean;
+  /** stdin setEncoding / string data listeners / stdio 'resize' events. */
+  stdioExtended: boolean;
   emitter: boolean;
   stream: boolean;
   zlib: boolean;
@@ -75,6 +81,7 @@ const DYN_ASYNC_LIB_FNS: ReadonlySet<IrLibFn> = new Set([
   "process.emitWarningText",
   "process.deprecationFlag",
   "process.setDeprecationFlag",
+  "process.setEmitWarning",
   // The performance timeline (scr_perf.c, linked with this unit for its
   // MaxPerformanceEntryBufferExceededWarning).
   "perf.mark",
@@ -350,18 +357,41 @@ function boxesPromise(t: IrType, tables: TypeTables, seen: Set<string>): boolean
     }
     case "object": {
       // A boxed class instance exposes its fields as dyn values (Object.keys,
-      // spread, inspection), boxing a promise any field holds.
+      // spread, inspection), boxing a promise any field holds. It
+      // materializes inherited fields too, and the instance can be any
+      // subclass.
       const key = `class:${t.className}`;
       if (seen.has(key)) return false;
       seen.add(key);
-      const def = tables.classes.get(t.className);
-      return def?.fields.some((f) => boxesPromise(f.type, tables, seen)) ?? false;
+      const related = (def: IrClassDef): boolean => {
+        for (
+          let c: IrClassDef | undefined = def;
+          c;
+          c = c.base ? tables.classes.get(c.base) : undefined
+        )
+          if (c.name === t.className) return true;
+        return false;
+      };
+      for (const def of tables.classes.values()) {
+        if (!related(def)) continue;
+        for (
+          let c: IrClassDef | undefined = def;
+          c;
+          c = c.base ? tables.classes.get(c.base) : undefined
+        )
+          if (c.fields.some((f) => boxesPromise(f.type, tables, seen))) return true;
+      }
+      return false;
     }
     default:
       return false;
   }
 }
 
+/** Names that reach the extended process-stream surface (the
+ * SCR_STDIO_EXTENDED events unit): stdin.setEncoding and 'resize'. */
+const STDIO_EXTENDED_NAMES: ReadonlySet<string> = new Set(["setEncoding", "resize"]);
+
 function scanRuntimeFeatures(mod: IrModule, stopAt?: keyof RuntimeFeatures): RuntimeFeatures {
   const features: RuntimeFeatures = {
     regex: false,
@@ -375,6 +405,8 @@ function scanRuntimeFeatures(mod: IrModule, stopAt?: keyof RuntimeFeatures): Run
       (c) => c.name === RUNTIME_EVENT_TARGET_CLASS || c.name === RUNTIME_EVENT_CLASS,
     ),
     processEvents: false,
+    warningReplace: false,
+    stdioExtended: false,
     emitter:
       mod.workers === true || (mod.classes ?? []).some((c) => c.name === RUNTIME_EMITTER_CLASS),
     stream: (mod.classes ?? []).some((c) => RUNTIME_STREAM_CLASSES.has(c.name)),
@@ -422,6 +454,14 @@ function scanRuntimeFeatures(mod: IrModule, stopAt?: keyof RuntimeFeatures): Run
       if (REGEX_LIB_FNS.has(fn)) features.regex = true;
       if (LEGACY_TEXT_DECODER_LIB_FNS.has(fn)) features.legacyTextDecoder = true;
       if (fn.startsWith("fetch.")) features.fetch = true;
+      if (fn === "process.setEmitWarning") features.warningReplace = true;
+      // A typed string 'data' listener takes setEncoding-decoded chunks.
+      if (
+        fn === "stdin.onData" &&
+        node.args[0]?.type.kind === "func" &&
+        node.args[0].type.params[0]?.kind === "string"
+      )
+        features.stdioExtended = true;
       if (fn.startsWith("event.") || fn === "events.addAbortListener") features.eventTarget = true;
       if (ABORT_SIGNAL_LIB_FNS.has(fn)) features.eventTarget = true;
       if (PROCESS_EVENT_LIB_FNS.has(fn)) features.processEvents = true;
@@ -529,6 +569,12 @@ function scanRuntimeFeatures(mod: IrModule, stopAt?: keyof RuntimeFeatures): Run
           break;
         case "dynInvoke":
           features.dynInvoke = true;
+          if (STDIO_EXTENDED_NAMES.has(node.method)) features.stdioExtended = true;
+          break;
+        // The process stream object's setEncoding and 'resize' members are
+        // reached by name (dynamic member calls and event-name strings).
+        case "strLit":
+          if (STDIO_EXTENDED_NAMES.has(node.value)) features.stdioExtended = true;
           break;
         case "awaitExpr":
           if (node.type.kind === "dyn") features.dynAsync = true;
diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts
index fa3b693a3a..4a961dfca6 100644
--- a/packages/compiler/src/ir/validate.ts
+++ b/packages/compiler/src/ir/validate.ts
@@ -5103,7 +5103,8 @@ function validateFunction(
       let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
       if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
         const p = cbT.params[0]!;
-        if (e.fn === "stdin.onData") ok = p.kind === "bytes" && p.elem === "u8";
+        if (e.fn === "stdin.onData")
+          ok = (p.kind === "bytes" && p.elem === "u8") || p.kind === "string";
         else if (e.fn === "stdin.onError") ok = p.kind === "object" && p.className === "%Error";
         else ok = p.kind === "f64";
       }
diff --git a/packages/compiler/src/native/sanitizer.test.ts b/packages/compiler/src/native/sanitizer.test.ts
index 79984d6c55..2c86d01afe 100644
--- a/packages/compiler/src/native/sanitizer.test.ts
+++ b/packages/compiler/src/native/sanitizer.test.ts
@@ -75,6 +75,8 @@ test.skipIf(process.platform !== "linux" && process.platform !== "darwin")(
               workers: false,
               youngNursery: false,
               eventTarget: false,
+              warningReplace: false,
+              stdioExtended: false,
               regex: true,
               copying: false,
               textDecoderLegacy: false,
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6231-process-emit-warning-assign.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6231-process-emit-warning-assign.ts.json
new file mode 100644
index 0000000000..ac7be42ac0
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6231-process-emit-warning-assign.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6231-process-emit-warning-assign.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6232-process-builtin-module-typed/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6232-process-builtin-module-typed/main.ts.json
new file mode 100644
index 0000000000..8adab38b7b
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6232-process-builtin-module-typed/main.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6232-process-builtin-module-typed/main.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6233-for-await-class-async-generator.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6233-for-await-class-async-generator.ts.json
new file mode 100644
index 0000000000..89f131b0fe
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6233-for-await-class-async-generator.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6233-for-await-class-async-generator.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6234-weak-collection-class-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6234-weak-collection-class-fields.ts.json
new file mode 100644
index 0000000000..e7e18883aa
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6234-weak-collection-class-fields.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6234-weak-collection-class-fields.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6235-bare-builtin-shadowed-package/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6235-bare-builtin-shadowed-package/main.ts.json
new file mode 100644
index 0000000000..eee3db81ad
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6235-bare-builtin-shadowed-package/main.ts.json
@@ -0,0 +1,7 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6235-bare-builtin-shadowed-package/helper.cjs",
+  "<repo>/tests/corpus/6235-bare-builtin-shadowed-package/main.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6236-stdin-encoding-tty-probes/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6236-stdin-encoding-tty-probes/main.ts.json
new file mode 100644
index 0000000000..c7546dd635
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6236-stdin-encoding-tty-probes/main.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6236-stdin-encoding-tty-probes/main.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6237-error-subclass-delete-stack/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6237-error-subclass-delete-stack/main.js.json
new file mode 100644
index 0000000000..a483858716
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6237-error-subclass-delete-stack/main.js.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6237-error-subclass-delete-stack/main.js"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs b/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs
index 5eec9b1429..9ef3f2404f 100644
--- a/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs
+++ b/packages/runtime-darwin-arm64/runtime-pack-matrix.mjs
@@ -125,6 +125,23 @@ function variantsFor(source) {
       defines: ["SCR_TEXT_DECODER_LEGACY"],
     });
   }
+  // Programs that assign process.emitWarning link the replacement-aware
+  // warning paths; every other program keeps the default object.
+  if (source === "scr_async_dyn.c") {
+    variants.push({
+      id: "warning-replace",
+      when: { warningReplace: true },
+      defines: ["SCR_WARNING_REPLACE"],
+    });
+  }
+  // stdin setEncoding, string data listeners and stdio 'resize' events.
+  if (source === "scr_events.c") {
+    variants.push({
+      id: "stdio-extended",
+      when: { stdioExtended: true },
+      defines: ["SCR_STDIO_EXTENDED"],
+    });
+  }
   if (source === "scr_cycle.c") {
     // The young-in nursery (SCRIPTC_YOUNG_NURSERY=1): the collector with
     // nursery collections; programs built without it link the default.
diff --git a/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs
index 18ee441e61..dbde1564ff 100644
--- a/packages/runtime-darwin-arm64/scripts/build.mjs
+++ b/packages/runtime-darwin-arm64/scripts/build.mjs
@@ -343,7 +343,12 @@ async function build() {
         ...(unitHelper === null ? {} : { speed_codegen: unitHelper.identity }),
       },
       macros: {
-        executable: ["SCR_TEXT_DECODER_LEGACY", "SCR_YIN"],
+        executable: [
+          "SCR_TEXT_DECODER_LEGACY",
+          "SCR_WARNING_REPLACE",
+          "SCR_STDIO_EXTENDED",
+          "SCR_YIN",
+        ],
         excluded: ["SCR_RC_AUDIT", "SCR_ASAN_FIBERS"],
         sanitizer: "external-toolchain-required",
       },
diff --git a/packages/runtime-pack-common/runtime-pack-matrix.mjs b/packages/runtime-pack-common/runtime-pack-matrix.mjs
index eab680a553..654e8581e4 100644
--- a/packages/runtime-pack-common/runtime-pack-matrix.mjs
+++ b/packages/runtime-pack-common/runtime-pack-matrix.mjs
@@ -115,6 +115,23 @@ function variantsFor(source) {
       defines: ["SCR_TEXT_DECODER_LEGACY"],
     });
   }
+  // Programs that assign process.emitWarning link the replacement-aware
+  // warning paths; every other program keeps the default object.
+  if (source === "scr_async_dyn.c") {
+    variants.push({
+      id: "warning-replace",
+      when: { warningReplace: true },
+      defines: ["SCR_WARNING_REPLACE"],
+    });
+  }
+  // stdin setEncoding, string data listeners and stdio 'resize' events.
+  if (source === "scr_events.c") {
+    variants.push({
+      id: "stdio-extended",
+      when: { stdioExtended: true },
+      defines: ["SCR_STDIO_EXTENDED"],
+    });
+  }
   if (source === "scr_cycle.c") {
     // The young-in nursery (SCRIPTC_YOUNG_NURSERY=1): the collector with
     // nursery collections; programs built without it link the default.
diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs
index 1bcd7455df..a0f117cec1 100644
--- a/packages/runtime-pack-common/scripts/build.mjs
+++ b/packages/runtime-pack-common/scripts/build.mjs
@@ -440,7 +440,12 @@ async function build() {
         ...(unitHelper === null ? {} : { speed_codegen: unitHelper.identity }),
       },
       macros: {
-        executable: ["SCR_TEXT_DECODER_LEGACY", "SCR_YIN"],
+        executable: [
+          "SCR_TEXT_DECODER_LEGACY",
+          "SCR_WARNING_REPLACE",
+          "SCR_STDIO_EXTENDED",
+          "SCR_YIN",
+        ],
         excluded: ["SCR_RC_AUDIT", "SCR_ASAN_FIBERS"],
         sanitizer: "external-toolchain-required",
       },
diff --git a/packages/runtime/src/scr_async.h b/packages/runtime/src/scr_async.h
index d16fd8b9c1..6f56758ce5 100644
--- a/packages/runtime/src/scr_async.h
+++ b/packages/runtime/src/scr_async.h
@@ -216,6 +216,12 @@ void scr_process_on_warning(ScrDyn *fn);
 void scr_process_off_warning(ScrDyn *fn);
 void scr_process_emit_warning(ScrDyn *args);
 void scr_emit_warning(const char *name, const char *code, ScrStr *message);
+/* process.emitWarning = fn (borrowed; the runtime keeps its own
+ * reference). Later process.emitWarning(...) calls apply the replacement
+ * to their arguments, and runtime-built warnings (Node's own modules call
+ * process.emitWarning) reach it as (message, type[, code]) instead of the
+ * report and the 'warning' listeners. */
+void scr_process_set_emit_warning(ScrDyn *fn);
 /* node:punycode's first load (scr_async_dyn.c): later calls are module
  * cache hits. The first reports DEP0040 when `report` (false for a require
  * made from node_modules) — at once for a static ES import, which Node
diff --git a/packages/runtime/src/scr_async_dyn.c b/packages/runtime/src/scr_async_dyn.c
index dbddc5b183..1cdd466c3d 100644
--- a/packages/runtime/src/scr_async_dyn.c
+++ b/packages/runtime/src/scr_async_dyn.c
@@ -822,10 +822,59 @@ ScrDyn *scr_warning_new(ScrStr *message, const char *type, const ScrStr *code) {
   return w;
 }
 
+#ifdef SCR_WARNING_REPLACE
+/* The program's process.emitWarning replacement, or NULL while the
+ * property holds Node's own function. Compiled only into the
+ * SCR_WARNING_REPLACE variant, which programs assigning process.emitWarning
+ * link: every other executable keeps the plain warning paths. */
+static SCR_TL ScrDyn *scr_emit_warning_override = NULL;
+
+static void scr_emit_warning_override_teardown(void) {
+  scr_dyn_release(scr_emit_warning_override);
+  scr_emit_warning_override = NULL;
+}
+
+void scr_process_set_emit_warning(ScrDyn *fn) {
+  if (scr_emit_warning_override == NULL) scr_atexit(scr_emit_warning_override_teardown);
+  ScrDyn *previous = scr_emit_warning_override;
+  scr_emit_warning_override = scr_dyn_retain(fn);
+  scr_dyn_release(previous);
+  /* Units that report their own warnings without a listener route them
+   * here once a replacement exists. */
+  scr_warning_emit_hook = scr_emit_warning;
+}
+
+/* A runtime-built warning while a replacement is installed: Node's modules
+ * call process.emitWarning(message, type, code), so the replacement sees
+ * those arguments; nothing is reported. A throw stays pending. */
+static void scr_emit_warning_replaced(ScrStr *message, ScrStr *type, ScrStr *code) {
+  ScrDyn *args[3];
+  size_t argc = 0;
+  args[argc++] = scr_dyn_new_str(message);
+  ScrStr *fallback = type ? NULL : scr_str_new("Warning", 7);
+  args[argc++] = scr_dyn_new_str(type ? type : fallback);
+  scr_str_release(fallback);
+  if (code) args[argc++] = scr_dyn_new_str(code);
+  ScrDyn *r = scr_dyn_call(scr_emit_warning_override, args, argc, "process.emitWarning");
+  scr_dyn_release(r);
+  for (size_t i = 0; i < argc; i++) scr_dyn_release(args[i]);
+}
+#endif /* SCR_WARNING_REPLACE */
+
 /* A warning built from C parts (the runtime deprecation sites): name
  * defaults to "Warning"; code/detail optional. Reported synchronously.
  * Borrows message. */
 void scr_emit_warning(const char *name, const char *code, ScrStr *message) {
+#ifdef SCR_WARNING_REPLACE
+  if (scr_emit_warning_override != NULL) {
+    ScrStr *type_text = scr_str_new(name ? name : "Warning", strlen(name ? name : "Warning"));
+    ScrStr *code_text = code ? scr_str_new(code, strlen(code)) : NULL;
+    scr_emit_warning_replaced(message, type_text, code_text);
+    scr_str_release(type_text);
+    scr_str_release(code_text);
+    return;
+  }
+#endif
   ScrStr *code_text = code ? scr_str_new(code, strlen(code)) : NULL;
   ScrDyn *w = scr_warning_new(message, name ? name : "Warning", code_text);
   scr_str_release(code_text);
@@ -856,6 +905,18 @@ static void scr_warning_defer(ScrDyn *w, void (*fire)(ScrClosure *)) {
 }
 
 void scr_warning_emit_deferred(ScrDyn *w) {
+#ifdef SCR_WARNING_REPLACE
+  if (scr_emit_warning_override != NULL) {
+    const ScrDyn *em = scr_dyn_obj_get(w, "message", 7);
+    const ScrDyn *ec = scr_dyn_obj_get(w, "code", 4);
+    ScrStr *name = scr_warning_name(w);
+    ScrStr *message = em && em->kind == SCR_DYN_STR ? scr_str_retain(em->v.str) : scr_str_new("", 0);
+    scr_emit_warning_replaced(message, name, ec && ec->kind == SCR_DYN_STR ? ec->v.str : NULL);
+    scr_str_release(message);
+    scr_str_release(name);
+    return;
+  }
+#endif
   if (scr_warning_is_deprecation(w)) {
     if (scr_process_deprecation_flag_on(0)) return;
     if (scr_process_deprecation_flag_on(1)) {
@@ -942,6 +1003,13 @@ static void scr_warn_bad_arg(const char *arg, const char *want) {
  * ERR_INVALID_ARG_TYPE TypeErrors at the call; non-string details are
  * ignored. The warning itself is emitted on the next tick. */
 void scr_process_emit_warning(ScrDyn *args) {
+#ifdef SCR_WARNING_REPLACE
+  if (scr_emit_warning_override != NULL) {
+    ScrDyn *r = scr_dyn_apply(scr_emit_warning_override, args, "process.emitWarning");
+    scr_dyn_release(r);
+    return;
+  }
+#endif
   size_t argc = args->kind == SCR_DYN_ARR ? args->v.arr.len : 0;
   ScrDyn *const *items = args->kind == SCR_DYN_ARR ? args->v.arr.items : NULL;
   ScrDyn *warning = argc >= 1 ? items[0] : NULL;
diff --git a/packages/runtime/src/scr_events.c b/packages/runtime/src/scr_events.c
index 54eb87a0d3..3391f54b1d 100644
--- a/packages/runtime/src/scr_events.c
+++ b/packages/runtime/src/scr_events.c
@@ -345,9 +345,23 @@ static void scr_signals_drain(void) {
  * listener it is treated as EOF (piped fd 0 read errors are not
  * meaningfully reachable). */
 
+#ifdef SCR_STDIO_EXTENDED
+/* What a 'data' listener receives (the SCR_STDIO_EXTENDED variant, linked
+ * by programs that use setEncoding, string data listeners or 'resize'):
+ * raw chunks (typed Buffer listeners and the runtime's own consumers), the
+ * decoded string (typed string listeners, which need setEncoding), or
+ * whichever Node delivers (checked-dynamic listeners: the string once an
+ * encoding is set, else the Buffer). */
+enum { SCR_STDIN_DATA_BYTES, SCR_STDIN_DATA_STRING, SCR_STDIN_DATA_DYN };
+
+#endif
 typedef struct {
   ScrClosure *cb; /* owned */
   void (*fn)(ScrClosure *cb, ScrBytes *chunk); /* adapter: chunk borrowed */
+#ifdef SCR_STDIO_EXTENDED
+  void (*str_fn)(ScrClosure *cb, ScrStr *text); /* STRING/DYN: text borrowed */
+  unsigned char kind;
+#endif
   bool once;
 } ScrStdinDataL;
 
@@ -377,6 +391,57 @@ static SCR_TL bool scr_stdin_read_eof = false;
 static SCR_TL ScrBytes *scr_stdin_buffer;
 static SCR_TL size_t scr_stdin_read_demand;
 
+#ifdef SCR_STDIO_EXTENDED
+/* process.stdin.setEncoding(enc): the canonical encoding name (NULL until
+ * set) and the StringDecoder's packed pending partial sequence, so a
+ * multibyte character split across reads decodes whole, as Node's
+ * decoder does. */
+static SCR_TL ScrStr *scr_stdin_encoding = NULL;
+static SCR_TL double scr_stdin_dec_pending = 0;
+
+static void scr_stdin_add_data(ScrClosure *cb /*moves*/, void (*fn)(ScrClosure *, ScrBytes *),
+                               void (*str_fn)(ScrClosure *, ScrStr *), unsigned char kind,
+                               bool once) {
+  if (scr_stdin_eof || scr_stdin_destroyed) {
+    scr_closure_release(cb); /* never fires again, like Node post-'end' */
+    return;
+  }
+  if (scr_stdin_ndata == scr_stdin_data_cap) {
+    scr_stdin_data_cap = scr_stdin_data_cap ? scr_stdin_data_cap * 2 : 2;
+    scr_stdin_data = realloc(scr_stdin_data, scr_stdin_data_cap * sizeof *scr_stdin_data);
+    if (!scr_stdin_data) scr_events_oom();
+  }
+  scr_stdin_data[scr_stdin_ndata].cb = cb;
+  scr_stdin_data[scr_stdin_ndata].fn = fn;
+  scr_stdin_data[scr_stdin_ndata].str_fn = str_fn;
+  scr_stdin_data[scr_stdin_ndata].kind = kind;
+  scr_stdin_data[scr_stdin_ndata].once = once;
+  scr_stdin_ndata++;
+}
+
+void scr_stdin_on_data(ScrClosure *cb /*moves*/, void (*fn)(ScrClosure *, ScrBytes *),
+                        bool once) {
+  scr_stdin_add_data(cb, fn, NULL, SCR_STDIN_DATA_BYTES, once);
+}
+
+void scr_stdin_on_data_str(ScrClosure *cb /*moves*/, void (*fn)(ScrClosure *, ScrStr *),
+                            bool once) {
+  scr_stdin_add_data(cb, NULL, fn, SCR_STDIN_DATA_STRING, once);
+}
+
+static void scr_stdin_encoding_teardown(void) {
+  scr_str_release(scr_stdin_encoding);
+  scr_stdin_encoding = NULL;
+}
+
+void scr_stdin_set_encoding(ScrStr *enc) {
+  if (scr_stdin_encoding == NULL) scr_atexit(scr_stdin_encoding_teardown);
+  ScrStr *previous = scr_stdin_encoding;
+  scr_stdin_encoding = scr_str_retain(enc);
+  scr_str_release(previous);
+  scr_stdin_dec_pending = 0;
+}
+#else
 void scr_stdin_on_data(ScrClosure *cb /*moves*/, void (*fn)(ScrClosure *, ScrBytes *),
                         bool once) {
   if (scr_stdin_eof || scr_stdin_destroyed) {
@@ -393,6 +458,7 @@ void scr_stdin_on_data(ScrClosure *cb /*moves*/, void (*fn)(ScrClosure *, ScrByt
   scr_stdin_data[scr_stdin_ndata].once = once;
   scr_stdin_ndata++;
 }
+#endif
 
 void scr_stdin_on_end(ScrClosure *cb /*moves*/, bool once) {
   if (scr_stdin_eof || scr_stdin_destroyed) {
@@ -487,7 +553,20 @@ static void scr_stdin_settle_done(void) {
 /* EOF/teardown shared tail: 'end' fires (snapshot; once semantics are
  * moot — everything drops right after), the parked promise settles done,
  * and every listener is released. */
+#ifdef SCR_STDIO_EXTENDED
+static void scr_stdin_deliver_parts(ScrBytes *chunk, ScrStr *text);
+#endif
 static void scr_stdin_finish(bool fire_end) {
+#ifdef SCR_STDIO_EXTENDED
+  if (fire_end && scr_stdin_encoding != NULL && scr_stdin_ndata > 0) {
+    /* The decoder's end() flush reaches the string listeners before 'end'. */
+    ScrStr *tail = scr_strdec_end(scr_stdin_encoding, scr_stdin_dec_pending);
+    scr_stdin_dec_pending = 0;
+    if (tail->len > 0) scr_stdin_deliver_parts(NULL, tail);
+    scr_str_release(tail);
+    if (scr_exc_pending()) fire_end = false;
+  }
+#endif
   scr_stdin_eof = true;
   if (fire_end) {
     size_t n = scr_stdin_nend;
@@ -657,7 +736,25 @@ static void scr_stdin_service(void) {
   scr_stdin_arrived(chunk);
 }
 
+#ifdef SCR_STDIO_EXTENDED
+static void scr_stdin_deliver(ScrBytes *chunk) {
+  if (scr_stdin_ndata > 0 && scr_stdin_encoding != NULL) {
+    /* Node's readable decodes once, in the stream: every listener sees
+     * the same string, and a read holding only a partial sequence emits
+     * nothing. */
+    ScrStr *text = scr_strdec_write(scr_stdin_encoding, scr_stdin_dec_pending, chunk);
+    scr_stdin_dec_pending = scr_strdec_next(scr_stdin_encoding, scr_stdin_dec_pending, chunk);
+    if (text->len > 0) scr_stdin_deliver_parts(chunk, text);
+    scr_str_release(text);
+    return;
+  }
+  scr_stdin_deliver_parts(chunk, NULL);
+}
+
+static void scr_stdin_deliver_parts(ScrBytes *chunk, ScrStr *text) {
+#else
 static void scr_stdin_deliver(ScrBytes *chunk) {
+#endif
   if (scr_stdin_ndata > 0) {
     size_t nd = scr_stdin_ndata;
     ScrStdinDataL *snap = malloc(nd * sizeof *snap);
@@ -678,11 +775,31 @@ static void scr_stdin_deliver(ScrBytes *chunk) {
           }
         }
       }
+#ifdef SCR_STDIO_EXTENDED
+      if (!scr_exc_pending()) {
+        if (snap[i].kind == SCR_STDIN_DATA_BYTES) {
+          if (chunk != NULL) snap[i].fn(snap[i].cb, chunk);
+        } else if (text != NULL) {
+          snap[i].str_fn(snap[i].cb, text);
+        } else if (snap[i].kind == SCR_STDIN_DATA_DYN) {
+          if (chunk != NULL) snap[i].fn(snap[i].cb, chunk);
+        } else {
+          static const char msg[] =
+              "stdin data listener type does not match setEncoding state";
+          scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+        }
+      }
+      scr_closure_release(snap[i].cb);
+    }
+    free(snap);
+  } else if (scr_stdin_waiter && chunk != NULL) {
+#else
       if (!scr_exc_pending()) snap[i].fn(snap[i].cb, chunk);
       scr_closure_release(snap[i].cb);
     }
     free(snap);
   } else if (scr_stdin_waiter) {
+#endif
     ScrPromise *p = scr_stdin_waiter;
     scr_stdin_waiter = NULL;
     scr_promise_fulfill_ref(p, scr_bytes_retain(chunk), scr_bytes_retain_v,
@@ -701,14 +818,31 @@ typedef struct {
   bool *error_once;
   size_t nerrors;
   ScrDyn *write_error;
+#ifdef SCR_STDIO_EXTENDED
+  /* 'resize' listeners (stdout/stderr) and the size they last saw. */
+  ScrDyn **resizes;
+  bool *resize_once;
+  size_t nresizes;
+  double columns, rows;
+#endif
 } ScrStdio;
 
 static SCR_TL ScrStdio scr_stdio_streams[3] = {{.fd = 0}, {.fd = 1}, {.fd = 2}};
+#ifdef SCR_STDIO_EXTENDED
+enum { STDIO_WRITE, STDIO_ON, STDIO_ONCE, STDIO_OFF, STDIO_PAUSE, STDIO_RESUME,
+       STDIO_IS_PAUSED, STDIO_READ, STDIO_RAW, STDIO_DESTROY, STDIO_WINDOW_SIZE,
+       STDIO_SET_ENCODING, STDIO_METHOD_COUNT };
+static const char *const scr_stdio_names[] = {
+  "write", "on", "once", "removeListener", "pause", "resume", "isPaused", "read", "setRawMode", "destroy", "getWindowSize",
+  "setEncoding"
+};
+#else
 enum { STDIO_WRITE, STDIO_ON, STDIO_ONCE, STDIO_OFF, STDIO_PAUSE, STDIO_RESUME,
        STDIO_IS_PAUSED, STDIO_READ, STDIO_RAW, STDIO_DESTROY, STDIO_WINDOW_SIZE, STDIO_METHOD_COUNT };
 static const char *const scr_stdio_names[] = {
   "write", "on", "once", "removeListener", "pause", "resume", "isPaused", "read", "setRawMode", "destroy", "getWindowSize"
 };
+#endif
 static SCR_TL ScrDyn *scr_stdio_methods[STDIO_METHOD_COUNT];
 static SCR_TL bool scr_stdio_initialized;
 static SCR_TL bool scr_stdio_raw;
@@ -736,6 +870,13 @@ static void scr_stdio_data(ScrClosure *cb, ScrBytes *bytes) {
   scr_stdio_fire(cb, chunk, 1);
   scr_dyn_release(chunk);
 }
+#ifdef SCR_STDIO_EXTENDED
+static void scr_stdio_data_text(ScrClosure *cb, ScrStr *text) {
+  ScrDyn *chunk = scr_dyn_new_str(text);
+  scr_stdio_fire(cb, chunk, 1);
+  scr_dyn_release(chunk);
+}
+#endif
 static void scr_stdio_end(ScrClosure *cb) { scr_stdio_fire(cb, NULL, 0); }
 static void scr_stdio_error(ScrClosure *cb, ScrStr *message) {
   ScrError *error = scr_error_new(SCR_ERR_ERROR, message);
@@ -861,6 +1002,95 @@ static ScrDyn *scr_stdio_read(ScrDyn *size) {
   return result;
 }
 
+#ifdef SCR_STDIO_EXTENDED
+/* 'resize' on a TTY stdout/stderr: Node's tty.WriteStream listens for
+ * SIGWINCH and emits 'resize' when the window size changed. The signal
+ * listener does not keep the loop alive, and a non-TTY stream never
+ * emits. */
+static SCR_TL ScrDyn *scr_stdio_winch = NULL;
+
+static void scr_stdio_resize_emit(ScrStdio *stream) {
+  size_t n = stream->nresizes;
+  if (n == 0) return;
+  ScrDyn **snap = malloc(n * sizeof *snap);
+  bool *once = malloc(n * sizeof *once);
+  if (!snap || !once) scr_events_oom();
+  for (size_t i = 0; i < n; i++) {
+    snap[i] = scr_dyn_retain(stream->resizes[i]);
+    once[i] = stream->resize_once[i];
+  }
+  for (size_t i = 0; i < n; i++) {
+    if (once[i]) {
+      for (size_t j = 0; j < stream->nresizes; j++) {
+        if (stream->resizes[j] == snap[i]) {
+          scr_dyn_release(stream->resizes[j]);
+          memmove(stream->resizes + j, stream->resizes + j + 1, (stream->nresizes - j - 1) * sizeof *stream->resizes);
+          memmove(stream->resize_once + j, stream->resize_once + j + 1, (stream->nresizes - j - 1) * sizeof *stream->resize_once);
+          stream->nresizes--;
+          break;
+        }
+      }
+    }
+    if (!scr_exc_pending()) {
+      scr_dyn_this_push(stream, SCR_DYNH_STDIO);
+      ScrDyn *r = scr_dyn_call(snap[i], NULL, 0, "listener");
+      scr_dyn_this_pop();
+      scr_dyn_release(r);
+    }
+    scr_dyn_release(snap[i]);
+  }
+  free(snap);
+  free(once);
+}
+
+static ScrDyn *scr_stdio_winch_fire(ScrClosure *cb, ScrDyn *const *args, size_t argc) {
+  (void)cb; (void)args; (void)argc;
+  for (int fd = 1; fd <= 2 && !scr_exc_pending(); fd++) {
+    ScrStdio *stream = &scr_stdio_streams[fd];
+    if (stream->nresizes == 0 || !scr_process_is_tty(fd)) continue;
+    double columns = scr_process_columns(fd), rows = scr_process_rows(fd);
+    if (columns == stream->columns && rows == stream->rows) continue;
+    stream->columns = columns;
+    stream->rows = rows;
+    scr_stdio_resize_emit(stream);
+  }
+  return scr_exc_pending() ? NULL : scr_dyn_retain(scr_dyn_undefined());
+}
+
+static void scr_stdio_resize_listener(ScrStdio *stream, ScrDyn *listener, bool remove, bool once) {
+  if (remove) {
+    for (size_t i = stream->nresizes; i > 0; i--) {
+      if (scr_dyn_strict_eq(stream->resizes[i - 1], listener)) {
+        scr_dyn_release(stream->resizes[i - 1]);
+        memmove(stream->resizes + i - 1, stream->resizes + i, (stream->nresizes - i) * sizeof *stream->resizes);
+        memmove(stream->resize_once + i - 1, stream->resize_once + i, (stream->nresizes - i) * sizeof *stream->resize_once);
+        stream->nresizes--;
+        break;
+      }
+    }
+    return;
+  }
+  if (stream->nresizes == 0) {
+    stream->columns = scr_process_columns(stream->fd);
+    stream->rows = scr_process_rows(stream->fd);
+  }
+  stream->resizes = realloc(stream->resizes, (stream->nresizes + 1) * sizeof *stream->resizes);
+  stream->resize_once = realloc(stream->resize_once, (stream->nresizes + 1) * sizeof *stream->resize_once);
+  if (!stream->resizes || !stream->resize_once) scr_events_oom();
+  stream->resizes[stream->nresizes] = scr_dyn_retain(listener);
+  stream->resize_once[stream->nresizes++] = once;
+#if !defined(_WIN32) && !defined(__wasi__)
+  if (scr_stdio_winch == NULL && scr_context_is_main()) {
+    ScrClosure *cb = scr_closure_new(NULL, 0);
+    scr_stdio_winch = scr_dyn_new_func(cb, scr_stdio_winch_fire, 0, "", "refreshSize");
+    ScrStr *name = scr_str_new("SIGWINCH", 8);
+    scr_signal_on(name, scr_stdio_winch, false);
+    scr_str_release(name);
+  }
+#endif
+}
+
+#endif
 static ScrDyn *scr_stdio_method(ScrClosure *cb, ScrDyn *const *args, size_t argc) {
   int method = (int)scr_box_get_f64(cb->caps[0]);
   ScrDyn *self = scr_dyn_this_get();
@@ -920,14 +1150,30 @@ static ScrDyn *scr_stdio_method(ScrClosure *cb, ScrDyn *const *args, size_t argc
     bool data = arg->kind == SCR_DYN_STR && arg->v.str->len == 4 && memcmp(event, "data", 4) == 0;
     bool end = arg->kind == SCR_DYN_STR && arg->v.str->len == 3 && memcmp(event, "end", 3) == 0;
     bool error = arg->kind == SCR_DYN_STR && arg->v.str->len == 5 && memcmp(event, "error", 5) == 0;
+#ifdef SCR_STDIO_EXTENDED
+    bool resize = stream->fd != 0 && arg->kind == SCR_DYN_STR && arg->v.str->len == 6 &&
+                  memcmp(event, "resize", 6) == 0;
+    if ((!data && !end && !error && !resize) || (stream->fd != 0 && !error && !resize)) {
+#else
     if ((!data && !end && !error) || (stream->fd != 0 && !error)) {
+#endif
       result = scr_stdio_refusal("event");
       goto done;
     }
     bool remove = method == STDIO_OFF, once = method == STDIO_ONCE;
+#ifdef SCR_STDIO_EXTENDED
+    if (resize) {
+      scr_stdio_resize_listener(stream, listener, remove, once);
+    } else if (stream->fd == 0) {
+      if (!remove) {
+        if (data)
+          scr_stdin_add_data(scr_stdio_callback(listener, (void *)scr_stdio_data), scr_stdio_data,
+                             scr_stdio_data_text, SCR_STDIN_DATA_DYN, once);
+#else
     if (stream->fd == 0) {
       if (!remove) {
         if (data) scr_stdin_on_data(scr_stdio_callback(listener, (void *)scr_stdio_data), scr_stdio_data, once);
+#endif
         if (end) scr_stdin_on_end(scr_stdio_callback(listener, (void *)scr_stdio_end), once);
         if (error) scr_stdin_on_error(scr_stdio_callback(listener, (void *)scr_stdio_error), scr_stdio_error, once);
       } else {
@@ -972,6 +1218,15 @@ static ScrDyn *scr_stdio_method(ScrClosure *cb, ScrDyn *const *args, size_t argc
   } else if (stream->fd == 0 && method == STDIO_RAW) {
     scr_process_stdin_set_raw_mode(scr_dyn_truthy(arg));
     if (!scr_exc_pending()) { scr_stdio_raw = scr_dyn_truthy(arg); result = scr_dyn_retain(self); }
+#ifdef SCR_STDIO_EXTENDED
+  } else if (stream->fd == 0 && method == STDIO_SET_ENCODING) {
+    ScrStr *enc = scr_strdec_encoding(arg);
+    if (enc) {
+      scr_stdin_set_encoding(enc);
+      scr_str_release(enc);
+      result = scr_dyn_retain(self);
+    }
+#endif
   } else if (stream->fd == 0 && method == STDIO_DESTROY && argc == 0) {
     scr_stdin_destroy();
     result = scr_dyn_retain(self);
@@ -1069,7 +1324,16 @@ static void scr_stdio_cleanup(void) {
     for (size_t j = 0; j < stream->nerrors; j++) scr_dyn_release(stream->errors[j]);
     free(stream->errors); free(stream->error_once);
     stream->errors = NULL; stream->error_once = NULL; stream->nerrors = 0;
+#ifdef SCR_STDIO_EXTENDED
+    for (size_t j = 0; j < stream->nresizes; j++) scr_dyn_release(stream->resizes[j]);
+    free(stream->resizes); free(stream->resize_once);
+    stream->resizes = NULL; stream->resize_once = NULL; stream->nresizes = 0;
+#endif
   }
+#ifdef SCR_STDIO_EXTENDED
+  scr_dyn_release(scr_stdio_winch);
+  scr_stdio_winch = NULL;
+#endif
   for (int i = 0; i < STDIO_METHOD_COUNT; i++) {
     scr_dyn_release(scr_stdio_methods[i]);
     scr_stdio_methods[i] = NULL;
@@ -1213,6 +1477,11 @@ void scr_stdin_data_thunk_bytes(ScrClosure *cb, ScrBytes *chunk) {
   /* The listener owns its +1 param per the universal convention. */
   ((void (*)(ScrClosure *, ScrBytes *))cb->fn)(cb, scr_bytes_retain(chunk));
 }
+#ifdef SCR_STDIO_EXTENDED
+void scr_stdin_data_thunk_str(ScrClosure *cb, ScrStr *text) {
+  ((void (*)(ScrClosure *, ScrStr *))cb->fn)(cb, scr_str_retain(text));
+}
+#endif
 
 
 /* ── the loop hooks (see scr_async.c) ─────────────────────────────────── */
diff --git a/packages/runtime/src/scr_events.h b/packages/runtime/src/scr_events.h
index 7dcf9cda0b..a0025783e3 100644
--- a/packages/runtime/src/scr_events.h
+++ b/packages/runtime/src/scr_events.h
@@ -42,6 +42,13 @@ void scr_run_exit_listeners(double code);
 void scr_exit_thunk0(ScrClosure *cb, double code);
 void scr_exit_thunk_code(ScrClosure *cb, double code);
 void scr_stdin_on_data(ScrClosure *cb, void (*fn)(ScrClosure *, ScrBytes *), bool once);
+/* A string 'data' listener (moves cb): receives each chunk decoded by the
+ * stdin's setEncoding decoder; with no encoding set, a delivery throws
+ * the setEncoding-state TypeError instead (Node would pass a Buffer). */
+void scr_stdin_on_data_str(ScrClosure *cb, void (*fn)(ScrClosure *, ScrStr *), bool once);
+/* process.stdin.setEncoding: the canonical encoding (borrowed). */
+void scr_stdin_set_encoding(ScrStr *enc);
+void scr_stdin_data_thunk_str(ScrClosure *cb, ScrStr *text);
 void scr_stdin_on_end(ScrClosure *cb, bool once);
 void scr_stdin_on_error(ScrClosure *cb, ScrChildErrFn fn, bool once);
 ScrPromise *scr_stdin_next_chunk(void); /* +1 */
diff --git a/tests/corpus/6231-process-emit-warning-assign.ts b/tests/corpus/6231-process-emit-warning-assign.ts
new file mode 100644
index 0000000000..1cae44f82f
--- /dev/null
+++ b/tests/corpus/6231-process-emit-warning-assign.ts
@@ -0,0 +1,35 @@
+// process.emitWarning and process.title are ordinary writable properties
+// (pi's CLI setup assigns both). After the replacement, process.emitWarning
+// calls reach it with their own arguments, no report reaches stderr, and
+// the warnings Node's own modules emit through process.emitWarning (a
+// util.deprecate wrapper's first call) reach it too.
+import { deprecate } from "node:util";
+
+process.title = "pi";
+console.log("title", process.title);
+process.env.PI_CODING_AGENT = "true";
+console.log("env", process.env.PI_CODING_AGENT);
+
+const seen: string[] = [];
+process.on("warning", (w) => seen.push(`listener ${w.name}`));
+function show(a: unknown): string {
+  if (a instanceof Error) return `Error(${a.message})`;
+  return typeof a === "object" ? JSON.stringify(a) : String(a);
+}
+process.emitWarning = ((warning: unknown, type: unknown, code: unknown) => {
+  seen.push(`${show(warning)}|${show(type)}|${show(code)}`);
+}) as typeof process.emitWarning;
+
+process.emitWarning("plain");
+process.emitWarning("typed", "CustomWarning", "CW_1");
+process.emitWarning("options", { type: "OptWarning", code: "OW_1", detail: "d" });
+process.emitWarning(new Error("as error"));
+const old = deprecate(() => "result", "old() is deprecated", "DEP_SCRIPTC_1");
+console.log("deprecated call", old());
+console.log("second call", old());
+console.log("sync", seen.join(" ; "));
+
+// A replacement that does nothing silences warnings entirely.
+process.emitWarning = (() => {}) as typeof process.emitWarning;
+process.emitWarning("silenced");
+setTimeout(() => console.log("after tick", seen.length), 0);
diff --git a/tests/corpus/6232-process-builtin-module-typed/main.ts b/tests/corpus/6232-process-builtin-module-typed/main.ts
new file mode 100644
index 0000000000..7765bd228a
--- /dev/null
+++ b/tests/corpus/6232-process-builtin-module-typed/main.ts
@@ -0,0 +1,28 @@
+// process.getBuiltinModule and process.features under @types/node: a
+// literal id types as the module namespace, so the result is the same
+// object `import * as os` binds (pi's user-agent probe casts process and
+// calls the member optionally), and process.features is an object a
+// feature probe can test with `in` (pi's single-executable check).
+import * as os from "node:os";
+import type * as NodeOs from "node:os";
+
+const direct = process.getBuiltinModule("node:os");
+console.log("direct", direct.platform() === os.platform(), direct.EOL === os.EOL);
+console.log("bare id", process.getBuiltinModule("os").arch() === os.arch());
+
+type ProcessWithOsBuiltinModule = typeof process & {
+  getBuiltinModule?: (id: "node:os") => typeof NodeOs;
+};
+function loadNodeOs(): typeof NodeOs | null {
+  if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+    return null;
+  }
+  return (process as ProcessWithOsBuiltinModule).getBuiltinModule?.("node:os") ?? null;
+}
+const nodeOs = loadNodeOs();
+const agent = nodeOs ? `pi (${nodeOs.platform()} ${nodeOs.release()}; ${nodeOs.arch()})` : "pi (browser)";
+console.log("agent", agent === `pi (${os.platform()} ${os.release()}; ${os.arch()})`);
+console.log("present", nodeOs !== null, nodeOs ? typeof nodeOs.homedir() : "none");
+
+const isNodeSeaBinary = "sea" in process.features && process.features.sea === true;
+console.log("sea", isNodeSeaBinary, "sea" in process.features);
diff --git a/tests/corpus/6232-process-builtin-module-typed/package.json b/tests/corpus/6232-process-builtin-module-typed/package.json
new file mode 100644
index 0000000000..5ffd9800b9
--- /dev/null
+++ b/tests/corpus/6232-process-builtin-module-typed/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
diff --git a/tests/corpus/6232-process-builtin-module-typed/tsconfig.json b/tests/corpus/6232-process-builtin-module-typed/tsconfig.json
new file mode 100644
index 0000000000..ae4eda1945
--- /dev/null
+++ b/tests/corpus/6232-process-builtin-module-typed/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true
+  }
+}
diff --git a/tests/corpus/6233-for-await-class-async-generator.ts b/tests/corpus/6233-for-await-class-async-generator.ts
new file mode 100644
index 0000000000..1a88df7e87
--- /dev/null
+++ b/tests/corpus/6233-for-await-class-async-generator.ts
@@ -0,0 +1,168 @@
+// `for await` over a class instance whose [Symbol.asyncIterator] is an
+// async generator method — pi-ai's EventStream, which is how every
+// provider stream is consumed: a generic push/end queue, a subclass, the
+// protocol-interface return annotations, producers that run between
+// iterations, early exit (the generator's finally runs), and errors.
+class FifoQueue<T> {
+  private incoming: T[] = [];
+  private outgoing: T[] = [];
+
+  get length(): number {
+    return this.incoming.length + this.outgoing.length;
+  }
+
+  enqueue(value: T): void {
+    this.incoming.push(value);
+  }
+
+  dequeue(): T | undefined {
+    if (this.outgoing.length === 0) {
+      while (this.incoming.length > 0) {
+        this.outgoing.push(this.incoming.pop()!);
+      }
+    }
+    return this.outgoing.pop();
+  }
+}
+
+class EventStream<T, R = T> implements AsyncIterable<T> {
+  private queue = new FifoQueue<T>();
+  private waiting = new FifoQueue<(value: IteratorResult<T>) => void>();
+  protected done = false;
+  private finalResultPromise: Promise<R>;
+  private resolveFinalResult!: (result: R) => void;
+  private isComplete: (event: T) => boolean;
+  private extractResult: (event: T) => R;
+
+  constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R) {
+    this.isComplete = isComplete;
+    this.extractResult = extractResult;
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+
+  push(event: T): void {
+    if (this.done) return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      this.resolveFinalResult(this.extractResult(event));
+    }
+    const waiter = this.waiting.dequeue();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.enqueue(event);
+    }
+  }
+
+  end(result?: R): void {
+    this.done = true;
+    if (result !== undefined) {
+      this.resolveFinalResult(result);
+    }
+    while (this.waiting.length > 0) {
+      const waiter = this.waiting.dequeue()!;
+      waiter({ value: undefined as any, done: true });
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<T> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.dequeue()!;
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise<IteratorResult<T>>((resolve) => this.waiting.enqueue(resolve));
+        if (result.done) return;
+        yield result.value;
+      }
+    }
+  }
+
+  result(): Promise<R> {
+    return this.finalResultPromise;
+  }
+}
+
+type Event = { type: "text"; delta: string } | { type: "done"; text: string };
+
+class TextStream extends EventStream<Event, string> {
+  constructor() {
+    super(
+      (event) => event.type === "done",
+      (event) => (event.type === "done" ? event.text : ""),
+    );
+  }
+}
+
+function produce(stream: TextStream, words: string[]): void {
+  let i = 0;
+  const step = (): void => {
+    if (i < words.length) {
+      stream.push({ type: "text", delta: words[i]! });
+      i++;
+      setTimeout(step, 1);
+    } else {
+      stream.push({ type: "done", text: words.join("") });
+    }
+  };
+  step();
+}
+
+class Ticker {
+  log: string[] = [];
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<number> {
+    try {
+      for (let n = 1; n <= 5; n++) {
+        this.log.push(`yield ${n}`);
+        yield n;
+      }
+    } finally {
+      this.log.push("closed");
+    }
+  }
+}
+
+class Failing {
+  async *[Symbol.asyncIterator](): AsyncGenerator<string> {
+    yield "first";
+    throw new Error("stream failed");
+  }
+}
+
+async function main(): Promise<void> {
+  const stream = new TextStream();
+  produce(stream, ["Hello", " from", " the", " stub"]);
+  let text = "";
+  for await (const event of stream) {
+    if (event.type === "text") text += event.delta;
+    else console.log("done event", event.text);
+  }
+  console.log("streamed", JSON.stringify(text), "result", await stream.result());
+
+  // Events queued before iteration starts, then end() with no consumer waiting.
+  const early = new TextStream();
+  early.push({ type: "text", delta: "a" });
+  early.push({ type: "text", delta: "b" });
+  early.end("ab");
+  const seen: string[] = [];
+  for await (const event of early) seen.push(event.type === "text" ? event.delta : "?");
+  console.log("queued", seen.join(","), await early.result());
+
+  // break closes the generator: its finally runs before the loop exits.
+  const ticker = new Ticker();
+  for await (const n of ticker) {
+    if (n === 3) break;
+  }
+  console.log("ticker", ticker.log.join(" | "));
+
+  // A throw from the generator rejects the loop.
+  try {
+    for await (const s of new Failing()) console.log("got", s);
+  } catch (e) {
+    console.log("caught", (e as Error).message);
+  }
+}
+main();
diff --git a/tests/corpus/6234-weak-collection-class-fields.ts b/tests/corpus/6234-weak-collection-class-fields.ts
new file mode 100644
index 0000000000..d7a0859212
--- /dev/null
+++ b/tests/corpus/6234-weak-collection-class-fields.ts
@@ -0,0 +1,39 @@
+// WeakMap- and WeakSet-typed class fields (pi's AgentSession keys entry ids by
+// message object): initialized, optional, and constructor-assigned fields hold
+// the native weak collections like locals of those types.
+class Session {
+  private readonly _entryIdsByMessage = new WeakMap<object, string>();
+  private seen = new WeakSet<object>();
+  cache: WeakMap<object, number> | undefined;
+  record(message: object, id: string): void {
+    this._entryIdsByMessage.set(message, id);
+    this.seen.add(message);
+  }
+  idOf(message: object): string | undefined {
+    return this._entryIdsByMessage.get(message);
+  }
+  has(message: object): boolean {
+    return this.seen.has(message) && this._entryIdsByMessage.has(message);
+  }
+}
+const s = new Session();
+const a = { role: "user" };
+const b = { role: "assistant" };
+s.record(a, "e1");
+console.log(s.idOf(a), s.idOf(b), s.has(a), s.has(b));
+s.cache = new WeakMap();
+s.cache.set(a, 1);
+console.log(s.cache.get(a), s.cache.has(b), s.cache instanceof WeakMap);
+class Registry {
+  private readonly names: WeakMap<object, string>;
+  constructor(names: WeakMap<object, string>) {
+    this.names = names;
+  }
+  name(o: object): string {
+    return this.names.get(o) ?? "(unnamed)";
+  }
+}
+const names = new WeakMap<object, string>();
+names.set(a, "alice");
+const registry = new Registry(names);
+console.log(registry.name(a), registry.name(b));
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/helper.cjs b/tests/corpus/6235-bare-builtin-shadowed-package/helper.cjs
new file mode 100644
index 0000000000..8e0a0457cc
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/helper.cjs
@@ -0,0 +1,6 @@
+// A CommonJS require of the bare names resolves to the builtins too.
+const { StringDecoder } = require("string_decoder");
+exports.decodeEuro = () => {
+  const d = new StringDecoder("utf8");
+  return d.write(Buffer.from([0xe2, 0x82])) + d.end(Buffer.from([0xac]));
+};
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/main.ts b/tests/corpus/6235-bare-builtin-shadowed-package/main.ts
new file mode 100644
index 0000000000..e9e83ea872
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/main.ts
@@ -0,0 +1,17 @@
+// A bare core-module specifier names the Node builtin even when an npm
+// package of the same name is installed (pi depends on string_decoder
+// transitively): Node checks its builtins before node_modules.
+import { StringDecoder } from "string_decoder";
+import { EventEmitter } from "events";
+import { createRequire } from "node:module";
+
+const decoder = new StringDecoder("utf8");
+console.log(decoder.write(Buffer.from([0xe2, 0x82])) + decoder.end(Buffer.from([0xac])));
+
+const emitter = new EventEmitter();
+emitter.on("ping", (n: number) => console.log("ping", n));
+emitter.emit("ping", 1);
+
+const require = createRequire(import.meta.url);
+const helper = require("./helper.cjs") as { decodeEuro(): string };
+console.log("cjs", helper.decodeEuro());
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/events/events.js b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/events/events.js
new file mode 100644
index 0000000000..f1a344ef11
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/events/events.js
@@ -0,0 +1 @@
+throw new Error("the npm events package was loaded");
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/events/package.json b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/events/package.json
new file mode 100644
index 0000000000..0fb1a3c8aa
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/events/package.json
@@ -0,0 +1 @@
+{ "name": "events", "version": "3.3.0", "main": "events.js" }
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/string_decoder/index.js b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/string_decoder/index.js
new file mode 100644
index 0000000000..02af46d5ac
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/string_decoder/index.js
@@ -0,0 +1,3 @@
+// An installed package named like the core module: Node never loads it
+// for the bare specifier.
+throw new Error("the npm string_decoder package was loaded");
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/string_decoder/package.json b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/string_decoder/package.json
new file mode 100644
index 0000000000..ad07adde83
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/node_modules/string_decoder/package.json
@@ -0,0 +1 @@
+{ "name": "string_decoder", "version": "1.3.0", "main": "index.js" }
diff --git a/tests/corpus/6235-bare-builtin-shadowed-package/package.json b/tests/corpus/6235-bare-builtin-shadowed-package/package.json
new file mode 100644
index 0000000000..5ffd9800b9
--- /dev/null
+++ b/tests/corpus/6235-bare-builtin-shadowed-package/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
diff --git a/tests/corpus/6236-stdin-encoding-tty-probes/main.ts b/tests/corpus/6236-stdin-encoding-tty-probes/main.ts
new file mode 100644
index 0000000000..0fbe7eb99e
--- /dev/null
+++ b/tests/corpus/6236-stdin-encoding-tty-probes/main.ts
@@ -0,0 +1,62 @@
+// pi-tui's terminal setup on a piped stdin: the `if (process.stdin.setRawMode)`
+// presence check (the method exists only on a TTY), setEncoding with a
+// string 'data' listener whose chunks keep multibyte characters split
+// across writes whole, and stdout 'resize' listeners (registered,
+// removed, never fired off a TTY). The program re-runs itself with a
+// pipe so the parent controls the write boundaries.
+import { spawn } from "node:child_process";
+
+if (process.argv[2] === "child") {
+  console.log("raw present", typeof process.stdin.setRawMode, Boolean(process.stdin.setRawMode));
+  if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+  process.stdin.setEncoding("utf8");
+  const onResize = (): void => console.log("resize", process.stdout.columns);
+  process.stdout.on("resize", onResize);
+  process.stdout.once("resize", onResize);
+  process.stdout.removeListener("resize", onResize);
+  let total = "";
+  let replacement = false;
+  process.stdin.on("data", (data: string) => {
+    if (typeof data !== "string") console.log("not a string");
+    if (data.includes("�")) replacement = true;
+    total += data;
+  });
+  process.stdin.on("end", () => {
+    console.log("end", JSON.stringify(total), "replacement", replacement);
+    process.stdout.removeListener("resize", onResize);
+  });
+  process.stdin.resume();
+  // Off a TTY no stream listens for SIGWINCH and its default is to ignore.
+  process.kill(process.pid, "SIGWINCH");
+} else {
+  const child = spawn(process.execPath, [process.argv[1]!, "child"], {
+    stdio: ["pipe", "pipe", "inherit"],
+  });
+  let out = "";
+  child.stdout!.setEncoding("utf8");
+  child.stdout!.on("data", (chunk: string) => {
+    out += chunk;
+  });
+  child.on("close", (code: number | null) => {
+    process.stdout.write(out);
+    console.log("child exit", code);
+  });
+  const parts = [
+    Buffer.from([0x68, 0xc3]),
+    Buffer.from([0xa9, 0x6c, 0x6c, 0x6f, 0x20, 0xe2, 0x82]),
+    Buffer.from([0xac, 0x20, 0xf0, 0x9f]),
+    Buffer.from([0x98, 0x80, 0x21]),
+  ];
+  let i = 0;
+  const next = (): void => {
+    if (i < parts.length) {
+      const part: Buffer = parts[i]!;
+      i++;
+      child.stdin!.write(part);
+      setTimeout(next, 30);
+    } else {
+      child.stdin!.end();
+    }
+  };
+  next();
+}
diff --git a/tests/corpus/6236-stdin-encoding-tty-probes/package.json b/tests/corpus/6236-stdin-encoding-tty-probes/package.json
new file mode 100644
index 0000000000..5ffd9800b9
--- /dev/null
+++ b/tests/corpus/6236-stdin-encoding-tty-probes/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
diff --git a/tests/corpus/6236-stdin-encoding-tty-probes/tsconfig.json b/tests/corpus/6236-stdin-encoding-tty-probes/tsconfig.json
new file mode 100644
index 0000000000..ae4eda1945
--- /dev/null
+++ b/tests/corpus/6236-stdin-encoding-tty-probes/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true
+  }
+}
diff --git a/tests/corpus/6237-error-subclass-delete-stack/main.js b/tests/corpus/6237-error-subclass-delete-stack/main.js
new file mode 100644
index 0000000000..96ca7593de
--- /dev/null
+++ b/tests/corpus/6237-error-subclass-delete-stack/main.js
@@ -0,0 +1,12 @@
+// Deleting `stack` on an Error subclass that declares a stack accessor
+// lets reads reach the accessor (the package's guest exceptions).
+import { GuestError } from "guest-error";
+
+try {
+  throw new GuestError(7);
+} catch (e) {
+  console.log(e instanceof GuestError, e instanceof Error, e.handle, e.message);
+  console.log(e.stack);
+  e.stack = "rewritten";
+  console.log(e.stack, Object.keys(e));
+}
diff --git a/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/index.d.ts b/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/index.d.ts
new file mode 100644
index 0000000000..7f3b83f94b
--- /dev/null
+++ b/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/index.d.ts
@@ -0,0 +1,6 @@
+export declare class GuestError extends Error {
+  handle: number;
+  constructor(handle: number);
+  get stack(): string;
+  set stack(v: string);
+}
diff --git a/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/index.js b/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/index.js
new file mode 100644
index 0000000000..693c06b510
--- /dev/null
+++ b/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/index.js
@@ -0,0 +1,18 @@
+// quickjs-wasi's JSException shape: an Error subclass whose stack
+// accessor pair the constructor exposes by deleting V8's own `stack`.
+export class GuestError extends Error {
+  handle;
+  #stack;
+  constructor(handle) {
+    super("guest error " + handle);
+    this.handle = handle;
+    delete this.stack;
+    this.#stack = "guest stack " + handle;
+  }
+  get stack() {
+    return this.#stack;
+  }
+  set stack(v) {
+    this.#stack = v;
+  }
+}
diff --git a/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/package.json b/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/package.json
new file mode 100644
index 0000000000..99f59d07bf
--- /dev/null
+++ b/tests/corpus/6237-error-subclass-delete-stack/node_modules/guest-error/package.json
@@ -0,0 +1 @@
+{"name": "guest-error", "version": "1.0.0", "type": "module", "main": "index.js", "types": "index.d.ts"}
diff --git a/tests/corpus/6237-error-subclass-delete-stack/package.json b/tests/corpus/6237-error-subclass-delete-stack/package.json
new file mode 100644
index 0000000000..5ffd9800b9
--- /dev/null
+++ b/tests/corpus/6237-error-subclass-delete-stack/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
diff --git a/tests/diagnostics/deferred-class-receiver/shelf.ts b/tests/diagnostics/deferred-class-receiver/shelf.ts
index 1308ce5dc6..d0fba73b3b 100644
--- a/tests/diagnostics/deferred-class-receiver/shelf.ts
+++ b/tests/diagnostics/deferred-class-receiver/shelf.ts
@@ -1,6 +1,6 @@
 export class Shelf {
   readonly name: string;
-  private readonly notes = new WeakMap<object, string>();
+  private readonly cursor = new Map<string, number>().keys();
   constructor(name: string) {
     this.name = name;
   }
diff --git a/tests/fixtures/npm/cases/chalk5/main.ts b/tests/fixtures/npm/cases/chalk5/main.ts
index 6a33a1466d..0bfa806c16 100644
--- a/tests/fixtures/npm/cases/chalk5/main.ts
+++ b/tests/fixtures/npm/cases/chalk5/main.ts
@@ -15,6 +15,13 @@ console.log(modifierNames.join(","));
 console.log(foregroundColorNames.length + " " + backgroundColorNames.length + " " + colorNames.length);
 
 show("red", chalk.red("red"));
+// Root members named like String.prototype's HTML methods, called from
+// TypeScript (pi's `chalk.bold(APP_NAME)`): the checker types chalk's
+// JavaScript default export as a plain function, so the member is `any`.
+show("bold", chalk.bold("bold"));
+show("bold template", `${chalk.bold("Usage:")} pi`);
+const alias = chalk;
+show("bold alias", alias.bold("alias") + alias.italic("i"));
 show("red.bold", chalk.red.bold("bold red"));
 show("nested", chalk.blue("a " + chalk.red("b") + " c"));
 show("multi-arg", chalk.green("one", "two", 3));
@@ -36,6 +43,7 @@ show("gray-grey", chalk.gray("x") + chalk.grey("y"));
 for (const level of [0, 1, 2, 3] as const) {
   const c = new Chalk({ level });
   show(`L${level} red.bold`, c.red.bold("x"));
+  show(`L${level} bold`, c.bold("x"));
   show(`L${level} hex`, c.hex("#123456")("x"));
   show(`L${level} rgb`, c.rgb(255, 255, 255).bgRgb(0, 0, 0)("x"));
   show(`L${level} ansi256`, c.ansi256(100).bgAnsi256(200)("x"));
diff --git a/tests/harness/__snapshots__/deferred-class-receiver/main.ts.txt b/tests/harness/__snapshots__/deferred-class-receiver/main.ts.txt
index 0e9cab090c..9097951746 100644
--- a/tests/harness/__snapshots__/deferred-class-receiver/main.ts.txt
+++ b/tests/harness/__snapshots__/deferred-class-receiver/main.ts.txt
@@ -5,9 +5,9 @@ deferred-class-receiver/main.ts:4:10 - error SC1090: constructing through a clas
     |          ^~~~~~~~~~~~~~~
   5 | }
 
-deferred-class-receiver/shelf.ts:3:20 - error SC1090: 'WeakMap<object, string>'-typed class fields are not supported yet
+deferred-class-receiver/shelf.ts:3:20 - error SC1090: 'MapIterator<string>'-typed class fields are not supported yet
 
   2 |   readonly name: string;
-  3 |   private readonly notes = new WeakMap<object, string>();
-    |                    ^~~~~
+  3 |   private readonly cursor = new Map<string, number>().keys();
+    |                    ^~~~~~
   4 |   constructor(name: string) {
\ No newline at end of file
diff --git a/tests/harness/coverage.test.ts b/tests/harness/coverage.test.ts
index 8cf5d6719b..b1e25dead6 100644
--- a/tests/harness/coverage.test.ts
+++ b/tests/harness/coverage.test.ts
@@ -421,7 +421,7 @@ test("a rejected class reached only through a receiver probe reports its own dia
   const { coverage } = analyze(join(repoRoot, "tests/diagnostics/deferred-class-receiver/main.ts"));
   const messages = coverage.diagnostics.map((d) => d.message);
   expect(
-    messages.filter((m) => m.startsWith("'WeakMap<object, string>'-typed class fields")),
+    messages.filter((m) => m.startsWith("'MapIterator<string>'-typed class fields")),
   ).toHaveLength(1);
   expect(messages.some((m) => m.startsWith("constructing through a class value"))).toBe(true);
   expect(coverage.unreached?.diagnostics ?? []).toEqual([]);