@scriptc/compiler 0.1.7 → 0.2.1

package/dist/frontend/type-mapper.js

@@ -1,14 +1,44 @@
 import { InternalCompilerError } from "../errors.js";
 import * as ts from "./ts7/adapter.js";
 import { bodyReadsArguments } from "./arguments-usage.js";
-import { 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, 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";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
-import { accessorSlotProp } from "../ir/ir.js";
+import { accessorSlotProp, recordTextCodecClass } from "../ir/ir.js";
 // typeKey moved to ir/ir.ts (the backend needs it too, for per-type
 // helper interning); re-exported here so frontend call sites keep their
 // import path.
 export { typeKey };
+/** Empty JS object inference describes no fixed layout. Keep these values
+ * in checked storage across fields, parameters and function signatures. */
+export function jsOpenObjectType(decl, type, shapes, unions) {
+    if (!decl || !isJsSourceFile(decl.getSourceFile()))
+        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;
+    // Numeric 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 &&
+        present[0].kind === "array" && present[0].elem.kind === "f64")
+        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 &&
+        present?.some((arm) => arm.kind === "object") &&
+        arms?.every((arm) => canConvertToDyn(arm, (id) => shapes.get(id), (id) => unions.get(id))))
+        return DYN;
+    if (present?.length !== 1 || present[0].kind !== "record")
+        return type;
+    const shape = shapes.get(present[0].shapeId);
+    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).
  * Static fetch gives Response, RequestInit, AbortController/AbortSignal, response
