@scriptc/compiler 0.4.6 → 0.4.8

package/dist/frontend/type-mapper.js

@@ -1,5 +1,6 @@
 import { InternalCompilerError } from "../errors.js";
 import { keyedHelperName } from "./lowering/stable-names.js";
+import { contentDigest } from "./lowering/unit-journal.js";
 import { mockCallRecordType, mockContextType } from "./mock-shapes.js";
 import * as ts from "./ts7/adapter.js";
 import { bodyReadsArguments } from "./arguments-usage.js";
@@ -154,8 +155,10 @@ export const FETCH_AMBIENT_TYPES = [
     "ReadableStreamReadValueResult",
     "ReadableStreamReadDoneResult",
     "TransformStream",
+    "TransformStreamDefaultController",
     "WritableStream",
     "WritableStreamDefaultWriter",
+    "WritableStreamDefaultController",
     "Blob",
     "File",
     "BlobPropertyBag",
@@ -587,9 +590,41 @@ export class UnionRegistry {
      * the key its arms give. A unit that adds a recursive union changes
      * journalSizes, so the unions past a unit's start are interned ones. */
     journalTable() {
+        // The position of each union by id, for the unions indexed so far.
+        let indexes = new Map();
+        let indexed = 0;
+        const indexOf = (id) => {
+            if (indexed > this.unions.length) {
+                indexes = new Map();
+                indexed = 0;
+            }
+            for (; indexed < this.unions.length; indexed++)
+                indexes.set(this.unions[indexed].id, indexed);
+            const index = indexes.get(id);
+            return index !== undefined && this.unions[index]?.id === id ? index : undefined;
+        };
         return {
             name: "unions",
             size: () => this.unions.length,
+            digest: (key, before) => {
+                if (!this.byId.has(key))
+                    return null;
+                let index = indexOf(key);
+                if (index === undefined) {
+                    // A list that was cut and grown again holds other unions at the
+                    // positions indexed before.
+                    indexes = new Map();
+                    indexed = 0;
+                    index = indexOf(key);
+                }
+                if (index === undefined || index >= before)
+                    return null;
+                return contentDigest(JSON.stringify(this.unions[index]));
+            },
+            holds: (entry) => {
+                const def = JSON.parse(entry);
+                return this.byKey.has(unionKey(def.arms, def.discriminant));
+            },
             entries: (from) => {
                 const out = [];
                 for (const def of this.unions.slice(from)) {
@@ -601,6 +636,11 @@ export class UnionRegistry {
                 }
                 return out;
             },
+            agrees: (entries) => entries.every((entry) => {
+                const def = JSON.parse(entry);
+                const held = this.byKey.get(unionKey(def.arms, def.discriminant));
+                return held === undefined ? !this.byId.has(def.id) : held === def.id;
+            }),
             apply: (entries) => {
                 for (const entry of entries) {
                     const def = JSON.parse(entry);
@@ -1106,11 +1146,57 @@ export function isDeclaredInAmbientNamespace(d, name) {
     }
     return false;
 }
+/** The answers provenanceOf has given, keyed by symbol. The lowering owns
+ * one map through TypeMapperCtx.symbolProvenance; a symbol belongs to one
+ * loaded program, so one island round shares the map across its passes
+ * (lowering-facts.ts). */
+export function newSymbolProvenanceMemo() {
+    return new Map();
+}
+/** A symbol's provenance, computed from its declarations alone: the answer
+ * depends on which files declare it and nothing else, so it is the same for
+ * every lowering pass of one loaded program (lowering-facts.ts shares the
+ * memo). */
+export function computeSymbolProvenance(psym, isStdlibFile) {
+    let stdlibInterface = false;
+    let stdlibClass = false;
+    let libInterface = false;
+    for (const decl of psym.declarations) {
+        const file = ts.getSourceFileOfNode(decl);
+        if (!isStdlibFile(file))
+            continue;
+        if (ts.isInterfaceDeclaration(decl)) {
+            stdlibInterface = true;
+            stdlibClass = true;
+            if (!isNodeTypesPath(file.fileName))
+                libInterface = true;
+        }
+        else if (ts.isClassDeclaration(decl)) {
+            stdlibClass = true;
+        }
+    }
+    return { stdlibInterface, stdlibClass, libInterface };
+}
+function provenanceOf(psym, ctx) {
+    let bySymbol = ctx.symbolProvenance;
+    if (bySymbol === undefined) {
+        bySymbol = new Map();
+        ctx.symbolProvenance = bySymbol;
+    }
+    let provenance = bySymbol.get(psym);
+    if (provenance === undefined) {
+        provenance = computeSymbolProvenance(psym, ctx.isStdlibFile);
+        bySymbol.set(psym, provenance);
+    }
+    else
+        ctx.verifySymbolProvenance?.(psym, provenance);
+    return provenance;
+}
 /** Whether `type` is one of the stream spellings the general stream
  * representation (TypeMapperCtx.generalNodeStreams) maps differently:
  * NodeJS.ReadableStream / NodeJS.WritableStream, @types/node's
  * stream.Readable / stream.Writable, or the fallback declarations'
- * ChildStdin. */
+ * ChildStdin / ChildStdout. */
 export function isGeneralNodeStreamInterface(type, ctx) {
     const psym = type.getSymbol() ?? type.getAliasSymbol();
     if (psym === undefined)
@@ -1122,13 +1208,21 @@ export function isGeneralNodeStreamInterface(type, ctx) {
             return false;
         if (ts.symbolName(psym) === "ReadableStream" || ts.symbolName(psym) === "WritableStream")
             return ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS");
-        if (ts.symbolName(psym) === "ChildStdin")
+        if (ts.symbolName(psym) === "ChildStdin" || ts.symbolName(psym) === "ChildStdout")
             return isDeclaredInAmbientModule(d, "child_process");
         return ((ts.symbolName(psym) === "Readable" || ts.symbolName(psym) === "Writable") &&
             isNodeTypesPath(ts.getSourceFileOfNode(d).fileName) &&
             isDeclaredInAmbientModule(d, "stream"));
     });
 }
+/** Whether any declaration of the symbol sits in the shipped WebAssembly
+ * namespace (scriptc.d.ts). Like the declaration-kind walk, the answer is a
+ * function of the declarations alone, so provenanceOf's shared memo can keep
+ * it (SymbolProvenance.webAssembly). */
+export function declaresWebAssemblyNamespace(declarations, isStdlibFile) {
+    return declarations.some((d) => isStdlibFile(ts.getSourceFileOfNode(d)) &&
+        isDeclaredInAmbientNamespace(d, "WebAssembly"));
+}
 /** A type declared in the shipped WebAssembly namespace (scriptc.d.ts):
  * its modules, instances, memories, tables, globals, error classes and the
  * Exports/Imports records. */
@@ -1136,8 +1230,9 @@ export function isWebAssemblyType(type, ctx) {
     const symbol = type.getAliasSymbol() ?? type.getSymbol();
     if (!symbol)
         return false;
-    return symbol.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
-        isDeclaredInAmbientNamespace(d, "WebAssembly"));
+    const provenance = provenanceOf(symbol, ctx);
+    provenance.webAssembly ??= declaresWebAssemblyNamespace(symbol.declarations, ctx.isStdlibFile);
+    return provenance.webAssembly;
 }
 /** True when a type contains a record anywhere (the trigger for the
  * shape-mismatch diagnostic SC2002 — non-record mismatches are tsc's or
@@ -1251,6 +1346,37 @@ let mapTypeDepth = 0;
  * a bump between entry and exit stays fenced (recursive generic-open types
  * stay fenced instead of interning a per-context-wrong shape). */
 let contextResolutions = 0;
+/** Bumped whenever a mapping reads state that only a generic-INSTANTIATION
+ * scope installs: a type-parameter binding (the Lowerer's resolver hooks,
+ * consulted whether or not bindings are installed right now — the same
+ * checker type parameter answers differently with and without them), the
+ * instance's result class, or the local-class instantiation stack. The
+ * answer of such a mapping can differ from one instance to the next, so it
+ * stays in that scope's memo (Lowerer.currentTypeMemo). A mapping that reads
+ * none of it is the answer every scope gives, and may serve all of them
+ * (TypeMapperCtx.typeMemoShared). */
+let scopeSensitivity = 0;
+/** Notes that the mapping in progress read generic-instantiation scope state. */
+export function noteScopeSensitiveMapping() {
+    scopeSensitivity++;
+}
+/** SCRIPTC_TYPE_MEMO_VERIFY=1: every hit on a shared (scope-independent)
+ * memo entry is recomputed from scratch in the scope that took it and
+ * compared. A mismatch is a miscompile the sharing would have introduced,
+ * so the mode throws instead of quietly recomputing: it exists to prove the
+ * sharing on a corpus, never to rescue it at run time. `=stats` also prints
+ * how many hits it checked when the process exits. */
+const verifyMemoMode = process.env["SCRIPTC_TYPE_MEMO_VERIFY"] ?? "";
+const verifySharedTypeMemo = verifyMemoMode === "1" || verifyMemoMode === "stats";
+let verifiedSharedHits = 0;
+if (verifyMemoMode === "stats") {
+    process.on("exit", () => {
+        process.stderr.write(`[type-memo] verified ${verifiedSharedHits} shared memo hits\n`);
+    });
+}
+/** Set while verifying, so the recomputation bypasses every memo and does
+ * not verify itself. */
+let bypassTypeMemo = false;
 /** node:url's legacy record interfaces: url.parse()'s Url instance (and
  * its two query-typed refinements), url.format()'s UrlObject input, the
  * URL form's URLFormatOptions, and urlToHttpOptions's result. The values
@@ -1274,7 +1400,15 @@ export function isLegacyUrlType(type, ctx) {
 export function isLegacyUrlSymbol(symbol, ctx) {
     if (!symbol)
         return false;
-    for (const d of symbol.declarations) {
+    const provenance = provenanceOf(symbol, ctx);
+    provenance.legacyUrl ??= declaresLegacyUrl(symbol.declarations, ctx);
+    return provenance.legacyUrl;
+}
+/** Whether any declaration of the symbol is one of node:url's legacy record
+ * interfaces (or a member of one). A function of the declarations alone,
+ * stored as SymbolProvenance.legacyUrl in provenanceOf's shared memo. */
+export function declaresLegacyUrl(declarations, ctx) {
+    for (const d of declarations) {
         if (!ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
             continue;
         let family = false;
@@ -1646,12 +1780,34 @@ function mapTypeEntry(type, ctx) {
     // arm (emptyLiteralArm) and to the checked-dynamic value elsewhere: the two
     // answers keep separate memo entries. Type ids are non-negative integers.
     const memoKey = memoizable ? typeId * 2 + (ctx.emptyLiteralArm ? 1 : 0) : null;
-    if (memoKey !== null) {
-        const memo = ctx.typeMemo?.get(memoKey);
-        if (memo !== undefined)
-            return memo;
+    /** The memo of the binding context this frame started in: the scope's own
+     * inside generic bindings, the lowerer's top-level memo outside them. */
+    let contextMemo;
+    if (memoKey !== null && !bypassTypeMemo) {
+        contextMemo = ctx.typeMemoFor?.() ?? ctx.typeMemo;
+        const own = contextMemo?.get(memoKey);
+        if (own !== undefined) {
+            // The scope's own memo also holds answers this scope's bindings shaped
+            // (they were written here, not shared). Taking one re-reads that
+            // scope state just as mapping the type would, so the frame that took it
+            // is scope-specific too: without this the parent could enter the shared
+            // memo and serve this instance's representation to every later one.
+            if (ctx.typeMemoShared?.get(memoKey) !== own)
+                noteScopeSensitiveMapping();
+            return own;
+        }
+        const shared = ctx.typeMemoShared;
+        if (shared !== undefined && shared !== contextMemo) {
+            const hit = shared.get(memoKey);
+            if (hit !== undefined) {
+                if (verifySharedTypeMemo && topLevel)
+                    verifySharedMapping(type, ctx, hit);
+                return hit;
+            }
+        }
     }
     const sensitivityAtEntry = contextResolutions;
+    const scopeReadsAtEntry = scopeSensitivity;
     mapTypeDepth++;
     try {
         let mapped;
@@ -1677,6 +1833,17 @@ function mapTypeEntry(type, ctx) {
                     contextResolutions++;
             }
         }
+        // A PACKAGE DATA SHAPE the structural rules cannot map: `import type`
+        // from a package whose implementation is not part of the compiled
+        // module graph declares data the program itself builds, and a
+        // declaration the compiled graph never loads cannot produce a value of
+        // its own. A shape with no native mapping is then exactly the
+        // checked-dynamic value — the same answer `unknown` gets — never the
+        // package's story (there is no package value here to disagree with).
+        if (mapped === null && packageTypeIsData(type, ctx)) {
+            mapped = DYN;
+            contextResolutions++;
+        }
         // Localized failure: a type that failed at a committed slot maps to its
         // lenient form. It counts as a context resolution so neither it nor a
         // type containing it is memoized: the strict form may map elsewhere.
@@ -1697,10 +1864,25 @@ function mapTypeEntry(type, ctx) {
         if (mapped !== null &&
             memoKey !== null &&
             topLevel &&
+            !bypassTypeMemo &&
             contextResolutions === sensitivityAtEntry &&
             ctx.erasingSignature === undefined &&
             (ctx.canMemoizeType?.() ?? true)) {
-            ctx.typeMemo?.set(memoKey, mapped);
+            // Read the hook again rather than reusing the entry's memo: the write
+            // condition rechecks the binding context, and a hook is what keeps a
+            // context copy made inside a binding scope pointed at that scope.
+            const liveMemo = ctx.typeMemoFor?.() ?? ctx.typeMemo;
+            // A scope that changed mid-frame cannot own this answer. (It cannot
+            // happen today; the identity check keeps it a proof rather than an
+            // assumption.)
+            if (liveMemo === contextMemo) {
+                liveMemo?.set(memoKey, mapped);
+                // An answer that read no scope state is every scope's answer, so it
+                // also serves the shared memo — including the scopes entered later.
+                const shared = ctx.typeMemoShared;
+                if (shared !== undefined && shared !== liveMemo && scopeSensitivity === scopeReadsAtEntry)
+                    shared.set(memoKey, mapped);
+            }
         }
         return mapped;
     }
@@ -1708,6 +1890,32 @@ function mapTypeEntry(type, ctx) {
         mapTypeDepth--;
     }
 }
+/** SCRIPTC_TYPE_MEMO_VERIFY: recomputes a shared memo entry in the scope
+ * that just took it and fails loudly when the two answers disagree. The
+ * recalculation runs with every memo bypassed and restores the mapping
+ * counters it moves, so the observation leaves the mapping it observes
+ * unchanged. */
+function verifySharedMapping(type, ctx, shared) {
+    const resolutions = contextResolutions;
+    const scopeReads = scopeSensitivity;
+    bypassTypeMemo = true;
+    let recomputed;
+    try {
+        recomputed = mapTypeEntry(type, ctx);
+    }
+    finally {
+        bypassTypeMemo = false;
+        contextResolutions = resolutions;
+        scopeSensitivity = scopeReads;
+    }
+    const wanted = recomputed === null ? "<unmapped>" : typeKey(recomputed);
+    verifiedSharedHits++;
+    if (typeKey(shared) === wanted)
+        return;
+    throw new InternalCompilerError(`shared type memo entry does not match a fresh mapping: type ` +
+        `${checkerTypeDescription(type, ctx)} answered ${typeKey(shared)} from the shared ` +
+        `memo and ${wanted} when remapped in its scope`);
+}
 /** Local class types need the enclosing specialization's registered layout.
  * Static-block classes are sent through the same hook for an explicit fence. */
 function classExprNeedsContext(decl) {
@@ -1736,6 +1944,19 @@ function spreadsCheckedDynamic(symbol, ctx) {
     return decl.properties.nodes.some((prop) => ts.isSpreadAssignment(prop) &&
         mapType(ctx.checker.getTypeAtLocation(prop.expression), ctx)?.kind === "dyn");
 }
+/** The members a hand-written writable-pipe interface may name: the child
+ * stdin surface a `Pipe { write(chunk: string): boolean; end(): void }`
+ * declares (see the childWriter mapping in mapTypeInner). */
+const CHILD_WRITER_MEMBERS = new Set([
+    "write",
+    "end",
+    "destroy",
+    "writable",
+    "on",
+    "once",
+    "off",
+    "removeListener",
+]);
 function mapTypeInner(type, ctx) {
     const { checker, unions, classNamer, resolveTypeParam } = ctx;
     // TypeScript's intrinsic globalThis symbol has no declaration. A stored
@@ -1997,6 +2218,10 @@ function mapTypeInner(type, ctx) {
                 ts.symbolName(boxSym) === "String" ||
                 ts.symbolName(boxSym) === "Boolean") &&
             boxSym.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            // Once the program creates wrapper objects, a slot of the boxed type
+            // may hold one: the checked-dynamic value holds both.
+            if (ctx.primitiveWrappers?.())
+                return DYN;
             return ts.symbolName(boxSym) === "Number"
                 ? F64
                 : ts.symbolName(boxSym) === "String"
@@ -2157,30 +2382,13 @@ function mapTypeInner(type, ctx) {
     // such a type is one the program built itself (`import type` from a
     // types-only package), so it maps structurally like a local declaration.
     // Values the package itself would produce stay refused at their import.
-    const packageOnly = (sym) => {
-        const decls = sym ? sym.declarations : undefined;
-        return decls &&
-            decls.length > 0 &&
-            decls.every((d) => {
-                const sf = ts.getSourceFileOfNode(d);
-                return sf.isDeclarationFile && !ctx.isStdlibFile(sf) && !ctx.isExternalTypeFile(sf);
-            })
-            ? decls
-            : null;
-    };
-    const pureTypeShape = (decls) => decls === null ||
-        decls.every((d) => packageTypeFile(ts.getSourceFileOfNode(d), ctx) &&
-            (ts.isInterfaceDeclaration(d) ||
-                ts.isTypeAliasDeclaration(d) ||
-                ts.isTypeLiteralNode(d) ||
-                ts.isMappedTypeNode(d) ||
-                isDeclaredDataClass(d) ||
-                (decls.some(isDeclaredDataClass) && isTypeOnlyNamespace(d))));
-    const aliasDecls = packageOnly(widened.getAliasSymbol());
-    const ownDecls = packageOnly(widened.getSymbol());
-    if ((aliasDecls !== null || (widened.getAliasSymbol() === undefined && ownDecls !== null)) &&
-        !(pureTypeShape(aliasDecls) && pureTypeShape(ownDecls))) {
-        return null;
+    {
+        const aliasDecls = packageDeclarations(widened.getAliasSymbol(), ctx);
+        const ownDecls = packageDeclarations(widened.getSymbol(), ctx);
+        if ((aliasDecls !== null || (widened.getAliasSymbol() === undefined && ownDecls !== null)) &&
+            !(purePackageDeclarations(aliasDecls, ctx) && purePackageDeclarations(ownDecls, ctx))) {
+            return null;
+        }
     }
     // Module namespaces were claimed above when they name compiled source
     // modules or supported builtins. Declaration-only namespaces remain refused.
@@ -2398,8 +2606,22 @@ function mapTypeInner(type, ctx) {
         }
     }
     const classView = mapClassView(widened, ctx);
-    if (classView !== undefined)
+    if (classView !== undefined) {
+        // An intersection of ONE compiled class instance with data-only object
+        // types is a class instance carrying expando properties
+        // (`Box & { preview?: Preview }`): the class owns the instance's
+        // storage and the other members are properties the instance carries at
+        // run time, so the class view has no single layout to answer (null).
+        // The checked-dynamic representation IS that object model — one object,
+        // the instance's identity and prototype, class fields reading and
+        // writing through the live view, extra members in its property table.
+        if (classView === null && widened.isIntersectionType()) {
+            const expando = mapClassExpandoIntersection(widened, ctx);
+            if (expando)
+                return expando;
+        }
         return classView;
+    }
     // Class instances name a program class. The same symbol with construct
     // signatures names its static side, mapped to classval below.
     const widenedSym = widened.getSymbol();
@@ -2556,15 +2778,24 @@ function mapTypeInner(type, ctx) {
     // outside stays unmapped — callers report the component fence (SC2009)
     // naming the offending half, as does the `new Map` lowering per site.
     const psym = widened.getSymbol();
-    const isStdlibInterface = (name) => psym !== undefined &&
-        ts.symbolName(psym) === name &&
-        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
+    // The symbol's name and its standard-library declarations, asked once per
+    // type (provenanceOf memoizes the answer per symbol). No symbol is named
+    // "", so the absent symbol's placeholder names nothing.
+    const psymName = psym === undefined ? "" : ts.symbolName(psym);
+    const provenance = psym === undefined ? null : provenanceOf(psym, ctx);
+    const isStdlibInterface = (name) => provenance !== null && name === psymName && provenance.stdlibInterface;
+    // The async iteration protocols a `for await` source is annotated with
+    // (and the older spelling of an async generator's iterator object). Node's
+    // typings declare an interface named AsyncIterator too — the native handle
+    // timers/promises.setInterval answers, which that builtin's lowering
+    // builds — so only the ES lib's declarations take the protocol mapping.
+    const isLibAsyncInterface = (name) => provenance !== null && name === psymName && provenance.libInterface;
+    const isAsyncIterationProtocol = () => isLibAsyncInterface("AsyncIterable") ||
+        isLibAsyncInterface("AsyncIterator") ||
+        isLibAsyncInterface("AsyncIterableIterator");
     // The timer handles: an interface in the fallback and in @types/node 22+,
     // a class (`class Timeout implements Timer`) in @types/node 20 and older.
-    const isStdlibTimerHandle = (name) => psym !== undefined &&
-        ts.symbolName(psym) === name &&
-        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
+    const isStdlibTimerHandle = (name) => provenance !== null && name === psymName && provenance.stdlibClass;
     // The builtin Error classes: references to the lib's Error interfaces map to the runtime-provided class
     // hierarchy (provenance, not the name — a user's own `class Error`
     // resolved through the class-instance branch above, and a user
@@ -2578,7 +2809,7 @@ function mapTypeInner(type, ctx) {
     // node:assert's AssertionError is declared as a class (in the shipped
     // fallback and in @types/node), not as a lib interface.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "AssertionError" &&
+        psymName === "AssertionError" &&
         psym.declarations.some((d) => ts.isClassDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
         return { kind: "object", className: "%AssertionError" };
     // The lib's `Object` interface is a TOP type: tsc admits every
@@ -2595,11 +2826,11 @@ function mapTypeInner(type, ctx) {
     // module lowering before generic number operations can observe the
     // representation. The node:module class's merged instance interface is
     // included, while unrelated user interfaces named Module stay structural.
-    if (((psym !== undefined && ts.symbolName(psym) === "ScriptcModule") ||
-        (psym !== undefined && ts.symbolName(psym) === "Module")) &&
+    if (((psym !== undefined && psymName === "ScriptcModule") ||
+        (psym !== undefined && psymName === "Module")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
-            (ts.symbolName(psym) === "ScriptcModule" ||
+            (psymName === "ScriptcModule" ||
                 isDeclaredInAmbientNamespace(d, "NodeJS") ||
                 isDeclaredInAmbientModule(d, "module")))) {
         return F64;
@@ -2612,7 +2843,7 @@ function mapTypeInner(type, ctx) {
     // NodeJS.EventEmitter interface (the structural surface net.Socket
     // et al. extend) is the same runtime value. Provenance-checked.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "EventEmitter" &&
+        psymName === "EventEmitter" &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "events") || isDeclaredInAmbientNamespace(d, "NodeJS")))) {
@@ -2623,7 +2854,7 @@ function mapTypeInner(type, ctx) {
     // precedent). The NAME is generic, so the provenance check adds the
     // enclosing ambient module, like net.Server.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Interface" &&
+        psymName === "Interface" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "readline") ||
@@ -2634,7 +2865,7 @@ function mapTypeInner(type, ctx) {
     // it keeps Node's own shape (an undefined name, the escape sequences'
     // code member).
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Key" &&
+        psymName === "Key" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "readline") ||
@@ -2643,7 +2874,7 @@ function mapTypeInner(type, ctx) {
     }
     // readline/promises.Readline: an f64 handle the same way.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Readline" &&
+        psymName === "Readline" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "readline/promises"))) {
@@ -2656,7 +2887,7 @@ function mapTypeInner(type, ctx) {
     // plus the ambient module suffices for both the fallback declarations
     // and @types/node's class Channel<StoreType, ContextType>.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Channel" &&
+        psymName === "Channel" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
@@ -2666,7 +2897,7 @@ function mapTypeInner(type, ctx) {
     // the runtime's store id space (the Channel story — stores are
     // process-lived; contexts ride the fiber machinery).
     if (psym !== undefined &&
-        ts.symbolName(psym) === "AsyncLocalStorage" &&
+        psymName === "AsyncLocalStorage" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "async_hooks"))) {
@@ -2675,7 +2906,7 @@ function mapTypeInner(type, ctx) {
     // diagnostics_channel.TracingChannel: the same f64-handle story over the
     // runtime's tracing registry (five event channels per entry).
     if (psym !== undefined &&
-        ts.symbolName(psym) === "TracingChannel" &&
+        psymName === "TracingChannel" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
@@ -2708,15 +2939,15 @@ function mapTypeInner(type, ctx) {
         };
     // WHATWG codec instances have ordinary reference identity and ownership.
     // Their private encoding slot is omitted from enumeration and JSON.
-    if (((psym !== undefined && ts.symbolName(psym) === "TextEncoder") ||
-        (psym !== undefined && ts.symbolName(psym) === "TextDecoder")) &&
+    if (((psym !== undefined && psymName === "TextEncoder") ||
+        (psym !== undefined && psymName === "TextDecoder")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return {
             kind: "record",
             shapeId: ctx.shapes.intern([
-                { name: `%${ts.symbolName(psym)}`, type: F64 },
-                ...(ts.symbolName(psym) === "TextDecoder"
+                { name: `%${psymName}`, type: F64 },
+                ...(psymName === "TextDecoder"
                     ? [
                         { name: "%fatal", type: BOOL },
                         { name: "%ignoreBOM", type: BOOL },
@@ -2734,7 +2965,7 @@ function mapTypeInner(type, ctx) {
     // special-cased in lowerNew / lowerStringDecoderMethodCall, so the
     // record shape never surfaces.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "StringDecoder" &&
+        psymName === "StringDecoder" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return {
@@ -2803,7 +3034,7 @@ function mapTypeInner(type, ctx) {
     // `typeof inspect`): the runtime's inspect function, called through the
     // checked-dynamic boundary.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "inspect" &&
+        psymName === "inspect" &&
         psym.declarations.some((d) => ts.isFunctionDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "util")))
@@ -2824,7 +3055,7 @@ function mapTypeInner(type, ctx) {
     // option record whose members include functions, agents and signals.
     // Values ride checked-dynamic storage, like SpawnOptions.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "RequestOptions" &&
+        psymName === "RequestOptions" &&
         psym.declarations.some((d) => {
             if (!ts.isInterfaceDeclaration(d) || !ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
                 return false;
@@ -2858,8 +3089,7 @@ function mapTypeInner(type, ctx) {
         }
     }
     if (psym &&
-        (ts.symbolName(psym) === "ReadableStreamReadValueResult" ||
-            ts.symbolName(psym) === "ReadableStreamReadDoneResult") &&
+        (psymName === "ReadableStreamReadValueResult" || psymName === "ReadableStreamReadDoneResult") &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         const elemTs = checker.getTypeArguments(widened)[0];
         const elem = elemTs && elemTs.flags & ts.TypeFlags.Any ? DYN : elemTs ? mapType(elemTs, ctx) : null;
@@ -2870,10 +3100,10 @@ function mapTypeInner(type, ctx) {
     // node:net's SocketAddress and BlockList (scr_net.c) and node:util's
     // MIMEType and MIMEParams (scr_mime.c): native handles whose getters and
     // methods dispatch through the handle.
-    if (((psym !== undefined && ts.symbolName(psym) === "SocketAddress") ||
-        (psym !== undefined && ts.symbolName(psym) === "BlockList") ||
-        (psym !== undefined && ts.symbolName(psym) === "MIMEType") ||
-        (psym !== undefined && ts.symbolName(psym) === "MIMEParams")) &&
+    if (((psym !== undefined && psymName === "SocketAddress") ||
+        (psym !== undefined && psymName === "BlockList") ||
+        (psym !== undefined && psymName === "MIMEType") ||
+        (psym !== undefined && psymName === "MIMEParams")) &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
@@ -2882,7 +3112,7 @@ function mapTypeInner(type, ctx) {
     // (scr_util_timing.c): native functions with their own members and
     // getters.
     if (psym !== undefined &&
-        (ts.symbolName(psym) === "DebouncedFunction" || ts.symbolName(psym) === "ThrottledFunction") &&
+        (psymName === "DebouncedFunction" || psymName === "ThrottledFunction") &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
@@ -2891,7 +3121,7 @@ function mapTypeInner(type, ctx) {
     // the algorithm dictionaries the methods take and keys report are plain
     // checked-dynamic objects.
     if (psym &&
-        WEBCRYPTO_DYN_TYPES.has(ts.symbolName(psym)) &&
+        WEBCRYPTO_DYN_TYPES.has(psymName) &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
@@ -2900,8 +3130,8 @@ function mapTypeInner(type, ctx) {
     // public keys (scr_pki.c) are native handles whose getters and methods
     // dispatch through the handle. The JsonWebKey that export() returns is a
     // plain checked-dynamic object.
-    if (((psym !== undefined && ts.symbolName(psym) === "KeyObject") ||
-        (psym !== undefined && ts.symbolName(psym) === "JsonWebKey")) &&
+    if (((psym !== undefined && psymName === "KeyObject") ||
+        (psym !== undefined && psymName === "JsonWebKey")) &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
@@ -2910,7 +3140,7 @@ function mapTypeInner(type, ctx) {
     // objects, so a value asserted to one (`opts as
     // crypto.AsymmetricKeyExportOptions<"pem">`) reaches the call unchanged.
     if (psym !== undefined &&
-        CRYPTO_KEY_OPTION_DYN_TYPES.has(ts.symbolName(psym)) &&
+        CRYPTO_KEY_OPTION_DYN_TYPES.has(psymName) &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
@@ -2919,15 +3149,15 @@ function mapTypeInner(type, ctx) {
     // node:crypto's Sign and Verify (createSign/createVerify): native
     // handles over the digest state (scr_pki.c).
     if (psym !== undefined &&
-        (ts.symbolName(psym) === "Sign" || ts.symbolName(psym) === "Verify") &&
+        (psymName === "Sign" || psymName === "Verify") &&
         psym.declarations.some((d) => ts.isClassDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
         return DYN;
     }
     if (psym &&
-        FETCH_AMBIENT_TYPES.includes(ts.symbolName(psym)) &&
-        !((ts.symbolName(psym) === "ReadableStream" || ts.symbolName(psym) === "WritableStream") &&
+        FETCH_AMBIENT_TYPES.includes(psymName) &&
+        !((psymName === "ReadableStream" || psymName === "WritableStream") &&
             psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS"))) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
@@ -2940,10 +3170,10 @@ function mapTypeInner(type, ctx) {
     // AsyncDisposable are checked objects carrying their Symbol.dispose or
     // Symbol.asyncDispose method. A DisposableStack is a native handle whose
     // methods are function values of its checked-dynamic view.
-    if (((psym !== undefined && ts.symbolName(psym) === "Console") ||
-        (psym !== undefined && ts.symbolName(psym) === "Disposable") ||
-        (psym !== undefined && ts.symbolName(psym) === "AsyncDisposable") ||
-        (psym !== undefined && ts.symbolName(psym) === "DisposableStack")) &&
+    if (((psym !== undefined && psymName === "Console") ||
+        (psym !== undefined && psymName === "Disposable") ||
+        (psym !== undefined && psymName === "AsyncDisposable") ||
+        (psym !== undefined && psymName === "DisposableStack")) &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
@@ -2951,14 +3181,14 @@ function mapTypeInner(type, ctx) {
     // interfaces over them) are native handles carried by the checked-dynamic
     // representation; lowerCipherMethodCall dispatches their methods.
     if (psym !== undefined &&
-        CIPHER_TYPE_NAMES.has(ts.symbolName(psym)) &&
+        CIPHER_TYPE_NAMES.has(psymName) &&
         psym.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
     // node:crypto ECDH values are native handles carried by the
     // checked-dynamic representation; lowerEcdhCall dispatches their methods.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "ECDH" &&
+        psymName === "ECDH" &&
         psym.declarations.some((d) => ts.isClassDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
@@ -3111,7 +3341,7 @@ function mapTypeInner(type, ctx) {
     // fallback and by @types/node (whose NonSharedBuffer alias resolves to
     // the same symbol); provenance-checked like URL.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Buffer" &&
+        psymName === "Buffer" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return bytesOf("u8");
@@ -3122,7 +3352,7 @@ function mapTypeInner(type, ctx) {
     // instance type). Provenance, not the name: a user's own URL maps as a
     // record/class like any other.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "URL" &&
+        psymName === "URL" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "url" };
@@ -3131,7 +3361,7 @@ function mapTypeInner(type, ctx) {
     // interface by the shipped fallback and by @types/node (plus `class
     // URLSearchParams` in the "url" module). Provenance-checked like URL.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "URLSearchParams" &&
+        psymName === "URLSearchParams" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "searchParams" };
@@ -3139,7 +3369,7 @@ function mapTypeInner(type, ctx) {
     // fs.Stats: @types/node's `class Stats` (module "fs") or the fallback
     // declarations' interface. Provenance-checked like URL.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Stats" &&
+        psymName === "Stats" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "stats" };
@@ -3149,16 +3379,16 @@ function mapTypeInner(type, ctx) {
     // `class BigIntStats` in "fs"; the fallback declarations keep the class
     // shape too. Provenance-checked like Stats.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "BigIntStats" &&
+        psymName === "BigIntStats" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "bigintStats" };
     }
     // Capacity snapshots and options keep their live object representation
     // across numeric/BigInt overloads, runtime options, and callbacks.
-    if (((psym !== undefined && ts.symbolName(psym) === "StatsFs") ||
-        (psym !== undefined && ts.symbolName(psym) === "BigIntStatsFs") ||
-        (psym !== undefined && ts.symbolName(psym) === "StatFsOptions")) &&
+    if (((psym !== undefined && psymName === "StatsFs") ||
+        (psym !== undefined && psymName === "BigIntStatsFs") ||
+        (psym !== undefined && psymName === "StatFsOptions")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs")))
@@ -3169,7 +3399,7 @@ function mapTypeInner(type, ctx) {
     // distinguishes it from user interfaces with the same name; both the
     // fallback and @types/node declare it in "fs/promises".
     if (psym !== undefined &&
-        ts.symbolName(psym) === "FileHandle" &&
+        psymName === "FileHandle" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs/promises"))) {
@@ -3178,7 +3408,7 @@ function mapTypeInner(type, ctx) {
     // fs.Dir: an open directory stream, declared in "fs" by both the
     // fallback and @types/node.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Dir" &&
+        psymName === "Dir" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs"))) {
@@ -3189,7 +3419,7 @@ function mapTypeInner(type, ctx) {
     // reads work either way) or the fallback declarations' plain interface.
     // Provenance-checked like Stats.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "SpawnSyncReturns" &&
+        psymName === "SpawnSyncReturns" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "spawnRes" };
@@ -3198,9 +3428,9 @@ function mapTypeInner(type, ctx) {
     // interfaces: all carry the same runtime child handle; the generic
     // refinements only tell the checker which stdio properties are null.
     if (psym !== undefined &&
-        (ts.symbolName(psym) === "ChildProcess" ||
-            ts.symbolName(psym) === "ChildProcessWithoutNullStreams" ||
-            ts.symbolName(psym) === "ChildProcessByStdio") &&
+        (psymName === "ChildProcess" ||
+            psymName === "ChildProcessWithoutNullStreams" ||
+            psymName === "ChildProcessByStdio") &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "child_process"))) {
@@ -3213,9 +3443,9 @@ function mapTypeInner(type, ctx) {
     // declare these inside `declare module "net"` — a declaration outside
     // that module (http's Server) stays unmapped and fences at its use
     // site.
-    if (((psym !== undefined && ts.symbolName(psym) === "Server") ||
-        (psym !== undefined && ts.symbolName(psym) === "Socket") ||
-        (psym !== undefined && ts.symbolName(psym) === "TLSSocket")) &&
+    if (((psym !== undefined && psymName === "Server") ||
+        (psym !== undefined && psymName === "Socket") ||
+        (psym !== undefined && psymName === "TLSSocket")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "net") ||
@@ -3224,12 +3454,12 @@ function mapTypeInner(type, ctx) {
                 // (listen/close/address/'error'), same handle kind. tls.TLSSocket
                 // extends net.Socket the same way: post-handshake it IS a net
                 // socket to every lowered member.
-                (ts.symbolName(psym) === "Server" &&
+                (psymName === "Server" &&
                     (isDeclaredInAmbientModule(d, "http") ||
                         isDeclaredInAmbientModule(d, "tls") ||
                         isDeclaredInAmbientModule(d, "https"))) ||
-                (ts.symbolName(psym) === "TLSSocket" && isDeclaredInAmbientModule(d, "tls"))))) {
-        return ts.symbolName(psym) === "Server" ? { kind: "netServer" } : { kind: "netSocket" };
+                (psymName === "TLSSocket" && isDeclaredInAmbientModule(d, "tls"))))) {
+        return psymName === "Server" ? { kind: "netServer" } : { kind: "netSocket" };
     }
     // tls.SecureContext: the opaque parsed-cert/key handle SNI callbacks
     // answer with (tls.createSecureContext({ cert, key }) mints it; the TLS
@@ -3237,7 +3467,7 @@ function mapTypeInner(type, ctx) {
     // @types/node declares `interface SecureContext` inside `declare module
     // "tls"`, and the shipped fallback mirrors it.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "SecureContext" &&
+        psymName === "SecureContext" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "tls"))) {
@@ -3246,7 +3476,7 @@ function mapTypeInner(type, ctx) {
     // Scrypt's runtime options retain property accessors and aliases. Use
     // checked values so presence probes and repeated getter reads match Node.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "ScryptOptions" &&
+        psymName === "ScryptOptions" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto")))
@@ -3254,19 +3484,18 @@ function mapTypeInner(type, ctx) {
     // crypto.Hash / crypto.Hmac: native incremental digest handles. Keep
     // provenance module-qualified so user classes with these common names
     // retain their ordinary structural/class representation.
-    if (((psym !== undefined && ts.symbolName(psym) === "Hash") ||
-        (psym !== undefined && ts.symbolName(psym) === "Hmac")) &&
+    if (((psym !== undefined && psymName === "Hash") || (psym !== undefined && psymName === "Hmac")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
-        return ts.symbolName(psym) === "Hash" ? CRYPTOHASH_T : CRYPTOHMAC_T;
+        return psymName === "Hash" ? CRYPTOHASH_T : CRYPTOHMAC_T;
     }
     // fs.FSWatcher: the fs.watch handle (scr_watch.c). Module-checked like
     // net.Server — @types/node declares `interface FSWatcher extends
     // EventEmitter` inside `declare module "fs"`, and the shipped fallback
     // mirrors it.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "FSWatcher" &&
+        psymName === "FSWatcher" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs"))) {
@@ -3308,7 +3537,7 @@ function mapTypeInner(type, ctx) {
         return DYN;
     }
     const nodeWritableInterface = psym !== undefined &&
-        ts.symbolName(psym) === "WritableStream" &&
+        psymName === "WritableStream" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientNamespace(d, "NodeJS"));
@@ -3316,7 +3545,7 @@ function mapTypeInner(type, ctx) {
         return ctx.dynNodeStreams === true ? DYN : { kind: "object", className: "%Writable" };
     }
     if ((psym !== undefined &&
-        ts.symbolName(psym) === "WriteStream" &&
+        psymName === "WriteStream" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "tty") ||
@@ -3329,13 +3558,13 @@ function mapTypeInner(type, ctx) {
     // stream.Writable. As with stream.Readable below, unsupported producers
     // of the broad @types class fence where they are constructed.
     if ((psym !== undefined &&
-        ts.symbolName(psym) === "ChildStdin" &&
+        psymName === "ChildStdin" &&
         ctx.generalNodeStreams !== true &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "child_process"))) ||
         (psym !== undefined &&
-            ts.symbolName(psym) === "Writable" &&
+            psymName === "Writable" &&
             ctx.generalNodeStreams !== true &&
             psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
                 ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
@@ -3347,7 +3576,7 @@ function mapTypeInner(type, ctx) {
     // ChildStdin is the runtime Writable too (child.stdioStream bridges it).
     if (ctx.generalNodeStreams === true &&
         psym !== undefined &&
-        ts.symbolName(psym) === "ChildStdin" &&
+        psymName === "ChildStdin" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "child_process"))) {
@@ -3365,7 +3594,7 @@ function mapTypeInner(type, ctx) {
     // Writable join them under the general representation.
     for (const [irName, rec] of RUNTIME_STREAM_CLASSES) {
         if (psym !== undefined &&
-            ts.symbolName(psym) === rec.lib &&
+            psymName === rec.lib &&
             psym.declarations.some((d) => ts.isClassDeclaration(d) &&
                 ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
                 (!isNodeTypesPath(ts.getSourceFileOfNode(d).fileName) ||
@@ -3378,7 +3607,7 @@ function mapTypeInner(type, ctx) {
     // node:zlib's stream classes (the shipped fallback declarations and
     // @types/node's): their instances are runtime Transform streams.
     if (psym !== undefined &&
-        ZLIB_STREAM_MODES.has(ts.symbolName(psym)) &&
+        ZLIB_STREAM_MODES.has(psymName) &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) ||
             (ts.isInterfaceDeclaration(d) && isNodeTypesPath(ts.getSourceFileOfNode(d).fileName))) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
@@ -3388,32 +3617,38 @@ function mapTypeInner(type, ctx) {
     // fs.ReadStream / fs.WriteStream (the shipped fallback declarations and
     // @types/node's): their instances are runtime Readable / Writable
     // streams (scr_fs_stream.c).
-    if (((psym !== undefined && ts.symbolName(psym) === "ReadStream") ||
-        (psym !== undefined && ts.symbolName(psym) === "WriteStream")) &&
+    if (((psym !== undefined && psymName === "ReadStream") ||
+        (psym !== undefined && psymName === "WriteStream")) &&
         psym.declarations.some((d) => ts.isClassDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs"))) {
         return {
             kind: "object",
-            className: ts.symbolName(psym) === "ReadStream" ? "%Readable" : "%Writable",
+            className: psymName === "ReadStream" ? "%Readable" : "%Writable",
         };
     }
     if ((psym !== undefined &&
-        ts.symbolName(psym) === "Readable" &&
+        psymName === "Readable" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "stream"))) ||
         (psym !== undefined &&
-            ts.symbolName(psym) === "ReadableStream" &&
+            psymName === "ReadableStream" &&
             psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
                 ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
-                isDeclaredInAmbientNamespace(d, "NodeJS")))) {
+                isDeclaredInAmbientNamespace(d, "NodeJS"))) ||
+        (psym !== undefined &&
+            psymName === "ChildStdout" &&
+            psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+                ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+                isDeclaredInAmbientModule(d, "child_process")))) {
         // The general representation: the runtime Readable, which child
         // stdio reads produce through the child stream bridge. With
         // checked-dynamic stream slots, NodeJS.ReadableStream holds any
         // stream value (dyn-streams.ts); stream.Readable keeps the class.
         if (ctx.generalNodeStreams === true) {
-            if (ctx.dynNodeStreams === true && ts.symbolName(psym) === "ReadableStream")
+            if (ctx.dynNodeStreams === true &&
+                (psymName === "ReadableStream" || psymName === "ChildStdout"))
                 return DYN;
             return { kind: "object", className: "%Readable" };
         }
@@ -3424,7 +3659,7 @@ function mapTypeInner(type, ctx) {
     // EventEmitter` and the fallback declarations' interface both live
     // inside `declare module "dgram"`.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Socket" &&
+        psymName === "Socket" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "dgram"))) {
@@ -3436,8 +3671,8 @@ function mapTypeInner(type, ctx) {
     // classes and the fallback declarations' interfaces all live inside
     // `declare module "node:test"` (isDeclaredInAmbientModule answers for
     // both spellings).
-    if (((psym !== undefined && ts.symbolName(psym) === "TestContext") ||
-        (psym !== undefined && ts.symbolName(psym) === "SuiteContext")) &&
+    if (((psym !== undefined && psymName === "TestContext") ||
+        (psym !== undefined && psymName === "SuiteContext")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "test"))) {
@@ -3446,8 +3681,8 @@ function mapTypeInner(type, ctx) {
     // node:test's MockFunctionContext<F> and MockFunctionCall<F>: compiler
     // records built from F (mock-shapes.ts). Mock<F> then maps as the hybrid
     // { %call: F, mock } record through mapHybridCallableIntersection.
-    if (((psym !== undefined && ts.symbolName(psym) === "MockFunctionContext") ||
-        (psym !== undefined && ts.symbolName(psym) === "MockFunctionCall")) &&
+    if (((psym !== undefined && psymName === "MockFunctionContext") ||
+        (psym !== undefined && psymName === "MockFunctionCall")) &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "test"))) {
@@ -3455,7 +3690,7 @@ function mapTypeInner(type, ctx) {
         const fn = fnTs ? mapType(fnTs, ctx) : null;
         if (!fn || fn.kind !== "func")
             return null;
-        return ts.symbolName(psym) === "MockFunctionContext"
+        return psymName === "MockFunctionContext"
             ? mockContextType(fn, ctx)
             : mockCallRecordType(fn, ctx);
     }
@@ -3465,7 +3700,7 @@ function mapTypeInner(type, ctx) {
     // above; optional metadata uses the same checked property view.
     // Provenance-checked like the rest.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "ErrnoException" &&
+        psymName === "ErrnoException" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "object", className: "%Error" };
     }
@@ -3476,7 +3711,7 @@ function mapTypeInner(type, ctx) {
     // of fencing at the declaration. Module-checked like the rest (https'
     // Agent extends http's; both live in their ambient modules).
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Agent" &&
+        psymName === "Agent" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "http") || isDeclaredInAmbientModule(d, "https")))) {
@@ -3485,12 +3720,12 @@ function mapTypeInner(type, ctx) {
     // http.IncomingMessage / http.ServerResponse — module-checked like
     // net.Server (the names repeat nowhere today, but provenance stays the
     // rule).
-    if (((psym !== undefined && ts.symbolName(psym) === "IncomingMessage") ||
-        (psym !== undefined && ts.symbolName(psym) === "ServerResponse")) &&
+    if (((psym !== undefined && psymName === "IncomingMessage") ||
+        (psym !== undefined && psymName === "ServerResponse")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http"))) {
-        return ts.symbolName(psym) === "IncomingMessage" ? { kind: "httpReq" } : { kind: "httpRes" };
+        return psymName === "IncomingMessage" ? { kind: "httpReq" } : { kind: "httpRes" };
     }
     // http2's compatibility surface (the allowHTTP1 lowering): the secure
     // server IS a net server (listen/close/address/emit ride the same
@@ -3500,15 +3735,15 @@ function mapTypeInner(type, ctx) {
     // ServerResponse surface. h2-only members (stream, session) fence per
     // member at their use sites (lower-server.ts). Module-checked like the
     // rest.
-    if (((psym !== undefined && ts.symbolName(psym) === "Http2SecureServer") ||
-        (psym !== undefined && ts.symbolName(psym) === "Http2ServerRequest") ||
-        (psym !== undefined && ts.symbolName(psym) === "Http2ServerResponse")) &&
+    if (((psym !== undefined && psymName === "Http2SecureServer") ||
+        (psym !== undefined && psymName === "Http2ServerRequest") ||
+        (psym !== undefined && psymName === "Http2ServerResponse")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http2"))) {
-        return ts.symbolName(psym) === "Http2SecureServer"
+        return psymName === "Http2SecureServer"
             ? { kind: "netServer" }
-            : ts.symbolName(psym) === "Http2ServerRequest"
+            : psymName === "Http2ServerRequest"
                 ? { kind: "httpReq" }
                 : { kind: "httpRes" };
     }
@@ -3516,25 +3751,25 @@ function mapTypeInner(type, ctx) {
     // like the secure one; sessions and streams are first-class handle
     // kinds (client and server flavors share a kind — the runtime handle
     // carries the role). Module-checked like the rest.
-    if (((psym !== undefined && ts.symbolName(psym) === "Http2Server") ||
-        (psym !== undefined && ts.symbolName(psym) === "Http2Session") ||
-        (psym !== undefined && ts.symbolName(psym) === "ClientHttp2Session") ||
-        (psym !== undefined && ts.symbolName(psym) === "ServerHttp2Session") ||
-        (psym !== undefined && ts.symbolName(psym) === "ClientHttp2Stream") ||
-        (psym !== undefined && ts.symbolName(psym) === "ServerHttp2Stream")) &&
+    if (((psym !== undefined && psymName === "Http2Server") ||
+        (psym !== undefined && psymName === "Http2Session") ||
+        (psym !== undefined && psymName === "ClientHttp2Session") ||
+        (psym !== undefined && psymName === "ServerHttp2Session") ||
+        (psym !== undefined && psymName === "ClientHttp2Stream") ||
+        (psym !== undefined && psymName === "ServerHttp2Stream")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http2"))) {
-        return ts.symbolName(psym) === "Http2Server"
+        return psymName === "Http2Server"
             ? { kind: "netServer" }
-            : ts.symbolName(psym) === "ClientHttp2Stream" || ts.symbolName(psym) === "ServerHttp2Stream"
+            : psymName === "ClientHttp2Stream" || psymName === "ServerHttp2Stream"
                 ? { kind: "http2Stream" }
                 : { kind: "http2Session" };
     }
     // http.ClientRequest (http.request/http.get results) — module-checked
     // like IncomingMessage.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "ClientRequest" &&
+        psymName === "ClientRequest" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http"))) {
@@ -3549,7 +3784,7 @@ function mapTypeInner(type, ctx) {
     // declarations' anonymous env type takes the pureIndexShape path below
     // and interns the SAME shape.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "ProcessEnv" &&
+        psymName === "ProcessEnv" &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         const value = withUndefinedArm(STRING, ctx.unions);
         if (!value)
@@ -3596,8 +3831,10 @@ function mapTypeInner(type, ctx) {
         return { kind: "generator", yieldT, retT: VOID, nextT: UNDEFINED_T };
     }
     // Generator<T, TReturn, TNext>, AsyncGenerator<T, TReturn, TNext> (and
-    // the lib's IterableIterator<T, ...>, the older sync annotation spelling):
-    // the generator kind. Channel normalization keeps the runtime honest:
+    // the lib's IterableIterator<T, ...>, the older sync annotation spelling;
+    // AsyncIterator<T>, AsyncIterableIterator<T> and AsyncIterable<T>, what
+    // `for await` consumes): the generator kind. Channel normalization keeps
+    // the runtime honest:
     //   yield channel  — T must be a real value type (a generator that could
     //                    only yield undefined has no C value form); `never`
     //                    (a generator that never yields) rides the VOID
@@ -3626,19 +3863,32 @@ function mapTypeInner(type, ctx) {
         isStdlibInterface("Iterator") ||
         // IteratorObject<T> is what the iterator helpers return: a helper
         // generator over its source (containers/iterator-helpers.ts).
-        isStdlibInterface("IteratorObject")) {
+        isStdlibInterface("IteratorObject") ||
+        isAsyncIterationProtocol()) {
         const args = checker.getTypeArguments(widened);
         const channels = genChannels(args[0], args[1], args[2], ctx);
         if (!channels)
             return null;
+        // The async iteration protocols are what `for await` CONSUMES: the
+        // yield channel is the only promise they make. A for-await consumer
+        // sends nothing back, and a producer's own return and resume
+        // channels are its business, so the protocol spelling takes the
+        // return channel as valueless and the resume channel as the
+        // checked-dynamic one — the channels of the common
+        // `AsyncGenerator<T, void, unknown>` producer annotation.
+        const consumer = isAsyncIterationProtocol()
+            ? { ...channels, retT: VOID, nextT: DYN }
+            : channels;
         // The result record must exist too (its union must be legal), or
         // `.next()` could never answer — mapped generators always resume.
-        if (!genResultRecord(channels.yieldT, channels.retT, ctx.shapes, unions))
+        if (!genResultRecord(consumer.yieldT, consumer.retT, ctx.shapes, unions))
             return null;
         return {
             kind: "generator",
-            ...(isStdlibInterface("AsyncGenerator") ? { async: true } : {}),
-            ...channels,
+            ...(isStdlibInterface("AsyncGenerator") || isAsyncIterationProtocol()
+                ? { async: true }
+                : {}),
+            ...consumer,
         };
     }
     // Iterable<T>: the iterable union (iterableUnionType) — the source value
@@ -3732,6 +3982,37 @@ function mapTypeInner(type, ctx) {
             ], false, undefined, ["encoding", "cwd", "input", "timeout", "stdio", "maxBuffer", "windowsHide"]),
         };
     }
+    // child_process.SpawnSyncOptionsWithStringEncoding: the spawnSync twin of
+    // the exec-options record above, interned explicitly for the same
+    // reason — a typed const or a runner function's options parameter is a
+    // runtime record the spawnSync lowering reads member by member. The
+    // members are the ones it honestly implements: encoding (required — the
+    // "WithStringEncoding" refinement), cwd/input/timeout/shell/stdio (a
+    // runtime array is string[]; unsupported runtime modes throw at the
+    // call), and the accepted-but-inert windowsHide. env and killSignal
+    // stay literal-only, so their presence keeps the shape unmatched and
+    // their literals fence at the shape check instead of being dropped.
+    if (isStdlibInterface("SpawnSyncOptionsWithStringEncoding")) {
+        const optStr = withUndefinedArm(STRING, ctx.unions);
+        const optNum = withUndefinedArm(F64, ctx.unions);
+        const optBool = withUndefinedArm(BOOL, ctx.unions);
+        const stdioArms = [arrayOf(STRING), STRING, UNDEFINED_T].sort((a, b) => typeKey(a) < typeKey(b) ? -1 : 1);
+        const stdio = { kind: "union", unionId: ctx.unions.intern(stdioArms) };
+        if (!optStr || !optNum || !optBool)
+            return null;
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "cwd", type: optStr },
+                { name: "encoding", type: STRING },
+                { name: "input", type: optStr },
+                { name: "shell", type: optBool },
+                { name: "stdio", type: stdio },
+                { name: "timeout", type: optNum },
+                { name: "windowsHide", type: optBool },
+            ], false, undefined, ["encoding", "cwd", "input", "timeout", "shell", "stdio", "windowsHide"]),
+        };
+    }
     if (isStdlibInterface("AddressInfo")) {
         return {
             kind: "record",
@@ -3775,10 +4056,10 @@ function mapTypeInner(type, ctx) {
         return DYN;
     // Filesystem options are data records. Keep their declared optional fields
     // instead of allowing arbitrary standard-library interfaces into records.
-    if (((psym !== undefined && ts.symbolName(psym) === "FileReadOptions") ||
-        (psym !== undefined && ts.symbolName(psym) === "ReadOptions") ||
-        (psym !== undefined && ts.symbolName(psym) === "ReadOptionsWithBuffer") ||
-        (psym !== undefined && ts.symbolName(psym) === "WriteOptions")) &&
+    if (((psym !== undefined && psymName === "FileReadOptions") ||
+        (psym !== undefined && psymName === "ReadOptions") ||
+        (psym !== undefined && psymName === "ReadOptionsWithBuffer") ||
+        (psym !== undefined && psymName === "WriteOptions")) &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "fs/promises") || isDeclaredInAmbientModule(d, "fs")))) {
@@ -3799,24 +4080,24 @@ function mapTypeInner(type, ctx) {
     // null-prototype objects returned by FileHandle.read/write. The native
     // record does not model the prototype (unobservable through the lowered
     // surface); it preserves the caller buffer/string by reference.
-    if (((psym !== undefined && ts.symbolName(psym) === "FileReadResult") ||
-        (psym !== undefined && ts.symbolName(psym) === "FileWriteResult") ||
-        (psym !== undefined && ts.symbolName(psym) === "FileReadvResult") ||
-        (psym !== undefined && ts.symbolName(psym) === "FileWritevResult") ||
-        (psym !== undefined && ts.symbolName(psym) === "ReadVResult") ||
-        (psym !== undefined && ts.symbolName(psym) === "WriteVResult")) &&
+    if (((psym !== undefined && psymName === "FileReadResult") ||
+        (psym !== undefined && psymName === "FileWriteResult") ||
+        (psym !== undefined && psymName === "FileReadvResult") ||
+        (psym !== undefined && psymName === "FileWritevResult") ||
+        (psym !== undefined && psymName === "ReadVResult") ||
+        (psym !== undefined && psymName === "WriteVResult")) &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "fs/promises") ||
-                ((ts.symbolName(psym) === "ReadVResult" || ts.symbolName(psym) === "WriteVResult") &&
+                ((psymName === "ReadVResult" || psymName === "WriteVResult") &&
                     isDeclaredInAmbientModule(d, "fs"))))) {
         const args = checker.getTypeArguments(widened);
         if (args.length !== 1)
             return null;
-        const vector = ts.symbolName(psym) === "FileReadvResult" ||
-            ts.symbolName(psym) === "FileWritevResult" ||
-            ts.symbolName(psym) === "ReadVResult" ||
-            ts.symbolName(psym) === "WriteVResult";
+        const vector = psymName === "FileReadvResult" ||
+            psymName === "FileWritevResult" ||
+            psymName === "ReadVResult" ||
+            psymName === "WriteVResult";
         const emptyVector = vector &&
             checker.isArrayType(args[0]) &&
             (checker.getTypeArguments(args[0])[0].flags & ts.TypeFlags.Never) !== 0;
@@ -3827,9 +4108,7 @@ function mapTypeInner(type, ctx) {
                 : !(payload.kind === "string" || (payload.kind === "bytes" && payload.elem === "u8")))) {
             return null;
         }
-        const count = ts.symbolName(psym) === "FileReadResult" ||
-            ts.symbolName(psym) === "FileReadvResult" ||
-            ts.symbolName(psym) === "ReadVResult"
+        const count = psymName === "FileReadResult" || psymName === "FileReadvResult" || psymName === "ReadVResult"
             ? "bytesRead"
             : "bytesWritten";
         const payloadName = vector ? "buffers" : "buffer";
@@ -3856,7 +4135,7 @@ function mapTypeInner(type, ctx) {
     // declares it concrete (an interface; @types/node uses a class — both
     // provenance-checked, the Buffer/URL pattern).
     if (psym !== undefined &&
-        ts.symbolName(psym) === "Dirent" &&
+        psymName === "Dirent" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         const args = checker.getTypeArguments(widened);
@@ -3946,6 +4225,20 @@ function mapTypeInner(type, ctx) {
             ], false, undefined, ["uid", "gid", "username", "homedir", "shell"]),
         };
     }
+    // os.BufferUserInfo: os.userInfo({ encoding: 'buffer' }) — the same
+    // record with the three passwd strings as Buffers (the u8 bytes kind).
+    if (isStdlibInterface("BufferUserInfo")) {
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "gid", type: F64 },
+                { name: "homedir", type: bytesOf("u8") },
+                { name: "shell", type: bytesOf("u8") },
+                { name: "uid", type: F64 },
+                { name: "username", type: bytesOf("u8") },
+            ], false, undefined, ["uid", "gid", "username", "homedir", "shell"]),
+        };
+    }
     // The promisified exec/execFile result `{ stdout: string; stderr: string }`
     // and the promisified dns.lookupService result `{ hostname: string;
     // service: string }`: anonymous type literals (@types/node's
@@ -3987,8 +4280,7 @@ function mapTypeInner(type, ctx) {
     // mapped property types (KeyObjects, PEM strings or DER Buffers), in
     // Node's key order.
     if (psym !== undefined &&
-        (ts.symbolName(psym) === "KeyPairKeyObjectResult" ||
-            ts.symbolName(psym) === "KeyPairSyncResult") &&
+        (psymName === "KeyPairKeyObjectResult" || psymName === "KeyPairSyncResult") &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
@@ -4011,8 +4303,7 @@ function mapTypeInner(type, ctx) {
     // X509Certificate.toLegacyObject()'s PeerCertificate (and tls's detailed
     // form) is a plain checked-dynamic object.
     if (psym !== undefined &&
-        (ts.symbolName(psym) === "PeerCertificate" ||
-            ts.symbolName(psym) === "DetailedPeerCertificate") &&
+        (psymName === "PeerCertificate" || psymName === "DetailedPeerCertificate") &&
         psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
@@ -4024,7 +4315,7 @@ function mapTypeInner(type, ctx) {
     // it. JSON.stringify of one shows the fields where Node's internal-slot
     // object shows {} — the Dirent %dtype edge's cousin.
     if (psym !== undefined &&
-        ts.symbolName(psym) === "X509Certificate" &&
+        psymName === "X509Certificate" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
@@ -4048,9 +4339,9 @@ function mapTypeInner(type, ctx) {
     // record (util.inspect names the class from entryType, like Node).
     // @types/node declares the classes in perf_hooks and global interfaces
     // over them; the shipped fallback declares the classes.
-    if (((psym !== undefined && ts.symbolName(psym) === "PerformanceEntry") ||
-        (psym !== undefined && ts.symbolName(psym) === "PerformanceMark") ||
-        (psym !== undefined && ts.symbolName(psym) === "PerformanceMeasure")) &&
+    if (((psym !== undefined && psymName === "PerformanceEntry") ||
+        (psym !== undefined && psymName === "PerformanceMark") ||
+        (psym !== undefined && psymName === "PerformanceMeasure")) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "record", shapeId: perfEntryShape(ctx.shapes, ctx.unions) };
@@ -4275,6 +4566,40 @@ function mapTypeInner(type, ctx) {
     // (als.snapshot), called through the dyn call path.
     if (callSigs.length === 1 && isAsyncLocalStorageSnapshot(callSigs[0], ctx))
         return DYN;
+    // A process/net/stream `write` method taken as a value (`typeof
+    // process.stdout.write`, the saved original of an output guard): its
+    // overload set has no single compiled signature, and the value is the
+    // stream's replaceable method slot, so it is the checked-dynamic function
+    // the stream object hands out (scr_events.c ProcessStream).
+    if (callSigs.length > 1 && isStdlibStreamWriteOverloads(callSigs, ctx))
+        return DYN;
+    // An overload set held as a VALUE (a callback parameter, an alias, a
+    // variable, a member read): JavaScript stores ONE function, so the value
+    // is that function's erased type, the same slot a record member of this
+    // type stores (erasedOverloadMemberType). Calls through it convert the
+    // result back to the resolved overload's type (lowerCallThroughValue).
+    if (callSigs.length > 1 && isOverloadedCallableMemberType(widened, checker)) {
+        const erased = erasedOverloadMemberType(widened, ctx);
+        if (erased !== undefined)
+            return erased;
+    }
+    // A generic signature as a VALUE (`const f: <T>(x: T) => T`, a generic
+    // method's record slot, a union arm holding one): JavaScript erases type
+    // parameters, so the value is the ONE function every instantiation calls,
+    // and its type is that signature with each own type parameter bound to
+    // `unknown` — the erased func type erasedGenericMemberType /
+    // erasedOverloadMemberType already answer for generic-callable members.
+    // The calls that instantiate it convert their arguments in and their
+    // result out (lower-calls.ts, genericValueCall). A signature whose
+    // erasure does not map (a rest parameter, an unmappable position) keeps
+    // the fences below: undefined falls through to mapCallSignature's null.
+    if (erasedGenericSignatureType(widened, callSigs, ctx)) {
+        const erased = callSigs.length === 1
+            ? erasedGenericMemberType(widened, ctx)
+            : erasedOverloadMemberType(widened, ctx);
+        if (erased !== undefined)
+            return erased;
+    }
     if (callSigs.length === 1)
         return mapCallSignature(callSigs[0], ctx);
     // Records: object types whose members are all data properties (shorthand
@@ -4395,6 +4720,43 @@ function mapTypeInner(type, ctx) {
             });
         if (childShaped && core >= 2)
             return CHILD_T;
+        // A USER-declared writable-pipe interface — the writer half of the same
+        // idiom (a hand-written `Pipe { write(chunk: string): boolean; end():
+        // void }` naming child.stdin). Every member is named on the child
+        // stdin surface, `write` takes a chunk the writer takes (a string, or
+        // bytes such as a Uint8Array/Buffer) and answers the backpressure
+        // boolean, and at least one other member says writer (a lone `write`
+        // member is an ordinary record holding a function). The type maps to
+        // the child writer handle: in a compiled program the only VALUE
+        // producer is spawn's child.stdin, and the members lower against it.
+        const chunkIsWritten = (chunk) => {
+            const arms = chunk.kind === "union" ? (ctx.unions.get(chunk.unionId)?.arms ?? []) : [chunk];
+            return (arms.length > 0 &&
+                arms.every((arm) => arm.kind === "string" || (arm.kind === "bytes" && arm.elem === "u8")));
+        };
+        const writeMember = (p) => {
+            const sigs = checker.getCallSignatures(checker.getTypeOfSymbol(p));
+            if (sigs.length !== 1)
+                return false;
+            const sig = sigs[0];
+            const params = sig.getParameters();
+            if (params.length < 1 || params.length > 2)
+                return false;
+            if ((checker.getReturnTypeOfSignature(sig).flags & ts.TypeFlags.Boolean) === 0)
+                return false;
+            const chunk = mapType(checker.getTypeOfSymbol(params[0]), ctx);
+            return chunk !== null && chunkIsWritten(chunk);
+        };
+        const writerProps = checker.getPropertiesOfType(widened);
+        const writerShaped = writerProps.length >= 2 &&
+            writerProps.some((p) => ts.symbolName(p) === "write" && writeMember(p)) &&
+            writerProps.every((p) => CHILD_WRITER_MEMBERS.has(ts.symbolName(p)) &&
+                (ts.symbolName(p) !== "write" || writeMember(p)));
+        if (writerShaped) {
+            return ctx.generalNodeStreams === true
+                ? { kind: "object", className: "%Writable" }
+                : { kind: "childWriter" };
+        }
     }
     if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection) && callSigs.length === 0) {
         const viaMapped = mapBoundMappedType(widened, ctx);
@@ -4453,6 +4815,7 @@ function mapTypeInner(type, ctx) {
         try {
             const byKey = new Map();
             const recordParts = [];
+            const classParts = [];
             const substitutedUnions = [];
             // The lib's `T extends readonly unknown[] | []` idiom (Promise.all,
             // allSettled) maps an array input to `X[] | []`: the empty tuple is
@@ -4543,6 +4906,19 @@ function mapTypeInner(type, ctx) {
                 byKey.set(typeKey(mapped), mapped);
                 if (mapped.kind === "record")
                     recordParts.push({ source: part, mapped });
+                if (mapped.kind === "object")
+                    classParts.push({ source: part, mapped });
+            }
+            // A subclass arm beside one of its ancestor classes (`Shape | Circle`
+            // with `class Circle extends Shape`) is that ancestor: every instance
+            // of the subclass is an instance of the ancestor, the ancestor's slot
+            // holds it as the same pointer, and `instanceof` and member dispatch
+            // read the instance's own class. A union would box each value.
+            if (classParts.length > 1) {
+                for (const { source, mapped } of classParts) {
+                    if (programClassBases(source, ctx).some((base) => byKey.has(typeKey(base))))
+                        byKey.delete(typeKey(mapped));
+                }
             }
             const arms = [...byKey.values()];
             if (arms.length === 0)
@@ -4590,6 +4966,16 @@ function mapTypeInner(type, ctx) {
                 !unions.recursivePending(widened)) {
                 return DYN;
             }
+            // A module namespace beside another value in one slot (`[path.posix,
+            // path.win32]`, a `['posix', path.posix]` table row): a namespace has
+            // no union representation, and as a value it is the runtime's module
+            // object, so the slot is checked-dynamic. A namespace or null keeps
+            // its union (a probed process.getBuiltinModule result).
+            if (arms.some((a) => a.kind === "moduleNs") &&
+                arms.filter((a) => !isUnitType(a)).length > 1 &&
+                !unions.recursivePending(widened)) {
+                return DYN;
+            }
             // SEVERAL PROMISE ARMS are ONE: `Promise<A> | Promise<B>` is
             // `Promise<A | B>`. A promise arm's tag IS the `instanceof Promise`
             // test, so JavaScript cannot tell the arms apart at run time (both
@@ -4648,6 +5034,37 @@ function mapTypeInner(type, ctx) {
     }
     return null;
 }
+/** The classes a non-generic program class extends, nearest first, as
+ * long as each is a non-generic class the program declares. Empty for
+ * other types. */
+function programClassBases(instance, ctx) {
+    const bases = [];
+    let current = instance;
+    while (bases.length < MAP_TYPE_MAX_DEPTH) {
+        if (!programClassDeclaration(current, ctx))
+            break;
+        const base = ctx.checker.getBaseTypes(current)[0];
+        if (base === undefined || !programClassDeclaration(base, ctx))
+            break;
+        const mapped = mapType(base, ctx);
+        if (mapped?.kind !== "object")
+            break;
+        bases.push(mapped);
+        current = base;
+    }
+    return bases;
+}
+/** Whether `type` is the instance type of a non-generic class declared in
+ * the program's source. */
+function programClassDeclaration(type, ctx) {
+    if ((type.flags & ts.TypeFlags.Object) === 0 || !type.isClassOrInterface())
+        return false;
+    const decl = type.getSymbol()?.valueDeclaration;
+    if (decl === undefined || !ts.isClassDeclaration(decl) || decl.typeParameters?.nodes.length)
+        return false;
+    const file = ts.getSourceFileOfNode(decl);
+    return !file.isDeclarationFile && ctx.isProgramFile(file);
+}
 /** One non-overloaded call signature's func type (mapTypeInner's
  * single-signature rule; erasedOverloadMemberType maps each overload of a
  * member through it). */
@@ -4669,6 +5086,27 @@ function isAsyncLocalStorageSnapshot(sig, ctx) {
         ctx.isStdlibFile(ts.getSourceFileOfNode(decl)) &&
         isDeclaredInAmbientModule(decl, "async_hooks"));
 }
+const STREAM_WRITE_OWNERS = new Set(["Socket", "Writable", "WriteStream", "WritableStream"]);
+/** Every signature is a `write` method declared on a standard-library
+ * stream interface or class (net.Socket, stream.Writable, tty.WriteStream,
+ * NodeJS.WritableStream) — @types/node's or the fallback declarations'. */
+function isStdlibStreamWriteOverloads(sigs, ctx) {
+    return sigs.every((sig) => {
+        const decl = sig.declaration;
+        if (decl === undefined ||
+            !(ts.isMethodSignatureDeclaration(decl) || ts.isMethodDeclaration(decl)))
+            return false;
+        if (!ts.isIdentifier(decl.name) || decl.name.text !== "write")
+            return false;
+        const owner = decl.parent;
+        const ownerName = owner !== undefined && (ts.isInterfaceDeclaration(owner) || ts.isClassDeclaration(owner))
+            ? (owner.name?.text ?? null)
+            : null;
+        return (ownerName !== null &&
+            STREAM_WRITE_OWNERS.has(ownerName) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(decl)));
+    });
+}
 function mapCallSignature(sig, ctx) {
     const { checker } = ctx;
     if (sig.getTypeParameters().length && ctx.erasingSignature !== sig)
@@ -6389,6 +6827,57 @@ function mapEqualConstituentsIntersection(widened, ctx) {
     }
     return same;
 }
+/** A CLASS INSTANCE carrying expando properties
+ * (`Box & { preview?: Preview }`): one compiled class constituent and
+ * data-only object constituents that are not part of the class's own
+ * storage. It has no native layout — the class owns the struct and the
+ * other constituents are properties the instance carries at run time —
+ * and the checked-dynamic representation IS that object model: the value
+ * is the instance (identity, prototype, method dispatch), the class fields
+ * read and write through the live view in both directions, and the expando
+ * members live in its property table. Every other intersection keeps its
+ * existing treatment: reached only where the class view found extra
+ * members, and refusing everything that is not one class plus data. */
+function mapClassExpandoIntersection(widened, ctx) {
+    const { checker } = ctx;
+    if (checker.getConstructSignatures(widened).length > 0)
+        return null;
+    let classPart = null;
+    const expandoParts = [];
+    for (const part of ts.constituentTypes(widened)) {
+        const mapped = mapType(part, ctx);
+        if (mapped === null)
+            return null;
+        if (mapped.kind === "object") {
+            if (classPart !== null)
+                return null;
+            classPart = part;
+            continue;
+        }
+        // The expando members are DATA: a plain record, with no call or
+        // construct signature of its own.
+        if (mapped.kind !== "record")
+            return null;
+        if (checker.getCallSignatures(part).length > 0)
+            return null;
+        expandoParts.push(part);
+    }
+    if (classPart === null)
+        return null;
+    // The expando members are properties the class does not declare. An
+    // index signature names every key, and a member the class declares
+    // restates the class's own storage: both refine the class's members
+    // rather than add to them, and keep their diagnostics.
+    const classMembers = new Set(checker.getPropertiesOfType(classPart).map((member) => ts.symbolName(member)));
+    for (const part of expandoParts) {
+        if (checker.getIndexInfosOfType(part).length > 0)
+            return null;
+        for (const member of checker.getPropertiesOfType(part))
+            if (classMembers.has(ts.symbolName(member)))
+                return null;
+    }
+    return DYN;
+}
 function mapHybridCallableIntersection(widened, ctx) {
     const { checker, shapes } = ctx;
     if (!widened.isIntersectionType())
@@ -6750,6 +7239,70 @@ function packageTypeFile(sf, ctx) {
         (/[\\/]node_modules[\\/]/.test(sf.fileName) || ctx.isExperimentalFile?.(sf) === true) &&
         !ctx.isStdlibFile(sf));
 }
+/** `type`'s declarations — through its alias, or its own symbol when the
+ * checker gives it no alias — when EVERY one is a declaration-file
+ * declaration outside the standard library and the external type
+ * surfaces; null otherwise. */
+function packageDeclarations(sym, ctx) {
+    const decls = sym ? sym.declarations : undefined;
+    return decls &&
+        decls.length > 0 &&
+        decls.every((d) => {
+            const sf = ts.getSourceFileOfNode(d);
+            return sf.isDeclarationFile && !ctx.isStdlibFile(sf) && !ctx.isExternalTypeFile(sf);
+        })
+        ? decls
+        : null;
+}
+/** One non-union part's package provenance: true when the part is
+ * package-declared as data, false when it is package-declared with a value
+ * or implementation shape, null when no package declares it. */
+function packageDataPart(type, ctx) {
+    const aliasDecls = packageDeclarations(type.getAliasSymbol(), ctx);
+    const ownDecls = packageDeclarations(type.getSymbol(), ctx);
+    if (aliasDecls === null && (type.getAliasSymbol() !== undefined || ownDecls === null))
+        return null;
+    return purePackageDeclarations(aliasDecls, ctx) && purePackageDeclarations(ownDecls, ctx);
+}
+/** True when EVERY declaration `type` is spelled by is a pure data
+ * declaration (interface, type alias, object or mapped type literal,
+ * declared data class, type-only namespace) in a package declaration file —
+ * no value declaration merged in, no class implementation. */
+function purePackageDeclarations(decls, ctx) {
+    return (decls === null ||
+        decls.every((d) => packageTypeFile(ts.getSourceFileOfNode(d), ctx) &&
+            (ts.isInterfaceDeclaration(d) ||
+                ts.isTypeAliasDeclaration(d) ||
+                ts.isTypeLiteralNode(d) ||
+                ts.isMappedTypeNode(d) ||
+                isDeclaredDataClass(d) ||
+                (decls.some(isDeclaredDataClass) && isTypeOnlyNamespace(d)))));
+}
+/** True when `type` is PACKAGE-DECLARED as data: some part of its
+ * provenance is a package declaration, and no declaration it reaches is a
+ * value or implementation shape. Such a type describes data the PROGRAM
+ * built — `import type` from a package whose implementation is not part of
+ * the compiled module graph — so the structural rules map it like a local
+ * declaration, and a shape they cannot map is still that data, held as the
+ * checked-dynamic value (`mapTypeEntry`'s fallback). A member the package
+ * does not declare (a scalar beside a recursive knot) carries no provenance
+ * of its own. */
+export function packageTypeIsData(type, ctx) {
+    // `npmPackageOf` reaches the declaring package through the union's
+    // members; the value-shape test is per member and never recurses (a
+    // recursive alias reaches itself here).
+    const parts = type.isUnionType() ? ts.constituentTypes(type) : [type];
+    let declared = false;
+    for (const part of parts) {
+        const data = packageDataPart(part, ctx);
+        if (data === null)
+            continue;
+        declared = true;
+        if (!data)
+            return false;
+    }
+    return declared;
+}
 /** The record path's provenance fence. Declared shapes (object literals,
  * interfaces, type literals) must come from user code or an explicitly
  * mapped external type surface, never an arbitrary .d.ts — the empty
@@ -6849,6 +7402,26 @@ function mentionsErasedTypeParam(type, ctx, depth) {
                 return true;
     return false;
 }
+/** A type whose call signatures keep their own type parameters and that is
+ * pure function-shaped — call signatures only, no data properties, no
+ * construct or index signatures: the type of a generic function held as a
+ * value (`const f: <T>(x: T) => T`, an interface's generic method, a union
+ * arm naming one). mapType answers its erased func type
+ * (erasedGenericMemberType / erasedOverloadMemberType). False while the
+ * active erasure already IS one of these signatures: that mapping is
+ * mapCallSignature's own, and re-entering the erasure would recurse. */
+function erasedGenericSignatureType(t, sigs, ctx) {
+    if (sigs.length === 0)
+        return false;
+    if (!sigs.some((sig) => sig.getTypeParameters().length > 0))
+        return false;
+    if (ctx.erasingSignature !== undefined && sigs.includes(ctx.erasingSignature))
+        return false;
+    const { checker } = ctx;
+    return (checker.getConstructSignatures(t).length === 0 &&
+        checker.getPropertiesOfType(t).length === 0 &&
+        checker.getIndexInfosOfType(t).length === 0);
+}
 /** A generic callable member's runtime type: its one call signature with
  * every own type parameter bound to `unknown`, the erased instance a stored
  * or escaping definition carries (JavaScript erases type parameters the
@@ -6884,12 +7457,14 @@ export function erasedGenericMemberType(t, ctx) {
 }
 /** An OVERLOADED callable member type (`on(event: "a", h: (x: number) =>
  * void): () => void; on(event: "b", h: (x: string) => void): () => void`
- * in a program interface or type literal): two or more call signatures and
+ * in a program interface or type literal, or a class's body-less overload
+ * declarations above its implementation): two or more call signatures and
  * nothing else (no data properties, construct signatures, or index
  * signatures), every one declared in TypeScript program source. Such a
  * member keeps a record slot holding its erased runtime function
  * (erasedOverloadMemberType); calls convert per their resolved overload
- * (lowerRecordFieldCall). */
+ * (lowerRecordFieldCall). An overload set held as a value maps to the same
+ * erased function (mapTypeInner). */
 export function isOverloadedCallableMemberType(t, checker) {
     const sigs = checker.getCallSignatures(t);
     if (sigs.length < 2)
@@ -6902,7 +7477,12 @@ export function isOverloadedCallableMemberType(t, checker) {
         const decl = sig.declaration;
         if (decl === undefined)
             return false;
-        if (!ts.isMethodSignatureDeclaration(decl) && !ts.isCallSignatureDeclaration(decl))
+        // Interface and type-literal members, call signatures, and a class's
+        // body-less overload declarations (`getAuth(id: string): R;` above its
+        // implementation): each names one overload of ONE stored function.
+        if (!ts.isMethodSignatureDeclaration(decl) &&
+            !ts.isCallSignatureDeclaration(decl) &&
+            !(ts.isMethodDeclaration(decl) && decl.body === undefined))
             return false;
         const file = ts.getSourceFileOfNode(decl);
         return !file.isDeclarationFile && !isJsSourceFile(file);
@@ -7984,6 +8564,14 @@ function mergePromiseArms(arms, ctx) {
     // exactly `Promise<void>`.
     if (payload.every((arm) => arm.kind === "undefinedT"))
         payload.length = 0;
+    // SEVERAL MODULE NAMESPACES are ONE checked-dynamic payload: a namespace
+    // has no union tag (its value is the module's namespace object, built by
+    // the same dynamic box a bare namespace value crosses as), so JavaScript
+    // cannot tell the merged arms apart — `then((m) => …)` reads a namespace
+    // object either way. The joint payload is that object, exactly what
+    // `Promise<unknown>` settles here (moduleNamespacePromiseDynValue).
+    else if (payload.length > 1 && payload.every((arm) => arm.kind === "moduleNs"))
+        payload.splice(0, payload.length, DYN);
     // One payload arm is that arm itself (a regex or a promise payload has a
     // promise slot but no union arm); a JOINT payload is a union, so its arms
     // need union homes.