@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -9,7 +9,7 @@ import * as ts from "../ts7/adapter.js";
 import { dirname, posix } from "node:path";
 import { pathToFileURL } from "node:url";
 import { wasiGuestPath } from "../../wasi-paths.js";
-import { 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 { 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 { blockedBindingUseDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.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,7 @@ 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";
 /** 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
@@ -143,6 +144,16 @@ function lowerExprInner(lowerer, expr) {
         }
         return { kind: "numLit", value, type: F64, loc };
     }
+    if (ts.isBigIntLiteral(expr)) {
+        const spelling = expr.getText().replace(/_/g, "").replace(/n$/i, "");
+        return {
+            kind: "libCall",
+            fn: "bigint.parse",
+            args: [{ kind: "strLit", value: spelling, type: STRING, loc }],
+            type: BIGINT_T,
+            loc,
+        };
+    }
     if (expr.kind === ts.SyntaxKind.TrueKeyword) {
         return { kind: "boolLit", value: true, type: BOOL, loc };
     }
@@ -583,11 +594,12 @@ function lowerExprInner(lowerer, expr) {
             operand = operand.value;
         }
         const FOLD = {
-            f64: "number", string: "string", bool: "boolean", func: "function",
+            f64: "number", bigint: "bigint", string: "string", bool: "boolean", func: "function",
             array: "object", object: "object", record: "object",
             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];
@@ -639,13 +651,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:
@@ -799,17 +820,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 };
         }
@@ -869,6 +885,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)`);
                 }
@@ -879,7 +900,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)) {
@@ -931,11 +957,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
@@ -960,7 +989,6 @@ function lowerExprInner(lowerer, expr) {
                 // The families with a WHY: each hint states what makes the
                 // surface genuinely non-static (or what to use instead).
                 const globalHints = {
-                    BigInt: "arbitrary-precision integers have no static representation — f64 is the one number type (Number.MAX_SAFE_INTEGER bounds exact integers)",
                     Proxy: "property-access metaprogramming has no static lowering (every property read must resolve at compile time)",
                     Reflect: "reflective property access has no static lowering — read and call members directly",
                     Intl: "locale- and ICU-backed behavior lives outside the static runtime (the localeCompare stance: code-unit order, no collation/locale data) — what lowers: the composed new Intl.NumberFormat(\"en-US\").format(x) and x.toLocaleString(\"en-US\") with default options",
@@ -1072,6 +1100,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;
@@ -2957,6 +2994,9 @@ export function ensureBool(lowerer, e, node) {
     if (e.type.kind === "f64" || e.type.kind === "string") {
         return { kind: "toBool", operand: e, type: BOOL, loc: e.loc };
     }
+    if (e.type.kind === "bigint") {
+        return { kind: "libCall", fn: "bigint.truthy", args: [e], type: BOOL, loc: e.loc };
+    }
     if (e.type.kind === "dyn") {
         // ToBoolean over the checked-dynamic tree (`if (pkg)` on a JSON.parse result): every
         // dyn kind has a JS-exact answer — the truthy dynTest reads the kind
@@ -3072,10 +3112,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`
@@ -3125,7 +3165,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([
@@ -3166,22 +3206,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 —
@@ -3194,7 +3242,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"]);
@@ -4863,6 +4911,15 @@ export function lowerElementWrite(lowerer, expr) {
 export function ensureString(lowerer, e, node) {
     if (e.type.kind === "string")
         return e;
+    if (e.type.kind === "bigint") {
+        return {
+            kind: "libCall",
+            fn: "bigint.toString",
+            args: [e, { kind: "numLit", value: 10, type: F64, loc: e.loc }],
+            type: STRING,
+            loc: e.loc,
+        };
+    }
     if (e.type.kind === "dyn") {
         // String(u) / `${u}`: a runtime dispatch over the dyn kind — Node's
         // String() exactly (undefined/null texts, JS number formatting,
@@ -4892,7 +4949,7 @@ export function ensureString(lowerer, e, node) {
         // JS would print "[object Object]" and friends — narrow first.
         const def = lowerer.unions.get(e.type.unionId);
         const stringable = def?.arms.every((a) => a.kind === "undefinedT" || a.kind === "nullT" ||
-            a.kind === "string" || a.kind === "f64" || a.kind === "bool");
+            a.kind === "string" || a.kind === "f64" || a.kind === "bigint" || a.kind === "bool");
         if (stringable) {
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
@@ -5171,6 +5228,9 @@ export function lowerPrefixUnary(lowerer, expr) {
             if (raw.type.kind === "jsval") {
                 return { kind: "jsOp", op: "neg", args: [raw], type: JSVAL, loc };
             }
+            if (raw.type.kind === "bigint") {
+                return { kind: "libCall", fn: "bigint.neg", args: [raw], type: BIGINT_T, loc };
+            }
             const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
@@ -5201,7 +5261,18 @@ export function lowerPrefixUnary(lowerer, expr) {
         }
         case ts.SyntaxKind.TildeToken: {
             // `~x`: ToInt32, complement, back to f64 (JS-exact, incl. NaN → -1).
-            const operand = lowerOptionalNumber(lowerer, lowerer.lowerExpr(expr.operand), loc, expr.operand);
+            const raw = lowerer.lowerExpr(expr.operand);
+            if (raw.type.kind === "bigint") {
+                return { kind: "libCall", fn: "bigint.not", args: [raw], type: BIGINT_T, loc };
+            }
+            // 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 };
@@ -5490,23 +5561,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) {
@@ -5530,6 +5588,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
@@ -5877,6 +5944,73 @@ export function lowerBinary(lowerer, expr) {
     if (left.type.kind === "jsval" || right.type.kind === "jsval") {
         return lowerAnyBinaryInIsland(lowerer, expr, left, right, loc);
     }
+    if (left.type.kind === "bigint" && right.type.kind === "bigint") {
+        const binary = {
+            [ts.SyntaxKind.PlusToken]: "bigint.add",
+            [ts.SyntaxKind.MinusToken]: "bigint.sub",
+            [ts.SyntaxKind.AsteriskToken]: "bigint.mul",
+            [ts.SyntaxKind.SlashToken]: "bigint.div",
+            [ts.SyntaxKind.PercentToken]: "bigint.mod",
+            [ts.SyntaxKind.AsteriskAsteriskToken]: "bigint.pow",
+            [ts.SyntaxKind.AmpersandToken]: "bigint.and",
+            [ts.SyntaxKind.BarToken]: "bigint.or",
+            [ts.SyntaxKind.CaretToken]: "bigint.xor",
+            [ts.SyntaxKind.LessThanLessThanToken]: "bigint.shl",
+            [ts.SyntaxKind.GreaterThanGreaterThanToken]: "bigint.shr",
+        };
+        const fn = binary[op];
+        if (fn)
+            return { kind: "libCall", fn, args: [left, right], type: BIGINT_T, loc };
+        if (op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+            op === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+            const equal = { kind: "libCall", fn: "bigint.eq", args: [left, right], type: BOOL, loc };
+            return op === ts.SyntaxKind.ExclamationEqualsEqualsToken
+                ? { kind: "unary", op: "!", operand: equal, type: BOOL, loc }
+                : equal;
+        }
+        if (op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.LessThanEqualsToken ||
+            op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.GreaterThanEqualsToken) {
+            const cmp = { kind: "libCall", fn: "bigint.cmp", args: [left, right], type: F64, loc };
+            const zero = { kind: "numLit", value: 0, type: F64, loc };
+            const cmpOp = op === ts.SyntaxKind.LessThanToken ? "<"
+                : op === ts.SyntaxKind.LessThanEqualsToken ? "<="
+                    : op === ts.SyntaxKind.GreaterThanToken ? ">" : ">=";
+            return { kind: "bin", op: cmpOp, left: cmp, right: zero, type: BOOL, loc };
+        }
+    }
+    if ((left.type.kind === "bigint" && right.type.kind === "f64") ||
+        (left.type.kind === "f64" && right.type.kind === "bigint")) {
+        if (op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.LessThanEqualsToken ||
+            op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.GreaterThanEqualsToken) {
+            const big = left.type.kind === "bigint" ? left : right;
+            const num = left.type.kind === "f64" ? left : right;
+            const cmp = { kind: "libCall", fn: "bigint.cmpNumber", args: [big, num], type: F64, loc };
+            const cmpLocal = lowerer.declareHiddenLocal("%bigcmp", F64);
+            const cmpRef = { kind: "varRef", localId: cmpLocal.id, type: F64, loc };
+            const unordered = {
+                kind: "bin", op: "===", left: cmpRef,
+                right: { kind: "numLit", value: 2, type: F64, loc }, type: BOOL, loc,
+            };
+            const zero = { kind: "numLit", value: 0, type: F64, loc };
+            const leftBig = left.type.kind === "bigint";
+            const cmpOp = leftBig
+                ? op === ts.SyntaxKind.LessThanToken ? "<" : op === ts.SyntaxKind.LessThanEqualsToken ? "<=" : op === ts.SyntaxKind.GreaterThanToken ? ">" : ">="
+                : op === ts.SyntaxKind.LessThanToken ? ">" : op === ts.SyntaxKind.LessThanEqualsToken ? ">=" : op === ts.SyntaxKind.GreaterThanToken ? "<" : "<=";
+            const result = {
+                kind: "logical", op: "&&",
+                left: { kind: "unary", op: "!", operand: unordered, type: BOOL, loc },
+                right: { kind: "bin", op: cmpOp, left: cmpRef, right: zero, type: BOOL, loc },
+                type: BOOL, loc,
+            };
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "varDecl", localId: cmpLocal.id, init: cmp, loc }],
+                result,
+                type: BOOL,
+                loc,
+            };
+        }
+    }
     // An unchecked array read keeps its undefined arm in the IR even when
     // the checker typed the binding as `string`. An optional string is not
     // itself a string operand for `+`: `undefined + 1` and
@@ -6158,6 +6292,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" ||
@@ -6390,6 +6527,7 @@ function typeofAnswer(arm) {
         case "undefinedT": return "undefined";
         case "func": return "function";
         case "symbol": return "symbol";
+        case "bigint": return "bigint";
         case "nullT":
         case "array":
         case "map":
@@ -6409,7 +6547,10 @@ function typeofAnswer(arm) {
         case "httpClientReq":
         case "secureCtx":
         case "fsWatcher":
+        case "cryptoHash":
+        case "cryptoHmac":
         case "childStream":
+        case "childWriter":
         case "procStream":
         case "object":
         case "record":
@@ -7260,10 +7401,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))
@@ -7271,12 +7412,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,
+                };
             }
         }
     }
@@ -8912,32 +9055,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,
         };