@@ -19,6 +49,7 @@ export { typeKey };
  * same names keep their ordinary structural representation. */
 export const ISLAND_AMBIENT_TYPES = [
     "Response",
+    "Request",
     "ResponseInit",
     "RequestInit",
     "Event",
@@ -67,7 +98,7 @@ export function isParseArgsDynTypeName(name) {
     return PARSE_ARGS_DYN_TYPES.has(name);
 }
 function priorityRank(priority) {
-    return "rank" in priority ? priority.rank : priority;
+    return Array.isArray(priority) ? priority : priority.rank;
 }
 function comparePriority(left, right) {
     const a = priorityRank(left);
@@ -86,6 +117,8 @@ function comparePriority(left, right) {
  * struct). Owned by the Lowerer; `mapType` needs it to intern the object
  * types it encounters, which is why it is threaded through as a parameter. */
 export class ShapeRegistry {
+    /** Existing layouts change only when a recursive placeholder closes. */
+    revision = 0;
     byKey = new Map();
     byId = new Map();
     /** Historical emit-order rank of the declaration-order metadata each
@@ -245,6 +278,7 @@ export class ShapeRegistry {
                 shape.indexValue = indexValue;
             this.adoptDeclaredOrder(shape, declaredOrder);
             this.pendingRec.delete(id);
+            this.revision++;
             const key = this.keyOf(fields, false, indexValue);
             if (!this.byKey.has(key))
                 this.byKey.set(key, id);
@@ -294,13 +328,15 @@ export class ShapeRegistry {
     }
 }
 /** The frontend's union interner — mirrors ShapeRegistry. A union's
- * canonical identity is its typeKey-sorted arm list; two ts unions whose
- * arms map to the same IR types share one unionId (and later one runtime
- * tag numbering: an arm's index in the canonical list IS its tag). Owned by
- * the Lowerer; threaded through mapType exactly like ShapeRegistry. */
+ * canonical identity includes its typeKey-sorted arms and literal
+ * discriminator contract. An arm's index in that list IS its runtime tag.
+ * Owned by the Lowerer; threaded through mapType like ShapeRegistry. */
 export class UnionRegistry {
+    /** Existing arm/discriminator contracts change when a placeholder closes. */
+    revision = 0;
     byKey = new Map();
     byId = new Map();
+    armTags = new Map();
     /** All interned unions in first-seen (`u0`, `u1`, ...) order. */
     unions = [];
     /** ts.Types currently being mapped — a back-reference to one is the
@@ -343,37 +379,67 @@ export class UnionRegistry {
     }
     /** Completes a recursive placeholder with its canonical arm list and
      * registers the structural key (first writer wins, like shapes). */
-    finalizeRecursive(t, arms) {
+    finalizeRecursive(t, arms, discriminant) {
         const id = this.recIds.get(t);
         if (id === undefined)
             throw new InternalCompilerError("union registry bug: finalizeRecursive without a placeholder");
         if (this.pendingRec.has(id)) {
             const def = this.byId.get(id);
             def.arms.push(...arms);
+            if (discriminant)
+                def.discriminant = discriminant;
             this.pendingRec.delete(id);
-            const key = JSON.stringify(arms.map(typeKey));
+            this.armTags.delete(id);
+            this.revision++;
+            const key = JSON.stringify([arms.map(typeKey), discriminant]);
             if (!this.byKey.has(key))
                 this.byKey.set(key, id);
         }
         return id;
     }
-    /** Interns a canonical (typeKey-sorted, deduplicated) arm list, returning
-     * its unionId. */
-    intern(arms) {
-        const key = JSON.stringify(arms.map(typeKey));
+    /** Interns canonical arms and discriminator cases, returning their unionId. */
+    intern(arms, discriminant) {
+        const key = JSON.stringify([arms.map(typeKey), discriminant]);
         let id = this.byKey.get(key);
         if (id === undefined) {
             id = `u${this.unions.length}`;
-            const def = { id, arms };
+            const def = { id, arms, ...(discriminant ? { discriminant } : {}) };
             this.byKey.set(key, id);
             this.byId.set(id, def);
             this.unions.push(def);
         }
         return id;
     }
+    /** An exact arm transformation keeps the source's semantic variants. */
+    transform(source, arms) {
+        return this.intern(arms, remapUnionDiscriminant(source, arms));
+    }
     get(unionId) {
         return this.byId.get(unionId);
     }
+    /** Index large arm lists once. Exact equality still resolves type-key
+     * collisions, including optional function ABI flags. */
+    armTag(unionId, arm) {
+        const def = this.byId.get(unionId);
+        if (!def)
+            return -1;
+        if (def.arms.length < 8)
+            return def.arms.findIndex((candidate) => typeEquals(candidate, arm));
+        let tags = this.armTags.get(unionId);
+        if (!tags) {
+            tags = new Map();
+            def.arms.forEach((candidate, tag) => {
+                const key = typeKey(candidate);
+                const previous = tags.get(key);
+                if (previous)
+                    previous.push(tag);
+                else
+                    tags.set(key, [tag]);
+            });
+            this.armTags.set(unionId, tags);
+        }
+        return tags.get(typeKey(arm))?.find((tag) => typeEquals(def.arms[tag], arm)) ?? -1;
+    }
 }
 /** Human-readable rendering of an IrType for diagnostics (records expand to
  * their canonical field list, unions to their arms; `checker.typeToString`
@@ -442,7 +508,7 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
             case "bytes":
                 // The u8 kind reads as Uint8Array (Buffer maps here too — one
                 // runtime representation; the message stays honest either way).
-                return append(t.elem === "u8" ? "Uint8Array" : t.elem === "u32" ? "Uint32Array" : t.elem === "i32" ? "Int32Array" : t.elem === "f32" ? "Float32Array" : "Float64Array");
+                return append(BYTES_ELEMENT_NAME[t.elem]);
             case "map":
                 append("Map<");
                 child(t.key);
@@ -471,6 +537,9 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
                 const shape = shapes.get(t.shapeId);
                 if (!shape)
                     return append(`{ /* unknown shape ${t.shapeId} */ }`);
+                const codec = recordTextCodecClass(shape);
+                if (codec !== null)
+                    return append(codec);
                 if (seen.has(t.shapeId))
                     return append("..."); // the recursive knot
                 seen.add(t.shapeId);
@@ -696,16 +765,13 @@ export function containsUnion(t) {
  *   sentinel; any/unknown ride dyn; undefined-only yields have no C value
  *   form (null); else the mapped type.
  * - return: void/undefined/never carry no value (VOID — the done-value is
- *   the undefined arm); any/unknown are DEFAULTS (`Generator<number>` is
- *   Generator<number, any, any>), and a defaulted return channel means
- *   "no modeled return value" — VOID, not dyn (a dyn return channel would
- *   force the yield channel dyn too; bodies that `return v` under a
- *   defaulted TReturn keep their fence at the return site).
+ *   the undefined arm); any/unknown carry checked values. A defaulted or
+ *   inferred return channel can still return a value and must preserve it.
  * - next: void/undefined/never mean valueless resumes (the undefined
  *   unit); any/unknown ride dyn; else the mapped type (`.next(v)` then
  *   requires its argument — fenced at the call site).
- * Mixed dyn/concrete value channels stay unmapped (the shared result
- * record's value slot is one representation). */
+ * Mixed dyn/concrete value channels both use checked values because the
+ * shared result record's value slot has one representation. */
 function genChannels(yieldTs, retTs, nextTs, ctx) {
     if (!yieldTs)
         return null;
@@ -723,9 +789,9 @@ function genChannels(yieldTs, retTs, nextTs, ctx) {
     }
     if (!yieldT)
         return null;
-    const retT = retTs === undefined || retTs.flags & (UNITISH | ANYISH)
+    const retT = retTs === undefined || retTs.flags & UNITISH
         ? VOID
-        : 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
@@ -736,7 +802,7 @@ function genChannels(yieldTs, retTs, nextTs, ctx) {
     const dynMix = (yieldT.kind === "dyn" && retT.kind !== "dyn" && retT.kind !== "void") ||
         (retT.kind === "dyn" && yieldT.kind !== "dyn" && yieldT.kind !== "void");
     if (dynMix)
-        return null;
+        return { yieldT: DYN, retT: DYN, nextT };
     return { yieldT, retT, nextT };
 }
 /** SELF-REFERENTIAL types recurse through mapType with no structural floor:
@@ -788,16 +854,10 @@ export function mapType(type, ctx) {
         mapTypeDepth--;
     }
 }
-/** True when a class expression can NEVER register a lowering: one
- * enclosed by a function-like body or a class static block mints a
- * DISTINCT class per evaluation, which lowerClassExpressionInfo always
- * fences. Its instance/static types must stay UNMAPPED — an object type
- * naming a struct that will never be emitted is the invalid-C escape
- * family (every SITE using the value already carries its own fence). */
-function classExprNeverRegisters(decl) {
-    if (!ts.isClassExpression(decl))
-        return false;
-    for (let p = decl.parent; !ts.isSourceFile(p); p = p.parent) {
+/** Local class types need the enclosing specialization's registered layout.
+ * Static-block classes are sent through the same hook for an explicit fence. */
+function classExprNeedsContext(decl) {
+    for (let p = decl.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
         if (ts.isFunctionLike(p) || ts.isClassStaticBlockDeclaration(p))
             return true;
     }
@@ -805,6 +865,11 @@ function classExprNeverRegisters(decl) {
 }
 function mapTypeInner(type, ctx) {
     const { checker, unions, classNamer, resolveTypeParam } = ctx;
+    // TypeScript's intrinsic globalThis symbol has no declaration. A stored
+    // reference needs native object identity, including var's undefined state.
+    const intrinsic = type.getSymbol();
+    if (!ctx.dynamic && intrinsic?.name === "globalThis" && checker.declarationsOf(intrinsic).length === 0)
+        return DYN;
     if (!ctx.dynamic) {
         const moduleId = ctx.moduleNamespaceId?.(type) ?? null;
         if (moduleId !== null)
@@ -866,6 +931,15 @@ function mapTypeInner(type, ctx) {
         return STRING;
     if (flags & ts.TypeFlags.Boolean || flags & ts.TypeFlags.BooleanLiteral)
         return BOOL;
+    // ErrorOptions carries a presence-sensitive unknown value. A fixed
+    // optional field cannot distinguish {} from { cause: undefined }; the
+    // checked-dynamic object retains that distinction through forwarding
+    // constructors. Only the standard library's interface gets this ABI.
+    const errorOptionsSymbol = widened.getSymbol();
+    if (errorOptionsSymbol?.name === "ErrorOptions" &&
+        checker.declarationsOf(errorOptionsSymbol).some((d) => ctx.isStdlibFile(d.getSourceFile()))) {
+        return DYN;
+    }
     // node:util.parseArgs config/results are declaration-heavy conditional
     // and discriminated-union types over a value that is naturally a checked-
     // dynamic tree. Keep the named public surface (plus @types/node's private
@@ -876,12 +950,29 @@ function mapTypeInner(type, ctx) {
     // user aliases with the same names on the normal structural path.
     {
         const parseArgsSym = widened.getAliasSymbol() ?? widened.getSymbol();
-        if (parseArgsSym &&
-            PARSE_ARGS_DYN_TYPES.has(parseArgsSym.name) &&
-            checker.declarationsOf(parseArgsSym).some((d) => ctx.isStdlibFile(d.getSourceFile()) &&
-                isDeclaredInAmbientModule(d, "util"))) {
+        const belongs = (declaration) => {
+            if (!ctx.isStdlibFile(declaration.getSourceFile()))
+                return false;
+            let family = false;
+            for (let node = declaration; node; node = node.parent) {
+                if ((ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) &&
+                    PARSE_ARGS_DYN_TYPES.has(node.name.text))
+                    family = true;
+                if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name)) {
+                    return family && (node.name.text === "util" || node.name.text === "node:util");
+                }
+            }
+            return false;
+        };
+        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)))
             return DYN;
-        }
     }
     // The lib's BOXED wrapper interfaces used as TYPES (`const n: Number =
     // 5`): every value such a slot can hold IS the primitive — `new
@@ -933,6 +1024,21 @@ function mapTypeInner(type, ctx) {
     // position knows it wants a value; this mapping cannot.
     if (flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined))
         return VOID;
+    // 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;
+    }))
+        return VOID;
     // Standalone `null` (a `const x = null` binding, a `{ value: null }`
     // field, a `(): null` return): the unit-only union — the value is always
     // THE interned null instance, comparisons are tag tests, JSON serializes
@@ -1047,7 +1153,8 @@ function mapTypeInner(type, ctx) {
     // function VALUE is one ScrClosure for its whole life — top-level
     // declarations intern one immortal closure, and inner closures are
     // allocated once at their definition's evaluation and flow by
-    // reference, exactly JS's function identity. map/set/regex/url/dyn and
+    // reference, exactly JS's function identity. Maps and Sets use their
+    // typed RC/trace adapters; RegExp values use immutable REF storage. URL and
     // Date (scalar-backed but identity-bearing in JS) and the other opaque
     // handles stay unsupported as array elements; ordinary Date locals,
     // params, fixed record/tuple fields, and promise payloads are supported.
@@ -1059,7 +1166,7 @@ function mapTypeInner(type, ctx) {
         // `undefined[]` (sparse literals — `[,]` — and explicit annotations):
         // the element rides the unit-only union like a record field would; the
         // VOID mapping is a return-position artifact, not a value.
-        if (elem?.kind === "void" && isUnitOnlyTsType(elemTs))
+        if (elem?.kind === "void" && isUnitOnlyTsType(elemTs, ctx.resolveTypeParam))
             elem = unitOnlyUnion(unions);
         // A jsval element ABSORBS the array — with one carve-out. An array
         // type entangled with package-declared ('npm-jsval') elements
@@ -1077,15 +1184,15 @@ function mapTypeInner(type, ctx) {
         // A dyn ELEMENT makes the WHOLE array the checked-dynamic value:
         // `unknown[]`, `object[]`, and the collapsed `(string | object)[]`
         // (the plugins-slot shape) — the checked-dynamic tree has real arrays, so length/
-        // index/push/iteration ride the keyed-dyn paths, while a dyn-element
-        // STATIC array has no backend representation (ScrArr has no dyn
-        // element kind). This is dynFallbackType's JS stance promoted into
+        // index/push/iteration ride the keyed-dyn paths. Native dyn-element
+        // vectors are reserved for collection seeds and drains, rather than
+        // changing this public representation. This is dynFallbackType's JS stance promoted into
         // the mapping itself; construction sites build dynArrLit (the checked-dynamic tree
         // array literal) and typed sources convert per element at the slot.
         if (elem.kind === "dyn")
             return DYN;
         // The shared predicate is the runtime/backend storage contract. In
-        // particular, valid standalone values such as Map/Set/Date and opaque
+        // particular, valid standalone values such as Date and opaque
         // handles do not automatically have an array element representation.
         if (!isSupportedArrayElem(elem))
             return null;
@@ -1139,10 +1246,10 @@ function mapTypeInner(type, ctx) {
         }
         const fields = [];
         for (let i = 0; i < args.length; i++) {
-            let et = mapType(args[i], ctx);
+            let et = !ctx.dynamic && (args[i].flags & ts.TypeFlags.Any) !== 0 ? DYN : mapType(args[i], ctx);
             // A unit-only element (`[number, undefined]`) rides the unit-only
             // union, the record-field rule.
-            if (et?.kind === "void" && isUnitOnlyTsType(args[i]))
+            if (et?.kind === "void" && isUnitOnlyTsType(args[i], ctx.resolveTypeParam))
                 et = unitOnlyUnion(unions);
             // dyn ELEMENTS map now — `[string, unknown]`, the Object.entries
             // tuple over an `unknown`-valued index signature (the pricing-table
@@ -1170,8 +1277,6 @@ function mapTypeInner(type, ctx) {
         if (brandedPrimitive)
             return brandedPrimitive;
     }
-    // Class instances: the type's symbol is a class declared in the user's
-    // file. The class NAME as a value has the *constructor* type — same
     // REFINED handle intersections — @types/node's idioms: `ServerResponse<
     // IncomingMessage> & { req: IncomingMessage }` (RequestListener's
     // inferred res param — every unannotated http.createServer handler) and
@@ -1223,8 +1328,11 @@ function mapTypeInner(type, ctx) {
             }
         }
     }
-    // symbol, but with construct signatures — that is the STATIC side, and
-    // it maps to classval below.
+    const classView = mapClassView(widened, ctx);
+    if (classView !== undefined)
+        return classView;
+    // Class instances name a program class. The same symbol with construct
+    // signatures names its static side, mapped to classval below.
     const widenedSym = widened.getSymbol();
     const classDecl = widenedSym ? checker.valueDeclarationOf(widenedSym) : undefined;
     if (classDecl &&
@@ -1251,17 +1359,17 @@ function mapTypeInner(type, ctx) {
                 return viaMixin;
             }
         }
-        // A class expression inside a function/static block never registers
-        // (a distinct class per evaluation): unmappable for the same reason.
-        if (classExprNeverRegisters(classDecl))
-            return null;
+        if (classExprNeedsContext(classDecl)) {
+            const local = ctx.localClassInstance?.(classDecl);
+            if (local)
+                contextResolutions++;
+            return local ?? null;
+        }
         // A GENERIC class's instance type (`Box<number>`) maps to the concrete
         // INSTANTIATION's class (`Box%0`), registered on demand — the Lowerer
         // hook owns the instance table (monomorphization by flow).
         if (classDecl.typeParameters) {
-            const instance = ctx.genericClassInstance
-                ? ctx.genericClassInstance(classDecl, widened)
-                : 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.
@@ -1289,8 +1397,14 @@ function mapTypeInner(type, ctx) {
                 return { kind: "classval", className: viaMixin.className };
             }
         }
-        if (classExprNeverRegisters(classDecl))
+        if (classExprNeedsContext(classDecl)) {
+            const local = ctx.localClassInstance?.(classDecl);
+            if (local?.kind === "object") {
+                contextResolutions++;
+                return { kind: "classval", className: local.className };
+            }
             return null;
+        }
         // A GENERIC class's static side: only an INSTANTIATED one maps — an
         // instantiation expression's type (`Box<number>` as a value) carries a
         // construct signature returning the concrete instance, which maps to
@@ -1335,8 +1449,7 @@ function mapTypeInner(type, ctx) {
     const psym = widened.getSymbol();
     const isStdlibInterface = (name) => psym?.name === name &&
         checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(d.getSourceFile()));
-    // The builtin Error classes: references to the LIB's Error/TypeError/
-    // RangeError/SyntaxError interfaces map to the runtime-provided class
+    // 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
     // `interface Error` maps as a record). The '%'-prefixed IR names are the
@@ -1421,6 +1534,15 @@ function mapTypeInner(type, ctx) {
             isDeclaredInAmbientModule(d, "diagnostics_channel"))) {
         return 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()))) {
+        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, []),
+        };
+    }
     // string_decoder.StringDecoder: the decoder value is a two-field record
     // — the CANONICAL encoding name (construction normalizes aliases; the
     // `.encoding` property reads it) and the f64 packing the pending
