@scriptc/compiler 0.2.0 → 0.2.1

package/dist/frontend/lowering/lower-exprs.js

@@ -11,13 +11,14 @@ import * as ts from "../ts7/adapter.js";
 import { dirname } from "node:path";
 import * as posix from "node:path/posix";
 import { pathToFileURL } from "node:url";
+import { captureContextArguments } from "./function-context.js";
 import { OBJECT_CALLABLE_VALUES } from "./surfaces.js";
 import { wasiGuestPath } from "../../wasi-paths.js";
 import { BIGINT_T, BYTES_ELEMENT_NAME, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canDynCheckTo, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isSupportedArrayElem, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey, unionContainerArmsOk } from "../../ir/ir.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf } from "../program.js";
 import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModulesArrayLit, builtinModuleFnOf, COMPOUND_ASSIGN_OPS, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STRING_INDEX_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
 import { UNSUPPORTED, blockedBindingUseDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
-import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, nodeThrowExpr, own } from "./lowerer.js";
+import { PoisonError, dynFallbackType, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, nodeThrowExpr, own } from "./lowerer.js";
 import { lowerCollectionSpread, lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall, tryLowerNumericIndexRead } from "./lower-containers.js";
 import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.js";
 import { lowerOptionalStringIndex } from "./string-index.js";
@@ -29,13 +30,14 @@ import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUn
 import { expandoMemberRead, expandoWritableTarget } from "./lower-expando.js";
 import { lowerSocketInstanceOf, lowerTlsRootCertificates } from "./lower-server.js";
 import { findGenericMethodOn, lowerStaticFieldRead, staticFieldWriteTarget, storedClassValueType } from "./lower-classes.js";
+import { hasRuntimeStatics } from "./class-runtime-statics.js";
 import { bindingNeverReassigned, funcTypeFromParamShapes, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
 import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion, withUnitArm } from "../type-mapper.js";
 import { lowerYield } from "./lower-generators.js";
-import { errorToStringCall } from "./error-methods.js";
+import { errorPropertyRead, errorPropertyWrite, errorToStringCall } from "./error-methods.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
-import { countedFor, numLit, varRef } from "../../ir/build.js";
+import { countedFor, numLit, strLit, varRef } from "../../ir/build.js";
 import { unionWideningTags } from "../../ir/analysis.js";
 import { isSafeToDiscard, isSafeToMoveConditionEarlier, isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
@@ -52,8 +54,12 @@ import { lowerClassMethodValue } from "./class-method-values.js";
 import { classInstanceOf } from "./class-dynamic-dispatch.js";
 import { lowerGlobalValue } from "./lower-global-value.js";
 import { lowerClassPrototypeData } from "./class-prototypes.js";
-import { lowerArrayIsArrayValue } from "./lower-builtin-values.js";
+import { isClassCallback } from "./class-callbacks.js";
+import { builtinPrototypeMethod, lowerArrayIsArrayValue, lowerCheckedPredicateValue, lowerNumberParserValue, lowerObjectAssignValue, lowerStringCodesValue } from "./lower-builtin-values.js";
+import { lowerArrayFromValue } from "./lower-containers.js";
 import { lowerPerfHooksTypeof } from "./lower-builtins.js";
+import { jsBindingHasOpenWrites } from "./lower-stmts.js";
+import { checkedClassInstanceOf } from "./class-construction.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
  * declares it; the serialized node data omits it), so the raw span comes
