@scriptc/compiler 0.2.0 → 0.2.2

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

@@ -1,4 +1,5 @@
 import { InternalCompilerError } from "../../errors.js";
+import { SYMBOL_T } from "../../ir/ir.js";
 import { literalValues } from "../literal-values.js";
 import { literalUnionArm } from "../union-discriminants.js";
 /* Expression lowering: the expression dispatch (lowerExpr), literals
@@ -11,13 +12,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 +31,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";
@@ -51,9 +54,14 @@ import { classSymbolKeyOf } from "./symbol-fields.js";
 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 { lowerClassPrototypeData, lowerClassPrototypeComputedAssignment } from "./class-prototypes.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";
+import { lowerModuleNamespaceElement } from "./module-namespace-elements.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
@@ -580,6 +588,8 @@ function lowerExprInner(lowerer, expr) {
     if (ts.isTypeOfExpression(expr)) {
         if (lowerer.isStdlibGlobal(expr.expression, "process"))
             return { kind: "strLit", value: "object", type: STRING, loc };
+        if (lowerer.isStdlibGlobal(expr.expression, "fetch"))
+            return { kind: "strLit", value: "function", type: STRING, loc };
         const performance = lowerPerfHooksTypeof(lowerer, expr.expression);
         if (performance)
             return performance;
@@ -704,8 +714,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
@@ -769,7 +781,7 @@ function lowerExprInner(lowerer, expr) {
                 if (use?.kind === "element") {
                     const key = runtimeOptionalElementKey(use.access.argumentExpression);
                     if (key === null) {
-                        lowerer.unsupported("SC1090", use.access, "a computed read from a runtime-optional capture (use a literal key)");
+                        return varRef(local.id, local.type, loc);
                     }
                     return runtimeOptionalReceiverRead(lowerer, expr, local, key, loc);
                 }
@@ -1052,14 +1064,38 @@ 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 (isJsSourceFile(expr.getSourceFile()) && lowerer.isStdlibGlobal(expr, "Array"))
+            return { kind: "libCall", fn: "dyn.arrayConstructor", 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 +1296,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 +1497,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 +1548,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 +1641,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 +1658,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 +1898,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 };
             }
         }
@@ -1876,6 +1947,13 @@ function lowerExprInner(lowerer, expr) {
                     : { kind: "strIntrinsic", method: "length", receiver: recv, args: [], type: F64, loc };
             }
         }
+        if (isJsSourceFile(expr.getSourceFile()) && expr.name.text === "constructor") {
+            const receiver = tryLowerExpression(lowerer, expr.expression);
+            if (receiver?.type.kind === "dyn" || receiver?.type.kind === "object" && !lowerer.classes.get(receiver.type.className)?.fields.has("constructor")) {
+                return { kind: "dynKeyGet", value: lowerer.coerceToExpected(receiver, DYN),
+                    key: { kind: "strLit", value: "constructor", type: STRING, loc }, type: DYN, loc };
+            }
+        }
         // `f.name` / `f.length` / own properties on a FUNCTION-typed JS
         // value (the mustCall wrapper's function-instance members): read
         // through the dyn box — the closure's own-property table answers
@@ -1921,10 +1999,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 +2103,12 @@ 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) ||
+                recvLowered.type.kind === "union" && lowerer.dynConvertible(recvLowered.type))) {
             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 +2158,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 +2201,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 +2209,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 +2494,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
@@ -2452,8 +2554,57 @@ export function maybeNarrow(lowerer, expr, node) {
     // instead of misreading the payload (the dyn boundary's usual stance).
     // Object/array narrowings stay dyn-typed and keep their fences.
     if (expr.type.kind === "dyn") {
+        // An inferred JS member's storage may be deliberately wider than its
+        // declaration (prototype-selected buffers, null-initialized scratch
+        // objects). Extract at the consuming operation, not at the read.
+        if (isJsSourceFile(node.getSourceFile()) && ts.isPropertyAccessExpression(node)) {
+            const receiver = lowerer.mapTypeOf(lowerer.typeOf(node.expression));
+            if (receiver?.kind === "object") {
+                const info = lowerer.classes.get(receiver.className);
+                if (info?.fields.get(node.name.text)?.kind === "dyn" || lowerer.findMethodOn(info ?? null, `get:${node.name.text}`)?.sig.ret.kind === "dyn")
+                    return expr;
+            }
+            if (receiver?.kind === "classval") {
+                const info = lowerer.classes.get(receiver.className);
+                if (info && hasRuntimeStatics(info))
+                    return expr;
+            }
+        }
+        if (isJsSourceFile(node.getSourceFile()) &&
+            (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node))) {
+            let receiver = node.expression;
+            while (ts.isPropertyAccessExpression(receiver) || ts.isElementAccessExpression(receiver) || ts.isParenthesizedExpression(receiver)) {
+                if (ts.isPropertyAccessExpression(receiver)) {
+                    const owner = lowerer.mapTypeOf(lowerer.typeOf(receiver.expression));
+                    if (owner?.kind === "object" && lowerer.classes.get(owner.className)?.fields.get(receiver.name.text)?.kind === "dyn")
+                        return expr;
+                }
+                receiver = receiver.expression;
+            }
+            if (receiver.kind === ts.SyntaxKind.ThisKeyword && lowerer.resolveThis()?.type.kind === "dyn")
+                return expr;
+            if (ts.isIdentifier(receiver)) {
+                const stored = lowerer.peekLocal(receiver)?.type ?? lowerer.globalOf(receiver)?.type;
+                if (stored?.kind === "dyn")
+                    return expr;
+                const symbol = lowerer.resolveValueSymbol(receiver);
+                const bound = symbol && lowerer.implicitParamTypes?.get(symbol);
+                if (bound && lowerer.mapTypeOf(bound)?.kind === "dyn")
+                    return expr;
+            }
+        }
         if (isJsSourceFile(node.getSourceFile()) && ts.isIdentifier(node)) {
             const symbol = lowerer.resolveValueSymbol(node);
+            if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => ts.isParameter(decl) &&
+                ts.isMethodDeclaration(decl.parent) && lowerer.checkedVirtualJsMethods.has(decl.parent)))
+                return expr;
+            if (symbol && lowerer.checker.declarationsOf(symbol).some((decl) => ts.isParameter(decl) && ts.isConstructorDeclaration(decl.parent)))
+                return expr;
+            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;
@@ -2512,6 +2663,19 @@ export function maybeNarrow(lowerer, expr, node) {
     }
     if (expr.type.kind !== "union")
         return expr;
+    // Represented fields and index values can include undefined even when
+    // checker inference or lib.d.ts declares strings (RegExp captures).
+    // Only a declaration that represents the optional arm can provide a
+    // trustworthy flow narrowing; otherwise consumers must check it.
+    if ((expr.kind === "recordGet" || expr.kind === "recordKeyGet") &&
+        (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node))) {
+        const receiver = lowerer.mapTypeOf(lowerer.typeOf(node.expression));
+        const shape = receiver?.kind === "record" ? lowerer.shapes.get(receiver.shapeId) : undefined;
+        const declared = expr.kind === "recordGet" ? shape?.fields.find((field) => field.name === expr.field)?.type : shape?.indexValue;
+        if (lowerer.armTag(expr.type.unionId, UNDEFINED_T) >= 0 &&
+            declared && !(declared.kind === "union" && lowerer.armTag(declared.unionId, UNDEFINED_T) >= 0))
+            return expr;
+    }
     if (ts.isIdentifier(node)) {
         const symbol = lowerer.resolveValueSymbol(node);
         if (symbol && lowerer.unstableSwitchBindings.has(symbol))
@@ -3003,6 +3167,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 +3241,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 +3259,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 +3538,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,10 +3625,21 @@ 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) };
+        const result = { kind: "libCall", fn: "dyn.arrayConstructor", args: [], type: DYN, loc: locOf(expr) };
+        return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc: locOf(expr) }], result, type: DYN, loc: locOf(expr) };
+    }
     const strictReceiver = (expected) => {
         const value = lowerer.lowerExpr(expr.expression);
-        if (value.type.kind === "dyn")
+        if (value.type.kind === "dyn") {
+            if (isJsSourceFile(expr.getSourceFile()) && name === "length")
+                return value;
             return lowerer.coerceInto(expr.expression, value, expected);
+        }
         return lowerer.runtimeOptionalPropertyReceiver(expr.expression, value, expected, name) ?? value;
     };
     if (kind === "child") {
@@ -3517,7 +3743,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         // (the child.stdout pattern); a checker-narrowed read extracts
         // through maybeNarrow like any union member.
         if (name === "description") {
-            const receiver = lowerer.lowerExpr(expr.expression);
+            const receiver = lowerer.coerceToExpected(lowerer.lowerExpr(expr.expression), SYMBOL_T);
             const type = { kind: "union", unionId: lowerer.unions.intern([STRING, UNDEFINED_T]) };
             return { kind: "libCall", fn: "sym.desc", args: [receiver], type, loc };
         }
@@ -3585,6 +3811,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,11 +3833,20 @@ 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"
                 ? strictReceiver(expected)
                 : lowerer.lowerExpr(expr.expression);
+            if (receiver.type.kind === "dyn")
+                return { kind: "dynCheck", value: { kind: "dynKeyGet", value: receiver,
+                        key: { kind: "strLit", value: name, type: STRING, loc: locOf(expr) }, type: DYN, loc: locOf(expr) }, type: F64, loc: locOf(expr) };
             if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0) {
                 const present = lowerer.stripUndefinedArm(receiver.type);
                 const helper = present.kind === "bytes"
@@ -3674,9 +3912,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 +3981,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 +4090,14 @@ 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;
+    }
+    if (!expected && isJsSourceFile(expr.getSourceFile()) && expr.elements.some((element) => ts.isSpreadElement(element) && tryLowerExpression(lowerer, element.expression)?.type.kind === "dyn"))
+        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 +4109,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 +4169,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 +4263,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):
@@ -4255,6 +4516,9 @@ export function lowerElementAccess(lowerer, expr) {
     const cachedModule = lowerRequireCacheElement(lowerer, expr);
     if (cachedModule)
         return cachedModule;
+    const namespaceElement = lowerModuleNamespaceElement(lowerer, expr);
+    if (namespaceElement)
+        return namespaceElement;
     // Native Web handles use the same supported surface for bracket and dot
     // spellings. Fence a statically-known unsupported key before the generic
     // checked-dynamic element-read path can turn it into a runtime missing
@@ -4320,7 +4584,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,13 +4608,26 @@ 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);
         }
+        if (receiver?.type.kind === "array" || receiver?.type.kind === "bytes")
+            receiverIr = receiver.type;
+        if (receiver?.type.kind === "union") {
+            const present = lowerer.stripUndefinedArm(receiver.type);
+            if (present.kind === "array" || present.kind === "bytes")
+                receiverIr = present;
+        }
     }
     // A readonly tuple union under Array.isArray is checker-typed as an
     // intersection with any[], whose structural mapping is not the tuple
@@ -4363,7 +4644,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 +4693,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 +4795,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") {
@@ -4571,6 +4862,11 @@ export function lowerElementAccess(lowerer, expr) {
     if (receiverIr?.kind !== "array") {
         {
             const receiver = tryLowerExpression(lowerer, expr.expression);
+            if (receiver?.type.kind === "dyn" || receiver && isJsSourceFile(expr.getSourceFile()) &&
+                (receiver.type.kind === "union" || receiver.type.kind === "bytes") && lowerer.dynConvertible(receiver.type)) {
+                const key = lowerRecordPropertyKey(lowerer, lowerer.lowerExpr(expr.argumentExpression), expr.argumentExpression);
+                return lowerer.maybeNarrow({ kind: "dynKeyGet", value: lowerer.coerceInto(expr.expression, receiver, DYN), key, type: DYN, loc: locOf(expr) }, expr);
+            }
             if (receiver?.type.kind === "func" &&
                 canBoxFuncIntoDyn(receiver.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
                 const key = lowerRecordPropertyKey(lowerer, lowerer.lowerExpr(expr.argumentExpression), expr.argumentExpression);
@@ -4692,6 +4988,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 +5103,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 +5154,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 +5231,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 +5399,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
@@ -5108,7 +5446,9 @@ export function lowerElementCompound(lowerer, expr, op) {
     const oldLocal = lowerer.declareHiddenLocal("%compoundOld", oldValue.type);
     const oldRef = () => varRef(oldLocal.id, oldValue.type, loc);
     const rhs = lowerer.lowerExpr(expr.right);
-    const numericRhs = lowerOptionalNumber(lowerer, rhs, loc);
+    const numericRhs = rhs.type.kind === "dyn" && isJsSourceFile(expr.getSourceFile()) && receiver.type.kind === "bytes"
+        ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [rhs], type: F64, loc }
+        : lowerOptionalNumber(lowerer, rhs, loc);
     const elementType = receiver.type.kind === "array" ? receiver.type.elem : F64;
     const valueType = elementType.kind === "union" && lowerer.armTag(elementType.unionId, UNDEFINED_T) >= 0
         ? lowerer.stripUndefinedArm(elementType)
@@ -5120,6 +5460,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);
     }
@@ -5181,6 +5527,18 @@ export function lowerNativeFunctionAssignment(lowerer, expr) {
         (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) ||
         target.questionDotToken)
         return null;
+    // Checked constructors share the callable's live property descriptors.
+    const classType = storedClassValueType(lowerer, target.expression);
+    const staticClass = classType?.kind === "classval" ? lowerer.classes.get(classType.className) : undefined;
+    if (staticClass && hasRuntimeStatics(staticClass)) {
+        return lowerDynMemberAssignment(lowerer, expr, lowerer.lowerExprExpecting(target.expression, DYN));
+    }
+    // Other class statics and prototype tables have their own paths.
+    // Probing them as ordinary functions could materialize unused methods.
+    if (lowerer.exactClassOfReceiver(target.expression) ||
+        ts.isPropertyAccessExpression(target.expression) && target.expression.name.text === "prototype" &&
+            lowerer.exactClassOfReceiver(target.expression.expression))
+        return null;
     const receiver = tryLowerExpression(lowerer, target.expression);
     if (receiver?.type.kind !== "func" ||
         !canBoxFuncIntoDyn(receiver.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
@@ -5194,6 +5552,9 @@ export function lowerNativeFunctionAssignment(lowerer, expr) {
     return lowerDynMemberAssignment(lowerer, expr, boxed);
 }
 export function lowerElementWrite(lowerer, expr) {
+    const prototype = lowerClassPrototypeComputedAssignment(lowerer, expr);
+    if (prototype)
+        return { kind: "exprStmt", expr: prototype, loc: locOf(expr) };
     const target = expr.left;
     fenceNodeModuleMutation(lowerer, target, "assignment");
     const globalKey = globalSymbolKey(lowerer, target.expression, target.argumentExpression);
@@ -5233,13 +5594,30 @@ 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 (isJsSourceFile(expr.getSourceFile()) && checkedReceiver) {
+        const represented = checkedReceiver.type.kind === "union"
+            ? lowerer.stripUndefinedArm(checkedReceiver.type) : checkedReceiver.type;
+        if (represented.kind === "array" || represented.kind === "bytes")
+            receiverIr = represented;
+    }
     if (receiverIr === null || receiverIr.kind === "dyn") {
         const receiver = tryLowerExpression(lowerer, target.expression);
         if (receiver?.type.kind === "array")
@@ -5307,13 +5685,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 +5879,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 +5924,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 +6261,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")
@@ -6011,59 +6394,86 @@ export function lowerPrefixUnary(lowerer, expr) {
     }
     lowerer.unsupported("SC1090", expr, `syntax '${ts.syntaxKindName(expr.kind)}'`);
 }
-/** `x++`/`x--`/`++x`/`--x` in EXPRESSION position — the incDec node:
-   * read, write ±1, yield old (postfix) or new (prefix) value. Receivers
-   * are f64 LOCALS or module globals (captured/boxed included — the
-   * backend reads/writes through the box); record fields and array
-   * elements keep the fence in value position (statement-position `obj.f++`
-   * still desugars through the compound-field path). */
-function lowerIncDec(lowerer, expr, prefix) {
+/** Member updates evaluate the reference once, convert its old value with
+ * ToNumeric, store the new value, then yield the old or new numeric value. */
+export function lowerIncDec(lowerer, expr, prefix) {
     const loc = locOf(expr);
     const op = expr.operator === ts.SyntaxKind.PlusPlusToken ? "+" : "-";
     if (!ts.isIdentifier(expr.operand)) {
-        if (ts.isPropertyAccessExpression(expr.operand)) {
-            const target = staticFieldWriteTarget(lowerer, expr.operand);
+        const access = expr.operand;
+        if (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access) || access.questionDotToken) {
+            lowerer.unsupported("SC1045", expr, "increment/decrement of this target");
+        }
+        fenceNodeModuleMutation(lowerer, access, "assignment");
+        if (ts.isPropertyAccessExpression(access)) {
+            const target = staticFieldWriteTarget(lowerer, access);
             if (target) {
                 if (target.type.kind !== "f64")
                     lowerer.unsupported("SC1043", expr);
                 return { kind: "incDec", op, prefix, localId: target.id, type: F64, loc };
             }
         }
-        // CLASS-FIELD receivers (`if (--this.limit === 0)` — countdown.js's
-        // dec(); `--this[kLimit]` — its symbol-keyed spelling): a single-
-        // evaluation read-modify-write over the instance, yielding old/new
-        // like the local form. f64 fields are JS-exact; CHECKED-DYNAMIC
-        // fields (implicit-any ctor assignments in JS) take the dyn
-        // arithmetic stance — the number validates out (dynCheck's
-        // catchable TypeError, never a silent ToNumber; SEMANTICS.md),
-        // computes, and boxes back. Array elements, record fields, and
-        // accessor-backed names keep the fence.
-        if ((ts.isPropertyAccessExpression(expr.operand) || ts.isElementAccessExpression(expr.operand)) &&
-            !expr.operand.questionDotToken) {
-            const target = ts.isPropertyAccessExpression(expr.operand)
-                ? lowerer.fieldTarget(expr.operand)
-                : symbolFieldTarget(lowerer, expr.operand);
-            if (target?.container === "class" &&
-                !RUNTIME_ERROR_CLASSES.has(target.className) &&
-                (target.fieldType.kind === "f64" ||
-                    (target.fieldType.kind === "dyn" && isJsSourceFile(expr.getSourceFile())))) {
-                return {
-                    kind: "fieldIncDec",
-                    op,
-                    prefix,
-                    obj: target.obj,
-                    className: target.className,
-                    field: target.field,
-                    fieldDyn: target.fieldType.kind === "dyn",
-                    type: F64,
-                    loc,
-                };
-            }
-        }
-        // Other field/element receivers need a read-modify-write over a
-        // computed receiver — statement position has that desugar; value
-        // position does not yet. The message names the working forms.
-        lowerer.unsupported("SC1045", expr, "increment/decrement of record fields or elements in expression position");
+        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 finish = (read, write) => {
+            const old = save(read.type.kind === "f64" ? read : {
+                kind: "libCall", fn: "dyn.toNumeric", args: [lowerer.coerceInto(access, read, DYN)], type: DYN, loc,
+            }, "%incrementOld");
+            const next = save(old.type.kind === "f64" ? {
+                kind: "bin", op, left: old, right: { kind: "numLit", value: 1, type: F64, loc }, type: F64, loc,
+            } : {
+                kind: "libCall", fn: "dyn.increment", args: [old, { kind: "boolLit", value: op === "+", type: BOOL, loc }], type: DYN, loc,
+            }, "%incrementNext");
+            stmts.push(write(next));
+            const result = prefix ? next : old;
+            return { kind: "seqExpr", stmts, result, type: result.type, loc };
+        };
+        const raw = lowerer.lowerExpr(access.expression);
+        // Keep native array/byte storage: boxing a native array can create a
+        // checked view, which is not a substitute for updating its slot.
+        if (ts.isElementAccessExpression(access) && (raw.type.kind === "array" || raw.type.kind === "bytes")) {
+            const receiver = save(raw, "%incrementArray");
+            const rawIndex = lowerer.lowerExpr(access.argumentExpression);
+            const index = save(rawIndex.type.kind === "dyn" && isJsSourceFile(expr.getSourceFile())
+                ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [rawIndex], type: F64, loc } : rawIndex, "%incrementIndex");
+            if (index.type.kind !== "f64")
+                lowerer.unsupported("SC1090", access, "incrementing non-number array keys");
+            const type = raw.type;
+            const read = type.kind === "array"
+                ? arrayValueRead(lowerer, receiver, index, type.elem, loc)
+                : { kind: "bytesIntrinsic", method: "get", receiver, args: [index], type: F64, loc };
+            return finish(read, (value) => type.kind === "array"
+                ? arrayValueStore(lowerer, receiver, index, lowerer.coerceInto(access, value, type.elem), type.elem, loc)
+                : { kind: "bytesSet", arr: receiver, index, value: lowerer.coerceInto(access, value, F64), loc });
+        }
+        if (isJsSourceFile(expr.getSourceFile()) && raw.type.kind === "dyn") {
+            const receiver = save(raw, "%incrementReceiver");
+            const key = save(ts.isElementAccessExpression(access)
+                ? lowerer.lowerExprExpecting(access.argumentExpression, DYN)
+                : lowerer.coerceInto(access, { kind: "strLit", value: access.name.text, type: STRING, loc }, DYN), "%incrementKey");
+            return finish({ kind: "dynKeyGet", value: receiver, key, type: DYN, loc }, (value) => ({
+                kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySetComputed", args: [receiver, key, lowerer.coerceInto(access, value, DYN)], type: VOID, loc }, loc,
+            }));
+        }
+        const target = ts.isPropertyAccessExpression(access) ? lowerer.fieldTarget(access) : symbolFieldTarget(lowerer, access);
+        if (target && lowerer.dynConvertible(target.fieldType)) {
+            target.obj = save(target.obj, "%incrementReceiver");
+            return finish(lowerer.fieldGetExpr(target, loc, access), (value) => lowerer.fieldSetStmt(target, lowerer.coerceInto(access, value, target.fieldType), loc, access));
+        }
+        if (isJsSourceFile(expr.getSourceFile()) && lowerer.dynConvertible(raw.type)) {
+            const receiver = save(lowerer.coerceInto(access.expression, raw, DYN), "%incrementReceiver");
+            const key = save(ts.isElementAccessExpression(access)
+                ? lowerer.lowerExprExpecting(access.argumentExpression, DYN)
+                : lowerer.coerceInto(access, { kind: "strLit", value: access.name.text, type: STRING, loc }, DYN), "%incrementKey");
+            return finish({ kind: "dynKeyGet", value: receiver, key, type: DYN, loc }, (value) => ({
+                kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySetComputed", args: [receiver, key, lowerer.coerceInto(access, value, DYN)], type: VOID, loc }, loc,
+            }));
+        }
+        lowerer.unsupported("SC1045", expr, "increment/decrement of this member target");
     }
     const target = lowerer.resolveWritable(expr.operand);
     if (!target) {
@@ -6143,6 +6553,7 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     const loc = locOf(expr);
     const read = { kind: "varRef", localId: target.id, type: target.type, loc: locOf(expr.left) };
     const rhs = lowerer.lowerExpr(expr.right);
+    const numericRead = lowerOptionalNumber(lowerer, read, loc);
     const numericRhs = lowerOptionalNumber(lowerer, rhs, loc);
     if (target.type.kind === "jsval" || rhs.type.kind === "jsval") {
         const JS_COMPOUND = { "+": "add", "-": "sub", "*": "mul", "/": "div", "%": "mod", "**": "pow" };
@@ -6159,16 +6570,17 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     if (compound === "+" && target.type.kind === "string") {
         return { kind: "strConcat", left: read, right: lowerer.ensureString(rhs, expr.right), type: STRING, loc };
     }
-    if (target.type.kind === "f64" && numericRhs.type.kind === "f64") {
-        return { kind: "bin", op: compound, left: read, right: numericRhs, type: F64, loc };
+    if (numericRead.type.kind === "f64" && numericRhs.type.kind === "f64") {
+        return lowerer.coerceInto(expr, { kind: "bin", op: compound, left: numericRead, right: numericRhs, type: F64, loc }, target.type);
     }
     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);
 }
@@ -6180,6 +6592,9 @@ export function lowerBinary(lowerer, expr) {
         return cacheHas;
     if (op === ts.SyntaxKind.EqualsToken || (op >= ts.SyntaxKind.FirstCompoundAssignment && op <= ts.SyntaxKind.LastCompoundAssignment)) {
         if (op === ts.SyntaxKind.EqualsToken) {
+            const prototypeWrite = lowerClassPrototypeComputedAssignment(lowerer, expr);
+            if (prototypeWrite)
+                return prototypeWrite;
             const callableWrite = lowerNativeFunctionAssignment(lowerer, expr);
             if (callableWrite)
                 return callableWrite;
@@ -6293,8 +6708,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 +6774,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);
@@ -6446,8 +6859,14 @@ export function lowerBinary(lowerer, expr) {
     }
     const strictEquality = op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
         op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
-    const left = strictEquality ? lowerAbsenceProbe(lowerer, expr.left) ?? lowerer.lowerExpr(expr.left) : lowerer.lowerExpr(expr.left);
-    const right = strictEquality ? lowerAbsenceProbe(lowerer, expr.right) ?? lowerer.lowerExpr(expr.right) : lowerer.lowerExpr(expr.right);
+    let left = strictEquality ? lowerAbsenceProbe(lowerer, expr.left) ?? lowerer.lowerExpr(expr.left) : lowerer.lowerExpr(expr.left);
+    let right = strictEquality ? lowerAbsenceProbe(lowerer, expr.right) ?? lowerer.lowerExpr(expr.right) : lowerer.lowerExpr(expr.right);
+    if (strictEquality && (left.type.kind === "caught" || right.type.kind === "caught")) {
+        if (left.type.kind === "caught")
+            left = { kind: "caughtToDyn", value: left, type: DYN, loc: left.loc };
+        if (right.type.kind === "caught")
+            right = { kind: "caughtToDyn", value: right, type: DYN, loc: right.loc };
+    }
     if (left.type.kind === "dyn" || right.type.kind === "dyn") {
         // The narrowing unit comparisons ARE answerable on unknown: `v ===
         // undefined` / `v !== null` test the dyn node's kind directly, and
@@ -6475,9 +6894,9 @@ export function lowerBinary(lowerer, expr) {
             const dynSide = left.type.kind === "dyn" ? left : right;
             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)) &&
+            if ((reference.kind === "object" || reference.kind === "record" || reference.kind === "array" ||
+                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 +6943,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 +6975,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 +7409,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 +7427,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 +7473,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 +7532,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.
@@ -7664,6 +8110,8 @@ function lowerDynTypeofTest(lowerer, expr, loc) {
     for (const [a, b] of operandPairs(expr)) {
         if (!ts.isTypeOfExpression(a))
             continue;
+        if (lowerer.isStdlibGlobal(a.expression, "fetch"))
+            continue;
         // Non-literal comparisons use the ordinary typeof string value,
         // preserving both operands' evaluation order without a narrowing test.
         if (!ts.isStringLiteral(b))
@@ -7970,6 +8418,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 +8436,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 +8494,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 +8538,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 +8557,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 +8585,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 +8684,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 +8913,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 +8946,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 +9197,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 +9339,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) {
@@ -8967,11 +9474,10 @@ function matchAllRegexOf(lowerer, e) {
    *     member fence);
    *   - a nullable receiver (the JS `s.match(re).groups` idiom) throws
    *     Node's exact TypeError on the unit arms;
-   *   - every declared name is a key (nonparticipating groups hold "" —
-   *     divergence 51's rule, exactly the slice elements they project);
+   *   - every declared name is a key (nonparticipating groups hold undefined,
+   *     exactly the slice elements they project);
    *   - ES2025 duplicate names (distinct alternatives) project the first
-   *     participating occurrence: at most one participates, and a
-   *     participating-empty "" falls through to slots that are "" anyway;
+   *     participating occurrence, including a participating empty string;
    *   - key order is group declaration order (declaredOrder), Node's own.
    * The record has no prototype — Node's groups object is null-prototype,
    * observable only through util.inspect's "[Object: null prototype]"
@@ -9048,12 +9554,8 @@ function matchSliceUnionArms(lowerer, unionId) {
     }
     return { arrTag, units };
 }
-/** The groups-record projection call: the result is the CHECKER'S OWN
-   * shape — `{ [key: string]: string }`, the hybrid index-signature
-   * record with no declared fields — holding one OVERFLOW entry per
-   * group name in declaration order, so every downstream consumer
-   * (recordKeyGet reads, Object.keys, JSON, the `| undefined` union
-   * wrap) meets exactly the type tsc reported. One lifted helper per
+/** The groups-record projection holds string | undefined values, including
+   * an own overflow entry for every nonparticipating capture. One lifted helper per
    * (index list, receiver representation) builds it; see
    * lowerMatchGroupsRead for the semantics the body encodes. */
 export function lowerGroupsProjection(lowerer, recv, groups, loc) {
@@ -9071,7 +9573,8 @@ export function lowerGroupsProjection(lowerer, recv, groups, loc) {
             order.push(g.name);
         }
     }
-    const shapeId = lowerer.shapes.intern([], false, STRING);
+    const valueType = arrayValueType(lowerer, STRING);
+    const shapeId = lowerer.shapes.intern([], false, valueType);
     const recordT = { kind: "record", shapeId };
     const recvKey = recv.type.kind === "union" ? recv.type.unionId : "arr";
     const key = `regexgroups:${shapeId}:${groups.map((g) => `${g.name}=${g.index}`).join(",")}:${recvKey}`;
@@ -9113,7 +9616,7 @@ export function lowerGroupsProjection(lowerer, recv, groups, loc) {
             body.push({ kind: "varDecl", localId: "arr.0", init: narrowed, loc });
             mRef = { kind: "varRef", localId: "arr.0", type: arrayOf(STRING), loc };
         }
-        const elem = (index) => ({ kind: "arrayGet", arr: mRef, index: numLit(index, loc), type: STRING, loc });
+        const elem = (index) => arrayValueRead(lowerer, mRef, numLit(index, loc), STRING, loc);
         const values = new Map();
         order.forEach((name, i) => {
             const idxs = indicesByName.get(name);
@@ -9121,16 +9624,16 @@ export function lowerGroupsProjection(lowerer, recv, groups, loc) {
                 values.set(name, elem(idxs[0]));
                 return;
             }
-            // Duplicates: the first non-"" occurrence (at most one
-            // participates; all-"" answers "" like any nonparticipating slot).
+            // Duplicates: the first participating occurrence. Empty strings
+            // participate; undefined means this alternative did not match.
             const id = `g${i}.0`;
-            locals.push({ id, name: `g${i}`, type: STRING, mutable: true });
+            locals.push({ id, name: `g${i}`, type: valueType, mutable: true });
             body.push({ kind: "varDecl", localId: id, init: elem(idxs[0]), loc });
-            const gRef = { kind: "varRef", localId: id, type: STRING, loc };
+            const gRef = { kind: "varRef", localId: id, type: valueType, loc };
             for (const idx of idxs.slice(1)) {
                 body.push({
                     kind: "if",
-                    cond: { kind: "strEq", negated: false, left: gRef, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc },
+                    cond: { kind: "unionIsTag", unionId: valueType.kind === "union" ? valueType.unionId : "", tag: valueType.kind === "union" ? lowerer.armTag(valueType.unionId, UNDEFINED_T) : -1, negated: false, value: gRef, type: BOOL, loc },
                     then: [{ kind: "assign", localId: id, value: elem(idx), loc }],
                     else_: null,
                     loc,
@@ -9224,6 +9727,15 @@ export function lowerFieldRead(lowerer, expr) {
     if (receiverIr?.kind === "record") {
         const shape = lowerer.shapes.get(receiverIr.shapeId);
         if (shape?.indexValue && !shape.fields.some((f) => f.name === expr.name.text)) {
+            const actual = tryLowerExpression(lowerer, expr.expression);
+            if (actual?.type.kind === "dyn")
+                return { kind: "dynKeyGet", value: actual,
+                    key: { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) }, type: DYN, loc: locOf(expr) };
+            if (actual?.type.kind === "record") {
+                const field = lowerer.shapes.get(actual.type.shapeId)?.fields.find((field) => field.name === expr.name.text);
+                if (field)
+                    return { kind: "recordGet", obj: actual, shapeId: actual.type.shapeId, field: field.name, type: field.type, loc: locOf(expr) };
+            }
             lowerer.unsupported("SC1090", expr, `dot access to index-signature keys (spell it r["${expr.name.text}"] — brackets are the index-signature form)`);
         }
     }
@@ -9370,7 +9882,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) };
     }
@@ -9504,6 +10016,10 @@ function lowerUnionKeyedRead(lowerer, expr, unionId, value, key, literalField) {
  * or accessor dispatch. Resolve the property from the represented class;
  * the optional checker view must not turn its getter into a record read. */
 function classFieldTarget(lowerer, receiverNode, receiverType, fieldName, saved) {
+    const represented = saved ?? lowerer.lowerExpr(receiverNode);
+    if (represented.type.kind === "dyn" && isJsSourceFile(receiverNode.getSourceFile()) && !fieldName.startsWith("#")) {
+        return { container: "dynamic", obj: represented, field: fieldName, fieldType: DYN };
+    }
     const info = lowerer.classes.get(receiverType.className);
     if (!info) {
         // A receiver typed as a class whose collection deferred: the
@@ -9513,14 +10029,14 @@ function classFieldTarget(lowerer, receiverNode, receiverType, fieldName, saved)
     }
     const fieldType = info.fields.get(fieldName);
     const lowerObjectReceiver = () => {
-        let obj = saved ?? lowerer.lowerExpr(receiverNode);
+        let obj = represented;
         if (obj.type.kind === "union") {
             const helper = lowerer.narrowedArmHelper(obj.type.unionId, receiverType, locOf(receiverNode));
             obj = helper
                 ? { kind: "call", callee: helper, args: [obj], type: receiverType, loc: locOf(receiverNode) }
                 : lowerer.maybeNarrow(obj, receiverNode);
         }
-        return obj.type.kind === "dyn" ? lowerer.coerceInto(receiverNode, obj, receiverType) : obj;
+        return lowerer.coerceInto(receiverNode, obj, receiverType);
     };
     if (fieldName === "cause" && receiverType.className !== "%DOMException") {
         let root = info;
@@ -9532,6 +10048,11 @@ function classFieldTarget(lowerer, receiverNode, receiverType, fieldName, saved)
     }
     if (fieldType) {
         const obj = lowerObjectReceiver();
+        if (isJsSourceFile(receiverNode.getSourceFile()) && !fieldName.startsWith("#") &&
+            [...lowerer.classes.values()].some((candidate) => lowerer.isSubclassOf(candidate.def.name, receiverType.className) &&
+                (candidate.methods.has(`get:${fieldName}`) || candidate.methods.has(`set:${fieldName}`)))) {
+            return { container: "dynamic", obj: lowerer.coerceToExpected(obj, DYN), field: fieldName, fieldType: DYN };
+        }
         return { container: "class", obj, className: receiverType.className, field: fieldName, fieldType };
     }
     // Accessor property: either half declared anywhere on the chain
@@ -9549,6 +10070,12 @@ function classFieldTarget(lowerer, receiverNode, receiverType, fieldName, saved)
             fieldType: getF ? getF.sig.ret : setF.sig.params[0].type,
         };
     }
+    if (info.decl && isJsSourceFile(info.decl.getSourceFile())) {
+        const property = lowerer.checker.getPropertyOfType(lowerer.checker.getTypeAtLocation(receiverNode), fieldName);
+        if (property && lowerer.checker.declarationsOf(property).some((declaration) => ts.isPropertyAccessExpression(declaration) || ts.isBinaryExpression(declaration) || ts.isElementAccessExpression(declaration))) {
+            return { container: "dynamic", obj: lowerer.coerceToExpected(lowerObjectReceiver(), DYN), field: fieldName, fieldType: DYN };
+        }
+    }
     return null;
 }
 /** A structural assertion can leave the value in its original class
@@ -9574,6 +10101,8 @@ function representedClassFieldTarget(lowerer, receiverNode, fieldName, value) {
    * receivers) a declared accessor property. Returns the pieces of a
    * fieldSet/recordSet/accessor-call (minus value/kind) or null. */
 export function fieldTarget(lowerer, access) {
+    if (lowerer.cjsLocalModuleBindingOf(access.expression))
+        return null;
     if (lowerer.chainBlocked(access))
         return null;
     if (access.name.text === "stackTraceLimit" && lowerer.isStdlibGlobal(access.expression, "Error")) {
@@ -9581,7 +10110,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);
     }
@@ -9688,8 +10217,17 @@ export function fieldTarget(lowerer, access) {
                 return declaredArms.every((a) => ivArms.some((b) => typeEquals(a, b)));
             };
             if (!nameSym || nameSym.name === ts.InternalSymbolName.Index || canonicalized()) {
-                const obj = lowerer.lowerExpr(access.expression);
-                return { container: "recordOvf", obj, shapeId: receiverIr.shapeId, field: access.name.text, fieldType: shape.indexValue };
+                let obj = lowerer.lowerExpr(access.expression);
+                if (obj.type.kind === "union" && lowerer.armTag(obj.type.unionId, UNDEFINED_T) >= 0) {
+                    const present = lowerer.stripUndefinedArm(obj.type);
+                    obj = present.kind === "record" ? lowerer.runtimeOptionalPropertyReceiver(access.expression, obj, present, access.name.text) ?? obj : lowerer.maybeNarrow(obj, access.expression);
+                }
+                if (obj.type.kind !== "record")
+                    return null;
+                const actualShape = lowerer.shapes.get(obj.type.shapeId);
+                if (!actualShape?.indexValue)
+                    return null;
+                return { container: "recordOvf", obj, shapeId: obj.type.shapeId, field: access.name.text, fieldType: actualShape.indexValue };
             }
         }
         return null;
@@ -9787,6 +10325,13 @@ 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 === "dynamic")
+        return {
+            kind: "dynKeyGet", value: target.obj,
+            key: { kind: "strLit", value: target.field, type: STRING, loc }, type: DYN, loc,
+        };
+    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 +10357,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 +10439,13 @@ 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 === "dynamic")
+        return {
+            kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet",
+                args: [target.obj, { kind: "strLit", value: target.field, type: STRING, loc }, lowerer.coerceToExpected(value, DYN)], type: VOID, loc }, loc,
+        };
+    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 +10553,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
@@ -10054,7 +10611,7 @@ export function lowerPromiseAllTupleCall(lowerer, call, access) {
     const loc = locOf(call);
     const inner = first.inner;
     const entryT = { kind: "promise", inner };
-    const elems = argNode.elements.map((el) => lowerer.lowerExpr(el));
+    const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, entryT));
     const entries = { kind: "arrayLit", elems, type: arrayOf(entryT), loc };
     const type = inner.kind === "void"
         ? { kind: "promise", inner: VOID }
@@ -10086,7 +10643,10 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     // NaN — SEMANTICS.md), combine, write back (dyn.keySet). The
     // receiver and member read are saved before evaluating the RHS.
     if (ts.isPropertyAccessExpression(access)) {
-        const probed = tryLowerExpression(lowerer, access.expression);
+        let probed = tryLowerExpression(lowerer, access.expression);
+        const staticClass = probed?.type.kind === "classval" ? lowerer.classes.get(probed.type.className) : undefined;
+        if (probed && staticClass && hasRuntimeStatics(staticClass))
+            probed = lowerer.coerceToExpected(probed, DYN);
         if (probed?.type.kind === "dyn") {
             const receiver = save(probed, "%compoundReceiver");
             const key = { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access.name) };
@@ -10095,6 +10655,14 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
             const rhs = save(rhsNode
                 ? lowerer.lowerExpr(rhsNode)
                 : { kind: "numLit", value: 1, type: F64, loc }, "%compoundRhs");
+            if (isJsSourceFile(access.getSourceFile()) && lowerer.dynConvertible(rhs.type)) {
+                const numeric = ["-", "*", "/", "%", "**"].includes(op);
+                const right = lowerer.coerceToExpected(rhs, DYN);
+                const value = save({ kind: "libCall", fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+                    args: op === "+" ? [read, right] : [read, right, { kind: "strLit", value: op, type: STRING, loc }], type: DYN, loc }, "%compoundResult");
+                body.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [receiver, key, value], type: VOID, loc }, loc });
+                return { kind: "seqExpr", stmts: body, result: value, type: DYN, loc };
+            }
             const numericRhs = rhs.type.kind === "dyn"
                 ? { kind: "dynCheck", value: rhs, type: F64, loc: rhs.loc }
                 : lowerOptionalNumber(lowerer, rhs, loc);
@@ -10132,35 +10700,12 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
         value = { kind: "bin", op, left: read, right: numericRhs, type: F64, loc };
     }
     else if (target.fieldType.kind === "dyn" &&
-        isJsSourceFile(access.getSourceFile()) &&
-        (op === "+" || op === "-" || op === "*" || op === "/" || op === "%" || op === "**")) {
-        // CHECKED-DYNAMIC fields (implicit-any ctor assignments —
-        // countdown.js's `this[kLimit]` shape with a plain name) follow the
-        // JS dyn-operand binary stance: arithmetic CHECKS the dyn side to
-        // number (dynCheck — the catchable TypeError, never a silent
-        // ToNumber; SEMANTICS.md) and computes natively; the result boxes
-        // back into the field's dyn slot. `+=` with a string RHS is the
-        // string-context read: check to string, concat, box back.
-        const checkNum = (e) => e.type.kind === "dyn" ? { kind: "dynCheck", value: e, type: F64, loc: e.loc } : e;
-        if (op === "+" && rhs.type.kind === "string") {
-            const concat = {
-                kind: "strConcat",
-                // String-context read: JS's String(unknown) over the field —
-                // the JS-exact dyn walker, never a checked cast.
-                left: { kind: "toString", operand: read, type: STRING, loc },
-                right: rhs,
-                type: STRING,
-                loc,
-            };
-            value = { kind: "dynFrom", value: concat, type: DYN, loc };
-        }
-        else if (rhs.type.kind === "f64" || rhs.type.kind === "dyn") {
-            const bin = { kind: "bin", op, left: checkNum(read), right: checkNum(rhs), type: F64, loc };
-            value = { kind: "dynFrom", value: bin, type: DYN, loc };
-        }
-        else {
-            lowerer.unsupported("SC1043", access);
-        }
+        isJsSourceFile(access.getSourceFile())) {
+        const numeric = ["-", "*", "/", "%", "**"].includes(op);
+        const left = lowerer.coerceToExpected(read, DYN);
+        const right = lowerer.coerceToExpected(rhs, DYN);
+        value = { kind: "libCall", fn: op === "+" ? "dyn.add" : numeric ? "dyn.arithmetic" : "dyn.bitwise",
+            args: op === "+" ? [left, right] : [left, right, { kind: "strLit", value: op, type: STRING, loc }], type: DYN, loc };
     }
     else {
         lowerer.unsupported("SC1043", access);
@@ -10193,8 +10738,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 +10748,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 +10774,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