@@ -1449,9 +1571,10 @@ function mapTypeInner(type, ctx) {
     // record-holding binding forms compile. User-declared literals with
     // these member names keep the ordinary record path (their declarations
     // are not in declaration files).
+    const promiseDeclarations = psym ? checker.declarationsOf(psym) : [];
     if (flags & ts.TypeFlags.Object &&
-        (psym ? checker.declarationsOf(psym).length : 0) > 0 &&
-        (psym ? checker.declarationsOf(psym) : []).every((d) => d.getSourceFile().isDeclarationFile)) {
+        promiseDeclarations.length > 0 &&
+        promiseDeclarations.every((d) => d.getSourceFile().isDeclarationFile)) {
         const props = checker.getPropertiesOfType(widened);
         if (props.length === 3 &&
             ["promise", "resolve", "reject"].every((n) => props.some((p) => p.name === n))) {
@@ -1484,6 +1607,10 @@ function mapTypeInner(type, ctx) {
     // read has its own lowering (errno/syscall/path stay per-member fences).
     if (isStdlibInterface("ErrnoException"))
         return { kind: "object", className: "%Error" };
+    // spawn consumes a presence-sensitive option bag, including optional
+    // stdio and env values. Keep it checked-dynamic for native normalization.
+    if (isStdlibInterface("SpawnOptions"))
+        return DYN;
     // The fetch ambient slice: under --dynamic these are island handles
     // exactly like npm-declared types. Static fetch has one deliberately
     // narrower native representation: Response is an opaque checked-
@@ -1544,26 +1671,33 @@ function mapTypeInner(type, ctx) {
         const args = checker.getTypeArguments(widened);
         if (args.length !== 2)
             return null;
-        const key = mapType(args[0], ctx);
-        if (!key || !isSupportedMapKey(key))
+        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))
             return null;
-        const value = mapType(args[1], ctx);
+        const value = !ctx.dynamic && (args[1].flags & ts.TypeFlags.Any) !== 0 ? DYN : mapType(args[1], ctx);
         if (!value || !isSupportedMapValue(value))
             return null;
         return mapOf(key, value);
     }
-    // Set<T>: Map's sibling — same provenance rule, elements fenced to Map's
-    // KEY kinds (f64/string, SameValueZero). Anything else stays unmapped;
+    // Native WeakMap keeps reference identities in checked-dynamic storage.
+    // The runtime rejects reference kinds without a weak lifetime contract.
+    if (isStdlibInterface("WeakMap") || isStdlibInterface("WeakSet"))
+        return ctx.dynamic ? JSVAL : 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.
     if (isStdlibInterface("Set") || isStdlibInterface("ReadonlySet")) {
         const args = checker.getTypeArguments(widened);
         if (args.length !== 1)
             return null;
-        const elem = mapType(args[0], ctx);
-        if (!elem || !isSupportedSetElem(elem))
+        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))
             return null;
         return setOf(elem);
     }
