@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/type-mapper.js

@@ -1,12 +1,14 @@
 import { InternalCompilerError } from "../errors.js";
+import { keyedHelperName } from "./lowering/stable-names.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, 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 { 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, iterableArmsElem, 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, KEY_ORDER_FIELD } from "../ir/ir.js";
 import { literalValues } from "./literal-values.js";
 import { remapUnionDiscriminant } from "./union-discriminants.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
+import { isProvenanceSourceFile } from "./provenance-registry.js";
 import { functionCanReturnUndefined } from "./function-completion.js";
 import { accessorSlotProp, recordTextCodecClass } from "../ir/ir.js";
 // typeKey moved to ir/ir.ts (the backend needs it too, for per-type
@@ -85,6 +87,46 @@ export const WEBCRYPTO_DYN_TYPES = new Set([
     "KeyAlgorithm",
     "HmacImportParams",
     "HmacKeyAlgorithm",
+    "CryptoKeyPair",
+    "EcKeyAlgorithm",
+    "RsaHashedKeyAlgorithm",
+    "EcKeyGenParams",
+    "EcKeyImportParams",
+    "EcdsaParams",
+    "RsaHashedKeyGenParams",
+    "RsaHashedImportParams",
+    "RsaPssParams",
+    "HmacKeyGenParams",
+    "AesKeyGenParams",
+    "AesKeyAlgorithm",
+    "JsonWebKey",
+    "AesGcmParams",
+    "AesCbcParams",
+    "AesCtrParams",
+    "Pbkdf2Params",
+    "HkdfParams",
+    "AesDerivedKeyParams",
+]);
+/** node:crypto's key and signature option interfaces: the key functions,
+ * KeyObject.export and sign/verify take them as checked-dynamic arguments
+ * (scr_lib.c, scr_pki.c). */
+export const CRYPTO_KEY_OPTION_DYN_TYPES = new Set([
+    "AsymmetricKeyExportOptions",
+    "ECKeyPairKeyObjectOptions",
+    "ECKeyPairOptions",
+    "ED25519KeyPairOptions",
+    "JsonWebKeyInput",
+    "JwkKeyExportOptions",
+    "KeyExportOptions",
+    "PrivateKeyInput",
+    "PublicKeyInput",
+    "RSAKeyPairKeyObjectOptions",
+    "RSAKeyPairOptions",
+    "SignKeyObjectInput",
+    "SignPrivateKeyInput",
+    "SigningOptions",
+    "VerifyKeyObjectInput",
+    "VerifyPublicKeyInput",
 ]);
 export const FETCH_AMBIENT_TYPES = [
     "Response",
@@ -108,6 +150,9 @@ export const FETCH_AMBIENT_TYPES = [
     "ReadableStreamReadResult",
     "ReadableStreamReadValueResult",
     "ReadableStreamReadDoneResult",
+    "TransformStream",
+    "WritableStream",
+    "WritableStreamDefaultWriter",
     "Blob",
     "File",
     "BlobPropertyBag",
@@ -179,6 +224,8 @@ function comparePriority(left, right) {
 export class ShapeRegistry {
     /** Existing layouts change only when a recursive placeholder closes. */
     revision = 0;
+    /** Each shape id with a second hash of its key (keyedHelperName). */
+    keyedNameKeys = new Map();
     byKey = new Map();
     byId = new Map();
     /** Historical emit-order rank of the declaration-order metadata each
@@ -194,7 +241,7 @@ export class ShapeRegistry {
      * writer after all priority candidates have closed. */
     derivedDeclaredOrderFinalizers = [];
     currentDeclaredOrderPriority = [0, 0];
-    /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */
+    /** All interned shapes in first-seen order. */
     shapes = [];
     /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is
      * the recursive knot (`interface TreeNode { children: TreeNode[] }`):
@@ -299,11 +346,12 @@ export class ShapeRegistry {
     }
     /** The shape id a back-reference to an in-progress type resolves to:
      * reuses the type's persistent recursive id or mints a PLACEHOLDER
-     * entry (empty fields) the outer frame finalizes. */
-    recursiveRef(t) {
+     * entry (empty fields) the outer frame finalizes. `describe` names a new
+     * placeholder (checkerTypeDescription). */
+    recursiveRef(t, describe) {
         let id = this.recIds.get(t);
         if (id === undefined) {
-            id = `r${this.shapes.length}`;
+            id = recursivePlaceholderName(this, "r", describe(), (name) => this.byId.has(name));
             const shape = { id, fields: [] };
             this.byId.set(id, shape);
             this.shapes.push(shape);
@@ -358,7 +406,7 @@ export class ShapeRegistry {
         const key = this.keyOf(fields, tuple, indexValue);
         let id = this.byKey.get(key);
         if (id === undefined) {
-            id = `r${this.shapes.length}`;
+            id = keyedHelperName(this, "r", key, "");
             const shape = {
                 id,
                 fields,
@@ -401,6 +449,20 @@ export class ShapeRegistry {
         const missing = extra.filter((name) => !order.includes(name));
         return missing.length === 0 ? order : [...order, ...missing];
     }
+    /** Gives a shape with orderVariants its KEY_ORDER_FIELD, in place,
+     * after the bodies lowered (key-order-witness.ts adds the field to each
+     * of the shape's literals). Allocation zeroes it, which every other
+     * construction keeps. */
+    addKeyOrderField(shapeId) {
+        const shape = this.byId.get(shapeId);
+        if (!shape || shape.fields.some((f) => f.name === KEY_ORDER_FIELD))
+            return;
+        shape.fields = [...shape.fields, { name: KEY_ORDER_FIELD, type: F64 }].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        this.revision++;
+        const key = this.keyOf(shape.fields, false, shape.indexValue);
+        if (!this.byKey.has(key))
+            this.byKey.set(key, shapeId);
+    }
     /** 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
@@ -434,6 +496,44 @@ export class ShapeRegistry {
             this.byKey.set(key, shapeId);
     }
 }
+/** The id of a recursive placeholder described by `description`. Two
+ * different types can still share a description (checkerTypeDescription stops
+ * after a few levels of type arguments); the later one takes the first free
+ * name with a numbered suffix. */
+function recursivePlaceholderName(owner, prefix, description, taken) {
+    let name = keyedHelperName(owner, prefix, `recursive:${description}`, "");
+    for (let n = 1; taken(name); n++)
+        name = keyedHelperName(owner, prefix, `recursive:${description}#${n}`, "");
+    return name;
+}
+/** How many levels of type arguments checkerTypeDescription describes. */
+const RECURSIVE_NAME_DEPTH = 3;
+/** A checker type's description for names that must not depend on checker
+ * type ids (a recursive placeholder, a generic class instance keyed by a
+ * literal): its printed form, the structural position of its first
+ * declaration, and the same for its type arguments (two instantiations
+ * print the same when their type arguments are type parameters or classes
+ * of the same name from different declarations). */
+export function checkerTypeDescription(t, ctx, depth = 0) {
+    const symbol = t.getAliasSymbol() ?? t.getSymbol();
+    const declaration = symbol?.declarations[0];
+    const where = declaration
+        ? (ctx.positionOf?.(declaration) ??
+            `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}`)
+        : "";
+    let description = `${ctx.checker.typeToString(t)}@${where}`;
+    if (depth < RECURSIVE_NAME_DEPTH) {
+        const aliasArguments = t.getAliasSymbol() !== undefined ? (t.getAliasTypeArguments() ?? []) : [];
+        const typeArguments = aliasArguments.length > 0
+            ? aliasArguments
+            : t.isTypeReference()
+                ? ctx.checker.getTypeArguments(t)
+                : [];
+        if (typeArguments.length > 0)
+            description += `<${typeArguments.map((arg) => checkerTypeDescription(arg, ctx, depth + 1)).join(",")}>`;
+    }
+    return description;
+}
 /** The frontend's union interner — mirrors ShapeRegistry. A union's
  * canonical identity includes its typeKey-sorted arms and literal
  * discriminator contract. An arm's index in that list IS its runtime tag.
@@ -441,10 +541,12 @@ export class ShapeRegistry {
 export class UnionRegistry {
     /** Existing arm/discriminator contracts change when a placeholder closes. */
     revision = 0;
+    /** Each union id with a second hash of its key (keyedHelperName). */
+    keyedNameKeys = new Map();
     byKey = new Map();
     byId = new Map();
     armTags = new Map();
-    /** All interned unions in first-seen (`u0`, `u1`, ...) order. */
+    /** All interned unions in first-seen order. */
     unions = [];
     /** ts.Types currently being mapped — a back-reference to one is the
      * recursive knot passing through a union (`type Tree = Leaf | Branch`
@@ -459,11 +561,12 @@ export class UnionRegistry {
     pendingRec = new Set();
     /** The union id a back-reference to an in-progress union resolves to:
      * reuses the type's persistent recursive id or mints a PLACEHOLDER
-     * entry (empty arms) the outer frame finalizes. */
-    recursiveRef(t) {
+     * entry (empty arms) the outer frame finalizes. `describe` names a new
+     * placeholder (checkerTypeDescription). */
+    recursiveRef(t, describe) {
         let id = this.recIds.get(t);
         if (id === undefined) {
-            id = `u${this.unions.length}`;
+            id = recursivePlaceholderName(this, "u", describe(), (name) => this.byId.has(name));
             const def = { id, arms: [] };
             this.byId.set(id, def);
             this.unions.push(def);
@@ -509,7 +612,7 @@ export class UnionRegistry {
         const key = JSON.stringify([arms.map(typeKey), discriminant]);
         let id = this.byKey.get(key);
         if (id === undefined) {
-            id = `u${this.unions.length}`;
+            id = keyedHelperName(this, "u", key, "");
             const def = { id, arms, ...(discriminant ? { discriminant } : {}) };
             this.byKey.set(key, id);
             this.byId.set(id, def);
@@ -980,7 +1083,7 @@ function genChannels(yieldTs, retTs, nextTs, ctx) {
             : mapType(nextTs, ctx);
     if (!nextT || nextT.kind === "void" || nextT.kind === "nullT")
         return null;
-    const ownChannel = (t) => t.kind === "f64" || t.kind === "bool" || t.kind === "string";
+    const ownChannel = (t) => t.kind === "f64" || t.kind === "bool" || t.kind === "string" || t.kind === "record";
     const dynMix = (yieldT.kind === "dyn" && retT.kind !== "dyn" && retT.kind !== "void" && !ownChannel(retT)) ||
         (retT.kind === "dyn" && yieldT.kind !== "dyn" && yieldT.kind !== "void" && !ownChannel(yieldT));
     if (dynMix)
@@ -1325,10 +1428,18 @@ export function mapType(type, ctx) {
         if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
             return BOOL;
     }
+    const localValue = ctx.localClassValue?.(type);
+    if (localValue) {
+        contextResolutions++;
+        return localValue;
+    }
     const topLevel = mapTypeDepth === 0;
     const typeId = type.id;
     const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true);
-    const memoKey = memoizable ? `${0}:${typeId}` : null;
+    // An empty literal's type maps to the empty record as an unreduced union's
+    // arm (emptyLiteralArm) and to the checked-dynamic value elsewhere: the two
+    // answers keep separate memo entries.
+    const memoKey = memoizable ? `${ctx.emptyLiteralArm ? 1 : 0}:${typeId}` : null;
     if (memoKey !== null) {
         const memo = ctx.typeMemo?.get(memoKey);
         if (memo !== undefined)
@@ -1395,9 +1506,15 @@ 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 (intrinsic !== undefined &&
-        ts.symbolName(intrinsic) === "globalThis" &&
-        intrinsic.declarations.length === 0)
+    const isIntrinsicGlobal = (symbol) => symbol !== undefined &&
+        ts.symbolName(symbol) === "globalThis" &&
+        symbol.declarations.length === 0;
+    if (isIntrinsicGlobal(intrinsic))
+        return DYN;
+    // `typeof globalThis & { key?: T }` (the global-singleton spelling) is the
+    // same global object with declared extra members.
+    if (type.isIntersectionType() &&
+        ts.constituentTypes(type).some((part) => isIntrinsicGlobal(part.getSymbol())))
         return DYN;
     if (ctx.jsDynamicDeclaration !== undefined && intrinsic !== undefined) {
         const objectLiteral = (intrinsic.flags & ts.SymbolFlags.ObjectLiteral) !== 0;
@@ -1900,6 +2017,23 @@ function mapTypeInner(type, ctx) {
             return arrayOf(unitOnlyUnion(unions));
         if (tupleShape?.elementFlags === undefined)
             return null;
+        // A leading-required tuple ending in a rest element whose positions
+        // all share one type (`[string, ...string[]]`, the non-empty list)
+        // is an array of that type: every read, write and method behaves as
+        // the array's, and tsc already proves the required positions exist.
+        const flags = tupleShape.elementFlags;
+        if (flags.length >= 2 &&
+            (flags[flags.length - 1] & ts.ElementFlags.Rest) !== 0 &&
+            flags.slice(0, -1).every((f) => (f & ts.ElementFlags.Required) !== 0)) {
+            const elems = args.map((a) => mapType(a, ctx));
+            const first = elems[0];
+            if (first &&
+                first.kind !== "void" &&
+                isSupportedArrayElem(first) &&
+                elems.every((e) => e !== null && typeEquals(e, first)))
+                return arrayOf(first);
+            return null;
+        }
         // Optional/rest elements have no fixed native tuple layout.
         if (tupleShape.elementFlags.some((f) => !(f & ts.ElementFlags.Required))) {
             return null;
@@ -2119,6 +2253,25 @@ function mapTypeInner(type, ctx) {
                 return { kind: "classval", className: inst.className };
             }
         }
+        // A constructable declared in the program whose instances are not one
+        // program class's (`new () => unknown`, `abstract new () => S` over a
+        // record, a type that also names static members such as `{ readonly
+        // schema: unknown; new (): unknown }`, construct overloads): the class
+        // value rides the checked-dynamic tree, as an `unknown` slot already
+        // holds one. `new` through it and static reads dispatch at run time,
+        // and the constructed value checks into the signature's instance type.
+        // Lib and package constructables keep their fences, and so do those of
+        // fetched provenance sources (third-party code under its own policies:
+        // an unused `@__PURE__` const typed `{ new (): any }` elides there).
+        if (ctorSigs.length > 0 &&
+            checker.getCallSignatures(widened).length === 0 &&
+            (widened.getSymbol()?.declarations.length ?? 0) > 0 &&
+            widened.getSymbol().declarations.every((d) => {
+                const sf = ts.getSourceFileOfNode(d);
+                return ctx.isProgramFile(sf) && !isProvenanceSourceFile(sf.fileName);
+            })) {
+            return DYN;
+        }
     }
     // Map<K, V>: a reference to the standard library's Map interface —
     // provenance, not the name (a user's own `interface Map` maps as a record
@@ -2441,18 +2594,38 @@ function mapTypeInner(type, ctx) {
             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.
+    // node:crypto's KeyObject: secret keys (scr_lib.c) and private and
+    // public keys (scr_pki.c) are native handles whose getters and methods
+    // dispatch through the handle. The JsonWebKey that export() returns is a
+    // plain checked-dynamic object.
     if (((psym !== undefined && ts.symbolName(psym) === "KeyObject") ||
         (psym !== undefined && ts.symbolName(psym) === "JsonWebKey")) &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
+    // node:crypto's key and signature options are plain checked-dynamic
+    // objects, so a value asserted to one (`opts as
+    // crypto.AsymmetricKeyExportOptions<"pem">`) reaches the call unchanged.
+    if (psym !== undefined &&
+        CRYPTO_KEY_OPTION_DYN_TYPES.has(ts.symbolName(psym)) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        return DYN;
+    }
+    // node:crypto's Sign and Verify (createSign/createVerify): native
+    // handles over the digest state (scr_pki.c).
+    if (psym !== undefined &&
+        (ts.symbolName(psym) === "Sign" || ts.symbolName(psym) === "Verify") &&
+        psym.declarations.some((d) => ts.isClassDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        return DYN;
+    }
     if (psym &&
         FETCH_AMBIENT_TYPES.includes(ts.symbolName(psym)) &&
-        !(ts.symbolName(psym) === "ReadableStream" &&
+        !((ts.symbolName(psym) === "ReadableStream" || ts.symbolName(psym) === "WritableStream") &&
             psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS"))) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
@@ -2487,6 +2660,18 @@ function mapTypeInner(type, ctx) {
         psym.declarations.some((d) => ts.isClassDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
+    // node:crypto DiffieHellman values, and @types/node's DiffieHellmanGroup
+    // alias over them, are native handles carried by the checked-dynamic
+    // representation; lowerDiffieHellmanCall dispatches their methods.
+    {
+        const dhSym = widened.getAliasSymbol() ?? psym;
+        if (dhSym !== undefined &&
+            (ts.symbolName(dhSym) === "DiffieHellman" || ts.symbolName(dhSym) === "DiffieHellmanGroup") &&
+            dhSym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isTypeAliasDeclaration(d)) &&
+                ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            return DYN;
+        }
+    }
     // ReadonlyMap/ReadonlySet are the SAME runtime values as Map/Set — the
     // readonly-ness is a checker-only view (no mutating members on the
     // interface), so both map to the identical IR kinds and the read-side
@@ -2508,6 +2693,9 @@ function mapTypeInner(type, ctx) {
     // The runtime rejects reference kinds without a weak lifetime contract.
     if (isStdlibInterface("WeakMap") || isStdlibInterface("WeakSet"))
         return DYN;
+    // FinalizationRegistry is a native handle with register and unregister.
+    if (isStdlibInterface("FinalizationRegistry"))
+        return DYN;
     // Set<T>: Map's sibling — same provenance rule and key domain.
     // Anything else stays unmapped;
     // the `new Set` lowering names the offending element type specifically.
@@ -3114,9 +3302,10 @@ 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. A number,
-    // boolean or string channel keeps its own type beside a dyn one (the
-    // `Generator<number>` defaults): its values ride OUT typed and box only
-    // when the result record is built.
+    // boolean, string or record channel keeps its own type beside a dyn one
+    // (the `Generator<number>` and `IterableIterator<Row>` defaults): its
+    // values ride OUT typed and box only when the result record is built, so
+    // for-of and spread read them back unchecked.
     if (isStdlibInterface("Generator") ||
         isStdlibInterface("AsyncGenerator") ||
         isStdlibInterface("IterableIterator") ||
@@ -3140,6 +3329,14 @@ function mapTypeInner(type, ctx) {
             ...channels,
         };
     }
+    // Iterable<T>: the iterable union (iterableUnionType) — the source value
+    // itself in its own arm, so an array stays the same multi-pass object and
+    // a generator stays single-pass.
+    if (isStdlibInterface("Iterable")) {
+        const arg = checker.getTypeArguments(widened)[0];
+        const elem = arg ? mapType(arg, ctx) : null;
+        return elem ? iterableUnionType(elem, ctx.shapes, unions) : null;
+    }
     // IteratorResult<T, TReturn> — the checker's type of `g.next()` (an
     // alias for IteratorYieldResult<T> | IteratorReturnResult<TReturn>):
     // maps to the SAME interned record genResume answers, so `const r =
@@ -3257,6 +3454,13 @@ function mapTypeInner(type, ctx) {
         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) };
     }
+    // crypto.getCipherInfo's result is Node's info object itself, read as a
+    // checked-dynamic value: Node leaves out the fields a cipher lacks,
+    // including the nid the declaration requires, so a record cannot hold
+    // every result.
+    if (isStdlibInterface("CipherInfo") &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientModule(d, "crypto")))
+        return DYN;
     // Filesystem options are data records. Keep their declared optional fields
     // instead of allowing arbitrary standard-library interfaces into records.
     if (((psym !== undefined && ts.symbolName(psym) === "FileReadOptions") ||
@@ -3466,6 +3670,32 @@ function mapTypeInner(type, ctx) {
             };
         }
     }
+    // crypto.generateKeyPairSync's results: KeyPairKeyObjectResult and
+    // KeyPairSyncResult<T1, T2> as { publicKey, privateKey } records over the
+    // mapped property types (KeyObjects, PEM strings or DER Buffers), in
+    // Node's key order.
+    if (psym !== undefined &&
+        (ts.symbolName(psym) === "KeyPairKeyObjectResult" ||
+            ts.symbolName(psym) === "KeyPairSyncResult") &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        const field = (name) => {
+            const prop = ctx.checker.getPropertyOfType(type, name);
+            return prop ? mapType(ctx.checker.getTypeOfSymbol(prop), ctx) : null;
+        };
+        const publicKey = field("publicKey");
+        const privateKey = field("privateKey");
+        if (!publicKey || !privateKey)
+            return null;
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "privateKey", type: privateKey },
+                { name: "publicKey", type: publicKey },
+            ], false, undefined, ["publicKey", "privateKey"]),
+        };
+    }
     // crypto.X509Certificate — the Dirent-style data record: THREE visible
     // fields (fingerprint and the validFrom/validTo validity window, all
     // computed at construction by the new-expression lowering). Module-
@@ -3872,7 +4102,10 @@ function mapTypeInner(type, ctx) {
         if (knownRecursive !== undefined)
             return { kind: "union", unionId: knownRecursive };
         if (unions.inProgress.has(widened)) {
-            return { kind: "union", unionId: unions.recursiveRef(widened) };
+            return {
+                kind: "union",
+                unionId: unions.recursiveRef(widened, () => checkerTypeDescription(widened, ctx)),
+            };
         }
         unions.inProgress.add(widened);
         const sensitivityAtEntry = contextResolutions;
@@ -3896,6 +4129,14 @@ function mapTypeInner(type, ctx) {
                     (part.getSymbol()?.declarations.some((d) => ctx.isStdlibFile(d.getSourceFile())) ?? false));
             };
             const hasArrayPart = parts.some((part) => checker.isArrayType(part) || matchArray(part));
+            // Subtype reduction removes every arm assignable to `{}`, so a union
+            // that keeps another non-nullish arm beside an empty literal's `{}`
+            // was not reduced: that `{}` arm holds only the literal's objects.
+            const nullish = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+            const literalEmptyArms = parts.some((part) => isEmptyObjectLiteralType(part, ctx)) &&
+                parts.some((part) => (part.flags & nullish) === 0 &&
+                    !checker.isNeverType(part) &&
+                    !isEmptyObjectLiteralType(part, ctx));
             for (const part of parts) {
                 if (hasArrayPart && emptyTuple(part))
                     continue;
@@ -3916,7 +4157,19 @@ function mapTypeInner(type, ctx) {
                     byKey.set(typeKey(NULL_T), NULL_T);
                     continue;
                 }
-                const mapped = mapType(part, ctx);
+                let mapped;
+                if (literalEmptyArms && isEmptyObjectLiteralType(part, ctx)) {
+                    ctx.emptyLiteralArm = true;
+                    try {
+                        mapped = mapType(part, ctx);
+                    }
+                    finally {
+                        ctx.emptyLiteralArm = false;
+                    }
+                }
+                else {
+                    mapped = mapType(part, ctx);
+                }
                 if (!mapped) {
                     return null;
                 }
@@ -3986,7 +4239,9 @@ function mapTypeInner(type, ctx) {
                 a.kind === "union" ||
                 a.kind === "date" ||
                 a.kind === "dyn" ||
-                a.kind === "generator") ||
+                // A generator arm only comes from an Iterable<T> (an optional
+                // one keeps its unit arms beside the iterable union's).
+                (a.kind === "generator" && iterableArmsElem(arms) === null)) ||
                 !maybePromiseUnionOk(parts, arms, ctx)) {
                 return null;
             }
@@ -4789,6 +5044,53 @@ function constAssertedEmptyArrayProp(p) {
         return false;
     return underConstAssertion(d);
 }
+/** A TypeScript property assignment `name: []` whose type is `never[]`. */
+function emptyNeverArrayProp(p, fieldTs, checker) {
+    const d = p.valueDeclaration;
+    if (d === undefined || !ts.isPropertyAssignment(d))
+        return false;
+    if (isJsSourceFile(ts.getSourceFileOfNode(d)))
+        return false;
+    if (!ts.isArrayLiteralExpression(d.initializer) || d.initializer.elements.nodes.length > 0)
+        return false;
+    return (checker.isArrayType(fieldTs) &&
+        (checker.getTypeArguments(fieldTs)[0].flags & ts.TypeFlags.Never) !== 0);
+}
+/** A JavaScript object literal's property typed `never[]` (`{ issues: [] }`).
+ * Nothing checks a JavaScript file's later writes, which can push any value
+ * onto it (`ctx.common.issues.push(issue)`), so it holds the checked-dynamic
+ * array rather than never's f64 element array. */
+function jsNeverArrayProp(p, fieldTs, checker) {
+    return (jsObjectLiteralProperty(p) &&
+        checker.isArrayType(fieldTs) &&
+        (checker.getTypeArguments(fieldTs)[0].flags & ts.TypeFlags.Never) !== 0);
+}
+/** A JavaScript object literal's property (`{ lastComponent: undefined }`,
+ * `{ user: null }`). Nothing checks a JavaScript file's later writes, which
+ * can store any value in it (`path.lastComponent = { ... }`), so a
+ * property whose only initializer is a unit holds the checked-dynamic value
+ * rather than the unit-only union. */
+function isUnitOnlyIr(t, ctx) {
+    if (t.kind !== "union")
+        return false;
+    const def = ctx.unions.get(t.unionId);
+    return def !== undefined && def.arms.every((arm) => isUnitType(arm));
+}
+/** A property a JavaScript object literal declares. The checker also adds
+ * each missing property, optional and `undefined`, to every literal of a
+ * union of literals (`{ _tag, value } | { _tag, error }` gains
+ * `error?: undefined` and `value?: undefined`); those keep their unit-only
+ * type, so a literal still converts to the one arm whose properties it
+ * has. */
+function jsObjectLiteralProperty(p) {
+    const d = p.valueDeclaration;
+    // `__proto__: null` sets the literal's prototype; it declares no property.
+    return (d !== undefined &&
+        (ts.isPropertyAssignment(d) || ts.isShorthandPropertyAssignment(d)) &&
+        ts.symbolName(p) !== "__proto__" &&
+        (p.flags & ts.SymbolFlags.Optional) === 0 &&
+        isJsSourceFile(ts.getSourceFileOfNode(d)));
+}
 function mapGenericAwaitedAlias(type, ctx) {
     const { resolveTypeParam } = ctx;
     if (!resolveTypeParam)
@@ -5050,7 +5352,8 @@ function evalMappedTemplate(type, keys, aliases, ctx) {
         const checked = evalMappedTemplate(checkType, keys, scope, ctx);
         if (!checked)
             return null;
-        const inferred = matchInferReference(checked, extendsType, ctx);
+        const inferred = primitiveExtendsCheck(checked, extendsType, ctx) ??
+            matchInferReference(checked, extendsType, ctx);
         if (inferred === undefined)
             return null;
         const branch = inferred ? type.getTrueType() : type.getFalseType();
@@ -5059,6 +5362,24 @@ function evalMappedTemplate(type, keys, aliases, ctx) {
     }
     return mentionsMappedParams(type, keys, aliases) ? null : type;
 }
+/** `checked extends X` where X is a primitive or literal type, or a union of
+ * them (`K extends "required" ? ...`), and `checked` is one such type:
+ * X has no infer positions, so assignability decides the branch (an empty
+ * binding map for the true branch). A union `checked` distributes and stays
+ * undecided here (undefined), as do other shapes. */
+function primitiveExtendsCheck(checked, extendsType, ctx) {
+    const primitive = ts.TypeFlags.StringLike |
+        ts.TypeFlags.NumberLike |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.BigIntLike |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Undefined;
+    const isPrimitive = (t) => !t.isUnionType() && (t.flags & primitive) !== 0 && (t.flags & ts.TypeFlags.TypeParameter) === 0;
+    const extendsParts = extendsType.isUnionType() ? ts.constituentTypes(extendsType) : [extendsType];
+    if (!isPrimitive(checked) || !extendsParts.every(isPrimitive))
+        return undefined;
+    return ctx.checker.isTypeAssignableTo(checked, extendsType) ? new Map() : false;
+}
 /** `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
@@ -5332,6 +5653,40 @@ export function unitOnlyUnion(unions) {
     arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
     return { kind: "union", unionId: unions.intern(arms) };
 }
+/** `Iterable<T>`: a union whose arms are the sources that keep their own
+ * representation — `T[]`, a `Set<T>`, a `Map<K, V>` (T the `[K, V]`
+ * tuple), a string (T string) — and a generator over T, which also holds
+ * every other iterator (Map/Set and array iterators adapt into one). The
+ * generator arm marks the union as iterable (iterableArmsElem): no other
+ * union has one. Null when T has no array or generator form. */
+export function iterableUnionType(elem, shapes, unions) {
+    if (elem.kind === "void" || elem.kind === "generator" || !isSupportedArrayElem(elem))
+        return null;
+    if (!genResultRecord(elem, VOID, shapes, unions))
+        return null;
+    const arms = [
+        { kind: "array", elem },
+        { kind: "generator", yieldT: elem, retT: VOID, nextT: UNDEFINED_T },
+    ];
+    const elemArms = elem.kind === "union" ? unions.get(elem.unionId)?.arms : undefined;
+    if (isSupportedSetElem(elem, elemArms))
+        arms.push({ kind: "set", elem });
+    if (elem.kind === "string")
+        arms.push(STRING);
+    if (elem.kind === "record") {
+        const shape = shapes.get(elem.shapeId);
+        const [k, v] = shape?.fields ?? [];
+        if (shape?.tuple &&
+            shape.fields.length === 2 &&
+            k?.name === "0" &&
+            v?.name === "1" &&
+            isSupportedMapKey(k.type, k.type.kind === "union" ? unions.get(k.type.unionId)?.arms : undefined) &&
+            isSupportedMapValue(v.type))
+            arms.push({ kind: "map", key: k.type, value: v.type });
+    }
+    arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    return { kind: "union", unionId: unions.intern(arms) };
+}
 /** The IteratorResult record of a generator's value channels: `{ done:
  * boolean, value: V }` where V is dyn (an any/unknown channel) or the
  * canonical union of the yield arms, the return arms (when the return
@@ -6067,7 +6422,10 @@ function mapRecordType(widened, ctx) {
     // frame completes (finalizeRecursive below). Backends represent records
     // as heap references, so the self-reference is an ordinary pointer.
     if (shapes.inProgress.has(widened)) {
-        return { kind: "record", shapeId: shapes.recursiveRef(widened) };
+        return {
+            kind: "record",
+            shapeId: shapes.recursiveRef(widened, () => checkerTypeDescription(widened, ctx)),
+        };
     }
     shapes.inProgress.add(widened);
     const sensitivityAtEntry = contextResolutions;
@@ -6451,6 +6809,24 @@ function wideningAddedProperties(type, props, ctx) {
     }
     return added;
 }
+/** Whether `type` is an interface one of whose `extends` clauses names a
+ * type the checker answers `any` (or an error type) for. */
+function interfaceExtendsAny(type, checker) {
+    const symbol = type.getSymbol();
+    if (symbol === undefined || (symbol.flags & ts.SymbolFlags.Interface) === 0)
+        return false;
+    for (const decl of symbol.declarations) {
+        if (!ts.isInterfaceDeclaration(decl))
+            continue;
+        for (const clause of decl.heritageClauses?.nodes ?? []) {
+            for (const base of clause.types.nodes) {
+                if ((checker.getTypeAtLocation(base).flags & ts.TypeFlags.Any) !== 0)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
 function mapRecordTypeInner(widened, ctx) {
     const { checker, shapes } = ctx;
     if (checker.getConstructSignatures(widened).length > 0)
@@ -6466,6 +6842,14 @@ function mapRecordTypeInner(widened, ctx) {
     const widenedSym = widened.getSymbol();
     if (widenedSym !== undefined && (widenedSym.flags & ts.SymbolFlags.Enum) !== 0)
         return null;
+    // An interface extending a type the checker answers `any` for (in the
+    // compiled world, a package type computed from members only its .d.ts
+    // declares, such as `interface P extends z.infer<typeof S>`) has members
+    // the checker cannot list: its own declared fields are not the whole
+    // object. The value is checked-dynamic, never a record of the declared
+    // fields alone.
+    if (interfaceExtendsAny(widened, checker))
+        return DYN;
     // An index signature maps to a hybrid shape: declared fields keep
     // struct slots, undeclared keys ride the shape's overflow map, valued
     // uniformly by the signature's value type (`unknown` → dyn — a model-pricing table's
@@ -6607,24 +6991,28 @@ function mapRecordTypeInner(widened, ctx) {
         // has zero declared members — the signature is the shape.
         if (computed && props.length === 0 && !indexValue)
             return null;
-        // A DECLARED empty object type — `{}` (spelled or the checker's shared
-        // intrinsic), `interface Empty {}` — is tsc's TOP type over non-nullish
-        // values: every number, string, record, array, function, or class
-        // instance is assignable into the slot, so the exact-record stance
-        // cannot hold it. It lowers like `unknown` (the dyn), the same rule
-        // as `object` and the lib's `Object`: assignments convert at the site
-        // (sources outside the checked-dynamic tree fence there, exactly as unknown does), reads
-        // narrow back out through the same checked casts. The type INFERRED
-        // from an empty object literal (`const o = {}`) stays the empty record
-        // — it describes a value the program built, not an annotation that
-        // admits everything — and computed empties (`Partial<T>` in a generic
-        // body) returned null above. Empty shapes WITH an index signature
-        // (`Record<string, T>`) are not empty: the signature is the shape.
+        // An empty object type — `{}` (spelled, the checker's shared
+        // intrinsic, or inferred from an empty object literal), `interface
+        // Empty {}` — is tsc's TOP type over non-nullish values: every number,
+        // string, record, array, function, or class instance is assignable
+        // into the slot, so the exact-record stance cannot hold it. It lowers
+        // like `unknown` (the dyn), the same rule as `object` and the lib's
+        // `Object`: assignments convert at the site (sources outside the
+        // checked-dynamic tree fence there, exactly as unknown does), reads
+        // narrow back out through the same checked casts. A literal's inferred
+        // `{}` is no exception: union subtype reduction folds primitives into
+        // it (`["12", {}]` is `{}[]`, `flag ? "x" : {}` is `{}`), and `let o =
+        // {}` admits `o = "x"`. As an arm beside another non-nullish arm (the
+        // union was not reduced, `string | {} | DataView`) it holds only the
+        // literal's objects and stays the empty record (emptyLiteralArm).
+        // Computed empties (`Partial<T>` in a generic body) returned null
+        // above. Empty shapes WITH an index signature (`Record<string, T>`) are
+        // not empty: the signature is the shape.
         if (props.length === 0 &&
             indexValue === undefined &&
             checker.getCallSignatures(widened).length === 0 &&
             checker.getConstructSignatures(widened).length === 0 &&
-            !(anonSym !== undefined && anonSym.declarations.some((d) => ts.isObjectLiteralExpression(d)))) {
+            !(ctx.emptyLiteralArm && isEmptyObjectLiteralType(widened, ctx))) {
             return DYN;
         }
         const fields = [];
@@ -6731,6 +7119,14 @@ function mapRecordTypeInner(widened, ctx) {
                 constAssertedEmptyArrayProp(p)) {
                 pt = arrayOf(unitOnlyUnion(ctx.unions));
             }
+            // A TypeScript property initialized with an empty literal and typed
+            // `never[]` (`const out = { files: [] }`) holds no element, so it maps
+            // like the empty tuple: the unit-only element array, which a
+            // destination's typed array field (`files: string[]`) receives through
+            // the checked empty-array lift. never's f64 element would make it a
+            // `number[]` field.
+            if (pt?.kind === "array" && emptyNeverArrayProp(p, fieldTs, checker))
+                pt = arrayOf(unitOnlyUnion(ctx.unions));
             if (pt === null && (fieldTs.flags & ts.TypeFlags.Any) !== 0)
                 pt = DYN;
             // An `any[]` field (`list: any[]` in an SDK's message type, also
@@ -6750,6 +7146,10 @@ function mapRecordTypeInner(widened, ctx) {
             // omits the undefined arm exactly like an omitted optional.
             if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs, ctx.resolveTypeParam))
                 pt = unitOnlyUnion(ctx.unions);
+            if (pt !== null && isUnitOnlyIr(pt, ctx) && jsObjectLiteralProperty(p))
+                pt = DYN;
+            if (pt?.kind === "array" && jsNeverArrayProp(p, fieldTs, checker))
+                pt = DYN;
             // dyn FIELDS map now (`{ v: unknown }`, `[string, unknown]` tuples):
             // the slot carries a dyn value exactly like an `unknown`-valued
             // overflow entry — same RC adapters, same dynFrom conversion on the
@@ -7225,4 +7625,17 @@ function innerBlockedMember(t, ctx, seen) {
     }
     return here;
 }
+/** The type tsc infers from an empty object literal (`{}` written as a
+ * value): no members, index signatures or signatures, declared by an object
+ * literal expression. */
+function isEmptyObjectLiteralType(type, ctx) {
+    const { checker } = ctx;
+    const symbol = type.getSymbol();
+    return (symbol !== undefined &&
+        symbol.declarations.some((d) => ts.isObjectLiteralExpression(d)) &&
+        checker.getPropertiesOfType(type).length === 0 &&
+        checker.getIndexInfosOfType(type).length === 0 &&
+        checker.getCallSignatures(type).length === 0 &&
+        checker.getConstructSignatures(type).length === 0);
+}
 //# sourceMappingURL=type-mapper.js.map