@scriptc/compiler 0.4.7 → 0.4.8

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

@@ -1,5 +1,5 @@
 import { lowerStaticPrivateAssignment } from "./private-statics.js";
-import { keepsInitializerLayout, notePreservedLayout } from "./structural-instances.js";
+import { keepsCheckedDynamicValue, keepsInitializerLayout, notePreservedLayout, } from "./structural-instances.js";
 import { partialFieldRead } from "./partial-assertions.js";
 import { jsGlobalValueByName } from "./global-values.js";
 import { lowerTupleAliasDecl, stripTypeWrappers } from "./typed-arguments.js";
@@ -7,14 +7,15 @@ import { islandHandleBinding, lowerIslandExpr, isIslandRequireSpec, lowerIslandR
 import { isIslandSubclassDecl } from "../../node-islands/boundary.js";
 import { allBytesArms, indexedUnionArms, lowerIndexedUnionMember, lowerIndexedUnionNumberRead, lowerIndexedUnionRead, } from "./indexed-unions.js";
 import { declaredMemberOf, fenceDatePrototypeWrite, isPromisePrototypeRead, lowerUnionKeyedRead, } from "./expressions/property-access.js";
-import { hostedStorageView, hostsAll } from "./expressions/hosted-narrowing.js";
+import { hostedStorageView, hostsAll, recordViewHosted } from "./expressions/hosted-narrowing.js";
+import { assertionViewCopy, bindingIdentityUse, bindingWrite } from "./divergences.js";
 import { requestGeneralStreamSurface } from "./general-streams.js";
 import { lowerForAwaitDynStream, nodeStreamInterfaceSide } from "./dyn-streams.js";
 import { lowerForAwaitValueStream } from "./builtins/hash-stream.js";
 import { lowerChildPropertyWrite } from "./handle-properties.js";
 import { matchAllRowsReadByElements, storedMatchAllRowsReadByElements, } from "./containers/match-row-uses.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
-import { runtimeKeyPatternRead } from "./expressions/keyed-field-targets.js";
+import { literalFieldKeys, runtimeKeyPatternRead } from "./expressions/keyed-field-targets.js";
 import { declaresHoistedBinding, staticCondition } from "./static-typeof.js";
 import { lowerCollectionSpread } from "./containers/collection-methods.js";
 import { lowerEventObjectPropertyWrite } from "./lower-event-target.js";
@@ -39,17 +40,18 @@ import { requireInitFlagStmt } from "./require-initialization.js";
 import { isJsonRequireDecl } from "./json-require.js";
 import { isTimeValueDateDeclaration } from "./date-values.js";
 import { bindingSource } from "../binding-source.js";
-import { lowerConstructorReturn } from "./constructor-returns.js";
+import { clearPendingPrimitiveReturn, lowerConstructorReturn } from "./constructor-returns.js";
 import { statementGroupKey } from "./type-failure.js";
 import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, splitRequireAssignmentOf, splitRequireBindingOf, splitRequireBindingOfIdent, splitRequireEarlyReadOf, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
 import { cjsExportMemberWriteGlobalOf, isCjsExportsIdentifier, isCjsModuleExports, isFreshExportsReset, } from "./cjs-exports-object.js";
 import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
 import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, lowerSafeIndexRead, } from "./array-values.js";
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement, } from "./lower-generators.js";
-import { classAsyncGeneratorIterator, lowerForAwaitBuiltin } from "./lower-async-iteration.js";
+import { classAsyncGeneratorIterator, isNodeReadableIteratorSource, isWebReadableIteratorSource, lowerForAwaitBuiltin, } from "./lower-async-iteration.js";
 import { BOOL, BYTES_U8, CAUGHT, DATE_T, DYN_HANDLE_KINDS, DYN, F64, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, neverTaintedJsType, staticImportNamespaceType, } from "./lowerer.js";
 import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
