@scriptc/compiler 0.2.4 → 0.2.6

package/dist/frontend/type-mapper.js

@@ -1,7 +1,7 @@
 import { InternalCompilerError } from "../errors.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, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, unionContainerArmsOk, UNDEFINED_T, VOID } from "../ir/ir.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, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, 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";
@@ -19,18 +19,28 @@ export function jsOpenObjectType(decl, type, shapes, unions) {
         return type;
     const arms = type.kind === "union" ? unions.get(type.unionId)?.arms : [type];
     const present = arms?.filter((arm) => arm.kind !== "undefinedT");
-    const parameter = ts.isParameter(decl) ? decl : decl.parent && ts.isParameter(decl.parent) ? decl.parent : null;
+    const parameter = ts.isParameter(decl)
+        ? decl
+        : decl.parent && ts.isParameter(decl.parent)
+            ? decl.parent
+            : null;
     // Array parameters in JavaScript also accept typed arrays. Keep
     // their runtime storage at the boundary, including default [] parameters.
-    if (parameter && !parameter.dotDotDotToken && present?.length === 1 &&
+    if (parameter &&
+        !parameter.dotDotDotToken &&
+        present?.length === 1 &&
         present[0].kind === "array")
         return DYN;
-    if (parameter && !parameter.dotDotDotToken && present?.length === 1 && present[0].kind === "bytes")
+    if (parameter &&
+        !parameter.dotDotDotToken &&
+        present?.length === 1 &&
+        present[0].kind === "bytes")
         return DYN;
     // An unannotated JavaScript parameter's object default is a fallback,
     // not a closed class contract. Published code routinely passes another
     // implementation of the same protocol through a boxed callable.
-    if (parameter?.initializer && !parameter.type &&
+    if (parameter?.initializer &&
+        !parameter.type &&
         present?.some((arm) => arm.kind === "object") &&
         arms?.every((arm) => canConvertToDyn(arm, (id) => shapes.get(id), (id) => unions.get(id))))
         return DYN;
@@ -41,10 +51,15 @@ export function jsOpenObjectType(decl, type, shapes, unions) {
     // A typed index slot cannot represent either of those reads faithfully.
     if (shape?.indexValue && !shape.tuple)
         return DYN;
-    const unitOnly = (field) => isUnitType(field) || field.kind === "void" ||
-        field.kind === "union" && unions.get(field.unionId)?.arms.every(isUnitType) === true;
-    return shape && !shape.tuple && !shape.indexValue &&
-        (shape.fields.length === 0 || shape.fields.some((field) => unitOnly(field.type))) ? DYN : type;
+    const unitOnly = (field) => isUnitType(field) ||
+        field.kind === "void" ||
+        (field.kind === "union" && unions.get(field.unionId)?.arms.every(isUnitType) === true);
+    return shape &&
+        !shape.tuple &&
+        !shape.indexValue &&
+        (shape.fields.length === 0 || shape.fields.some((field) => unitOnly(field.type)))
+        ? DYN
+        : type;
 }
 /** The ambient TYPE names of the fetch slice. Under --dynamic their
  * values live in the embedded engine and map to island handles (jsval).
@@ -75,9 +90,12 @@ function isAmbientAbortHandleType(type, ctx) {
     if (type.isUnionType())
         return ts.constituentTypes(type).some((part) => isAmbientAbortHandleType(part, ctx));
     const symbol = type.getSymbol();
-    return !!symbol &&
+    return (!!symbol &&
         (symbol.name === "AbortSignal" || symbol.name === "AbortController") &&
-        ctx.checker.declarationsOf(symbol).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) && ctx.isStdlibFile(d.getSourceFile()));
+        ctx.checker
+            .declarationsOf(symbol)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile())));
 }
 /** node:util.parseArgs's public and @types/node helper type names. Values
  * behind this surface use the checked-dynamic tree; see mapTypeInner. */
@@ -195,7 +213,8 @@ export class ShapeRegistry {
         else
             this.declaredOrderCandidates.set(shape.id, [candidate]);
         const previous = this.declaredOrderPriority.get(shape.id);
-        if (previous !== undefined && comparePriority(previous, this.currentDeclaredOrderPriority) <= 0) {
+        if (previous !== undefined &&
+            comparePriority(previous, this.currentDeclaredOrderPriority) <= 0) {
             return;
         }
         shape.declaredOrder = declaredOrder;
@@ -798,12 +817,16 @@ function genChannels(yieldTs, retTs, nextTs, ctx) {
         return null;
     const retT = retTs === undefined || retTs.flags & UNITISH
         ? VOID
-        : retTs.flags & ANYISH ? DYN : mapType(retTs, ctx);
+        : retTs.flags & ANYISH
+            ? DYN
+            : mapType(retTs, ctx);
     if (!retT || (retT.kind !== "void" && isUnitType(retT)))
         return null;
     const nextT = nextTs === undefined || nextTs.flags & UNITISH
         ? UNDEFINED_T
-        : nextTs.flags & ANYISH ? DYN : mapType(nextTs, ctx);
+        : nextTs.flags & ANYISH
+            ? DYN
+            : mapType(nextTs, ctx);
     if (!nextT || nextT.kind === "void" || nextT.kind === "nullT")
         return null;
     const dynMix = (yieldT.kind === "dyn" && retT.kind !== "dyn" && retT.kind !== "void") ||
@@ -835,6 +858,18 @@ let contextResolutions = 0;
 export function mapType(type, ctx) {
     if (mapTypeDepth >= MAP_TYPE_MAX_DEPTH)
         return null;
+    // These intrinsic domains cannot depend on generic bindings, declaration
+    // provenance, or recursive shape state. Enum literals retain the ordinary
+    // widening path, including mixed numeric/string enum representations.
+    const flags = type.flags;
+    if ((flags & ts.TypeFlags.EnumLike) === 0) {
+        if (flags & (ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral))
+            return F64;
+        if (flags & (ts.TypeFlags.String | ts.TypeFlags.StringLiteral | ts.TypeFlags.TemplateLiteral))
+            return STRING;
+        if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
+            return BOOL;
+    }
     const topLevel = mapTypeDepth === 0;
     const typeId = type.id;
     const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true);
@@ -875,7 +910,9 @@ function mapTypeInner(type, 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 (!ctx.dynamic && intrinsic?.name === "globalThis" && checker.declarationsOf(intrinsic).length === 0)
+    if (!ctx.dynamic &&
+        intrinsic?.name === "globalThis" &&
+        checker.declarationsOf(intrinsic).length === 0)
         return DYN;
     if (!ctx.dynamic) {
         const moduleId = ctx.moduleNamespaceId?.(type) ?? null;
@@ -971,14 +1008,16 @@ function mapTypeInner(type, ctx) {
             }
             return false;
         };
-        if (parseArgsSym && PARSE_ARGS_DYN_TYPES.has(parseArgsSym.name) &&
+        if (parseArgsSym &&
+            PARSE_ARGS_DYN_TYPES.has(parseArgsSym.name) &&
             checker.declarationsOf(parseArgsSym).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) => checker.declarationsOf(member).some(belongs)))
             return DYN;
     }
     // The lib's BOXED wrapper interfaces used as TYPES (`const n: Number =
@@ -1012,7 +1051,11 @@ function mapTypeInner(type, ctx) {
                 ctorSym.name === "NumberConstructor" ||
                 ctorSym.name === "BooleanConstructor") &&
             checker.declarationsOf(ctorSym).some((d) => ctx.isStdlibFile(d.getSourceFile()))) {
-            return funcOf([STRING], ctorSym.name === "StringConstructor" ? STRING : ctorSym.name === "NumberConstructor" ? F64 : BOOL);
+            return funcOf([STRING], ctorSym.name === "StringConstructor"
+                ? STRING
+                : ctorSym.name === "NumberConstructor"
+                    ? F64
+                    : BOOL);
         }
     }
     // `symbol` and `unique symbol` (the type of `const k = Symbol(...)` —
@@ -1034,17 +1077,19 @@ function mapTypeInner(type, ctx) {
     // Generic visitors can instantiate `T | undefined` as `void | undefined`.
     // It has the same return convention as standalone void; value positions
     // still substitute the unit-only slot through isUnitOnlyTsType below.
-    if (widened.isUnionType() && ts.constituentTypes(widened).every((part) => {
-        if ((part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) !== 0)
-            return true;
-        // A forwarding generic call keeps its caller's symbolic T in the
-        // resolved signature. Its current instantiation can still be void.
-        if ((part.flags & ts.TypeFlags.TypeParameter) !== 0 && resolveTypeParam?.(part)?.kind === "void") {
-            contextResolutions++;
-            return true;
-        }
-        return false;
-    }))
+    if (widened.isUnionType() &&
+        ts.constituentTypes(widened).every((part) => {
+            if ((part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) !== 0)
+                return true;
+            // A forwarding generic call keeps its caller's symbolic T in the
+            // resolved signature. Its current instantiation can still be void.
+            if ((part.flags & ts.TypeFlags.TypeParameter) !== 0 &&
+                resolveTypeParam?.(part)?.kind === "void") {
+                contextResolutions++;
+                return true;
+            }
+            return false;
+        }))
         return VOID;
     // Standalone `null` (a `const x = null` binding, a `{ value: null }`
     // field, a `(): null` return): the unit-only union — the value is always
@@ -1295,7 +1340,13 @@ function mapTypeInner(type, ctx) {
     // no class identity of its own.
     if (widened.isIntersectionType()) {
         const HANDLE_KINDS = new Set([
-            "netServer", "netSocket", "httpReq", "httpRes", "httpClientReq", "dgramSocket", "childWriter",
+            "netServer",
+            "netSocket",
+            "httpReq",
+            "httpRes",
+            "httpClientReq",
+            "dgramSocket",
+            "childWriter",
             // process.stdout's own type IS the refined intersection
             // `WriteStream & { fd: 1 }` — the scalar stream kind rides the same
             // refinement rule.
@@ -1376,7 +1427,8 @@ function mapTypeInner(type, ctx) {
         // INSTANTIATION's class (`Box%0`), registered on demand — the Lowerer
         // hook owns the instance table (monomorphization by flow).
         if (classDecl.typeParameters) {
-            const instance = ctx.genericClassInstance?.(classDecl, widened, (argument) => mapType(argument, ctx)) ?? null;
+            const instance = ctx.genericClassInstance?.(classDecl, widened, (argument) => mapType(argument, ctx)) ??
+                null;
             // Before the generic declaration's collection turn, the hook can only
             // return its family shell; after collection the same checker type names
             // a concrete registered instance. Never memoize either phase's answer.
@@ -1455,7 +1507,9 @@ function mapTypeInner(type, ctx) {
     // 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()));
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
     // 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
@@ -1481,7 +1535,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             (psym.name === "ScriptcModule" ||
                 isDeclaredInAmbientNamespace(d, "NodeJS") ||
@@ -1496,7 +1552,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             (isDeclaredInAmbientModule(d, "events") || isDeclaredInAmbientNamespace(d, "NodeJS")))) {
         return { kind: "object", className: RUNTIME_EMITTER_CLASS };
@@ -1507,7 +1565,9 @@ function mapTypeInner(type, ctx) {
     // net.Server (@types/node also declares Interface in
     // readline/promises — that one stays unmapped and fences).
     if (psym?.name === "Interface" &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "readline"))) {
         return F64;
@@ -1519,7 +1579,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
         return F64;
@@ -1528,7 +1590,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "async_hooks"))) {
         return F64;
@@ -1536,31 +1600,57 @@ function mapTypeInner(type, ctx) {
     // diagnostics_channel.TracingChannel: the same f64-handle story over the
     // runtime's tracing registry (five event channels per entry).
     if (psym?.name === "TracingChannel" &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             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()))
-            return false;
-        if (ts.isInterfaceDeclaration(decl) && decl.name.text === "EncodeIntoResult")
-            return true;
-        const parent = decl.parent;
-        return ts.isTypeLiteralNode(decl) && parent?.kind === ts.SyntaxKind.MethodSignature &&
-            parent.name && ts.isIdentifier(parent.name) && parent.name.text === "encodeInto" &&
-            parent.parent && ts.isInterfaceDeclaration(parent.parent) && parent.parent.name.text === "TextEncoder";
-    });
+    const encodeResult = psym &&
+        checker.declarationsOf(psym).some((decl) => {
+            if (!ctx.isStdlibFile(decl.getSourceFile()))
+                return false;
+            if (ts.isInterfaceDeclaration(decl) && decl.name.text === "EncodeIntoResult")
+                return true;
+            const parent = decl.parent;
+            return (ts.isTypeLiteralNode(decl) &&
+                parent?.kind === ts.SyntaxKind.MethodSignature &&
+                parent.name &&
+                ts.isIdentifier(parent.name) &&
+                parent.name.text === "encodeInto" &&
+                parent.parent &&
+                ts.isInterfaceDeclaration(parent.parent) &&
+                parent.parent.name.text === "TextEncoder");
+        });
     if (encodeResult)
-        return { kind: "record", shapeId: ctx.shapes.intern([{ name: "read", type: F64 }, { name: "written", type: F64 }]) };
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "read", type: F64 },
+                { name: "written", type: F64 },
+            ]),
+        };
     // 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()))) {
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()))) {
         return {
             kind: "record",
-            shapeId: ctx.shapes.intern([{ name: `%${psym.name}`, type: F64 }, ...(psym.name === "TextDecoder" ? [{ name: "%fatal", type: BOOL }, { name: "%ignoreBOM", type: BOOL }, { name: "%state", type: DYN }] : [])], false, undefined, []),
+            shapeId: ctx.shapes.intern([
+                { name: `%${psym.name}`, type: F64 },
+                ...(psym.name === "TextDecoder"
+                    ? [
+                        { name: "%fatal", type: BOOL },
+                        { name: "%ignoreBOM", type: BOOL },
+                        { name: "%state", type: DYN },
+                    ]
+                    : []),
+            ], false, undefined, []),
         };
     }
     // string_decoder.StringDecoder: the decoder value is a two-field record