+    const collectionView = mapCollectionView(widened, ctx);
+    if (collectionView)
+        return collectionView;
     // Date: a TimeClip'd epoch-millisecond scalar in the static runtime.
     // This supports stored/passed values and the read-only getter slice;
     // identity and mutation stay fenced because the scalar deliberately
@@ -1577,6 +1711,8 @@ function mapTypeInner(type, ctx) {
     if (isStdlibInterface("RegExp")) {
         return { kind: "regex" };
     }
+    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
     // declares them generic over the backing buffer (`Uint8Array<ArrayBuffer>`
@@ -1616,10 +1752,22 @@ 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"))
+        return DYN;
+    if (Object.values(BYTES_ELEMENT_NAME).some((name) => isStdlibInterface(`${name}Constructor`)))
+        return DYN;
     if (isStdlibInterface("Uint8Array"))
         return bytesOf("u8");
     if (isStdlibInterface("Uint32Array"))
         return bytesOf("u32");
+    if (isStdlibInterface("Uint8ClampedArray"))
+        return bytesOf("u8c");
+    if (isStdlibInterface("Int8Array"))
+        return bytesOf("i8");
+    if (isStdlibInterface("Uint16Array"))
+        return bytesOf("u16");
+    if (isStdlibInterface("Int16Array"))
+        return bytesOf("i16");
     // Int32Array: the signed 32-bit kind (element reads sign-extend, writes
     // ToInt32-wrap) — the Atomics.wait sleep idiom constructs one over a
     // SharedArrayBuffer, and the i32 semantics hold for every other use.
@@ -1956,6 +2104,9 @@ function mapTypeInner(type, ctx) {
             return null;
         return { kind: "promise", inner };
     }
+    // Native collection iterators use checked runtime iterator objects.
+    if (isStdlibInterface("MapIterator") || isStdlibInterface("SetIterator"))
+        return DYN;
     // Generator<T, TReturn, TNext>, AsyncGenerator<T, TReturn, TNext> (and
     // the lib's IterableIterator<T, ...>, the older sync annotation spelling):
     // the generator kind. Channel normalization keeps the runtime honest:
@@ -1972,8 +2123,8 @@ function mapTypeInner(type, ctx) {
     //                    boxes; the yield expression reads checked-dynamic);
     //                    else the mapped type (`.next(v)` requires its
     //                    argument — fenced at the call).
-    // Mixed dyn/concrete channels stay unmapped: the shared result record's
-    // value slot would need a dyn union arm, which does not exist.
+    // 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")) {
         const args = checker.getTypeArguments(widened);
         const channels = genChannels(args[0], args[1], args[2], ctx);
@@ -2273,6 +2424,11 @@ function mapTypeInner(type, ctx) {
         const hybrid = mapHybridCallableIntersection(widened, ctx);
         if (hybrid)
             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 &&
+            checker.getPropertiesOfType(widened).length > 0)
+            return DYN;
     }
     const callSigs = checker.getCallSignatures(widened);
     if (callSigs.length === 1) {
@@ -2313,10 +2469,18 @@ function mapTypeInner(type, ctx) {
                 ts.isParameter(decl) &&
                 (decl.questionToken !== undefined || decl.initializer !== undefined);
             let pt = mapType(checker.getTypeOfSymbol(p), ctx);
+            // An inferred JavaScript binding pattern consumes an iterable; it
+            // does not require the caller's array to have exactly this length.
+            if (decl && ts.isParameter(decl) && ts.isArrayBindingPattern(decl.name) &&
+                isJsSourceFile(decl.getSourceFile()) && !decl.type &&
+                !/@(?:param|type)\b/.test(decl.getSourceFile().text.slice(decl.parent?.pos ?? decl.pos, decl.getStart())))
+                pt = DYN;
+            if (pt)
+                pt = jsOpenObjectType(decl, pt, ctx.shapes, ctx.unions);
             // Belt and braces for non-strict type worlds: an optional param's
             // ABI slot is always the undefined-armed union (strictNullChecks
             // already spells it that way; arm it here if the world didn't).
-            if (optional && pt && pt.kind !== "void" && pt.kind !== "jsval") {
+            if (optional && pt && pt.kind !== "void" && pt.kind !== "jsval" && pt.kind !== "dyn") {
                 const armed = withUndefinedArm(pt, ctx.unions);
                 if (!armed)
                     return null;
@@ -2338,8 +2502,16 @@ function mapTypeInner(type, ctx) {
         const retT = checker.getReturnTypeOfSignature(sig);
         // `() => never` (a throw-only lambda's inferred type) is assignable to
         // `() => void` and its calls never produce a value — map the return
-        // like declaredReturnType does for declarations.
-        const ret = retT.flags & ts.TypeFlags.Never ? VOID : mapType(retT, ctx);
+        // like declaredReturnType does for declarations. JS null/undefined
+        // returns can read mutable fields, so callable values use the same
+        // checked-native return ABI as their implementations.
+        const sigDecl = checker.signatureDeclaration(sig);
+        const jsUnitReturn = sigDecl !== undefined && isJsSourceFile(sigDecl.getSourceFile()) &&
+            (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
+        let ret = jsUnitReturn || (!ctx.dynamic && (retT.flags & ts.TypeFlags.Any) !== 0)
+            ? DYN : retT.flags & ts.TypeFlags.Never ? VOID : mapType(retT, ctx);
+        if (sigDecl && isJsSourceFile(sigDecl.getSourceFile()) && ret?.kind === "array" && ret.elem.kind === "f64")
+            ret = DYN;
         if (!ret)
             return null;
         return typedRest
@@ -2430,7 +2602,7 @@ function mapTypeInner(type, ctx) {
     // literal unions like `"a" | "b"` — parts that map to the SAME IR type
     // collapse (deduplicated by typeKey), so a single surviving arm is just
     // that type. Two or more distinct arms become a TAGGED union: the
-    // typeKey-sorted arm list is interned (its identity), and an arm's index
+    // typeKey-sorted arm list and discriminator are interned, and an arm's index
     // in that list is its runtime tag. `undefined` and `null` PARTS become
     // the unit arms undefinedT/nullT — strictNullChecks spells optionality
     // as exactly these unions (`string | undefined`, `number | null`), and
@@ -2454,7 +2626,12 @@ function mapTypeInner(type, ctx) {
         const sensitivityAtEntry = contextResolutions;
         try {
             const byKey = new Map();
+            const recordParts = [];
             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.
+                if (checker.isNeverType(part))
+                    continue;
                 // A `void` PART is inhabited only by undefined (`Promise<void> |
                 // void` return types, `string | void`): it becomes the undefinedT
                 // unit arm, exactly like an undefined part — the value either
@@ -2489,9 +2666,17 @@ function mapTypeInner(type, ctx) {
                     }
                     return null;
                 }
+                if (mapped.kind === "void") {
+                    byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
+                    continue;
+                }
                 byKey.set(typeKey(mapped), mapped);
+                if (mapped.kind === "record")
+                    recordParts.push({ source: part, mapped });
             }
             const arms = [...byKey.values()];
+            if (arms.length === 0)
+                return F64; // same unreachable placeholder as standalone never
             // A single surviving UNIT arm cannot stand alone (degenerate — the
             // checker collapsed everything else away); anything else single is
             // just that type. A single arm UNDER A MINTED PLACEHOLDER cannot
@@ -2531,29 +2716,12 @@ function mapTypeInner(type, ctx) {
                 return DYN;
             }
             if (arms.some((a) => a.kind === "void" || a.kind === "union" ||
-                // Map/Set arms stay out (like func against data arms: no
-                // narrowing test — no discriminant fields on them). REGEX
-                // arms map: `x instanceof RegExp` is their narrowing test
-                // (the skip-utility `string | RegExp` shape), and the arm
-                // rides the ref machinery like array regex elements.
-                a.kind === "map" || a.kind === "set" || a.kind === "date" || a.kind === "dyn" ||
-                // Generator arms follow the map/set rule: no narrowing test.
-                a.kind === "generator" ||
-                // Func arms map beside ANY sibling: `typeof x === "function"`
-                // is the narrowing against data arms (typeofAnswer knows every
-                // arm kind), unit TAG tests cover the nullable-callback shape
-                // (cb !== null, cb ?? f, cb?.()), and against FUNC siblings
-                // (`StringConstructor | NumberConstructor` — the option-table
-                // field) closures compare by pointer identity per tag
-                // (unionEq), so `x === String` narrows. No restriction left.
-                // Promise arms follow the func rule (typeof gives no test
-                // against sibling data arms): only the promise-or-absent shape
-                // maps — `Promise<T> | undefined`, and `Promise<T> | void`
-                // return types whose void part became the undefined arm above.
-                (a.kind === "promise" && !arms.every((b) => b === a || isUnitType(b))))) {
+                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);
             if (unions.recursivePending(widened)) {
                 // The knot closed through this union. A frame that resolved
                 // through context-sensitive hooks (generic type parameters, mixin
@@ -2562,9 +2730,9 @@ function mapTypeInner(type, ctx) {
                 // recursive generic-open unions stay fenced.
                 if (contextResolutions !== sensitivityAtEntry)
                     return null;
-                return { kind: "union", unionId: unions.finalizeRecursive(widened, arms) };
+                return { kind: "union", unionId: unions.finalizeRecursive(widened, arms, discriminant) };
             }
-            return { kind: "union", unionId: unions.intern(arms) };
+            return { kind: "union", unionId: unions.intern(arms, discriminant) };
         }
         finally {
             unions.inProgress.delete(widened);
@@ -2572,6 +2740,231 @@ function mapTypeInner(type, ctx) {
     }
     return null;
 }
+/** Retain a literal discriminator before widening erases its values. A
+ * structural match alone is insufficient: `{ kind: "loop", body: ... }`
+ * also fits a smaller `{ kind: "empty" }` record. Choosing that layout
+ * makes a later switch on kind read fields outside the allocated object.
+ *
+ * Require one common, required data property with finite literal values.
+ * Values may repeat within a single storage arm (several variants share a
+ * shape), but never select different arms. Non-record arms keep their
+ * ordinary kind checks. Types without an unambiguous discriminator retain
+ * their structural boundary behavior. */
+function unionDiscriminant(parts, arms, ctx) {
+    if (arms.filter((arm) => arm.kind === "record").length < 2 || parts.length < 2)
+        return undefined;
+    const { checker } = ctx;
+    for (const candidate of checker.getPropertiesOfType(parts[0].source)) {
+        if (candidate.name.startsWith("__@"))
+            continue;
+        const byTag = new Map();
+        const owner = new Map();
+        let complete = true;
+        for (const part of parts) {
+            const prop = checker.getPropertyOfType(part.source, candidate.name);
+            if (!prop || prop.flags & (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
+                complete = false;
+                break;
+            }
+            const values = literalValues(checker.getTypeOfSymbol(prop));
+            if (!values) {
+                complete = false;
+                break;
+            }
+            const tag = arms.findIndex((arm) => typeEquals(arm, part.mapped));
+            const grouped = byTag.get(tag) ?? [];
+            for (const value of values) {
+                const key = JSON.stringify(value);
+                const previous = owner.get(key);
+                if (previous !== undefined && previous !== tag) {
+                    complete = false;
+                    break;
+                }
+                owner.set(key, tag);
+                if (!grouped.includes(value))
+                    grouped.push(value);
+            }
+            if (!complete)
+                break;
+            byTag.set(tag, grouped);
+        }
+        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),
+                })),
+            };
+        }
+    }
+    return undefined;
+}
+/** A class-derived interface or intersection can refine existing members
+ * without changing the object's layout. Keep the unique program class as
+ * its representation; structural lookalikes without a class base do not
+ * qualify. Construction and coercion must still supply that actual class.
+ * Undefined means no class view, while null is a recognized but unsupported
+ * view: do not fall through and copy an identity-bearing object to a record. */
+function mapClassView(type, ctx, seen = new Set()) {
+    const { checker } = ctx;
+    if (seen.has(type) || seen.size >= MAP_TYPE_MAX_DEPTH)
+        return null;
+    let bases;
+    let viewCtx = ctx;
+    if (type.isIntersectionType()) {
+        bases = ts.constituentTypes(type);
+    }
+    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())))
+            return undefined;
+        const target = type.isTypeReference() ? type.getTarget() : type;
+        if (target === undefined || !target.isClassOrInterface())
+            return undefined;
+        bases = checker.getBaseTypes(target);
+        if (type.isTypeReference() && target.isTypeReference()) {
+            const params = checker.getTypeArguments(target);
+            const args = checker.getTypeArguments(type);
+            viewCtx = {
+                ...ctx,
+                canMemoizeType: () => false,
+                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;
+                },
+                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;
+                },
+            };
+        }
+    }
+    seen.add(type);
+    try {
+        let baseType;
+        let representation;
+        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)) &&
+                !declaration.getSourceFile().isDeclarationFile;
+            const mapped = classBase ? mapType(base, viewCtx) : mapClassView(base, viewCtx, seen);
+            if (mapped === null)
+                return null;
+            if (mapped === undefined)
+                continue;
+            if (mapped.kind !== "object" || (representation && !typeEquals(representation, mapped)))
+                return null;
+            baseType = base;
+            representation = mapped;
+        }
+        if (!representation || !baseType)
+            return undefined;
+        if (checker.getCallSignatures(type).length || checker.getConstructSignatures(type).length ||
+            checker.getIndexInfosOfType(type).length)
+            return null;
+        for (const property of checker.getPropertiesOfType(type)) {
+            const original = checker.getPropertyOfType(baseType, property.name);
+            if (!original)
+                return null;
+            if (original === property)
+                continue;
+            const originalDeclarations = checker.declarationsOf(original);
+            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 &&
+                declarations.every((declaration, index) => declaration === originalDeclarations[index]))
+                continue;
+            const before = checker.getTypeOfSymbol(original);
+            const after = checker.getTypeOfSymbol(property);
+            if (checker.getCallSignatures(before).length || checker.getCallSignatures(after).length) {
+                const from = mapType(before, viewCtx);
+                const to = mapType(after, viewCtx);
+                if (!from || !to || !typeEquals(from, to))
+                    return null;
+            }
+            else if (!checker.isTypeAssignableTo(after, before)) {
+                return null;
+            }
+        }
+        return representation;
+    }
+    finally {
+        seen.delete(type);
+    }
+}
+/** Interface views of native collections may inherit their runtime surface
+ * and refine `has` into a type predicate. Keep declaration provenance and
+ * require the same call ABI; extra fields or replacement methods need a
+ * different representation. Value construction/coercion still has to prove
+ * a native Map/Set, so structural mocks cannot acquire a native handle. */
+function mapCollectionView(type, ctx, seen = new Set()) {
+    if (!type.isTypeReference())
+        return null;
+    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())))
+        return null;
+    const target = type.getTarget();
+    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 ||
+        checker.getIndexInfosOfType(type).length)
+        return null;
+    // Base declarations contain the interface's parameters, even when this
+    // reference is instantiated. Resolve those through this reference before
+    // mapping the base; never cache a template under one instantiation's ABI.
+    const params = checker.getTypeArguments(target);
+    const args = checker.getTypeArguments(type);
+    const baseCtx = {
+        ...ctx,
+        canMemoizeType: () => false,
+        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;
+        },
+        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;
+        },
+    };
+    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 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()));
+            if (own.length === 0)
+                continue;
+            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);
+            if (!method || !typeEquals(method, hasType))
+                return null;
+        }
+        return mapped;
+    }
+    finally {
+        seen.delete(target);
+    }
+}
 /** The narrowed-type-parameter recognizer behind mapType's early return:
  * a union/intersection over exactly ONE type parameter whose companions
  * are all `{}`-empty shapes or the null/undefined units. Returns the
@@ -2651,7 +3044,7 @@ function mapBoundIndexedAccess(type, ctx) {
     const { checker, resolveTypeParamTs } = ctx;
     if (!resolveTypeParamTs || !type.isIndexedAccessType())
         return null;
-    const resolveSide = (t) => t.flags & ts.TypeFlags.TypeParameter ? resolveTypeParamTs(t) : t;
+    const resolveSide = (t) => t === undefined ? null : t.flags & ts.TypeFlags.TypeParameter ? resolveTypeParamTs(t) : t;
     const objT = resolveSide(type.getObjectType());
     const idxT = resolveSide(type.getIndexType());
     if (!objT || !idxT)
@@ -2768,7 +3161,7 @@ function mapGenericIndexedAccess(type, ctx) {
     if (!resolveTypeParam || !type.isIndexedAccessType())
         return null;
     const obj = type.getObjectType();
-    if (!(obj.flags & ts.TypeFlags.TypeParameter))
+    if (obj === undefined || !(obj.flags & ts.TypeFlags.TypeParameter))
         return null;
     const bound = resolveTypeParam(obj);
     if (!bound || bound.kind !== "record")
@@ -2777,13 +3170,15 @@ function mapGenericIndexedAccess(type, ctx) {
     if (!shape || shape.tuple)
         return null;
     const idx = type.getIndexType();
+    if (idx === undefined)
+        return null;
     let covered = null;
     if (idx.isStringLiteralType()) {
         const f = shape.fields.find((x) => x.name === idx.value);
         covered = f ? [f.type] : shape.indexValue ? [shape.indexValue] : null;
     }
     else {
-        const allKeys = (idx.flags & ts.TypeFlags.TypeParameter && 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);
@@ -2864,8 +3259,8 @@ export function unitOnlyUnion(unions) {
  * answers undefined). ONE shape per channel pair — `g.next()`'s lowering,
  * `.return()`, `.throw()`, the for-of desugar, and mapType's
  * IteratorResult alias mapping all intern through here, so reads agree.
- * Null when the combined union would be illegal (a func/set arm beside
- * data arms, a map/regex/Date arm — kinds with no narrowing test): such
+ * Null when the combined union would be illegal (a container arm beside
+ * data arms, a regex/Date arm — kinds with no narrowing test here): such
  * generators stay unmapped. */
 export function genResultRecord(yieldT, retT, shapes, unions) {
     let valueT;
@@ -2882,7 +3277,7 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
                     byKey.set(typeKey(a), a);
                 return true;
             }
