@scriptc/compiler 0.2.1 → 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
@@ -53,13 +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 { 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
@@ -586,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;
@@ -777,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);
                 }
@@ -1067,6 +1071,8 @@ function lowerExprInner(lowerer, expr) {
         }
         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 };
         }
@@ -1941,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
@@ -2091,7 +2104,8 @@ function lowerExprInner(lowerer, expr) {
         // chain. Scalar-narrowed occurrences bridge via maybeNarrow's
         // validated dynCheck as usual.
         if (recvLowered.type.kind === "dyn" || isJsSourceFile(expr.getSourceFile()) &&
-            ["f64", "bool", "bigint", "string", "symbol"].includes(recvLowered.type.kind)) {
+            (["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: lowerer.coerceToExpected(recvLowered, DYN), type: DYN, loc }, expr);
@@ -2540,8 +2554,52 @@ 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 &&
@@ -2605,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))
@@ -3559,14 +3630,16 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         if (receiver.type.kind === "dyn")
             return { kind: "dynKeyGet", value: receiver,
                 key: { kind: "strLit", value: name, type: STRING, loc: locOf(expr) }, type: DYN, loc: locOf(expr) };
-        // Ordinary arrays keep the existing Array builtin identity token.
-        const result = { kind: "strLit", value: "[builtin Array]", type: STRING, loc: locOf(expr) };
-        return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr: receiver, loc: locOf(expr) }], result, type: STRING, loc: locOf(expr) };
+        const 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") {
@@ -3670,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 };
         }
@@ -3771,6 +3844,9 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             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"
@@ -4020,6 +4096,8 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         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
@@ -4438,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
@@ -4540,6 +4621,13 @@ export function lowerElementAccess(lowerer, expr) {
             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
@@ -4774,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);
@@ -5353,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)
@@ -5432,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)))
@@ -5445,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);
@@ -5502,6 +5612,12 @@ export function lowerElementWrite(lowerer, 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")
@@ -6278,78 +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) {
-            if (ts.isPropertyAccessExpression(expr.operand) && isJsSourceFile(expr.getSourceFile())) {
-                const receiver = lowerer.lowerExpr(expr.operand.expression);
-                if (receiver.type.kind === "dyn") {
-                    const local = lowerer.declareHiddenLocal("%incrementReceiver", DYN);
-                    const old = lowerer.declareHiddenLocal("%incrementOld", DYN);
-                    const next = lowerer.declareHiddenLocal("%incrementNext", DYN);
-                    const value = varRef(local.id, DYN, loc);
-                    const key = { kind: "strLit", value: expr.operand.name.text, type: STRING, loc };
-                    return { kind: "seqExpr", stmts: [
-                            { kind: "varDecl", localId: local.id, init: receiver, loc },
-                            { kind: "varDecl", localId: old.id, init: { kind: "libCall", fn: "dyn.toNumeric", args: [
-                                        { kind: "dynKeyGet", value, key, type: DYN, loc },
-                                    ], type: DYN, loc }, loc },
-                            { kind: "varDecl", localId: next.id, init: { kind: "libCall", fn: "dyn.increment", args: [varRef(old.id, DYN, loc),
-                                        { kind: "boolLit", value: op === "+", type: BOOL, loc }], type: DYN, loc }, loc },
-                            { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [value, key, varRef(next.id, DYN, loc)], type: VOID, loc }, loc },
-                        ], result: varRef(prefix ? next.id : old.id, DYN, loc), type: DYN, loc };
-                }
-            }
-            const target = ts.isPropertyAccessExpression(expr.operand)
-                ? lowerer.fieldTarget(expr.operand)
-                : symbolFieldTarget(lowerer, expr.operand);
-            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) {
@@ -6429,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" };
@@ -6445,8 +6570,8 @@ 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") &&
         isJsSourceFile(expr.getSourceFile())) {
@@ -6467,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;
@@ -6731,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
@@ -6760,7 +6894,7 @@ 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" ||
+            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)) {
@@ -7976,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))
@@ -9338,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]"
@@ -9419,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) {
@@ -9442,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}`;
@@ -9484,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);
@@ -9492,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,
@@ -9595,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)`);
         }
     }
@@ -9875,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
@@ -9884,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;
@@ -9903,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
@@ -9920,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
@@ -9945,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")) {
@@ -10059,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;
@@ -10158,6 +10325,11 @@ 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") {
@@ -10267,6 +10439,11 @@ 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") {
@@ -10434,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 }
@@ -10466,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) };
@@ -10475,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);
@@ -10512,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);