@@ -1571,7 +1661,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         return {
             kind: "record",
@@ -1608,7 +1700,11 @@ function mapTypeInner(type, ctx) {
                         { name: "promise", type: promT },
                         {
                             name: "reject",
-                            type: { kind: "func", params: [{ kind: "object", className: "%Error" }], ret: VOID },
+                            type: {
+                                kind: "func",
+                                params: [{ kind: "object", className: "%Error" }],
+                                ret: VOID,
+                            },
                         },
                         {
                             name: "resolve",
@@ -1646,14 +1742,11 @@ function mapTypeInner(type, ctx) {
         const alias = widened.getAliasSymbol();
         if (!ctx.dynamic &&
             alias?.name === "ReadableStreamReadResult" &&
-            checker.declarationsOf(alias).some((d) => ts.isTypeAliasDeclaration(d) &&
-                ctx.isStdlibFile(d.getSourceFile()))) {
+            checker
+                .declarationsOf(alias)
+                .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
             const elemTs = widened.getAliasTypeArguments()?.[0];
-            const elem = elemTs && elemTs.flags & ts.TypeFlags.Any
-                ? DYN
-                : elemTs
-                    ? mapType(elemTs, ctx)
-                    : null;
+            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);
@@ -1663,14 +1756,11 @@ function mapTypeInner(type, ctx) {
         psym &&
         (psym.name === "ReadableStreamReadValueResult" ||
             psym.name === "ReadableStreamReadDoneResult") &&
-        checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
         const elemTs = checker.getTypeArguments(widened)[0];
-        const elem = elemTs && elemTs.flags & ts.TypeFlags.Any
-            ? DYN
-            : elemTs
-                ? mapType(elemTs, ctx)
-                : null;
+        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);
@@ -1678,8 +1768,12 @@ function mapTypeInner(type, ctx) {
     if (psym &&
         ISLAND_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)) &&
+            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()))) {
         return ctx.dynamic ? JSVAL : DYN;
     }
@@ -1692,7 +1786,8 @@ function mapTypeInner(type, ctx) {
         if (args.length !== 2)
             return null;
         const key = !ctx.dynamic && (args[0].flags & ts.TypeFlags.Any) !== 0 ? DYN : mapType(args[0], ctx);
-        if (!key || !isSupportedMapKey(key, key.kind === "union" ? ctx.unions.get(key.unionId)?.arms : undefined))
+        if (!key ||
+            !isSupportedMapKey(key, key.kind === "union" ? ctx.unions.get(key.unionId)?.arms : undefined))
             return null;
         const value = !ctx.dynamic && (args[1].flags & ts.TypeFlags.Any) !== 0 ? DYN : mapType(args[1], ctx);
         if (!value || !isSupportedMapValue(value))
@@ -1711,7 +1806,8 @@ function mapTypeInner(type, ctx) {
         if (args.length !== 1)
             return null;
         const elem = !ctx.dynamic && (args[0].flags & ts.TypeFlags.Any) !== 0 ? DYN : mapType(args[0], ctx);
-        if (!elem || !isSupportedSetElem(elem, elem.kind === "union" ? ctx.unions.get(elem.unionId)?.arms : undefined))
+        if (!elem ||
+            !isSupportedSetElem(elem, elem.kind === "union" ? ctx.unions.get(elem.unionId)?.arms : undefined))
             return null;
         return setOf(elem);
     }
@@ -1731,7 +1827,9 @@ function mapTypeInner(type, ctx) {
     if (isStdlibInterface("RegExp")) {
         return { kind: "regex" };
     }
-    if (isStdlibInterface("Segmenter") || isStdlibInterface("Segments") || isStdlibInterface("SegmentData"))
+    if (isStdlibInterface("Segmenter") ||
+        isStdlibInterface("Segments") ||
+        isStdlibInterface("SegmentData"))
         return DYN;
     // Typed arrays: references to the lib's Uint8Array/Uint32Array/
     // Float32Array/Float64Array interfaces (provenance, not names). The es2022+ lib
@@ -1771,7 +1869,10 @@ function mapTypeInner(type, ctx) {
     // space, so clearTimeout of an Immediate no-ops like Node.
     if (isStdlibInterface("Immediate"))
         return F64;
-    if (isStdlibInterface("ArrayBuffer") || isStdlibInterface("PropertyDescriptor") || isStdlibInterface("ProcessVersions"))
+    if (isStdlibInterface("ArrayBuffer") ||
+        isStdlibInterface("SharedArrayBuffer") ||
+        isStdlibInterface("PropertyDescriptor") ||
+        isStdlibInterface("ProcessVersions"))
         return DYN;
     if (Object.values(BYTES_ELEMENT_NAME).some((name) => isStdlibInterface(`${name}Constructor`)))
         return DYN;
@@ -1808,7 +1909,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         return bytesOf("u8");
     }
@@ -1818,7 +1921,9 @@ function mapTypeInner(type, ctx) {
     // instance type). Provenance, not the name: a user's own URL maps as a
     // record/class like any other.
     if (psym?.name === "URL" &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         return { kind: "url" };
     }
@@ -1826,28 +1931,46 @@ function mapTypeInner(type, ctx) {
     // interface by the shipped fallback and by @types/node (plus `class
     // URLSearchParams` in the "url" module). Provenance-checked like URL.
     if (psym?.name === "URLSearchParams" &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         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()) && isDeclaredInAmbientModule(d, "fs")))
+    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()) &&
+            isDeclaredInAmbientModule(d, "fs")))
+        return DYN;
+    if ((psym?.name === "Worker" || psym?.name === "MessagePort") &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "worker_threads")))
         return DYN;
     // 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) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "fs/promises"))) {
         return { kind: "fileHandle" };
