@scriptc/compiler 0.4.5 → 0.4.6

package/dist/frontend/lowering/expressions/property-access.js

@@ -1,21 +1,28 @@
+import { widensReducedRecords } from "../function-returns.js";
+import { widthNarrowHelper } from "../coercions/unions.js";
 /* Property reads (`a.b`): lowerExprInner's property-access branch, intrinsic and union properties, field reads and targets, and match-group reads. */
+import { jsSpecialGlobalValue } from "../global-values.js";
+import { arrayClassMemberOwner, arrayClassReceiver, lowerArrayClassConstructorRead, } from "../builtins/array-classes.js";
 import { indexedUnionArms, lowerIndexedUnionMember } from "../indexed-unions.js";
 import { keyedHelperName } from "../stable-names.js";
 import { builtinNamespaceValue } from "../builtin-namespaces.js";
 import { staticallySelected } from "../static-typeof.js";
+import { lowerWebStreamClassRead } from "../builtins/web-streams-dyn.js";
 import * as ts from "../../ts7/adapter.js";
 import { lowerHistogramProperty } from "../builtins/performance.js";
 import { staticFunctionNameRead } from "../static-function-names.js";
 import { typedArgumentsArity } from "../typed-arguments.js";
+import { INSPECT_CUSTOM_DESCRIPTION, isInspectCustomAccess } from "../symbol-fields.js";
 import { isThisParameter } from "../call-signatures.js";
 import { argumentCountSlot, contextualCallCount, usedAsValue } from "../argument-counts.js";
 import { checkedPrivateValue, localPrivateBrandClass, privateNameClass, } from "../private-brands.js";
-import { PoisonError, jsFuncNameOf, neverTaintedJsType, own } from "../lowerer.js";
+import { PoisonError, builtinValueNameOf, jsFuncNameOf, neverTaintedJsType, own, } from "../lowerer.js";
 import { ARRAY_METHODS, MAP_METHODS, NARROW_FIRST, OBJECT_CALLABLE_VALUES, SET_METHODS, STDLIB_SURFACE, STRING_INDEX_METHODS, STR_METHODS, isChildSurfaceMember, stdlibGlobalNameOf, } from "../surfaces.js";
 import { isGenericCallableMemberType, isLegacyUrlSymbol, isOsConstantsType, isParseArgsDynTypeName, } from "../../type-mapper.js";
-import { BOOL, BYTES_ELEMENT_NAME, BYTES_U8, DYN, F64, NULL_T, SEARCH_PARAMS_T, STRING, SYMBOL_T, UNDEFINED_T, arrayOf, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isUnitType, typeEquals, typeKey, unionContainerArmsOk, BYTES_ELEMENT_SIZE, } from "../../../ir/ir.js";
-import { lowerNavigatorMember } from "../builtins/navigator.js";
+import { BIGINT_T, BOOL, BYTES_U8, DYN, F64, NULL_T, SEARCH_PARAMS_T, STRING, SYMBOL_T, UNDEFINED_T, arrayOf, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isUnitType, typeEquals, typeKey, unionContainerArmsOk, BYTES_ELEMENT_SIZE, } from "../../../ir/ir.js";
+import { lowerNavigatorMember, navigatorValue } from "../builtins/navigator.js";
 import { lowerX509PublicKey } from "../builtins/x509.js";
+import { fenceMimeStaticRead } from "../builtins/mime.js";
 import { NODE_COMPAT_VERSION } from "../builtins/process.js";
 import { inlineNamespaceRequireOf, lowerWithInlineRequireInit, wholeExportValue, } from "../cjs-inline-require.js";
 import { cjsAccessorCall, constInitializerOf, exactUnionWidening, hasClassPayload, lowerExpr, matchAllCallbackRegexOf, matchAllRegexOf, namedCaptureGroupsOfPattern, primitiveCtorClosure, recordKeyResultOk, representedClassFieldTarget, staticRegexPatternOf, } from "../lower-exprs.js";
@@ -35,6 +42,8 @@ import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../.
 import { typedArrayLacksMember } from "../builtins/typed-array-members.js";
 import { TEMPORAL_GLOBAL } from "../../builtin-modules.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
+import { applyDeferredAssertion, assertedReceiverNode, deferredMemberReadTarget, deferredProbeReadAccess, } from "./asserted-receiver.js";
+import { lowerRecordInheritedMember } from "../record-inherited.js";
 import { DATE_METHOD_HINT } from "../builtins/dates.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf, } from "../../program.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, contextualUndefReadType, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "../lower-namespaces.js";
@@ -53,7 +62,7 @@ import { blockedBindingUseDiag } from "../../../diagnostics/diagnostic.js";
 import { npmStaticPackageOfPath } from "../../npm-static.js";
 import { importMetaField, isImportMeta } from "../import-meta.js";
 import { createRequireCalleeFileOf } from "../builtins/module-bindings.js";