-            if (t.kind === "map" || t.kind === "regex" || t.kind === "date" ||
+            if (t.kind === "regex" || t.kind === "date" ||
                 t.kind === "jsval" || t.kind === "generator") {
                 return false; // no legal union arm exists for these kinds
             }
@@ -2893,9 +3288,9 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
             return null;
         byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
         const arms = [...byKey.values()];
-        // func/set arms are legal only beside unit arms (no narrowing test
-        // against data siblings — the union rule).
-        if (arms.some((a) => (a.kind === "func" || a.kind === "set") && !arms.every((b) => b === a || isUnitType(b)))) {
+        // 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)))) {
             return null;
         }
         if (arms.every(isUnitType) && arms.length < 2) {
@@ -2922,37 +3317,45 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
  * fields, tuple/array elements, variable slots) substitute unitOnlyUnion
  * for these; RETURN positions keep the VOID mapping (a void return is not
  * a value). */
-export function isUnitOnlyTsType(t) {
+export function isUnitOnlyTsType(t, resolveTypeParam) {
     const UNIT = ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Null;
     const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
-    return parts.every((p) => (p.flags & UNIT) !== 0);
+    return parts.every((p) => (p.flags & UNIT) !== 0 ||
+        ((p.flags & ts.TypeFlags.TypeParameter) !== 0 && resolveTypeParam?.(p)?.kind === "void"));
 }
 /** IR-level `t | undefined`, canonicalized and fenced exactly like the
- * ts-union branch of mapType (typeKey-sorted arms, deduplicated; map/
- * regex/Date/dyn/void arms unrepresentable; a func arm IS representable — the
+ * ts-union branch of mapType (typeKey-sorted arms, deduplicated;
+ * Date/dyn/void arms unrepresentable; a func arm IS representable — the
  * result is exactly the nullable-callback shape mapType's union branch
  * admits, `(() => void) | undefined`) so the interned union is IDENTICAL
  * to what mapping the checker's own `T | undefined` produces. */
 export function withUndefinedArm(t, unions) {
+    return withUnitArm(t, "undefinedT", unions);
+}
+/** Preserve a nullish runtime value that JavaScript inference omitted. */
+export function withUnitArm(t, kind, unions) {
+    const unit = { kind };
+    if (t.kind === "jsval")
+        return t;
     if (t.kind === "union") {
         const def = unions.get(t.unionId);
         if (!def)
             return null;
         if (def.arms.some((a) => a.kind === "date"))
             return null;
-        if (def.arms.some((a) => a.kind === "undefinedT"))
+        if (def.arms.some((a) => a.kind === kind))
             return t;
-        const arms = [...def.arms, UNDEFINED_T];
+        const arms = [...def.arms, unit];
         arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
-        return { kind: "union", unionId: unions.intern(arms) };
+        return { kind: "union", unionId: unions.transform(def, arms) };
     }
-    if (t.kind === "void" || t.kind === "map" || 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)) {
         return null;
     }
-    const arms = [t, UNDEFINED_T];
+    const arms = [t, unit];
     arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
     return { kind: "union", unionId: unions.intern(arms) };
 }
@@ -3130,8 +3533,11 @@ function recordProvenanceOk(t, ctx) {
         return true;
     const tSym = t.getSymbol();
     const decls = tSym ? checker.declarationsOf(tSym) : undefined;
-    if (!decls || decls.length === 0)
-        return false;
+    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 !decls.some((d) => {
         const sf = d.getSourceFile();
         return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
@@ -3200,6 +3606,15 @@ function mapRecordType(widened, ctx) {
                 shapeId: shapes.finalizeRecursive(widened, inner.fields, inner.indexValue, inner.declaredOrder),
             };
         }
+        // A record with no typed payload contract is a view of an existing
+        // object, including across parameters and returns. Building a native
+        // struct for it would copy a checked-dynamic object at each boundary
+        // and sever mutation/identity. Keep the same representation as unknown;
+        // constrained records and tuples retain their native layouts.
+        if ((inner.fields.length > 0 || inner.indexValue !== undefined) &&
+            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) };
     }
     finally {
@@ -3343,6 +3758,10 @@ function mapRecordTypeInner(widened, ctx) {
     const computed = widened.isIntersectionType() || isMappedShape(widened);
     {
         const props = checker.getPropertiesOfType(widened);
+        // 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("__@")))
+            return DYN;
         // A computed shape with NO members is not a real empty record: inside a
         // generic body `Partial<T>` resolves to no members at all (keyof T is
         // still unknown there) — interning `{}` would be silently wrong. The
@@ -3463,11 +3882,13 @@ function mapRecordTypeInner(widened, 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)
+                pt = DYN;
             // Unit-only FIELDS (`{ msg?: undefined }` — the discriminated-union
             // absent-field idiom — and `{ p: undefined }` spellings): the
             // unit-only union. The runtime value is the interned unit, JSON
             // omits the undefined arm exactly like an omitted optional.
-            if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs))
+            if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs, ctx.resolveTypeParam))
                 pt = unitOnlyUnion(ctx.unions);
             // dyn FIELDS map now (`{ v: unknown }`, `[string, unknown]` tuples):
             // the slot carries a dyn value exactly like an `unknown`-valued
