@scriptc/compiler 0.3.5 → 0.4.0

package/dist/frontend/type-mapper.js

@@ -2,7 +2,7 @@ import { InternalCompilerError } from "../errors.js";
 import { mockCallRecordType, mockContextType } from "./mock-shapes.js";
 import * as ts from "./ts7/adapter.js";
 import { bodyReadsArguments } from "./arguments-usage.js";
-import { BYTES_ELEMENT_NAME, arrayOf, BOOL, bytesOf, canConvertToDyn, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, ZLIB_STREAM_MODES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, unionContainerArmsOk, UNDEFINED_T, VOID, } from "../ir/ir.js";
+import { BYTES_ELEMENT_NAME, arrayOf, isDynTypedRefType, BOOL, bytesOf, canConvertToDyn, canDynCheckTo, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, ZLIB_STREAM_MODES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, maybePromiseUnionArmsOk, unionContainerArmsOk, UNDEFINED_T, VOID, } from "../ir/ir.js";
 import { BIGINT_T } from "../ir/ir.js";
 import { literalValues } from "./literal-values.js";
 import { remapUnionDiscriminant } from "./union-discriminants.js";
@@ -21,7 +21,7 @@ function runtimeParameterCount(parameters) {
 /** Empty JS object inference describes no fixed layout. Keep these values
  * in checked storage across fields, parameters and function signatures. */
 export function jsOpenObjectType(decl, type, shapes, unions) {
-    if (!decl || !isJsSourceFile(decl.getSourceFile()))
+    if (!decl || !isJsSourceFile(ts.getSourceFileOfNode(decl)))
         return type;
     const arms = type.kind === "union" ? unions.get(type.unionId)?.arms : [type];
     const present = arms?.filter((arm) => arm.kind !== "undefinedT");
@@ -67,6 +67,25 @@ export function jsOpenObjectType(decl, type, shapes, unions) {
         ? DYN
         : type;
 }
+/** The modules whose RequestOptions interface maps to the checked dynamic. */
+const HTTP_REQUEST_OPTION_MODULES = new Set([
+    "http",
+    "node:http",
+    "https",
+    "node:https",
+]);
+/** The WebCrypto interfaces whose values are checked-dynamic: the crypto
+ * global, SubtleCrypto, CryptoKey handles and the algorithm dictionaries
+ * (scr_webcrypto.c). */
+export const WEBCRYPTO_DYN_TYPES = new Set([
+    "Crypto",
+    "SubtleCrypto",
+    "CryptoKey",
+    "Algorithm",
+    "KeyAlgorithm",
+    "HmacImportParams",
+    "HmacKeyAlgorithm",
+]);
 export const FETCH_AMBIENT_TYPES = [
     "Response",
     "Request",
@@ -74,6 +93,7 @@ export const FETCH_AMBIENT_TYPES = [
     "RequestInit",
     "Event",
     "CustomEvent",
+    "MessageEvent",
     "EventTarget",
     "AddEventListenerOptions",
     "EventListenerOptions",
@@ -232,7 +252,7 @@ export class ShapeRegistry {
             comparePriority(previous, this.currentDeclaredOrderPriority) <= 0) {
             return;
         }
-        shape.declaredOrder = declaredOrder;
+        shape.declaredOrder = this.withExtendedNames(shape.id, declaredOrder);
         this.declaredOrderPriority.set(shape.id, this.currentDeclaredOrderPriority);
     }
     /** Mutable generic-instance ranks settle only after reachability closes.
@@ -250,7 +270,7 @@ export class ShapeRegistry {
             const shape = this.byId.get(shapeId);
             if (!shape)
                 continue;
-            shape.declaredOrder = best.order;
+            shape.declaredOrder = this.withExtendedNames(shapeId, best.order);
             this.declaredOrderPriority.set(shapeId, best.priority);
         }
         for (const finalize of this.derivedDeclaredOrderFinalizers)
@@ -274,7 +294,7 @@ export class ShapeRegistry {
                 return;
             const next = order();
             if (next !== undefined)
-                shape.declaredOrder = next;
+                shape.declaredOrder = this.withExtendedNames(shape.id, next);
         };
     }
     /** The shape id a back-reference to an in-progress type resolves to:
@@ -367,6 +387,52 @@ export class ShapeRegistry {
     get(shapeId) {
         return this.byId.get(shapeId);
     }
+    /** Names extendShape added to a shape, which every key-order table the
+     * shape adopts lists after its declared names. */
+    extendedNames = new Map();
+    /** The members extendShape attached to a shape (empty for most). */
+    attachedNames(shapeId) {
+        return this.extendedNames.get(shapeId) ?? [];
+    }
+    withExtendedNames(shapeId, order) {
+        const extra = this.extendedNames.get(shapeId);
+        if (!extra)
+            return order;
+        const missing = extra.filter((name) => !order.includes(name));
+        return missing.length === 0 ? order : [...order, ...missing];
+    }
+    /** Adds optional fields to an interned shape in place: members a type
+     * assertion attaches to the shape's values (`r as R & { tag: string }`
+     * followed by `view.tag = ...`; see assertion-members.ts). Every value
+     * of the shape holds them absent until a write through such a view, so
+     * the shape keeps its id, both structural keys resolve to it, and its
+     * key-order table lists the new names after the declared ones. Runs
+     * before any body lowers; existing layouts change, so the revision
+     * advances like a closing recursive placeholder. */
+    extendShape(shapeId, extra) {
+        const shape = this.byId.get(shapeId);
+        if (!shape || shape.tuple || extra.length === 0)
+            return;
+        const fresh = extra.filter((f) => !shape.fields.some((x) => x.name === f.name));
+        if (fresh.length === 0)
+            return;
+        shape.fields = [...shape.fields, ...fresh].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        this.extendedNames.set(shapeId, [
+            ...(this.extendedNames.get(shapeId) ?? []),
+            ...fresh.map((f) => f.name),
+        ]);
+        if (shape.declaredOrder)
+            shape.declaredOrder = this.withExtendedNames(shapeId, shape.declaredOrder);
+        const candidates = this.declaredOrderCandidates.get(shapeId);
+        if (candidates) {
+            for (const c of candidates)
+                c.order = this.withExtendedNames(shapeId, c.order);
+        }
+        this.revision++;
+        const key = this.keyOf(shape.fields, false, shape.indexValue);
+        if (!this.byKey.has(key))
+            this.byKey.set(key, shapeId);
+    }
 }
 /** The frontend's union interner — mirrors ShapeRegistry. A union's
  * canonical identity includes its typeKey-sorted arms and literal
@@ -527,6 +593,7 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
             case "bool":
                 return append("boolean");
             case "dyn":
+            case "jsval":
                 return append("unknown");
             case "caught":
                 // What tsc calls the binding; the fence messages carry the real story.
@@ -793,7 +860,7 @@ function isDeclaredInAmbientModule(d, name) {
 /** True when the declaration's nearest enclosing namespace is `name`
  * (`declare global { namespace NodeJS { ... } }` — the NodeJS-global
  * interfaces @types/node declares outside any ambient module). */
-function isDeclaredInAmbientNamespace(d, name) {
+export function isDeclaredInAmbientNamespace(d, name) {
     let node = d.parent;
     while (node) {
         if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
@@ -803,6 +870,39 @@ function isDeclaredInAmbientNamespace(d, name) {
     }
     return false;
 }
+/** 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. */
+export function isGeneralNodeStreamInterface(type, ctx) {
+    const psym = type.getSymbol() ?? type.getAliasSymbol();
+    if (psym === undefined)
+        return false;
+    return psym.declarations.some((d) => {
+        if (!(ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)))
+            return false;
+        if (!ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
+            return false;
+        if (ts.symbolName(psym) === "ReadableStream" || ts.symbolName(psym) === "WritableStream")
+            return ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS");
+        if (ts.symbolName(psym) === "ChildStdin")
+            return isDeclaredInAmbientModule(d, "child_process");
+        return ((ts.symbolName(psym) === "Readable" || ts.symbolName(psym) === "Writable") &&
+            isNodeTypesPath(ts.getSourceFileOfNode(d).fileName) &&
+            isDeclaredInAmbientModule(d, "stream"));
+    });
+}
+/** A type declared in the shipped WebAssembly namespace (scriptc.d.ts):
+ * its modules, instances, memories, tables, globals, error classes and the
+ * Exports/Imports records. */
+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"));
+}
 /** True when a type contains a record anywhere (the trigger for the
  * shape-mismatch diagnostic SC2002 — non-record mismatches are tsc's or
  * the validator's business). */
@@ -928,8 +1028,8 @@ export function isLegacyUrlType(type, ctx) {
 export function isLegacyUrlSymbol(symbol, ctx) {
     if (!symbol)
         return false;
-    for (const d of ctx.checker.declarationsOf(symbol)) {
-        if (!ctx.isStdlibFile(d.getSourceFile()))
+    for (const d of symbol.declarations) {
+        if (!ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
             continue;
         let family = false;
         for (let n = d; n; n = n.parent) {
@@ -958,10 +1058,11 @@ export function isOsConstantsType(type, ctx) {
 export function isOsConstantsSymbol(symbol, ctx, types = false) {
     if (!symbol)
         return false;
-    for (const d of ctx.checker.declarationsOf(symbol)) {
+    for (const d of symbol.declarations) {
         const alias = types && ts.isTypeAliasDeclaration(d) && d.name.text === "SignalConstants";
         const signals = !types && ts.isVariableDeclaration(d) && ts.isIdentifier(d.name) && d.name.text === "signals";
-        if (!(alias || signals || ts.isModuleDeclaration(d)) || !ctx.isStdlibFile(d.getSourceFile()))
+        if (!(alias || signals || ts.isModuleDeclaration(d)) ||
+            !ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
             continue;
         let inConstants = ts.isModuleDeclaration(d) && d.name.text === "constants";
         for (let n = d.parent; n; n = n.parent) {
@@ -981,13 +1082,163 @@ export function isOsConstantsSymbol(symbol, ctx, types = false) {
 /** worker_threads' Worker and MessagePort: owned runtime handles that keep
  * their live object representation (DYN) wherever they are stored. */
 function isWorkerHandleSymbol(symbol, ctx) {
-    return ((symbol?.name === "Worker" || symbol?.name === "MessagePort") &&
-        ctx.checker
-            .declarationsOf(symbol)
-            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    return (((symbol !== undefined && ts.symbolName(symbol) === "Worker") ||
+        (symbol !== undefined && ts.symbolName(symbol) === "MessagePort") ||
+        (symbol !== undefined && ts.symbolName(symbol) === "MessageChannel") ||
+        (symbol !== undefined && ts.symbolName(symbol) === "BroadcastChannel")) &&
+        symbol.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "worker_threads")));
 }
+/** The `{ message: any }` object type (or its union with undefined) that
+ * worker_threads declares as receiveMessageOnPort's result. */
+/** A union of dns lookup option bags with numbers and nullish values that
+ * includes LookupAllOptions (whose `all: true` arm has no record form). */
+function isLookupOptionsUnion(type, ctx) {
+    if (!type.isUnionType())
+        return false;
+    let all = false;
+    for (const member of ts.constituentTypes(type)) {
+        if (member.flags & (ts.TypeFlags.NumberLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined))
+            continue;
+        const symbol = member.getSymbol();
+        if (symbol === undefined ||
+            !/^Lookup(One|All)?Options$/.test(ts.symbolName(symbol)) ||
+            !symbol.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
+            return false;
+        if (ts.symbolName(symbol) === "LookupAllOptions")
+            all = true;
+    }
+    return all;
+}
+/** The binary and stream members of fetch's BodyInit (undici-types):
+ * NodeJS.ArrayBufferView expands to the typed arrays and DataView. */
+const FETCH_BODY_MEMBERS = new Set([
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "AsyncIterable",
+    "Iterable",
+    "Blob",
+    "FormData",
+    "URLSearchParams",
+    "ReadableStream",
+    "DataView",
+    "Buffer",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float16Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array",
+]);
+/** fetch's request body type, BodyInit, however TypeScript spells it
+ * (`RequestInit["body"]`, `NonNullable<...>`, an optional member): a
+ * union of strings, the stdlib binary and stream types and nullish
+ * values that includes both FormData and URLSearchParams. Native fetch
+ * reads such a body at run time, so it rides checked-dynamic storage. */
+function isFetchBodyUnion(type, ctx) {
+    if (!type.isUnionType())
+        return false;
+    let formData = false;
+    let searchParams = false;
+    for (const member of ts.constituentTypes(type)) {
+        if (member.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined))
+            continue;
+        const symbol = member.getSymbol();
+        if (symbol === undefined ||
+            !FETCH_BODY_MEMBERS.has(ts.symbolName(symbol)) ||
+            !symbol.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
+            return false;
+        if (ts.symbolName(symbol) === "FormData")
+            formData = true;
+        if (ts.symbolName(symbol) === "URLSearchParams")
+            searchParams = true;
+    }
+    return formData && searchParams;
+}
+/** A mapped object type (Omit, Pick, Partial) whose members all come from
+ * one stdlib interface that maps to the checked dynamic. */
+function isDynInterfaceSubset(type, ctx) {
+    if (!(type.flags & ts.TypeFlags.Object) || type.isClassOrInterface())
+        return false;
+    const alias = type.getAliasSymbol();
+    if (alias === undefined)
+        return false;
+    const props = ctx.checker.getPropertiesOfType(type);
+    if (props.length === 0)
+        return false;
+    let owner;
+    for (const prop of props) {
+        const decl = prop.declarations[0];
+        const parent = decl?.parent;
+        if (parent === undefined ||
+            !ts.isInterfaceDeclaration(parent) ||
+            !ctx.isStdlibFile(ts.getSourceFileOfNode(parent)) ||
+            (owner !== undefined && owner !== parent))
+            return false;
+        owner = parent;
+    }
+    return (owner !== undefined && mapType(ctx.checker.getTypeAtLocation(owner.name), ctx)?.kind === "dyn");
+}
+/** fetch's HeadersInit (undici-types): a union of the stdlib Headers
+ * class with header-pair arrays and/or a header record, plus nullish
+ * values. Native fetch reads it at run time like the init around it. */
+function isFetchHeadersUnion(type, ctx) {
+    if (!type.isUnionType())
+        return false;
+    let headers = false;
+    let other = false;
+    for (const member of ts.constituentTypes(type)) {
+        if (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
+            continue;
+        const symbol = member.getSymbol();
+        if (symbol !== undefined &&
+            ts.symbolName(symbol) === "Headers" &&
+            symbol.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            headers = true;
+            continue;
+        }
+        const alias = ts.symbolNameOf(member.getAliasSymbol());
+        if ((symbol !== undefined && ts.symbolName(symbol) === "Array") ||
+            (symbol !== undefined && ts.symbolName(symbol) === "ReadonlyArray") ||
+            alias === "Record" ||
+            alias === "HeaderRecord") {
+            other = true;
+            continue;
+        }
+        return false;
+    }
+    return headers && other;
+}
+function isReceiveMessageResult(type, ctx) {
+    const members = type.isUnionType() ? ts.constituentTypes(type) : [type];
+    let found = false;
+    for (const member of members) {
+        if (member.flags & ts.TypeFlags.Undefined)
+            continue;
+        const decl = member.getSymbol() ? member.getSymbol().declarations[0] : undefined;
+        let fn = decl?.parent;
+        while (fn && ts.isUnionTypeNode(fn))
+            fn = fn.parent;
+        if (!decl ||
+            !ts.isTypeLiteralNode(decl) ||
+            !fn ||
+            !ts.isFunctionDeclaration(fn) ||
+            fn.name?.text !== "receiveMessageOnPort" ||
+            !ctx.isStdlibFile(ts.getSourceFileOfNode(decl)) ||
+            !isDeclaredInAmbientModule(fn, "worker_threads")) {
+            return false;
+        }
+        found = true;
+    }
+    return found;
+}
 /** True for a type built only from worker handles, null/undefined, and
  * arrays of those: values that keep the live DYN representation. */
 export function isWorkerHandleType(type, ctx) {
@@ -1008,6 +1259,57 @@ export function isWorkerHandleType(type, ctx) {
     }
     return handle;
 }
+/** The return annotation of an `async *` declaration spelled with the
+ * protocol interfaces the generator object implements —
+ * `AsyncIterator<T>`, `AsyncIterableIterator<T>` or `AsyncIterable<T>` (pi's
+ * `async *[Symbol.asyncIterator](): AsyncIterator<T>`): the body always
+ * produces an async generator, so the declaration maps exactly like an
+ * `AsyncGenerator<T, TReturn, TNext>` annotation. Values of these types
+ * elsewhere stay unmapped (they can hold any object implementing the
+ * protocol). Null when the annotation is not one of them. */
+export function mapAsyncGeneratorAnnotation(type, ctx) {
+    const { checker } = ctx;
+    const symbol = type.getSymbol();
+    if (!symbol ||
+        !["AsyncIterator", "AsyncIterableIterator", "AsyncIterable"].includes(ts.symbolName(symbol)) ||
+        !symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
+        return null;
+    const args = checker.getTypeArguments(type);
+    const channels = genChannels(args[0], args[1], args[2], ctx);
+    if (!channels)
+        return null;
+    if (!genResultRecord(channels.yieldT, channels.retT, ctx.shapes, ctx.unions))
+        return null;
+    return { kind: "generator", async: true, ...channels };
+}
+/** The native fetch handles (Headers, Request, Response), optionally in
+ * arrays or with null/undefined: checked-dynamic handles wherever they are
+ * stored, like the worker handles above. */
+export function isFetchHandleType(type, ctx) {
+    const members = type.isUnionType() ? ts.constituentTypes(type) : [type];
+    let handle = false;
+    for (const member of members) {
+        if (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
+            continue;
+        if (ctx.checker.isArrayType(member)) {
+            const element = ctx.checker.getTypeArguments(member)[0];
+            if (element === undefined || !isFetchHandleType(element, ctx))
+                return false;
+        }
+        else {
+            const symbol = member.getSymbol();
+            if (!symbol ||
+                (ts.symbolName(symbol) !== "Headers" &&
+                    ts.symbolName(symbol) !== "Request" &&
+                    ts.symbolName(symbol) !== "Response") ||
+                !symbol.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                    ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
+                return false;
+        }
+        handle = true;
+    }
+    return handle;
+}
 export function mapType(type, ctx) {
     if (mapTypeDepth >= MAP_TYPE_MAX_DEPTH)
         return null;
@@ -1035,7 +1337,18 @@ export function mapType(type, ctx) {
     const sensitivityAtEntry = contextResolutions;
     mapTypeDepth++;
     try {
-        const mapped = mapTypeInner(type, ctx);
+        let mapped;
+        try {
+            mapped = mapTypeInner(type, ctx);
+        }
+        catch (e) {
+            // typescript-go's API can panic serializing a union's members (an
+            // empty tuple cloned as an array literal, `s.match(re) || []`): a
+            // union the checker cannot describe has no representation.
+            if (!topLevel || !ts.isUnreadableConstituentsPanic(e))
+                throw e;
+            mapped = null;
+        }
         if (mapped !== null &&
             memoKey !== null &&
             topLevel &&
@@ -1058,34 +1371,135 @@ function classExprNeedsContext(decl) {
     }
     return false;
 }
+/** True for the type of a TypeScript object literal with no contextual
+ * type (`const options = { ...location, path }`) that spreads a value
+ * mapping to the checked dynamic (a stdlib options type such as
+ * http.RequestOptions). A literal with a contextual type is built in that
+ * type's representation instead, and JavaScript literals keep their own
+ * rules. */
+function spreadsCheckedDynamic(symbol, ctx) {
+    if (symbol === undefined || (symbol.flags & ts.SymbolFlags.ObjectLiteral) === 0)
+        return false;
+    const decl = symbol.declarations[0];
+    if (decl === undefined || !ts.isObjectLiteralExpression(decl))
+        return false;
+    if (isJsSourceFile(ts.getSourceFileOfNode(decl)))
+        return false;
+    if (ctx.checker.getContextualType(decl))
+        return false;
+    return decl.properties.nodes.some((prop) => ts.isSpreadAssignment(prop) &&
+        mapType(ctx.checker.getTypeAtLocation(prop.expression), ctx)?.kind === "dyn");
+}
 function mapTypeInner(type, ctx) {
     const { checker, unions, classNamer, resolveTypeParam } = ctx;
     // TypeScript's intrinsic globalThis symbol has no declaration. A stored
     // reference needs native object identity, including var's undefined state.
     const intrinsic = type.getSymbol();
-    if (intrinsic?.name === "globalThis" && checker.declarationsOf(intrinsic).length === 0)
+    if (intrinsic !== undefined &&
+        ts.symbolName(intrinsic) === "globalThis" &&
+        intrinsic.declarations.length === 0)
         return DYN;
+    if (ctx.jsDynamicDeclaration !== undefined && intrinsic !== undefined) {
+        const objectLiteral = (intrinsic.flags & ts.SymbolFlags.ObjectLiteral) !== 0;
+        const classInstance = (intrinsic.flags & ts.SymbolFlags.Class) !== 0 && type.isClassOrInterface();
+        if ((objectLiteral || classInstance) &&
+            intrinsic.declarations.some((decl) => ctx.jsDynamicDeclaration(decl)))
+            return DYN;
+    }
     {
         const moduleId = ctx.moduleNamespaceId?.(type) ?? null;
         if (moduleId !== null)
             return { kind: "moduleNs", moduleId };
     }
+    // A TypeScript object literal that spreads a checked-dynamic value
+    // (`{ ...requestOptions, path, timeout }`): its keys are the source's
+    // runtime keys, which no record shape holds, so the literal rides
+    // checked-dynamic storage like its source.
+    if (spreadsCheckedDynamic(intrinsic, ctx))
+        return DYN;
+    // worker_threads.receiveMessageOnPort's `{ message: any } | undefined`:
+    // the runtime's { message } object, a checked-dynamic value.
+    if (isReceiveMessageResult(type, ctx))
+        return DYN;
+    if (isFetchBodyUnion(type, ctx) || isFetchHeadersUnion(type, ctx))
+        return DYN;
+    // Omit/Pick/Partial of a stdlib interface that rides checked-dynamic
+    // storage (`Omit<RequestInit, "body" | "headers">`): every member comes
+    // from that interface, so the value is a subset of the same runtime-read
+    // options object and rides the same storage.
+    if (isDynInterfaceSubset(type, ctx))
+        return DYN;
+    // The lookup-function option union (`LookupOneOptions | LookupAllOptions
+    // | number | undefined`): with a LookupAllOptions arm it is an option bag
+    // dns.lookup reads at run time, so it rides checked-dynamic storage.
+    if (isLookupOptionsUnion(type, ctx))
+        return DYN;
     // @types/node spells child_process.ExecFileException as an intersection
     // type alias over two Error-derived metadata interfaces. The value is
     // still one ordinary Error; recognize the owned alias before generic
     // intersection mapping decomposes it into unsupported utility types.
     const directAlias = type.getAliasSymbol();
-    if (directAlias?.name === "ExecFileException" &&
-        checker.declarationsOf(directAlias).some((decl) => ctx.isStdlibFile(decl.getSourceFile()))) {
+    if (directAlias !== undefined &&
+        ts.symbolName(directAlias) === "ExecFileException" &&
+        directAlias.declarations.some((decl) => ctx.isStdlibFile(ts.getSourceFileOfNode(decl)))) {
+        return { kind: "object", className: "%Error" };
+    }
+    // child_process.ExecException, exec's callback error, is an interface
+    // extending Error with optional metadata members; the value is one
+    // ordinary Error as well.
+    const execException = type.getSymbol();
+    if (execException !== undefined &&
+        ts.symbolName(execException) === "ExecException" &&
+        execException.declarations.some((decl) => ts.isInterfaceDeclaration(decl) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(decl)) &&
+            isDeclaredInAmbientModule(decl, "child_process"))) {
         return { kind: "object", className: "%Error" };
     }
     if (isOsConstantsType(type, ctx) || isLegacyUrlType(type, ctx))
         return DYN;
+    // The WebAssembly API's values have the checked-dynamic representation, so
+    // declarations that merely mention them compile; each reached use of the
+    // API itself is refused at its site (builtins/webassembly.ts).
+    if (isWebAssemblyType(type, ctx))
+        return DYN;
+    // A union over one of them (quickjs-wasi's `BufferSource | WebAssembly.Module`
+    // option) holds that dynamic value too, so the whole union is dynamic.
+    if (type.isUnionType() && ts.constituentTypes(type).some((t) => isWebAssemblyType(t, ctx)))
+        return DYN;
+    // JavaScript inference merges WebAssembly.instantiate's overloads into
+    // `Promise<WebAssemblyInstantiatedSource> & Promise<Instance>`: a promise
+    // of a WebAssembly value either way.
+    if (type.isIntersectionType() &&
+        ts.constituentTypes(type).every((t) => {
+            if (ts.symbolNameOf(t.getSymbol()) !== "Promise")
+                return false;
+            const arg = ctx.checker.getTypeArguments(t)[0];
+            return arg !== undefined && isWebAssemblyType(arg, ctx);
+        }))
+        return { kind: "promise", inner: DYN };
     // Immutable<T> (@scriptc/types) is a deep-readonly view: the value is
     // still the T it maps.
     const immutableSource = immutableSourceType(type, ctx);
     if (immutableSource !== null)
         return mapType(immutableSource, ctx);
+    // Inside an erased generic signature or body, every type that mentions
+    // an erased type parameter is `unknown` (`T[]`, `Map<string, T>`,
+    // `[A, B]`, `T[K]`, callbacks over `T`): its values cross through the
+    // checked-dynamic boundary, as JavaScript sees them. The erased
+    // signature itself maps its parameters and result this way.
+    if ((ctx.erasingSignature || ctx.isErasing?.()) &&
+        !(type.flags & ts.TypeFlags.TypeParameter) &&
+        !checker.getCallSignatures(type).some((sig) => sig === ctx.erasingSignature) &&
+        !ERASURE_KEPT_CONTAINERS.has(ts.symbolNameOf(type.getSymbol()) ?? "") &&
+        mentionsErasedTypeParam(type, ctx, 0)) {
+        contextResolutions++;
+        return DYN;
+    }
+    // Readonly<C> over a program class (Object.freeze's result type) is the
+    // same instance.
+    const readonlyClass = readonlyClassType(type, ctx);
+    if (readonlyClass !== null)
+        return readonlyClass;
     if (resolveTypeParam && type.flags & ts.TypeFlags.TypeParameter) {
         const bound = resolveTypeParam(type);
         if (bound) {
@@ -1124,6 +1538,27 @@ function mapTypeInner(type, ctx) {
             contextResolutions++;
             return viaIndexed;
         }
+        // `Parameters<F>` / `ReturnType<F>` over a bound function-typed
+        // parameter (variadic higher-order wrappers): the checker keeps both
+        // conditionals symbolic inside the body, and their `infer` positions
+        // match a call signature, which matchInferReference cannot decide.
+        const viaSignature = mapBoundSignatureAlias(type, ctx) ?? mapBoundKeyofNeverConditional(type, ctx);
+        if (viaSignature !== null) {
+            contextResolutions++;
+            return viaSignature;
+        }
+        // A conditional type over a bound parameter (`Infer<S["left"]>`, a
+        // mapped type's member): evaluate it against the bindings.
+        if (type.isConditionalType()) {
+            const evaluated = evalMappedTemplate(type, new Map(), new Map(), ctx);
+            if (evaluated && evaluated !== type) {
+                const viaConditional = mapType(evaluated, ctx);
+                if (viaConditional !== null) {
+                    contextResolutions++;
+                    return viaConditional;
+                }
+            }
+        }
     }
     const widened = checker.getBaseTypeOfLiteralType(type);
     const flags = widened.flags;
@@ -1138,8 +1573,9 @@ function mapTypeInner(type, ctx) {
     // checked-dynamic object retains that distinction through forwarding
     // constructors. Only the standard library's interface gets this ABI.
     const errorOptionsSymbol = widened.getSymbol();
-    if (errorOptionsSymbol?.name === "ErrorOptions" &&
-        checker.declarationsOf(errorOptionsSymbol).some((d) => ctx.isStdlibFile(d.getSourceFile()))) {
+    if (errorOptionsSymbol !== undefined &&
+        ts.symbolName(errorOptionsSymbol) === "ErrorOptions" &&
+        errorOptionsSymbol.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
     // node:util.parseArgs config/results are declaration-heavy conditional
@@ -1153,7 +1589,7 @@ function mapTypeInner(type, ctx) {
     {
         const parseArgsSym = widened.getAliasSymbol() ?? widened.getSymbol();
         const belongs = (declaration) => {
-            if (!ctx.isStdlibFile(declaration.getSourceFile()))
+            if (!ctx.isStdlibFile(ts.getSourceFileOfNode(declaration)))
                 return false;
             let family = false;
             for (let node = declaration; node; node = node.parent) {
@@ -1167,15 +1603,14 @@ function mapTypeInner(type, ctx) {
             return false;
         };
         if (parseArgsSym &&
-            PARSE_ARGS_DYN_TYPES.has(parseArgsSym.name) &&
-            checker.declarationsOf(parseArgsSym).some(belongs))
+            PARSE_ARGS_DYN_TYPES.has(ts.symbolName(parseArgsSym)) &&
+            parseArgsSym.declarations.some(belongs))
             return DYN;
         // ReturnType and instantiated conditional types can erase the alias.
         // Require every member to retain the util declaration provenance so
         // unrelated records with similar property names keep their own layout.
         const members = checker.getPropertiesOfType(widened);
-        if (members.length > 0 &&
-            members.every((member) => checker.declarationsOf(member).some(belongs)))
+        if (members.length > 0 && members.every((member) => member.declarations.some(belongs)))
             return DYN;
     }
     // The lib's BOXED wrapper interfaces used as TYPES (`const n: Number =
@@ -1186,9 +1621,15 @@ function mapTypeInner(type, ctx) {
     {
         const boxSym = widened.getSymbol();
         if (boxSym &&
-            (boxSym.name === "Number" || boxSym.name === "String" || boxSym.name === "Boolean") &&
-            checker.declarationsOf(boxSym).some((d) => ctx.isStdlibFile(d.getSourceFile()))) {
-            return boxSym.name === "Number" ? F64 : boxSym.name === "String" ? STRING : BOOL;
+            (ts.symbolName(boxSym) === "Number" ||
+                ts.symbolName(boxSym) === "String" ||
+                ts.symbolName(boxSym) === "Boolean") &&
+            boxSym.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            return ts.symbolName(boxSym) === "Number"
+                ? F64
+                : ts.symbolName(boxSym) === "String"
+                    ? STRING
+                    : BOOL;
         }
     }
     // The lib's PRIMITIVE-CONSTRUCTOR interfaces as TYPES (`typeof String`,
@@ -1205,13 +1646,13 @@ function mapTypeInner(type, ctx) {
     {
         const ctorSym = widened.getSymbol();
         if (ctorSym &&
-            (ctorSym.name === "StringConstructor" ||
-                ctorSym.name === "NumberConstructor" ||
-                ctorSym.name === "BooleanConstructor") &&
-            checker.declarationsOf(ctorSym).some((d) => ctx.isStdlibFile(d.getSourceFile()))) {
-            return funcOf([STRING], ctorSym.name === "StringConstructor"
+            (ts.symbolName(ctorSym) === "StringConstructor" ||
+                ts.symbolName(ctorSym) === "NumberConstructor" ||
+                ts.symbolName(ctorSym) === "BooleanConstructor") &&
+            ctorSym.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            return funcOf([STRING], ts.symbolName(ctorSym) === "StringConstructor"
                 ? STRING
-                : ctorSym.name === "NumberConstructor"
+                : ts.symbolName(ctorSym) === "NumberConstructor"
                     ? F64
                     : BOOL);
         }
@@ -1315,16 +1756,21 @@ function mapTypeInner(type, ctx) {
             return hasStr ? STRING : F64;
         }
     }
-    // @scriptc/experimental's LifetimeRegion and InternTable: synthetic
-    // program classes, provenance-checked by the package's declaration file.
+    // @scriptc/experimental's LifetimeRegion, InternTable and ThreadSlots:
+    // synthetic program classes, provenance-checked by the package's
+    // declaration file.
     {
         const classSym = widened.getSymbol();
-        const name = classSym?.name;
-        if (name === "LifetimeRegion" || name === "InternTable") {
-            for (const d of checker.declarationsOf(classSym)) {
+        const name = ts.symbolNameOf(classSym);
+        if (name === "LifetimeRegion" || name === "InternTable" || name === "ThreadSlots") {
+            for (const d of classSym.declarations) {
                 if (!ts.isClassDeclaration(d))
                     continue;
-                const synthetic = name === "LifetimeRegion" ? ctx.lifetimeRegionClass?.(d) : ctx.internTableClass?.(d);
+                const synthetic = name === "LifetimeRegion"
+                    ? ctx.lifetimeRegionClass?.(d)
+                    : name === "InternTable"
+                        ? ctx.internTableClass?.(d)
+                        : ctx.threadSlotsClass?.(d);
                 if (synthetic)
                     return synthetic;
             }
@@ -1333,15 +1779,33 @@ function mapTypeInner(type, ctx) {
     // Declaration-only package types have no compiled implementation.
     // Primitive and container types retain their structural mappings; types
     // owned by the standard library or explicit host mappings are handled
-    // by their dedicated native rules.
-    const npmSym = widened.getAliasSymbol() ?? widened.getSymbol();
-    const npmDecls = npmSym ? checker.declarationsOf(npmSym) : undefined;
-    if (npmDecls &&
-        npmDecls.length > 0 &&
-        npmDecls.every((d) => {
-            const sf = d.getSourceFile();
-            return sf.isDeclarationFile && !ctx.isStdlibFile(sf) && !ctx.isExternalTypeFile(sf);
-        })) {
+    // by their dedicated native rules. Pure type shapes — interfaces, type
+    // aliases, and object or mapped type literals with no value declaration
+    // merged in — describe data, not an implementation: a program value of
+    // 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)));
+    const aliasDecls = packageOnly(widened.getAliasSymbol());
+    const ownDecls = packageOnly(widened.getSymbol());
+    if ((aliasDecls !== null || (widened.getAliasSymbol() === undefined && ownDecls !== null)) &&
+        !(pureTypeShape(aliasDecls) && pureTypeShape(ownDecls))) {
         return null;
     }
     // Module namespaces were claimed above when they name compiled source
@@ -1534,19 +1998,24 @@ function mapTypeInner(type, ctx) {
     // Class instances name a program class. The same symbol with construct
     // signatures names its static side, mapped to classval below.
     const widenedSym = widened.getSymbol();
-    const classDecl = widenedSym ? checker.valueDeclarationOf(widenedSym) : undefined;
+    const classDecl = widenedSym ? widenedSym.valueDeclaration : undefined;
     if (classDecl &&
         (ts.isClassDeclaration(classDecl) || ts.isClassExpression(classDecl)) &&
         // Nameless class DECLARATIONS are legal only as `export default class
         // {}` — classNamer spells them "%anon" (unique per file), the same
         // name their collection registered.
-        !classDecl.getSourceFile().isDeclarationFile &&
-        checker.getConstructSignatures(widened).length === 0) {
-        // Declared OUTSIDE the lowered program (reached through the type world
-        // alone — jsdoc `typeof import()` over a never-required module): the
-        // class will never register, so the instance type is unmappable, not
-        // an object type naming a struct that cannot exist.
-        if (!ctx.isProgramFile(classDecl.getSourceFile()))
+        !ts.getSourceFileOfNode(classDecl).isDeclarationFile &&
+        checker.getConstructSignatures(widened).length === 0 &&
+        // A TypeScript class declared OUTSIDE the lowered program (reached
+        // through `import type` alone) never registers, and the program can
+        // hold no instance of it: its instance type maps below as the
+        // structural type it describes, like an interface.
+        (ctx.isProgramFile(ts.getSourceFileOfNode(classDecl)) ||
+            isJsSourceFile(ts.getSourceFileOfNode(classDecl)))) {
+        // A JavaScript class outside the lowered program (jsdoc `typeof
+        // import()` over a never-required module) stays unmappable: JSDoc
+        // types are not checked, so its slots fall back to the dynamic value.
+        if (!ctx.isProgramFile(ts.getSourceFileOfNode(classDecl)))
             return null;
         // The class inside a MIXIN function: per-call-site instantiations
         // share this one node — the CURRENT instantiation (collecting or
@@ -1560,7 +2029,7 @@ function mapTypeInner(type, ctx) {
             }
         }
         if (classExprNeedsContext(classDecl)) {
-            const local = ctx.localClassInstance?.(classDecl);
+            const local = ctx.localClassInstance?.(classDecl, widened);
             if (local)
                 contextResolutions++;
             return local ?? null;
@@ -1568,7 +2037,7 @@ function mapTypeInner(type, ctx) {
         // A GENERIC class's instance type (`Box<number>`) maps to the concrete
         // INSTANTIATION's class (`Box%0`), registered on demand — the Lowerer
         // hook owns the instance table (monomorphization by flow).
-        if (classDecl.typeParameters) {
+        if (classDecl.typeParameters?.nodes) {
             const instance = ctx.genericClassInstance?.(classDecl, widened, (argument) => mapType(argument, ctx)) ??
                 null;
             // Before the generic declaration's collection turn, the hook can only
@@ -1580,14 +2049,21 @@ function mapTypeInner(type, ctx) {
         }
         return { kind: "object", className: classNamer(classDecl) };
     }
+    // A runtime-provided class's static side (`typeof EventEmitter`,
+    // `typeof Readable`, `ErrorConstructor`): that class's value.
+    {
+        const runtimeClass = ctx.runtimeClassValue?.(widened);
+        if (runtimeClass)
+            return { kind: "classval", className: runtimeClass };
+    }
     // The class STATIC side (`typeof C` — the class name as a value): the
     // same symbol WITH its construct signatures. Program classes only; lib
     // and package statics keep their fences.
     if (classDecl &&
         (ts.isClassDeclaration(classDecl) || ts.isClassExpression(classDecl)) &&
-        !classDecl.getSourceFile().isDeclarationFile &&
+        !ts.getSourceFileOfNode(classDecl).isDeclarationFile &&
         checker.getConstructSignatures(widened).length > 0) {
-        if (!ctx.isProgramFile(classDecl.getSourceFile()))
+        if (!ctx.isProgramFile(ts.getSourceFileOfNode(classDecl)))
             return null;
         // The MIXIN class node's static side (`typeof C` inside the mixin):
         // the current instantiation's classval, like the instance type above.
@@ -1599,7 +2075,8 @@ function mapTypeInner(type, ctx) {
             }
         }
         if (classExprNeedsContext(classDecl)) {
-            const local = ctx.localClassInstance?.(classDecl);
+            const ctorSigs = checker.getConstructSignatures(widened);
+            const local = ctx.localClassInstance?.(classDecl, ctorSigs.length === 1 ? checker.getReturnTypeOfSignature(ctorSigs[0]) : undefined);
             if (local?.kind === "object") {
                 contextResolutions++;
                 return { kind: "classval", className: local.className };
@@ -1612,7 +2089,7 @@ function mapTypeInner(type, ctx) {
         // the instantiation's classval. Uninstantiated `typeof Box` keeps the
         // type parameter in the construct signature's return — unmapped (the
         // family has no thunk and no single constructor ABI).
-        if (classDecl.typeParameters) {
+        if (classDecl.typeParameters?.nodes) {
             const ctorSigs = checker.getConstructSignatures(widened);
             if (ctorSigs.length !== 1)
                 return null;
@@ -1648,10 +2125,9 @@ 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?.name === name &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
+    const isStdlibInterface = (name) => psym !== undefined &&
+        ts.symbolName(psym) === name &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
     // 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
@@ -1664,10 +2140,9 @@ 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?.name === "AssertionError" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isClassDeclaration(d) && ctx.isStdlibFile(d.getSourceFile())))
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "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
     // non-nullish value into an `Object` slot (`const x: Object = "s"`), so
@@ -1683,12 +2158,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?.name === "ScriptcModule" || psym?.name === "Module") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
-            (psym.name === "ScriptcModule" ||
+    if (((psym !== undefined && ts.symbolName(psym) === "ScriptcModule") ||
+        (psym !== undefined && ts.symbolName(psym) === "Module")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            (ts.symbolName(psym) === "ScriptcModule" ||
                 isDeclaredInAmbientNamespace(d, "NodeJS") ||
                 isDeclaredInAmbientModule(d, "module")))) {
         return F64;
@@ -1700,11 +2174,10 @@ function mapTypeInner(type, ctx) {
     // (generic) class plus a same-named interface — and @types/node's
     // NodeJS.EventEmitter interface (the structural surface net.Socket
     // et al. extend) is the same runtime value. Provenance-checked.
-    if (psym?.name === "EventEmitter" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "EventEmitter" &&
+        psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "events") || isDeclaredInAmbientNamespace(d, "NodeJS")))) {
         return { kind: "object", className: RUNTIME_EMITTER_CLASS };
     }
@@ -1712,54 +2185,69 @@ function mapTypeInner(type, ctx) {
     // value is an f64 handle into the runtime's registry (the Timeout-id
     // precedent). The NAME is generic, so the provenance check adds the
     // enclosing ambient module, like net.Server.
-    if (psym?.name === "Interface" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Interface" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "readline") ||
                 isDeclaredInAmbientModule(d, "readline/promises")))) {
         return F64;
     }
+    // readline.Key: emitKeys' key object stays a checked-dynamic value, so
+    // it keeps Node's own shape (an undefined name, the escape sequences'
+    // code member).
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Key" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            (isDeclaredInAmbientModule(d, "readline") ||
+                isDeclaredInAmbientModule(d, "readline/promises")))) {
+        return DYN;
+    }
+    // readline/promises.Readline: an f64 handle the same way.
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Readline" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "readline/promises"))) {
+        return F64;
+    }
     // diagnostics_channel.Channel: the channel value is an f64 handle into
     // the runtime's channel registry (the readline.Interface precedent —
     // Node's channels are process-lived too, its WeakRef machinery aside).
     // Provenance: the name is specific enough that stdlib-file provenance
     // plus the ambient module suffices for both the fallback declarations
     // and @types/node's class Channel<StoreType, ContextType>.
-    if (psym?.name === "Channel" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Channel" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
         return F64;
     }
     // async_hooks.AsyncLocalStorage: the store value is an f64 handle into
     // the runtime's store id space (the Channel story — stores are
     // process-lived; contexts ride the fiber machinery).
-    if (psym?.name === "AsyncLocalStorage" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "AsyncLocalStorage" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "async_hooks"))) {
         return F64;
     }
     // diagnostics_channel.TracingChannel: the same f64-handle story over the
     // runtime's tracing registry (five event channels per entry).
-    if (psym?.name === "TracingChannel" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "TracingChannel" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
         return F64;
     }
     // Node names this result; the ambient WHATWG declaration uses a type literal.
     const encodeResult = psym &&
-        checker.declarationsOf(psym).some((decl) => {
-            if (!ctx.isStdlibFile(decl.getSourceFile()))
+        psym.declarations.some((decl) => {
+            if (!ctx.isStdlibFile(ts.getSourceFileOfNode(decl)))
                 return false;
             if (ts.isInterfaceDeclaration(decl) && decl.name.text === "EncodeIntoResult")
                 return true;
@@ -1783,16 +2271,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?.name === "TextEncoder" || psym?.name === "TextDecoder") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (((psym !== undefined && ts.symbolName(psym) === "TextEncoder") ||
+        (psym !== undefined && ts.symbolName(psym) === "TextDecoder")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return {
             kind: "record",
             shapeId: ctx.shapes.intern([
-                { name: `%${psym.name}`, type: F64 },
-                ...(psym.name === "TextDecoder"
+                { name: `%${ts.symbolName(psym)}`, type: F64 },
+                ...(ts.symbolName(psym) === "TextDecoder"
                     ? [
                         { name: "%fatal", type: BOOL },
                         { name: "%ignoreBOM", type: BOOL },
@@ -1809,11 +2296,10 @@ function mapTypeInner(type, ctx) {
     // checked like Stats; construction and the write/end methods are
     // special-cased in lowerNew / lowerStringDecoderMethodCall, so the
     // record shape never surfaces.
-    if (psym?.name === "StringDecoder" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "StringDecoder" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return {
             kind: "record",
             shapeId: ctx.shapes.intern([
@@ -1832,14 +2318,14 @@ function mapTypeInner(type, ctx) {
     // record-holding binding forms compile. User-declared literals with
     // these member names keep the ordinary record path (their declarations
     // are not in declaration files).
-    const promiseDeclarations = psym ? checker.declarationsOf(psym) : [];
+    const promiseDeclarations = psym ? psym.declarations : [];
     if (flags & ts.TypeFlags.Object &&
         promiseDeclarations.length > 0 &&
-        promiseDeclarations.every((d) => d.getSourceFile().isDeclarationFile)) {
+        promiseDeclarations.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile)) {
         const props = checker.getPropertiesOfType(widened);
         if (props.length === 3 &&
-            ["promise", "resolve", "reject"].every((n) => props.some((p) => p.name === n))) {
-            const promProp = props.find((p) => p.name === "promise");
+            ["promise", "resolve", "reject"].every((n) => props.some((p) => ts.symbolName(p) === n))) {
+            const promProp = props.find((p) => ts.symbolName(p) === "promise");
             const promT = mapType(checker.getTypeOfSymbol(promProp), ctx);
             if (promT?.kind === "promise") {
                 const inner = promT.inner;
@@ -1876,6 +2362,27 @@ function mapTypeInner(type, ctx) {
     // stdio and env values. Keep it checked-dynamic for native normalization.
     if (isStdlibInterface("SpawnOptions"))
         return DYN;
+    // dns.LookupAllOptions (`all: true`, the overload whose callback takes
+    // an address list): a lookup option bag dns.lookup reads at run time.
+    // It rides checked-dynamic storage, so the lookup function type that
+    // takes `LookupOneOptions | LookupAllOptions | number` compiles.
+    if (isStdlibInterface("LookupAllOptions"))
+        return DYN;
+    // http.RequestOptions / https.RequestOptions as a declared type: an
+    // option record whose members include functions, agents and signals.
+    // Values ride checked-dynamic storage, like SpawnOptions.
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "RequestOptions" &&
+        psym.declarations.some((d) => {
+            if (!ts.isInterfaceDeclaration(d) || !ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
+                return false;
+            for (let p = d.parent; p !== undefined; p = p.parent) {
+                if (ts.isModuleDeclaration(p) && ts.isStringLiteral(p.name))
+                    return HTTP_REQUEST_OPTION_MODULES.has(p.name.text);
+            }
+            return false;
+        }))
+        return DYN;
     // exactly like npm-declared types. Static fetch has one deliberately
     // narrower native representation: Response is an opaque checked-
     // dynamic capsule consumed only by the Response method lowerings, and
@@ -1888,10 +2395,9 @@ function mapTypeInner(type, ctx) {
     // interfaces; @types/node's undici-types declares Response as a class).
     {
         const alias = widened.getAliasSymbol();
-        if (alias?.name === "ReadableStreamReadResult" &&
-            checker
-                .declarationsOf(alias)
-                .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+        if (alias !== undefined &&
+            ts.symbolName(alias) === "ReadableStreamReadResult" &&
+            alias.declarations.some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
             const elemTs = widened.getAliasTypeArguments()?.[0];
             const elem = elemTs && elemTs.flags & ts.TypeFlags.Any ? DYN : elemTs ? mapType(elemTs, ctx) : null;
             if (!elem)
@@ -1900,56 +2406,70 @@ function mapTypeInner(type, ctx) {
         }
     }
     if (psym &&
-        (psym.name === "ReadableStreamReadValueResult" ||
-            psym.name === "ReadableStreamReadDoneResult") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+        (ts.symbolName(psym) === "ReadableStreamReadValueResult" ||
+            ts.symbolName(psym) === "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;
         if (!elem)
             return null;
         return genResultRecord(elem, VOID, ctx.shapes, ctx.unions);
     }
+    // node:net's SocketAddress and BlockList: native handles (scr_net.c)
+    // whose getters and methods dispatch through the handle.
+    if (((psym !== undefined && ts.symbolName(psym) === "SocketAddress") ||
+        (psym !== undefined && ts.symbolName(psym) === "BlockList")) &&
+        psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+        return DYN;
+    }
+    // WebCrypto: the crypto global and its subtle object are dynamic
+    // objects, CryptoKey values are native handles (scr_webcrypto.c), and
+    // the algorithm dictionaries the methods take and keys report are plain
+    // checked-dynamic objects.
+    if (psym &&
+        WEBCRYPTO_DYN_TYPES.has(ts.symbolName(psym)) &&
+        psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+        return DYN;
+    }
     // node:crypto's KeyObject: secret keys are native handles (scr_lib.c)
     // whose getters and methods dispatch through the handle. The JsonWebKey
     // that export() returns is a plain checked-dynamic object.
-    if ((psym?.name === "KeyObject" || psym?.name === "JsonWebKey") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (((psym !== undefined && ts.symbolName(psym) === "KeyObject") ||
+        (psym !== undefined && ts.symbolName(psym) === "JsonWebKey")) &&
+        psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
     if (psym &&
-        FETCH_AMBIENT_TYPES.includes(psym.name) &&
-        !(psym.name === "ReadableStream" &&
-            checker
-                .declarationsOf(psym)
-                .some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS"))) &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+        FETCH_AMBIENT_TYPES.includes(ts.symbolName(psym)) &&
+        !(ts.symbolName(psym) === "ReadableStream" &&
+            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)))) {
         return DYN;
     }
     // The stdlib Console interface (the global console and node:console
     // Console instances) is a native handle carried by the checked-dynamic
     // representation and consumed by the console method lowerings. The
-    // stdlib Disposable (events.addAbortListener's result) is a checked
-    // object carrying its Symbol.dispose method.
-    if ((psym?.name === "Console" || psym?.name === "Disposable") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+    // stdlib Disposable (events.addAbortListener's result) and
+    // 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")) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
     // node:crypto Cipheriv/Decipheriv values (and @types/node's per-mode
     // interfaces over them) are native handles carried by the checked-dynamic
     // representation; lowerCipherMethodCall dispatches their methods.
     if (psym !== undefined &&
-        CIPHER_TYPE_NAMES.has(psym.name) &&
-        checker.declarationsOf(psym).some((d) => ctx.isStdlibFile(d.getSourceFile()))) {
+        CIPHER_TYPE_NAMES.has(ts.symbolName(psym)) &&
+        psym.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
     // ReadonlyMap/ReadonlySet are the SAME runtime values as Map/Set — the
@@ -2069,6 +2589,8 @@ function mapTypeInner(type, ctx) {
     // SharedArrayBuffer, and the i32 semantics hold for every other use.
     if (isStdlibInterface("Int32Array"))
         return bytesOf("i32");
+    if (isStdlibInterface("Float16Array"))
+        return bytesOf("f16");
     if (isStdlibInterface("Float32Array"))
         return bytesOf("f32");
     if (isStdlibInterface("Float64Array"))
@@ -2084,11 +2606,10 @@ function mapTypeInner(type, ctx) {
     // (the u8 bytes kind). Declared `interface Buffer` by the shipped
     // fallback and by @types/node (whose NonSharedBuffer alias resolves to
     // the same symbol); provenance-checked like URL.
-    if (psym?.name === "Buffer" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Buffer" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return bytesOf("u8");
     }
     // URL: the WHATWG URL instance type — declared as a global `interface
@@ -2096,41 +2617,36 @@ function mapTypeInner(type, ctx) {
     // URL` in @types/node's "url" module (`new URL(x)` types as the class's
     // instance type). Provenance, not the name: a user's own URL maps as a
     // record/class like any other.
-    if (psym?.name === "URL" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "URL" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "url" };
     }
     // URLSearchParams: the WHATWG live query view — declared as a global
     // interface by the shipped fallback and by @types/node (plus `class
     // URLSearchParams` in the "url" module). Provenance-checked like URL.
-    if (psym?.name === "URLSearchParams" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "URLSearchParams" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "searchParams" };
     }
     // fs.Stats: @types/node's `class Stats` (module "fs") or the fallback
     // declarations' interface. Provenance-checked like URL.
-    if (psym?.name === "Stats" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Stats" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "stats" };
     }
     // Capacity snapshots and options keep their live object representation
     // across numeric/BigInt overloads, runtime options, and callbacks.
-    if ((psym?.name === "StatsFs" ||
-        psym?.name === "BigIntStatsFs" ||
-        psym?.name === "StatFsOptions") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (((psym !== undefined && ts.symbolName(psym) === "StatsFs") ||
+        (psym !== undefined && ts.symbolName(psym) === "BigIntStatsFs") ||
+        (psym !== undefined && ts.symbolName(psym) === "StatFsOptions")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs")))
         return DYN;
     if (isWorkerHandleSymbol(psym, ctx))
@@ -2138,21 +2654,19 @@ function mapTypeInner(type, ctx) {
     // fs/promises.FileHandle: an owned descriptor object. Module provenance
     // distinguishes it from user interfaces with the same name; both the
     // fallback and @types/node declare it in "fs/promises".
-    if (psym?.name === "FileHandle" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "FileHandle" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs/promises"))) {
         return { kind: "fileHandle" };
     }
     // fs.Dir: an open directory stream, declared in "fs" by both the
     // fallback and @types/node.
-    if (psym?.name === "Dir" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Dir" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs"))) {
         return { kind: "dir" };
     }
@@ -2160,24 +2674,21 @@ function mapTypeInner(type, ctx) {
     // Buffer/string split is re-checked at the stdout/stderr READ — status
     // reads work either way) or the fallback declarations' plain interface.
     // Provenance-checked like Stats.
-    if (psym?.name === "SpawnSyncReturns" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "SpawnSyncReturns" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "spawnRes" };
     }
     // child_process.ChildProcess and @types/node's stdio-refined return
     // interfaces: all carry the same runtime child handle; the generic
     // refinements only tell the checker which stdio properties are null.
     if (psym !== undefined &&
-        (psym.name === "ChildProcess" ||
-            psym.name === "ChildProcessWithoutNullStreams" ||
-            psym.name === "ChildProcessByStdio") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+        (ts.symbolName(psym) === "ChildProcess" ||
+            ts.symbolName(psym) === "ChildProcessWithoutNullStreams" ||
+            ts.symbolName(psym) === "ChildProcessByStdio") &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "child_process"))) {
         return { kind: "child" };
     }
@@ -2188,64 +2699,62 @@ 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?.name === "Server" || psym?.name === "Socket" || psym?.name === "TLSSocket") &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (((psym !== undefined && ts.symbolName(psym) === "Server") ||
+        (psym !== undefined && ts.symbolName(psym) === "Socket") ||
+        (psym !== undefined && ts.symbolName(psym) === "TLSSocket")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "net") ||
                 // http.Server extends net.Server in @types/node — and tls.Server
                 // / https.Server extend it transitively: same lowered surface
                 // (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.
-                (psym.name === "Server" &&
+                (ts.symbolName(psym) === "Server" &&
                     (isDeclaredInAmbientModule(d, "http") ||
                         isDeclaredInAmbientModule(d, "tls") ||
                         isDeclaredInAmbientModule(d, "https"))) ||
-                (psym.name === "TLSSocket" && isDeclaredInAmbientModule(d, "tls"))))) {
-        return psym.name === "Server" ? { kind: "netServer" } : { kind: "netSocket" };
+                (ts.symbolName(psym) === "TLSSocket" && isDeclaredInAmbientModule(d, "tls"))))) {
+        return ts.symbolName(psym) === "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
     // server's handshake consumes it). Module-checked like net.Server —
     // @types/node declares `interface SecureContext` inside `declare module
     // "tls"`, and the shipped fallback mirrors it.
-    if (psym?.name === "SecureContext" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "SecureContext" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "tls"))) {
         return { kind: "secureCtx" };
     }
     // Scrypt's runtime options retain property accessors and aliases. Use
     // checked values so presence probes and repeated getter reads match Node.
-    if (psym?.name === "ScryptOptions" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "ScryptOptions" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto")))
         return DYN;
     // 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?.name === "Hash" || psym?.name === "Hmac") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (((psym !== undefined && ts.symbolName(psym) === "Hash") ||
+        (psym !== undefined && ts.symbolName(psym) === "Hmac")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
-        return psym.name === "Hash" ? CRYPTOHASH_T : CRYPTOHMAC_T;
+        return ts.symbolName(psym) === "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?.name === "FSWatcher" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "FSWatcher" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs"))) {
         return { kind: "fsWatcher" };
     }
@@ -2266,41 +2775,70 @@ function mapTypeInner(type, ctx) {
     // global-namespace interface real code writes in its own signatures —
     // prefixStream's `output` param). The representation is the raw fd
     // scalar; the lowered surface is write(string).
-    if ((psym?.name === "WriteStream" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    // Under the program's general stream representation (generalNodeStreams)
+    // NodeJS.WritableStream is the runtime Writable instead: the process
+    // streams convert into it where they flow (process.stdioWritable).
+    // Checked-dynamic stream slots: an intersection over a NodeJS stream
+    // interface (`NodeJS.ReadableStream & { destroy?(): void }`) holds the
+    // same values as the interface.
+    if (ctx.dynNodeStreams === true &&
+        (type.flags & ts.TypeFlags.Intersection) !== 0 &&
+        ts.constituentTypes(type).some((part) => {
+            const sym = part.getSymbol();
+            return (((sym !== undefined && ts.symbolName(sym) === "ReadableStream") ||
+                (sym !== undefined && ts.symbolName(sym) === "WritableStream")) &&
+                sym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+                    ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+                    isDeclaredInAmbientNamespace(d, "NodeJS")));
+        })) {
+        return DYN;
+    }
+    const nodeWritableInterface = psym !== undefined &&
+        ts.symbolName(psym) === "WritableStream" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientNamespace(d, "NodeJS"));
+    if (nodeWritableInterface && ctx.generalNodeStreams === true) {
+        return ctx.dynNodeStreams === true ? DYN : { kind: "object", className: "%Writable" };
+    }
+    if ((psym !== undefined &&
+        ts.symbolName(psym) === "WriteStream" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "tty") ||
-                (isDeclaredInAmbientModule(d, "process") &&
-                    isDeclaredInAmbientNamespace(d, "NodeJS"))))) ||
-        (psym?.name === "WritableStream" &&
-            checker
-                .declarationsOf(psym)
-                .some((d) => ts.isInterfaceDeclaration(d) &&
-                ctx.isStdlibFile(d.getSourceFile()) &&
-                isDeclaredInAmbientNamespace(d, "NodeJS")))) {
+                (isDeclaredInAmbientModule(d, "process") && isDeclaredInAmbientNamespace(d, "NodeJS"))))) ||
+        nodeWritableInterface) {
         return PROCSTREAM_T;
     }
     // A piped child stdin writer. The fallback declarations give it the
     // dedicated ChildStdin name; @types/node spells the same value as
     // stream.Writable. As with stream.Readable below, unsupported producers
     // of the broad @types class fence where they are constructed.
-    if ((psym?.name === "ChildStdin" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if ((psym !== undefined &&
+        ts.symbolName(psym) === "ChildStdin" &&
+        ctx.generalNodeStreams !== true &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "child_process"))) ||
-        (psym?.name === "Writable" &&
-            checker
-                .declarationsOf(psym)
-                .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-                ctx.isStdlibFile(d.getSourceFile()) &&
-                isNodeTypesPath(d.getSourceFile().fileName) &&
+        (psym !== undefined &&
+            ts.symbolName(psym) === "Writable" &&
+            ctx.generalNodeStreams !== true &&
+            psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+                isNodeTypesPath(ts.getSourceFileOfNode(d).fileName) &&
                 isDeclaredInAmbientModule(d, "stream")))) {
         return { kind: "childWriter" };
     }
+    // Under the general stream representation the fallback declarations'
+    // ChildStdin is the runtime Writable too (child.stdioStream bridges it).
+    if (ctx.generalNodeStreams === true &&
+        psym !== undefined &&
+        ts.symbolName(psym) === "ChildStdin" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "child_process"))) {
+        return { kind: "object", className: "%Writable" };
+    }
     // The static node:stream classes (the shipped fallback declarations —
     // NOT @types/node, whose stream.Readable also types child stdio; under
     // @types/node the childStream mapping below keeps priority and the
@@ -2308,93 +2846,102 @@ function mapTypeInner(type, ctx) {
     // branch: the fallback's Readable must map to the runtime class, and
     // under the fallback child.stdout is NodeJS.ReadableStream (its own
     // branch below), so the two never collide.
+    // @types/node's Duplex/Transform/PassThrough classes have no child-stdio
+    // reading, so they map to the runtime classes too; its Readable and
+    // Writable join them under the general representation.
     for (const [irName, rec] of RUNTIME_STREAM_CLASSES) {
-        if (psym?.name === rec.lib &&
-            checker
-                .declarationsOf(psym)
-                .some((d) => ts.isClassDeclaration(d) &&
-                ctx.isStdlibFile(d.getSourceFile()) &&
-                !isNodeTypesPath(d.getSourceFile().fileName) &&
+        if (psym !== undefined &&
+            ts.symbolName(psym) === rec.lib &&
+            psym.declarations.some((d) => ts.isClassDeclaration(d) &&
+                ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+                (!isNodeTypesPath(ts.getSourceFileOfNode(d).fileName) ||
+                    ctx.generalNodeStreams === true ||
+                    (rec.lib !== "Readable" && rec.lib !== "Writable")) &&
                 isDeclaredInAmbientModule(d, "stream"))) {
             return { kind: "object", className: irName };
         }
     }
-    // node:zlib's stream classes (the shipped fallback declarations): their
-    // instances are runtime Transform streams.
+    // 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(psym.name) &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isClassDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
-            !isNodeTypesPath(d.getSourceFile().fileName) &&
+        ZLIB_STREAM_MODES.has(ts.symbolName(psym)) &&
+        psym.declarations.some((d) => (ts.isClassDeclaration(d) ||
+            (ts.isInterfaceDeclaration(d) && isNodeTypesPath(ts.getSourceFileOfNode(d).fileName))) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "zlib"))) {
         return { kind: "object", className: "%Transform" };
     }
-    // fs.ReadStream / fs.WriteStream (the shipped fallback declarations):
-    // their instances are runtime Readable / Writable streams
-    // (scr_fs_stream.c).
-    if ((psym?.name === "ReadStream" || psym?.name === "WriteStream") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isClassDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
-            !isNodeTypesPath(d.getSourceFile().fileName) &&
+    // 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")) &&
+        psym.declarations.some((d) => ts.isClassDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "fs"))) {
-        return { kind: "object", className: psym.name === "ReadStream" ? "%Readable" : "%Writable" };
+        return {
+            kind: "object",
+            className: ts.symbolName(psym) === "ReadStream" ? "%Readable" : "%Writable",
+        };
     }
-    if ((psym?.name === "Readable" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if ((psym !== undefined &&
+        ts.symbolName(psym) === "Readable" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "stream"))) ||
-        (psym?.name === "ReadableStream" &&
-            checker
-                .declarationsOf(psym)
-                .some((d) => ts.isInterfaceDeclaration(d) &&
-                ctx.isStdlibFile(d.getSourceFile()) &&
+        (psym !== undefined &&
+            ts.symbolName(psym) === "ReadableStream" &&
+            psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+                ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
                 isDeclaredInAmbientNamespace(d, "NodeJS")))) {
+        // 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")
+                return DYN;
+            return { kind: "object", className: "%Readable" };
+        }
         return { kind: "childStream" };
     }
     // dgram.Socket: the same ambiguous "Socket" name disambiguated by its
     // enclosing ambient module — @types/node's `class Socket extends
     // EventEmitter` and the fallback declarations' interface both live
     // inside `declare module "dgram"`.
-    if (psym?.name === "Socket" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Socket" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "dgram"))) {
         return { kind: "dgramSocket" };
     }
     // node:test's TestContext — the test-body parameter (`test('x', (t) =>
-    // ...)`). @types/node's `class TestContext` and the fallback
-    // declarations' interface both live inside `declare module "node:test"`
-    // (isDeclaredInAmbientModule answers for both spellings).
-    if (psym?.name === "TestContext" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    // ...)`) — and SuiteContext, the describe-body and suite-hook parameter:
+    // both are the runner's node for the test or suite. @types/node's
+    // 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")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "test"))) {
         return { kind: "testCtx" };
     }
     // 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?.name === "MockFunctionContext" || psym?.name === "MockFunctionCall") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (((psym !== undefined && ts.symbolName(psym) === "MockFunctionContext") ||
+        (psym !== undefined && ts.symbolName(psym) === "MockFunctionCall")) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "test"))) {
         const fnTs = checker.getTypeArguments(widened)[0];
         const fn = fnTs ? mapType(fnTs, ctx) : null;
         if (!fn || fn.kind !== "func")
             return null;
-        return psym.name === "MockFunctionContext"
+        return ts.symbolName(psym) === "MockFunctionContext"
             ? mockContextType(fn, ctx)
             : mockCallRecordType(fn, ctx);
     }
@@ -2403,10 +2950,9 @@ function mapTypeInner(type, ctx) {
     // it to the runtime %Error hierarchy like the lib Error interfaces
     // above; optional metadata uses the same checked property view.
     // Provenance-checked like the rest.
-    if (psym?.name === "ErrnoException" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "ErrnoException" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return { kind: "object", className: "%Error" };
     }
     // http.Agent / https.Agent — the Agent VALUE is a checked-dynamic
@@ -2415,24 +2961,22 @@ function mapTypeInner(type, ctx) {
     // binding, parameter, or field carrying an Agent stays usable instead
     // of fencing at the declaration. Module-checked like the rest (https'
     // Agent extends http's; both live in their ambient modules).
-    if (psym?.name === "Agent" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Agent" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "http") || isDeclaredInAmbientModule(d, "https")))) {
         return { kind: "dyn" };
     }
     // http.IncomingMessage / http.ServerResponse — module-checked like
     // net.Server (the names repeat nowhere today, but provenance stays the
     // rule).
-    if ((psym?.name === "IncomingMessage" || psym?.name === "ServerResponse") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (((psym !== undefined && ts.symbolName(psym) === "IncomingMessage") ||
+        (psym !== undefined && ts.symbolName(psym) === "ServerResponse")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http"))) {
-        return psym.name === "IncomingMessage" ? { kind: "httpReq" } : { kind: "httpRes" };
+        return ts.symbolName(psym) === "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
@@ -2442,17 +2986,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?.name === "Http2SecureServer" ||
-        psym?.name === "Http2ServerRequest" ||
-        psym?.name === "Http2ServerResponse") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (((psym !== undefined && ts.symbolName(psym) === "Http2SecureServer") ||
+        (psym !== undefined && ts.symbolName(psym) === "Http2ServerRequest") ||
+        (psym !== undefined && ts.symbolName(psym) === "Http2ServerResponse")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http2"))) {
-        return psym.name === "Http2SecureServer"
+        return ts.symbolName(psym) === "Http2SecureServer"
             ? { kind: "netServer" }
-            : psym.name === "Http2ServerRequest"
+            : ts.symbolName(psym) === "Http2ServerRequest"
                 ? { kind: "httpReq" }
                 : { kind: "httpRes" };
     }
@@ -2460,30 +3002,27 @@ 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?.name === "Http2Server" ||
-        psym?.name === "Http2Session" ||
-        psym?.name === "ClientHttp2Session" ||
-        psym?.name === "ServerHttp2Session" ||
-        psym?.name === "ClientHttp2Stream" ||
-        psym?.name === "ServerHttp2Stream") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    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")) &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http2"))) {
-        return psym.name === "Http2Server"
+        return ts.symbolName(psym) === "Http2Server"
             ? { kind: "netServer" }
-            : psym.name === "ClientHttp2Stream" || psym.name === "ServerHttp2Stream"
+            : ts.symbolName(psym) === "ClientHttp2Stream" || ts.symbolName(psym) === "ServerHttp2Stream"
                 ? { kind: "http2Stream" }
                 : { kind: "http2Session" };
     }
     // http.ClientRequest (http.request/http.get results) — module-checked
     // like IncomingMessage.
-    if (psym?.name === "ClientRequest" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "ClientRequest" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "http"))) {
         return { kind: "httpClientReq" };
     }
@@ -2495,10 +3034,9 @@ function mapTypeInner(type, ctx) {
     // record) and ProcessEnv-typed parameters mappable. The fallback
     // declarations' anonymous env type takes the pureIndexShape path below
     // and interns the SAME shape.
-    if (psym?.name === "ProcessEnv" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "ProcessEnv" &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         const value = withUndefinedArm(STRING, ctx.unions);
         if (!value)
             return null;
@@ -2532,8 +3070,9 @@ function mapTypeInner(type, ctx) {
     if (isStdlibInterface("MapIterator") || isStdlibInterface("SetIterator"))
         return DYN;
     // Array iterators (`list.values()` and friends) are generators over the
-    // live array: each step reads the current length and element.
-    if (isStdlibInterface("ArrayIterator")) {
+    // live array: each step reads the current length and element. String
+    // iterators (`s[Symbol.iterator]()`) are generators over the code points.
+    if (isStdlibInterface("ArrayIterator") || isStdlibInterface("StringIterator")) {
         const arg = checker.getTypeArguments(widened)[0];
         const yieldT = arg ? mapType(arg, ctx) : null;
         if (!yieldT || yieldT.kind === "void" || isUnitType(yieldT))
@@ -2568,7 +3107,10 @@ function mapTypeInner(type, ctx) {
         isStdlibInterface("IterableIterator") ||
         // An Iterator<T> annotation holds a single-pass iterator object: a
         // generator, or a native iterator adapted into one.
-        isStdlibInterface("Iterator")) {
+        isStdlibInterface("Iterator") ||
+        // IteratorObject<T> is what the iterator helpers return: a helper
+        // generator over its source (containers/iterator-helpers.ts).
+        isStdlibInterface("IteratorObject")) {
         const args = checker.getTypeArguments(widened);
         const channels = genChannels(args[0], args[1], args[2], ctx);
         if (!channels)
@@ -2589,10 +3131,9 @@ function mapTypeInner(type, ctx) {
     // g.next()` binds without an annotation and reads flow.
     {
         const alias = widened.getAliasSymbol();
-        if (alias?.name === "IteratorResult" &&
-            checker
-                .declarationsOf(alias)
-                .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+        if (alias !== undefined &&
+            ts.symbolName(alias) === "IteratorResult" &&
+            alias.declarations.some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
             const targs = widened.getAliasTypeArguments() ?? [];
             const channels = genChannels(targs[0], targs[1], undefined, ctx);
             if (!channels)
@@ -2690,12 +3231,12 @@ function mapTypeInner(type, ctx) {
         ];
         const fields = [];
         for (const property of checker.getPropertiesOfType(widened)) {
-            if (!known.includes(property.name))
+            if (!known.includes(ts.symbolName(property)))
                 return null;
             const type = mapType(checker.getTypeOfSymbol(property), ctx);
             if (!type)
                 return null;
-            fields.push({ name: property.name, type });
+            fields.push({ name: ts.symbolName(property), type });
         }
         const order = fields.map((field) => field.name);
         fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
@@ -2703,23 +3244,21 @@ function mapTypeInner(type, ctx) {
     }
     // Filesystem options are data records. Keep their declared optional fields
     // instead of allowing arbitrary standard-library interfaces into records.
-    if ((psym?.name === "FileReadOptions" ||
-        psym?.name === "ReadOptions" ||
-        psym?.name === "ReadOptionsWithBuffer" ||
-        psym?.name === "WriteOptions") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    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")) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "fs/promises") || isDeclaredInAmbientModule(d, "fs")))) {
         const fields = [];
         for (const property of checker.getPropertiesOfType(widened)) {
-            if (!["buffer", "offset", "length", "position"].includes(property.name))
+            if (!["buffer", "offset", "length", "position"].includes(ts.symbolName(property)))
                 return null;
             const type = mapType(checker.getTypeOfSymbol(property), ctx);
             if (!type)
                 return null;
-            fields.push({ name: property.name, type });
+            fields.push({ name: ts.symbolName(property), type });
         }
         const order = fields.map((field) => field.name);
         fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
@@ -2729,26 +3268,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?.name === "FileReadResult" ||
-        psym?.name === "FileWriteResult" ||
-        psym?.name === "FileReadvResult" ||
-        psym?.name === "FileWritevResult" ||
-        psym?.name === "ReadVResult" ||
-        psym?.name === "WriteVResult") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    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")) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             (isDeclaredInAmbientModule(d, "fs/promises") ||
-                ((psym.name === "ReadVResult" || psym.name === "WriteVResult") &&
+                ((ts.symbolName(psym) === "ReadVResult" || ts.symbolName(psym) === "WriteVResult") &&
                     isDeclaredInAmbientModule(d, "fs"))))) {
         const args = checker.getTypeArguments(widened);
         if (args.length !== 1)
             return null;
-        const vector = psym.name === "FileReadvResult" ||
-            psym.name === "FileWritevResult" ||
-            psym.name === "ReadVResult" ||
-            psym.name === "WriteVResult";
+        const vector = ts.symbolName(psym) === "FileReadvResult" ||
+            ts.symbolName(psym) === "FileWritevResult" ||
+            ts.symbolName(psym) === "ReadVResult" ||
+            ts.symbolName(psym) === "WriteVResult";
         const emptyVector = vector &&
             checker.isArrayType(args[0]) &&
             (checker.getTypeArguments(args[0])[0].flags & ts.TypeFlags.Never) !== 0;
@@ -2759,9 +3296,9 @@ function mapTypeInner(type, ctx) {
                 : !(payload.kind === "string" || (payload.kind === "bytes" && payload.elem === "u8")))) {
             return null;
         }
-        const count = psym.name === "FileReadResult" ||
-            psym.name === "FileReadvResult" ||
-            psym.name === "ReadVResult"
+        const count = ts.symbolName(psym) === "FileReadResult" ||
+            ts.symbolName(psym) === "FileReadvResult" ||
+            ts.symbolName(psym) === "ReadVResult"
             ? "bytesRead"
             : "bytesWritten";
         const payloadName = vector ? "buffers" : "buffer";
@@ -2787,11 +3324,10 @@ function mapTypeInner(type, ctx) {
     // encoding:'buffer' readdir form has no lowering); the shipped fallback
     // declares it concrete (an interface; @types/node uses a class — both
     // provenance-checked, the Buffer/URL pattern).
-    if (psym?.name === "Dirent" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "Dirent" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         const args = checker.getTypeArguments(widened);
         if (args.length > 1)
             return null;
@@ -2829,15 +3365,13 @@ function mapTypeInner(type, ctx) {
         shapeId: ctx.shapes.intern(["idle", "irq", "nice", "sys", "user"].map((name) => ({ name, type: F64 })), false, undefined, ["user", "nice", "sys", "idle", "irq"]),
     });
     if (psym &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isTypeLiteralNode(d) &&
+        psym.declarations.some((d) => ts.isTypeLiteralNode(d) &&
             ts.isPropertySignature(d.parent) &&
             ts.isIdentifier(d.parent.name) &&
             d.parent.name.text === "times" &&
             ts.isInterfaceDeclaration(d.parent.parent) &&
             d.parent.parent.name.text === "CpuInfo" &&
-            ctx.isStdlibFile(d.getSourceFile())))
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
         return cpuTimes();
     if (isStdlibInterface("CpuInfo")) {
         const times = cpuTimes();
@@ -2851,7 +3385,7 @@ function mapTypeInner(type, ctx) {
         };
     }
     if (isStdlibInterface("ParsedPath") || isStdlibInterface("FormatInputPathObject")) {
-        const field = psym.name === "ParsedPath" ? STRING : withUndefinedArm(STRING, ctx.unions);
+        const field = ts.symbolName(psym) === "ParsedPath" ? STRING : withUndefinedArm(STRING, ctx.unions);
         if (!field)
             return null;
         return {
@@ -2881,26 +3415,40 @@ function mapTypeInner(type, ctx) {
             ], false, undefined, ["uid", "gid", "username", "homedir", "shell"]),
         };
     }
-    // The promisified exec/execFile result `{ stdout: string; stderr: string }`:
-    // an anonymous type literal (@types/node's __promisify__ overloads in
-    // child_process, the shipped fallback's promisify overloads in util),
-    // so it maps by provenance and exact shape, interned as the
-    // %execFileAsync/%execAsync helpers build it. Node builds the object as
-    // { stdout, stderr }. The Buffer-typed literals do not match and stay
+    // 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
+    // __promisify__ overloads in child_process and dns, the shipped
+    // fallback's promisify overloads in util), so they map by provenance and
+    // exact shape. The exec result is interned as the %execFileAsync/
+    // %execAsync helpers build it; Node builds { stdout, stderr } and
+    // { hostname, service }. The Buffer-typed literals do not match and stay
     // unmapped.
     if (psym &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isTypeLiteralNode(d) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
-            (isDeclaredInAmbientModule(d, "child_process") || isDeclaredInAmbientModule(d, "util")))) {
+        psym.declarations.some((d) => ts.isTypeLiteralNode(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            (isDeclaredInAmbientModule(d, "child_process") ||
+                isDeclaredInAmbientModule(d, "util") ||
+                isDeclaredInAmbientModule(d, "dns")))) {
         const props = checker.getPropertiesOfType(widened);
-        if (props.length === 2 &&
-            props.every((p) => (p.name === "stdout" || p.name === "stderr") &&
-                (p.flags & ts.SymbolFlags.Optional) === 0 &&
-                (checker.getTypeOfSymbol(p).flags & ts.TypeFlags.String) !== 0) &&
-            props[0].name !== props[1].name) {
+        const names = props.length === 2 &&
+            props.every((p) => (p.flags & ts.SymbolFlags.Optional) === 0 &&
+                (checker.getTypeOfSymbol(p).flags & ts.TypeFlags.String) !== 0)
+            ? props
+                .map((p) => ts.symbolName(p))
+                .sort()
+                .join(",")
+            : "";
+        if (names === "stderr,stdout")
             return { kind: "record", shapeId: execResultShape(ctx.shapes) };
+        if (names === "hostname,service") {
+            return {
+                kind: "record",
+                shapeId: ctx.shapes.intern([
+                    { name: "hostname", type: STRING },
+                    { name: "service", type: STRING },
+                ], false, undefined, ["hostname", "service"]),
+            };
         }
     }
     // crypto.X509Certificate — the Dirent-style data record: THREE visible
@@ -2910,11 +3458,10 @@ function mapTypeInner(type, ctx) {
     // `declare module "crypto"`, the shipped fallback mirrors it.
     // JSON.stringify of one shows the three fields where Node's
     // internal-slot object shows {} — the Dirent %dtype edge's cousin.
-    if (psym?.name === "X509Certificate" &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
+    if (psym !== undefined &&
+        ts.symbolName(psym) === "X509Certificate" &&
+        psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
         return {
             kind: "record",
@@ -2933,15 +3480,40 @@ 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?.name === "PerformanceEntry" ||
-        psym?.name === "PerformanceMark" ||
-        psym?.name === "PerformanceMeasure") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+    if (((psym !== undefined && ts.symbolName(psym) === "PerformanceEntry") ||
+        (psym !== undefined && ts.symbolName(psym) === "PerformanceMark") ||
+        (psym !== undefined && ts.symbolName(psym) === "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) };
     }
+    // readline's getCursorPos() record, in Node's key order ({ cols, rows }).
+    // perf_hooks' EventLoopUtilization (performance.eventLoopUtilization's
+    // result): a plain data record in Node's key order.
+    if (isStdlibInterface("EventLoopUtilization")) {
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "active", type: F64 },
+                { name: "idle", type: F64 },
+                { name: "utilization", type: F64 },
+            ], false, undefined, ["idle", "active", "utilization"]),
+        };
+    }
+    // monitorEventLoopDelay's IntervalHistogram: a numeric handle into the
+    // runtime's histogram table, like a timer handle. Its members lower over
+    // the handle (builtins/performance.ts).
+    if (isStdlibInterface("IntervalHistogram"))
+        return F64;
+    if (isStdlibInterface("CursorPos")) {
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "cols", type: F64 },
+                { name: "rows", type: F64 },
+            ], false, undefined, ["cols", "rows"]),
+        };
+    }
     // process.memoryUsage()'s record, in Node's key order.
     if (isStdlibInterface("MemoryUsage")) {
         const names = ["rss", "heapTotal", "heapUsed", "external", "arrayBuffers"];
@@ -2950,6 +3522,29 @@ function mapTypeInner(type, ctx) {
             shapeId: ctx.shapes.intern([...names].sort().map((name) => ({ name, type: F64 })), false, undefined, names),
         };
     }
+    // v8.getHeapStatistics()'s record, in Node's key order (builtins/v8.ts).
+    if (isStdlibInterface("HeapInfo")) {
+        const names = [
+            "total_heap_size",
+            "total_heap_size_executable",
+            "total_physical_size",
+            "total_available_size",
+            "used_heap_size",
+            "heap_size_limit",
+            "malloced_memory",
+            "peak_malloced_memory",
+            "does_zap_garbage",
+            "number_of_native_contexts",
+            "number_of_detached_contexts",
+            "total_global_handles_size",
+            "used_global_handles_size",
+            "external_memory",
+        ];
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([...names].sort().map((name) => ({ name, type: F64 })), false, undefined, names),
+        };
+    }
     // process.cpuUsage()/threadCpuUsage()'s {user, system} microsecond
     // record and resourceUsage()'s getrusage record — stdlib data
     // interfaces interned explicitly (the RemoteInfo pattern; declared
@@ -3008,7 +3603,7 @@ function mapTypeInner(type, ctx) {
     // over a row answers exactly Node.
     if (isStdlibInterface("NetworkInterfaceInfoIPv4") ||
         isStdlibInterface("NetworkInterfaceInfoIPv6")) {
-        const v6 = psym.name === "NetworkInterfaceInfoIPv6";
+        const v6 = ts.symbolName(psym) === "NetworkInterfaceInfoIPv6";
         const cidrArms = [NULL_T, STRING].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
         const cidr = { kind: "union", unionId: ctx.unions.intern(cidrArms) };
         const scopeid = v6 ? F64 : withUndefinedArm(F64, ctx.unions);
@@ -3099,147 +3694,17 @@ function mapTypeInner(type, ctx) {
             checker.getPropertiesOfType(widened).length > 0)
             return DYN;
     }
+    // A union of such hybrids that all map to ONE record is that record:
+    // node:test's Mock<F | Implementation> distributes to (F & { mock }) |
+    // (Implementation & { mock }), and the two function types can map alike.
+    if (widened.isUnionType()) {
+        const hybrid = mapUniformHybridUnion(widened, ctx);
+        if (hybrid)
+            return hybrid;
+    }
     const callSigs = checker.getCallSignatures(widened);
-    if (callSigs.length === 1) {
-        const sig = callSigs[0];
-        if (sig.getTypeParameters().length)
-            return null;
-        // A SYNTHESIZED rest param (tsc's JS inference for a function body
-        // reading `arguments` — `(...args: any[]) => any` whose args symbol
-        // has no declaration): the dotDotDot check below can't see it, and a
-        // fixed-arity func mapping would LIE about the value's calling
-        // convention. Detected by the param-count mismatch against the
-        // signature's own declaration, excluding an erased `this` parameter.
-        {
-            const sigDecl = checker.signatureDeclaration(sig);
-            const declParams = sigDecl !== undefined && ts.isFunctionLike(sigDecl) ? sigDecl.parameters : undefined;
-            if (declParams !== undefined &&
-                runtimeParameterCount(declParams) !== sig.getParameters().length) {
-                return null;
-            }
-            // tsgo never SYNTHESIZES that rest param into the inferred signature
-            // (5.9.3 did — the count mismatch above was the whole detector
-            // there), so the declaration's own body answers directly.
-            if (sigDecl !== undefined && ts.isFunctionLike(sigDecl) && bodyReadsArguments(sigDecl)) {
-                return null;
-            }
-        }
-        const params = [];
-        let typedRest = false;
-        for (const p of sig.getParameters()) {
-            const decl = checker.valueDeclarationOf(p);
-            const rest = decl !== undefined && ts.isParameter(decl) && decl.dotDotDotToken !== undefined;
-            // arity ABI selected by lambdaSignature. Treating an inferred any[]
-            // declaration as a typed packed-array closure would bypass its boxed
-            // spread/error semantics and change coverage classification.
-            if (rest && decl !== undefined && isJsSourceFile(decl.getSourceFile()))
-                return null;
-            const optional = decl !== undefined &&
-                ts.isParameter(decl) &&
-                (decl.questionToken !== undefined || decl.initializer !== undefined);
-            let pt = mapType(checker.getTypeOfSymbol(p), ctx);
-            if (decl &&
-                ts.isParameter(decl) &&
-                ts.isSetAccessorDeclaration(decl.parent) &&
-                isJsSourceFile(decl.getSourceFile()))
-                pt = DYN;
-            // An inferred JavaScript binding pattern consumes an iterable; it
-            // does not require the caller's array to have exactly this length.
-            const executor = decl && ts.isParameter(decl) ? decl.parent : null;
-            const construction = executor?.parent;
-            const constructorSymbol = construction && ts.isNewExpression(construction)
-                ? checker.getSymbolAtLocation(construction.expression)
-                : undefined;
-            const nativeExecutor = executor &&
-                (ts.isArrowFunction(executor) || ts.isFunctionExpression(executor)) &&
-                construction &&
-                ts.isNewExpression(construction) &&
-                construction.arguments?.[0] === executor &&
-                ts.isIdentifier(construction.expression) &&
-                construction.expression.text === "Promise" &&
-                constructorSymbol &&
-                checker
-                    .declarationsOf(constructorSymbol)
-                    .some((site) => ctx.isStdlibFile(site.getSourceFile()));
-            if (!nativeExecutor &&
-                decl &&
-                ts.isParameter(decl) &&
-                !decl.dotDotDotToken &&
-                !ts.isSetAccessorDeclaration(decl.parent) &&
-                isJsSourceFile(decl.getSourceFile()) &&
-                !decl.type &&
-                !/@(?:param|type)\b/.test(decl.getSourceFile().text.slice(decl.parent?.pos ?? decl.pos, decl.getStart())))
-                pt = DYN;
-            if (pt)
-                pt = jsOpenObjectType(decl, pt, ctx.shapes, ctx.unions);
-            // Belt and braces for non-strict type worlds: an optional param's
-            // ABI slot is always the undefined-armed union (strictNullChecks
-            // already spells it that way; arm it here if the world didn't).
-            if (optional && pt && pt.kind !== "void" && pt.kind !== "dyn") {
-                const armed = withUndefinedArm(pt, ctx.unions);
-                if (!armed)
-                    return null;
-                pt = armed;
-            }
-            if (!pt)
-                return null;
-            if (rest) {
-                if (pt.kind !== "array")
-                    return null;
-                typedRest = true;
-            }
-            // `(value: void) => void` (Promise<void>'s resolve) is callable with
-            // no arguments — a void param is dropped, not a mapping failure.
-            if (pt.kind === "void")
-                continue;
-            params.push(pt);
-        }
-        const retT = checker.getReturnTypeOfSignature(sig);
-        // `() => never` (a throw-only lambda's inferred type) is assignable to
-        // `() => void` and its calls never produce a value — map the return
-        // like declaredReturnType does for declarations. JS null/undefined
-        // returns can read mutable fields, so callable values use the same
-        // checked-native return ABI as their implementations.
-        const sigDecl = checker.signatureDeclaration(sig);
-        const jsUnitReturn = sigDecl !== undefined &&
-            isJsSourceFile(sigDecl.getSourceFile()) &&
-            (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
-        let ret = jsUnitReturn || (retT.flags & ts.TypeFlags.Any) !== 0
-            ? DYN
-            : retT.flags & ts.TypeFlags.Never
-                ? VOID
-                : mapType(retT, ctx);
-        if (sigDecl && ts.isGetAccessorDeclaration(sigDecl) && isJsSourceFile(sigDecl.getSourceFile()))
-            ret = DYN;
-        if (sigDecl && isJsSourceFile(sigDecl.getSourceFile()) && ret?.kind === "array")
-            ret = DYN;
-        if (sigDecl &&
-            ts.isFunctionLike(sigDecl) &&
-            isJsSourceFile(sigDecl.getSourceFile()) &&
-            !sigDecl.type &&
-            !/@returns?\b/.test(sigDecl.getSourceFile().text.slice(sigDecl.pos, sigDecl.getStart())) &&
-            ret?.kind === "record")
-            ret = DYN;
-        if (sigDecl &&
-            ts.isFunctionLike(sigDecl) &&
-            isJsSourceFile(sigDecl.getSourceFile()) &&
-            !sigDecl.type &&
-            !/@returns?\b/.test(sigDecl.getSourceFile().text.slice(sigDecl.pos, sigDecl.getStart())) &&
-            (ret?.kind === "date" ||
-                (ret?.kind === "union" &&
-                    ctx.unions.get(ret.unionId)?.arms.some((arm) => arm.kind === "func"))))
-            ret = DYN;
-        if (ret &&
-            sigDecl &&
-            isJsSourceFile(sigDecl.getSourceFile()) &&
-            functionCanReturnUndefined(sigDecl))
-            ret = withUndefinedArm(ret, ctx.unions) ?? ret;
-        if (!ret)
-            return null;
-        return typedRest
-            ? { kind: "func", params, ret, rest: true, restAbi: "typed" }
-            : funcOf(params, ret);
-    }
+    if (callSigs.length === 1)
+        return mapCallSignature(callSigs[0], ctx);
     // Records: object types whose members are all data properties (shorthand
     // methods in type position count — they're func-typed fields) with
     // mappable types; no call/construct signatures, no index signatures, not
@@ -3276,10 +3741,8 @@ function mapTypeInner(type, ctx) {
     if (flags & ts.TypeFlags.Object &&
         callSigs.length === 0 &&
         psym !== undefined &&
-        checker.declarationsOf(psym).length > 0 &&
-        checker
-            .declarationsOf(psym)
-            .every((d) => ts.isInterfaceDeclaration(d) && !ctx.isStdlibFile(d.getSourceFile()))) {
+        psym.declarations.length > 0 &&
+        psym.declarations.every((d) => ts.isInterfaceDeclaration(d) && !ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         const CHILD_SURFACE = new Set([
             "pid",
             "exitCode",
@@ -3312,37 +3775,49 @@ function mapTypeInner(type, ctx) {
         const props = checker.getPropertiesOfType(widened);
         let core = 0;
         const childMemberType = (p) => {
-            if (["kill", "on", "once", "off", "removeListener", "unref", "ref"].includes(p.name)) {
+            if (["kill", "on", "once", "off", "removeListener", "unref", "ref"].includes(ts.symbolName(p))) {
                 return checker.getCallSignatures(checker.getTypeOfSymbol(p)).length > 0;
             }
-            const expected = p.name === "stdout" || p.name === "stderr"
+            const expected = ts.symbolName(p) === "stdout" || ts.symbolName(p) === "stderr"
                 ? "childStream"
-                : p.name === "stdin"
+                : ts.symbolName(p) === "stdin"
                     ? "childWriter"
-                    : p.name === "killed"
+                    : ts.symbolName(p) === "killed"
                         ? "bool"
                         : "f64";
-            const unit = p.name === "pid"
+            const unit = ts.symbolName(p) === "pid"
                 ? "undefinedT"
-                : p.name === "exitCode" ||
-                    p.name === "stdin" ||
-                    p.name === "stdout" ||
-                    p.name === "stderr"
+                : ts.symbolName(p) === "exitCode" ||
+                    ts.symbolName(p) === "stdin" ||
+                    ts.symbolName(p) === "stdout" ||
+                    ts.symbolName(p) === "stderr"
                     ? "nullT"
                     : null;
             const mapped = mapType(checker.getTypeOfSymbol(p), ctx);
             if (!mapped)
                 return false;
             const arms = mapped.kind === "union" ? ctx.unions.get(mapped.unionId)?.arms : [mapped];
+            // Under the general stream representation the stdio members are the
+            // runtime stream classes.
+            const isExpected = (arm) => arm.kind === expected ||
+                (ctx.generalNodeStreams === true &&
+                    arm.kind === "object" &&
+                    ((expected === "childStream" && arm.className === "%Readable") ||
+                        (expected === "childWriter" && arm.className === "%Writable"))) ||
+                // Checked-dynamic stream slots: `NodeJS.ReadableStream | null`
+                // collapses to dyn (the reads still produce the bridged stream).
+                (ctx.dynNodeStreams === true &&
+                    arm.kind === "dyn" &&
+                    (expected === "childStream" || expected === "childWriter"));
             return (arms !== undefined &&
-                arms.some((arm) => arm.kind === expected) &&
-                arms.every((arm) => arm.kind === expected || arm.kind === unit));
+                arms.some(isExpected) &&
+                arms.every((arm) => isExpected(arm) || arm.kind === unit));
         };
         const childShaped = props.length > 0 &&
             props.every((p) => {
-                if (!CHILD_SURFACE.has(p.name) || !childMemberType(p))
+                if (!CHILD_SURFACE.has(ts.symbolName(p)) || !childMemberType(p))
                     return false;
-                if (CHILD_CORE.has(p.name))
+                if (CHILD_CORE.has(ts.symbolName(p)))
                     core++;
                 return true;
             });
@@ -3350,6 +3825,9 @@ function mapTypeInner(type, ctx) {
             return CHILD_T;
     }
     if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection) && callSigs.length === 0) {
+        const viaMapped = mapBoundMappedType(widened, ctx);
+        if (viaMapped)
+            return viaMapped;
         const viaAlias = mapGenericUtilityAlias(widened, ctx);
         if (viaAlias)
             return viaAlias;
@@ -3483,7 +3961,7 @@ function mapTypeInner(type, ctx) {
                 a.kind === "date" ||
                 a.kind === "dyn" ||
                 a.kind === "generator") ||
-                !unionContainerArmsOk(arms)) {
+                !maybePromiseUnionOk(parts, arms, ctx)) {
                 return null;
             }
             arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
@@ -3509,6 +3987,221 @@ function mapTypeInner(type, ctx) {
     }
     return null;
 }
+/** One non-overloaded call signature's func type (mapTypeInner's
+ * single-signature rule; erasedOverloadMemberType maps each overload of a
+ * member through it). */
+function mapCallSignature(sig, ctx) {
+    const { checker } = ctx;
+    if (sig.getTypeParameters().length && ctx.erasingSignature !== sig)
+        return null;
+    // A SYNTHESIZED rest param (tsc's JS inference for a function body
+    // reading `arguments` — `(...args: any[]) => any` whose args symbol
+    // has no declaration): the dotDotDot check below can't see it, and a
+    // fixed-arity func mapping would LIE about the value's calling
+    // convention. Detected by the param-count mismatch against the
+    // signature's own declaration, excluding an erased `this` parameter.
+    {
+        const sigDecl = sig.declaration;
+        const declParams = sigDecl !== undefined && ts.isFunctionLike(sigDecl) ? sigDecl.parameters.nodes : undefined;
+        if (declParams !== undefined &&
+            runtimeParameterCount(declParams) !== sig.getParameters().length) {
+            return null;
+        }
+        // tsgo never SYNTHESIZES that rest param into the inferred signature
+        // (5.9.3 did — the count mismatch above was the whole detector
+        // there), so the declaration's own body answers directly.
+        if (sigDecl !== undefined && ts.isFunctionLike(sigDecl) && bodyReadsArguments(sigDecl)) {
+            return null;
+        }
+    }
+    const params = [];
+    let typedRest = false;
+    let dynRest = false;
+    for (const p of sig.getParameters()) {
+        const decl = p.valueDeclaration;
+        const rest = decl !== undefined && ts.isParameter(decl) && decl.dotDotDotToken !== undefined;
+        // arity ABI selected by lambdaSignature. Treating an inferred any[]
+        // declaration as a typed packed-array closure would bypass its boxed
+        // spread/error semantics and change coverage classification.
+        if (rest && decl !== undefined && isJsSourceFile(ts.getSourceFileOfNode(decl)))
+            return null;
+        // A fixed-tuple rest (`...args: [A, B]`, `...args: Parameters<F>` over
+        // a bound F) flattens to its positional parameters. Pattern rests keep
+        // their packed-record ABI and stay unmapped as values.
+        if (rest && decl !== undefined && ts.isParameter(decl) && ts.isIdentifier(decl.name)) {
+            const elems = restTupleParamTypes(checker.getTypeOfSymbol(p), ctx);
+            if (elems) {
+                params.push(...elems);
+                continue;
+            }
+        }
+        const optional = decl !== undefined &&
+            ts.isParameter(decl) &&
+            (decl.questionToken !== undefined || decl.initializer !== undefined);
+        let pt = mapType(checker.getTypeOfSymbol(p), ctx);
+        // A parameter a TypeScript program types `any` takes whatever the
+        // caller passes: the checked-dynamic slot, as an `any`-typed binding
+        // already is (dynFallbackType). Declaration files keep their paths.
+        // Only function declarations, spelled function types and lambda
+        // parameters whose default is the only source of their type (`(n =
+        // lookup() ?? 5) => ...` with an `any` lookup): other lambdas and
+        // methods in object literals keep their existing checked-dynamic story.
+        if (!pt &&
+            !rest &&
+            decl !== undefined &&
+            ts.isParameter(decl) &&
+            decl.parent !== undefined &&
+            (ts.isFunctionDeclaration(decl.parent) ||
+                ts.isFunctionTypeNode(decl.parent) ||
+                ((ts.isArrowFunction(decl.parent) || ts.isFunctionExpression(decl.parent)) &&
+                    decl.initializer !== undefined &&
+                    decl.type === undefined &&
+                    !isJsSourceFile(ts.getSourceFileOfNode(decl)))) &&
+            !ts.getSourceFileOfNode(decl).isDeclarationFile &&
+            (checker.getTypeOfSymbol(p).flags & ts.TypeFlags.Any) !== 0)
+            pt = DYN;
+        if (decl &&
+            ts.isParameter(decl) &&
+            ts.isSetAccessorDeclaration(decl.parent) &&
+            isJsSourceFile(ts.getSourceFileOfNode(decl)))
+            pt = DYN;
+        // An inferred JavaScript binding pattern consumes an iterable; it
+        // does not require the caller's array to have exactly this length.
+        const executor = decl && ts.isParameter(decl) ? decl.parent : null;
+        const construction = executor?.parent;
+        const constructorSymbol = construction && ts.isNewExpression(construction)
+            ? checker.getSymbolAtLocation(construction.expression)
+            : undefined;
+        const nativeExecutor = executor &&
+            (ts.isArrowFunction(executor) || ts.isFunctionExpression(executor)) &&
+            construction &&
+            ts.isNewExpression(construction) &&
+            construction.arguments?.nodes[0] === executor &&
+            ts.isIdentifier(construction.expression) &&
+            construction.expression.text === "Promise" &&
+            constructorSymbol &&
+            constructorSymbol.declarations.some((site) => ctx.isStdlibFile(ts.getSourceFileOfNode(site)));
+        if (!nativeExecutor &&
+            decl &&
+            ts.isParameter(decl) &&
+            !decl.dotDotDotToken &&
+            !ts.isSetAccessorDeclaration(decl.parent) &&
+            isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+            !decl.type &&
+            !/@(?:param|type)\b/.test(ts
+                .getSourceFileOfNode(decl)
+                .text.slice(decl.parent?.pos ?? decl.pos, ts.tokenStartOfNode(decl))))
+            pt = DYN;
+        // A DEFAULTED program-source parameter of a function, arrow or function
+        // expression that the checker types `any` — a default under an
+        // `(...args: any[]) => any` wrapper slot (`wrap((limit = 5) => ...)`),
+        // where the contextual `any` wins over the default's type: its binding
+        // is already the checked-dynamic kind inside the body
+        // (dynFallbackType), so the callable's ABI slot is the same dyn value.
+        // Other `any` parameters keep their existing paths (an object literal
+        // holding such a callback stays a checked-dynamic object).
+        if (pt === null &&
+            !rest &&
+            decl !== undefined &&
+            ts.isParameter(decl) &&
+            decl.initializer !== undefined &&
+            (ts.isArrowFunction(decl.parent) ||
+                ts.isFunctionExpression(decl.parent) ||
+                ts.isFunctionDeclaration(decl.parent)) &&
+            !ts.getSourceFileOfNode(decl).isDeclarationFile &&
+            (checker.getTypeOfSymbol(p).flags & ts.TypeFlags.Any) !== 0)
+            pt = DYN;
+        if (pt)
+            pt = jsOpenObjectType(decl, pt, ctx.shapes, ctx.unions);
+        // Belt and braces for non-strict type worlds: an optional param's
+        // ABI slot is always the undefined-armed union (strictNullChecks
+        // already spells it that way; arm it here if the world didn't).
+        if (optional && pt && pt.kind !== "void" && pt.kind !== "dyn") {
+            const armed = withUndefinedArm(pt, ctx.unions);
+            if (!armed)
+                return null;
+            pt = armed;
+        }
+        // `...args: unknown[]` / `...args: any[]` declared in program source:
+        // the checked-dynamic variadic ABI (no typed slot; the callee's hidden
+        // trailing dyn array receives every surplus argument, as for JS rest
+        // params). Declaration files keep their existing paths: library
+        // callback slots such as String#replace's `(substring, ...args: any[])`
+        // have intrinsic lowerings that inspect the unmapped type.
+        // node:test's default mock function type, `(...args: any[]) =>
+        // undefined` (the type parameter default of mock.fn), takes the same
+        // ABI: mock.fn() without an original records whatever its callers pass.
+        if (rest &&
+            decl !== undefined &&
+            (!ts.getSourceFileOfNode(decl).isDeclarationFile ||
+                isNodeTestDefaultFunctionParam(decl, ctx)) &&
+            (pt?.kind === "dyn" || (!pt && isAnyArrayType(checker.getTypeOfSymbol(p), checker)))) {
+            dynRest = true;
+            continue;
+        }
+        if (!pt)
+            return null;
+        if (rest) {
+            if (pt.kind !== "array")
+                return null;
+            typedRest = true;
+        }
+        // `(value: void) => void` (Promise<void>'s resolve) is callable with
+        // no arguments — a void param is dropped, not a mapping failure.
+        if (pt.kind === "void")
+            continue;
+        params.push(pt);
+    }
+    const retT = checker.getReturnTypeOfSignature(sig);
+    // `() => never` (a throw-only lambda's inferred type) is assignable to
+    // `() => void` and its calls never produce a value — map the return
+    // like declaredReturnType does for declarations. JS null/undefined
+    // returns can read mutable fields, so callable values use the same
+    // checked-native return ABI as their implementations.
+    const sigDecl = sig.declaration;
+    const jsUnitReturn = sigDecl !== undefined &&
+        isJsSourceFile(ts.getSourceFileOfNode(sigDecl)) &&
+        (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
+    let ret = jsUnitReturn || (retT.flags & ts.TypeFlags.Any) !== 0
+        ? DYN
+        : retT.flags & ts.TypeFlags.Never
+            ? VOID
+            : mapType(retT, ctx);
+    if (sigDecl &&
+        ts.isGetAccessorDeclaration(sigDecl) &&
+        isJsSourceFile(ts.getSourceFileOfNode(sigDecl)))
+        ret = DYN;
+    if (sigDecl && isJsSourceFile(ts.getSourceFileOfNode(sigDecl)) && ret?.kind === "array")
+        ret = DYN;
+    if (sigDecl &&
+        ts.isFunctionLike(sigDecl) &&
+        isJsSourceFile(ts.getSourceFileOfNode(sigDecl)) &&
+        !sigDecl.type &&
+        !/@returns?\b/.test(ts.getSourceFileOfNode(sigDecl).text.slice(sigDecl.pos, ts.tokenStartOfNode(sigDecl))) &&
+        ret?.kind === "record")
+        ret = DYN;
+    if (sigDecl &&
+        ts.isFunctionLike(sigDecl) &&
+        isJsSourceFile(ts.getSourceFileOfNode(sigDecl)) &&
+        !sigDecl.type &&
+        !/@returns?\b/.test(ts.getSourceFileOfNode(sigDecl).text.slice(sigDecl.pos, ts.tokenStartOfNode(sigDecl))) &&
+        (ret?.kind === "date" ||
+            (ret?.kind === "union" &&
+                ctx.unions.get(ret.unionId)?.arms.some((arm) => arm.kind === "func"))))
+        ret = DYN;
+    if (ret &&
+        sigDecl &&
+        isJsSourceFile(ts.getSourceFileOfNode(sigDecl)) &&
+        functionCanReturnUndefined(sigDecl))
+        ret = withUndefinedArm(ret, ctx.unions) ?? ret;
+    if (!ret)
+        return null;
+    return typedRest
+        ? { kind: "func", params, ret, rest: true, restAbi: "typed" }
+        : dynRest
+            ? { kind: "func", params, ret, rest: true }
+            : funcOf(params, ret);
+}
 /** Retain a literal discriminator before widening erases its values. A
  * structural match alone is insufficient: `{ kind: "loop", body: ... }`
  * also fits a smaller `{ kind: "empty" }` record. Choosing that layout
@@ -3523,14 +4216,18 @@ function unionDiscriminant(parts, arms, ctx) {
     if (arms.filter((arm) => arm.kind === "record").length < 2 || parts.length < 2)
         return undefined;
     const { checker } = ctx;
+    // Tuple shapes keep positions only: their checker `length` literal has
+    // no slot to compare (discriminantField refuses tuple shapes too).
+    if (parts.some((part) => ctx.shapes.get(part.mapped.shapeId)?.tuple))
+        return undefined;
     for (const candidate of checker.getPropertiesOfType(parts[0].source)) {
-        if (candidate.name.startsWith("__@"))
+        if (ts.symbolName(candidate).startsWith("__@"))
             continue;
         const byTag = new Map();
         const owner = new Map();
         let complete = true;
         for (const part of parts) {
-            const prop = checker.getPropertyOfType(part.source, candidate.name);
+            const prop = checker.getPropertyOfType(part.source, ts.symbolName(candidate));
             if (!prop ||
                 prop.flags &
                     (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
@@ -3561,7 +4258,7 @@ function unionDiscriminant(parts, arms, ctx) {
         }
         if (complete) {
             return {
-                field: candidate.name,
+                field: ts.symbolName(candidate),
                 cases: [...byTag]
                     .sort(([a], [b]) => a - b)
                     .map(([tag, values]) => ({
@@ -3594,9 +4291,9 @@ function mapClassView(type, ctx, seen = new Set()) {
     }
     else {
         const symbol = type.getSymbol();
-        const declarations = symbol ? checker.declarationsOf(symbol) : [];
+        const declarations = symbol ? symbol.declarations : [];
         if (declarations.length === 0 ||
-            !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(decl.getSourceFile())))
+            !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(ts.getSourceFileOfNode(decl))))
             return undefined;
         const target = type.isTypeReference() ? type.getTarget() : type;
         if (target === undefined || !target.isClassOrInterface())
@@ -3629,10 +4326,10 @@ function mapClassView(type, ctx, seen = new Set()) {
         let representation;
         for (const base of bases) {
             const symbol = base.getSymbol();
-            const declaration = symbol ? checker.valueDeclarationOf(symbol) : undefined;
+            const declaration = symbol ? symbol.valueDeclaration : undefined;
             const classBase = declaration &&
                 (ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration)) &&
-                !declaration.getSourceFile().isDeclarationFile;
+                !ts.getSourceFileOfNode(declaration).isDeclarationFile;
             const mapped = classBase ? mapType(base, viewCtx) : mapClassView(base, viewCtx, seen);
             if (mapped === null)
                 return null;
@@ -3650,13 +4347,13 @@ function mapClassView(type, ctx, seen = new Set()) {
             checker.getIndexInfosOfType(type).length)
             return null;
         for (const property of checker.getPropertiesOfType(type)) {
-            const original = checker.getPropertyOfType(baseType, property.name);
+            const original = checker.getPropertyOfType(baseType, ts.symbolName(property));
             if (!original)
                 return null;
             if (original === property)
                 continue;
-            const originalDeclarations = checker.declarationsOf(original);
-            const declarations = checker.declarationsOf(property);
+            const originalDeclarations = original.declarations;
+            const declarations = property.declarations;
             // Instantiating an inherited member can create a new symbol without
             // changing its declaration or ABI. Only refinements need validation.
             if (declarations.length > 0 &&
@@ -3691,9 +4388,9 @@ function mapCollectionView(type, ctx, seen = new Set()) {
         return null;
     const { checker } = ctx;
     const symbol = type.getSymbol();
-    const declarations = symbol ? checker.declarationsOf(symbol) : [];
+    const declarations = symbol ? symbol.declarations : [];
     if (declarations.length === 0 ||
-        !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(decl.getSourceFile())))
+        !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(ts.getSourceFileOfNode(decl))))
         return null;
     const target = type.getTarget();
     if (target === undefined ||
@@ -3734,21 +4431,17 @@ function mapCollectionView(type, ctx, seen = new Set()) {
         const base = bases[0];
         const baseSymbol = base.getSymbol();
         const native = baseSymbol &&
-            ["Map", "ReadonlyMap", "Set", "ReadonlySet"].includes(baseSymbol.name) &&
-            checker
-                .declarationsOf(baseSymbol)
-                .some((decl) => ts.isInterfaceDeclaration(decl) && ctx.isStdlibFile(decl.getSourceFile()));
+            ["Map", "ReadonlyMap", "Set", "ReadonlySet"].includes(ts.symbolName(baseSymbol)) &&
+            baseSymbol.declarations.some((decl) => ts.isInterfaceDeclaration(decl) && ctx.isStdlibFile(ts.getSourceFileOfNode(decl)));
         const mapped = native ? mapType(base, baseCtx) : mapCollectionView(base, baseCtx, seen);
         if (mapped?.kind !== "map" && mapped?.kind !== "set")
             return null;
         const hasType = funcOf([mapped.kind === "map" ? mapped.key : mapped.elem], BOOL);
         for (const property of checker.getPropertiesOfType(type)) {
-            const own = checker
-                .declarationsOf(property)
-                .filter((decl) => !ctx.isStdlibFile(decl.getSourceFile()));
+            const own = property.declarations.filter((decl) => !ctx.isStdlibFile(ts.getSourceFileOfNode(decl)));
             if (own.length === 0)
                 continue;
-            if (property.name !== "has" ||
+            if (ts.symbolName(property) !== "has" ||
                 property.flags & ts.SymbolFlags.Optional ||
                 !own.every((decl) => decl.kind === ts.SyntaxKind.MethodSignature))
                 return null;
@@ -3858,6 +4551,166 @@ function mapBoundIndexedAccess(type, ctx) {
         return null;
     return mapType(checker.getTypeOfSymbol(prop), ctx);
 }
+/** The standard library's `Parameters<F>` / `ReturnType<F>` over a type
+ * parameter the current instantiation binds to a callable checker type:
+ * that type's one call signature. Concrete arguments never reach here (the
+ * checker evaluates those conditionals itself); generic bodies keep them
+ * symbolic because their `infer` sits in a call signature. */
+function boundSignatureAlias(type, ctx) {
+    const { checker, resolveTypeParamTs } = ctx;
+    if (!resolveTypeParamTs)
+        return null;
+    const alias = type.getAliasSymbol();
+    const aliasName = alias === undefined ? undefined : ts.symbolName(alias);
+    if (!alias || (aliasName !== "Parameters" && aliasName !== "ReturnType"))
+        return null;
+    const aliasArgs = type.getAliasTypeArguments();
+    const arg = aliasArgs[0];
+    if (aliasArgs.length !== 1 || !arg || !(arg.flags & ts.TypeFlags.TypeParameter))
+        return null;
+    const isLibAlias = alias.declarations.some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
+    if (!isLibAlias)
+        return null;
+    const bound = resolveTypeParamTs(arg);
+    if (!bound || bound.flags & ts.TypeFlags.TypeParameter)
+        return null;
+    const sigs = checker.getCallSignatures(bound);
+    const sig = sigs[0];
+    if (sigs.length !== 1 || !sig || sig.getTypeParameters().length > 0)
+        return null;
+    return { name: aliasName, sig };
+}
+/** The positional parameters of a signature as a fixed tuple: a trailing
+ * rest flattened when its own type is a fixed tuple. Null for a variadic
+ * position, which has no fixed native arity. */
+function signatureParameters(sig, ctx) {
+    const { checker } = ctx;
+    const out = [];
+    for (const p of sig.getParameters()) {
+        const decl = p.valueDeclaration;
+        const type = checker.getTypeOfSymbol(p);
+        if (decl !== undefined && ts.isParameter(decl)) {
+            if (decl.dotDotDotToken !== undefined) {
+                const inner = restTupleElements(type, ctx);
+                if (!inner)
+                    return null;
+                out.push(...inner);
+                continue;
+            }
+            out.push({
+                type,
+                optional: decl.questionToken !== undefined || decl.initializer !== undefined,
+            });
+            continue;
+        }
+        out.push({ type, optional: (p.flags & ts.SymbolFlags.Optional) !== 0 });
+    }
+    return out;
+}
+/** The required-only positional parameter types of a signature (the
+ * value-level `Parameters<F>` tuple), null when a position is optional
+ * or variadic: such a tuple's length varies per call. */
+function signatureParameterTypes(sig, ctx) {
+    const elems = signatureParameters(sig, ctx);
+    if (!elems || elems.some((e) => e.optional))
+        return null;
+    return elems.map((e) => e.type);
+}
+/** The element types of a REST parameter's type when it is a fixed tuple:
+ * a tuple of required elements (`[number, string]`, the empty `[]`), a type
+ * parameter bound to one, or `Parameters<F>` over a bound function type.
+ * Such a rest parameter has a compile-time arity, so its native ABI is the
+ * flattened positional list (exactly the equivalent fixed signature —
+ * TypeScript treats `(...a: [A, B]) => R` and `(a: A, b: B) => R` alike). */
+export function restTupleElementTypes(type, ctx) {
+    return restTupleElements(type, ctx)?.map((e) => e.type) ?? null;
+}
+/** restTupleElementTypes with each position's optionality: a rest tuple
+ * may end in optional positions (`[A, B?]`, `Parameters<(a: A, b?: B) =>
+ * R>`), which flatten to `T | undefined` slots exactly as the function
+ * type's optional parameters do. */
+function restTupleElements(type, ctx) {
+    const { checker } = ctx;
+    if (type.flags & ts.TypeFlags.TypeParameter) {
+        const bound = ctx.resolveTypeParamTs?.(type);
+        return bound && bound !== type ? restTupleElements(bound, ctx) : null;
+    }
+    const viaAlias = boundSignatureAlias(type, ctx);
+    if (viaAlias) {
+        return viaAlias.name === "Parameters" ? signatureParameters(viaAlias.sig, ctx) : null;
+    }
+    if (!checker.isTupleType(type))
+        return null;
+    const ref = type;
+    const tupleShape = ref.elementFlags !== undefined
+        ? ref
+        : ref.getTarget();
+    const args = checker.getTypeArguments(ref);
+    if (args.length === 0)
+        return [];
+    const flags = tupleShape?.elementFlags;
+    if (flags === undefined)
+        return null;
+    if (flags.some((f) => !(f & (ts.ElementFlags.Required | ts.ElementFlags.Optional))))
+        return null;
+    return args.map((t, i) => ({
+        type: t,
+        optional: (flags[i] & ts.ElementFlags.Optional) !== 0,
+    }));
+}
+/** One tuple element's IR type under the tuple mapping's rules. */
+function mapTupleElement(t, ctx) {
+    let et = (t.flags & ts.TypeFlags.Any) !== 0 ? DYN : mapType(t, ctx);
+    if (et?.kind === "void" && isUnitOnlyTsType(t, ctx.resolveTypeParam))
+        et = unitOnlyUnion(ctx.unions);
+    return !et || et.kind === "void" ? null : et;
+}
+/** The mapped element types of a fixed-tuple rest parameter type
+ * (restTupleElementTypes), null when it is not one or an element does not
+ * map. */
+export function restTupleParamTypes(type, ctx) {
+    const elems = restTupleElements(type, ctx);
+    if (!elems)
+        return null;
+    const out = [];
+    for (const e of elems) {
+        let et = mapTupleElement(e.type, ctx);
+        // An optional position's slot holds undefined when the caller omits
+        // it, as an optional parameter's does (mapCallSignature).
+        if (et && e.optional && et.kind !== "dyn")
+            et = withUndefinedArm(et, ctx.unions);
+        if (!et)
+            return null;
+        out.push(et);
+    }
+    return out;
+}
+/** `Parameters<F>` (the fixed tuple of F's parameters, interned exactly as
+ * the spelled tuple maps) and `ReturnType<F>` (F's mapped result) over a
+ * bound function-typed type parameter. */
+function mapBoundSignatureAlias(type, ctx) {
+    const target = boundSignatureAlias(type, ctx);
+    if (!target)
+        return null;
+    if (target.name === "ReturnType") {
+        const ret = ctx.checker.getReturnTypeOfSignature(target.sig);
+        return ret.flags & ts.TypeFlags.Any ? DYN : mapType(ret, ctx);
+    }
+    const elems = signatureParameterTypes(target.sig, ctx);
+    if (!elems)
+        return null;
+    if (elems.length === 0)
+        return arrayOf(unitOnlyUnion(ctx.unions));
+    const fields = [];
+    for (let i = 0; i < elems.length; i++) {
+        const et = mapTupleElement(elems[i], ctx);
+        if (!et)
+            return null;
+        fields.push({ name: String(i), type: et });
+    }
+    fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return { kind: "record", shapeId: ctx.shapes.intern(fields, true) };
+}
 /** `Partial<T>` / `Readonly<T>` where T is a STILL-GENERIC type parameter —
  * the one mapped-type spelling a monomorphized body can contain that the
  * checker cannot resolve for us (`keyof T` is unknown inside the body, so
@@ -3897,16 +4750,16 @@ export function underConstAssertion(n) {
  * panic repair): a property symbol declared by a property assignment whose
  * initializer is an EMPTY array literal inside a const assertion — its
  * type is provably `readonly []`, whatever the panicked query answered. */
-function constAssertedEmptyArrayProp(p, ctx) {
-    const d = ctx.checker.valueDeclarationOf(p);
+function constAssertedEmptyArrayProp(p) {
+    const d = p.valueDeclaration;
     if (d === undefined || !ts.isPropertyAssignment(d))
         return false;
     const init = d.initializer;
     // `a: [] as const` pins the field type by itself, wherever the literal sits.
     if (ts.isAsExpression(init) && isConstAssertionTypeNode(init.type)) {
-        return ts.isArrayLiteralExpression(init.expression) && init.expression.elements.length === 0;
+        return (ts.isArrayLiteralExpression(init.expression) && init.expression.elements.nodes.length === 0);
     }
-    if (!ts.isArrayLiteralExpression(init) || init.elements.length > 0)
+    if (!ts.isArrayLiteralExpression(init) || init.elements.nodes.length > 0)
         return false;
     return underConstAssertion(d);
 }
@@ -3915,21 +4768,22 @@ function mapGenericAwaitedAlias(type, ctx) {
     if (!resolveTypeParam)
         return null;
     const alias = type.getAliasSymbol();
-    if (!alias || alias.name !== "Awaited")
+    if (!alias || ts.symbolName(alias) !== "Awaited")
         return null;
     const aliasArgs = type.getAliasTypeArguments();
     const arg = aliasArgs[0];
     if (aliasArgs.length !== 1 || !arg)
         return null;
-    if (!(arg.flags & ts.TypeFlags.TypeParameter))
+    // `Awaited<ReturnType<F>>` (an async wrapper's settled result) resolves
+    // through F's bound signature like a bare type parameter.
+    const viaSignature = arg.flags & ts.TypeFlags.TypeParameter ? null : boundSignatureAlias(arg, ctx);
+    if (!(arg.flags & ts.TypeFlags.TypeParameter) && viaSignature?.name !== "ReturnType")
         return null;
     // Provenance: the STANDARD LIBRARY's alias, not a user's shadowing one.
-    const isLibAlias = ctx.checker
-        .declarationsOf(alias)
-        .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
+    const isLibAlias = alias.declarations.some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
     if (!isLibAlias)
         return null;
-    const bound = resolveTypeParam(arg);
+    const bound = viaSignature ? mapBoundSignatureAlias(arg, ctx) : resolveTypeParam(arg);
     if (!bound)
         return null;
     let r = bound;
@@ -3958,14 +4812,19 @@ function mapGenericIndexedAccess(type, ctx) {
     if (obj === undefined || !(obj.flags & ts.TypeFlags.TypeParameter))
         return null;
     const bound = resolveTypeParam(obj);
+    const idx = type.getIndexType();
+    if (idx === undefined)
+        return null;
+    // `T[keyof T]` over a T bound to an unknown-valued record view
+    // (`Record<string, unknown>` maps to the checked-dynamic value, see
+    // mapRecordType): every member reads as unknown.
+    if (bound?.kind === "dyn" && idx.isIndexType() && idx.getTarget() === obj)
+        return DYN;
     if (!bound || bound.kind !== "record")
         return null;
     const shape = shapes.get(bound.shapeId);
     if (!shape || shape.tuple)
         return null;
-    const idx = type.getIndexType();
-    if (idx === undefined)
-        return null;
     let covered = null;
     if (idx.isStringLiteralType()) {
         const f = shape.fields.find((x) => x.name === idx.value);
@@ -3984,14 +4843,414 @@ function mapGenericIndexedAccess(type, ctx) {
     if (!covered || covered.length === 0)
         return null;
     const first = covered[0];
-    return covered.every((t) => typeEquals(t, first)) ? first : null;
+    if (covered.every((t) => typeEquals(t, first)))
+        return first;
+    // Only the `keyof T` index itself covers every field at once; a key
+    // parameter bound to string keeps its literal-key resolution below.
+    if (!(idx.isIndexType() && idx.getTarget() === obj))
+        return null;
+    // Fields of different scalar types (`Object.entries` over a bound record
+    // reads `T[keyof T]`): any one of them, the union of their types.
+    const arms = [];
+    for (const t of covered) {
+        const parts = t.kind === "union" ? (ctx.unions.get(t.unionId)?.arms ?? null) : [t];
+        if (!parts)
+            return null;
+        for (const part of parts) {
+            if (part.kind !== "f64" &&
+                part.kind !== "string" &&
+                part.kind !== "bool" &&
+                part.kind !== "undefinedT" &&
+                part.kind !== "nullT")
+                return null;
+            if (!arms.some((a) => typeEquals(a, part)))
+                arms.push(part);
+        }
+    }
+    if (arms.length === 1)
+        return arms[0];
+    arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    return { kind: "union", unionId: ctx.unions.intern(arms) };
+}
+/** `keyof T extends never ? A : B` over a bound record T (the lib's
+ * Object.entries element spelling): decided by whether the binding has any
+ * key. */
+function mapBoundKeyofNeverConditional(type, ctx) {
+    const { resolveTypeParam, shapes } = ctx;
+    if (!resolveTypeParam || !type.isConditionalType())
+        return null;
+    const check = type.getCheckType();
+    const ext = type.getExtendsType();
+    if (!check || !ext || !(ext.flags & ts.TypeFlags.Never) || !check.isIndexType())
+        return null;
+    const target = check.getTarget();
+    if (!target || !(target.flags & ts.TypeFlags.TypeParameter))
+        return null;
+    const bound = resolveTypeParam(target);
+    // A T bound to the checked-dynamic value (`Record<string, unknown>`, an
+    // unknown-valued record view) has no static key set to decide the
+    // branch, but both branches of the lib's `keyof T extends never ?
+    // unknown : T[keyof T]` read as unknown there: one answer either way.
+    if (bound?.kind === "dyn") {
+        const whenEmpty = type.getTrueType();
+        const otherwise = type.getFalseType();
+        const a = whenEmpty ? mapType(whenEmpty, ctx) : null;
+        const b = otherwise ? mapType(otherwise, ctx) : null;
+        return a && b && typeEquals(a, b) ? a : null;
+    }
+    if (bound?.kind !== "record")
+        return null;
+    const shape = shapes.get(bound.shapeId);
+    if (!shape || shape.tuple)
+        return null;
+    const hasKeys = shape.fields.length > 0 || shape.indexValue !== undefined;
+    const branch = hasKeys ? type.getFalseType() : type.getTrueType();
+    return branch ? mapType(branch, ctx) : null;
+}
+/** A mapped type over a type parameter of the instance being lowered (`{
+ * [K in keyof S]: S[K] }`, `{ [K in keyof S]: Infer<S[K]> }`): the checker
+ * keeps it symbolic inside the generic body, but the instance binds `S`,
+ * so each property of the bound type maps through the template evaluated
+ * with `K` set to that property's key. Optionality follows the `?`
+ * modifier, or the bound property's own for a homomorphic mapping. Null
+ * when the shape is anything else or a template form does not evaluate. */
+function mapBoundMappedType(widened, ctx) {
+    const { checker, resolveTypeParamTs, shapes, unions } = ctx;
+    if (!resolveTypeParamTs || !isMappedShape(widened))
+        return null;
+    const symbol = widened.getSymbol();
+    const node = symbol
+        ? symbol.declarations.find((d) => ts.isMappedTypeNode(d))
+        : undefined;
+    const constraint = node?.typeParameter.constraint;
+    if (!node?.type ||
+        !constraint ||
+        !ts.isTypeOperatorNode(constraint) ||
+        constraint.operator !== ts.SyntaxKind.KeyOfKeyword)
+        return null;
+    const source = checker.getTypeFromTypeNode(constraint.type);
+    if (!(source.flags & ts.TypeFlags.TypeParameter))
+        return null;
+    const bound = resolveTypeParamTs(source);
+    const key = checker.getSymbolAtLocation(node.typeParameter.name);
+    if (!bound || !key)
+        return null;
+    const template = checker.getTypeFromTypeNode(node.type);
+    const modifier = node.questionToken?.kind;
+    const fields = [];
+    const order = [];
+    for (const property of checker.getPropertiesOfType(bound)) {
+        const name = ts.symbolName(property);
+        const evaluated = evalMappedTemplate(template, new Map([[key, name]]), new Map(), ctx);
+        let type = evaluated ? mapType(evaluated, ctx) : null;
+        if (!type)
+            return null;
+        const optional = modifier === ts.SyntaxKind.MinusToken
+            ? false
+            : modifier !== undefined || (property.flags & ts.SymbolFlags.Optional) !== 0;
+        if (optional) {
+            const armed = withUndefinedArm(type, unions);
+            if (!armed)
+                return null;
+            type = armed;
+        }
+        fields.push({ name, type });
+        order.push(name);
+    }
+    fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return { kind: "record", shapeId: shapes.intern(fields, false, undefined, order) };
+}
+/** The checker type a mapped type's template stands for at one key:
+ * `keys` binds the mapped type parameter to a property name, `aliases`
+ * binds type-alias and `infer` parameters met on the way. Handles type
+ * parameters (through the instance's bindings), indexed accesses
+ * (`S[K]`, `S[K]["_output"]`) and conditional types whose `extends` side
+ * is a reference to the same generic type as the checked type
+ * (`S extends Schema<infer T> ? T : never`); answers the type itself
+ * when it mentions none of the bound parameters, null otherwise. */
+function evalMappedTemplate(type, keys, aliases, ctx) {
+    const { checker, resolveTypeParamTs } = ctx;
+    if (type.flags & ts.TypeFlags.TypeParameter) {
+        const symbol = type.getSymbol();
+        if (symbol && keys.has(symbol))
+            return null;
+        if (symbol && aliases.has(symbol))
+            return aliases.get(symbol);
+        return resolveTypeParamTs?.(type) ?? null;
+    }
+    if (type.isIndexedAccessType()) {
+        const object = type.getObjectType();
+        const index = type.getIndexType();
+        if (!object || !index)
+            return null;
+        const receiver = evalMappedTemplate(object, keys, aliases, ctx);
+        const indexSymbol = index.flags & ts.TypeFlags.TypeParameter ? index.getSymbol() : undefined;
+        const name = indexSymbol && keys.has(indexSymbol)
+            ? keys.get(indexSymbol)
+            : index.isStringLiteralType()
+                ? index.value
+                : index.isNumberLiteralType()
+                    ? String(index.value)
+                    : null;
+        if (!receiver || name === null)
+            return null;
+        const property = checker.getPropertyOfType(receiver, name);
+        return property ? checker.getTypeOfSymbol(property) : null;
+    }
+    if (type.isConditionalType()) {
+        // A conditional reached through an alias (`Infer<S[K]>`) checks the
+        // alias's own parameters: bind them to the evaluated arguments.
+        let scope = aliases;
+        const alias = type.getAliasSymbol();
+        const aliasArgs = type.getAliasTypeArguments();
+        const aliasDecl = alias
+            ? alias.declarations.find((d) => ts.isTypeAliasDeclaration(d))
+            : undefined;
+        if (aliasDecl?.typeParameters?.nodes &&
+            aliasArgs.length === aliasDecl.typeParameters.nodes.length) {
+            scope = new Map(aliases);
+            for (let i = 0; i < aliasArgs.length; i++) {
+                const param = checker.getSymbolAtLocation(aliasDecl.typeParameters.nodes[i].name);
+                const arg = evalMappedTemplate(aliasArgs[i], keys, aliases, ctx);
+                if (!param || !arg)
+                    return null;
+                scope.set(param, arg);
+            }
+        }
+        const checkType = type.getCheckType();
+        const extendsType = type.getExtendsType();
+        if (!checkType || !extendsType)
+            return null;
+        const checked = evalMappedTemplate(checkType, keys, scope, ctx);
+        if (!checked)
+            return null;
+        const inferred = matchInferReference(checked, extendsType, ctx);
+        if (inferred === undefined)
+            return null;
+        const branch = inferred ? type.getTrueType() : type.getFalseType();
+        const branchScope = inferred ? new Map([...scope, ...inferred]) : scope;
+        return evalMappedTemplate(branch, keys, branchScope, ctx);
+    }
+    return mentionsMappedParams(type, keys, aliases) ? null : type;
+}
+/** `checked extends G<..., infer T, ...>`: the infer bindings when
+ * `checked` is a reference to the same generic `G` (its arguments bind the
+ * infer positions; other positions must be the same types), false when it
+ * is a reference to another type or a primitive, undefined when the match
+ * cannot be decided this way. */
+function matchInferReference(checked, extendsType, ctx) {
+    const { checker } = ctx;
+    const target = (t) => t.isTypeReference?.() ? t.getTarget?.() : undefined;
+    const wantTarget = target(extendsType) ?? extendsType.getAliasSymbol();
+    if (!wantTarget)
+        return matchInferSignature(checked, extendsType, ctx);
+    const gotTarget = target(checked) ?? checked.getAliasSymbol();
+    if (!gotTarget)
+        return checked.flags & ts.TypeFlags.Object
+            ? matchInferThenable(checked, extendsType, ctx)
+            : false;
+    if (gotTarget !== wantTarget)
+        return matchInferThenable(checked, extendsType, ctx);
+    const wantArgs = target(extendsType)
+        ? checker.getTypeArguments(extendsType)
+        : extendsType.getAliasTypeArguments();
+    const gotArgs = target(checked)
+        ? checker.getTypeArguments(checked)
+        : checked.getAliasTypeArguments();
+    if (wantArgs.length !== gotArgs.length)
+        return undefined;
+    const inferred = new Map();
+    for (let i = 0; i < wantArgs.length; i++) {
+        const want = wantArgs[i];
+        const symbol = want.flags & ts.TypeFlags.TypeParameter ? want.getSymbol() : undefined;
+        const isInfer = symbol
+            ? symbol.declarations.some((d) => d.parent !== undefined && ts.isInferTypeNode(d.parent))
+            : false;
+        if (isInfer && symbol)
+            inferred.set(symbol, gotArgs[i]);
+        else if (want !== gotArgs[i])
+            return undefined;
+    }
+    return inferred;
+}
+/** The type parameter an `infer X` declares, when `t` is one. */
+function inferSymbolOf(t, _ctx) {
+    if (!(t.flags & ts.TypeFlags.TypeParameter))
+        return undefined;
+    const symbol = t.getSymbol();
+    return symbol &&
+        symbol.declarations.some((d) => d.parent !== undefined && ts.isInferTypeNode(d.parent))
+        ? symbol
+        : undefined;
+}
+/** `checked extends (...args: any) => infer R` — the shape of the standard
+ * library's ReturnType, over a concrete function type: R binds to its
+ * result. Pattern parameters must be `any` or `any[]`, and a pattern rest
+ * `any` or `any[]`; anything else stays undecided. The match follows
+ * TypeScript's assignability: a primitive never matches a function type,
+ * a function that needs more arguments than a pattern without a rest
+ * passes never matches, and a positional `any[]` parameter needs the
+ * function's parameter there to accept an array. */
+function matchInferSignature(checked, extendsType, ctx) {
+    const { checker } = ctx;
+    const wantSigs = checker.getCallSignatures(extendsType);
+    const want = wantSigs[0];
+    if (wantSigs.length !== 1 || !want || want.getTypeParameters().length > 0)
+        return undefined;
+    const wantShape = signatureShape(want, ctx);
+    if (wantShape === undefined)
+        return undefined;
+    const isAny = (t) => (t.flags & ts.TypeFlags.Any) !== 0;
+    const isAnyArray = (t) => checker.isArrayType(t) && isAny(checker.getTypeArguments(t)[0]);
+    if (!wantShape.params.every((p) => isAny(p.type) || isAnyArray(p.type)))
+        return undefined;
+    if (wantShape.rest !== null && !isAny(wantShape.rest))
+        return undefined;
+    if (!(checked.flags & ts.TypeFlags.Object))
+        return false;
+    const gotSigs = checker.getCallSignatures(checked);
+    const got = gotSigs[0];
+    if (gotSigs.length !== 1 || !got || got.getTypeParameters().length > 0)
+        return undefined;
+    const gotShape = signatureShape(got, ctx);
+    if (gotShape !== undefined) {
+        // `(a: any) => infer R` rejects `(a: string, b: string) => R` and
+        // `(...args: [string, number]) => R`: they need more arguments.
+        if (wantShape.rest === null && requiredArguments(gotShape) > wantShape.params.length)
+            return false;
+        for (let i = 0; i < wantShape.params.length; i++) {
+            if (!isAnyArray(wantShape.params[i].type))
+                continue;
+            const param = gotShape.params[i]?.type ?? gotShape.rest;
+            if (param === undefined || param === null)
+                continue;
+            const accepts = acceptsArray(param, ctx);
+            if (accepts !== true)
+                return accepts;
+        }
+    }
+    else if (wantShape.params.some((p) => isAnyArray(p.type))) {
+        return undefined;
+    }
+    const wantRet = checker.getReturnTypeOfSignature(want);
+    const infer = inferSymbolOf(wantRet, ctx);
+    if (infer)
+        return new Map([[infer, checker.getReturnTypeOfSignature(got)]]);
+    return wantRet.flags & ts.TypeFlags.Any ? new Map() : undefined;
+}
+/** A signature's parameters as a call sees them: the positional ones, with
+ * a fixed-tuple rest (`...args: [A, B?]`) flattened into positions, and the
+ * element type of an array rest (`any` for `...args: any`). Undefined when
+ * a parameter has no declaration, or the rest is a variadic tuple or
+ * another type. */
+function signatureShape(sig, ctx) {
+    const { checker } = ctx;
+    const params = [];
+    for (const p of sig.getParameters()) {
+        const decl = p.valueDeclaration;
+        if (decl === undefined || !ts.isParameter(decl))
+            return undefined;
+        const type = checker.getTypeOfSymbol(p);
+        if (decl.dotDotDotToken === undefined) {
+            params.push({
+                type,
+                optional: decl.questionToken !== undefined || decl.initializer !== undefined,
+            });
+            continue;
+        }
+        if (type.flags & ts.TypeFlags.Any)
+            return { params, rest: type };
+        if (checker.isArrayType(type))
+            return { params, rest: checker.getTypeArguments(type)[0] };
+        const elems = restTupleElements(type, ctx);
+        if (!elems)
+            return undefined;
+        for (const e of elems)
+            params.push({ type: e.type, optional: e.optional });
+        return { params, rest: null };
+    }
+    return { params, rest: null };
+}
+/** The fewest arguments a call must pass: up to the last required position. */
+function requiredArguments(shape) {
+    let required = 0;
+    shape.params.forEach((p, i) => {
+        if (!p.optional)
+            required = i + 1;
+    });
+    return required;
+}
+/** Whether a parameter of this type accepts an `any[]` argument: true for
+ * `any`, `unknown` and array types, false for primitives, undefined
+ * otherwise. */
+function acceptsArray(t, ctx) {
+    if (t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
+        return true;
+    if (ctx.checker.isArrayType(t))
+        return true;
+    const primitive = ts.TypeFlags.StringLike |
+        ts.TypeFlags.NumberLike |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.BigIntLike |
+        ts.TypeFlags.ESSymbolLike |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Void;
+    return t.flags & primitive ? false : undefined;
+}
+/** `checked extends PromiseLike<infer U>` (or `Promise<infer U>`) over the
+ * standard library's Promise: U binds to the settled type. An object with
+ * no `then` member is no thenable. Everything else stays undecided. */
+function matchInferThenable(checked, extendsType, ctx) {
+    const { checker } = ctx;
+    const stdlibNamed = (t, names) => {
+        const symbol = t.getSymbol();
+        return (symbol !== undefined &&
+            names.includes(ts.symbolName(symbol)) &&
+            symbol.declarations.some((d) => ctx.isStdlibFile(ts.getSourceFileOfNode(d))));
+    };
+    if (!stdlibNamed(extendsType, ["PromiseLike", "Promise"]))
+        return undefined;
+    const wantArgs = checker.getTypeArguments(extendsType);
+    const infer = wantArgs.length === 1 ? inferSymbolOf(wantArgs[0], ctx) : undefined;
+    if (!infer)
+        return undefined;
+    if (stdlibNamed(checked, ["Promise", "PromiseLike"])) {
+        const gotArgs = checker.getTypeArguments(checked);
+        return gotArgs.length === 1 ? new Map([[infer, gotArgs[0]]]) : undefined;
+    }
+    return checker.getPropertyOfType(checked, "then") === undefined ? false : undefined;
+}
+/** The type mentions a mapped key or bound alias parameter (a template
+ * shape evalMappedTemplate does not reduce). */
+function mentionsMappedParams(type, keys, aliases) {
+    if (type.flags & ts.TypeFlags.TypeParameter) {
+        const symbol = type.getSymbol();
+        return symbol !== undefined && (keys.has(symbol) || aliases.has(symbol));
+    }
+    if (type.isUnionType() || type.isIntersectionType())
+        return ts.constituentTypes(type).some((part) => mentionsMappedParams(part, keys, aliases));
+    return false;
+}
+function readonlyClassType(type, ctx) {
+    const alias = type.getAliasSymbol();
+    if (alias === undefined || ts.symbolName(alias) !== "Readonly")
+        return null;
+    const args = type.getAliasTypeArguments();
+    if (args.length !== 1 || !args[0])
+        return null;
+    const isLibAlias = alias.declarations.some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
+    if (!isLibAlias)
+        return null;
+    const mapped = mapType(args[0], ctx);
+    return mapped !== null && isDynTypedRefType(mapped) ? mapped : null;
 }
 function mapGenericUtilityAlias(widened, ctx) {
     const { resolveTypeParam, shapes, unions } = ctx;
     if (!resolveTypeParam)
         return null;
     const alias = widened.getAliasSymbol();
-    if (!alias || (alias.name !== "Partial" && alias.name !== "Readonly"))
+    if (!alias || (ts.symbolName(alias) !== "Partial" && ts.symbolName(alias) !== "Readonly"))
         return null;
     const aliasArgs = widened.getAliasTypeArguments();
     const arg = aliasArgs[0];
@@ -4000,15 +5259,13 @@ function mapGenericUtilityAlias(widened, ctx) {
     if (!(arg.flags & ts.TypeFlags.TypeParameter))
         return null;
     // Provenance: the STANDARD LIBRARY's alias, not a user's shadowing one.
-    const isLibAlias = ctx.checker
-        .declarationsOf(alias)
-        .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
+    const isLibAlias = alias.declarations.some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)));
     if (!isLibAlias)
         return null;
     const bound = resolveTypeParam(arg);
     if (!bound || bound.kind !== "record")
         return null;
-    if (alias.name === "Readonly")
+    if (ts.symbolName(alias) === "Readonly")
         return bound;
     const shape = shapes.get(bound.shapeId);
     if (!shape)
@@ -4118,7 +5375,20 @@ export function isUnitOnlyTsType(t, resolveTypeParam) {
     const UNIT = ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Null;
     const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
     return parts.every((p) => (p.flags & UNIT) !== 0 ||
-        ((p.flags & ts.TypeFlags.TypeParameter) !== 0 && resolveTypeParam?.(p)?.kind === "void"));
+        ((p.flags & ts.TypeFlags.TypeParameter) !== 0 && resolveTypeParam?.(p)?.kind === "void") ||
+        boundVoidReturnType(p, resolveTypeParam));
+}
+/** `ReturnType<F>` over a type parameter bound to a void-returning
+ * function (a variadic wrapper's result slot): a unit-only value. */
+function boundVoidReturnType(p, resolveTypeParam) {
+    if (!resolveTypeParam || ts.symbolNameOf(p.getAliasSymbol()) !== "ReturnType")
+        return false;
+    const args = p.getAliasTypeArguments();
+    const arg = args[0];
+    if (args.length !== 1 || !arg || !(arg.flags & ts.TypeFlags.TypeParameter))
+        return false;
+    const bound = resolveTypeParam(arg);
+    return bound?.kind === "func" && bound.ret.kind === "void";
 }
 /** IR-level `t | undefined`, canonicalized and fenced exactly like the
  * ts-union branch of mapType (typeKey-sorted arms, deduplicated;
@@ -4201,14 +5471,31 @@ function mapHybridCallableIntersection(widened, ctx) {
         const pt = mapType(checker.getTypeOfSymbol(p), ctx);
         if (!pt || pt.kind === "void")
             return null;
-        fields.push({ name: p.name, type: pt });
-        declaredOrder.push(p.name);
+        fields.push({ name: ts.symbolName(p), type: pt });
+        declaredOrder.push(ts.symbolName(p));
     }
     if (fields.length === 1)
         return null; // no properties — it is just F
     fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     return { kind: "record", shapeId: shapes.intern(fields, false, undefined, declaredOrder) };
 }
+/** The record every part of a union of function-with-properties
+ * intersections maps to, or null when a part does not map to the same one. */
+function mapUniformHybridUnion(widened, ctx) {
+    const parts = ts.constituentTypes(widened);
+    if (!parts.every((p) => p.isIntersectionType()))
+        return null;
+    let first = null;
+    for (const part of parts) {
+        if (ctx.checker.getConstructSignatures(part).length > 0)
+            return null;
+        const mapped = mapHybridCallableIntersection(part, ctx);
+        if (!mapped || (first && typeKey(mapped) !== typeKey(first)))
+            return null;
+        first ??= mapped;
+    }
+    return first;
+}
 /** Optional standard error metadata refines an existing Error identity;
  * it does not allocate a structural copy or extend its native layout. */
 function mapErrorMetadataIntersection(type, ctx) {
@@ -4227,12 +5514,14 @@ function mapErrorMetadataIntersection(type, ctx) {
                 "TypeError",
                 "URIError",
                 "AggregateError",
-            ].includes(symbol.name) &&
-            ctx.checker.declarationsOf(symbol).some((decl) => ctx.isStdlibFile(decl.getSourceFile())));
+                "SuppressedError",
+            ].includes(ts.symbolName(symbol)) &&
+            symbol.declarations.some((decl) => ctx.isStdlibFile(ts.getSourceFileOfNode(decl))));
     });
     if (!hasError)
         return null;
     let error = null;
+    const extra = [];
     for (const part of parts) {
         const mapped = mapType(part, ctx);
         if (mapped?.kind === "object" && RUNTIME_ERROR_CLASSES.has(mapped.className)) {
@@ -4246,19 +5535,45 @@ function mapErrorMetadataIntersection(type, ctx) {
             ctx.checker.getIndexInfosOfType(part).length)
             return null;
         for (const property of ctx.checker.getPropertiesOfType(part)) {
-            const expected = property.name === "errno"
+            const expected = ts.symbolName(property) === "errno"
                 ? "f64"
-                : ["code", "syscall", "path", "dest"].includes(property.name)
+                : ["code", "syscall", "path", "dest"].includes(ts.symbolName(property))
                     ? "string"
                     : null;
-            if (!expected || !(property.flags & ts.SymbolFlags.Optional))
-                return null;
+            if (!expected) {
+                extra.push(property);
+                continue;
+            }
             const field = mapType(ctx.checker.getTypeOfSymbol(property), ctx);
             const arms = field?.kind === "union" ? ctx.unions.get(field.unionId)?.arms : field ? [field] : [];
             if (!arms?.length || !arms.every((arm) => arm.kind === expected || arm.kind === "undefinedT"))
                 return null;
+            // A required member must still admit the absent value the slot reads.
+            if (!(property.flags & ts.SymbolFlags.Optional) &&
+                !arms.some((arm) => arm.kind === "undefinedT"))
+                return null;
         }
     }
+    if (!error)
+        return null;
+    // Members beyond Error's own and the system-error metadata (`Error & {
+    // status: number }`, Object.assign's result) are own properties of the
+    // error's checked-dynamic node: each must map to a type a checked read
+    // can produce. Error's own string members keep their slots.
+    for (const property of extra) {
+        const field = mapType(ctx.checker.getTypeOfSymbol(property), ctx);
+        if (!field || field.kind === "void")
+            return null;
+        if (ts.symbolName(property) === "message" || ts.symbolName(property) === "name") {
+            if (field.kind !== "string")
+                return null;
+            continue;
+        }
+        if (ts.symbolName(property) === "stack" || ts.symbolName(property) === "cause")
+            return null;
+        if (!canDynCheckTo(field, (id) => ctx.shapes.get(id), (id) => ctx.unions.get(id)))
+            return null;
+    }
     return error;
 }
 /** A conventional primitive brand has one runtime-carrying primitive part
@@ -4365,13 +5680,13 @@ function immutableSourceType(type, ctx) {
         return null;
     const { checker } = ctx;
     const symbol = type.getSymbol();
-    const decl = symbol ? checker.declarationsOf(symbol)[0] : undefined;
-    if (decl === undefined || !CONTRACT_TYPES_FILE.test(decl.getSourceFile().fileName))
+    const decl = symbol ? symbol.declarations[0] : undefined;
+    if (decl === undefined || !CONTRACT_TYPES_FILE.test(ts.getSourceFileOfNode(decl).fileName))
         return null;
     const props = checker.getPropertiesOfType(type);
     const seen = new Set();
     for (const prop of props) {
-        const owner = checker.declarationsOf(prop)[0]?.parent;
+        const owner = prop.declarations[0]?.parent;
         if (owner === undefined || seen.has(owner))
             continue;
         seen.add(owner);
@@ -4380,7 +5695,7 @@ function immutableSourceType(type, ctx) {
             source = checker.getTypeFromTypeNode(owner);
         else if ((ts.isClassDeclaration(owner) || ts.isInterfaceDeclaration(owner)) &&
             owner.name !== undefined &&
-            (owner.typeParameters?.length ?? 0) === 0) {
+            (owner.typeParameters?.nodes.length ?? 0) === 0) {
             const ownerSymbol = checker.getSymbolAtLocation(owner.name);
             if (ownerSymbol)
                 source = checker.getDeclaredTypeOfSymbol(ownerSymbol);
@@ -4398,6 +5713,14 @@ function isMappedShape(t) {
     return ((t.flags & ts.TypeFlags.Object) !== 0 &&
         (t.objectFlags & ts.ObjectFlags.Mapped) !== 0);
 }
+/** A declaration file an installed package ships (its own or an @types
+ * twin), outside the standard library and @types/node: the type surface
+ * of a package the program does not compile. Its pure type shapes —
+ * interfaces, aliases, type literals — describe data a program can build
+ * itself (`import type` from a types-only package such as type-fest). */
+function packageTypeFile(sf, ctx) {
+    return (sf.isDeclarationFile && /[\\/]node_modules[\\/]/.test(sf.fileName) && !ctx.isStdlibFile(sf));
+}
 /** 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
@@ -4423,20 +5746,19 @@ function recordProvenanceOk(t, ctx) {
     if (isMappedShape(t))
         return true;
     const tSym = t.getSymbol();
-    const decls = tSym ? checker.declarationsOf(tSym) : undefined;
+    const decls = tSym ? tSym.declarations : undefined;
     if (!decls || decls.length === 0) {
         // Inferred destructuring parameters can have a synthesized anonymous
         // shape with no declaration or member symbols to trace to a source.
         return checker
             .getPropertiesOfType(t)
-            .every((property) => checker
-            .declarationsOf(property)
-            .every((decl) => !decl.getSourceFile().isDeclarationFile ||
-            ctx.isExternalTypeFile(decl.getSourceFile())));
+            .every((property) => property.declarations.every((decl) => !ts.getSourceFileOfNode(decl).isDeclarationFile ||
+            ctx.isExternalTypeFile(ts.getSourceFileOfNode(decl)) ||
+            packageTypeFile(ts.getSourceFileOfNode(decl), ctx)));
     }
     return !decls.some((d) => {
-        const sf = d.getSourceFile();
-        return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
+        const sf = ts.getSourceFileOfNode(d);
+        return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf) && !packageTypeFile(sf, ctx);
     });
 }
 /** A GENERIC-callable member type (`m<T>(x: T): T` / `f: <T>(x: T) => T` in
@@ -4458,6 +5780,213 @@ export function isGenericCallableMemberType(t, checker) {
         checker.getPropertiesOfType(t).length === 0 &&
         checker.getIndexInfosOfType(t).length === 0);
 }
+/** Result containers an erased async function or generator must keep:
+ * their contents are erased instead (`Promise<T>` maps as
+ * `Promise<unknown>`). */
+const ERASURE_KEPT_CONTAINERS = new Set(["Promise", "Generator", "AsyncGenerator"]);
+/** The type mentions a type parameter that the active erasure binds to
+ * `unknown` (erasedGenericMemberType, erased bodies). */
+function mentionsErasedTypeParam(type, ctx, depth) {
+    if (depth > 8)
+        return false;
+    const { checker } = ctx;
+    if (type.flags & ts.TypeFlags.TypeParameter)
+        return ctx.resolveTypeParam?.(type)?.kind === "dyn";
+    if (type.flags &
+        (ts.TypeFlags.IndexedAccess | ts.TypeFlags.Conditional | ts.TypeFlags.Substitution))
+        return true;
+    if (type.isUnionType() || type.isIntersectionType())
+        return ts.constituentTypes(type).some((part) => mentionsErasedTypeParam(part, ctx, depth + 1));
+    if ((type.flags & ts.TypeFlags.Object) === 0)
+        return false;
+    if (type.isTypeReference() &&
+        checker
+            .getTypeArguments(type)
+            .some((arg) => mentionsErasedTypeParam(arg, ctx, depth + 1)))
+        return true;
+    for (const sig of checker.getCallSignatures(type)) {
+        if (mentionsErasedTypeParam(checker.getReturnTypeOfSignature(sig), ctx, depth + 1))
+            return true;
+        for (const param of sig.getParameters())
+            if (mentionsErasedTypeParam(checker.getTypeOfSymbol(param), ctx, depth + 1))
+                return true;
+    }
+    const symbol = type.getSymbol();
+    const anonymous = symbol !== undefined &&
+        (symbol.flags & (ts.SymbolFlags.TypeLiteral | ts.SymbolFlags.ObjectLiteral)) !== 0;
+    if (anonymous)
+        for (const property of checker.getPropertiesOfType(type))
+            if (mentionsErasedTypeParam(checker.getTypeOfSymbol(property), ctx, depth + 1))
+                return true;
+    return false;
+}
+/** 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
+ * same way). Undefined when the member has overloads or the erased
+ * signature does not map: the member then stays out of the shape, and only
+ * calls on a provable definition compile. */
+export function erasedGenericMemberType(t, ctx) {
+    const sigs = ctx.checker.getCallSignatures(t);
+    if (sigs.length !== 1)
+        return undefined;
+    const sig = sigs[0];
+    const own = new Set(sig.getTypeParameters());
+    const outer = ctx.resolveTypeParam;
+    const erased = mapType(t, {
+        ...ctx,
+        erasingSignature: sig,
+        resolveTypeParam: (param) => (own.has(param) ? DYN : (outer?.(param) ?? null)),
+    });
+    return erased?.kind === "func" ? erased : undefined;
+}
+/** 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
+ * 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). */
+export function isOverloadedCallableMemberType(t, checker) {
+    const sigs = checker.getCallSignatures(t);
+    if (sigs.length < 2)
+        return false;
+    if (checker.getConstructSignatures(t).length > 0 ||
+        checker.getPropertiesOfType(t).length > 0 ||
+        checker.getIndexInfosOfType(t).length > 0)
+        return false;
+    return sigs.every((sig) => {
+        const decl = sig.declaration;
+        if (decl === undefined)
+            return false;
+        if (!ts.isMethodSignatureDeclaration(decl) && !ts.isCallSignatureDeclaration(decl))
+            return false;
+        const file = ts.getSourceFileOfNode(decl);
+        return !file.isDeclarationFile && !isJsSourceFile(file);
+    });
+}
+/** Scalar arms an overload join may combine into one union. */
+const OVERLOAD_JOIN_SCALARS = new Set(["f64", "string", "bool", "undefinedT", "nullT"]);
+/** The join of one position's types across an overload set: equal types
+ * stay; scalar mixes form their union; anything else is `unknown` when
+ * every joined type crosses the checked-dynamic boundary in both directions
+ * (the call site converts into the slot, the implementation converts out
+ * of it). Differing callbacks (`(x: number) => void` beside `(x: string) =>
+ * void`) therefore travel as checked function values, which any
+ * implementation's own callback type adapts from. Null when no join
+ * exists. */
+function joinOverloadTypes(types, ctx) {
+    const first = types[0];
+    if (types.every((t) => typeEquals(t, first)))
+        return first;
+    const getRecord = (id) => ctx.shapes.get(id);
+    const getUnion = (id) => ctx.unions.get(id);
+    const arms = new Map();
+    let scalar = true;
+    for (const t of types) {
+        const parts = t.kind === "union" ? (ctx.unions.get(t.unionId)?.arms ?? []) : [t];
+        if (parts.length === 0)
+            scalar = false;
+        for (const part of parts) {
+            if (!OVERLOAD_JOIN_SCALARS.has(part.kind))
+                scalar = false;
+            arms.set(typeKey(part), part);
+        }
+    }
+    if (scalar && [...arms.values()].some((arm) => !isUnitType(arm))) {
+        const sorted = [...arms.values()].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+        return { kind: "union", unionId: ctx.unions.intern(sorted) };
+    }
+    if (types.every((t) => t.kind === "dyn" ||
+        (t.kind !== "void" &&
+            canConvertToDyn(t, getRecord, getUnion) &&
+            canDynCheckTo(t, getRecord, getUnion))))
+        return DYN;
+    return null;
+}
+/** An overloaded member's runtime type (isOverloadedCallableMemberType).
+ * JavaScript stores ONE function under the member; overload signatures only
+ * constrain call sites. The slot's type joins the overloads per parameter
+ * position and result (joinOverloadTypes), and a position some overloads
+ * omit is optional. Each overload's own type parameters erase to `unknown`
+ * first. Calls pick their overload statically, convert arguments into the
+ * slot's parameter types and the result back to the overload's; an
+ * implementation converts into the slot like any function value. Undefined
+ * when the set does not join (rest parameters, a void result beside a
+ * value result, a component outside the checked-dynamic boundary): the
+ * member keeps its fence. */
+export function erasedOverloadMemberType(t, ctx) {
+    const funcs = [];
+    for (const sig of ctx.checker.getCallSignatures(t)) {
+        const own = new Set(sig.getTypeParameters());
+        const outer = ctx.resolveTypeParam;
+        const mapped = mapCallSignature(sig, own.size === 0
+            ? ctx
+            : {
+                ...ctx,
+                erasingSignature: sig,
+                resolveTypeParam: (param) => (own.has(param) ? DYN : (outer?.(param) ?? null)),
+            });
+        if (mapped?.kind !== "func" || mapped.rest === true || mapped.argumentsAll === true)
+            return undefined;
+        funcs.push(mapped);
+    }
+    const arity = Math.max(...funcs.map((f) => f.params.length));
+    const params = [];
+    for (let i = 0; i < arity; i++) {
+        const present = funcs.filter((f) => i < f.params.length).map((f) => f.params[i]);
+        let param = joinOverloadTypes(present, ctx);
+        if (param !== null && present.length < funcs.length && param.kind !== "dyn")
+            param = withUndefinedArm(param, ctx.unions);
+        if (param === null)
+            return undefined;
+        params.push(param);
+    }
+    const voids = funcs.filter((f) => f.ret.kind === "void").length;
+    if (voids !== 0 && voids !== funcs.length)
+        return undefined;
+    const ret = voids === funcs.length
+        ? VOID
+        : joinOverloadTypes(funcs.map((f) => f.ret), ctx);
+    if (ret === null)
+        return undefined;
+    return funcOf(params, ret);
+}
+/** Why an overloaded member's set has no erased type
+ * (erasedOverloadMemberType): the first overload, and within it the first
+ * parameter or result, that does not map; otherwise the join itself. A
+ * message tail after "its member 'name'". */
+function describeOverloadSetBlocker(t, ctx) {
+    const { checker } = ctx;
+    for (const sig of checker.getCallSignatures(t)) {
+        const own = new Set(sig.getTypeParameters());
+        const outer = ctx.resolveTypeParam;
+        const sigCtx = own.size === 0
+            ? ctx
+            : {
+                ...ctx,
+                erasingSignature: sig,
+                resolveTypeParam: (param) => (own.has(param) ? DYN : (outer?.(param) ?? null)),
+            };
+        const mapped = mapCallSignature(sig, sigCtx);
+        if (mapped?.kind === "func" && mapped.rest !== true && mapped.argumentsAll !== true)
+            continue;
+        const decl = sig.declaration;
+        const spelled = decl ? ts.getTextOfNode(decl).replace(/\s+/g, " ").replace(/;$/, "") : "";
+        const which = spelled ? `overload '${spelled}'` : "one overload";
+        if (mapped?.kind === "func")
+            return `is an overload set, and its ${which} has a rest parameter (an overload set stores one fixed-arity function)`;
+        for (const param of sig.getParameters()) {
+            const paramTs = checker.getTypeOfSymbol(param);
+            if (!mapType(paramTs, sigCtx))
+                return `is an overload set, and its ${which} has parameter '${ts.symbolName(param)}' of type '${checker.typeToString(paramTs)}', which does not compile`;
+        }
+        const retTs = checker.getReturnTypeOfSignature(sig);
+        return `is an overload set, and its ${which} returns '${checker.typeToString(retTs)}', which does not compile`;
+    }
+    return "is an overload set whose signatures do not join into one stored function (a void result beside a value result, or positions whose differing types do not cross the checked-dynamic boundary)";
+}
 function mapRecordType(widened, ctx) {
     const { shapes } = ctx;
     // A type whose recursive shape already finalized answers its id straight
@@ -4496,10 +6025,9 @@ function mapRecordType(widened, ctx) {
             // checker-type identity — fence recursive generic-open shapes.
             if (contextResolutions !== sensitivityAtEntry)
                 return null;
-            return {
-                kind: "record",
-                shapeId: shapes.finalizeRecursive(widened, inner.fields, inner.indexValue, inner.declaredOrder),
-            };
+            const recursive = shapes.finalizeRecursive(widened, inner.fields, inner.indexValue, inner.declaredOrder);
+            adoptAccessorOrder(shapes.get(recursive), inner.accessorOrder);
+            return { kind: "record", shapeId: recursive };
         }
         // A record with no typed payload contract is a view of an existing
         // object, including across parameters and returns. Building a native
@@ -4510,18 +6038,294 @@ function mapRecordType(widened, ctx) {
             inner.fields.every((field) => field.type.kind === "dyn") &&
             (inner.indexValue === undefined || inner.indexValue.kind === "dyn"))
             return DYN;
+        const covered = coveredOptionalFieldsShape(widened, inner, ctx);
+        if (covered !== null)
+            return { kind: "record", shapeId: covered };
+        const merged = dictSpreadLiteralShape(widened, inner, ctx);
+        if (merged === "dyn")
+            return DYN;
+        if (merged !== null)
+            return { kind: "record", shapeId: merged };
         const refined = refinedConstituentShape(widened, inner, ctx);
         if (refined !== null)
             return { kind: "record", shapeId: refined };
-        return {
-            kind: "record",
-            shapeId: shapes.intern(inner.fields, false, inner.indexValue, inner.declaredOrder),
-        };
+        const shapeId = shapes.intern(inner.fields, false, inner.indexValue, inner.declaredOrder);
+        adoptAccessorOrder(shapes.get(shapeId), inner.accessorOrder);
+        return { kind: "record", shapeId };
     }
     finally {
         shapes.inProgress.delete(widened);
     }
 }
+/** An index signature already describes every OPTIONAL declared member
+ * whose type is its slot type: @types/node's `ProcessEnv extends
+ * Dict<string> { TZ?: string }` and every spread of it, or a declared
+ * environment `{ CI?: string } & Dictionary<string>`. At runtime such a
+ * member is just another key, so the shape interns as the pure
+ * index-signature record. Its slot admits undefined, as the optional
+ * members do (`env.CI = undefined` keeps the key). A hybrid layout would
+ * give each member a struct slot, which enumerates before the overflow
+ * keys (Node keeps one insertion order) and makes `delete` and spread
+ * answer differently for declared and undeclared keys. Required members,
+ * and members typed otherwise than the slot (whose reads the slot type
+ * could not give back), keep the hybrid shape. */
+function coveredOptionalFieldsShape(widened, parts, ctx) {
+    const slot = parts.indexValue;
+    if (!slot || parts.fields.length === 0)
+        return null;
+    const { checker, shapes, unions } = ctx;
+    // The members' common type must be the slot plus undefined. Read it off
+    // the members (already interned) rather than building it: a hybrid that
+    // does not qualify must not intern anything new.
+    const optionalSlot = parts.fields[0].type;
+    if (!parts.fields.every((field) => typeEquals(field.type, optionalSlot)))
+        return null;
+    if (optionalSlot.kind !== "union" || unions.armTag(optionalSlot.unionId, UNDEFINED_T) < 0)
+        return null;
+    const memberArms = unions.get(optionalSlot.unionId)?.arms ?? [];
+    const slotArms = slot.kind === "union" ? (unions.get(slot.unionId)?.arms ?? []) : isUnitType(slot) ? [] : [slot];
+    const definedArms = memberArms.filter((arm) => arm.kind !== "undefinedT");
+    const slotDefined = slotArms.filter((arm) => arm.kind !== "undefinedT");
+    if (definedArms.length === 0 ||
+        definedArms.length !== slotDefined.length ||
+        !slotDefined.every((arm) => definedArms.some((other) => typeEquals(arm, other))))
+        return null;
+    if (!isSupportedIndexValue(optionalSlot))
+        return null;
+    const props = checker.getPropertiesOfType(widened);
+    if (props.length !== parts.fields.length)
+        return null;
+    if (!props.every((p) => (p.flags & ts.SymbolFlags.Optional) !== 0))
+        return null;
+    return shapes.intern([], false, optionalSlot, []);
+}
+/** The type of an object literal that spreads an index-signature record
+ * (`{ ...tags, bucket: b, status }`, the metric-tags idiom). The checker
+ * drops the signature and types the literal by its explicit members only,
+ * but at run time the object holds every key the spread copied, in one
+ * insertion order. Such a literal maps to the pure index-signature record
+ * whose slot joins the spread slots and the member types, so the merge,
+ * every enumeration and keyed writes see the same keys Node does. A
+ * member read still answers its member type: members written after the
+ * spreads always win, and a member written before a spread must have that
+ * spread's slot type, so an override cannot change its type. The join
+ * covers scalar and unit types only; other literals keep their shape and
+ * the spread fence. */
+function dictSpreadLiteralShape(widened, parts, ctx) {
+    if (parts.indexValue)
+        return null;
+    const symbol = widened.getSymbol();
+    if (!symbol || (symbol.flags & ts.SymbolFlags.ObjectLiteral) === 0)
+        return null;
+    const literal = symbol.declarations.find((d) => ts.isObjectLiteralExpression(d));
+    if (!literal)
+        return null;
+    const { checker, shapes, unions } = ctx;
+    const props = literal.properties.nodes;
+    if (!props.some((p) => ts.isSpreadAssignment(p)))
+        return null;
+    // Decide on checker types alone before mapping anything: object literals
+    // with ordinary spreads are everywhere, and mapping their sources here
+    // would intern types out of their usual order.
+    // A literal written into a typed index-signature slot already lowers into
+    // it (the merge into the contextual record); its own type keeps its
+    // mapping.
+    const contextualRaw = checker.getContextualType(literal);
+    const contextual = contextualRaw ? checker.getNonNullableType(contextualRaw) : undefined;
+    // A literal written into a declared slot lowers into that slot (a typed
+    // index-signature record merges into it, a declared record converts),
+    // and its own type keeps its mapping. Only a literal with no declared
+    // destination (an unannotated binding, a type parameter, `any` or
+    // `unknown`, an unknown-valued record) is built by its own type.
+    // A generic argument's context is the instantiated parameter: the
+    // literal's own type when the type argument was inferred from it.
+    const ownContext = contextual !== undefined &&
+        (contextual === widened || contextual.getSymbol()?.declarations.includes(literal) === true);
+    if (contextual &&
+        !ownContext &&
+        !(contextual.flags & (ts.TypeFlags.TypeParameter | ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
+        const infos = checker.getIndexInfosOfType(contextual);
+        const unknownValued = infos.length > 0 &&
+            infos.every((info) => (info.type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
+        if (!unknownValued)
+            return null;
+    }
+    const kinds = props.map((p) => ts.isSpreadAssignment(p) ? spreadSourceKindTs(checker, p.expression) : "member");
+    if (kinds.some((k) => k === null) || !kinds.includes("dict"))
+        return null;
+    const dictSlotOf = (e) => {
+        const t = checker.getNonNullableType(checker.getTypeAtLocation(e));
+        if (checker.getPropertiesOfType(t).length === 0) {
+            const infos = checker.getIndexInfosOfType(t);
+            if (infos.length !== 1 || !(infos[0].keyType.flags & ts.TypeFlags.String))
+                return null;
+            return mapType(infos[0].type, ctx);
+        }
+        // Another such literal's type (`{ ...tags, repo }` over a binding
+        // initialized by `{ ...base, plan }`) is stored as the same kind of
+        // pure index-signature record.
+        if (t === widened)
+            return null;
+        const mapped = mapType(t, ctx);
+        if (mapped?.kind === "dyn")
+            return DYN;
+        const shape = mapped?.kind === "record" ? shapes.get(mapped.shapeId) : undefined;
+        return shape?.indexValue && shape.fields.length === 0 && !shape.tuple ? shape.indexValue : null;
+    };
+    const arms = new Map();
+    const addArms = (t) => {
+        const list = t.kind === "union" ? (unions.get(t.unionId)?.arms ?? []) : [t];
+        for (const arm of list) {
+            if (!OVERLOAD_JOIN_SCALARS.has(arm.kind))
+                return false;
+            arms.set(typeKey(arm), arm);
+        }
+        return true;
+    };
+    const before = [];
+    // An unknown-valued spread (`Record<string, unknown>`, or another such
+    // literal) makes the object the checked-dynamic value: it is built like
+    // a JavaScript object literal (copy each spread's own keys in order), and
+    // member reads check their declared types.
+    let unknownValued = false;
+    for (const [i, p] of props.entries()) {
+        // A fixed-shape or conditional spread contributes its own members,
+        // which the checker already types exactly (they are in `parts`).
+        if (kinds[i] === "record") {
+            // Its members may be overwritten by a later dict spread, like members
+            // written before one.
+            before.push(...spreadMemberNamesTs(checker, p.expression));
+            continue;
+        }
+        if (ts.isSpreadAssignment(p)) {
+            const slot = dictSlotOf(p.expression);
+            if (slot?.kind === "dyn") {
+                unknownValued = true;
+                continue;
+            }
+            if (!slot)
+                return null;
+            if (!addArms(slot)) {
+                // A slot outside the scalar join still has the checked-dynamic
+                // representation when it converts to it.
+                if (!canConvertToDyn(slot, (id) => shapes.get(id), (id) => unions.get(id)))
+                    return null;
+                unknownValued = true;
+            }
+            // A member written before this spread may be overwritten by it: the
+            // typed join keeps member types only where the slot is that type;
+            // otherwise the checked-dynamic object (whose member reads check
+            // their types) holds whatever the spread wrote.
+            for (const name of before) {
+                const field = parts.fields.find((f) => f.name === name);
+                if (!field)
+                    return null;
+                if (!typeEquals(field.type, slot))
+                    unknownValued = true;
+            }
+            continue;
+        }
+        if (!(ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)))
+            return null;
+        const name = p.name;
+        if (!(ts.isIdentifier(name) || ts.isStringLiteral(name)))
+            return null;
+        before.push(name.text);
+    }
+    if (parts.fields.some((f) => f.name.startsWith("%")))
+        return null;
+    // Members outside the scalar join (an array of labels beside the tags)
+    // make the object the checked-dynamic value too.
+    if (!unknownValued && !parts.fields.every((f) => addArms(f.type)))
+        unknownValued = true;
+    if (unknownValued) {
+        const getRecord = (id) => shapes.get(id);
+        const getUnion = (id) => unions.get(id);
+        return parts.fields.every((f) => f.type.kind === "dyn" || canConvertToDyn(f.type, getRecord, getUnion))
+            ? "dyn"
+            : null;
+    }
+    for (const field of parts.fields)
+        if (!addArms(field.type))
+            return null;
+    if (![...arms.values()].some((arm) => !isUnitType(arm)))
+        return null;
+    const sorted = [...arms.values()].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    const slot = sorted.length === 1 ? sorted[0] : { kind: "union", unionId: unions.intern(sorted) };
+    return shapes.intern([], false, slot, []);
+}
+/** How a spread source contributes to dictSpreadLiteralShape, judged on
+ * checker types only: "dict" for a pure string index signature or another
+ * literal that spreads one, "record" for a fixed object shape or a
+ * conditional spread (`...(c && { k: v })`), null otherwise. */
+function spreadSourceKindTs(checker, e) {
+    if (dictSpreadSourceTs(checker, e, 0))
+        return "dict";
+    let inner = e;
+    while (ts.isParenthesizedExpression(inner))
+        inner = inner.expression;
+    if ((ts.isBinaryExpression(inner) &&
+        inner.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) ||
+        ts.isConditionalExpression(inner))
+        return "record";
+    const t = checker.getNonNullableType(checker.getTypeAtLocation(e));
+    if ((t.flags & ts.TypeFlags.Object) === 0 || t.isUnionType())
+        return null;
+    if (checker.getIndexInfosOfType(t).length > 0)
+        return null;
+    if (checker.getCallSignatures(t).length > 0 || checker.getConstructSignatures(t).length > 0)
+        return null;
+    const symbol = t.getSymbol();
+    if (symbol && (symbol.flags & ts.SymbolFlags.Class) !== 0)
+        return null;
+    return "record";
+}
+/** The member names a fixed-shape or conditional spread contributes. */
+function spreadMemberNamesTs(checker, e) {
+    let inner = e;
+    while (ts.isParenthesizedExpression(inner))
+        inner = inner.expression;
+    const literals = [];
+    if (ts.isBinaryExpression(inner))
+        literals.push(inner.right);
+    else if (ts.isConditionalExpression(inner))
+        literals.push(inner.whenTrue, inner.whenFalse);
+    else
+        literals.push(inner);
+    const names = [];
+    for (const l of literals) {
+        const t = checker.getNonNullableType(checker.getTypeAtLocation(l));
+        for (const property of checker.getPropertiesOfType(t))
+            names.push(ts.symbolName(property));
+    }
+    return names;
+}
+/** A spread source the checker types as a pure string index signature,
+ * or as another object literal that spreads one (dictSpreadLiteralShape),
+ * judged on checker types only. */
+function dictSpreadSourceTs(checker, e, depth) {
+    const t = checker.getNonNullableType(checker.getTypeAtLocation(e));
+    if (checker.getPropertiesOfType(t).length === 0) {
+        const infos = checker.getIndexInfosOfType(t);
+        return infos.length === 1 && (infos[0].keyType.flags & ts.TypeFlags.String) !== 0;
+    }
+    if (depth > 4)
+        return false;
+    const symbol = t.getSymbol();
+    if (!symbol || (symbol.flags & ts.SymbolFlags.ObjectLiteral) === 0)
+        return false;
+    const literal = symbol.declarations.find((d) => ts.isObjectLiteralExpression(d));
+    if (!literal)
+        return false;
+    const spreads = literal.properties.nodes.filter((p) => ts.isSpreadAssignment(p));
+    return (spreads.length > 0 &&
+        spreads.every((p) => dictSpreadSourceTs(checker, p.expression, depth + 1)));
+}
+/** The first-seen accessor key order of a shape with accessor slots. */
+function adoptAccessorOrder(shape, order) {
+    if (shape !== undefined && order !== undefined && shape.accessorOrder === undefined)
+        shape.accessorOrder = order;
+}
 /** A refinement intersection (`Expr & { kind: "mul" }`, which the checker
  * reduces to `Mul & { kind: "mul" }`) keeps the shape of the constituent it
  * refines when the refinement changes no field's representation. Recursive
@@ -4535,12 +6339,12 @@ function refinedConstituentShape(widened, parts, ctx) {
     if (!widened.isIntersectionType())
         return null;
     const { checker, shapes } = ctx;
-    const names = checker.getPropertiesOfType(widened).map((prop) => prop.name);
+    const names = checker.getPropertiesOfType(widened).map((prop) => ts.symbolName(prop));
     let found = null;
     for (const part of ts.constituentTypes(widened)) {
         if ((part.flags & ts.TypeFlags.Object) === 0 || shapes.inProgress.has(part))
             continue;
-        const own = new Set(checker.getPropertiesOfType(part).map((prop) => prop.name));
+        const own = new Set(checker.getPropertiesOfType(part).map((prop) => ts.symbolName(prop)));
         if (own.size !== names.length || !names.every((name) => own.has(name)))
             continue;
         const mapped = mapType(part, ctx);
@@ -4560,6 +6364,29 @@ function refinedConstituentShape(widened, parts, ctx) {
     }
     return found;
 }
+/** The optional `undefined` members widening adds to an object literal's
+ * type for properties only its sibling literals declare (`[{ a: 1 }, { b: 2
+ * }]` gives the first `b?: undefined`). They are never own keys of the
+ * literal's value, so they go after the declared members, by name. Where
+ * the checker lists them is not observable: TypeScript 7.0.2 orders them
+ * by the literal its checker widened first, TypeScript 7.1 by the sibling
+ * that declares them. */
+function wideningAddedProperties(type, props, ctx) {
+    const added = new Set();
+    const literal = type.getSymbol()?.declarations.find(ts.isObjectLiteralExpression);
+    if (literal === undefined || literal.properties.nodes.some(ts.isSpreadAssignment))
+        return added;
+    for (const prop of props) {
+        if ((prop.flags & ts.SymbolFlags.Optional) === 0 || prop.declarations.length === 0)
+            continue;
+        if (prop.declarations.some((d) => d.parent === literal))
+            continue;
+        if ((ctx.checker.getTypeOfSymbol(prop).flags & ts.TypeFlags.Undefined) === 0)
+            continue;
+        added.add(ts.symbolName(prop));
+    }
+    return added;
+}
 function mapRecordTypeInner(widened, ctx) {
     const { checker, shapes } = ctx;
     if (checker.getConstructSignatures(widened).length > 0)
@@ -4612,7 +6439,7 @@ function mapRecordTypeInner(widened, ctx) {
         for (const info of indexInfos) {
             if (!stringKey(info.keyType) && !(info.keyType.flags & ts.TypeFlags.Number))
                 return null;
-            const iv = mapType(info.valueType, ctx);
+            const iv = mapType(info.type, ctx);
             // JSONValue>` (a package's own JSON alias) and `Record<string, any>`
             if (!iv || !isSupportedIndexValue(iv))
                 return null;
@@ -4688,7 +6515,7 @@ function mapRecordTypeInner(widened, ctx) {
     // stance), records of other shapes at theirs — the declaration itself is
     // representable.
     const anonSym = widened.getSymbol();
-    const anonymousEmpty = (anonSym === undefined || checker.declarationsOf(anonSym).length === 0) &&
+    const anonymousEmpty = (anonSym === undefined || anonSym.declarations.length === 0) &&
         !widened.isIntersectionType() &&
         indexValue === undefined &&
         checker.getPropertiesOfType(widened).length === 0;
@@ -4703,7 +6530,7 @@ function mapRecordTypeInner(widened, ctx) {
             return DYN;
         // Symbol-keyed records use the checked object's descriptor table. A
         // checker-internal __@ name is not a string field in a native struct.
-        if (props.some((property) => property.name.startsWith("__@")))
+        if (props.some((property) => ts.symbolName(property).startsWith("__@")))
             return DYN;
         // A computed shape with NO members is not a real empty record: inside a
         // generic body `Partial<T>` resolves to no members at all (keyof T is
@@ -4730,8 +6557,7 @@ function mapRecordTypeInner(widened, ctx) {
             indexValue === undefined &&
             checker.getCallSignatures(widened).length === 0 &&
             checker.getConstructSignatures(widened).length === 0 &&
-            !(anonSym !== undefined &&
-                checker.declarationsOf(anonSym).some((d) => ts.isObjectLiteralExpression(d)))) {
+            !(anonSym !== undefined && anonSym.declarations.some((d) => ts.isObjectLiteralExpression(d)))) {
             return DYN;
         }
         const fields = [];
@@ -4752,7 +6578,7 @@ function mapRecordTypeInner(widened, ctx) {
                 // their existing paths (the CJS export-table narrowing and the
                 // checked-dynamic fallback), and .d.ts declarations stay out with
                 // the rest of the lib's type worlds.
-                const decls = checker.declarationsOf(p);
+                const decls = p.declarations;
                 const getDecl = decls.find((d) => ts.isGetAccessorDeclaration(d));
                 const setDecl = decls.find((d) => ts.isSetAccessorDeclaration(d));
                 const accessorOwned = decls.length > 0 &&
@@ -4761,13 +6587,13 @@ function mapRecordTypeInner(widened, ctx) {
                         (ts.isObjectLiteralExpression(d.parent) ||
                             ts.isInterfaceDeclaration(d.parent) ||
                             d.parent.kind === ts.SyntaxKind.TypeLiteral) &&
-                        !d.getSourceFile().isDeclarationFile &&
-                        !isJsSourceFile(d.getSourceFile()));
+                        !ts.getSourceFileOfNode(d).isDeclarationFile &&
+                        !isJsSourceFile(ts.getSourceFileOfNode(d)));
                 if (!accessorOwned || (!getDecl && !setDecl))
                     return null;
                 // Symbol-keyed accessors have no foldable literal name to fill at
                 // the literal — no slot to make.
-                if (p.name.startsWith("__@"))
+                if (ts.symbolName(p).startsWith("__@"))
                     return null;
                 // An index-signature shape stores accessor NAMES nowhere the keyed
                 // read/walk machinery can answer (the overflow would miss where
@@ -4782,7 +6608,7 @@ function mapRecordTypeInner(widened, ctx) {
                 }
                 let writeT = null;
                 if (setDecl) {
-                    const param = setDecl.parameters[0];
+                    const param = setDecl.parameters.nodes[0];
                     if (!param)
                         return null;
                     writeT = mapType(checker.getTypeAtLocation(param), ctx);
@@ -4795,9 +6621,9 @@ function mapRecordTypeInner(widened, ctx) {
                         return null;
                 }
                 if (readT !== null || getDecl)
-                    fields.push({ name: `%get:${p.name}`, type: funcOf([], readT ?? VOID) });
+                    fields.push({ name: `%get:${ts.symbolName(p)}`, type: funcOf([], readT ?? VOID) });
                 if (writeT !== null)
-                    fields.push({ name: `%set:${p.name}`, type: funcOf([writeT], VOID) });
+                    fields.push({ name: `%set:${ts.symbolName(p)}`, type: funcOf([writeT], VOID) });
                 continue;
             }
             // Computed shapes carry provenance per MEMBER: a utility type over a
@@ -4805,9 +6631,9 @@ function mapRecordTypeInner(widened, ctx) {
             // a data shape. Synthesized members (a literal-key Record's) have no
             // declarations and pass.
             if (computed &&
-                checker.declarationsOf(p).some((d) => {
-                    const sf = d.getSourceFile();
-                    return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
+                p.declarations.some((d) => {
+                    const sf = ts.getSourceFileOfNode(d);
+                    return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf) && !packageTypeFile(sf, ctx);
                 })) {
                 return null;
             }
@@ -4816,9 +6642,16 @@ function mapRecordTypeInner(widened, ctx) {
             // can hold them — see isGenericCallableMemberType): the shape keeps
             // its data fields, and calls of the member monomorphize per call
             // site against the defining object literal's declaration.
-            if (isGenericCallableMemberType(fieldTs, checker))
+            // OVERLOADED members hold their erased runtime function (see
+            // erasedOverloadMemberType); a set that does not join fails the
+            // shape as before.
+            let pt = isGenericCallableMemberType(fieldTs, checker)
+                ? erasedGenericMemberType(fieldTs, ctx)
+                : isOverloadedCallableMemberType(fieldTs, checker)
+                    ? (erasedOverloadMemberType(fieldTs, ctx) ?? null)
+                    : mapType(fieldTs, ctx);
+            if (pt === undefined)
                 continue;
-            let pt = mapType(fieldTs, ctx);
             // tsgo PANICS computing `readonly []` through the symbol-type query
             // (the TupleType conversion — the facade's panic fence answers
             // `any`), which would absorb the whole shape into the dynamic tier.
@@ -4828,7 +6661,7 @@ function mapRecordTypeInner(widened, ctx) {
             // unit-element array; see the `[] as const` rule there).
             if (pt === null &&
                 (fieldTs.flags & ts.TypeFlags.Any) !== 0 &&
-                constAssertedEmptyArrayProp(p, ctx)) {
+                constAssertedEmptyArrayProp(p)) {
                 pt = arrayOf(unitOnlyUnion(ctx.unions));
             }
             if (pt === null && (fieldTs.flags & ts.TypeFlags.Any) !== 0)
@@ -4849,10 +6682,10 @@ function mapRecordTypeInner(widened, ctx) {
             // A DATA property spelled like a reserved accessor slot (`{ "%get:x":
             // v }` — a string-literal key): mapping it would collide with the
             // accessor dispatch, so the shape stays unmapped.
-            if (accessorSlotProp(p.name) !== null)
+            if (accessorSlotProp(ts.symbolName(p)) !== null)
                 return null;
             // an options record with `signal?: AbortSignal` must not turn its
-            fields.push({ name: p.name, type: pt });
+            fields.push({ name: ts.symbolName(p), type: pt });
         }
         // getPropertiesOfType yields DECLARATION order (interface/alias/literal
         // source order) — captured before the canonical sort so Object.keys/
@@ -4863,9 +6696,23 @@ function mapRecordTypeInner(widened, ctx) {
         // indices, from folded numeric computed keys and quoted numeric keys)
         // enumerate FIRST ascending, then string keys in insertion order
         // (OrdinaryOwnPropertyKeys) — Object.keys/JSON/inspect all read it.
-        const declaredOrder = esOwnKeyOrder(fields.filter((f) => accessorSlotProp(f.name) === null).map((f) => f.name));
+        const widenedAbsent = wideningAddedProperties(widened, props, ctx);
+        const declaredOrder = esOwnKeyOrder(fields
+            .filter((f) => accessorSlotProp(f.name) === null && !widenedAbsent.has(f.name))
+            .map((f) => f.name)
+            .concat([...widenedAbsent].sort()));
+        // With accessors: every own key in that order, an accessor property
+        // named once for its get/set pair (the checked-dynamic copy lists it).
+        const accessorOrder = fields.some((f) => accessorSlotProp(f.name) !== null)
+            ? esOwnKeyOrder([...new Set(fields.map((f) => accessorSlotProp(f.name)?.prop ?? f.name))])
+            : undefined;
         fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-        return { fields, ...(indexValue ? { indexValue } : {}), declaredOrder };
+        return {
+            fields,
+            ...(indexValue ? { indexValue } : {}),
+            declaredOrder,
+            ...(accessorOrder ? { accessorOrder } : {}),
+        };
     }
 }
 /* ── Component-fence classification (SC2009) ───────────────────────────────
@@ -4915,9 +6762,63 @@ function dynSubsumableUnionArm(arm, ctx) {
             return false;
     }
 }
+/** A parameter of a function type that is the default of a type parameter
+ * declared in node:test's standard-library declarations (MockTracker.fn's
+ * `F extends Function = (...args: any[]) => undefined`). */
+function isNodeTestDefaultFunctionParam(decl, ctx) {
+    const fnType = decl.parent;
+    return (ts.isParameter(decl) &&
+        fnType !== undefined &&
+        ts.isFunctionTypeNode(fnType) &&
+        fnType.parent !== undefined &&
+        ts.isTypeParameterDeclaration(fnType.parent) &&
+        fnType.parent.defaultType === fnType &&
+        ctx.isStdlibFile(ts.getSourceFileOfNode(decl)) &&
+        isDeclaredInAmbientModule(decl, "test"));
+}
+/** `any[]` (or `readonly any[]`): an array type whose element is `any`. */
+export function isAnyArrayType(t, checker) {
+    if (!checker.isArrayType(t))
+        return false;
+    const elem = checker.getTypeArguments(t)[0];
+    return elem !== undefined && (elem.flags & ts.TypeFlags.Any) !== 0;
+}
+/** The maybe-promise union rule (mapTypeInner's union rule; IR
+ * maybePromiseUnionArmsOk): at most one promise arm, and when it has data
+ * siblings none of them may be thenable — `await` and async `return`
+ * dispatch on the union tag, so a data arm whose type declares `then`
+ * would skip the thenable adoption JS performs. */
+function maybePromiseUnionOk(parts, arms, ctx) {
+    if (unionContainerArmsOk(arms))
+        return true;
+    if (!maybePromiseUnionArmsOk(arms))
+        return false;
+    // A function beside a promise (`Promise<T> | (() => Promise<T>)`, the
+    // assert.rejects argument) keeps its existing representation: callers
+    // dispatch on callability, not on a then-able promise.
+    if (arms.some((arm) => arm.kind === "func"))
+        return false;
+    return maybePromiseThenableArm(parts, ctx) === null;
+}
+/** The first non-promise constituent of a promise-armed union whose type
+ * has a `then` member (a thenable data arm), or null. */
+function maybePromiseThenableArm(parts, ctx) {
+    const { checker } = ctx;
+    for (const part of parts) {
+        if (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Null))
+            continue;
+        if (mapType(part, ctx)?.kind === "promise")
+            continue;
+        // Primitive arms answer through their wrapper prototypes, none of
+        // which has `then`; object arms answer through their own members.
+        if (checker.getPropertyOfType(part, "then"))
+            return part;
+    }
+    return null;
+}
 /** Arm kinds with no home in a compiled union (mapTypeInner's union rule):
  * no runtime narrowing test exists against sibling data arms. */
-function armHasUnionHome(arm, siblingCount) {
+function armHasUnionHome(arm) {
     switch (arm.kind) {
         case "void":
         case "union":
@@ -4926,9 +6827,6 @@ function armHasUnionHome(arm, siblingCount) {
         case "generator":
         case "dyn":
             return false;
-        // Promise data siblings still lack a supported narrowing contract.
-        case "promise":
-            return siblingCount === 0;
         default:
             return true;
     }
@@ -4946,11 +6844,9 @@ export function describeComponentBlocker(widened, ctx) {
     // `interface Map` is a record shape and keeps the record stories).
     const psym = widened.getSymbol();
     const container = psym !== undefined &&
-        Object.prototype.hasOwnProperty.call(STDLIB_CONTAINERS, psym.name) &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))
-        ? psym.name
+        Object.prototype.hasOwnProperty.call(STDLIB_CONTAINERS, ts.symbolName(psym)) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))
+        ? ts.symbolName(psym)
         : undefined;
     if (container !== undefined) {
         const spec = STDLIB_CONTAINERS[container];
@@ -5035,10 +6931,24 @@ export function describeComponentBlocker(widened, ctx) {
             if (!mapped) {
                 return `the union shape is supported, but its arm '${text(part)}' does not compile`;
             }
-            if (!armHasUnionHome(mapped, dataArms.length - 1)) {
+            if (!armHasUnionHome(mapped)) {
                 return `the union shape is supported, but '${text(part)}' arms have no home in a compiled union yet (no runtime narrowing test exists against sibling arms)`;
             }
         }
+        const promiseArms = mappedArms.filter(({ mapped }) => mapped?.kind === "promise");
+        if (promiseArms.length > 1) {
+            return `the union shape is supported, but it has several promise arms ('${text(promiseArms[0].p)}' and '${text(promiseArms[1].p)}'), and a compiled union holds at most one (the union tag is the 'instanceof Promise' test)`;
+        }
+        if (promiseArms.length === 1 && dataArms.length > 1) {
+            const callable = mappedArms.find(({ mapped }) => mapped?.kind === "func");
+            if (callable) {
+                return `the union shape is supported, but its function arm '${text(callable.p)}' sits beside a promise arm, and a maybe-promise union holds only data arms beside its promise`;
+            }
+            const thenable = maybePromiseThenableArm(parts, ctx);
+            if (thenable) {
+                return `the union shape is supported, but its arm '${text(thenable)}' declares 'then' beside a promise arm, so 'await' would have to adopt it as a thenable (a maybe-promise union's data arms must not be thenable)`;
+            }
+        }
         return null;
     }
     // Single-signature, non-generic function types: a parameter type or the
@@ -5051,17 +6961,17 @@ export function describeComponentBlocker(widened, ctx) {
         const sig = callSigs[0];
         if (sig.getTypeParameters().length > 0)
             return null;
-        const sigDecl = checker.signatureDeclaration(sig);
+        const sigDecl = sig.declaration;
         if (sigDecl !== undefined &&
             ts.isFunctionLike(sigDecl) &&
-            (runtimeParameterCount(sigDecl.parameters) !== sig.getParameters().length ||
+            (runtimeParameterCount(sigDecl.parameters.nodes) !== sig.getParameters().length ||
                 bodyReadsArguments(sigDecl))) {
             return `the function shape is supported, but its signature is variadic ('arguments'-reading), and a compiled signature is fixed-arity`;
         }
         for (const p of sig.getParameters()) {
             const pTs = checker.getTypeOfSymbol(p);
             if (!mapType(pTs, ctx)) {
-                return `the function shape is supported, but its parameter '${p.name}' has type '${text(pTs)}', which does not compile`;
+                return `the function shape is supported, but its parameter '${ts.symbolName(p)}' has type '${text(pTs)}', which does not compile`;
             }
         }
         const retTs = checker.getReturnTypeOfSignature(sig);
@@ -5098,26 +7008,33 @@ export function describeRecordMemberBlocker(widened, ctx) {
         // rules (mapRecordTypeInner) — no single-member claim is honest there.
         if ((p.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) !== 0)
             continue;
-        if (p.name.startsWith("__@"))
+        if (ts.symbolName(p).startsWith("__@"))
             continue;
         // Computed shapes over LIBRARY members (`Readonly<Date>`): the record
         // fence there is per-member PROVENANCE (mapRecordTypeInner's rule), not
         // any one member's type — that story stays with the residual fence.
         if (computed &&
-            checker.declarationsOf(p).some((d) => {
-                const sf = d.getSourceFile();
-                return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
+            p.declarations.some((d) => {
+                const sf = ts.getSourceFileOfNode(d);
+                return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf) && !packageTypeFile(sf, ctx);
             })) {
             return null;
         }
         const fieldTs = checker.getTypeOfSymbol(p);
-        if (isGenericCallableMemberType(fieldTs, checker))
+        if (isOverloadedCallableMemberType(fieldTs, checker)) {
+            if (erasedOverloadMemberType(fieldTs, ctx) !== undefined)
+                continue;
+            return `the record shape is supported, but its member '${ts.symbolName(p)}' ${describeOverloadSetBlocker(fieldTs, ctx)}`;
+        }
+        let pt = isGenericCallableMemberType(fieldTs, checker)
+            ? erasedGenericMemberType(fieldTs, ctx)
+            : mapType(fieldTs, ctx);
+        if (pt === undefined)
             continue;
-        let pt = mapType(fieldTs, ctx);
         if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs, ctx.resolveTypeParam))
             pt = unitOnlyUnion(ctx.unions);
         if (!pt || pt.kind === "void") {
-            return `the record shape is supported, but its member '${p.name}' has type '${checker.typeToString(fieldTs)}', which does not compile`;
+            return `the record shape is supported, but its member '${ts.symbolName(p)}' has type '${checker.typeToString(fieldTs)}', which does not compile`;
         }
     }
     return null;