@scriptc/compiler 0.1.3 → 0.1.5

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

@@ -11,11 +11,11 @@ import { pathToFileURL } from "node:url";
 import { wasiGuestPath } from "../../wasi-paths.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isJsonSafeType, isSupportedArrayElem, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey, unionFuncSetArmsOk } from "../../ir/ir.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf } from "../program.js";
-import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModulesArrayLit, builtinModuleFnOf, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
+import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModulesArrayLit, builtinModuleFnOf, COMPOUND_ASSIGN_OPS, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
 import { blockedBindingUseDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, nodeThrowExpr, own } from "./lowerer.js";
-import { lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall } from "./lower-containers.js";
-import { arrayValueStore } from "./array-values.js";
+import { lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall, tryLowerNumericIndexRead } from "./lower-containers.js";
+import { arrayValueRead, arrayValueStore } from "./array-values.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { unsupportedModuleFeatureOf } from "../builtin-modules.js";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
@@ -23,7 +23,7 @@ import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUn
 import { expandoMemberRead, expandoWritableTarget } from "./lower-expando.js";
 import { lowerSocketInstanceOf, lowerTlsRootCertificates } from "./lower-server.js";
 import { findGenericMethodOn, lowerStaticFieldRead } from "./lower-classes.js";
-import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
+import { bindingNeverReassigned, funcTypeFromParamShapes, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
 import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion } from "../type-mapper.js";
 import { lowerYield } from "./lower-generators.js";
@@ -34,6 +34,8 @@ import { hasOptionalChainGuard, isOptionalChainTail, isRequireMainFilename } fro
 import { conditionalSpreadOf, foldedStringKeyOf } from "./expressions/object-literals.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { fenceNodeModuleMutation, isNodeModuleValue, lowerNodeModuleIdentifier, lowerNodeModuleProperty, lowerRequireCacheElement, lowerRequireCacheHas, lowerRequireMainProperty } from "./lower-node-module.js";