@@ -3556,15 +3977,15 @@ function armHasUnionHome(arm, siblingCount) {
     switch (arm.kind) {
         case "void":
         case "union":
-        case "map":
-        case "set":
         case "regex":
         case "date":
         case "generator":
         case "dyn":
             return false;
-        // Promise arms map only beside unit siblings (the promise-or-absent
-        // shape); a data sibling has no narrowing test against them.
+        // Containers map only beside unit siblings; data siblings have no
+        // supported runtime narrowing test against them.
+        case "map":
+        case "set":
         case "promise":
             return siblingCount === 0;
         default:
@@ -3598,14 +4019,14 @@ 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)) {
-                return `the ${container} shape is supported, but keys are limited to numbers and strings — '${text(arg)}' is outside that domain`;
+            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, identity references, or unions of identity references)`;
             }
             if ((container === "Map" || container === "ReadonlyMap") && i === 1 && !isSupportedMapValue(mapped)) {
-                return `the ${container} shape is supported, but '${text(arg)}' values have no Map slot yet (functions, promises, and nested Maps stay out)`;
+                return `the ${container} shape is supported, but '${text(arg)}' values have no Map slot yet`;
             }
-            if ((container === "Set" || container === "ReadonlySet") && !isSupportedSetElem(mapped)) {
-                return `the ${container} shape is supported, but elements are limited to numbers and strings — '${text(arg)}' is outside that domain`;
+            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, identity references, or unions of identity references)`;
             }
         }
         // Every argument passed the per-slot checks and the type still failed:
@@ -3631,7 +4052,7 @@ export function describeComponentBlocker(widened, ctx) {
     if (checker.isTupleType(widened)) {
         for (const arg of checker.getTypeArguments(widened)) {
             const et = mapType(arg, ctx);
-            if (et?.kind === "void" && isUnitOnlyTsType(arg))
+            if (et?.kind === "void" && isUnitOnlyTsType(arg, ctx.resolveTypeParam))
                 continue;
             if (!et || et.kind === "void") {
                 return `the tuple shape is supported, but its element type '${text(arg)}' does not compile`;
@@ -3745,7 +4166,7 @@ export function describeRecordMemberBlocker(widened, ctx) {
         if (isGenericCallableMemberType(fieldTs, checker))
             continue;
         let pt = mapType(fieldTs, ctx);
-        if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs))
+        if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs, ctx.resolveTypeParam))
             pt = unitOnlyUnion(ctx.unions);
         if (!pt || pt.kind === "void") {
             return `the record shape is supported, but its member '${p.name}' has type '${checker.typeToString(fieldTs)}', which does not compile`;