@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/surfaces.js

@@ -1,8 +1,15 @@
 import * as ts from "../ts7/adapter.js";
+import { staticCondition, staticallySelected } from "./static-typeof.js";
+function unparenthesized(e) {
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return e;
+}
 import { UNSUPPORTED } from "../../diagnostics/diagnostic.js";
 import { BOOL, BYTES_U8, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DIR_T, DYN, F64, FILEHANDLE_T, SPAWNRES_T, STATS_T, STRING, URL_T, VOID, arrayOf, } from "../../ir/ir.js";
-import { isNodeTypesPath, requireSpecOf } from "../program.js";
+import { isJsSourceFile, isNodeTypesPath, requireSpecOf } from "../program.js";
 import { ZLIB_CONSTANTS } from "./zlib-constants.js";
+import { V8_MEMBER_REASON } from "../builtin-modules.js";
 /** zlib stream instances: runtime Transform streams (scr_zlib_stream.c). */
 const ZLIB_STREAM = { kind: "object", className: "%Transform" };
 /** Statement-level constructs rejected wholesale, keyed by syntax kind. */
@@ -106,13 +113,13 @@ export function sideEffectFreeOptionValue(node) {
         return sideEffectFreeOptionValue(e.operand);
     }
     if (ts.isObjectLiteralExpression(e)) {
-        return e.properties.every((p) => ts.isShorthandPropertyAssignment(p) ||
+        return e.properties.nodes.every((p) => ts.isShorthandPropertyAssignment(p) ||
             (ts.isPropertyAssignment(p) &&
                 !ts.isComputedPropertyName(p.name) &&
                 sideEffectFreeOptionValue(p.initializer)));
     }
     if (ts.isArrayLiteralExpression(e)) {
-        return e.elements.every((el) => !ts.isSpreadElement(el) && sideEffectFreeOptionValue(el));
+        return e.elements.nodes.every((el) => !ts.isSpreadElement(el) && sideEffectFreeOptionValue(el));
     }
     return false;
 }