-import { createRequireResolveFenceValue } from "../builtins/module-resolution.js";
+import { createRequireResolveFenceValue, createRequireResolveValue, } from "../builtins/module-resolution.js";
 import { builtinPrototypeMethod, lowerArrayIsArrayValue, lowerCheckedPredicateValue, lowerNumberParserValue, lowerObjectAssignValue, lowerStringCodesValue, } from "../lower-builtin-values.js";
 import { lowerArrayFromValue } from "../containers/array-construction.js";
 import { lowerBufferPrototypeMember } from "../containers/bytes.js";
@@ -171,11 +180,15 @@ function isCreateRequireResolveValue(lowerer, expr) {
         ts.isPropertyAccessExpression(expr.expression) &&
         !expr.expression.questionDotToken)
         resolve = expr.expression;
-    return (ts.isPropertyAccessExpression(resolve) &&
+    return (!expr.questionDotToken &&
+        ts.isPropertyAccessExpression(resolve) &&
         resolve.name.text === "resolve" &&
         createRequireCalleeFileOf(lowerer, resolve.expression) !== null);
 }
 export function lowerPropertyAccessExpr(lowerer, expr, loc) {
+    const arrayClassConstructor = lowerArrayClassConstructorRead(lowerer, expr, loc);
+    if (arrayClassConstructor !== null)
+        return arrayClassConstructor;
     // `value.#x` on a checked-dynamic value, or on a checked extraction of
     // one: the field of the brand-checked receiver (checkedPrivateValue).
     if (ts.isPrivateIdentifier(expr.name)) {
@@ -199,6 +212,16 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
     const navigator = lowerNavigatorMember(lowerer, expr, NODE_COMPAT_VERSION);
     if (navigator)
         return navigator;
+    // util.inspect.custom: Symbol.for('nodejs.util.inspect.custom').
+    if (isInspectCustomAccess(lowerer, expr)) {
+        return {
+            kind: "libCall",
+            fn: "sym.for",
+            args: [{ kind: "strLit", value: INSPECT_CUSTOM_DESCRIPTION, type: STRING, loc }],
+            type: SYMBOL_T,
+            loc,
+        };
+    }
     {
         const member = lowerBufferPrototypeMember(lowerer, expr);
         if (member)
@@ -439,6 +462,12 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
     if (lowerer.stdlibGlobalMember(expr, "globalThis") === "console") {
         return { kind: "libCall", fn: "console.native", args: [], type: DYN, loc };
     }
+    {
+        // `globalThis.ReadableStream` in JavaScript: the class value.
+        const webStream = lowerWebStreamClassRead(lowerer, expr);
+        if (webStream)
+            return webStream;
+    }
     if (lowerer.stdlibGlobalMember(expr, "console") !== null) {
         return {
             kind: "dynKeyGet",
@@ -458,7 +487,8 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         // (`(_a = globalThis).__config ?? (_a.__config = {})`) reads back from
         // the global object's own properties.
         const globalType = lowerer.typeOf(staticallySelected(lowerer, expr.expression));
-        if (globalThisWrittenNames(lowerer, globalType).has(expr.name.text)) {
+        if (globalThisWrittenNames(lowerer, globalType).has(expr.name.text) ||
+            lowerer.globalThisComputedWrite) {
             return {
                 kind: "dynKeyGet",
                 value: lowerer.coerceToExpected(lowerer.lowerExpr(expr.expression), DYN),
@@ -467,6 +497,10 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
                 loc,
             };
         }
+        // Node's navigator, which JavaScript reads as a free name when no
+        // declaration types it (isNavigatorGlobal).
+        if (expr.name.text === "navigator" && isJsSourceFile(ts.getSourceFileOfNode(expr)))
+            return navigatorValue(loc);
         return dynUndefinedExpr(loc);
     }
     // `Uint8Array.prototype.toBase64` and its siblings, the base64/hex
@@ -769,6 +803,7 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         // prototype that no lowering above claimed keeps the SC2020 fence
         // rather than reading undefined through the field and dynamic reads.
         fenceBuiltinConstructorStaticRead(lowerer, expr) ??
+        fenceMimeStaticRead(lowerer, expr) ??
         lowerer.lowerFieldRead(expr);
     // A union-typed field read narrows like an identifier when the
     // checker has narrowed this use to one arm.
@@ -810,18 +845,9 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
             // Typed for the programs that name it, absent in Node 24.
             if (canonical === TEMPORAL_GLOBAL)
                 return dynUndefinedExpr(loc);
-            if (canonical === "ArrayBuffer")
-                return { kind: "libCall", fn: "arrayBuffer.constructor", args: [], type: DYN, loc };
-            if (canonical === "fetch")
-                return { kind: "libCall", fn: "fetch.function", args: [], type: DYN, loc };
-            if (Object.values(BYTES_ELEMENT_NAME).includes(canonical))
-                return {
-                    kind: "libCall",
-                    fn: "bytes.constructor",
-                    args: [{ kind: "strLit", value: canonical, type: STRING, loc }],
-                    type: DYN,
-                    loc,
-                };
+            const value = jsSpecialGlobalValue(lowerer, canonical, loc);
+            if (value)
+                return value;
             return (builtinGlobalValueAt(lowerer, expr, canonical, loc, true) ?? {
                 kind: "strLit",
                 value: `[builtin ${canonical}]`,
@@ -973,12 +999,14 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         if ((isJsSourceFile(ts.getSourceFileOfNode(expr)) || expr.name.text === "constructor") &&
             probed?.type.kind === "func" &&
             canBoxFuncIntoDyn(probed.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-            const fnName = jsFuncNameOf(expr.expression);
-            // A builtin function value whose length is not its adapter's
-            // parameter count (`Math.max.length` is 2).
-            const fnLength = probed.kind === "closure"
-                ? lowerer.builtinCallableValueLengths.get(probed.fnName)
-                : undefined;
+            // A function is named by its definition, through const aliases: a
+            // builtin module member whose Node name differs from the member
+            // (`process.cwd` is `wrappedCwd`) by the module table, anything else
+            // by the property or function it reads. A builtin function value
+            // keeps its length when that is not its adapter's parameter count
+            // (`Math.max.length` is 2).
+            const fnName = builtinValueNameOf(expr.expression, lowerer) ?? jsFuncNameOf(expr.expression, lowerer);
+            const fnLength = lowerer.builtinFunctionIdentity(probed).fnLength;
             const boxed = {
                 kind: "dynFrom",
                 value: probed,
@@ -1124,10 +1152,13 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         }
     }
     // A createRequire loader's resolve read as a value (passed on, or
-    // picked by `??`): resolution happens at build time, so only calls
-    // with a literal specifier lower.
+    // picked by `??`): a function that resolves its request at run time.
+    // resolve.paths read as a value has no run-time lowering: a function
+    // that throws the fence when called.
     if (isCreateRequireResolveValue(lowerer, expr))
-        return createRequireResolveFenceValue(lowerer, expr, loc);
+        return expr.name.text === "paths"
+            ? createRequireResolveFenceValue(lowerer, expr, loc)
+            : createRequireResolveValue(lowerer, expr, loc);
     // The lib fence's PROPERTY chokepoint: a stdlib-declared member that
     // no lowering above claimed ([1,2].entries, Math.SQRT2, Promise.all,
     // re.exec as a value, ...) reports SC2020 here.
@@ -1153,7 +1184,41 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
     // honest one, not a generic recitation about the outer dot. A
     // receiver that lowers cleanly means the MEMBER is the gap — name
     // the property and the receiver's type instead of "property access".
-    const recvLowered = lowerer.lowerExpr(expr.expression);
+    let recvLowered = lowerer.lowerExpr(expr.expression);
+    // A PRESENCE PROBE of a member read through an erased assertion
+    // (`typeof (u as R).member`, `(u as R).member !== undefined`): Node
+    // reads the property off the value actually stored, so an arm that does
+    // not declare it answers undefined. lowerAsExpression deferred the
+    // assertion's checked extraction for this read; answer it per arm
+    // (assertedMemberRead), and only a member with no per-arm answer applies
+    // the extraction the assertion would otherwise have taken (a lying
+    // assertion still throws on a real use, never on the probe).
+    {
+        const assertion = assertedReceiverNode(expr.expression);
+        const target = assertion
+            ? deferredMemberReadTarget(lowerer, assertion, expr, recvLowered)
+            : null;
+        if (target !== null) {
+            const read = assertedMemberRead(lowerer, expr.expression, expr.name.text, recvLowered, loc);
+            if (read)
+                return read;
+            recvLowered = applyDeferredAssertion(lowerer, recvLowered, target, loc);
+        }
+    }
+    // A receiver whose value union holds record types the checker's subtype
+    // reduction folded into its type (`{ status } | { status, value }` typed
+    // `{ status }`, a call of a function with an inferred return type): read
+    // through the checker's type, converting the wider arms.
+    if (recvLowered.type.kind === "union") {
+        const declared = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
+        if (declared !== null &&
+            declared.kind === "record" &&
+            widensReducedRecords(lowerer, declared, recvLowered.type)) {
+            const helper = widthNarrowHelper(lowerer, recvLowered.type.unionId, declared, loc);
+            if (helper !== null)
+                recvLowered = lowerer.checkedNarrowCall(helper, recvLowered, declared, loc);
+        }
+    }
     // A dyn receiver — JSON.parse's `any`, or `unknown` the checker
     // narrowed to `object` — reads through the dyn keyed read: member
     // or undefined (JS's own-property answer), throwing JS's TypeError
@@ -1295,7 +1360,7 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         const mapped = lowerer.mapTypeOf(lowerer.typeOf(expr));
         return mapped && mapped.kind !== "void" ? lowerer.coerceInto(expr, read, mapped) : read;
     }
-    const asserted = assertedMemberRead(lowerer, expr, recvLowered, loc);
+    const asserted = assertedMemberRead(lowerer, expr.expression, expr.name.text, recvLowered, loc);
     if (asserted)
         return asserted;
     // A checker-`any` receiver whose value is a FRESH typed result of an
@@ -1371,14 +1436,17 @@ function isFreshCallResult(node) {
 /** `(source as { repoName: string }).repoName` where the assertion names a
  * member some arms of the stored union of records do not declare: Node
  * reads the property off whichever object it is, so arms that declare it
- * answer their slot, and the others answer undefined (native records are
- * closed, so they cannot hold it). The result keeps that undefined arm
- * whatever the assertion claims; a consumer that needs the asserted type
- * checks it like any other narrowing. The arms that declare the member
- * must agree on its type. Null when the receiver is not such an
- * assertion over records, or no arm declares the member. */
-function assertedMemberRead(lowerer, expr, recv, loc) {
-    let receiverNode = expr.expression;
+ * answer their slot (a getter arm calls its getter), an index-signature arm
+ * answers its own key (a declared miss reads undefined), an arm with only a
+ * setter of that name reads undefined, and the rest answer undefined
+ * (native records are closed, so they cannot hold it). The result keeps
+ * that undefined arm whatever the assertion claims; a consumer that needs
+ * the asserted type checks it like any other narrowing. The arms that
+ * declare the member must agree on its type. `receiverNode` is the asserted
+ * expression and `name` the member read (the dot and bracket spellings
+ * share this answer). Null when the receiver is not such an assertion over
+ * records, or no arm answers the member. */
+export function assertedMemberRead(lowerer, receiverNode, name, recv, loc) {
     while (ts.isParenthesizedExpression(receiverNode))
         receiverNode = receiverNode.expression;
     if (!ts.isAsExpression(receiverNode) && !ts.isTypeAssertion(receiverNode))
@@ -1387,10 +1455,14 @@ function assertedMemberRead(lowerer, expr, recv, loc) {
         return null;
     const unionId = recv.type.unionId;
     const arms = lowerer.unions.get(unionId)?.arms ?? [];
-    const name = expr.name.text;
     let resultType = null;
     let records = 0;
+    // A getter arm answers by calling its getter, once per read, as Node's
+    // read does; a data arm reads its slot.
     const declaring = [];
+    // An index-signature arm may hold the key in its overflow map: the read
+    // probes it per value (the stored value, or undefined).
+    const keyed = [];
     const units = [];
     for (let tag = 0; tag < arms.length; tag++) {
         const arm = arms[tag];
@@ -1402,20 +1474,44 @@ function assertedMemberRead(lowerer, expr, recv, loc) {
             return null;
         records++;
         const shape = lowerer.shapes.get(arm.shapeId);
-        if (!shape || shape.tuple || shape.indexValue)
+        if (!shape || shape.tuple)
             return null;
-        const field = shape.fields.find((f) => f.name === name);
-        if (!field)
+        const getter = shape.fields.find((f) => f.name === `%get:${name}`);
+        if (getter && getter.type.kind !== "func")
+            return null;
+        const field = getter ?? shape.fields.find((f) => f.name === name);
+        if (!field) {
+            // A setter-only arm reads undefined (Node never invokes a setter on
+            // a read); an index-signature arm answers its own key.
+            if (shape.indexValue)
+                keyed.push({ tag, shapeId: arm.shapeId, type: shape.indexValue });
             continue;
+        }
+        const fieldType = field.type.kind === "func" && getter ? field.type.ret : field.type;
         // The declaring arms agree up to an undefined arm (`string` beside
         // `string | undefined`).
-        const armResult = lowerer.withUndefinedArmOf(field.type);
+        const armResult = lowerer.withUndefinedArmOf(fieldType);
         if (!armResult || (resultType && !typeEquals(resultType, armResult)))
             return null;
         resultType = armResult;
-        declaring.push({ tag, shapeId: arm.shapeId, type: field.type });
+        declaring.push({ tag, shapeId: arm.shapeId, type: field.type, getter: getter !== undefined });
+    }
+    // The index-signature arms answer their value type armed with undefined;
+    // a union with several shapes uses the union of every arm's answer.
+    for (const k of keyed) {
+        const armResult = lowerer.withUndefinedArmOf(k.type);
+        if (!armResult)
+            return null;
+        if (resultType === null || typeEquals(resultType, armResult)) {
+            resultType = armResult;
+            continue;
+        }
+        const merged = mergeReadTypes(lowerer, [resultType, armResult]);
+        if (!merged)
+            return null;
+        resultType = merged;
     }
-    if (!resultType || declaring.length === records)
+    if (!resultType || (declaring.length === records && declaring.every((d) => !d.getter)))
         return null;
     const stable = lowerer.declareHiddenLocal("%assertedRecv", recv.type);
     const ref = () => ({ kind: "varRef", localId: stable.id, type: recv.type, loc });
@@ -1434,15 +1530,41 @@ function assertedMemberRead(lowerer, expr, recv, loc) {
             loc,
         };
     }
-    for (const { tag, shapeId, type: fieldType } of declaring) {
-        const read = {
+    for (const { tag, shapeId, type: fieldType, getter } of declaring) {
+        const slot = {
             kind: "recordGet",
             obj: { kind: "unionNarrow", unionId, tag, value: ref(), type: arms[tag], loc },
             shapeId,
-            field: name,
+            field: getter ? `%get:${name}` : name,
             type: fieldType,
             loc,
         };
+        const read = getter && fieldType.kind === "func"
+            ? { kind: "callValue", callee: slot, args: [], type: fieldType.ret, loc }
+            : slot;
+        result = {
+            kind: "ternary",
+            cond: { kind: "unionIsTag", unionId, tag, negated: false, value: ref(), type: BOOL, loc },
+            then: lowerer.coerceToExpected(read, resultType),
+            else_: result,
+            type: resultType,
+            loc,
+        };
+    }
+    for (const { tag, shapeId, type: valueType } of keyed) {
+        const axis = { kind: "unionNarrow", unionId, tag, value: ref(), type: arms[tag], loc };
+        const answer = lowerer.withUndefinedArmOf(valueType);
+        if (!answer)
+            return null;
+        const read = {
+            kind: "recordKeyGet",
+            obj: axis,
+            shapeId,
+            key: { kind: "strLit", value: name, type: STRING, loc },
+            overflowOnly: true,
+            type: answer,
+            loc,
+        };
         result = {
             kind: "ternary",
             cond: { kind: "unionIsTag", unionId, tag, negated: false, value: ref(), type: BOOL, loc },
@@ -1460,6 +1582,23 @@ function assertedMemberRead(lowerer, expr, recv, loc) {
         loc,
     };
 }
+/** The union of two per-arm read answers (each already carries its
+ * undefined arm), or null when the shapes cannot intern as one union. */
+function mergeReadTypes(lowerer, types) {
+    const arms = [];
+    for (const t of types) {
+        const list = t.kind === "union" ? (lowerer.unions.get(t.unionId)?.arms ?? []) : [t];
+        for (const arm of list)
+            if (!arms.some((a) => typeEquals(a, arm)))
+                arms.push(arm);
+    }
+    if (arms.length === 0)
+        return null;
+    if (arms.length === 1)
+        return arms[0];
+    const canonical = arms.sort((a, b) => typeKey(a) < typeKey(b) ? -1 : typeKey(a) > typeKey(b) ? 1 : 0);
+    return { kind: "union", unionId: lowerer.unions.intern(canonical) };
+}
 function importMetaProperty(lowerer, expr) {
     return isImportMeta(expr.expression) ? importMetaField(lowerer, expr, expr.name.text) : null;
 }
@@ -1666,6 +1805,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         kind !== "url" &&
         kind !== "searchParams" &&
         kind !== "stats" &&
+        kind !== "bigintStats" &&
         kind !== "spawnRes" &&
         kind !== "child" &&
         kind !== "bytes" &&
@@ -1745,6 +1885,19 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             const receiver = lowerer.lowerExpr(expr.expression);
             return { kind: "libCall", fn: "child.killed", args: [receiver], type: BOOL, loc };
         }
+        // signalCode: `NodeJS.Signals | null`, the signal that terminated the
+        // child (null while running, after a normal exit, and after a spawn
+        // failure) — the exit listener's second parameter, read as a property.
+        // The `string | null` union builds type-directedly over a has/get
+        // runtime pair (the spawnRes.signal pattern).
+        if (name === "signalCode") {
+            const receiver = lowerer.lowerExpr(expr.expression);
+            const type = {
+                kind: "union",
+                unionId: lowerer.unions.intern([STRING, NULL_T]),
+            };
+            return { kind: "libCall", fn: "child.signalCode", args: [receiver], type, loc };
+        }
         if (name === "on" || name === "once" || name === "kill" || name === "unref") {
             lowerer.unsupported("SC1090", expr, `child methods as values (call '${name}' directly)`);
         }
@@ -1790,15 +1943,24 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         }
         lowerer.noLowering(`SpawnSyncReturns.${name}`, expr, "status, stdout, stderr, and error are the supported spawnSync-result members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
-    if (kind === "stats") {
+    if (kind === "stats" || kind === "bigintStats") {
+        const bigintStats = kind === "bigintStats";
         if (name === "size") {
             const receiver = lowerer.lowerExpr(expr.expression);
-            return { kind: "libCall", fn: "stats.size", args: [receiver], type: F64, loc: locOf(expr) };
+            return {
+                kind: "libCall",
+                fn: bigintStats ? "bigstats.size" : "stats.size",
+                args: [receiver],
+                type: bigintStats ? BIGINT_T : F64,
+                loc: locOf(expr),
+            };
         }
         if (Object.hasOwn(STATS_TYPE_TESTS, name)) {
-            lowerer.unsupported("SC1090", expr, `Stats methods as values (call '${name}' directly)`);
+            lowerer.unsupported("SC1090", expr, `${bigintStats ? "BigIntStats" : "Stats"} methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), isBlockDevice(), isCharacterDevice(), isFIFO(), isSocket(), dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs, atime, mtime, ctime, and birthtime are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`${bigintStats ? "BigIntStats" : "Stats"}.${name}`, expr, bigintStats
+            ? "BigIntStats' isFile(), isDirectory(), isSymbolicLink(), isBlockDevice(), isCharacterDevice(), isFIFO(), isSocket(), dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeNs, mtimeNs, ctimeNs, birthtimeNs, atimeMs, mtimeMs, ctimeMs, birthtimeMs, atime, mtime, ctime, and birthtime are the supported members"
+            : "isFile(), isDirectory(), isSymbolicLink(), isBlockDevice(), isCharacterDevice(), isFIFO(), isSocket(), dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs, atime, mtime, ctime, and birthtime are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "date") {
         // A Date held as a checked-dynamic value (a Date a JavaScript file
@@ -2696,6 +2858,23 @@ export function lowerGroupsProjection(lowerer, recv, groups, loc) {
 }
 /** Field reads use the shared FieldTarget union. Native method reads select
  * an interned unbound callable; invocation supplies its receiver separately. */
+/** Whether a receiver is a binding or `this`, or a chain of property reads
+ * from one whose every member is a plain property (no accessor), so that
+ * reading it has no effect. */
+function plainReadChain(lowerer, node) {
+    let current = node;
+    while (ts.isPropertyAccessExpression(current)) {
+        if (current.questionDotToken)
+            return false;
+        const member = lowerer.checker.getSymbolAtLocation(current.name);
+        if (member === undefined || (member.flags & ts.SymbolFlags.Property) === 0)
+            return false;
+        if ((member.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) !== 0)
+            return false;
+        current = current.expression;
+    }
+    return ts.isIdentifier(current) || current.kind === ts.SyntaxKind.ThisKeyword;
+}
 export function lowerFieldRead(lowerer, expr) {
     // A checked receiver already owns its property table. An ambient
     // generic method signature must not divert its value into native
@@ -2717,6 +2896,13 @@ export function lowerFieldRead(lowerer, expr) {
                 };
         }
     }
+    // A presence probe of a member read through a record assertion
+    // (`typeof (u as R).member`): the field target comes from the ASSERTED
+    // checker type and would apply the checked extraction, trapping on the
+    // very arm the probe exists to detect. Leave the read to the per-arm
+    // answer in lowerPropertyAccessExpr (asserted-receiver.ts).
+    if (deferredProbeReadAccess(lowerer, expr))
+        return null;
     const target = lowerer.fieldTarget(expr);
     if (target)
         return lowerer.fieldGetExpr(target, locOf(expr), expr);
@@ -2792,6 +2978,13 @@ export function lowerFieldRead(lowerer, expr) {
                         loc: locOf(expr),
                     };
             }
+            // Object.prototype's methods read as values: an own entry of the
+            // member's function type, else the built-in.
+            if (actual?.type.kind === "record") {
+                const inherited = lowerRecordInheritedMember(lowerer, actual, expr);
+                if (inherited)
+                    return inherited;
+            }
             // A member the checker declares on the receiver, stored in a pure
             // index-signature record (an object literal that spread one, see
             // dictSpreadLiteralShape): the key is always present, so the keyed
@@ -2812,23 +3005,89 @@ export function lowerFieldRead(lowerer, expr) {
         }
     }
     // `t.length` on a tuple: the arity CONSTANT (tuples are fixed-shape —
-    // the checker types it as the literal arity too). Folding discards the
-    // receiver's evaluation, so only side-effect-free receivers fold;
-    // anything else (a call result) binds to a const first.
+    // the checker types it as the literal arity too). A binding or `this`,
+    // or a chain of plain property reads from one, folds; any other receiver
+    // (a call result, a ternary, an assertion, a chain through an accessor)
+    // is evaluated first, for its side effects and exceptions, and its value
+    // discarded.
     if (receiverIr?.kind === "record" && expr.name.text === "length") {
         const shape = lowerer.shapes.get(receiverIr.shapeId);
         if (shape?.tuple) {
-            let root = expr.expression;
-            while (ts.isPropertyAccessExpression(root))
-                root = root.expression;
-            if (!ts.isIdentifier(root) && root.kind !== ts.SyntaxKind.ThisKeyword) {
-                lowerer.unsupported("SC1090", expr, "'.length' of a computed tuple expression (the arity is a constant — bind the tuple to a const first)");
+            const arity = {
+                kind: "numLit",
+                value: shape.fields.length,
+                type: F64,
+                loc: locOf(expr),
+            };
+            if (plainReadChain(lowerer, expr.expression))
+                return arity;
+            const receiver = checkerArray ?? lowerer.lowerExpr(expr.expression);
+            const loc = locOf(expr);
+            // An unchecked element read (`rows[i].length` with `rows: T[]`) answers
+            // the element's optional value: a missing element is undefined, and
+            // reading `length` from it throws Node's TypeError.
+            if (receiver.type.kind === "union") {
+                const unionId = receiver.type.unionId;
+                const held = lowerer.declareHiddenLocal("%tupleLengthReceiver", receiver.type);
+                let result = arity;
+                for (const unit of ["undefined", "null"]) {
+                    const tag = lowerer.armTag(unionId, unit === "undefined" ? UNDEFINED_T : NULL_T);
+                    if (tag < 0)
+                        continue;
+                    result = {
+                        kind: "ternary",
+                        cond: {
+                            kind: "unionIsTag",
+                            unionId,
+                            tag,
+                            negated: false,
+                            value: varRef(held.id, receiver.type, loc),
+                            type: BOOL,
+                            loc,
+                        },
+                        then: nodeThrowExpr(1, "", `Cannot read properties of ${unit} (reading 'length')`, F64, loc),
+                        else_: result,
+                        type: F64,
+                        loc,
+                    };
+                }
+                return {
+                    kind: "seqExpr",
+                    stmts: [{ kind: "varDecl", localId: held.id, init: receiver, loc }],
+                    result,
+                    type: F64,
+                    loc,
+                };
             }
-            return { kind: "numLit", value: shape.fields.length, type: F64, loc: locOf(expr) };
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "exprStmt", expr: receiver, loc: locOf(expr.expression) }],
+                result: arity,
+                type: F64,
+                loc,
+            };
         }
     }
     return null;
 }
+/** Whether a receiver is a value the checker ruled UNREACHABLE (`never`),
+ * directly or through the parenthesized assertion chain that escapes it
+ * (`(x as any)`, `(x as unknown)`, `x!`). The erasure is what hides the
+ * value's stored union from the checker; the value itself still holds it. */
+function unreachableReceiver(lowerer, expr) {
+    let node = expr.expression;
+    for (;;) {
+        if ((lowerer.typeOf(node).flags & ts.TypeFlags.Never) !== 0)
+            return true;
+        if (ts.isParenthesizedExpression(node) ||
+            ts.isNonNullExpression(node) ||
+            ts.isAssertionExpression(node)) {
+            node = node.expression;
+            continue;
+        }
+        return false;
+    }
+}
 /** Shared-field read `r.f` on a UNION receiver: supported exactly when
  * every arm is a record/class possessing the field with ONE shared IR
  * type — the discriminant pattern (`r.kind`, primitive) and the
@@ -2843,7 +3102,15 @@ export function lowerUnionProperty(lowerer, expr) {
         return null;
     const receiverIr = structuralReadType(lowerer, expr.expression) ??
         lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
-    if (receiverIr?.kind !== "union")
+    // The checker can rule the receiver UNREACHABLE and the assertion that
+    // escapes it (`const x: never = event; (event as any).type` — the
+    // `default:` branch of a switch that exhausts every arm) erases to
+    // checked-dynamic, hiding the union the value actually holds. Node reads
+    // the member off the object it is; the arms all declare it, so the read
+    // is the shared-field read. `never` admits no reachable call site, so no
+    // reachable program changes shape.
+    const unreachable = receiverIr?.kind !== "union" && unreachableReceiver(lowerer, expr);
+    if (receiverIr?.kind !== "union" && !unreachable)
         return null;
     // Lower the receiver first: its runtime value can still carry the full
     // binding union even when the checker has removed several variants.
@@ -2851,7 +3118,9 @@ export function lowerUnionProperty(lowerer, expr) {
     // A guard can remove several variants without selecting one record.
     // Materialize that sub-union before looking for common fields; arms
     // ruled out by the guard must not veto a field shared by the survivors.
-    if (value.type.kind === "union" && !typeEquals(value.type, receiverIr)) {
+    if (receiverIr?.kind === "union" &&
+        value.type.kind === "union" &&
+        !typeEquals(value.type, receiverIr)) {
         const helper = lowerer.narrowedRetagHelper(expr.expression, value.type.unionId, receiverIr.unionId, locOf(expr));
         if (helper)
             value = { kind: "call", callee: helper, args: [value], type: receiverIr, loc: locOf(expr) };
@@ -2908,6 +3177,18 @@ export function lowerUnionProperty(lowerer, expr) {
         if (getter)
             return lowerer.fieldGetExpr({ container: "accessor", obj: value, className, field, fieldType: getter.sig.ret }, locOf(expr), expr);
     }
+    // An array the checker sees through a union of arrays (`readdirSync`'s
+    // `string[] | Buffer[]`, whose lowering answers the string[] arm).
+    if (value.type.kind === "array" && expr.name.text === "length") {
+        return {
+            kind: "arrIntrinsic",
+            method: "length",
+            receiver: value,
+            args: [],
+            type: F64,
+            loc: locOf(expr),
+        };
+    }
     if (value.type.kind !== "union") {
         lowerer.unsupported("SC1090", expr, "shared property access without a represented union receiver");
     }
@@ -3040,7 +3321,7 @@ export function lowerUnionProperty(lowerer, expr) {
  * Array reads retain the ordinary invalid-index trap policy.
  * Returns null when any arm cannot answer — the caller owns the fence
  * message. The caller (the property/element dispatch) maybeNarrows. */
-export function lowerUnionKeyedRead(lowerer, expr, unionId, value, key, literalField) {
+export function lowerUnionKeyedRead(lowerer, expr, unionId, value, key, literalField, missingFieldAsUndefined = false) {
     const def = lowerer.unions.get(unionId);
     if (!def)
         return null;
@@ -3099,6 +3380,14 @@ export function lowerUnionKeyedRead(lowerer, expr, unionId, value, key, literalF
         if (!shape.indexValue) {
             if (literalField === null && shape.fields.length > 0)
                 continue;
+            // A record arm that does not declare the key at all answers
+            // UNDEFINED in JS. Destructuring asks for that answer (its own
+            // desugar reads a missing property as undefined, Node-exact); a
+            // dotted read keeps refusing until narrowing proves the arm.
+            if (literalField !== null && missingFieldAsUndefined) {
+                push(UNDEFINED_T);
+                continue;
+            }
             return null;
         }
         if (!pushAnswer(shape.indexValue))
@@ -3145,6 +3434,13 @@ export function lowerUnionKeyedRead(lowerer, expr, unionId, value, key, literalF
                 return null;
             continue;
         }
+        if (literalField !== null && !shape.indexValue && missingFieldAsUndefined) {
+            // The missing-field answer above must surface as the join's
+            // undefined arm (the backend's keyed-read miss path stores it).
+            if (!(type.kind === "union" && lowerer.armTag(type.unionId, UNDEFINED_T) >= 0))
+                return null;
+            continue;
+        }
         const ovfShape = literalField !== null && shape.indexValue ? { ...shape, fields: [] } : shape;
         if (!recordKeyResultOk(lowerer, ovfShape, type))
             return null;
@@ -3161,13 +3457,13 @@ export function classFieldTarget(lowerer, receiverNode, receiverType, fieldName,
         !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
-        // deferred diagnostics are what explains the miss.
+    // A receiver typed as a class whose collection deferred: the deferred
+    // diagnostics are what explains the miss (unless the flush registers
+    // the class with dynamic slots, retryDeferred).
+    const info = lowerer.classes.get(receiverType.className) ??
         lowerer.flushDeferredClass(receiverType.className);
+    if (!info)
         return null;
-    }
     const fieldType = info.fields.get(fieldName);
     const lowerObjectReceiver = () => {
         let obj = represented;
@@ -3305,6 +3601,19 @@ export function fieldTarget(lowerer, access) {
             return classFieldTarget(lowerer, access.expression, { kind: "object", className: owner.def.name }, access.name.text, receiver);
         }
     }
+    // A field declared by a class that extends Array, on an instance (whose
+    // type maps to its array): the class object's field.
+    {
+        const owner = arrayClassMemberOwner(lowerer, access);
+        const name = access.name.text;
+        if (owner !== null &&
+            (owner.fields.has(name) ||
+                lowerer.findMethodOn(owner, `get:${name}`) ||
+                lowerer.findMethodOn(owner, `set:${name}`))) {
+            const receiver = arrayClassReceiver(lowerer, owner, lowerer.lowerExpr(access.expression), access.expression);
+            return classFieldTarget(lowerer, access.expression, { kind: "object", className: owner.def.name }, access.name.text, receiver);
+        }
+    }
     const stored = ts.isIdentifier(access.expression)
         ? (lowerer.peekLocal(access.expression)?.type ?? lowerer.globalOf(access.expression)?.type)
         : undefined;
@@ -3717,9 +4026,13 @@ const GLOBAL_CONSTRUCTOR_VALUES = new Set([
 ]);
 /** The builtin global functions JavaScript sources read as interned
  * function values (the `cond ? setImmediate : process.nextTick` feature
- * probe of bcryptjs and async libraries): typeof answers "function",
- * identity holds across spellings, and calls run the timer APIs. */
+ * probe of bcryptjs and async libraries, and the known globals Node's test
+ * harness collects): typeof answers "function", identity holds across
+ * spellings, and calls run what the direct calls run. */
 const GLOBAL_FUNCTION_VALUES = new Set([
+    "atob",
+    "btoa",
+    "structuredClone",
     "setTimeout",
     "setInterval",
     "setImmediate",
@@ -4056,10 +4369,20 @@ function globalThisWrittenNames(lowerer, globalType) {
                 (node.operatorToken.kind === ts.SyntaxKind.EqualsToken ||
                     node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken ||
                     node.operatorToken.kind === ts.SyntaxKind.BarBarEqualsToken ||
-                    node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) &&
-                ts.isPropertyAccessExpression(node.left) &&
-                lowerer.typeOf(node.left.expression) === globalType)
-                names.add(node.left.name.text);
+                    node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken)) {
+                if (ts.isPropertyAccessExpression(node.left) &&
+                    lowerer.typeOf(node.left.expression) === globalType)
+                    names.add(node.left.name.text);
+                // A write by computed name may store any name: every read of a
+                // name the program does not declare consults the global object.
+                if (ts.isElementAccessExpression(node.left) &&
+                    lowerer.typeOf(node.left.expression) === globalType) {
+                    if (ts.isStringLiteralLike(node.left.argumentExpression))
+                        names.add(node.left.argumentExpression.text);
+                    else
+                        lowerer.globalThisComputedWrite = true;
+                }
+            }
             return undefined;
         });
     }