@@ -704,8 +710,10 @@ function lowerExprInner(lowerer, expr) {
         // `arguments` in a variadic JS function (the rest-marked form): the
         // synthetic trailing dyn-array param — lambdaSignature marked the
         // type and lowerLambda declared the local.
-        if (expr.text === "arguments" && lowerer.ctx.argumentsLocal) {
-            return { kind: "varRef", localId: lowerer.ctx.argumentsLocal.id, type: DYN, loc };
+        if (expr.text === "arguments") {
+            const binding = captureContextArguments(lowerer.fnStack);
+            if (binding)
+                return { kind: "varRef", localId: binding.id, type: DYN, loc };
         }
         // A compiler-projected adapter as a VALUE: the adapter has no
         // runtime function object (its calls rewrite directly) — call it
@@ -1052,14 +1060,36 @@ function lowerExprInner(lowerer, expr) {
         // type-mapper.ts pins the one concrete signature `(value: string) =>
         // primitive`; direct calls `String(x)` never reach here — the call
         // lowering intercepts them with the wider static coercions).
-        const jsPrimitiveCtorSelector = isJsSourceFile(expr.getSourceFile()) &&
-            expr.parent !== undefined &&
-            ts.isArrowFunction(expr.parent) &&
-            expr.parent.body === expr;
-        if ((expr.text === "String" || expr.text === "Number" || expr.text === "Boolean") &&
-            (!isJsSourceFile(expr.getSourceFile()) || jsPrimitiveCtorSelector) &&
-            lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(expr))) {
-            return primitiveCtorClosure(lowerer, expr.text, loc, jsPrimitiveCtorSelector);
+        const jsPrimitiveCtorSelector = isJsSourceFile(expr.getSourceFile());
+        const primitiveName = stdlibGlobalNameOf(lowerer, expr);
+        if (primitiveName === "String" || primitiveName === "Number" || primitiveName === "Boolean" || primitiveName === "BigInt") {
+            return primitiveCtorClosure(lowerer, primitiveName, loc, jsPrimitiveCtorSelector);
+        }
+        if (lowerer.isStdlibGlobal(expr, "ArrayBuffer"))
+            return { kind: "libCall", fn: "arrayBuffer.constructor", args: [], type: DYN, loc };
+        if (Object.values(BYTES_ELEMENT_NAME).includes(expr.text) && lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(expr))) {
+            return { kind: "libCall", fn: "bytes.constructor", args: [{ kind: "strLit", value: expr.text, type: STRING, loc }], type: DYN, loc };
+        }
+        if ((expr.text === "encodeURIComponent" || expr.text === "encodeURI" || expr.text === "decodeURIComponent" || expr.text === "decodeURI") && lowerer.isStdlibGlobal(expr, expr.text)) {
+            const name = `%builtin.${expr.text}`;
+            const type = funcOf([DYN], STRING);
+            if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+                const value = { kind: "libCall", fn: "dyn.toStringCoerce", args: [varRef("value", DYN, loc)], type: STRING, loc };
+                const fn = expr.text === "encodeURIComponent" ? "str.encodeUriComponent" : expr.text === "encodeURI" ? "str.encodeUri" : expr.text === "decodeURI" ? "str.decodeUri" : "str.decodeUriComponent";
+                lowerer.liftedFns.push({ name, params: [{ localId: "value", name: "value", type: DYN }],
+                    locals: [{ id: "value", name: "value", type: DYN, mutable: false }], returnType: STRING,
+                    body: [{ kind: "return", value: { kind: "libCall", fn, args: [value], type: STRING, loc }, loc }], loc });
+            }
+            return { kind: "closure", fnName: name, captures: [], type, loc };
+        }
+        if (!lowerer.dynamic && lowerer.isStdlibGlobal(expr, "crypto"))
+            return { kind: "libCall", fn: "crypto.native", args: [], type: DYN, loc };
+        const nativeAlias = stdlibGlobalNameOf(lowerer, expr);
+        if (nativeAlias === "Buffer" && expr.text !== "Buffer") {
+            return { kind: "strLit", value: "[builtin Buffer]", type: STRING, loc };
+        }
+        if (!lowerer.dynamic && lowerer.isStdlibGlobal(expr, "fetch")) {
+            return { kind: "libCall", fn: "fetch.function", args: [], type: DYN, loc };
         }
         // The lib fence's IDENTIFIER chokepoint: the real standard library
         // resolves names the old minimal ambient world never declared
@@ -1260,8 +1290,13 @@ function lowerExprInner(lowerer, expr) {
         // `this` in plain nested functions is already a tsc error under
         // noImplicitThis, so the generic scope walk here is preflight-safe.
         const local = lowerer.resolveThis();
-        if (local)
-            return { kind: "varRef", localId: local.id, type: local.type, loc };
+        if (local) {
+            const value = { kind: "varRef", localId: local.id, type: local.type, loc };
+            const initialized = lowerer.ctx.superInitialized;
+            if (initialized)
+                return { kind: "seqExpr", stmts: [{ kind: "if", cond: { kind: "unary", op: "!", operand: { kind: "varRef", localId: initialized.id, type: BOOL, loc }, type: BOOL, loc }, then: [{ kind: "exprStmt", expr: nodeThrowExpr(5, "", "Must call super constructor in derived class before accessing 'this' or returning from derived constructor", DYN, loc), loc }], else_: null, loc }], result: value, type: value.type, loc };
+            return value;
+        }
         // `this` in a plain JS FUNCTION (not a method): the AMBIENT
         // RECEIVER (libCall dyn.this — scr_dyn_this_get). Firing sites bind
         // the emitting handle around each listener call (Node calls
@@ -1456,6 +1491,12 @@ function lowerExprInner(lowerer, expr) {
         const prototypeData = lowerClassPrototypeData(lowerer, expr);
         if (prototypeData)
             return prototypeData;
+        if (ts.isPropertyAccessExpression(expr.expression) && expr.expression.name.text === "prototype") {
+            const prototype = lowerClassPrototypeData(lowerer, expr.expression);
+            if (prototype)
+                return { kind: "dynKeyGet", value: prototype,
+                    key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
+        }
         // `super.x`: the base chain's GETTER, called directly (super
         // dispatch is static in JS — never through the dynamic class).
         // super.method() calls are routed at the call site; a bare super
@@ -1501,6 +1542,14 @@ function lowerExprInner(lowerer, expr) {
             ["iterator", "asyncIterator", "toStringTag", "toPrimitive", "hasInstance", "isConcatSpreadable", "match", "matchAll", "replace", "search", "split", "species", "unscopables", "dispose", "asyncDispose"].includes(expr.name.text)) {
             return { kind: "libCall", fn: "sym.wellKnown", args: [{ kind: "strLit", value: expr.name.text, type: STRING, loc }], type: { kind: "symbol" }, loc };
         }
+        if (!lowerer.dynamic && lowerer.stdlibGlobalMember(expr, "Object") === "freeze") {
+            const name = "%builtin.Object.freeze";
+            if (!lowerer.liftedFns.some((fn) => fn.name === name))
+                lowerer.liftedFns.push({ name,
+                    params: [{ localId: "value", name: "value", type: DYN }], locals: [{ id: "value", name: "value", type: DYN, mutable: false }], returnType: DYN,
+                    body: [{ kind: "return", value: { kind: "libCall", fn: "dyn.freeze", args: [varRef("value", DYN, loc)], type: DYN, loc }, loc }], loc });
+            return { kind: "closure", fnName: name, captures: [], type: funcOf([DYN], DYN), loc };
+        }
         if (lowerer.stdlibGlobalMember(expr, "globalThis") === "console") {
             return { kind: "libCall", fn: "console.native", args: [], type: DYN, loc };
         }
@@ -1586,15 +1635,6 @@ function lowerExprInner(lowerer, expr) {
             }
             return read;
         }
-        // `m.groups` on a match result whose regex is statically known:
-        // the compile-time record projection over the honest slice (or
-        // Node's undefined when the pattern has no named groups) — see
-        // lowerMatchGroupsRead.
-        {
-            const g = lowerMatchGroupsRead(lowerer, expr);
-            if (g !== null)
-                return g;
-        }
         // `m.index` on a for-of-over-matchAll binding reads the companion-
         // index array at this iteration's cursor — always a number: every
         // drained row matched, so the lib's `.index` is never undefined
@@ -1612,6 +1652,25 @@ function lowerExprInner(lowerer, expr) {
                 };
             }
         }
+        if ((expr.name.text === "index" || expr.name.text === "input") && !expr.questionDotToken) {
+            const represented = tryLowerExpression(lowerer, expr.expression);
+            if (represented && isMatchSliceType(lowerer, represented.type) &&
+                (lowerer.isStdlibMember(expr) || isJsSourceFile(expr.getSourceFile()))) {
+                const recv = represented;
+                const read = { kind: "dynKeyGet", value: lowerer.coerceToExpected(recv, DYN),
+                    key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc };
+                return lowerer.maybeNarrow(read, expr);
+            }
+        }
+        // `m.groups` on a match result whose regex is statically known:
+        // the compile-time record projection over the honest slice (or
+        // Node's undefined when the pattern has no named groups) — see
+        // lowerMatchGroupsRead.
+        {
+            const g = lowerMatchGroupsRead(lowerer, expr);
+            if (g !== null)
+                return g;
+        }
         // `arguments.length` in a TYPED function whose signature is
         // FIXED-ARITY (no optional/default/rest parameters): tsc enforces
         // exact arity at every call site and call/apply/bind indirection is
@@ -1833,6 +1892,12 @@ function lowerExprInner(lowerer, expr) {
             if (canonical !== null) {
                 if (!lowerer.dynamic && canonical === "globalThis")
                     return lowerGlobalValue(lowerer, expr);
+                if (!lowerer.dynamic && canonical === "ArrayBuffer")
+                    return { kind: "libCall", fn: "arrayBuffer.constructor", args: [], type: DYN, loc };
+                if (!lowerer.dynamic && canonical === "fetch")
+                    return { kind: "libCall", fn: "fetch.function", args: [], type: DYN, loc };
+                if (!lowerer.dynamic && Object.values(BYTES_ELEMENT_NAME).includes(canonical))
+                    return { kind: "libCall", fn: "bytes.constructor", args: [{ kind: "strLit", value: canonical, type: STRING, loc }], type: DYN, loc };
                 return { kind: "strLit", value: `[builtin ${canonical}]`, type: STRING, loc };
             }
         }
@@ -1921,10 +1986,14 @@ function lowerExprInner(lowerer, expr) {
         // is an ordinary recordGet — maybeNarrow then bridges the union slot
         // to the checker's narrowed arm, exactly like a union field read.
         if (expr.name.text === "done" || expr.name.text === "value") {
-            const recvSym = lowerer.typeOf(expr.expression).getSymbol();
-            if ((recvSym?.name === "IteratorYieldResult" || recvSym?.name === "IteratorReturnResult") &&
-                lowerer.checker.declarationsOf(recvSym).some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
+            const receiverType = lowerer.typeOf(expr.expression);
+            const recvSym = receiverType.getAliasSymbol()?.name === "IteratorResult" ? receiverType.getAliasSymbol() : receiverType.getSymbol();
+            if ((recvSym?.name === "IteratorResult" || recvSym?.name === "IteratorYieldResult" || recvSym?.name === "IteratorReturnResult") &&
+                lowerer.checker.declarationsOf(recvSym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isTypeAliasDeclaration(d)) && lowerer.isStdlibFile(d.getSourceFile()))) {
                 const recv = lowerer.lowerExpr(expr.expression);
+                if (recv.type.kind === "dyn")
+                    return lowerer.maybeNarrow({ kind: "dynKeyGet", value: recv,
+                        key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc }, expr);
                 if (recv.type.kind === "record") {
                     const shape = lowerer.shapes.get(recv.type.shapeId);
                     const field = shape?.fields.find((f) => f.name === expr.name.text);
@@ -2021,10 +2090,11 @@ function lowerExprInner(lowerer, expr) {
         // on undefined/null receivers unless an earlier `?.` guards the
         // chain. Scalar-narrowed occurrences bridge via maybeNarrow's
         // validated dynCheck as usual.
-        if (recvLowered.type.kind === "dyn") {
+        if (recvLowered.type.kind === "dyn" || isJsSourceFile(expr.getSourceFile()) &&
+            ["f64", "bool", "bigint", "string", "symbol"].includes(recvLowered.type.kind)) {
             const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
             const opt = hasOptionalChainGuard(expr.expression);
-            return lowerer.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: recvLowered, type: DYN, loc }, expr);
+            return lowerer.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: lowerer.coerceToExpected(recvLowered, DYN), type: DYN, loc }, expr);
         }
         // The lowered receiver is a RECORD the checker spelled wider —
         // `s.match(re).groups.key` in a JS file: the checker says
@@ -2074,6 +2144,16 @@ function lowerExprInner(lowerer, expr) {
         // reports a class. Its property bag must remain reachable, while
         // an absent element takes the normal checked-value TypeError.
         const nativeReceiver = lowerer.stripUndefinedArm(recvLowered.type);
+        if (ts.isPrivateIdentifier(expr.name) && recvLowered.type.kind === "object") {
+            const field = lowerer.classes.get(recvLowered.type.className)?.fields.get(expr.name.text);
+            if (field)
+                return { kind: "fieldGet", obj: recvLowered, className: recvLowered.type.className,
+                    field: expr.name.text, type: field, loc };
+        }
+        if (nativeReceiver.kind === "object" && nativeReceiver.className === "%Error") {
+            return lowerer.maybeNarrow({ kind: "dynKeyGet", value: lowerer.coerceToExpected(recvLowered, DYN),
+                key: { kind: "strLit", value: expr.name.text, type: STRING, loc }, type: DYN, loc }, expr);
+        }
         if (isDynTypedRefType(nativeReceiver)) {
             const info = lowerer.classes.get(nativeReceiver.className);
             if (info && !info.def.runtime && !info.builtinError && !info.builtinEmitter && !info.builtinStream) {
@@ -2107,7 +2187,7 @@ function moduleFileName(lowerer, sf) {
         : sf.fileName;
 }
 function importMetaProperty(lowerer, expr) {
-    if (expr.questionDotToken !== undefined || !ts.isMetaProperty(expr.expression))
+    if (!ts.isMetaProperty(expr.expression))
         return null;
     const meta = expr.expression;
     if (meta.keywordToken !== ts.SyntaxKind.ImportKeyword || meta.name.text !== "meta")
@@ -2115,6 +2195,8 @@ function importMetaProperty(lowerer, expr) {
     const sf = expr.getSourceFile();
     const fileName = moduleFileName(lowerer, sf);
     switch (expr.name.text) {
+        case "env":
+            return dynUndefinedExpr(locOf(expr));
         case "url":
             return {
                 kind: "strLit",
@@ -2398,7 +2480,13 @@ export function lowerTernary(lowerer, expr, expected) {
             thenRaw.type.kind === "func" && elseRaw.type.kind === "func" &&
             !typeEquals(thenRaw.type, elseRaw.type) &&
             lowerer.dynConvertible(thenRaw.type) && lowerer.dynConvertible(elseRaw.type);
-        const type = callableJoin ? DYN :
+        // JavaScript inference can discard an initially-undefined field from
+        // a conditional's type even after that field acquired other values.
+        // A checked arm must retain its actual representation at the join.
+        const checkedJsJoin = isJsSourceFile(expr.getSourceFile()) &&
+            (thenRaw.type.kind === "dyn" || elseRaw.type.kind === "dyn") &&
+            lowerer.dynConvertible(thenRaw.type) && lowerer.dynConvertible(elseRaw.type);
+        const type = callableJoin || checkedJsJoin ? DYN :
             thenRaw.type.kind === "array" && typeEquals(thenRaw.type, elseRaw.type)
                 ? thenRaw.type
                 : dynJoin
@@ -2454,6 +2542,11 @@ export function maybeNarrow(lowerer, expr, node) {
     if (expr.type.kind === "dyn") {
         if (isJsSourceFile(node.getSourceFile()) && ts.isIdentifier(node)) {
             const symbol = lowerer.resolveValueSymbol(node);
+            if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => ts.isVariableDeclaration(decl) && jsBindingHasOpenWrites(lowerer, decl)))
+                return expr;
+            if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => ts.isParameter(decl) && decl.initializer && !decl.type &&
+                !/@(?:param|type)\b/.test(decl.getSourceFile().text.slice(decl.parent?.pos ?? decl.pos, decl.getStart()))))
+                return expr;
             if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => {
                 if (!ts.isParameter(decl) || decl.type)
                     return false;
@@ -3003,6 +3096,10 @@ function lowerNullishPair(lowerer, expr, loc, left) {
     if (fresh)
         return { kind: "nullish", left, right: fresh, type: fresh.type, loc };
     const type = lowerer.irTypeOf(expr);
+    if (type.kind === "dyn" && lowerer.dynConvertible(left.type)) {
+        return { kind: "nullish", left: lowerer.coerceToExpected(left, DYN),
+            right: lowerer.lowerExprExpecting(expr.right, DYN), type: DYN, loc };
+    }
     if (typeEquals(type, left.type) || (rest.length === 1 && typeEquals(type, rest[0]))) {
         const right = lowerer.lowerExprExpecting(expr.right, type);
         return { kind: "nullish", left, right, type, loc };
@@ -3073,6 +3170,8 @@ export function lowerCondition(lowerer, expr) {
         if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
             const isAnd = op === ts.SyntaxKind.AmpersandAmpersandToken;
             const left = lowerer.lowerCondition(e.left);
+            if (left.kind === "boolLit" && left.value !== isAnd)
+                return left;
             // The right operand evaluates only when the left already answered
             // (true for &&, false for ||) — aliased-typeof narrows the left
             // PROVES under that polarity hold while it lowers (`type ===
@@ -3089,6 +3188,8 @@ export function lowerCondition(lowerer, expr) {
                     lowerer.runtimeOptionalLocals.add(lowerer.runtimeOptionalRootOf(runtimeOptionalLocal));
                 }
             });
+            if (left.kind === "boolLit")
+                return right;
             return {
                 kind: "logical",
                 op: isAnd ? "&&" : "||",
@@ -3366,13 +3467,56 @@ export function eqComparableUnion(lowerer, unionId) {
    * the receiver type AND the ambient-file provenance of the member are
    * verified — the name alone proves nothing. */
 export function lowerIntrinsicProperty(lowerer, expr) {
+    for (const name of ["String", "Number", "Boolean", "BigInt"]) {
+        if (!lowerer.chainBlocked(expr) && lowerer.isStdlibGlobal(expr, name)) {
+            return primitiveCtorClosure(lowerer, name, locOf(expr), isJsSourceFile(expr.getSourceFile()));
+        }
+    }
+    if (lowerer.stdlibGlobalMember(expr, "Reflect") === "ownKeys") {
+        const value = lowerer.lowerNativeCallableValue({
+            fn: "dyn.ownKeys", params: [DYN], result: DYN, valueParams: [{ mode: "required", type: DYN }],
+        }, "Reflect.ownKeys", locOf(expr));
+        return { kind: "dynFrom", value, fnName: "ownKeys", type: DYN, loc: locOf(expr) };
+    }
     if (lowerer.chainBlocked(expr))
         return null;
+    const builtinPrototype = builtinPrototypeMethod(lowerer, expr);
+    if (builtinPrototype)
+        return { kind: "libCall", fn: "dyn.builtinMethod", args: [
+                { kind: "strLit", value: builtinPrototype, type: STRING, loc: locOf(expr) },
+                { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) },
+            ], type: DYN, loc: locOf(expr) };
+    if (ts.isPropertyAccessExpression(expr.expression) &&
+        lowerer.stdlibGlobalMember(expr.expression, "Array") === "prototype") {
+        return { kind: "dynKeyGet", value: { kind: "libCall", fn: "dyn.arrayPrototype", args: [], type: DYN, loc: locOf(expr.expression) },
+            key: { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) }, type: DYN, loc: locOf(expr) };
+    }
+    if (expr.name.text === "apply" && ts.isPropertyAccessExpression(expr.expression) &&
+        lowerer.stdlibGlobalMember(expr.expression, "Function") === "prototype")
+        return { kind: "libCall", fn: "dyn.functionApply", args: [], type: DYN, loc: locOf(expr) };
     if (lowerer.stdlibGlobalMember(expr, "Array") === "prototype")
         return { kind: "libCall", fn: "dyn.arrayPrototype", args: [], type: DYN, loc: locOf(expr) };
+    if (lowerer.stdlibGlobalMember(expr, "Object") === "prototype")
+        return { kind: "libCall", fn: "dyn.objectPrototype", args: [], type: DYN, loc: locOf(expr) };
     if (lowerer.stdlibGlobalMember(expr, "Array") === "isArray")
         return lowerArrayIsArrayValue(lowerer, locOf(expr));
+    if (lowerer.stdlibGlobalMember(expr, "Array") === "from")
+        return lowerArrayFromValue(lowerer, locOf(expr));
+    const stringMember = lowerer.stdlibGlobalMember(expr, "String");
+    if (stringMember === "fromCharCode" || stringMember === "fromCodePoint")
+        return lowerStringCodesValue(lowerer, stringMember, locOf(expr));
+    const numberMember = lowerer.stdlibGlobalMember(expr, "Number");
+    if (numberMember === "parseInt" || numberMember === "parseFloat")
+        return lowerNumberParserValue(lowerer, numberMember, locOf(expr));
+    if (lowerer.stdlibGlobalMember(expr, "Buffer") === "isBuffer")
+        return lowerCheckedPredicateValue(lowerer, "Buffer.isBuffer", "buffer", locOf(expr));
+    if (lowerer.stdlibGlobalMember(expr, "Date") === "now")
+        return lowerer.lowerNativeCallableValue({
+            fn: "date.now", params: [], result: F64, valueParams: [],
+        }, "Date.now", locOf(expr));
     if (stdlibGlobalNameOf(lowerer, expr.expression) === "Object") {
+        if (expr.name.text === "assign")
+            return lowerObjectAssignValue(lowerer, locOf(expr));
         const fn = own(OBJECT_CALLABLE_VALUES, expr.name.text);
         if (fn)
             return lowerer.lowerNativeCallableValue(fn, `Object.${expr.name.text}`, locOf(expr));
@@ -3410,6 +3554,15 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     if (kind === "child" ? !isChildSurfaceMember(lowerer, expr) : !tupleLengthOnArray && !lowerer.isStdlibMember(expr))
         return null;
     const name = expr.name.text;
+    if (kind === "array" && name === "constructor" && isJsSourceFile(expr.getSourceFile())) {
+        const receiver = lowerer.lowerExpr(expr.expression);
+        if (receiver.type.kind === "dyn")
+            return { kind: "dynKeyGet", value: receiver,
+                key: { kind: "strLit", value: name, type: STRING, loc: locOf(expr) }, type: DYN, loc: locOf(expr) };
+        // Ordinary arrays keep the existing Array builtin identity token.
+        const result = { kind: "strLit", value: "[builtin Array]", type: STRING, loc: locOf(expr) };
+        return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc: locOf(expr) }], result, type: STRING, loc: locOf(expr) };
+    }
     const strictReceiver = (expected) => {
         const value = lowerer.lowerExpr(expr.expression);
         if (value.type.kind === "dyn")
@@ -3585,6 +3738,9 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         lowerer.noLowering(`URLSearchParams.${name}`, expr, "get, getAll, set, append, delete, has, sort, size, toString(), forEach, and for-of iteration are the supported URLSearchParams members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "regex") {
+        if (name === "lastIndex") {
+            return { kind: "regexIntrinsic", method: "lastIndex", receiver: strictReceiver({ kind: "regex" }), args: [], type: F64, loc: locOf(expr) };
+        }
         if (name === "source" || name === "flags") {
             const receiver = strictReceiver({ kind: "regex" });
             return { kind: "regexIntrinsic", method: name, receiver, args: [], type: STRING, loc: locOf(expr) };
@@ -3604,6 +3760,12 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     }
     if (kind === "bytes") {
         const loc = locOf(expr);
+        if (name === "constructor") {
+            const expected = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
+            const receiver = expected?.kind === "bytes" ? strictReceiver(expected) : lowerer.lowerExpr(expr.expression);
+            return { kind: "dynKeyGet", value: lowerer.coerceInto(expr.expression, receiver, DYN),
+                key: { kind: "strLit", value: name, type: STRING, loc }, type: DYN, loc };
+        }
         if (name === "length" || name === "byteLength") {
             const expected = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
             let receiver = expected?.kind === "bytes"
@@ -3674,9 +3836,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         const expected = kind === "string"
             ? STRING
             : lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
-        let receiver = expected && (expected.kind === "string" || expected.kind === "array")
-            ? strictReceiver(expected)
-            : lowerer.lowerExpr(expr.expression);
+        let receiver = lowerer.lowerExpr(expr.expression);
+        if (receiver.type.kind !== "dyn" && expected && (expected.kind === "string" || expected.kind === "array")) {
+            receiver = lowerer.runtimeOptionalPropertyReceiver(expr.expression, receiver, expected, name) ?? receiver;
+        }
         if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0 && kind === "array") {
             const present = lowerer.stripUndefinedArm(receiver.type);
             const helper = present.kind === "array"
@@ -3742,6 +3905,19 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
     // destination can use the ordinary tuple-to-array coercion afterward.
     const tsType = underConstAssertion(expr) ? lowerer.typeOf(expr) : ctxType ?? lowerer.typeOf(expr);
     let mapped = expected ?? lowerer.mapTypeOf(tsType);
+    // Inferred JavaScript arrays can contain unrelated constructors with
+    // structurally equal checker types. Their native class ABIs still differ.
+    if (!expected && isJsSourceFile(expr.getSourceFile()) && mapped?.kind === "array" && mapped.elem.kind === "classval")
+        mapped = DYN;
+    // An inferred destructuring pattern supplies a contextual [any, ...]
+    // tuple. Its positions do not erase the literal's inferred element
+    // types; explicit destinations already arrive through expected.
+    if (expected === undefined && ctxType && lowerer.checker.isTupleType(ctxType) &&
+        lowerer.checker.getTypeArguments(ctxType).some((type) => (type.flags & ts.TypeFlags.Any) !== 0)) {
+        const inferred = lowerer.mapTypeOf(lowerer.typeOf(expr));
+        if (inferred?.kind === "array" || inferred?.kind === "record" && lowerer.shapes.get(inferred.shapeId)?.tuple)
+            mapped = inferred;
+    }
     // A JS literal whose OWN inferred type is never-tainted
     // (neverTaintedJsType — the evolving `const gb = []`, the mixed
     // command tuple `['pwd', []]`) carries no element information: route
@@ -3838,6 +4014,12 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
             mapped = arrayOf(first.type);
         }
     }
+    if (!expected && isJsSourceFile(expr.getSourceFile()) && mapped?.kind === "array") {
+        const elem = mapped.elem;
+        const arms = elem.kind === "union" ? lowerer.unions.get(elem.unionId)?.arms : [elem];
+        if (arms?.length && arms.every((arm) => arm.kind === "classval"))
+            mapped = DYN;
+    }
     // An EMPTY literal under a CONST ASSERTION whose type queries panicked
     // (tsgo's readonly-[] TupleType conversion — the facade answers `any`,
     // which maps to nothing statically and to an island value under
@@ -3849,6 +4031,11 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         underConstAssertion(expr)) {
         mapped = arrayOf(unitOnlyUnion(lowerer.unions));
     }
+    // Heterogeneous JavaScript object arrays must retain each literal's
+    // real keys. A structural union can otherwise drop descriptor fields.
+    if (!expected && isJsSourceFile(expr.getSourceFile()) && mapped?.kind === "array" && mapped.elem.kind === "union" &&
+        expr.elements.some(ts.isObjectLiteralExpression))
+        mapped = DYN;
     // A TUPLE-typed slot (`const t: [string, number] = ["a", 1]`): the
     // literal constructs the tuple's record shape — one positional field
     // per element, source order (which IS index order, so evaluation order
@@ -3904,7 +4091,7 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         // `unknown[]` annotation or a collapsed `(string | object)[]` maps
         // to DYN wholesale now (mapType's dyn-element array rule), so the
         // literal IS the dyn array.
-        if (isJsSourceFile(expr.getSourceFile()) || mapped?.kind === "dyn") {
+        if (isJsSourceFile(expr.getSourceFile()) || mapped?.kind === "dyn" || lowerer.checkerAnyArray(expr)) {
             if (expr.elements.some(ts.isSpreadElement)) {
                 // Native collection drains return vectors of retained dyn
                 // elements. Reuse the ordinary spread builder, then expose the
@@ -3998,11 +4185,7 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
             // the checker inferred a typed array from its producer. Drain once
             // and validate the elements before the ordinary spread copy.
             if (src.type.kind === "dyn" && (type.elem.kind === "dyn" || type.elem.kind === "f64" || type.elem.kind === "string" || type.elem.kind === "bool")) {
-                src = lowerer.coerceInto(el.expression, {
-                    kind: "libCall", fn: "dyn.iterPack", args: [src,
-                        { kind: "strLit", value: el.expression.getText(), type: STRING, loc: locOf(el) }],
-                    type: DYN, loc: locOf(el),
-                }, type);
+                src = lowerer.coerceInto(el.expression, checkedIteratorPack(lowerer, src, locOf(el)), type);
             }
             // A same-family array whose ELEMENT lifts (string[] into a
             // (string | symbol)[] literal — per-element wrap/width copy):
@@ -4320,7 +4503,11 @@ export function lowerElementAccess(lowerer, expr) {
         if (target)
             return lowerer.maybeNarrow(lowerer.fieldGetExpr(target, locOf(expr), expr), expr);
         let receiver = lowerer.lowerExpr(expr.expression);
-        if (receiver.type.kind === "func") {
+        const classInfo = receiver.type.kind === "classval" ? lowerer.classes.get(receiver.type.className) : undefined;
+        if (receiver.type.kind === "func" || receiver.type.kind === "generator" ||
+            ((receiver.type.kind === "array" || receiver.type.kind === "string" || receiver.type.kind === "bytes") && lowerer.dynConvertible(receiver.type)) ||
+            (receiver.type.kind === "object" && lowerer.dynConvertible(receiver.type)) || isDynTypedRefType(receiver.type) ||
+            (classInfo && (classInfo.callableBase || hasRuntimeStatics(classInfo))) || ((receiver.type.kind === "map" || receiver.type.kind === "set") && lowerer.dynConvertible(receiver.type))) {
             const fnName = jsFuncNameOf(expr.expression);
             receiver = { kind: "dynFrom", value: receiver, type: DYN, loc: locOf(expr),
                 ...(fnName !== null ? { fnName } : {}) };
@@ -4340,11 +4527,17 @@ export function lowerElementAccess(lowerer, expr) {
         : lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
     if (isJsSourceFile(expr.getSourceFile())) {
         const receiver = tryLowerExpression(lowerer, expr.expression);
+        if (receiver?.type.kind === "dyn") {
+            const key = lowerer.lowerExprExpecting(expr.argumentExpression, DYN);
+            const optional = hasOptionalChainGuard(expr.expression);
+            return lowerer.maybeNarrow({ kind: "dynKeyGet", value: receiver, key,
+                ...(optional ? { optional: true } : {}), type: DYN, loc: locOf(expr) }, expr);
+        }
         if (receiver?.type.kind === "func" && lowerer.dynConvertible(receiver.type)) {
             const loc = locOf(expr);
             const fnName = jsFuncNameOf(expr.expression);
             const boxed = { kind: "dynFrom", value: receiver, type: DYN, loc, ...(fnName !== null ? { fnName } : {}) };
-            const key = lowerRecordPropertyKey(lowerer, lowerer.lowerExpr(expr.argumentExpression), expr.argumentExpression);
+            const key = lowerer.lowerExprExpecting(expr.argumentExpression, DYN);
             return lowerer.maybeNarrow({ kind: "dynKeyGet", key, value: boxed, type: DYN, loc }, expr);
         }
     }
@@ -4363,7 +4556,7 @@ export function lowerElementAccess(lowerer, expr) {
             if (target)
                 return lowerer.maybeNarrow(lowerer.fieldGetExpr(target, locOf(expr), expr), expr);
         }
-        if (isDynTypedRefType(receiverIr)) {
+        if (receiverIr.className === "%Error" || isDynTypedRefType(receiverIr)) {
             const receiver = lowerer.coerceToExpected(lowerer.lowerExpr(expr.expression), DYN);
             const key = lowerer.lowerExprExpecting(expr.argumentExpression, DYN);
             return lowerer.maybeNarrow({ kind: "dynKeyGet", value: receiver, key, type: DYN, loc: locOf(expr) }, expr);
@@ -4412,6 +4605,11 @@ export function lowerElementAccess(lowerer, expr) {
         if (recv.type.kind === "jsval")
             return islandElementRead(lowerer, expr, recv);
         const index = lowerer.lowerExpr(expr.argumentExpression);
+        if (isJsSourceFile(expr.getSourceFile()) && recv.type.kind === "bytes") {
+            return { kind: "dynKeyGet", value: lowerer.coerceInto(expr.expression, recv, DYN),
+                key: index.type.kind === "f64" ? { kind: "toString", operand: index, type: STRING, loc: locOf(expr) } : index,
+                type: DYN, loc: locOf(expr) };
+        }
         if (index.type.kind === "dyn" && recv.type.kind === "bytes") {
             return { kind: "dynKeyGet", value: lowerer.coerceInto(expr.expression, recv, DYN), key: index, type: DYN, loc: locOf(expr) };
         }
@@ -4509,16 +4707,21 @@ export function lowerElementAccess(lowerer, expr) {
         // Dispatch from that stored shape, as the array fallback below does.
         if (receiverIr === null && obj.type.kind === "record") {
             const shape = lowerer.shapes.get(obj.type.shapeId);
+            const index = tupleLiteralIndex(expr.argumentExpression);
+            const field = shape?.tuple && index !== null ? shape.fields.find((field) => field.name === String(index)) : null;
+            if (field)
+                return lowerer.maybeNarrow({ kind: "recordGet", obj, shapeId: obj.type.shapeId, field: field.name, type: field.type, loc: locOf(expr) }, expr);
             if (shape && !shape.tuple) {
                 return lowerer.lowerRecordKeyRead(expr, obj.type.shapeId, shape);
             }
         }
-        if (obj.type.kind === "dyn" || isDynTypedRefType(obj.type)) {
+        if (obj.type.kind === "dyn" || obj.type.kind === "object" && obj.type.className === "%Error" || isDynTypedRefType(obj.type)) {
             const rawKey = lowerer.lowerExpr(expr.argumentExpression);
             // Number, bool, and DYN keys stringify (ToPropertyKey) — the
             // dyn-keyed read `catchWarning[warning.name]` where the property
             // chain itself lowered dyn.
-            const key = rawKey.type.kind === "dyn" || rawKey.type.kind === "symbol"
+            const key = rawKey.type.kind === "dyn" || rawKey.type.kind === "symbol" ||
+                rawKey.type.kind === "union" && lowerer.dynConvertible(rawKey.type)
                 ? lowerer.coerceToExpected(rawKey, DYN)
                 : lowerRecordPropertyKey(lowerer, rawKey, expr.argumentExpression);
             if (key.type.kind === "string" || key.type.kind === "dyn") {
@@ -4692,6 +4895,11 @@ export function lowerElementAccess(lowerer, expr) {
     // is undefined, whose property lookup misses just like NaN; keep that
     // value instead of rejecting a checker-number index with optional IR.
     const index = lowerOptionalNumber(lowerer, lowerer.lowerExpr(expr.argumentExpression), locOf(expr.argumentExpression), expr.argumentExpression);
+    if (arr.type.kind === "array" && (index.type.kind === "dyn" ||
+        isJsSourceFile(expr.getSourceFile()) && index.type.kind !== "f64" && lowerer.dynConvertible(index.type))) {
+        return { kind: "dynKeyGet", value: lowerer.coerceToExpected(arr, DYN),
+            key: index, type: DYN, loc: locOf(expr) };
+    }
     if (index.type.kind !== "f64") {
         lowerer.unsupported("SC1090", expr.argumentExpression, "indexing with non-number keys");
     }
@@ -4802,8 +5010,11 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
         // Number AND checked-dynamic keys ride the JS-exact formatter —
         // property keys ARE strings (o[k] is o[String(k)] in JS), and a dyn
         // key (agent.sockets[agent.getName(...)]) stringifies the same way.
-        dk = lowerRecordPropertyKey(lowerer, dk, keyNode);
-        if (dk.type.kind !== "string") {
+        if (dk.type.kind === "union" && lowerer.dynConvertible(dk.type))
+            dk = lowerer.coerceToExpected(dk, DYN);
+        if (dk.type.kind !== "symbol" && dk.type.kind !== "dyn")
+            dk = lowerRecordPropertyKey(lowerer, dk, keyNode);
+        if (dk.type.kind !== "string" && dk.type.kind !== "symbol" && dk.type.kind !== "dyn") {
             lowerer.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys");
         }
         const read = { kind: "dynKeyGet", key: dk, value: obj, type: DYN, loc };
@@ -4850,6 +5061,19 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
     let key = litKey !== null
         ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(keyNode) }
         : lowerer.lowerExpr(keyNode);
+    // Optional string/number keys need ToPropertyKey, not a boxed copy of
+    // the receiver. Keep record reads on their native storage so nested
+    // references retain identity across index-signature reads.
+    if (key.type.kind === "union" &&
+        !lowerer.unions.get(key.type.unionId)?.arms.some((arm) => arm.kind === "symbol" || arm.kind === "dyn")) {
+        key = lowerRecordPropertyKey(lowerer, key, keyNode);
+    }
+    if ((key.type.kind === "symbol" || key.type.kind === "dyn" || key.type.kind === "union") &&
+        lowerer.dynConvertible(key.type) && lowerer.dynConvertible(obj.type)) {
+        const read = { kind: "dynKeyGet", value: lowerer.coerceToExpected(obj, DYN),
+            key: lowerer.coerceToExpected(key, DYN), type: DYN, loc };
+        return includeUndefined ? read : lowerer.maybeNarrow(read, expr);
+    }
     // Runtime NUMBER keys ride the JS-exact formatter (o[n] is o[String(n)]
     // in JS — the number-keyed-signature access path).
     key = lowerRecordPropertyKey(lowerer, key, keyNode);
@@ -4914,6 +5138,9 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
  * values remain real undefined values, whose JavaScript property spelling
  * is the string "undefined". */
 function lowerRecordPropertyKey(lowerer, key, node) {
+    if (key.type.kind === "union" && lowerer.dynConvertible(key.type)) {
+        return { kind: "libCall", fn: "dyn.toStringCoerce", args: [lowerer.coerceInto(node, key, DYN)], type: STRING, loc: key.loc };
+    }
     if (key.type.kind === "f64" || key.type.kind === "bool" || key.type.kind === "dyn" ||
         lowerer.runtimeOptionalWidening(key.type, STRING) !== null) {
         return lowerer.ensureString(key, node);
@@ -5079,11 +5306,29 @@ export function lowerElementCompound(lowerer, expr, op) {
     const target = expr.left;
     fenceNodeModuleMutation(lowerer, target, "assignment");
     const loc = locOf(expr);
-    const receiverType = lowerer.mapTypeOf(lowerer.typeOf(target.expression));
+    const checked = lowerer.lowerExpr(target.expression);
+    if (checked?.type.kind === "dyn" && isJsSourceFile(expr.getSourceFile())) {
+        const stmts = [];
+        const save = (value, name) => {
+            const local = lowerer.declareHiddenLocal(name, value.type);
+            stmts.push({ kind: "varDecl", localId: local.id, init: value, loc });
+            return varRef(local.id, value.type, loc);
+        };
+        const receiver = save(checked, "%compoundReceiver");
+        const key = save(lowerer.lowerExprExpecting(target.argumentExpression, DYN), "%compoundKey");
+        const old = save({ kind: "dynKeyGet", value: receiver, key, type: DYN, loc }, "%compoundOld");
+        const rhs = lowerer.lowerExprExpecting(expr.right, DYN);
+        const numeric = ["-", "*", "/", "%", "**"].includes(op);
+        const value = save({ kind: "libCall", fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+            args: op === "+" ? [old, rhs] : [old, rhs, strLit(op, loc)], type: DYN, loc }, "%compoundResult");
+        stmts.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySetComputed", args: [receiver, key, value], type: VOID, loc }, loc });
+        return { kind: "seqExpr", stmts, result: value, type: DYN, loc };
+    }
+    const receiverType = checked.type.kind === "array" || checked.type.kind === "bytes" ? checked.type : lowerer.mapTypeOf(lowerer.typeOf(target.expression));
     if (receiverType?.kind !== "array" && receiverType?.kind !== "bytes") {
         lowerer.unsupported("SC1090", target, "compound assignment to non-array elements");
     }
-    let receiver = lowerer.lowerExpr(target.expression);
+    let receiver = checked;
     if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0) {
         const present = lowerer.stripUndefinedArm(receiver.type);
         const helper = present.kind === receiverType.kind
@@ -5120,6 +5365,12 @@ export function lowerElementCompound(lowerer, expr, op) {
     else if (valueType.kind === "f64" && numericRhs.type.kind === "f64") {
         computed = { kind: "bin", op, left: lowerOptionalNumber(lowerer, oldRef(), loc), right: numericRhs, type: F64, loc };
     }
+    else if (valueType.kind === "dyn" && isJsSourceFile(expr.getSourceFile())) {
+        const left = lowerer.coerceToExpected(oldRef(), DYN), right = lowerer.coerceToExpected(rhs, DYN);
+        const numeric = ["-", "*", "/", "%", "**"].includes(op);
+        computed = { kind: "libCall", fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+            args: op === "+" ? [left, right] : [left, right, strLit(op, loc)], type: DYN, loc };
+    }
     else {
         lowerer.unsupported("SC1043", expr);
     }
@@ -5233,12 +5484,23 @@ export function lowerElementWrite(lowerer, expr) {
         const receiver = lowerer.lowerExpr(target.expression);
         if (receiver.type.kind === "dyn")
             return { kind: "exprStmt", expr: lowerDynMemberAssignment(lowerer, expr, receiver), loc: locOf(expr) };
+        if (isJsSourceFile(expr.getSourceFile()) && receiver.type.kind === "object" && lowerer.dynConvertible(receiver.type)) {
+            return { kind: "exprStmt", expr: lowerDynMemberAssignment(lowerer, expr, lowerer.coerceToExpected(receiver, DYN)), loc: locOf(expr) };
+        }
         lowerer.unsupported("SC1090", target, "symbol-keyed property writes outside class fields keyed by a stable module-level literal Symbol()/Symbol.for() (other static shapes have no symbol-keyed storage)");
     }
     const checkedReceiver = tryLowerExpression(lowerer, target.expression);
     if (checkedReceiver?.type.kind === "dyn") {
         return { kind: "exprStmt", expr: lowerDynMemberAssignment(lowerer, expr, checkedReceiver), loc: locOf(expr) };
     }
+    if (checkedReceiver?.type.kind === "object" && isJsSourceFile(expr.getSourceFile())) {
+        const info = lowerer.classes.get(checkedReceiver.type.className);
+        const key = recordKeyLiteralText(target.argumentExpression) ?? recordKeyTypeLiteralText(lowerer, target.argumentExpression);
+        if (info && key !== null && isClassCallback(lowerer, info, key)) {
+            const receiver = lowerer.coerceInto(target.expression, checkedReceiver, DYN);
+            return { kind: "exprStmt", expr: lowerDynMemberAssignment(lowerer, expr, receiver), loc: locOf(expr) };
+        }
+    }
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(target.expression));
     if (receiverIr === null || receiverIr.kind === "dyn") {
         const receiver = tryLowerExpression(lowerer, target.expression);
@@ -5307,13 +5569,15 @@ export function lowerElementWrite(lowerer, expr) {
                 return lowerer.fieldSetStmt(field, value, locOf(expr), target);
             }
             if (hasClassPayload(lowerer, receiver.type)) {
+                if (receiver.type.kind === "object" && receiver.type.className === "%Error") {
+                    return { kind: "exprStmt", expr: lowerDynMemberAssignment(lowerer, expr, lowerer.coerceInto(target.expression, receiver, DYN)), loc: locOf(expr) };
+                }
                 lowerer.unsupported("SC1090", target, "writing undeclared properties through structural views of class instances");
             }
         }
     }
     // Typed-array element write `b[i] = v` — bytesSet: the value is an f64
-    // the runtime coerces JS-exactly; invalid indices trap (no appends —
-    // typed arrays are fixed-length; JS would ignore the write).
+    // the runtime coerces JS-exactly; invalid indices are ignored.
     if (receiverIr?.kind === "bytes") {
         const recv = lowerer.lowerExpr(target.expression);
         // The write twin: a typed-array .d.ts surface whose VALUE is a
@@ -5499,7 +5763,7 @@ export function lowerElementWrite(lowerer, expr) {
     // write, anything else falls through to the fences.
     if (receiverIr?.kind === "dyn" || receiverIr?.kind === "object" || receiverIr === null) {
         const obj = receiverIr !== null ? lowerer.lowerExpr(target.expression) : tryLowerExpression(lowerer, target.expression);
-        if (obj !== null && (obj.type.kind === "dyn" || isDynTypedRefType(obj.type))) {
+        if (obj !== null && (obj.type.kind === "dyn" || obj.type.kind === "object" && obj.type.className === "%Error" || isDynTypedRefType(obj.type))) {
             const loc = locOf(expr);
             const litKey = recordKeyLiteralText(target.argumentExpression);
             let key = litKey !== null
@@ -5544,6 +5808,9 @@ export function lowerElementWrite(lowerer, expr) {
         lowerer.unsupported("SC1090", target.expression, "assignment through a possibly missing nested array receiver");
     }
     const index = lowerOptionalNumber(lowerer, lowerer.lowerExpr(target.argumentExpression), locOf(target.argumentExpression), target.argumentExpression);
+    if (index.type.kind === "dyn" && lowerer.dynConvertible(arr.type)) {
+        return { kind: "exprStmt", expr: lowerDynMemberAssignment(lowerer, expr, lowerer.coerceInto(target.expression, arr, DYN)), loc: locOf(expr) };
+    }
     if (index.type.kind !== "f64") {
         lowerer.unsupported("SC1090", target.argumentExpression, "indexing with non-number keys");
     }
@@ -5878,7 +6145,7 @@ export function lowerAsExpression(lowerer, expr) {
         return { kind: "jsExit", value: inner, type: target, loc: locOf(expr) };
     }
     const targetTs = lowerer.checker.getTypeFromTypeNode(expr.type);
-    const target = lowerer.mapTypeOf(targetTs);
+    const target = lowerer.mapTypeOf(targetTs) ?? dynFallbackType(lowerer, expr.type, targetTs);
     if (!target)
         lowerer.badType(expr.type, targetTs);
     if (target.kind === "dyn")
@@ -6040,6 +6307,25 @@ function lowerIncDec(lowerer, expr, prefix) {
         // accessor-backed names keep the fence.
         if ((ts.isPropertyAccessExpression(expr.operand) || ts.isElementAccessExpression(expr.operand)) &&
             !expr.operand.questionDotToken) {
+            if (ts.isPropertyAccessExpression(expr.operand) && isJsSourceFile(expr.getSourceFile())) {
+                const receiver = lowerer.lowerExpr(expr.operand.expression);
+                if (receiver.type.kind === "dyn") {
+                    const local = lowerer.declareHiddenLocal("%incrementReceiver", DYN);
+                    const old = lowerer.declareHiddenLocal("%incrementOld", DYN);
+                    const next = lowerer.declareHiddenLocal("%incrementNext", DYN);
+                    const value = varRef(local.id, DYN, loc);
+                    const key = { kind: "strLit", value: expr.operand.name.text, type: STRING, loc };
+                    return { kind: "seqExpr", stmts: [
+                            { kind: "varDecl", localId: local.id, init: receiver, loc },
+                            { kind: "varDecl", localId: old.id, init: { kind: "libCall", fn: "dyn.toNumeric", args: [
+                                        { kind: "dynKeyGet", value, key, type: DYN, loc },
+                                    ], type: DYN, loc }, loc },
+                            { kind: "varDecl", localId: next.id, init: { kind: "libCall", fn: "dyn.increment", args: [varRef(old.id, DYN, loc),
+                                        { kind: "boolLit", value: op === "+", type: BOOL, loc }], type: DYN, loc }, loc },
+                            { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [value, key, varRef(next.id, DYN, loc)], type: VOID, loc }, loc },
+                        ], result: varRef(prefix ? next.id : old.id, DYN, loc), type: DYN, loc };
+                }
+            }
             const target = ts.isPropertyAccessExpression(expr.operand)
                 ? lowerer.fieldTarget(expr.operand)
                 : symbolFieldTarget(lowerer, expr.operand);
@@ -6163,12 +6449,13 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
         return { kind: "bin", op: compound, left: read, right: numericRhs, type: F64, loc };
     }
     if ((target.type.kind === "dyn" || rhs.type.kind === "dyn") &&
-        (target.type.kind === "dyn" || target.type.kind === "f64") &&
-        (rhs.type.kind === "dyn" || rhs.type.kind === "f64") &&
         isJsSourceFile(expr.getSourceFile())) {
-        const checkNum = (value) => value.type.kind === "dyn" ? { kind: "dynCheck", value, type: F64, loc: value.loc } : value;
-        const computed = { kind: "bin", op: compound, left: checkNum(read), right: checkNum(rhs), type: F64, loc };
-        return target.type.kind === "dyn" ? { kind: "dynFrom", value: computed, type: DYN, loc } : computed;
+        const left = lowerer.coerceInto(expr.left, read, DYN);
+        const right = lowerer.coerceInto(expr.right, rhs, DYN);
+        const numeric = ["-", "*", "/", "%", "**"].includes(compound);
+        const computed = { kind: "libCall", fn: compound === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+            args: compound === "+" ? [left, right] : [left, right, { kind: "strLit", value: compound, type: STRING, loc }], type: DYN, loc };
+        return lowerer.coerceInto(expr, computed, target.type);
     }
     lowerer.unsupported("SC1043", expr);
 }
@@ -6293,8 +6580,30 @@ export function lowerBinary(lowerer, expr) {
             // key afterward, then yields the RHS without rereading the property.
             if (ts.isElementAccessExpression(expr.left) && !expr.left.questionDotToken) {
                 const recv = tryLowerExpression(lowerer, expr.left.expression);
-                if (recv?.type.kind === "dyn") {
-                    return lowerDynMemberAssignment(lowerer, expr, recv);
+                if (recv && (recv.type.kind === "dyn" ||
+                    recv.type.kind === "array" && isJsSourceFile(expr.getSourceFile()) && lowerer.dynConvertible(recv.type))) {
+                    return lowerDynMemberAssignment(lowerer, expr, lowerer.coerceInto(expr.left.expression, recv, DYN));
+                }
+                if (recv?.type.kind === "array" || recv?.type.kind === "bytes") {
+                    const receiver = lowerer.declareHiddenLocal("%setArray", recv.type);
+                    const index = lowerer.lowerExpr(expr.left.argumentExpression);
+                    if (index.type.kind !== "f64")
+                        lowerer.unsupported("SC1090", expr.left.argumentExpression, "indexing with non-number keys");
+                    const key = lowerer.declareHiddenLocal("%setIndex", F64);
+                    const raw = lowerer.lowerExpr(expr.right);
+                    const value = lowerer.declareHiddenLocal("%setValue", raw.type);
+                    const result = varRef(value.id, raw.type, loc);
+                    const arr = varRef(receiver.id, recv.type, loc);
+                    const idx = varRef(key.id, F64, loc);
+                    const write = recv.type.kind === "array"
+                        ? arrayValueStore(lowerer, arr, idx, result, recv.type.elem, loc)
+                        : { kind: "bytesSet", arr, index: idx, value: lowerer.coerceInto(expr.right, result, F64), loc };
+                    return { kind: "seqExpr", stmts: [
+                            { kind: "varDecl", localId: receiver.id, init: recv, loc },
+                            { kind: "varDecl", localId: key.id, init: index, loc },
+                            { kind: "varDecl", localId: value.id, init: raw, loc },
+                            write,
+                        ], result, type: result.type, loc };
                 }
             }
             // `h.k = v` on an ISLAND receiver in VALUE position: the engine
@@ -6337,32 +6646,8 @@ export function lowerBinary(lowerer, expr) {
             // consumer sees exactly what the checker typed.
             if (ts.isPropertyAccessExpression(expr.left) && !expr.left.questionDotToken) {
                 const recv = tryLowerExpression(lowerer, expr.left.expression);
-                if (recv && recv.type.kind === "dyn") {
-                    const recvTmp = lowerer.declareHiddenLocal("%setRecv", DYN);
-                    const rhsVal = lowerer.lowerExpr(expr.right);
-                    const valTmp = lowerer.declareHiddenLocal("%setVal", rhsVal.type);
-                    const valRef = () => ({ kind: "varRef", localId: valTmp.id, type: rhsVal.type, loc });
-                    const stored = lowerer.coerceToExpected(valRef(), DYN);
-                    if (stored.type.kind !== "dyn") {
-                        lowerer.unsupported("SC1101", expr.right, `assigning '${lowerer.fmt(rhsVal.type)}' values into a checked-dynamic member`);
-                    }
-                    const key = { kind: "strLit", value: expr.left.name.text, type: STRING, loc: locOf(expr.left.name) };
-                    return {
-                        kind: "seqExpr",
-                        stmts: [
-                            { kind: "varDecl", localId: recvTmp.id, init: recv, loc },
-                            { kind: "varDecl", localId: valTmp.id, init: rhsVal, loc },
-                            {
-                                kind: "exprStmt",
-                                expr: { kind: "libCall", fn: "dyn.keySet", args: [{ kind: "varRef", localId: recvTmp.id, type: DYN, loc }, key, stored], type: VOID, loc },
-                                loc,
-                            },
-                        ],
-                        result: valRef(),
-                        type: rhsVal.type,
-                        loc,
-                    };
-                }
+                if (recv && recv.type.kind === "dyn")
+                    return lowerDynMemberAssignment(lowerer, expr, recv);
                 const field = lowerer.fieldTarget(expr.left);
                 if (field) {
                     const recvTmp = lowerer.declareHiddenLocal("%setReceiver", field.obj.type);
@@ -6476,8 +6761,8 @@ export function lowerBinary(lowerer, expr) {
             const scalarSide = dynSide === left ? right : left;
             const reference = scalarSide.type;
             if ((isDynTypedRefType(reference) || reference.kind === "record" || reference.kind === "array" ||
-                reference.kind === "bytes" || reference.kind === "func" || reference.kind === "regex" || reference.kind === "url" ||
-                reference.kind === "bigint" || reference.kind === "symbol" || reference.kind === "set" || reference.kind === "union" || DYN_HANDLE_KINDS.has(reference.kind)) &&
+                reference.kind === "bytes" || reference.kind === "func" || reference.kind === "classval" || reference.kind === "regex" || reference.kind === "url" ||
+                reference.kind === "bigint" || reference.kind === "symbol" || reference.kind === "map" || reference.kind === "set" || reference.kind === "union" || DYN_HANDLE_KINDS.has(reference.kind)) &&
                 lowerer.dynConvertible(reference)) {
                 const boxed = {
                     kind: "dynFrom", value: scalarSide, type: DYN, loc: scalarSide.loc,
@@ -6524,8 +6809,11 @@ export function lowerBinary(lowerer, expr) {
         }
         // Numeric operators dispatch on ToNumeric's actual Number/BigInt
         // result, including values flowing through native callable properties.
-        if (isJsSourceFile(expr.getSourceFile()) || op === ts.SyntaxKind.PlusToken) {
-            const checkNum = (e) => e.type.kind === "dyn" ? { kind: "dynCheck", value: e, type: F64, loc: e.loc } : e;
+        if (isJsSourceFile(expr.getSourceFile()) || op === ts.SyntaxKind.PlusToken ||
+            [ts.SyntaxKind.LessThanToken, ts.SyntaxKind.LessThanEqualsToken,
+                ts.SyntaxKind.GreaterThanToken, ts.SyntaxKind.GreaterThanEqualsToken].includes(op) ||
+            [ts.SyntaxKind.MinusToken, ts.SyntaxKind.AsteriskToken, ts.SyntaxKind.SlashToken,
+                ts.SyntaxKind.PercentToken, ts.SyntaxKind.AsteriskAsteriskToken].includes(op)) {
             const other = left.type.kind === "dyn" ? right : left;
             const NUM_BIN = {
                 [ts.SyntaxKind.MinusToken]: "-",
@@ -6553,8 +6841,9 @@ export function lowerBinary(lowerer, expr) {
                     return numeric ? { kind: "dynCheck", value, type: numeric, loc } : value;
                 }
             }
-            if (cmp && (other.type.kind === "f64" || other.type.kind === "dyn")) {
-                return { kind: "bin", op: cmp, left: checkNum(left), right: checkNum(right), type: BOOL, loc };
+            if (cmp && lowerer.dynConvertible(left.type) && lowerer.dynConvertible(right.type)) {
+                return { kind: "libCall", fn: "dyn.compare", args: [lowerer.coerceToExpected(left, DYN),
+                        lowerer.coerceToExpected(right, DYN), { kind: "strLit", value: cmp, type: STRING, loc }], type: BOOL, loc };
             }
             // Untyped addition chooses concatenation or numeric addition only
             // after both operands have undergone ToPrimitive at runtime.
@@ -6986,6 +7275,10 @@ export function lowerBinary(lowerer, expr) {
             if (DYN_HANDLE_KINDS.has(idLeft.type.kind) && typeEquals(idLeft.type, idRight.type)) {
                 return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
             }
+            if (lowerer.dynConvertible(idLeft.type) && lowerer.dynConvertible(idRight.type)) {
+                return { kind: "dynScalarEq", left: lowerer.coerceToExpected(idLeft, DYN),
+                    right: lowerer.coerceToExpected(idRight, DYN), ...(negated ? { negated: true } : {}), type: BOOL, loc };
+            }
             lowerer.unsupported("SC1043", expr);
             break;
         }
@@ -7000,6 +7293,10 @@ export function lowerBinary(lowerer, expr) {
                 return { kind: "bin", op: cmpOp, left: arithmeticLeft, right: arithmeticRight, type: BOOL, loc };
             if (bothStr)
                 return { kind: "strCmp", op: cmpOp, left, right, type: BOOL, loc };
+            if (lowerer.dynConvertible(left.type) && lowerer.dynConvertible(right.type)) {
+                return { kind: "libCall", fn: "dyn.compare", args: [lowerer.coerceToExpected(left, DYN),
+                        lowerer.coerceToExpected(right, DYN), { kind: "strLit", value: cmpOp, type: STRING, loc }], type: BOOL, loc };
+            }
             lowerer.unsupported("SC1043", expr);
             break;
         }
@@ -7042,6 +7339,16 @@ function lowerLogicalChain(lowerer, expr) {
 function lowerLogicalPair(lowerer, expr, left) {
     const op = expr.operatorToken.kind;
     const loc = locOf(expr);
+    // Preserve short-circuiting during lowering too: an unreachable member
+    // on a specialized value must not poison the surrounding JS statement.
+    if (left.kind === "boolLit") {
+        const takeRight = op === ts.SyntaxKind.AmpersandAmpersandToken ? left.value : !left.value;
+        return takeRight ? lowerer.lowerExpr(expr.right) : left;
+    }
+    if (left.kind === "unitLit" && op === ts.SyntaxKind.AmpersandAmpersandToken)
+        return left;
+    if (op === ts.SyntaxKind.BarBarToken && REF_TRUTHY_KINDS.has(left.type.kind))
+        return left;
     const right = lowerer.lowerExpr(expr.right);
     // A LITERAL-unit left operand (a compile-time undefined/null — the
     // capability-probe members: `process.features.inspector ||
@@ -7091,6 +7398,11 @@ function lowerLogicalPair(lowerer, expr, left) {
             type: JSVAL, loc,
         };
     }
+    if (isJsSourceFile(expr.getSourceFile()) && op === ts.SyntaxKind.AmpersandAmpersandToken &&
+        left.type.kind === "union" && (lowerer.unions.get(left.type.unionId)?.arms.some((arm) => arm.kind === "bool")) &&
+        !typeEquals(left.type, right.type) && lowerer.dynConvertible(left.type) && lowerer.dynConvertible(right.type)) {
+        return { kind: "logical", op: "&&", left: lowerer.coerceToExpected(left, DYN), right: lowerer.coerceToExpected(right, DYN), type: DYN, loc };
+    }
     if (left.type.kind === "union" || right.type.kind === "union") {
         // Test the deciding operand in its own representation. The result
         // contains only the values that can survive short-circuit evaluation.
@@ -7970,6 +8282,8 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         if (value.type.kind === collection)
             return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: value, loc }],
                 result: { kind: "boolLit", value: true, type: BOOL, loc }, type: BOOL, loc };
+        return { kind: "libCall", fn: collection === "map" ? "dyn.nativeMapIs" : "dyn.nativeSetIs",
+            args: [lowerer.coerceInto(expr.left, value, DYN)], type: BOOL, loc };
     }
     if (lowerer.isStdlibGlobal(expr.right, "WeakMap") || lowerer.isStdlibGlobal(expr.right, "WeakSet")) {
         if (lowerer.dynamic) {
@@ -7986,6 +8300,10 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "dyn.nativeUrlIs", args: [value], type: BOOL, loc };
     }
+    if (lowerer.isStdlibGlobal(expr.right, "DataView")) {
+        const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
+        return { kind: "libCall", fn: "dyn.dataViewIs", args: [value], type: BOOL, loc };
+    }
     if (lowerer.isStdlibGlobal(expr.right, "ArrayBuffer")) {
         const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
         return { kind: "libCall", fn: "arrayBuffer.is", args: [value], type: BOOL, loc };
@@ -8040,24 +8358,29 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             if (value.type.kind === "dyn")
                 return { kind: "libCall", fn: date ? "dyn.nativeDateIs" : "dyn.nativeUrlIs", args: [value], type: BOOL, loc };
             if (value.type.kind === "union")
-                lowerer.unsupported("SC1090", expr, "Date or URL instanceof over a union");
+                return { kind: "libCall", fn: date ? "dyn.nativeDateIs" : "dyn.nativeUrlIs",
+                    args: [lowerer.coerceInto(expr.left, value, DYN)], type: BOOL, loc };
             return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: value, loc }],
                 result: { kind: "boolLit", value: value.type.kind === (date ? "date" : "url"), type: BOOL, loc }, type: BOOL, loc };
         }
+        const webBrand = ["Request", "Response", "Headers"].find((name) => lowerer.isStdlibGlobal(expr.right, name));
+        if (webBrand)
+            return { kind: "libCall", fn: "fetch.webIs", args: [lowerer.lowerExprExpecting(expr.left, DYN),
+                    { kind: "strLit", value: webBrand, type: STRING, loc }], type: BOOL, loc };
+        if (lowerer.isStdlibGlobal(expr.right, "ReadableStream")) {
+            const value = lowerer.lowerExprExpecting(expr.left, DYN);
+            return { kind: "libCall", fn: "fetch.streamIs", args: [value], type: BOOL, loc };
+        }
         // Unknown storage retains each numeric typed array's exact native brand.
-        if (ts.isIdentifier(expr.right) && !lowerer.caughtLocalOf(expr.left)) {
+        if (!lowerer.caughtLocalOf(expr.left)) {
             const elem = Object.keys(BYTES_ELEMENT_NAME).find((kind) => lowerer.isStdlibGlobal(expr.right, BYTES_ELEMENT_NAME[kind]));
             if (elem !== undefined) {
                 const left = lowerer.lowerExpr(expr.left);
                 if (left.type.kind === "dyn") {
                     return { kind: "dynTest", test: "bytes", bytesElem: elem, value: left, type: BOOL, loc };
                 }
-                if (left.type.kind === "bytes") {
-                    return {
-                        kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: left, loc }],
-                        result: { kind: "boolLit", value: left.type.elem === elem, type: BOOL, loc }, type: BOOL, loc,
-                    };
-                }
+                return { kind: "dynTest", test: "bytes", bytesElem: elem,
+                    value: lowerer.coerceInto(expr.left, left, DYN), type: BOOL, loc };
             }
         }
         // `x instanceof RegExp` over a union with a regex arm (the
@@ -8079,9 +8402,7 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                     return { kind: "unionIsTag", unionId: left.type.unionId, tag, negated: false, value: left, type: BOOL, loc };
                 }
             }
-            if (left.type.kind === "regex" && left.kind === "varRef" && ts.isIdentifier(expr.left)) {
-                return { kind: "boolLit", value: true, type: BOOL, loc };
-            }
+            return { kind: "libCall", fn: "dyn.nativeRegexIs", args: [lowerer.coerceInto(expr.left, left, DYN)], type: BOOL, loc };
         }
         // `x instanceof X` where X is a class VALUE (a classval-typed
         // binding): the target is DYNAMIC — a hierarchy target reads its
@@ -8100,6 +8421,10 @@ export function lowerInstanceOf(lowerer, expr, loc) {
                 lowerer.unsupported("SC1090", expr, "'instanceof' against a class value whose class has no lowering (the class declaration itself was rejected — see its own diagnostic)");
             }
             const left = lowerer.lowerExpr(expr.left);
+            if (left.type.kind === "dyn") {
+                const classValue = lowerer.lowerExpr(expr.right);
+                return classInstanceOf(lowerer, left, targetInfo, loc, classValue);
+            }
             if (left.type.kind !== "object") {
                 lowerer.unsupported("SC1090", expr, "'instanceof' on values other than class instances (narrow union-typed values first)");
             }
@@ -8124,6 +8449,11 @@ export function lowerInstanceOf(lowerer, expr, loc) {
             }
             lowerer.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the values to variables first)");
         }
+        const constructor = tryLowerExpression(lowerer, expr.right);
+        if (constructor?.type.kind === "dyn" && isJsSourceFile(expr.getSourceFile())) {
+            const value = lowerer.coerceInto(expr.left, lowerer.lowerExpr(expr.left), DYN);
+            return checkedClassInstanceOf(lowerer, value, constructor, loc);
+        }
         lowerer.unsupported("SC1090", expr.right, "'instanceof' right-hand sides other than classes declared in the program");
     }
     // A catch binding on the left: the runtime test against the class's
@@ -8218,7 +8548,8 @@ export function lowerInstanceOf(lowerer, expr, loc) {
         }
     }
     if (left.type.kind !== "object") {
-        lowerer.unsupported("SC1090", expr, "'instanceof' on values other than class instances (narrow union-typed values first)");
+        return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: left, loc }],
+            result: { kind: "boolLit", value: false, type: BOOL, loc }, type: BOOL, loc };
     }
     const lhsInfo = lowerer.classes.get(left.type.className);
     if (!lhsInfo)
@@ -8446,9 +8777,9 @@ function lowerInExpression(lowerer, expr, loc) {
         // `in` shares the coercion).
         {
             const probed = tryLowerExpression(lowerer, expr.right);
-            if (probed && (probed.type.kind === "dyn" || isDynTypedRefType(probed.type))) {
+            if (probed && lowerer.dynConvertible(probed.type)) {
                 const k = lowerer.lowerExpr(expr.left); // JS order: the key evaluates first
-                if (k.type.kind === "symbol" || k.type.kind === "dyn" || k.type.kind === "string" || k.type.kind === "f64") {
+                if (lowerer.dynConvertible(k.type)) {
                     const boxed = lowerer.coerceToExpected(k, DYN);
                     const keyLocal = lowerer.declareHiddenLocal("%inKey", DYN);
                     return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: keyLocal.id, init: boxed, loc }],
@@ -8479,7 +8810,9 @@ function lowerInExpression(lowerer, expr, loc) {
         return { kind: "unionIsTag", unionId: envType.unionId, tag: undefTag, negated: true, value: read, type: BOOL, loc };
     }
     let recv = lowerer.lowerExpr(expr.right);
-    if (isJsSourceFile(expr.getSourceFile()) && recv.type.kind === "func" && lowerer.dynConvertible(recv.type)) {
+    const classInfo = recv.type.kind === "classval" ? lowerer.classes.get(recv.type.className) : undefined;
+    if ((classInfo && (classInfo.callableBase || hasRuntimeStatics(classInfo))) ||
+        (isJsSourceFile(expr.getSourceFile()) && recv.type.kind === "func" && lowerer.dynConvertible(recv.type))) {
         recv = lowerer.coerceToExpected(recv, DYN);
     }
     const siteType = lowerer.mapTypeOf(lowerer.typeOf(expr.right));
@@ -8728,8 +9061,8 @@ function lowerRuntimeKeyIn(lowerer, expr, loc) {
     }
     return { kind: "call", callee: helper, args: [keyIr, recv], type: BOOL, loc };
 }
-/** A regex literal `/ab+c/gi` → regexLit (interned per (pattern, flags)
-   * by the backend). The TS parser has already syntax-checked the literal;
+/** A regex literal `/ab+c/gi` → regexLit (fresh state per evaluation,
+   * shared bytecode per (pattern, flags) pair). The TS parser has already syntax-checked the literal;
    * what remains here is the flag-alphabet fence (d and v are
    * declared-valid TS flags outside this slice). Named capture groups
    * `(?<name>...)` and `\k<name>` backreferences compile — libregexp
@@ -8870,14 +9203,52 @@ function constInitializerOf(lowerer, ident) {
    * caller keeps its fence), or the groups list (possibly empty — a
    * traced regex WITHOUT named groups is the Node-undefined case). */
 export function matchResultNamedGroupsOf(lowerer, e) {
+    let producer = e;
+    while (ts.isParenthesizedExpression(producer) || ts.isNonNullExpression(producer))
+        producer = producer.expression;
+    if (ts.isIdentifier(producer)) {
+        const init = constInitializerOf(lowerer, producer);
+        if (init !== null)
+            return matchResultNamedGroupsOf(lowerer, init);
+    }
     const reExpr = matchProducerRegexOf(lowerer, e);
     if (reExpr === null)
         return null;
+    if (ts.isCallExpression(producer) && ts.isPropertyAccessExpression(producer.expression) &&
+        producer.expression.name.text === "match") {
+        const flags = staticRegexFlagsOf(lowerer, reExpr);
+        if (flags === null)
+            return null;
+        // Global String.match returns whole matches without a groups
+        // property, even when the pattern contains named captures.
+        if (flags.includes("g"))
+            return [];
+    }
     const pattern = staticRegexPatternOf(lowerer, reExpr);
     if (pattern === null)
         return null;
     return namedCaptureGroupsOfPattern(pattern);
 }
+function staticRegexFlagsOf(lowerer, node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr) || ts.isNonNullExpression(expr))
+        expr = expr.expression;
+    if (ts.isRegularExpressionLiteral(expr))
+        return expr.text.slice(expr.text.lastIndexOf("/") + 1);
+    if (ts.isIdentifier(expr)) {
+        const init = constInitializerOf(lowerer, expr);
+        return init !== null ? staticRegexFlagsOf(lowerer, init) : null;
+    }
+    if (ts.isNewExpression(expr) && ts.isIdentifier(expr.expression) &&
+        lowerer.isStdlibGlobal(expr.expression, "RegExp")) {
+        const flags = expr.arguments?.[1];
+        if (!flags)
+            return "";
+        if (ts.isStringLiteral(flags) || ts.isNoSubstitutionTemplateLiteral(flags))
+            return flags.text;
+    }
+    return null;
+}
 /** The regex EXPRESSION whose match produced `e` (see
    * matchResultNamedGroupsOf for the traced shapes). */
 function matchProducerRegexOf(lowerer, e) {
@@ -9370,7 +9741,7 @@ export function lowerUnionProperty(lowerer, expr) {
     // instance argument (e.g. Matrix4.makeTranslation). Preserve primitive
     // missing-property semantics and dispatch class data through its native
     // capsule instead of demanding a field shared by every union arm.
-    if (isJsSourceFile(expr.getSourceFile()) && def.arms.some(isDynTypedRefType) && lowerer.dynConvertible(value.type)) {
+    if (isJsSourceFile(expr.getSourceFile()) && lowerer.dynConvertible(value.type)) {
         return { kind: "dynKeyGet", value: lowerer.coerceToExpected(value, DYN), key,
             ...(hasOptionalChainGuard(expr.expression) ? { optional: true } : {}), type: DYN, loc: locOf(expr) };
     }
@@ -9581,7 +9952,7 @@ export function fieldTarget(lowerer, access) {
     }
     const stored = ts.isIdentifier(access.expression)
         ? lowerer.peekLocal(access.expression)?.type ?? lowerer.globalOf(access.expression)?.type : undefined;
-    const receiverIr = stored?.kind === "record" ? stored : lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const receiverIr = stored?.kind === "record" || stored?.kind === "object" ? stored : lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     if (receiverIr?.kind === "object") {
         return classFieldTarget(lowerer, access.expression, receiverIr, access.name.text);
     }
@@ -9787,6 +10158,8 @@ function symbolFieldTarget(lowerer, expr) {
    * tsc-clean (the property types as the setter's param), but Node yields
    * undefined, which these property types cannot represent. */
 export function fieldGetExpr(lowerer, target, loc, blame) {
+    if (target.container === "class" && (target.field === "message" || target.field === "name") && (target.className === "%Error" || lowerer.isSubclassOf(target.className, "%Error")))
+        return errorPropertyRead(lowerer, target.obj, target.field);
     if (target.container === "errorStackLimit") {
         return { kind: "libCall", fn: "error.stackLimitGet", args: [], type: F64, loc };
     }
@@ -9812,6 +10185,11 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
         if (!getF) {
             lowerer.unsupported("SC1090", blame, `reading a property that has only a setter ('${target.field}' — Node would yield undefined)`);
         }
+        if (!target.field.startsWith("#") && isJsSourceFile(blame.getSourceFile()) && lowerer.dynConvertible(getF.sig.ret)) {
+            const value = { kind: "dynKeyGet", value: lowerer.coerceToExpected(target.obj, DYN),
+                key: { kind: "strLit", value: target.field, type: STRING, loc }, type: DYN, loc };
+            return lowerer.coerceToExpected(value, getF.sig.ret);
+        }
         return lowerer.accessorCall(target.className, `get:${target.field}`, target.obj, [], getF.sig.ret, loc);
     }
     // Record accessor properties: the read IS a call of the %get: closure
@@ -9889,6 +10267,8 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
    * call). A write to a getter-only property never gets here in a clean
    * program (tsc's TS2540 is the fence); the rejection is the backstop. */
 export function fieldSetStmt(lowerer, target, value, loc, blame) {
+    if (target.container === "class" && (target.field === "message" || target.field === "name") && (target.className === "%Error" || lowerer.isSubclassOf(target.className, "%Error")))
+        return errorPropertyWrite(lowerer, target.obj, value, target.field);
     if (target.container === "errorStackLimit") {
         return { kind: "exprStmt", expr: { kind: "libCall", fn: "error.stackLimitSet", args: [value], type: VOID, loc }, loc };
     }
@@ -9996,13 +10376,13 @@ export function lowerPromiseRejectCall(lowerer, call, access) {
     // identity survives to catch/unhandledRejection observers), and the
     // result is promise<dyn> when no context names a concrete one.
     const reason = lowerer.lowerExpr(reasonNode);
-    if (reason.type.kind === "dyn") {
+    if (reason.type.kind === "dyn" || lowerer.dynConvertible(reason.type) && reason.type.kind !== "object") {
         // The result only ever REJECTS, so the inner type is unobservable:
         // adopt the context's promise type when one names it, else the
         // checker's own Promise<never> reading (promise<void> — exactly the
         // Error-reason form below).
         const resultT = type?.kind === "promise" ? type : { kind: "promise", inner: VOID };
-        return { kind: "intrinsic", name: "promise.reject", args: [reason], type: resultT, loc };
+        return { kind: "intrinsic", name: "promise.reject", args: [lowerer.coerceInto(reasonNode, reason, DYN)], type: resultT, loc };
     }
     // An Error reason with NO context-named promise type (a bare
     // top-level `Promise.reject(new Error())` — the unhandled-rejection
@@ -10193,8 +10573,8 @@ function lowerStreamObjectProperty(lowerer, expr) {
  * Interning makes every reference under one ABI the SAME immortal closure,
  * so `opt.type === String` compares like JS function identity. */
 function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
-    const ret = name === "String" ? STRING : name === "Number" ? F64 : BOOL;
-    const input = dynamicInput ? DYN : STRING;
+    const ret = name === "String" ? STRING : name === "Number" ? F64 : name === "BigInt" ? BIGINT_T : BOOL;
+    const input = dynamicInput || name === "BigInt" ? DYN : STRING;
     const fnT = funcOf([input], ret);
     const key = `${name}:${dynamicInput ? "dyn" : "string"}`;
     let fnName = lowerer.primitiveCtorFns.get(key);
@@ -10203,16 +10583,20 @@ function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
         lowerer.primitiveCtorFns.set(key, fnName);
         const v = { kind: "varRef", localId: "v.0", type: input, loc };
         const value = dynamicInput
-            ? name === "String"
-                ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc }
-                : name === "Number"
-                    ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [v], type: F64, loc }
-                    : { kind: "dynTest", test: "truthy", value: v, type: BOOL, loc }
-            : name === "String"
-                ? v
-                : name === "Number"
-                    ? { kind: "libCall", fn: "num.fromString", args: [v], type: F64, loc }
-                    : { kind: "strEq", negated: true, left: v, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
+            ? name === "BigInt"
+                ? { kind: "libCall", fn: "dyn.bigintConstructor", args: [v], type: BIGINT_T, loc }
+                : name === "String"
+                    ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc }
+                    : name === "Number"
+                        ? { kind: "libCall", fn: "dyn.numberConstructor", args: [v], type: F64, loc }
+                        : { kind: "dynTest", test: "truthy", value: v, type: BOOL, loc }
+            : name === "BigInt"
+                ? { kind: "libCall", fn: "dyn.bigintConstructor", args: [v], type: BIGINT_T, loc }
+                : name === "String"
+                    ? v
+                    : name === "Number"
+                        ? { kind: "libCall", fn: "num.fromString", args: [v], type: F64, loc }
+                        : { kind: "strEq", negated: true, left: v, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
         const fn = {
             name: fnName,
             params: [{ localId: "v.0", name: "value", type: input }],
@@ -10225,4 +10609,25 @@ function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
     }
     return { kind: "closure", fnName, captures: [], type: fnT, loc };
 }
+/** Drain using checked dispatch so native class and generator iterators keep their methods. */
+function checkedIteratorPack(lowerer, source, loc) {
+    const name = "%iterator.pack.checked";
+    if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+        const ref = (id) => ({ kind: "varRef", localId: id, type: DYN, loc });
+        const property = (key) => ({ kind: "dynKeyGet", value: ref("step"), key: { kind: "strLit", value: key, type: STRING, loc }, type: DYN, loc });
+        lowerer.liftedFns.push({ name, params: [{ localId: "source", name: "source", type: DYN }], returnType: DYN,
+            locals: ["source", "iterator", "step", "result"].map((id) => ({ id, name: id, type: DYN, mutable: id !== "source" })),
+            body: [
+                { kind: "varDecl", localId: "iterator", init: { kind: "libCall", fn: "dyn.iterator", args: [ref("source"), { kind: "strLit", value: "value", type: STRING, loc }], type: DYN, loc }, loc },
+                { kind: "varDecl", localId: "result", init: { kind: "dynArrLit", elems: [], type: DYN, loc }, loc },
+                { kind: "while", cond: { kind: "boolLit", value: true, type: BOOL, loc }, body: [
+                        { kind: "varDecl", localId: "step", init: { kind: "dynInvoke", recv: ref("iterator"), method: "next", calleeName: "iterator.next", args: [], type: DYN, loc }, loc },
+                        { kind: "if", cond: { kind: "dynTest", test: "truthy", value: property("done"), type: BOOL, loc }, then: [{ kind: "return", value: ref("result"), loc }], else_: null, loc },
+                        { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.packPush", args: [ref("result"), property("value")], type: VOID, loc }, loc },
+                    ], loc },
+                { kind: "return", value: ref("result"), loc },
+            ], loc });
+    }
+    return { kind: "call", callee: name, args: [source], type: DYN, loc };
+}
 //# sourceMappingURL=lower-exprs.js.map