@@ -215,8 +222,8 @@ export const HTTP_SERVER_DOCUMENTED_OPTIONS = new Set([
 /** new http.Agent(options)'s documented keys (Node v24 — the Agent
  * constructor table plus the socket.connect() options it forwards into
  * each dial). The lowered set is keepAlive/keepAliveMsecs/maxSockets/
- * maxFreeSockets/timeout/port (+ scheduling, dropped: no free pool
- * exists); the rest fence by name and unknown keys drop like Node. */
+ * maxFreeSockets/timeout/port/scheduling; the rest fence by name and
+ * unknown keys drop like Node. */
 export const AGENT_DOCUMENTED_OPTIONS = new Set([
     "family",
     "hints",
@@ -566,6 +573,7 @@ export const STDLIB_SURFACE = {
             cosh: ISL_N1,
             exp: ISL_N1,
             expm1: ISL_N1,
+            f16round: ISL_N1,
             fround: ISL_N1,
             hypot: ISL_N2,
             imul: ISL_N2,
@@ -649,6 +657,7 @@ export const STATIC_MATH_FNS = {
     sign: { fn: "math.sign", arity: 1 },
     exp: { fn: "math.exp", arity: 1 },
     expm1: { fn: "math.expm1", arity: 1 },
+    f16round: { fn: "math.f16round", arity: 1 },
     fround: { fn: "math.fround", arity: 1 },
     sqrt: { fn: "math.sqrt", arity: 1 },
     log: { fn: "math.log", arity: 1 },
@@ -665,6 +674,7 @@ export const STATIC_MATH_FNS = {
  * fences, while the arity range is the surface manifest's support claim. */
 export const STATIC_NUMBER_METHODS = {
     toFixed: { fns: ["num.toFixed0", "num.toFixed"], minArgs: 0, maxArgs: 1 },
+    toPrecision: { fns: ["num.toPrecision"], minArgs: 0, maxArgs: 1 },
 };
 /** The common first-class shape for builtin functions whose supported
  * source signature is already exactly the fixed native ABI. Keeping the
@@ -1345,6 +1355,9 @@ export const BUILTIN_MODULE_FNS = {
             result: F64,
             valueParams: [{ mode: "optional", type: F64, defaultValue: 0 }],
         },
+        // A one-argument call is setPriority(0, priority)
+        // (lowerOsSetPriorityCall completes it).
+        setPriority: { fn: "os.setPriority", params: [F64, F64], result: VOID },
         // Special-cased (lowerOsCpusCall): the call site's CpuInfo[] assembles
         // from one uv_cpu_info snapshot.
         cpus: { fn: "os.cpusTake", params: [], result: VOID },
@@ -1357,7 +1370,15 @@ export const BUILTIN_MODULE_FNS = {
         userInfo: { fn: "os.userName", params: [], result: VOID },
     },
     crypto: {
-        randomUUID: { fn: "crypto.randomUUID", params: [], result: STRING },
+        randomUUID: {
+            fn: "crypto.randomUUID",
+            params: [],
+            result: STRING,
+            // As a value (uuid's `export default { randomUUID }`), the optional
+            // options argument goes through the validating entry point.
+            valueFn: "crypto.randomUUIDOpts",
+            valueParams: [{ mode: "optional", type: DYN, defaultValue: undefined }],
+        },
         // A real Buffer result. The composed randomBytes(n).toString(enc)
         // form KEEPS its one-libCall lowering (lowerCryptoComposedCall runs
         // first and the Buffer never materializes there); this entry covers
@@ -1376,9 +1397,15 @@ export const BUILTIN_MODULE_FNS = {
         hash: { fn: "crypto.hashDigestStr", params: [STRING, STRING, STRING], result: STRING },
         timingSafeEqual: { fn: "crypto.timingSafeEqual", params: [BYTES_U8, BYTES_U8], result: BOOL },
         randomFillSync: { fn: "crypto.randomFill", params: [BYTES_U8, F64, F64], result: BYTES_U8 },
+        getRandomValues: { fn: "crypto.getRandomValues", params: [BYTES_U8], result: BYTES_U8 },
         randomInt: { fn: "crypto.randomInt", params: [F64, F64], result: F64 },
         randomFill: { fn: "crypto.randomFillCb", params: [], result: VOID },
-        randomUUIDv7: { fn: "crypto.randomUUIDv7", params: [DYN], result: STRING },
+        randomUUIDv7: {
+            fn: "crypto.randomUUIDv7",
+            params: [DYN],
+            result: STRING,
+            valueParams: [{ mode: "optional", type: DYN, defaultValue: undefined }],
+        },
         createSecretKey: { fn: "crypto.createSecretKey", params: [DYN, DYN], result: DYN },
         generateKeySync: { fn: "crypto.generateKeySync", params: [DYN, DYN], result: DYN },
         generateKey: { fn: "crypto.generateKeyCb", params: [], result: VOID },
@@ -1400,6 +1427,9 @@ export const BUILTIN_MODULE_FNS = {
         // Decipheriv handle (lowerCryptoModuleCall).
         createCipheriv: { fn: "crypto.cipherNew", params: [BOOL, DYN, DYN, DYN, DYN], result: DYN },
         createDecipheriv: { fn: "crypto.cipherNew", params: [BOOL, DYN, DYN, DYN, DYN], result: DYN },
+        // A checked-dynamic curve name; the result is a native ECDH handle
+        // (lowerCreateEcdh).
+        createECDH: { fn: "crypto.ecdhNew", params: [DYN], result: DYN },
     },
     zlib: {
         // The default-options convenience family is special-cased in
@@ -1618,6 +1648,22 @@ export const BUILTIN_MODULE_FNS = {
         isAsyncFunction: { fn: "util.typeIs", params: [DYN], result: BOOL },
         isGeneratorFunction: { fn: "util.typeIs", params: [DYN], result: BOOL },
         isGeneratorObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isDate: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isSharedArrayBuffer: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isMapIterator: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isSetIterator: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isKeyObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isNumberObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isStringObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isBooleanObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isBigIntObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isSymbolObject: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isBoxedPrimitive: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isBigInt64Array: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isBigUint64Array: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isFloat16Array: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isCryptoKey: { fn: "util.typeIs", params: [DYN], result: BOOL },
+        isExternal: { fn: "util.typeIs", params: [DYN], result: BOOL },
     },
     buffer: {
         isAscii: { fn: "buffer.isAscii", params: [DYN], result: BOOL },
@@ -1661,6 +1707,22 @@ export const BUILTIN_MODULE_FNS = {
             valueParams: [{ mode: "required", type: STRING }],
         },
     },
+    // node:punycode (deprecated): punycode.js 2.1.0's conversions over
+    // strings (scr_url.c). ucs2.decode/encode are members of the module's
+    // ucs2 object, dispatched as module members (builtinMemberOf). The
+    // DEP0040 report rides the module's load sites (punycodeLoadWarning).
+    punycode: {
+        decode: { fn: "punycode.decode", params: [STRING], result: STRING },
+        encode: { fn: "punycode.encode", params: [STRING], result: STRING },
+        toASCII: { fn: "punycode.toASCII", params: [STRING], result: STRING },
+        toUnicode: { fn: "punycode.toUnicode", params: [STRING], result: STRING },
+        "ucs2.decode": { fn: "punycode.ucs2Decode", params: [STRING], result: arrayOf(F64) },
+        "ucs2.encode": { fn: "punycode.ucs2Encode", params: [arrayOf(F64)], result: STRING },
+    },
+    // node:constants (deprecated) is one frozen object (Object.assign of
+    // os.constants' groups, fs.constants and crypto.constants): bindings of
+    // the module read it as a checked-dynamic value (builtinConstantsObject).
+    constants: {},
     // node:readline: createInterface's options are entirely special-cased
     // (exactly { input: process.stdin, output?: process.stdout } — see
     // lowerBuiltinModuleCall); the entry carries the canonical shape. The
@@ -1712,6 +1774,18 @@ export const BUILTIN_MODULE_FNS = {
     // special-cased); the keys exist for the same reason net/http's do.
     dgram: {},
     dns: {},
+    // node:dns/promises rides the same spoke (lookup's promise form).
+    "dns/promises": {},
+    // node:v8: getHeapStatistics answers allocator-derived figures in
+    // Node's shape (builtins/v8.ts — the entry carries the canonical
+    // shape); every other member fences with the by-design reason
+    // (builtinFenceHintOf).
+    v8: {
+        getHeapStatistics: { fn: "process.memoryUsageTake", params: [], result: VOID },
+    },
+    // node:stream/web re-exports the web stream globals (the same objects);
+    // its members lower through the globals' own paths.
+    "stream/web": {},
     // node:assert lowers ENTIRELY through the assert spoke (lower-assert.ts
     // — every call shape is special-cased: optional messages complete, the
     // comparisons pick per-type libCalls, deep equality synthesizes
@@ -1733,13 +1807,25 @@ export const BUILTIN_MODULE_FNS = {
     // module-qualified with the pointed hint below.
     "stream/consumers": {},
     // node:timers/promises — the delay-only setTimeout and bare setImmediate
-    // (void promises the shared timer heap settles). The arity completion
-    // (omitted delay = Node's 1ms) and the value/options fences are
-    // special-cased in lowerBuiltinModuleCall; these entries carry the
-    // canonical shapes and route the dispatch.
+    // (void promises the shared timer heap settles), and scheduler.wait /
+    // scheduler.yield, which Node defines as setTimeout(delay, undefined,
+    // options) and setImmediate(). The arity completion (omitted delay =
+    // Node's 1ms) and the value/options fences are special-cased in
+    // lowerBuiltinModuleCall; these entries carry the canonical shapes and
+    // route the dispatch.
     "timers/promises": {
         setTimeout: { fn: "tp.setTimeout", params: [F64], result: { kind: "promise", inner: VOID } },
         setImmediate: { fn: "tp.setImmediate", params: [], result: { kind: "promise", inner: VOID } },
+        "scheduler.wait": {
+            fn: "tp.setTimeout",
+            params: [F64],
+            result: { kind: "promise", inner: VOID },
+        },
+        "scheduler.yield": {
+            fn: "tp.setImmediate",
+            params: [],
+            result: { kind: "promise", inner: VOID },
+        },
     },
     // node:diagnostics_channel — the pub/sub core. channel() answers an f64
     // handle (type-mapper.ts maps Channel to F64); the subscriber arguments box
@@ -1774,6 +1860,7 @@ export const BUILTIN_MODULE_CONSTS = {
     os: { EOL: "\n", devNull: "/dev/null" },
     worker_threads: { isMainThread: true, threadId: 0 },
     cluster: { isPrimary: true, isMaster: true, isWorker: false },
+    punycode: { version: "2.1.0" },
     // zlib's module-level copies of its constants (every member outside
     // BROTLI_*, Node's own loop over zlib.constants).
     zlib: Object.fromEntries(Object.entries(ZLIB_CONSTANTS).filter(([name]) => !name.startsWith("BROTLI"))),
@@ -1836,6 +1923,9 @@ export const BUILTIN_MODULE_FN_ALIASES = {
         readdirSync: ["fs.readdirTypesSync"],
         // The { throwIfNoEntry } probe form.
         statSync: ["fs.statProbeSync"],
+        // realpathSync and realpathSync.native read as function values.
+        realpathSync: ["fs.realpathValue"],
+        "realpathSync.native": ["fs.realpathValue"],
         lstatSync: ["fs.lstatProbeSync"],
         globSync: ["fs.globTypesSync"],
         // The JS-source validation-ladder variant (lowerFsLadderCall): the
@@ -1864,8 +1954,13 @@ export const BUILTIN_MODULE_FN_ALIASES = {
     crypto: {
         // The composed randomBytes(n).toString(enc) chain keeps its one-libCall
         // lowering (lowerCryptoComposedCall), while the callback overload has
-        // its own adapter spelling. Both remain the randomBytes surface.
-        randomBytes: ["crypto.randomBytesToString", "crypto.randomBytesCb"],
+        // its own adapter spelling. Both remain the randomBytes surface, as does
+        // the util.promisify form.
+        randomBytes: [
+            "crypto.randomBytesToString",
+            "crypto.randomBytesCb",
+            "crypto.randomBytesPromise",
+        ],
         // Omitting size fills from offset through the rest of the Buffer and
         // uses a separate runtime entry point for Node's exact bounds checks.
         // Views of every kind return themselves; other buffers take the Dyn form.
@@ -1875,9 +1970,14 @@ export const BUILTIN_MODULE_FN_ALIASES = {
             "crypto.randomFillViewRest",
             "crypto.randomFillSyncDyn",
         ],
-        randomFill: ["crypto.randomFillCbDyn"],
+        randomFill: [
+            "crypto.randomFillCbDyn",
+            "crypto.randomFillPromise",
+            "crypto.randomFillPromiseDyn",
+        ],
         timingSafeEqual: ["crypto.timingSafeEqualDyn"],
-        randomInt: ["crypto.randomIntMax", "crypto.randomIntCb"],
+        getRandomValues: ["crypto.getRandomValuesDyn"],
+        randomInt: ["crypto.randomIntMax", "crypto.randomIntCb", "crypto.randomIntPromise"],
         randomUUID: ["crypto.randomUUIDOpts"],
     },
     os: {
@@ -1899,7 +1999,14 @@ export const AMBIENT_SURFACE_FNS = [
         id: "node-builtin.worker_threads.metadata",
         kind: "node-builtin",
         name: "worker_threads metadata",
-        fns: ["worker.isMainThread", "worker.threadId", "worker.data", "worker.parentPort"],
+        fns: [
+            "worker.isMainThread",
+            "worker.threadId",
+            "worker.data",
+            "worker.parentPort",
+            "worker.resourceLimits",
+            "worker.threadName",
+        ],
         note: "current-thread metadata and the worker's parent message port",
     },
     {
@@ -1923,6 +2030,20 @@ export const AMBIENT_SURFACE_FNS = [
         fns: ["blob.fileNew"],
         note: "a Blob with name and lastModified (Date.now() when absent)",
     },
+    {
+        id: "stdlib.webcrypto.subtle",
+        kind: "stdlib",
+        name: "globalThis.crypto.subtle",
+        fns: ["webcrypto.importKey", "webcrypto.sign", "webcrypto.verify", "webcrypto.digest"],
+        note: "importKey('raw') for HMAC keys, HMAC sign and verify, and SHA-1/SHA-2 digest; other methods, algorithms and key formats are refused",
+    },
+    {
+        id: "stdlib.webcrypto.CryptoKey",
+        kind: "stdlib",
+        name: "CryptoKey",
+        fns: ["webcrypto.isCryptoKey"],
+        note: "secret HMAC keys with type, extractable, algorithm and usages, and instanceof CryptoKey",
+    },
     {
         id: "stdlib.atomics",
         kind: "stdlib",
@@ -1951,14 +2072,22 @@ export const AMBIENT_SURFACE_FNS = [
         kind: "stdlib",
         name: "Date.parse",
         fns: ["date.parse"],
-        note: "one date string, using the bounded parser shared with new Date(dateString).getTime()",
+        note: "one date string, using V8's date parser shared with new Date(dateString)",
     },
     {
         id: "stdlib.date.constructor",
         kind: "stdlib",
         name: "Date constructor",
-        fns: ["date.newNow", "date.newMs", "date.newString", "date.nativeNew"],
-        note: "zero arguments, or one milliseconds/date-string argument; values are the read-only TimeClip scalar slice",
+        fns: [
+            "date.newNow",
+            "date.newMs",
+            "date.newString",
+            "date.nativeNew",
+            "date.newLocal",
+            "date.nativeNewFields",
+            "date.nativeNewValue",
+        ],
+        note: "zero arguments, one milliseconds/date-string argument, or local-time year/month fields; values are the read-only TimeClip scalar slice",
     },
     {
         id: "stdlib.date.UTC",
@@ -1988,6 +2117,13 @@ export const AMBIENT_SURFACE_FNS = [
         fns: ["date.toISOString", "date.toISOStringValue"],
         note: "UTC ISO formatting over constructed and stored Date values",
     },
+    {
+        id: "stdlib.date.toUTCString",
+        kind: "stdlib",
+        name: "Date.prototype.toUTCString",
+        fns: ["date.toUTCString"],
+        note: "RFC 7231 IMF-fixdate formatting over stored Date values",
+    },
     {
         id: "stdlib.date.getFullYear",
         kind: "stdlib",
@@ -2085,6 +2221,25 @@ export const AMBIENT_SURFACE_FNS = [
         name: "Date.prototype.getTimezoneOffset",
         fns: ["date.getTimezoneOffset"],
     },
+    {
+        id: "stdlib.date.toString",
+        kind: "stdlib",
+        name: "Date.prototype.toString",
+        fns: ["date.toString"],
+        note: "local time with the host zone's long English name; String(date) and template literals use it",
+    },
+    {
+        id: "stdlib.date.toDateString",
+        kind: "stdlib",
+        name: "Date.prototype.toDateString",
+        fns: ["date.toDateString"],
+    },
+    {
+        id: "stdlib.date.toTimeString",
+        kind: "stdlib",
+        name: "Date.prototype.toTimeString",
+        fns: ["date.toTimeString"],
+    },
     // ── perf_hooks (lowerPerfHooksCall): the monotonic clock.
     {
         id: "node-builtin.perf_hooks.performance.now",
@@ -2135,6 +2290,27 @@ export const AMBIENT_SURFACE_FNS = [
         name: "perf_hooks.performance.clearMeasures",
         fns: ["perf.clearMeasures"],
     },
+    {
+        id: "node-builtin.perf_hooks.performance.eventLoopUtilization",
+        kind: "node-builtin",
+        name: "perf_hooks.performance.eventLoopUtilization",
+        fns: ["perf.loopStart", "perf.idleTime"],
+        note: "active time is the main thread's CPU time since the loop started; the one- and two-argument difference forms are supported",
+    },
+    {
+        id: "node-builtin.perf_hooks.monitorEventLoopDelay",
+        kind: "node-builtin",
+        name: "perf_hooks.monitorEventLoopDelay",
+        fns: [
+            "perf.eldNew",
+            "perf.eldEnable",
+            "perf.eldDisable",
+            "perf.eldReset",
+            "perf.eldPercentile",
+            "perf.eldStat",
+        ],
+        note: "an unref'd sampling interval records the delay histogram; enable, disable, reset, percentile and the min, max, mean, stddev, count and exceeds readings are supported",
+    },
     // ── the process global's ambient reads and authority calls
     // (lowerProcessProperty/lowerProcessMethodCall — process is a
     // provenance-checked global here, not an importable module).
@@ -2246,6 +2422,12 @@ export const AMBIENT_SURFACE_FNS = [
         name: "process.argv0",
         fns: ["process.argv0"],
     },
+    {
+        id: "node-builtin.process.execArgv",
+        kind: "node-builtin",
+        name: "process.execArgv",
+        fns: ["process.execArgv"],
+    },
     {
         id: "node-builtin.process.execPath",
         kind: "node-builtin",
@@ -2354,8 +2536,8 @@ export const AMBIENT_SURFACE_FNS = [
         id: "node-builtin.process.exitCode",
         kind: "node-builtin",
         name: "process.exitCode",
-        fns: ["process.setExitCode"],
-        note: "numeric writes in statement position set the implicit exit status; process.exit() reads it",
+        fns: ["process.setExitCode", "process.setExitCodeTracked", "process.hasExitCode"],
+        note: "numeric writes in statement position set the implicit exit status; reads answer the assigned code or undefined; process.exit() reads it",
     },
     // ── the tls CA store (lowerTlsCaCall / lowerTlsRootCertificates): the
     // host's trust anchors, read and replaced. Dedicated paths, and
@@ -2395,6 +2577,15 @@ export const AMBIENT_SURFACE_FNS = [
         fns: ["os.constants"],
         note: "the platform's dlopen, errno, signals and priority groups; members a platform lacks read as undefined",
     },
+    // fs.constants as a value, and its members beyond the baked access-mode
+    // bits: the target libc's null-prototype constants object.
+    {
+        id: "node-builtin.fs.constants",
+        kind: "node-builtin",
+        name: "fs.constants",
+        fns: ["fs.constants"],
+        note: "node_constants.cc's fs group under the target libc's macros; members a platform lacks read as undefined",
+    },
 ];
 /** The win32-target overrides of the bare modules' constants: path's
  * constants ARE the path/win32 namespace's, and os.EOL is CRLF (Node's
@@ -2477,7 +2668,11 @@ export const FS_CALLBACK_MEMBERS = new Set([
  * inherited function into the diagnostic text). */
 export function builtinFenceHintOf(module, member) {
     const mod = ownEntry(BUILTIN_MODULE_FENCE_HINTS, module);
-    return mod ? ownEntry(mod, member) : undefined;
+    const hint = mod ? ownEntry(mod, member) : undefined;
+    // node:v8's unlowered members observe the engine itself: the by-design
+    // reason, not a pending-surface hint (kept out of the hint table so the
+    // compatibility rows stay by-design rather than refused).
+    return hint === undefined && module === "v8" ? V8_MEMBER_REASON : hint;
 }
 /** BUILTIN_MODULE_CONSTS with the win32-target overrides applied — the
  * constants twin of builtinModuleFnsOf. */
@@ -2624,7 +2819,7 @@ export const BUILTIN_MODULE_FENCE_HINTS = {
         doesNotReject: ASSERT_MODULE_HINTS["doesNotReject"],
     },
     util: {
-        promisify: "the lowered shapes are const bindings over child_process.execFile, child_process.exec, setTimeout, setImmediate, stream.finished, stream.pipeline, the zlib callback one-shots and the fs callback functions with an fs/promises counterpart; call the bound function directly",
+        promisify: "the lowered shapes are const bindings over child_process.execFile, child_process.exec, setTimeout, setImmediate, stream.finished, stream.pipeline, the zlib callback one-shots, the crypto callback functions, dns.lookup, dns.lookupService and the fs callback functions with an fs/promises counterpart, plus typed callback-last function values whose callback takes (error?: Error | null, value?); call the bound function directly",
     },
     "stream/consumers": {
         blob: "collecting a stream into a Blob is not supported yet — " +
@@ -2636,7 +2831,7 @@ export const BUILTIN_MODULE_FENCE_HINTS = {
             "relative .json documents and natively compiled npm packages resolve at build time; " +
             "dynamic specifiers cannot exist in a compiled binary's fixed module graph",
         isBuiltin: "the lowered call checks a string against the baked Node v24 list, including bare/node: aliases and prefix-only builtins",
-        syncBuiltinESMExports: "the direct zero-argument call is a no-op because compiled builtin exports are immutable and cannot become stale",
+        syncBuiltinESMExports: "the direct zero-argument call statement refreshes the ES module namespace copy of events.defaultMaxListeners, the one builtin export a program can change",
     },
     child_process: {
         execFile: "the callback forms execFile(file, callback), execFile(file, args, callback), and execFile(file, args, { encoding: 'utf8', maxBuffer: N }, callback) lower; " +
@@ -2655,7 +2850,6 @@ export const BUILTIN_MODULE_FENCE_HINTS = {
             "createDiffieHellman",
             "createDiffieHellmanGroup",
             "getDiffieHellman",
-            "createECDH",
             "diffieHellman",
             "publicEncrypt",
             "publicDecrypt",
@@ -2754,8 +2948,8 @@ export function stdlibMemberFence(lowerer, access) {
     }
     else if (container === "Math" && (member === "min" || member === "max")) {
         hint =
-            `Math.${member} lowers with any number of plain arguments or ONE number[] spread — ` +
-                `mixed spread/positional lists don't: spread a single array (Math.${member}(...xs))`;
+            `Math.${member} lowers with number arguments and spreads of number[] values ` +
+                `(Math.${member}(...xs, y))`;
     }
     else if (recvIr?.kind === "array" &&
         member === "index" &&
@@ -2771,8 +2965,8 @@ export function stdlibMemberFence(lowerer, access) {
         hint =
             "'.groups' lowers when the match's regex is STATICALLY known — a regex literal, or a " +
                 "const initialized with one (the group-name table is built at compile time) — and the " +
-                "read is not an optional-chain step: narrow the match instead (if (m) { m.groups } or " +
-                "m!.groups)";
+                "match comes from exec, match, a for-of over matchAll, or the element parameter of an " +
+                "array-method callback over matchAll rows";
     }
     else if (recvIr?.kind === "array" && member === "flat") {
         hint =
@@ -2901,11 +3095,11 @@ export function isChildSurfaceMember(lowerer, access) {
     if (isStdlibMember(lowerer, access))
         return true;
     const sym = lowerer.checker.getSymbolAtLocation(access.name);
-    const decl = sym ? lowerer.checker.declarationsOf(sym)[0] : undefined;
+    const decl = sym ? sym.declarations[0] : undefined;
     const iface = decl?.parent;
     if (!decl || !iface || !ts.isInterfaceDeclaration(iface))
         return false;
-    if (lowerer.isStdlibFile(decl.getSourceFile()))
+    if (lowerer.isStdlibFile(ts.getSourceFileOfNode(decl)))
         return false;
     return lowerer.mapTypeOf(lowerer.checker.getTypeAtLocation(iface.name))?.kind === "child";
 }
@@ -2915,8 +3109,7 @@ export function isChildSurfaceMember(lowerer, access) {
  * with lib interfaces, so a member can carry declarations from both. A
  * user's own declaration is in neither, so shadowing never matches. */
 export function isStdlibSymbol(lowerer, symbol) {
-    return (!!symbol &&
-        lowerer.checker.declarationsOf(symbol).some((d) => lowerer.isStdlibFile(d.getSourceFile())));
+    return (!!symbol && symbol.declarations.some((d) => lowerer.isStdlibFile(ts.getSourceFileOfNode(d))));
 }
 /** The canonical stdlib-global name `expr` denotes, or null. Three
  * spellings reach the same global (Node's own aliasing):
@@ -2929,26 +3122,38 @@ export function isStdlibSymbol(lowerer, symbol) {
  *     `global.process`) — `declare var` globals ARE properties of
  *     `typeof globalThis`, same symbol either way;
  *   - a local alias binding (`const process = globalThis.process`, the
- *     tamper-guard prologue) registered in stdlibGlobalAliases. */
+ *     tamper-guard prologue) registered in stdlibGlobalAliases;
+ *   - a const binding of the Map or Set constructor (`const M = Map`,
+ *     builtinClassAliasOf). */
 export function stdlibGlobalNameOf(lowerer, expr) {
     if (ts.isParenthesizedExpression(expr))
         return stdlibGlobalNameOf(lowerer, expr.expression);
+    // The global-object detection chain (`typeof global < "u" ? global :
+    // typeof window < "u" ? window : {}`): a condition with static typeof
+    // answers selects one arm, and only that arm ever evaluates.
+    if (ts.isConditionalExpression(expr)) {
+        const taken = staticCondition(lowerer, expr.condition);
+        if (taken === null)
+            return null;
+        return stdlibGlobalNameOf(lowerer, taken ? expr.whenTrue : expr.whenFalse);
+    }
     if (ts.isIdentifier(expr)) {
         const symbol = lowerer.checker.getSymbolAtLocation(expr);
         // `globalThis` itself: a reserved intrinsic — tsc rejects user
         // global bindings, but local parameters can shadow it. Its special
         // symbol has no ordinary declarations for the provenance check.
         if (expr.text === "globalThis" &&
-            (!symbol ||
-                lowerer.checker.declarationsOf(symbol).length === 0 ||
-                lowerer.isStdlibSymbol(symbol)))
+            (!symbol || symbol.declarations.length === 0 || lowerer.isStdlibSymbol(symbol)))
             return "globalThis";
         if (!symbol)
             return null;
         const alias = lowerer.stdlibGlobalAliases.get(symbol);
         if (alias !== undefined)
             return alias;
-        const decl = lowerer.checker.declarationsOf(symbol)[0];
+        const classAlias = lowerer.builtinClassAliasOf(symbol);
+        if (classAlias?.kind === "collection")
+            return classAlias.which;
+        const decl = symbol.declarations[0];
         if (decl !== undefined && ts.isImportClause(decl) && decl.name !== undefined) {
             const importDecl = decl.parent;
             if (ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
@@ -2964,17 +3169,35 @@ export function stdlibGlobalNameOf(lowerer, expr) {
         // the bare-global spelling. A user module re-exporting its own
         // `Buffer` resolves to a user-file declaration and still misses.
         const resolved = symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol;
-        if (!lowerer.isStdlibSymbol(resolved))
+        if (!lowerer.isStdlibSymbol(resolved)) {
+            // A CommonJS binding of the buffer module's Buffer (`var Buffer =
+            // require('buffer').Buffer`, `const { Buffer } = require('buffer')`
+            // — safe-buffer and compression): the module member IS the global
+            // constructor.
+            if (decl !== undefined &&
+                (ts.isVariableDeclaration(decl) || ts.isBindingElement(decl)) &&
+                isJsSourceFile(ts.getSourceFileOfNode(decl))) {
+                const imported = lowerer.builtinImportOf(expr);
+                if (imported?.module === "buffer" && imported.member === "Buffer")
+                    return "Buffer";
+            }
             return null;
-        return resolved.name === "global" ? "globalThis" : resolved.name;
+        }
+        return ts.symbolName(resolved) === "global" ? "globalThis" : ts.symbolName(resolved);
     }
     if (ts.isPropertyAccessExpression(expr) && !expr.questionDotToken) {
         if (stdlibGlobalNameOf(lowerer, expr.expression) !== "globalThis")
             return null;
-        const symbol = lowerer.checker.getSymbolAtLocation(expr.name);
+        // Through a detection chain the checker types the receiver as the
+        // union of every arm; the selected arm (the global object) owns the
+        // member.
+        const selected = staticallySelected(lowerer, expr.expression);
+        const symbol = selected === expr.expression || ts.isIdentifier(unparenthesized(expr.expression))
+            ? lowerer.checker.getSymbolAtLocation(expr.name)
+            : lowerer.checker.getPropertyOfType(lowerer.typeOf(selected), expr.name.text);
         if (!symbol || !lowerer.isStdlibSymbol(symbol))
             return null;
-        return symbol.name === "global" ? "globalThis" : symbol.name;
+        return ts.symbolName(symbol) === "global" ? "globalThis" : ts.symbolName(symbol);
     }
     return null;
 }
@@ -3032,7 +3255,9 @@ export function stdlibGlobalAliasNameOf(lowerer, init) {
     const requireSpec = requireSpecOf(aliasExpr);
     const name = requireSpec === "process" || requireSpec === "node:process"
         ? "process"
-        : stdlibGlobalNameOf(lowerer, aliasExpr);
+        : bufferNamespaceMember(lowerer, aliasExpr)
+            ? "Buffer"
+            : stdlibGlobalNameOf(lowerer, aliasExpr);
     if (name === null)
         return null;
     // These globals have provenance-aware call or member lowering, so a
@@ -3049,10 +3274,22 @@ export function stdlibGlobalAliasNameOf(lowerer, init) {
         "Number",
         "String",
         "Boolean",
+        // Code generation from strings throws Node's EvalError at every call
+        // (code-generation.ts); zod 4 probes `const F = Function; new F("")`.
+        "Function",
+        "eval",
     ].includes(name)
         ? name
         : null;
 }
+/** `buffer.Buffer` through a buffer-module namespace binding (`var buffer
+ * = require('buffer')`): the module's Buffer IS the global constructor. */
+export function bufferNamespaceMember(lowerer, expr) {
+    if (!ts.isPropertyAccessExpression(expr) || expr.name.text !== "Buffer")
+        return false;
+    const member = lowerer.builtinMemberOf(expr);
+    return member?.module === "buffer" && member.member === "Buffer";
+}
 export function stdlibGlobalAliasDecl(lowerer, nameNode, init) {
     if (!ts.isIdentifier(nameNode))
         return false;
@@ -3076,12 +3313,12 @@ export function stdlibGlobalAliasDecl(lowerer, nameNode, init) {
  * the SC2020 fence's wording: "typed by @types/node", not "standard
  * library". */
 export function nodeTypesOnlySymbol(lowerer, sym) {
-    const decls = sym ? lowerer.checker.declarationsOf(sym) : undefined;
+    const decls = sym ? sym.declarations : undefined;
     if (!decls || decls.length === 0)
         return false;
     let viaNode = false;
     for (const d of decls) {
-        const sf = d.getSourceFile();
+        const sf = ts.getSourceFileOfNode(d);
         if (sf.isDeclarationFile && isNodeTypesPath(sf.fileName))
             viaNode = true;
         else if (lowerer.isStdlibFile(sf))