@@ -1857,7 +1980,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         return { kind: "spawnRes" };
     }
@@ -1868,7 +1993,9 @@ function mapTypeInner(type, ctx) {
         (psym.name === "ChildProcess" ||
             psym.name === "ChildProcessWithoutNullStreams" ||
             psym.name === "ChildProcessByStdio") &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "child_process"))) {
         return { kind: "child" };
@@ -1902,20 +2029,29 @@ function mapTypeInner(type, ctx) {
     // @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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             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()) && isDeclaredInAmbientModule(d, "crypto")))
+    if (psym?.name === "ScryptOptions" &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
         return psym.name === "Hash" ? CRYPTOHASH_T : CRYPTOHMAC_T;
@@ -1925,7 +2061,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "fs"))) {
         return { kind: "fsWatcher" };
@@ -1948,11 +2086,15 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "tty"))) ||
         (psym?.name === "WritableStream" &&
-            checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
+            checker
+                .declarationsOf(psym)
+                .some((d) => ts.isInterfaceDeclaration(d) &&
                 ctx.isStdlibFile(d.getSourceFile()) &&
                 isDeclaredInAmbientNamespace(d, "NodeJS")))) {
         return PROCSTREAM_T;
@@ -1962,11 +2104,15 @@ function mapTypeInner(type, ctx) {
     // stream.Writable. As with stream.Readable below, unsupported producers
     // of the broad @types class fence where they are constructed.
     if ((psym?.name === "ChildStdin" &&
-        checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "child_process"))) ||
         (psym?.name === "Writable" &&
-            checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            checker
+                .declarationsOf(psym)
+                .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
                 ctx.isStdlibFile(d.getSourceFile()) &&
                 isNodeTypesPath(d.getSourceFile().fileName) &&
                 isDeclaredInAmbientModule(d, "stream")))) {
@@ -1981,7 +2127,9 @@ function mapTypeInner(type, ctx) {
     // branch below), so the two never collide.
     for (const [irName, rec] of RUNTIME_STREAM_CLASSES) {
         if (psym?.name === rec.lib &&
-            checker.declarationsOf(psym).some((d) => ts.isClassDeclaration(d) &&
+            checker
+                .declarationsOf(psym)
+                .some((d) => ts.isClassDeclaration(d) &&
                 ctx.isStdlibFile(d.getSourceFile()) &&
                 !isNodeTypesPath(d.getSourceFile().fileName) &&
                 isDeclaredInAmbientModule(d, "stream"))) {
@@ -1989,11 +2137,15 @@ function mapTypeInner(type, ctx) {
         }
     }
     if ((psym?.name === "Readable" &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "stream"))) ||
         (psym?.name === "ReadableStream" &&
-            checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
+            checker
+                .declarationsOf(psym)
+                .some((d) => ts.isInterfaceDeclaration(d) &&
                 ctx.isStdlibFile(d.getSourceFile()) &&
                 isDeclaredInAmbientNamespace(d, "NodeJS")))) {
         return { kind: "childStream" };
@@ -2003,7 +2155,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "dgram"))) {
         return { kind: "dgramSocket" };
@@ -2013,7 +2167,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "test"))) {
         return { kind: "testCtx" };
@@ -2024,7 +2180,9 @@ function mapTypeInner(type, ctx) {
     // above; the optional errno/code/path/syscall extras fence per member
     // (the .stack stance). Provenance-checked like the rest.
     if (psym?.name === "ErrnoException" &&
-        checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
         return { kind: "object", className: "%Error" };
     }
     // http.Agent / https.Agent — the Agent VALUE is a checked-dynamic
@@ -2034,7 +2192,9 @@ function mapTypeInner(type, ctx) {
     // of fencing at the declaration. Module-checked like the rest (https'
     // Agent extends http's; both live in their ambient modules).
     if (psym?.name === "Agent" &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             (isDeclaredInAmbientModule(d, "http") || isDeclaredInAmbientModule(d, "https")))) {
         return { kind: "dyn" };
@@ -2043,7 +2203,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "http"))) {
         return psym.name === "IncomingMessage" ? { kind: "httpReq" } : { kind: "httpRes" };
@@ -2059,7 +2221,9 @@ function mapTypeInner(type, ctx) {
     if ((psym?.name === "Http2SecureServer" ||
         psym?.name === "Http2ServerRequest" ||
         psym?.name === "Http2ServerResponse") &&
-        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "http2"))) {
         return psym.name === "Http2SecureServer"
@@ -2072,10 +2236,15 @@ 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)) &&
+    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()) &&
             isDeclaredInAmbientModule(d, "http2"))) {
         return psym.name === "Http2Server"
@@ -2087,7 +2256,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "http"))) {
         return { kind: "httpClientReq" };
@@ -2101,7 +2272,9 @@ function mapTypeInner(type, ctx) {
     // 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()))) {
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
         const value = withUndefinedArm(STRING, ctx.unions);
         if (!value)
             return null;
@@ -2154,7 +2327,9 @@ function mapTypeInner(type, ctx) {
     //                    argument — fenced at the call).
     // Mixed dyn/concrete value channels share checked storage, so either
     // branch of the result record has the same representation.
-    if (isStdlibInterface("Generator") || isStdlibInterface("AsyncGenerator") || isStdlibInterface("IterableIterator")) {
+    if (isStdlibInterface("Generator") ||
+        isStdlibInterface("AsyncGenerator") ||
+        isStdlibInterface("IterableIterator")) {
         const args = checker.getTypeArguments(widened);
         const channels = genChannels(args[0], args[1], args[2], ctx);
         if (!channels)
@@ -2176,7 +2351,9 @@ function mapTypeInner(type, ctx) {
     {
         const alias = widened.getAliasSymbol();
         if (alias?.name === "IteratorResult" &&
-            checker.declarationsOf(alias).some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
+            checker
+                .declarationsOf(alias)
+                .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))) {
             const targs = widened.getAliasTypeArguments() ?? [];
             const channels = genChannels(targs[0], targs[1], undefined, ctx);
             if (!channels)
@@ -2216,7 +2393,7 @@ function mapTypeInner(type, ctx) {
         const optStr = withUndefinedArm(STRING, ctx.unions);
         const optNum = withUndefinedArm(F64, ctx.unions);
         const optBool = withUndefinedArm(BOOL, ctx.unions);
-        const stdioArms = [arrayOf(STRING), STRING, UNDEFINED_T].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+        const stdioArms = [arrayOf(STRING), STRING, UNDEFINED_T].sort((a, b) => typeKey(a) < typeKey(b) ? -1 : 1);
         const stdio = { kind: "union", unionId: ctx.unions.intern(stdioArms) };
         if (!optStr || !optNum || !optBool)
             return null;
@@ -2245,8 +2422,14 @@ 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?.name === "FileReadOptions" ||
+        psym?.name === "ReadOptions" ||
+        psym?.name === "ReadOptionsWithBuffer" ||
+        psym?.name === "WriteOptions") &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
             (isDeclaredInAmbientModule(d, "fs/promises") || isDeclaredInAmbientModule(d, "fs")))) {
         const fields = [];
         for (const property of checker.getPropertiesOfType(widened)) {
@@ -2258,31 +2441,48 @@ function mapTypeInner(type, ctx) {
             fields.push({ name: property.name, type });
         }
         const order = fields.map((field) => field.name);
-        fields.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
         return { kind: "record", shapeId: ctx.shapes.intern(fields, false, undefined, order) };
     }
     // fs/promises FileReadResult<T> / FileWriteResult<T>: the two-field
     // 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) &&
+    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()) &&
             (isDeclaredInAmbientModule(d, "fs/promises") ||
-                ((psym.name === "ReadVResult" || psym.name === "WriteVResult") && isDeclaredInAmbientModule(d, "fs"))))) {
+                ((psym.name === "ReadVResult" || psym.name === "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 emptyVector = vector && checker.isArrayType(args[0]) &&
+        const vector = psym.name === "FileReadvResult" ||
+            psym.name === "FileWritevResult" ||
+            psym.name === "ReadVResult" ||
+            psym.name === "WriteVResult";
+        const emptyVector = vector &&
+            checker.isArrayType(args[0]) &&
             (checker.getTypeArguments(args[0])[0].flags & ts.TypeFlags.Never) !== 0;
         const payload = emptyVector ? arrayOf(bytesOf("u8")) : mapType(args[0], ctx);
-        if (!payload || (vector
-            ? !(payload.kind === "array" && payload.elem.kind === "bytes" && payload.elem.elem === "u8")
-            : !(payload.kind === "string" || (payload.kind === "bytes" && payload.elem === "u8")))) {
+        if (!payload ||
+            (vector
+                ? !(payload.kind === "array" && payload.elem.kind === "bytes" && payload.elem.elem === "u8")
+                : !(payload.kind === "string" || (payload.kind === "bytes" && payload.elem === "u8")))) {
             return null;
         }
-        const count = psym.name === "FileReadResult" || psym.name === "FileReadvResult" || psym.name === "ReadVResult" ? "bytesRead" : "bytesWritten";
+        const count = psym.name === "FileReadResult" ||
+            psym.name === "FileReadvResult" ||
+            psym.name === "ReadVResult"
+            ? "bytesRead"
+            : "bytesWritten";
         const payloadName = vector ? "buffers" : "buffer";
         return {
             kind: "record",
@@ -2306,7 +2506,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
         const args = checker.getTypeArguments(widened);
         if (args.length > 1)
@@ -2364,7 +2566,9 @@ function mapTypeInner(type, ctx) {
     // 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)) &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
         return {
@@ -2391,10 +2595,21 @@ function mapTypeInner(type, ctx) {
     }
     if (isStdlibInterface("ResourceUsage")) {
         const names = [
-            "userCPUTime", "systemCPUTime", "maxRSS", "sharedMemorySize",
-            "unsharedDataSize", "unsharedStackSize", "minorPageFault",
-            "majorPageFault", "swappedOut", "fsRead", "fsWrite", "ipcSent",
-            "ipcReceived", "signalsCount", "voluntaryContextSwitches",
+            "userCPUTime",
+            "systemCPUTime",
+            "maxRSS",
+            "sharedMemorySize",
+            "unsharedDataSize",
+            "unsharedStackSize",
+            "minorPageFault",
+            "majorPageFault",
+            "swappedOut",
+            "fsRead",
+            "fsWrite",
+            "ipcSent",
+            "ipcReceived",
+            "signalsCount",
+            "voluntaryContextSwitches",
             "involuntaryContextSwitches",
         ];
         return {
@@ -2421,7 +2636,8 @@ function mapTypeInner(type, ctx) {
     // plain number. Declared order is Node's runtime insertion order
     // (lib/os.js builds address..cidr then appends scopeid), so Object.keys
     // over a row answers exactly Node.
-    if (isStdlibInterface("NetworkInterfaceInfoIPv4") || isStdlibInterface("NetworkInterfaceInfoIPv6")) {
+    if (isStdlibInterface("NetworkInterfaceInfoIPv4") ||
+        isStdlibInterface("NetworkInterfaceInfoIPv6")) {
         const v6 = psym.name === "NetworkInterfaceInfoIPv6";
         const cidrArms = [NULL_T, STRING].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
         const cidr = { kind: "union", unionId: ctx.unions.intern(cidrArms) };
@@ -2440,12 +2656,17 @@ function mapTypeInner(type, ctx) {
         return {
             kind: "record",
             shapeId: ctx.shapes.intern(fields, false, undefined, [
-                "address", "netmask", "family", "mac", "internal", "cidr", "scopeid",
+                "address",
+                "netmask",
+                "family",
+                "mac",
+                "internal",
+                "cidr",
+                "scopeid",
             ]),
         };
     }
-    if (isStdlibInterface("PromiseFulfilledResult") ||
-        isStdlibInterface("PromiseRejectedResult")) {
+    if (isStdlibInterface("PromiseFulfilledResult") || isStdlibInterface("PromiseRejectedResult")) {
         return {
             kind: "record",
             shapeId: ctx.shapes.intern([{ name: "status", type: STRING }], false, undefined, ["status"]),
@@ -2480,7 +2701,8 @@ function mapTypeInner(type, ctx) {
             return hybrid;
         // Recursive and Symbol-keyed callable objects need their complete live
         // property table; dropping those members into a plain closure loses data.
-        if (!ctx.dynamic && checker.getCallSignatures(widened).length > 0 &&
+        if (!ctx.dynamic &&
+            checker.getCallSignatures(widened).length > 0 &&
             checker.getPropertiesOfType(widened).length > 0)
             return DYN;
     }
@@ -2523,20 +2745,36 @@ function mapTypeInner(type, ctx) {
                 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()))
+            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 &&
+                ? 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)
@@ -2570,22 +2808,38 @@ function mapTypeInner(type, ctx) {
         // 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()) &&
+        const jsUnitReturn = sigDecl !== undefined &&
+            isJsSourceFile(sigDecl.getSourceFile()) &&
             (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
         let ret = jsUnitReturn || (!ctx.dynamic && (retT.flags & ts.TypeFlags.Any) !== 0)
-            ? DYN : retT.flags & ts.TypeFlags.Never ? VOID : mapType(retT, ctx);
+            ? 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")
+        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 &&
+        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?.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))
+        if (ret &&
+            sigDecl &&
+            isJsSourceFile(sigDecl.getSourceFile()) &&
+            functionCanReturnUndefined(sigDecl))
             ret = withUndefinedArm(ret, ctx.unions) ?? ret;
         if (!ret)
             return null;
@@ -2630,29 +2884,66 @@ function mapTypeInner(type, ctx) {
         callSigs.length === 0 &&
         psym !== undefined &&
         checker.declarationsOf(psym).length > 0 &&
-        checker.declarationsOf(psym).every((d) => ts.isInterfaceDeclaration(d) && !ctx.isStdlibFile(d.getSourceFile()))) {
+        checker
+            .declarationsOf(psym)
+            .every((d) => ts.isInterfaceDeclaration(d) && !ctx.isStdlibFile(d.getSourceFile()))) {
         const CHILD_SURFACE = new Set([
-            "pid", "exitCode", "killed", "kill", "on", "once", "off",
-            "removeListener", "unref", "ref", "stdin", "stdout", "stderr",
-            "send", "connected", "disconnect",
+            "pid",
+            "exitCode",
+            "killed",
+            "kill",
+            "on",
+            "once",
+            "off",
+            "removeListener",
+            "unref",
+            "ref",
+            "stdin",
+            "stdout",
+            "stderr",
+            "send",
+            "connected",
+            "disconnect",
+        ]);
+        const CHILD_CORE = new Set([
+            "kill",
+            "on",
+            "stdin",
+            "stdout",
+            "stderr",
+            "unref",
+            "exitCode",
+            "send",
+            "connected",
         ]);
-        const CHILD_CORE = new Set(["kill", "on", "stdin", "stdout", "stderr", "unref", "exitCode", "send", "connected"]);
         const props = checker.getPropertiesOfType(widened);
         let core = 0;
         const childMemberType = (p) => {
             if (["kill", "on", "once", "off", "removeListener", "unref", "ref"].includes(p.name)) {
                 return checker.getCallSignatures(checker.getTypeOfSymbol(p)).length > 0;
             }
-            const expected = p.name === "stdout" || p.name === "stderr" ? "childStream"
-                : p.name === "stdin" ? "childWriter"
-                    : p.name === "killed" ? "bool" : "f64";
-            const unit = p.name === "pid" ? "undefinedT" : p.name === "exitCode" || p.name === "stdin" || p.name === "stdout" || p.name === "stderr" ? "nullT" : null;
+            const expected = p.name === "stdout" || p.name === "stderr"
+                ? "childStream"
+                : p.name === "stdin"
+                    ? "childWriter"
+                    : p.name === "killed"
+                        ? "bool"
+                        : "f64";
+            const unit = p.name === "pid"
+                ? "undefinedT"
+                : p.name === "exitCode" ||
+                    p.name === "stdin" ||
+                    p.name === "stdout" ||
+                    p.name === "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];
-            return arms !== undefined && arms.some((arm) => arm.kind === expected) &&
-                arms.every((arm) => arm.kind === expected || arm.kind === unit);
+            return (arms !== undefined &&
+                arms.some((arm) => arm.kind === expected) &&
+                arms.every((arm) => arm.kind === expected || arm.kind === unit));
         };
         const childShaped = props.length > 0 &&
             props.every((p) => {
@@ -2702,6 +2993,7 @@ function mapTypeInner(type, ctx) {
         try {
             const byKey = new Map();
             const recordParts = [];
+            const substitutedUnions = [];
             for (const part of ts.constituentTypes(widened)) {
                 // TypeScript's client can retain impossible intersections in a
                 // distributed union. They have no inhabitants and no runtime tag.
@@ -2745,6 +3037,19 @@ function mapTypeInner(type, ctx) {
                     byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
                     continue;
                 }
+                // A generic parameter can substitute a complete union into one
+                // checker constituent: `(T | undefined)` with nullable T still
+                // has one flat storage contract. An unfinished recursive union
+                // cannot supply its arms yet, so retain that existing boundary.
+                if (mapped.kind === "union") {
+                    const substituted = unions.get(mapped.unionId);
+                    if (!substituted?.arms.length || substituted.arms.some((arm) => arm.kind === "union"))
+                        return null;
+                    substitutedUnions.push(substituted);
+                    for (const arm of substituted.arms)
+                        byKey.set(typeKey(arm), arm);
+                    continue;
+                }
                 byKey.set(typeKey(mapped), mapped);
                 if (mapped.kind === "record")
                     recordParts.push({ source: part, mapped });
@@ -2790,13 +3095,19 @@ function mapTypeInner(type, ctx) {
                 !unions.recursivePending(widened)) {
                 return DYN;
             }
-            if (arms.some((a) => a.kind === "void" || a.kind === "union" ||
-                a.kind === "date" || a.kind === "dyn" ||
-                a.kind === "generator") || !unionContainerArmsOk(arms)) {
+            if (arms.some((a) => a.kind === "void" ||
+                a.kind === "union" ||
+                a.kind === "date" ||
+                a.kind === "dyn" ||
+                a.kind === "generator") ||
+                !unionContainerArmsOk(arms)) {
                 return null;
             }
             arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
-            const discriminant = unionDiscriminant(recordParts, arms, ctx);
+            const discriminant = unionDiscriminant(recordParts, arms, ctx) ??
+                (substitutedUnions.length === 1
+                    ? remapUnionDiscriminant(substitutedUnions[0], arms)
+                    : undefined);
             if (unions.recursivePending(widened)) {
                 // The knot closed through this union. A frame that resolved
                 // through context-sensitive hooks (generic type parameters, mixin
@@ -2837,7 +3148,9 @@ function unionDiscriminant(parts, arms, ctx) {
         let complete = true;
         for (const part of parts) {
             const prop = checker.getPropertyOfType(part.source, candidate.name);
-            if (!prop || prop.flags & (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
+            if (!prop ||
+                prop.flags &
+                    (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
                 complete = false;
                 break;
             }
@@ -2866,8 +3179,15 @@ function unionDiscriminant(parts, arms, ctx) {
         if (complete) {
             return {
                 field: candidate.name,
-                cases: [...byTag].sort(([a], [b]) => a - b).map(([tag, values]) => ({
-                    tag, values: values.sort((a, b) => JSON.stringify(a) < JSON.stringify(b) ? -1 : JSON.stringify(a) > JSON.stringify(b) ? 1 : 0),
+                cases: [...byTag]
+                    .sort(([a], [b]) => a - b)
+                    .map(([tag, values]) => ({
+                    tag,
+                    values: values.sort((a, b) => JSON.stringify(a) < JSON.stringify(b)
+                        ? -1
+                        : JSON.stringify(a) > JSON.stringify(b)
+                            ? 1
+                            : 0),
                 })),
             };
         }
@@ -2892,7 +3212,8 @@ function mapClassView(type, ctx, seen = new Set()) {
     else {
         const symbol = type.getSymbol();
         const declarations = symbol ? checker.declarationsOf(symbol) : [];
-        if (declarations.length === 0 || !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(decl.getSourceFile())))
+        if (declarations.length === 0 ||
+            !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(decl.getSourceFile())))
             return undefined;
         const target = type.isTypeReference() ? type.getTarget() : type;
         if (target === undefined || !target.isClassOrInterface())
@@ -2907,12 +3228,14 @@ function mapClassView(type, ctx, seen = new Set()) {
                 resolveTypeParam: (param) => {
                     const index = params.indexOf(param);
                     const arg = index >= 0 ? args[index] : undefined;
-                    return arg && arg !== param ? mapType(arg, ctx) : ctx.resolveTypeParam?.(param) ?? null;
+                    return arg && arg !== param ? mapType(arg, ctx) : (ctx.resolveTypeParam?.(param) ?? null);
                 },
                 resolveTypeParamTs: (param) => {
                     const index = params.indexOf(param);
                     const arg = index >= 0 ? args[index] : undefined;
-                    return arg && arg !== param ? ctx.resolveTypeParamTs?.(arg) ?? arg : ctx.resolveTypeParamTs?.(param) ?? null;
+                    return arg && arg !== param
+                        ? (ctx.resolveTypeParamTs?.(arg) ?? arg)
+                        : (ctx.resolveTypeParamTs?.(param) ?? null);
                 },
             };
         }
@@ -2924,7 +3247,8 @@ function mapClassView(type, ctx, seen = new Set()) {
         for (const base of bases) {
             const symbol = base.getSymbol();
             const declaration = symbol ? checker.valueDeclarationOf(symbol) : undefined;
-            const classBase = declaration && (ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration)) &&
+            const classBase = declaration &&
+                (ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration)) &&
                 !declaration.getSourceFile().isDeclarationFile;
             const mapped = classBase ? mapType(base, viewCtx) : mapClassView(base, viewCtx, seen);
             if (mapped === null)
@@ -2938,7 +3262,8 @@ function mapClassView(type, ctx, seen = new Set()) {
         }
         if (!representation || !baseType)
             return undefined;
-        if (checker.getCallSignatures(type).length || checker.getConstructSignatures(type).length ||
+        if (checker.getCallSignatures(type).length ||
+            checker.getConstructSignatures(type).length ||
             checker.getIndexInfosOfType(type).length)
             return null;
         for (const property of checker.getPropertiesOfType(type)) {
@@ -2951,7 +3276,8 @@ function mapClassView(type, ctx, seen = new Set()) {
             const declarations = checker.declarationsOf(property);
             // Instantiating an inherited member can create a new symbol without
             // changing its declaration or ABI. Only refinements need validation.
-            if (declarations.length > 0 && declarations.length === originalDeclarations.length &&
+            if (declarations.length > 0 &&
+                declarations.length === originalDeclarations.length &&
                 declarations.every((declaration, index) => declaration === originalDeclarations[index]))
                 continue;
             const before = checker.getTypeOfSymbol(original);
@@ -2983,15 +3309,20 @@ function mapCollectionView(type, ctx, seen = new Set()) {
     const { checker } = ctx;
     const symbol = type.getSymbol();
     const declarations = symbol ? checker.declarationsOf(symbol) : [];
-    if (declarations.length === 0 || !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(decl.getSourceFile())))
+    if (declarations.length === 0 ||
+        !declarations.every((decl) => ts.isInterfaceDeclaration(decl) && !ctx.isStdlibFile(decl.getSourceFile())))
         return null;
     const target = type.getTarget();
-    if (target === undefined || !target.isClassOrInterface() || seen.has(target) || seen.size >= MAP_TYPE_MAX_DEPTH)
+    if (target === undefined ||
+        !target.isClassOrInterface() ||
+        seen.has(target) ||
+        seen.size >= MAP_TYPE_MAX_DEPTH)
         return null;
     const bases = checker.getBaseTypes(target);
     if (bases.length !== 1)
         return null;
-    if (checker.getCallSignatures(type).length || checker.getConstructSignatures(type).length ||
+    if (checker.getCallSignatures(type).length ||
+        checker.getConstructSignatures(type).length ||
         checker.getIndexInfosOfType(type).length)
         return null;
     // Base declarations contain the interface's parameters, even when this
@@ -3005,29 +3336,37 @@ function mapCollectionView(type, ctx, seen = new Set()) {
         resolveTypeParam: (param) => {
             const index = params.indexOf(param);
             const arg = index >= 0 ? args[index] : undefined;
-            return arg && arg !== param ? mapType(arg, ctx) : ctx.resolveTypeParam?.(param) ?? null;
+            return arg && arg !== param ? mapType(arg, ctx) : (ctx.resolveTypeParam?.(param) ?? null);
         },
         resolveTypeParamTs: (param) => {
             const index = params.indexOf(param);
             const arg = index >= 0 ? args[index] : undefined;
-            return arg && arg !== param ? ctx.resolveTypeParamTs?.(arg) ?? arg : ctx.resolveTypeParamTs?.(param) ?? null;
+            return arg && arg !== param
+                ? (ctx.resolveTypeParamTs?.(arg) ?? arg)
+                : (ctx.resolveTypeParamTs?.(param) ?? null);
         },
     };
     seen.add(target);
     try {
         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()));
+        const native = baseSymbol &&
+            ["Map", "ReadonlyMap", "Set", "ReadonlySet"].includes(baseSymbol.name) &&
+            checker
+                .declarationsOf(baseSymbol)
+                .some((decl) => ts.isInterfaceDeclaration(decl) && ctx.isStdlibFile(decl.getSourceFile()));
         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 = checker
+                .declarationsOf(property)
+                .filter((decl) => !ctx.isStdlibFile(decl.getSourceFile()));
             if (own.length === 0)
                 continue;
-            if (property.name !== "has" || (property.flags & ts.SymbolFlags.Optional) ||
+            if (property.name !== "has" ||
+                property.flags & ts.SymbolFlags.Optional ||
                 !own.every((decl) => decl.kind === ts.SyntaxKind.MethodSignature))
                 return null;
             const method = mapType(checker.getTypeOfSymbol(property), ctx);
@@ -3207,7 +3546,9 @@ function mapGenericAwaitedAlias(type, 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 = ctx.checker
+        .declarationsOf(alias)
+        .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
     if (!isLibAlias)
         return null;
     const bound = resolveTypeParam(arg);
@@ -3253,7 +3594,8 @@ function mapGenericIndexedAccess(type, ctx) {
         covered = f ? [f.type] : shape.indexValue ? [shape.indexValue] : null;
     }
     else {
-        const allKeys = ((idx.flags & ts.TypeFlags.TypeParameter) !== 0 && resolveTypeParam(idx)?.kind === "string") ||
+        const allKeys = ((idx.flags & ts.TypeFlags.TypeParameter) !== 0 &&
+            resolveTypeParam(idx)?.kind === "string") ||
             (idx.isIndexType() && idx.getTarget() === obj);
         if (allKeys) {
             covered = shape.fields.map((f) => f.type);
@@ -3280,7 +3622,9 @@ 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 = ctx.checker
+        .declarationsOf(alias)
+        .some((d) => ts.isTypeAliasDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
     if (!isLibAlias)
         return null;
     const bound = resolveTypeParam(arg);
@@ -3352,8 +3696,7 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
                     byKey.set(typeKey(a), a);
                 return true;
             }
-            if (t.kind === "regex" || t.kind === "date" ||
-                t.kind === "jsval" || t.kind === "generator") {
+            if (t.kind === "regex" || t.kind === "date" || t.kind === "jsval" || t.kind === "generator") {
                 return false; // no legal union arm exists for these kinds
             }
             byKey.set(typeKey(t), t);
@@ -3365,7 +3708,8 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
         const arms = [...byKey.values()];
         // Containers keep the shared nullable-only rule. Generator function
         // payloads retain their existing unit-only boundary too.
-        if (!unionContainerArmsOk(arms) || arms.some((a) => a.kind === "func" && !arms.every((b) => b === a || isUnitType(b)))) {
+        if (!unionContainerArmsOk(arms) ||
+            arms.some((a) => a.kind === "func" && !arms.every((b) => b === a || isUnitType(b)))) {
             return null;
         }
         if (arms.every(isUnitType) && arms.length < 2) {
@@ -3424,7 +3768,9 @@ export function withUnitArm(t, kind, unions) {
         arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
         return { kind: "union", unionId: unions.transform(def, arms) };
     }
-    if (t.kind === "void" || t.kind === "date" || t.kind === "dyn" ||
+    if (t.kind === "void" ||
+        t.kind === "date" ||
+        t.kind === "dyn" ||
         // A bare unit field type cannot occur (units live only inside unions),
         // but guard against constructing a single-arm union from one.
         isUnitType(t)) {
@@ -3517,7 +3863,12 @@ function mapBrandedPrimitiveIntersection(widened, ctx) {
             return BIGINT_T;
         if (base.flags & ts.TypeFlags.TypeParameter) {
             const bound = resolveTypeParam?.(base) ?? null;
-            if (bound && (bound.kind === "f64" || bound.kind === "bigint" || bound.kind === "string" || bound.kind === "bool" || bound.kind === "symbol")) {
+            if (bound &&
+                (bound.kind === "f64" ||
+                    bound.kind === "bigint" ||
+                    bound.kind === "string" ||
+                    bound.kind === "bool" ||
+                    bound.kind === "symbol")) {
                 contextResolutions++;
                 return bound;
             }
@@ -3597,11 +3948,11 @@ function recordProvenanceOk(t, ctx) {
     if (t.isIntersectionType()) {
         return ts.constituentTypes(t).every((part) => {
             const partSym = part.getSymbol();
-            return (part.flags & ts.TypeFlags.Object) !== 0 &&
+            return ((part.flags & ts.TypeFlags.Object) !== 0 &&
                 !(partSym && partSym.flags & ts.SymbolFlags.Class) &&
                 checker.getCallSignatures(part).length === 0 &&
                 checker.getConstructSignatures(part).length === 0 &&
-                recordProvenanceOk(part, ctx);
+                recordProvenanceOk(part, ctx));
         });
     }
     if (isMappedShape(t))
@@ -3611,7 +3962,12 @@ function recordProvenanceOk(t, ctx) {
     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())));
+        return checker
+            .getPropertiesOfType(t)
+            .every((property) => checker
+            .declarationsOf(property)
+            .every((decl) => !decl.getSourceFile().isDeclarationFile ||
+            ctx.isExternalTypeFile(decl.getSourceFile())));
     }
     return !decls.some((d) => {
         const sf = d.getSourceFile();
@@ -3690,7 +4046,10 @@ function mapRecordType(widened, ctx) {
             inner.fields.every((field) => field.type.kind === "dyn") &&
             (inner.indexValue === undefined || inner.indexValue.kind === "dyn"))
             return DYN;
-        return { kind: "record", shapeId: shapes.intern(inner.fields, false, inner.indexValue, inner.declaredOrder) };
+        return {
+            kind: "record",
+            shapeId: shapes.intern(inner.fields, false, inner.indexValue, inner.declaredOrder),
+        };
     }
     finally {
         shapes.inProgress.delete(widened);
@@ -3734,7 +4093,9 @@ function mapRecordTypeInner(widened, ctx) {
     if (indexInfos.length > 0) {
         const stringKey = (k) => (k.flags & ts.TypeFlags.String) !== 0 ||
             (k.isIntersectionType() &&
-                ts.constituentTypes(k).every((p) => (p.flags & ts.TypeFlags.String) !== 0 ||
+                ts
+                    .constituentTypes(k)
+                    .every((p) => (p.flags & ts.TypeFlags.String) !== 0 ||
                     ((p.flags & ts.TypeFlags.Object) !== 0 &&
                         checker.getPropertiesOfType(p).length === 0 &&
                         checker.getCallSignatures(p).length === 0 &&
@@ -3777,7 +4138,9 @@ function mapRecordTypeInner(widened, ctx) {
     // merge machinery cannot do.
     if (indexValue?.kind === "union") {
         const slotDef = ctx.unions.get(indexValue.unionId);
-        const armOk = (a) => a.kind === "f64" || a.kind === "string" || a.kind === "undefinedT" ||
+        const armOk = (a) => a.kind === "f64" ||
+            a.kind === "string" ||
+            a.kind === "undefinedT" ||
             (a.kind === "array" && a.elem.kind === "string");
         // A pure Dict<string[]> is the distinct-header shape, not a general
         // outgoing-header slot: retain its precise string[] | undefined value
@@ -3788,7 +4151,8 @@ function mapRecordTypeInner(widened, ctx) {
             slotDef.arms.length === 2 &&
             slotDef.arms.some((a) => a.kind === "array" && a.elem.kind === "string") &&
             slotDef.arms.some((a) => a.kind === "undefinedT");
-        if (slotDef !== undefined && !distinctOnly &&
+        if (slotDef !== undefined &&
+            !distinctOnly &&
             slotDef.arms.some((a) => a.kind === "array" && a.elem.kind === "string") &&
             slotDef.arms.every(armOk)) {
             const armsRaw = [F64, STRING, arrayOf(STRING), UNDEFINED_T];
@@ -3803,7 +4167,9 @@ function mapRecordTypeInner(widened, ctx) {
                 }
                 return armOk(t);
             };
-            if (checker.getPropertiesOfType(widened).every((p) => fits(mapType(checker.getTypeOfSymbol(p), ctx)))) {
+            if (checker
+                .getPropertiesOfType(widened)
+                .every((p) => fits(mapType(checker.getTypeOfSymbol(p), ctx)))) {
                 return { kind: "record", shapeId: shapes.intern([], false, canonical, []) };
             }
         }
@@ -3833,6 +4199,8 @@ function mapRecordTypeInner(widened, ctx) {
     const computed = widened.isIntersectionType() || isMappedShape(widened);
     {
         const props = checker.getPropertiesOfType(widened);
+        if (ctx.classImplementedProtocol?.(widened))
+            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("__@")))
@@ -3862,11 +4230,15 @@ 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 &&
+                checker.declarationsOf(anonSym).some((d) => ts.isObjectLiteralExpression(d)))) {
             return DYN;
         }
         const fields = [];
-        for (const p of props) {
+        for (let propertyIndex = 0; propertyIndex < props.length; propertyIndex++) {
+            if (propertyIndex % 32 === 0)
+                checker.prefetchMemberTypes(props, propertyIndex);
+            const p = props[propertyIndex];
             if (p.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
                 // OBJECT-LITERAL get/set accessors (TS sources): the property has
                 // no data slot — the shape carries reserved closure fields instead
@@ -3917,7 +4289,10 @@ function mapRecordTypeInner(widened, ctx) {
                     // A void/unit-typed write slot has no value form; DIVERGENT
                     // getter/setter types stay out too (one property, one type —
                     // the class-accessor stance).
-                    if (writeT === null || writeT.kind === "void" || writeT.kind === "jsval" || isUnitType(writeT))
+                    if (writeT === null ||
+                        writeT.kind === "void" ||
+                        writeT.kind === "jsval" ||
+                        isUnitType(writeT))
                         return null;
                     if (readT !== null && typeKey(readT) !== typeKey(writeT))
                         return null;
@@ -3954,7 +4329,9 @@ function mapRecordTypeInner(widened, ctx) {
             // initializer is an EMPTY array literal inside a const assertion IS
             // the empty tuple — map it exactly as the tuple branch does (the
             // unit-element array; see the `[] as const` rule there).
-            if ((pt === null || pt.kind === "jsval") && (fieldTs.flags & ts.TypeFlags.Any) !== 0 && constAssertedEmptyArrayProp(p, ctx)) {
+            if ((pt === null || pt.kind === "jsval") &&
+                (fieldTs.flags & ts.TypeFlags.Any) !== 0 &&
+                constAssertedEmptyArrayProp(p, ctx)) {
                 pt = arrayOf(unitOnlyUnion(ctx.unions));
             }
             if (pt === null && !ctx.dynamic && (fieldTs.flags & ts.TypeFlags.Any) !== 0)
@@ -4081,7 +4458,9 @@ export function describeComponentBlocker(widened, ctx) {
     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()))
+        checker
+            .declarationsOf(psym)
+            .some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()))
         ? psym.name
         : undefined;
     if (container !== undefined) {
@@ -4094,13 +4473,18 @@ export function describeComponentBlocker(widened, ctx) {
             if (!mapped) {
                 return `the ${container} shape is supported, but its ${role} type '${text(arg)}' does not compile`;
             }
-            if ((container === "Map" || container === "ReadonlyMap") && i === 0 && !isSupportedMapKey(mapped, mapped.kind === "union" ? ctx.unions.get(mapped.unionId)?.arms : undefined)) {
+            if ((container === "Map" || container === "ReadonlyMap") &&
+                i === 0 &&
+                !isSupportedMapKey(mapped, mapped.kind === "union" ? ctx.unions.get(mapped.unionId)?.arms : undefined)) {
                 return `the ${container} shape is supported, but '${text(arg)}' is outside its supported key domain (numbers, strings, booleans, bigints, identity references, or supported unions)`;
             }
-            if ((container === "Map" || container === "ReadonlyMap") && i === 1 && !isSupportedMapValue(mapped)) {
+            if ((container === "Map" || container === "ReadonlyMap") &&
+                i === 1 &&
+                !isSupportedMapValue(mapped)) {
                 return `the ${container} shape is supported, but '${text(arg)}' values have no Map slot yet`;
             }
-            if ((container === "Set" || container === "ReadonlySet") && !isSupportedSetElem(mapped, mapped.kind === "union" ? ctx.unions.get(mapped.unionId)?.arms : undefined)) {
+            if ((container === "Set" || container === "ReadonlySet") &&
+                !isSupportedSetElem(mapped, mapped.kind === "union" ? ctx.unions.get(mapped.unionId)?.arms : undefined)) {
                 return `the ${container} shape is supported, but '${text(arg)}' is outside its supported element domain (numbers, strings, booleans, bigints, identity references, or supported unions)`;
             }
         }
@@ -4181,8 +4565,7 @@ export function describeComponentBlocker(widened, ctx) {
         const sigDecl = checker.signatureDeclaration(sig);
         if (sigDecl !== undefined &&
             ts.isFunctionLike(sigDecl) &&
-            (sigDecl.parameters.length !== sig.getParameters().length ||
-                bodyReadsArguments(sigDecl))) {
+            (sigDecl.parameters.length !== 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()) {