+import { lowerAbstractEquality } from "./abstract-equality.js";
+import { coerceStringSearchValue, defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.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
@@ -598,6 +600,7 @@ function lowerExprInner(lowerer, expr) {
             symbol: "symbol",
             map: "object", set: "object", promise: "object", bytes: "object",
             regexp: "object", generator: "object", classval: "function",
+            moduleNs: "object",
             undefinedT: "undefined", nullT: "object",
         };
         const folded = FOLD[operand.type.kind];
@@ -649,13 +652,22 @@ function lowerExprInner(lowerer, expr) {
         if (expr.text === "arguments" && lowerer.ctx.argumentsLocal) {
             return { kind: "varRef", localId: lowerer.ctx.argumentsLocal.id, type: DYN, loc };
         }
-        // A `const x = promisify(execFile)` binding as a VALUE: the
-        // promisified function never exists at runtime (its calls lower to
-        // the interned async-exec helper) — call it directly.
+        // A compiler-projected adapter as a VALUE: the adapter has no
+        // runtime function object (its calls rewrite directly) — call it
+        // through its immutable binding instead.
         {
             const sym = lowerer.resolveValueSymbol(expr);
-            if (sym && lowerer.promisifiedExecFile.has(sym)) {
-                lowerer.unsupported("SC1090", expr, `a promisified execFile as a value (call '${expr.text}' directly)`);
+            const projection = sym ? lowerer.staticCallables.get(sym) : undefined;
+            if (projection?.kind === "promisified-exec-file" || projection?.kind === "promisified-builtin") {
+                lowerer.unsupported("SC1090", expr, `a promisified builtin as a value (call '${expr.text}' directly)`);
+            }
+            if (projection?.kind === "builtin-function") {
+                if (!isJsSourceFile(expr.getSourceFile())) {
+                    const callable = lowerer.lowerBuiltinCallableValue(projection, loc);
+                    if (callable)
+                        return callable;
+                }
+                lowerer.unsupported("SC1090", expr, `a builtin function alias as an escaping value (call '${expr.text}' directly)`);
             }
         }
         // Union-typed bindings read through tsc's control-flow narrowing:
@@ -809,17 +821,12 @@ function lowerExprInner(lowerer, expr) {
         if (sig && lowerer.isTopLevelFnSymbol(expr)) {
             // A declared function used as a value: a zero-capture closure. The
             // backend interns one per function so `f === f` holds (JS identity).
-            // The value's type is the completed ABI signature — exact-arity, so
-            // optional/default/rest declarations pass the value fence first.
+            // The value's type is the completed ABI signature; optional/default
+            // slots and typed rest arrays pass the value fence first.
             lowerer.noteEdge(sig.name);
             // dynRest slots stay out of the VALUE type's param list (fn.length
             // semantics); the rest marker carries the trailing dyn-array ABI.
-            const funcType = {
-                kind: "func",
-                params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
-                ret: sig.returnType,
-                ...(sig.params.some((p) => p.mode === "dynRest") ? { rest: true } : {}),
-            };
+            const funcType = funcTypeFromParamShapes(sig.params, sig.returnType);
             lowerer.requireExactArityValue(expr, expr, sig.params, funcType);
             return { kind: "closure", fnName: sig.name, captures: [], type: funcType, loc };
         }
@@ -865,6 +872,12 @@ function lowerExprInner(lowerer, expr) {
                 if (bi.module === "module" && bi.member === "builtinModules") {
                     return builtinModulesArrayLit(loc);
                 }
+                if (bi.module === "http" && bi.member === "METHODS") {
+                    return { kind: "libCall", fn: "http.methods", args: [], type: arrayOf(STRING), loc };
+                }
+                if (bi.module === "http" && bi.member === "STATUS_CODES") {
+                    return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
+                }
                 // tls.rootCertificates: a runtime-valued module constant (the
                 // cached bundled-CA array) — the one member read that lowers
                 // to a libCall instead of a baked literal.
@@ -879,6 +892,11 @@ function lowerExprInner(lowerer, expr) {
                 if (isJsSourceFile(expr.getSourceFile())) {
                     return { kind: "strLit", value: `[builtin ${bi.module}.${bi.member}]`, type: STRING, loc };
                 }
+                {
+                    const callable = lowerer.lowerBuiltinCallableValue(bi, loc);
+                    if (callable)
+                        return callable;
+                }
                 if (builtinModuleFnOf(lowerer, bi.module, bi.member)) {
                     lowerer.unsupported("SC1090", expr, `library functions as values (call '${expr.text}' directly)`);
                 }
@@ -889,7 +907,12 @@ function lowerExprInner(lowerer, expr) {
         // the namespace object has no representation — members lower at
         // their access sites only. The CommonJS namespace binding
         // (`const lib = require("./lib.js")`) gets the same fence.
-        if (lowerer.builtinNamespaceModuleOf(expr) !== null || lowerer.cjsLocalModuleBindingOf(expr)) {
+        const builtinNamespace = lowerer.builtinNamespaceModuleOf(expr);
+        if (builtinNamespace !== null) {
+            const type = { kind: "moduleNs", moduleId: `builtin:${builtinNamespace}` };
+            return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc };
+        }
+        if (lowerer.cjsLocalModuleBindingOf(expr)) {
             lowerer.unsupported("SC1090", expr, `module namespace objects as values (access '${expr.text}' members directly)`);
         }
         if (lowerer.islandGlobalFnOf(expr)) {
@@ -941,11 +964,14 @@ function lowerExprInner(lowerer, expr) {
         // type-mapper.ts pins the one concrete signature `(value: string) =>
         // primitive`; direct calls `String(x)` never reach here — the call
         // lowering intercepts them with the wider static coercions).
-        // JavaScript sources keep the identity-token path below.
+        const jsPrimitiveCtorSelector = isJsSourceFile(expr.getSourceFile()) &&
+            expr.parent !== undefined &&
+            ts.isArrowFunction(expr.parent) &&
+            expr.parent.body === expr;
         if ((expr.text === "String" || expr.text === "Number" || expr.text === "Boolean") &&
-            !isJsSourceFile(expr.getSourceFile()) &&
+            (!isJsSourceFile(expr.getSourceFile()) || jsPrimitiveCtorSelector) &&
             lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(expr))) {
-            return primitiveCtorClosure(lowerer, expr.text, loc);
+            return primitiveCtorClosure(lowerer, expr.text, loc, jsPrimitiveCtorSelector);
         }
         // The lib fence's IDENTIFIER chokepoint: the real standard library
         // resolves names the old minimal ambient world never declared
@@ -1081,6 +1107,15 @@ function lowerExprInner(lowerer, expr) {
         // representation (ambient namespaces compile to Node's
         // ReferenceError instead — the object never exists at runtime).
         {
+            const moduleNs = lowerer.mapTypeOf(lowerer.typeOf(expr));
+            if (moduleNs?.kind === "moduleNs") {
+                return { kind: "moduleNsRef", moduleId: moduleNs.moduleId, type: moduleNs, loc };
+            }
+            const builtinNs = lowerer.builtinNamespaceModuleOf(expr);
+            if (builtinNs !== null) {
+                const type = { kind: "moduleNs", moduleId: `builtin:${builtinNs}` };
+                return { kind: "moduleNsRef", moduleId: type.moduleId, type, loc };
+            }
             const ns = lowerNsIdentifierValue(lowerer, expr);
             if (ns)
                 return ns;
@@ -3084,10 +3119,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             const receiver = lowerer.lowerExpr(expr.expression);
             return { kind: "libCall", fn: "child.killed", args: [receiver], type: BOOL, loc };
         }
-        if (name === "on" || name === "kill" || name === "unref") {
+        if (name === "on" || name === "once" || name === "kill" || name === "unref") {
             lowerer.unsupported("SC1090", expr, `child methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`ChildProcess.${name}`, expr, "on(\"exit\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are the supported ChildProcess members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`ChildProcess.${name}`, expr, "on/once(\"exit\" | \"close\" | \"error\", cb), pid, exitCode, killed, kill(signal?), and unref() are the supported ChildProcess members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "spawnRes") {
         // The spawnSync-result reads. status is the interned `number | null`
@@ -3137,7 +3172,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         if (name === "isFile" || name === "isDirectory") {
             lowerer.unsupported("SC1090", expr, `Stats methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), size, blocks, nlink, atimeMs, and mtimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), dev, ino, size, blocks, nlink, atimeMs, mtimeMs, and ctimeMs are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "date") {
         const methods = new Set([
@@ -3178,22 +3213,30 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         // serialization: lowercased hostname, `:port` appended exactly when
         // a non-default port is present (scr_url_host — Node-exact,
         // opaque-path URLs answer ""); `hostname` is the stored port-less
-        // host field verbatim (Node would keep IPv6 brackets here, but the
-        // parser rejects IPv6 hosts — documented divergence — so the getter
-        // never sees one).
-        if (name === "protocol" || name === "pathname" || name === "href" || name === "host" || name === "hostname" || name === "search") {
+        // host field verbatim, including IPv6 brackets.
+        if (name === "protocol" || name === "origin" || name === "username" || name === "password" || name === "pathname" || name === "href" || name === "host" || name === "hostname" || name === "port" || name === "search" || name === "hash") {
             const receiver = lowerer.lowerExpr(expr.expression);
             const fn = name === "protocol"
                 ? "url.protocol"
-                : name === "pathname"
-                    ? "url.pathname"
-                    : name === "host"
-                        ? "url.host"
-                        : name === "hostname"
-                            ? "url.hostname"
-                            : name === "search"
-                                ? "url.search"
-                                : "url.href";
+                : name === "origin"
+                    ? "url.origin"
+                    : name === "username"
+                        ? "url.username"
+                        : name === "password"
+                            ? "url.password"
+                            : name === "pathname"
+                                ? "url.pathname"
+                                : name === "host"
+                                    ? "url.host"
+                                    : name === "hostname"
+                                        ? "url.hostname"
+                                        : name === "port"
+                                            ? "url.port"
+                                            : name === "search"
+                                                ? "url.search"
+                                                : name === "hash"
+                                                    ? "url.hash"
+                                                    : "url.href";
             return { kind: "libCall", fn, args: [receiver], type: STRING, loc: locOf(expr) };
         }
         // `u.searchParams`: the LIVE cached view (one identity per URL —
@@ -3206,7 +3249,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         if (name === "toString" || name === "toJSON") {
             lowerer.unsupported("SC1090", expr, `URL methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`URL.${name}`, expr, "protocol, pathname, href, host, hostname, search, searchParams, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`URL.${name}`, expr, "protocol, origin, username, password, pathname, href, host, hostname, port, search, hash, searchParams, and toString() are the supported URL members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "searchParams") {
         const SEARCH_PARAMS_METHODS = new Set(["get", "getAll", "set", "append", "delete", "has", "sort", "toString", "forEach", "keys", "values", "entries"]);
@@ -3768,6 +3811,11 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
     if (operand.type.kind !== "union" || lowerer.armTag(operand.type.unionId, UNDEFINED_T) < 0)
         return operand;
     const directNumber = lowerer.stripUndefinedArm(operand.type).kind === "f64";
+    if (directNumber) {
+        const scalarRead = tryLowerNumericIndexRead(lowerer, operand, loc);
+        if (scalarRead)
+            return scalarRead;
+    }
     const checkerNumber = narrowedNode !== undefined && lowerer.mapTypeOf(lowerer.typeOf(narrowedNode))?.kind === "f64";
     if (!directNumber && (!checkerNumber || lowerer.armTag(operand.type.unionId, F64) < 0))
         return operand;
@@ -4546,6 +4594,78 @@ function tupleLiteralIndex(node) {
     const n = Number(e.text);
     return Number.isInteger(n) && n >= 0 ? n : null;
 }
+/** `a[i] op= rhs` over native arrays and byte views. A compound assignment
+ * evaluates the receiver and index, reads the old element, evaluates rhs,
+ * then writes. Capture each stage so a call in the index or rhs cannot
+ * change the target or the value used by the operator. The expression yields
+ * the computed value before a typed array or Buffer coerces it for storage. */
+export function lowerElementCompound(lowerer, expr, op) {
+    const target = expr.left;
+    fenceNodeModuleMutation(lowerer, target, "assignment");
+    const loc = locOf(expr);
+    const receiverType = lowerer.mapTypeOf(lowerer.typeOf(target.expression));
+    if (receiverType?.kind !== "array" && receiverType?.kind !== "bytes") {
+        lowerer.unsupported("SC1090", target, "compound assignment to non-array elements");
+    }
+    let receiver = lowerer.lowerExpr(target.expression);
+    if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0) {
+        const present = lowerer.stripUndefinedArm(receiver.type);
+        const helper = present.kind === receiverType.kind
+            ? lowerer.narrowedArmHelper(receiver.type.unionId, present, locOf(target.expression))
+            : null;
+        if (helper)
+            receiver = { kind: "call", callee: helper, args: [receiver], type: present, loc: locOf(target.expression) };
+    }
+    if (receiver.type.kind !== receiverType.kind) {
+        lowerer.unsupported("SC1090", target.expression, "compound assignment through a non-native array or byte view");
+    }
+    const index = lowerer.lowerExpr(target.argumentExpression);
+    if (index.type.kind !== "f64")
+        lowerer.unsupported("SC1090", target.argumentExpression, "indexing with non-number keys");
+    const receiverLocal = lowerer.declareHiddenLocal("%compoundArray", receiver.type);
+    const indexLocal = lowerer.declareHiddenLocal("%compoundIndex", F64);
+    const receiverRef = () => varRef(receiverLocal.id, receiver.type, loc);
+    const indexRef = () => varRef(indexLocal.id, F64, loc);
+    const oldValue = receiver.type.kind === "array"
+        ? arrayValueRead(lowerer, receiverRef(), indexRef(), receiver.type.elem, locOf(target))
+        : { kind: "bytesIntrinsic", method: "get", receiver: receiverRef(), args: [indexRef()], type: F64, loc: locOf(target) };
+    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 elementType = receiver.type.kind === "array" ? receiver.type.elem : F64;
+    const valueType = elementType.kind === "union" && lowerer.armTag(elementType.unionId, UNDEFINED_T) >= 0
+        ? lowerer.stripUndefinedArm(elementType)
+        : elementType;
+    let computed;
+    if (op === "+" && valueType.kind === "string") {
+        computed = { kind: "strConcat", left: lowerer.ensureString(oldRef(), target), right: lowerer.ensureString(rhs, expr.right), type: STRING, loc };
+    }
+    else if (valueType.kind === "f64" && numericRhs.type.kind === "f64") {
+        computed = { kind: "bin", op, left: lowerOptionalNumber(lowerer, oldRef(), loc), right: numericRhs, type: F64, loc };
+    }
+    else {
+        lowerer.unsupported("SC1043", expr);
+    }
+    const resultLocal = lowerer.declareHiddenLocal("%compoundResult", computed.type);
+    const resultRef = () => varRef(resultLocal.id, computed.type, loc);
+    const write = receiver.type.kind === "array"
+        ? arrayValueStore(lowerer, receiverRef(), indexRef(), resultRef(), receiver.type.elem, loc)
+        : { kind: "bytesSet", arr: receiverRef(), index: indexRef(), value: resultRef(), loc };
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+            { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+            { kind: "varDecl", localId: oldLocal.id, init: oldValue, loc },
+            { kind: "varDecl", localId: resultLocal.id, init: computed, loc },
+            write,
+        ],
+        result: resultRef(),
+        type: computed.type,
+        loc,
+    };
+}
 /** `a[i] = v` in statement position → arraySet (element writes, like local
    * assignment, produce no value in our subset). */
 export function lowerElementWrite(lowerer, expr) {
@@ -4917,6 +5037,18 @@ export function ensureString(lowerer, e, node) {
         if (stringable) {
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
+        // Runtime-optional locals can retain their stored union after the
+        // checker has narrowed this use to a primitive arm. Validate that
+        // arm before converting it; an unguarded object arm stays fenced.
+        const narrowed = lowerer.mapTypeOf(lowerer.typeOf(node));
+        if (narrowed &&
+            (narrowed.kind === "string" || narrowed.kind === "f64" ||
+                narrowed.kind === "bool" || narrowed.kind === "bigint")) {
+            const helper = lowerer.narrowedArmHelper(e.type.unionId, narrowed, e.loc);
+            if (helper) {
+                return ensureString(lowerer, { kind: "call", callee: helper, args: [e], type: narrowed, loc: e.loc }, node);
+            }
+        }
         lowerer.unsupported("SC1090", node, `string conversions of unions with object arms (${NARROW_FIRST})`);
     }
     if (e.type.kind === "symbol") {
@@ -4968,7 +5100,7 @@ export function ensureString(lowerer, e, node) {
    * neither is observable where the value immediately stringifies — so the
    * span lowers as the argument's own ToString (`new String()` is "").
    * Every other position keeps the wrapper-object constructor fence. */
-function stringWrapperToString(lowerer, node) {
+export function stringWrapperToString(lowerer, node) {
     let e = node;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
@@ -4982,7 +5114,11 @@ function stringWrapperToString(lowerer, node) {
         return null;
     if (args.length === 0)
         return { kind: "strLit", value: "", type: STRING, loc: locOf(e) };
-    return lowerer.caughtToString(args[0]) ?? lowerer.ensureString(lowerer.lowerExpr(args[0]), args[0]);
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, args[0]);
+    if (undefinedArg)
+        return defaultAfterUndefined(undefinedArg, { kind: "strLit", value: "undefined", type: STRING, loc: locOf(e) });
+    return lowerer.caughtToString(args[0]) ??
+        coerceStringSearchValue(lowerer, lowerer.lowerExpr(args[0]), args[0], locOf(e));
 }
 export function lowerTemplate(lowerer, expr) {
     const loc = locOf(expr);
@@ -5229,7 +5365,14 @@ export function lowerPrefixUnary(lowerer, expr) {
             if (raw.type.kind === "bigint") {
                 return { kind: "libCall", fn: "bigint.not", args: [raw], type: BIGINT_T, loc };
             }
-            const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
+            // A checked-dynamic value retains enough JavaScript structure to
+            // run exact ToNumber, including the object valueOf/toString
+            // protocol. This is the static `any`/JS-lane answer for idioms
+            // such as `while (~index)`, where inference may have widened an
+            // otherwise numeric slot to the checked-dynamic tree.
+            const operand = raw.type.kind === "dyn"
+                ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [raw], type: F64, loc }
+                : lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
             return { kind: "unary", op: "~", operand, type: F64, loc };
@@ -5367,8 +5510,9 @@ export function lowerBinary(lowerer, expr) {
         // globals, captured/boxed included); the RHS coerces into the binding's
         // type exactly like statement position, and the expression's value is
         // the coerced binding-typed value (representation change only — never
-        // observably different from JS's raw-RHS yield). Compound operators,
-        // property/element targets, and destructuring targets stay fenced.
+        // observably different from JS's raw-RHS yield). Indexed compounds
+        // use a sequenced read/modify/write; other member targets and
+        // destructuring targets stay fenced.
         if (op === ts.SyntaxKind.EqualsToken && ts.isIdentifier(expr.left)) {
             const target = lowerer.resolveWritable(expr.left);
             if (!target) {
@@ -5380,6 +5524,10 @@ export function lowerBinary(lowerer, expr) {
                 lowerer.runtimeOptionalLocals.add(runtimeOptionalRoot);
             return { kind: "assignExpr", localId: target.id, value, type: target.type, loc };
         }
+        const indexedCompound = COMPOUND_ASSIGN_OPS[op];
+        if (indexedCompound !== undefined && ts.isElementAccessExpression(expr.left)) {
+            return lowerElementCompound(lowerer, expr, indexedCompound);
+        }
         // `events.defaultMaxListeners = v` — the module-property write
         // Node validates (validateNumber(n, 'defaultMaxListeners', 0)):
         // the value crosses into the checked-dynamic tree and the runtime ladder throws
@@ -5518,23 +5666,10 @@ export function lowerBinary(lowerer, expr) {
         const nullTest = lowerLooseNullCompare(lowerer, expr, loc);
         if (nullTest)
             return nullTest;
-        // SAME-KIND loose equality IS strict equality (the spec's ==
-        // dispatches to === when both operands share a type): `typeof v ==
-        // 'object'`, `n != 0`, `flag == true` all lower exactly. Mixed
-        // kinds (where == coerces) keep the fence.
-        {
-            const negated = op === ts.SyntaxKind.ExclamationEqualsToken;
-            const left = lowerer.lowerExpr(expr.left);
-            const right = lowerer.lowerExpr(expr.right);
-            if (left.type.kind === "string" && right.type.kind === "string") {
-                return { kind: "strEq", negated, left, right, type: BOOL, loc };
-            }
-            if ((left.type.kind === "f64" && right.type.kind === "f64") ||
-                (left.type.kind === "bool" && right.type.kind === "bool")) {
-                return { kind: "bin", op: negated ? "!==" : "===", left, right, type: BOOL, loc };
-            }
-        }
-        lowerer.unsupported("SC1040", expr);
+        const loose = lowerAbstractEquality(lowerer, lowerer.lowerExpr(expr.left), lowerer.lowerExpr(expr.right), op === ts.SyntaxKind.ExclamationEqualsToken, loc);
+        if (loose)
+            return loose;
+        lowerer.unsupported("SC1040", expr, undefined, "object-to-primitive loose equality can call user-defined valueOf/toString methods — compare explicit primitive conversions instead");
     }
     if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
         if (op === ts.SyntaxKind.BarBarToken) {
@@ -5558,6 +5693,15 @@ export function lowerBinary(lowerer, expr) {
         if (left.kind === "unitLit") {
             return op === ts.SyntaxKind.BarBarToken ? right : left;
         }
+        // JS objects and symbols are always truthy. In `ref || fallback`
+        // the fallback is therefore unreachable and the result is the
+        // already-evaluated left value — the browser-fallback idiom used by
+        // packages for `process.argv || []` and `process.env || {}`. The
+        // operand itself remains in the IR, preserving reads/calls that
+        // produce the reference; only the unreachable right lowering drops.
+        if (op === ts.SyntaxKind.BarBarToken && REF_TRUTHY_KINDS.has(left.type.kind)) {
+            return left;
+        }
         if (left.type.kind === "dyn" || right.type.kind === "dyn") {
             // A checked-dynamic operand (`fn.name || '<anonymous>'` —
             // test/common's _mustCallInner): both sides live in the checked-dynamic tree and
@@ -6253,6 +6397,9 @@ export function lowerBinary(lowerer, expr) {
             if (idLeft.type.kind === "classval" && idRight.type.kind === "classval") {
                 return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
             }
+            if (idLeft.type.kind === "moduleNs" && idRight.type.kind === "moduleNs") {
+                return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
+            }
             if ((idLeft.type.kind === "array" ||
                 idLeft.type.kind === "map" ||
                 idLeft.type.kind === "set" ||
@@ -7359,10 +7506,10 @@ function lowerInExpression(lowerer, expr, loc) {
     // Compile-time-known STRING keys fold — literals, and the same
     // const/enum-literal and template folding computed property keys get
     // (foldedStringKeyOf); runtime-valued keys keep the fence.
-    // NUMERIC literal keys answer on ARRAY receivers: dense arrays hold
-    // exactly the indices [0, length), so `3 in xs` is a length test (and
-    // a negative/fractional literal is a constant miss — the receiver
-    // still evaluates once through its own length read).
+    // NUMERIC literal keys answer on ARRAY receivers through the shared
+    // presence query. Arrays retain holes independently from length, and
+    // noncanonical numeric keys live in their ordinary-property table, so
+    // a length comparison is not an honest `in` answer.
     {
         let kNode = expr.left;
         while (ts.isParenthesizedExpression(kNode))
@@ -7370,12 +7517,14 @@ function lowerInExpression(lowerer, expr, loc) {
         if (ts.isNumericLiteral(kNode) && lowerer.mapTypeOf(lowerer.typeOf(expr.right))?.kind === "array") {
             const recvArr = lowerer.lowerExpr(expr.right);
             if (recvArr.type.kind === "array") {
-                const len = { kind: "arrIntrinsic", method: "length", receiver: recvArr, args: [], type: F64, loc };
                 const n = Number(kNode.text);
-                if (Number.isInteger(n) && n >= 0) {
-                    return { kind: "bin", op: "<", left: { kind: "numLit", value: n, type: F64, loc }, right: len, type: BOOL, loc };
-                }
-                return { kind: "bin", op: "<", left: len, right: { kind: "numLit", value: 0, type: F64, loc }, type: BOOL, loc };
+                return {
+                    kind: "arrayHas",
+                    arr: recvArr,
+                    index: { kind: "numLit", value: n, type: F64, loc },
+                    type: BOOL,
+                    loc,
+                };
             }
         }
     }
@@ -8695,7 +8844,20 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
     // construction), typed as the index value armed with undefined under
     // noUncheckedIndexedAccess (mirroring lowerRecordKeyRead).
     if (target.container === "recordOvf") {
-        let t = target.fieldType;
+        let obj = target.obj;
+        if (obj.type.kind === "union" && ts.isPropertyAccessExpression(blame)) {
+            const present = lowerer.stripUndefinedArm(obj.type);
+            if (present.kind === "record") {
+                obj = lowerer.runtimeOptionalPropertyReceiver(blame.expression, obj, present, target.field) ?? obj;
+            }
+        }
+        if (obj.type.kind !== "record") {
+            lowerer.unsupported("SC1090", blame, `reading '${target.field}' on a non-record receiver (narrow first)`);
+        }
+        const shape = lowerer.shapes.get(obj.type.shapeId);
+        if (!shape?.indexValue)
+            lowerer.unsupported("SC1090", blame, `reading '${target.field}' on a record without an index signature`);
+        let t = shape.indexValue;
         if (lowerer.program.getCompilerOptions().noUncheckedIndexedAccess) {
             const armed = lowerer.withUndefinedArmOf(t);
             if (!armed)
@@ -8704,8 +8866,8 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
         }
         return {
             kind: "recordKeyGet",
-            obj: target.obj,
-            shapeId: target.shapeId,
+            obj,
+            shapeId: obj.type.shapeId,
             key: { kind: "strLit", value: target.field, type: STRING, loc },
             overflowOnly: true,
             type: t,
@@ -9011,32 +9173,40 @@ function lowerStreamObjectProperty(lowerer, expr) {
     return lowerStreamProperty(lowerer, expr, info);
 }
 /** The primitive-constructor closure (`String`/`Number`/`Boolean` as a
- * VALUE): interns one synthesized module function per constructor —
- * `%builtin.String` et al. — and returns the zero-capture closure over it.
- * The body IS the string-coercion the type mapping promised
- * (`(value: string) => primitive`): String is identity, Number the ECMA
- * StringToNumber (num.fromString — the same runtime call the direct
- * `Number(s)` lowering emits), Boolean the emptiness test. Interning makes
- * every reference the SAME immortal closure, so `opt.type === String`
- * compares like JS function identity. */
-function primitiveCtorClosure(lowerer, name, loc) {
+ * VALUE): interns one synthesized module function per constructor/ABI and
+ * returns the zero-capture closure over it. Typed sources use the mapped
+ * `(value: string) => primitive` signature; a recognized JavaScript
+ * concise-arrow selector (`() => String`, the picocolors fallback) takes
+ * dyn so its ordinary coercion signature survives inference residue. The
+ * dyn bodies run exact ToString/ToNumber/ToBoolean, including object hooks.
+ * Interning makes every reference under one ABI the SAME immortal closure,
+ * so `opt.type === String` compares like JS function identity. */
+function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
     const ret = name === "String" ? STRING : name === "Number" ? F64 : BOOL;
-    const fnT = funcOf([STRING], ret);
-    let fnName = lowerer.primitiveCtorFns.get(name);
+    const input = dynamicInput ? DYN : STRING;
+    const fnT = funcOf([input], ret);
+    const key = `${name}:${dynamicInput ? "dyn" : "string"}`;
+    let fnName = lowerer.primitiveCtorFns.get(key);
     if (!fnName) {
-        fnName = `%builtin.${name}`;
-        lowerer.primitiveCtorFns.set(name, fnName);
-        const s = { kind: "varRef", localId: "v.0", type: STRING, loc };
-        const value = name === "String"
-            ? s
-            : name === "Number"
-                ? { kind: "libCall", fn: "num.fromString", args: [s], type: F64, loc }
-                : { kind: "strEq", negated: true, left: s, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
+        fnName = `%builtin.${name}${dynamicInput ? ".dyn" : ""}`;
+        lowerer.primitiveCtorFns.set(key, fnName);
+        const v = { kind: "varRef", localId: "v.0", type: input, loc };
+        const value = dynamicInput
+            ? name === "String"
+                ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc }
+                : name === "Number"
+                    ? { kind: "libCall", fn: "dyn.toNumberCoerce", args: [v], type: F64, loc }
+                    : { kind: "dynTest", test: "truthy", value: v, type: BOOL, loc }
+            : name === "String"
+                ? v
+                : name === "Number"
+                    ? { kind: "libCall", fn: "num.fromString", args: [v], type: F64, loc }
+                    : { kind: "strEq", negated: true, left: v, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
         const fn = {
             name: fnName,
-            params: [{ localId: "v.0", name: "value", type: STRING }],
+            params: [{ localId: "v.0", name: "value", type: input }],
             returnType: ret,
-            locals: [{ id: "v.0", name: "value", type: STRING, mutable: false }],
+            locals: [{ id: "v.0", name: "value", type: input, mutable: false }],
             body: [{ kind: "return", value, loc }],
             loc,
         };