+import { isBuiltinIdentityToken, isPrimitiveValueType, lowerPrimitiveBaseDelete, } from "./primitive-throws.js";
 import { cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, locOf, requireEarlyReference, requireSpecOf, } from "../program.js";
 import { isStrictCode } from "./strict-mode.js";
 import { markSloppyRecordWrites } from "./frozen-records.js";
@@ -62,7 +64,7 @@ import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfS
 import { lowerForOfHelperChain } from "./containers/iterator-helpers.js";
 import { objectIterOverIndexShape } from "./containers/indexed-objects.js";
 import { strCharsCall } from "./containers/array-construction.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, genericBindingPresenceStore, genericBindingStoredValue, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, genericLocalClassBinding, } from "./generic-functions.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, genericAliasPresenceStore, genericBindingPresenceStore, genericBindingStoredValue, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, genericLocalClassBinding, } from "./generic-functions.js";
 import { bindingNeverReassigned, deadUnmappableBinding, fileWritesBinding, nullishExprUnitOf, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
 import { hasExplicitJsDocReturn } from "./function-returns.js";
 import { recordKeysArrayCall } from "./lower-calls.js";
@@ -1726,6 +1728,39 @@ export function lowerStmt(lowerer, stmt) {
         // observed empty returns even when JSDoc omits undefined. Any remaining
         // incompatible boundary keeps the ordinary per-statement refusal.
         let value = null;
+        // A derived constructor that can record a pending TypeError on a
+        // primitive return drops it when a return of its own completes: a
+        // `finally` block's `return;`, `return undefined` or `return this`
+        // replaces the earlier completion instead of leaving it pending. The
+        // drop follows the operand, which may throw — an operand that throws
+        // never completes the return, so a `finally` that catches it and then
+        // finishes resumes the earlier primitive return (and its TypeError).
+        const withClearedPending = (ret) => {
+            const clear = clearPendingPrimitiveReturn(lowerer, stmt);
+            if (clear.length === 0)
+                return ret;
+            const loc = locOf(stmt);
+            const body = ret.kind === "block" ? ret.body : [ret];
+            const last = body.at(-1);
+            if (last?.kind !== "return")
+                return { kind: "block", body: [...clear, ret], loc };
+            const before = body.slice(0, -1);
+            if (last.value === null)
+                return { kind: "block", body: [...before, ...clear, last], loc };
+            // A constructor returns void, so a valued operand only evaluates for
+            // effect — ahead of the drop, since a `return this.fail()` inside a
+            // `finally` that catches the throw never completes.
+            return {
+                kind: "block",
+                body: [
+                    ...before,
+                    { kind: "exprStmt", expr: last.value, loc },
+                    ...clear,
+                    { kind: "return", value: null, loc },
+                ],
+                loc,
+            };
+        };
         if (stmt.expression) {
             // A constructor's returned object replaces the constructed `this`.
             if (lowerer.currentClass?.ctor) {
@@ -1733,7 +1768,7 @@ export function lowerStmt(lowerer, stmt) {
                 if (constructorReturn !== null)
                     return constructorReturn;
             }
-            return lowerer.lowerReturnStmt(stmt.expression, locOf(stmt));
+            return withClearedPending(lowerer.lowerReturnStmt(stmt.expression, locOf(stmt)));
         }
         else if (lowerer.ctx.returnType.kind === "union") {
             value = lowerer.wrappedUndefined(lowerer.ctx.returnType, locOf(stmt));
@@ -1749,8 +1784,8 @@ export function lowerStmt(lowerer, stmt) {
         }
         // An async generator's bare return has no operand to await.
         if (lowerer.ctx.isAsync === true && lowerer.ctx.generator)
-            return { kind: "return", value, awaited: true, loc: locOf(stmt) };
-        return { kind: "return", value, loc: locOf(stmt) };
+            return withClearedPending({ kind: "return", value, awaited: true, loc: locOf(stmt) });
+        return withClearedPending({ kind: "return", value, loc: locOf(stmt) });
     }
     if (ts.isBreakStatement(stmt) || ts.isContinueStatement(stmt)) {
         const kw = ts.isBreakStatement(stmt) ? "break" : "continue";
@@ -5003,17 +5038,20 @@ function evolvingArrayHolderType(lowerer, decl) {
         return null;
     return evolvingArrayHold(lowerer, decl.initializer) === null ? null : DYN;
 }
-/** A single static type for an initializer-less JavaScript `let` whose
- * later plain writes all agree. An evolving JS local reads as `undefined`
- * until control flow proves a write, so a scalar slot is sound only when
- * every ordinary use already has that concrete flow type. A write's call
- * counts when its signature is declared in the standard library, whose
- * return types are declared rather than inferred from JavaScript. A
- * closure capture can observe the local before an outer assignment, and
- * the checker leaves captured evolving lets broad: a captured runtime
- * handle (`let child; if (...) child = spawn(...)`) takes the handle or
- * `undefined`, which nested functions read as a checked-dynamic value
- * (closureDynLets), and other captured bindings stay checked-dynamic. */
+/** A single static type for an initializer-less `let` without an
+ * annotation whose later plain writes all agree. An evolving local reads as
+ * `undefined` until control flow proves a write, so a scalar slot is sound
+ * only when every ordinary use already has that concrete flow type (or an
+ * arm of it). A write of `null` or `undefined` joins the written type as an
+ * optional arm (`let stat; try { stat = lstatSync(".") } catch { stat = null }`
+ * holds `Stats | null`). A write's call counts when its signature is
+ * declared in the standard library, whose return types are declared rather
+ * than inferred from JavaScript. A closure capture can observe the local
+ * before an outer assignment, and the checker leaves captured evolving lets
+ * broad: a captured runtime handle (`let child; if (...) child = spawn(...)`)
+ * takes the handle or `undefined`, which nested functions read as a
+ * checked-dynamic value (closureDynLets), and other captured bindings stay
+ * checked-dynamic. */
 export function inferredEvolvingLetType(lowerer, decl) {
     if (!ts.isIdentifier(decl.name))
         return null;
@@ -5068,7 +5106,10 @@ export function inferredEvolvingLetType(lowerer, decl) {
             }
             return "skip";
         }
-        if (ts.isBinaryExpression(node)) {
+        // A compound assignment (`x += 1`) reads and rewrites the binding
+        // through an operator this scan does not model; a comparison
+        // (`x === null`) only reads it, and the read check below covers that.
+        if (ts.isBinaryExpression(node) && ts.isAssignmentOperator(node.operatorToken.kind)) {
             let left = node.left;
             while (ts.isParenthesizedExpression(left))
                 left = left.expression;
@@ -5091,7 +5132,7 @@ export function inferredEvolvingLetType(lowerer, decl) {
                     return "stop";
                 }
                 const mapped = lowerer.mapTypeOf(lowerer.typeOf(node.right));
-                if (!mapped || mapped.kind === "dyn" || mapped.kind === "void" || isUnitType(mapped)) {
+                if (!mapped || mapped.kind === "dyn" || mapped.kind === "void") {
                     invalid = true;
                     return "stop";
                 }
@@ -5114,20 +5155,49 @@ export function inferredEvolvingLetType(lowerer, decl) {
         return undefined;
     };
     ts.walkPreorder(scope, visit);
-    const first = writes[0];
-    if (invalid || first === undefined || !writes.every((write) => typeEquals(write, first)))
+    // A write of an already-unioned value contributes its arms, so a call
+    // declared `Stats | null` reads the same as separate value and unit
+    // writes.
+    const armsOf = (t) => t.kind === "union" ? (lowerer.unions.get(t.unionId)?.arms ?? [t]) : [t];
+    const valueArms = [];
+    const unitArms = [];
+    for (const write of writes) {
+        for (const arm of armsOf(write)) {
+            const seen = isUnitType(arm) ? unitArms : valueArms;
+            if (!seen.some((other) => typeEquals(other, arm)))
+                seen.push(arm);
+        }
+    }
+    const value = valueArms[0];
+    if (invalid || value === undefined || valueArms.length > 1)
         return null;
+    const arms = [value];
+    if (unitArms.length > 0) {
+        // An evolving local reads as `undefined` before control flow proves a
+        // write, so the optional storage carries that arm as well.
+        arms.push(UNDEFINED_T);
+        for (const unit of unitArms) {
+            if (unit.kind !== "undefinedT")
+                arms.push(unit);
+        }
+    }
+    const storage = arms.length === 1 ? value : { kind: "union", unionId: lowerer.unions.intern(arms) };
+    // A narrowed read sees an arm, or a sub-union of arms, of the storage.
     if (!reads.every((read) => {
         const mapped = lowerer.mapTypeOf(lowerer.typeOf(read));
-        return mapped !== null && typeEquals(mapped, first);
+        return (mapped !== null && armsOf(mapped).every((arm) => arms.some((own) => typeEquals(own, arm))));
     }))
         return null;
     if (!captured)
-        return first;
-    if (!DYN_HANDLE_KINDS.has(first.kind))
+        return storage;
+    if (!DYN_HANDLE_KINDS.has(value.kind))
         return null;
     lowerer.closureDynLets.add(symbol);
-    return { kind: "union", unionId: lowerer.unions.intern([first, UNDEFINED_T]) };
+    // A nested function can read the binding before the outer assignment:
+    // the optional arm is what the checked-dynamic read of the closure sees.
+    return storage.kind === "union"
+        ? storage
+        : { kind: "union", unionId: lowerer.unions.intern([value, UNDEFINED_T]) };
 }
 /** Whether a call's resolved signature is declared in the standard library
  * (`spawn(...)`), so its declared return type is the value's type. Calls of
@@ -5313,11 +5383,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     // `const h = id` — an ALIAS of a generic function: the alias's symbol
     // registers the target's info (calls and pinned values resolve like
-    // the target's own name), the binding has no runtime value, and the
-    // statement emits nothing (collectGlobals skipped module-scope
-    // globals by the same test; block-scoped aliases register here).
+    // the target's own name) and the binding has no runtime value, so the
+    // statement emits nothing but the flag of a module-scope alias whose
+    // reads can run before it (genericAliasPresenceStore).
     if (bindingGenericFnAliasInfoOf(lowerer, decl))
-        return null;
+        return genericAliasPresenceStore(lowerer, decl);
     // `const stored = overloadedDeclaration`: no runtime slot is needed;
     // calls project onto the declaration's implementation ABI and value
     // reads reuse its interned closure identity.
@@ -5439,6 +5509,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             raw.type.kind === "dyn" &&
             (g.type.kind === "record" ||
                 g.type.kind === "object" ||
+                // `const p = Promise.all.call(C, xs)` in JavaScript: the call runs
+                // the specification's algorithm with `C`'s capability and returns
+                // whatever `C` constructed, a foreign instance the checker still
+                // calls `Promise<T>`. The binding holds that value as dyn; a
+                // native-promise check would reject it (t262-db B3).
+                (g.type.kind === "promise" && isJsPromiseStaticCall(raw)) ||
                 (ts.isIdentifier(decl.name) &&
                     jsBindingKeepsCheckedObject(lowerer, decl.name, g.type) &&
                     (existingValueForm(decl.initializer) || jsHoldsDynObject(lowerer, decl.initializer)))))
@@ -5452,6 +5528,18 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             g.type = raw.type;
             notePreservedLayout(lowerer, decl);
         }
+        // The same for a module const initialized by an assertion: the value's
+        // storage already answers the asserted view (narrowing.ts), so the
+        // module holds that layout and writes through it reach the object.
+        if (!isVarDeclared(decl) &&
+            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
+            assertionKeepsStorageLayout(lowerer, decl, raw.type, g.type)) {
+            g.type = raw.type;
+            notePreservedLayout(lowerer, decl);
+        }
+        if (!isVarDeclared(decl) &&
+            keepsCheckedDynamicValue(lowerer, decl.initializer, raw.type, g.type))
+            g.type = raw.type;
         const arithmetic = raw.type.kind === "union" ? lowerer.unions.get(raw.type.unionId)?.arms : undefined;
         if (arithmetic?.length === 2 &&
             arithmetic.every((a) => a.kind === "f64" || a.kind === "string" || a.kind === "bool") &&
@@ -5464,6 +5552,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             lowerer.runtimeOptionalArithmeticGlobals.add(g);
         }
         const init = lowerer.coerceInto(decl.initializer, raw, g.type);
+        refuseAssertionViewWrite(lowerer, decl);
         return {
             kind: "assign",
             localId: g.id,
@@ -5505,12 +5594,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         // `let x: number;` — declared, uninitialized. tsc guarantees no read
         // before assignment (TS2454) and rejects uninitialized const (TS1155).
         // Unannotated `let x;` is an evolving `any` — the checked-dynamic
-        // binding fallback (irTypeOf → dynFallbackType).
+        // binding fallback (irTypeOf → dynFallbackType) unless its writes agree
+        // on a type.
         // Undefined-armed unions (`let x: string | undefined;`) are readable
         // immediately (the type covers the unassigned state), so they
         // initialize to the interned undefined arm like an omitted optional.
         let type = lowerer.irTypeOf(decl.name);
-        if (type.kind === "dyn" && isLet && isJsSourceFile(ts.getSourceFileOfNode(decl))) {
+        if (type.kind === "dyn" && isLet && decl.type === undefined) {
             type = inferredEvolvingLetType(lowerer, decl) ?? type;
         }
         // `var v: void;` / `let x: undefined;` — a unit-only binding rides
@@ -5621,6 +5711,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         type = init.type;
         notePreservedLayout(lowerer, decl);
     }
+    // An index-signature binding whose assertion of an existing value lowered
+    // to that value (narrowing.ts keeps it instead of answering a copy whose
+    // keys live in a map of its own) keeps the value too: converting it here
+    // would take every write through the binding with it.
+    if (keepsCheckedDynamicValue(lowerer, decl.initializer, init.type, type))
+        type = init.type;
     // A JavaScript binding assigned values outside its declared type
     // (analyzeJsWidenedBindings in lowerer.ts) holds them as checked-dynamic.
     {
@@ -5678,9 +5774,18 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     const keepsAssertedObject = init.type.kind === "dyn" &&
         !decl.type &&
         keptIdentityAssertion(lowerer, decl.initializer) !== undefined;
+    // `const p = Promise.all.call(C, xs)` in JavaScript: the checked-dynamic
+    // promise-static call returns whatever `C` constructed — a foreign
+    // instance, not the `Promise<T>` the checker infers from the signature —
+    // so the binding holds it as dyn (t262-db B3).
+    const keepsPromiseStaticValue = isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+        !decl.type &&
+        !hasJsTypeAnnotation(decl) &&
+        isJsPromiseStaticCall(init);
     if (expandsObject ||
         preservesObjectIdentity ||
         keepsAssertedObject ||
+        keepsPromiseStaticValue ||
         (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             !decl.type &&
             isNativeBuiltinValueInitializer(lowerer, decl.initializer))) {
@@ -5977,13 +6082,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // the stored type hosts (`const view: Route & { order: number } = ...`)
     // keeps it too: coercing into the annotated layout would copy the
     // value and read members the writes have not created yet.
-    if (!isLet &&
-        decl.initializer &&
-        isAssertionInitializer(decl.initializer) &&
-        (settledType.kind === "union" || settledType.kind === "record") &&
-        (init.type.kind === "union" || init.type.kind === "record") &&
-        hostsAll(lowerer, init.type, settledType)) {
+    if (!isLet && assertionKeepsStorageLayout(lowerer, decl, init.type, settledType)) {
         settledType = init.type;
+        notePreservedLayout(lowerer, decl);
     }
     // An exact class behind a generic interface keeps its native
     // representation so generic calls can specialize against its body.
@@ -6012,6 +6113,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // Slot coercion: `const r: A | B = bValue;` wraps implicitly; width
     // subtyping (`const p: {a: number} = wider;`) is rejected, not coerced.
     init = lowerer.coerceInto(decl.initializer, init, settledType);
+    refuseAssertionViewWrite(lowerer, decl);
     const local = lowerer.declareLocal(decl.name, decl.name.text, settledType, isLet);
     if (runtimeStringArithmetic && init.type.kind === "union") {
         lowerer.runtimeOptionalArithmeticLocals.add(lowerer.runtimeOptionalRootOf(local));
@@ -6061,6 +6163,17 @@ function inferredOptionalRecordType(lowerer, decl, declared, actual) {
         return declared;
     return actual;
 }
+/** Whether a lowered initializer is the checked-dynamic `Promise.<static>.call(C, …)`
+ * call (lower-calls.ts, JavaScript sources only). Its result is whatever `C`
+ * constructed, so a binding the checker typed `Promise<T>` holds it as dyn. */
+function isJsPromiseStaticCall(value) {
+    // Surplus arguments evaluate as statements before the call, so the
+    // initializer is a sequence expression whose result is the call.
+    let result = value;
+    while (result.kind === "seqExpr")
+        result = result.result;
+    return result.kind === "libCall" && result.fn === "promise.genericStatic";
+}
 function lowerVariableInitializer(lowerer, node, expected) {
     let value = node;
     while (ts.isParenthesizedExpression(value) ||
@@ -6802,13 +6915,35 @@ function declaresCheckedDynField(lowerer, type, name) {
     const arms = lowerer.unions.get(type.unionId)?.arms ?? [];
     return arms.length > 0 && arms.every((arm) => declaresCheckedDynField(lowerer, arm, name));
 }
+/** The constant property key of a `delete` target: the name of a dot
+ * access, or the one key of a bracket access spelled as a literal or
+ * proved by a literal-typed binding (`const key = "a"`). A key of several
+ * literals folds to nothing — deleting it would need per-key dispatch, so
+ * the record branch refuses and names the keys. Consistent with keyed
+ * record reads/writes (literalFieldKeys), the key expression is not
+ * evaluated: only a literal or an identifier folds, and an identifier
+ * read is pure. */
+function constantDeleteKey(lowerer, target) {
+    if (ts.isPropertyAccessExpression(target))
+        return target.name.text;
+    if (!ts.isElementAccessExpression(target))
+        return null;
+    const keyNode = target.argumentExpression;
+    if (ts.isStringLiteralLike(keyNode))
+        return keyNode.text;
+    if (!ts.isIdentifier(keyNode))
+        return null;
+    const keys = literalFieldKeys(lowerer, keyNode);
+    return keys?.length === 1 ? keys[0] : null;
+}
 /** Statement-position `delete`: process.env keys → process.envUnset
  * (unsetenv), pure `Record<string, T>` keys → recordKeyDelete (the
  * overflow Map delete), declared OPTIONAL fields → the field's ABSENT
  * state (the slot reads undefined and no longer counts as an own
  * property). Everything else
- * fences with the honest reason — a required field is a struct slot no
- * runtime can remove, and an optional `unknown`/`any` field maps to the
+ * fences with the honest reason — a required record field is a struct slot
+ * with no ABSENT state, a class field is part of the instance's fixed
+ * layout, and an optional `unknown`/`any` field maps to the
  * checked-dynamic slot, which has no ABSENT state yet. */
 function lowerDeleteStatement(lowerer, expr) {
     const loc = locOf(expr);
@@ -6879,6 +7014,18 @@ function lowerDeleteStatement(lowerer, expr) {
             return unionDelete;
     }
     let obj = lowerer.lowerExpr(target.expression);
+    // A PRIMITIVE receiver: `delete` runs ToObject on the base AFTER the key,
+    // and the base's type decides the answer — null and undefined throw
+    // Node's TypeError, `?.` on a nullish base short-circuits to `true`
+    // without evaluating the key, and every other primitive deletes from its
+    // ToObject wrapper (a String's indexes and `length` refuse the delete).
+    if (isPrimitiveValueType(obj.type) && !isBuiltinIdentityToken(lowerer, target.expression, obj)) {
+        return {
+            kind: "exprStmt",
+            expr: lowerPrimitiveBaseDelete(lowerer, expr, target, obj, VOID),
+            loc,
+        };
+    }
     // `delete this.stack` in an Error subclass that declares a `stack`
     // accessor (quickjs-wasi's JSException): V8 gives each error an own
     // `stack` that shadows the accessor, and the delete removes it so reads
@@ -6954,13 +7101,12 @@ function lowerDeleteStatement(lowerer, expr) {
             loc,
         };
     }
-    // The constant property key of the target (dot access or a literal
-    // bracket), when there is one.
-    const constantKey = ts.isPropertyAccessExpression(target)
-        ? target.name.text
-        : ts.isStringLiteral(target.argumentExpression)
-            ? target.argumentExpression.text
-            : null;
+    // The constant property key of the target: dot access, a literal
+    // bracket, or an element access whose key is a literal-typed binding
+    // (`const key = "a"; delete r[key]`) — the same stance a keyed record
+    // read/write takes (literalFieldKeys): identifier evaluation is pure, so
+    // skipping it matches JavaScript.
+    const constantKey = constantDeleteKey(lowerer, target);
     // An OPTIONAL `unknown`/`any` field rides the checked-dynamic slot,
     // which has no ABSENT state yet (an omitted such field already reads as
     // present), so it cannot delete. Name that reason instead of calling
@@ -7002,12 +7148,29 @@ function lowerDeleteStatement(lowerer, expr) {
         if (optionalCheckedDynDelete) {
             lowerer.unsupported("SC1090", expr, OPTIONAL_CHECKED_DYN_DELETE);
         }
-        lowerer.unsupported("SC1090", expr, "'delete' of required record fields (a monomorphic shape cannot remove its slot — only optional fields delete, becoming the undefined arm)");
+        // A key of SEVERAL literals names no single slot: say that instead of
+        // blaming a field the caller never named.
+        const keyNames = constantKey === null && ts.isElementAccessExpression(target)
+            ? literalFieldKeys(lowerer, target.argumentExpression)
+            : null;
+        if (keyNames !== null && keyNames.length > 1) {
+            lowerer.unsupported("SC1090", expr, `'delete' through keys of ${keyNames.length} literals (${keyNames.map((k) => `'${k}'`).join(", ")}; delete one constant key at a time, or switch over the key)`);
+        }
+        lowerer.unsupported("SC1090", expr, "'delete' of required record fields (the shape's slot cannot be removed — only an optional field (`f?: T`) has an absent state, which Object.keys, 'in', and JSON.stringify follow; make the field optional if the program must remove it)");
     }
     if (optionalCheckedDynDelete) {
         lowerer.unsupported("SC1090", expr, OPTIONAL_CHECKED_DYN_DELETE);
     }
-    lowerer.unsupported("SC1090", expr, `'delete' on '${lowerer.fmt(obj.type)}' receivers (process.env keys and pure Record<string, T> keys delete)`);
+    // A class field lives in the instance's fixed layout: there is no
+    // per-field presence state for a delete to write, so Object.keys,
+    // `in`, and JSON.stringify would keep reporting the field where Node
+    // drops it. Name that reason instead of the generic receiver fence.
+    if (obj.type.kind === "object" &&
+        constantKey !== null &&
+        lowerer.classes.get(obj.type.className)?.fields.has(constantKey)) {
+        lowerer.unsupported("SC1090", expr, "'delete' of class fields (an instance's fields are its fixed layout — there is no per-field presence state, so Object.keys, 'in', and JSON.stringify would still report a deleted field; only optional record fields (`f?: T`) and Record<string, T> keys delete)");
+    }
+    lowerer.unsupported("SC1090", expr, `'delete' on '${lowerer.fmt(obj.type)}' receivers (process.env keys, pure Record<string, T> keys, and optional record fields delete)`);
 }
 /** True when the `var`/`let` binding `nameNode` names cannot change after
  * the top-level CommonJS export statement `exportNode` that exports it by
@@ -9667,7 +9830,12 @@ export function lowerForOf(lowerer, stmt) {
     }
     const awaitArray = !!stmt.awaitModifier && lowerer.mapTypeOf(lowerer.typeOf(stmt.expression))?.kind === "array";
     if (stmt.awaitModifier && !awaitArray) {
-        {
+        // A web ReadableStream's and a Node readable's iterator views both type
+        // as AsyncIterableIterator, which lowers like the async protocols — but
+        // the loop consumes each view through its own lowering
+        // (lowerForAwaitBuiltin below).
+        if (!isWebReadableIteratorSource(lowerer, stmt.expression) &&
+            !isNodeReadableIteratorSource(lowerer, stmt.expression)) {
             const genT = lowerer.stageSourceType(stmt.expression) ??
                 lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
             if (genT?.kind === "generator" && genT.async) {
@@ -12322,4 +12490,54 @@ function isAssertionInitializer(node) {
         e = e.expression;
     return ts.isAsExpression(e) || ts.isTypeAssertion(e);
 }
+/** `const view = route as Route & { order: number }`: the asserted type
+ * refines the record arms the value is stored in (hosted-narrowing.ts), and
+ * a projection (`{ text: string }` over `TextBlock`) only names members the
+ * stored record already holds. Either way Node erases the assertion and
+ * keeps the object, so the binding keeps the value's layout and its writes
+ * reach that object instead of a copy. */
+function assertionKeepsStorageLayout(lowerer, decl, init, settled) {
+    if (decl.initializer === undefined || !isAssertionInitializer(decl.initializer))
+        return false;
+    if (settled.kind !== "union" && settled.kind !== "record")
+        return false;
+    if (init.kind !== "union" && init.kind !== "record")
+        return false;
+    if (hostsAll(lowerer, init, settled))
+        return true;
+    // A projection (`{ text: string }` over `TextBlock`) keeps the stored
+    // record only when the binding's identity is observable through it
+    // (a write, an identity comparison). A read-only view is equal either
+    // way, keeps the copy narrowing.ts made, and stays reported.
+    if (!bindingIdentityUse(decl, lowerer.checker))
+        return false;
+    return (init.kind === "record" &&
+        settled.kind === "record" &&
+        recordViewHosted(lowerer, init.shapeId, settled.shapeId));
+}
+/** `const v = x as { a: number; extra?: string }; v.extra = "x"`: the
+ * assertion's view names a member the value's own layout does not, so the
+ * binding receives a COPY of `x` and the write lands on that copy — Node
+ * erases the assertion and adds the property to `x` itself, so the write
+ * must reach a caller-visible object. Reads of a copy are equal either
+ * way, and so is a nested write through a member the copy shares (the same
+ * child object in both), so only a write to the copy's own field is
+ * refused, by name. Where the layouts agree the binding keeps the value's
+ * storage instead (assertionKeepsStorageLayout), narrowing.ts and
+ * lowerVarDecl record that in layoutKeptNodes, and nothing here fires.
+ * Runs for file-scope and local bindings alike, after the declaration has
+ * been lowered (so the keep is known). */
+function refuseAssertionViewWrite(lowerer, decl) {
+    if (decl.initializer === undefined || !isAssertionInitializer(decl.initializer))
+        return;
+    if (lowerer.layoutKeptNodes.has(decl.initializer))
+        return;
+    const copy = assertionViewCopy(lowerer, decl.initializer);
+    if (copy === null)
+        return;
+    const write = bindingWrite(lowerer, decl);
+    if (write === null)
+        return;
+    lowerer.unsupported("SC1090", decl, `writing '${write.text}' through '${decl.name.getText()}', a copy of the '${copy.source}' value the assertion views as '${copy.target}' (the write would land on the copy; write through the original binding, or declare the member on the value's type)`);
+}
 //# sourceMappingURL=lower-stmts.js.map