@scriptc/compiler 0.2.4 → 0.2.5

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

@@ -1,3 +1,4 @@
+import { dynUndefinedExpr, nodeThrowExpr, boolLit, numLit, strLit, varRef, } from "../../ir/build.js";
 /* The server-surface lowering (node:net + node:http — the spoke-module
  * pattern, like lower-island.ts): module-function calls (net
  * createServer/connect/createConnection, http createServer/request/get —
@@ -9,27 +10,32 @@
  * beyond these shapes fences member-qualified — never a generic
  * rejection, never silence. */
 import * as ts from "../ts7/adapter.js";
-import { ladderFenceExpr, nodeThrowExpr } from "./lowerer.js";
+import { ladderFenceExpr } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
-import { arrayOf, BOOL, BYTES_U8, canBoxFuncIntoDyn, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, funcOf, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, NETSERVER_T, NETSOCKET_T, NULL_T, SECURECTX_T, STRING, UNDEFINED_T, typeKey, VOID } from "../../ir/ir.js";
+import { arrayOf, BOOL, BYTES_U8, canBoxFuncIntoDyn, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, funcOf, HTTP2SESSION_T, HTTP2STREAM_T, HTTPCLIENTREQ_T, HTTPREQ_T, HTTPRES_T, NETSERVER_T, NETSOCKET_T, NULL_T, SECURECTX_T, STRING, UNDEFINED_T, typeKey, VOID, } from "../../ir/ir.js";
 import { AGENT_DOCUMENTED_OPTIONS, builtinFenceHintOf, builtinModuleFnOf, fenceOrDropOptionKey, HTTP_CLIENT_DOCUMENTED_OPTIONS, HTTP_SERVER_DOCUMENTED_OPTIONS, HTTP2_SECURE_SERVER_DOCUMENTED_OPTIONS, HTTPS_CLIENT_DOCUMENTED_OPTIONS, sideEffectFreeOptionValue, TLS_SERVER_DOCUMENTED_OPTIONS, } from "./surfaces.js";
 import { conditionalSpreadOf } from "./expressions/object-literals.js";
-import { boolLit, numLit, strLit, varRef } from "../../ir/build.js";
 import { resultIsDiscarded } from "./call-position.js";
 import { lowerCallbackArg as lowerCallbackArgShared } from "./callback-arg.js";
 import { pairsSnapshotHelper } from "./pairs-snapshot.js";
-const NARROW_DATA_HINT = 'write/end take one string or one Uint8Array/Buffer value (narrow unions first)';
+const NARROW_DATA_HINT = "write/end take one string or one Uint8Array/Buffer value (narrow unions first)";
 /** The writable numeric http.Server timeout fields. The selector is an
  * internal runtime ABI shared by the get/set libCalls (kept here beside
  * the only two construction/lowering paths that can mint the accesses). */
 function httpServerTimeoutField(name) {
     switch (name) {
-        case "timeout": return 0;
-        case "keepAliveTimeout": return 1;
-        case "headersTimeout": return 2;
-        case "requestTimeout": return 3;
-        case "keepAliveTimeoutBuffer": return 4;
-        default: return null;
+        case "timeout":
+            return 0;
+        case "keepAliveTimeout":
+            return 1;
+        case "headersTimeout":
+            return 2;
+        case "requestTimeout":
+            return 3;
+        case "keepAliveTimeoutBuffer":
+            return 4;
+        default:
+            return null;
     }
 }
 /** VOID-result server/socket calls are usable as statements and as concise
@@ -168,7 +174,12 @@ export function voidizedCallback(lowerer, cb, loc) {
                     expr: {
                         kind: "callValue",
                         callee: { kind: "varRef", localId: "f.0", type: fromT, loc },
-                        args: params.map((p) => ({ kind: "varRef", localId: p.localId, type: p.type, loc })),
+                        args: params.map((p) => ({
+                            kind: "varRef",
+                            localId: p.localId,
+                            type: p.type,
+                            loc,
+                        })),
                         type: fromT.ret,
                         loc,
                     },
@@ -182,7 +193,13 @@ export function voidizedCallback(lowerer, cb, loc) {
             params: [{ localId: "f.0", name: "f", type: fromT }],
             returnType: toT,
             locals: [{ id: "f.0", name: "f", type: fromT, mutable: false, boxed: true }],
-            body: [{ kind: "return", value: { kind: "closure", fnName: impl, captures: ["f.0"], type: toT, loc }, loc }],
+            body: [
+                {
+                    kind: "return",
+                    value: { kind: "closure", fnName: impl, captures: ["f.0"], type: toT, loc },
+                    loc,
+                },
+            ],
             loc,
         });
     }
@@ -268,7 +285,11 @@ function isAddressInfoRecord(lowerer, t) {
     const shape = lowerer.shapes.get(t.shapeId);
     if (!shape || shape.tuple || shape.indexValue || shape.fields.length !== 3)
         return false;
-    const want = [["address", "string"], ["family", "string"], ["port", "f64"]];
+    const want = [
+        ["address", "string"],
+        ["family", "string"],
+        ["port", "f64"],
+    ];
     return shape.fields.every((f, i) => f.name === want[i][0] && f.type.kind === want[i][1]);
 }
 function coerceToHandle(lowerer, node, want) {
@@ -301,25 +322,74 @@ function h2HeaderRecordStmts(lowerer, shapeId, pairsLocal, outLocal, statusLocal
     const pairAt = (offset) => ({
         kind: "arrayGet",
         arr: varRef(pairsLocal, pairsT, loc),
-        index: offset === 0 ? varRef("i.0", F64, loc) : { kind: "bin", op: "+", left: varRef("i.0", F64, loc), right: numLit(offset, loc), type: F64, loc },
+        index: offset === 0
+            ? varRef("i.0", F64, loc)
+            : {
+                kind: "bin",
+                op: "+",
+                left: varRef("i.0", F64, loc),
+                right: numLit(offset, loc),
+                type: F64,
+                loc,
+            },
         type: STRING,
         loc,
     });
     const stmts = [
-        { kind: "varDecl", localId: outLocal, init: { kind: "recordLit", fields: [], type: recT, loc }, loc },
+        {
+            kind: "varDecl",
+            localId: outLocal,
+            init: { kind: "recordLit", fields: [], type: recT, loc },
+            loc,
+        },
         {
             kind: "for",
             init: { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
             cond: {
-                kind: "bin", op: "<", left: varRef("i.0", F64, loc),
-                right: { kind: "arrIntrinsic", method: "length", receiver: varRef(pairsLocal, pairsT, loc), args: [], type: F64, loc },
-                type: BOOL, loc,
+                kind: "bin",
+                op: "<",
+                left: varRef("i.0", F64, loc),
+                right: {
+                    kind: "arrIntrinsic",
+                    method: "length",
+                    receiver: varRef(pairsLocal, pairsT, loc),
+                    args: [],
+                    type: F64,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            },
+            update: {
+                kind: "assign",
+                localId: "i.0",
+                value: {
+                    kind: "bin",
+                    op: "+",
+                    left: varRef("i.0", F64, loc),
+                    right: numLit(2, loc),
+                    type: F64,
+                    loc,
+                },
+                loc,
             },
-            update: { kind: "assign", localId: "i.0", value: { kind: "bin", op: "+", left: varRef("i.0", F64, loc), right: numLit(2, loc), type: F64, loc }, loc },
-            body: [{
-                    kind: "recordKeySet", obj: varRef(outLocal, recT, loc), shapeId, key: pairAt(0),
-                    value: { kind: "unionWrap", unionId: iv.unionId, tag: strTag, value: pairAt(1), type: iv, loc }, loc,
-                }],
+            body: [
+                {
+                    kind: "recordKeySet",
+                    obj: varRef(outLocal, recT, loc),
+                    shapeId,
+                    key: pairAt(0),
+                    value: {
+                        kind: "unionWrap",
+                        unionId: iv.unionId,
+                        tag: strTag,
+                        value: pairAt(1),
+                        type: iv,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
             loc,
         },
     ];
@@ -328,9 +398,19 @@ function h2HeaderRecordStmts(lowerer, shapeId, pairsLocal, outLocal, statusLocal
         if (f64Tag < 0)
             return null;
         stmts.push({
-            kind: "recordKeySet", obj: varRef(outLocal, recT, loc), shapeId,
+            kind: "recordKeySet",
+            obj: varRef(outLocal, recT, loc),
+            shapeId,
             key: { kind: "strLit", value: ":status", type: STRING, loc },
-            value: { kind: "unionWrap", unionId: iv.unionId, tag: f64Tag, value: varRef(statusLocal, F64, loc), type: iv, loc }, loc,
+            value: {
+                kind: "unionWrap",
+                unionId: iv.unionId,
+                tag: f64Tag,
+                value: varRef(statusLocal, F64, loc),
+                type: iv,
+                loc,
+            },
+            loc,
         });
     }
     return stmts;
@@ -365,7 +445,7 @@ function canonicalHeaderRecord(lowerer) {
 }
 function h2HeadersCallbackAdapter(lowerer, node, what, handleKind, withStatus, loc) {
     let cb = lowerer.lowerExpr(node);
-    const maxParams = (handleKind ? 1 : 0) + 1 /* headers */ + 1 /* flags */;
+    const maxParams = (handleKind ? 1 : 0) + 1 /* headers */ + 1; /* flags */
     // A checked-dynamic listener (test/common's mustCall wrapper — a dyn
     // value or an arguments-reading rest function of dyn params): wrap it
     // in a dynCheck to the CANONICAL event signature, then build the header
@@ -374,7 +454,8 @@ function h2HeadersCallbackAdapter(lowerer, node, what, handleKind, withStatus, l
     // precedent). The synthesized record IS the shape the adapter builds.
     const handleT = handleKind === "http2Stream" ? HTTP2STREAM_T : null;
     const isDynCb = cb.type.kind === "dyn" ||
-        (cb.type.kind === "func" && (cb.type.rest === true || cb.type.params.every((p) => p.kind === "dyn")) &&
+        (cb.type.kind === "func" &&
+            (cb.type.rest === true || cb.type.params.every((p) => p.kind === "dyn")) &&
             canBoxFuncIntoDyn(cb.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)));
     if (isDynCb) {
         const rec = canonicalHeaderRecord(lowerer);
@@ -428,8 +509,10 @@ function h2HeadersCallbackAdapter(lowerer, node, what, handleKind, withStatus, l
         }
         // Assemble the user-call arguments in the user's declared order.
         const callArgs = [];
-        const push = (e) => { if (callArgs.length < fromT.params.length)
-            callArgs.push(e); };
+        const push = (e) => {
+            if (callArgs.length < fromT.params.length)
+                callArgs.push(e);
+        };
         if (handleT)
             push(varRef("h.0", handleT, loc));
         if (recordRef)
@@ -439,14 +522,37 @@ function h2HeadersCallbackAdapter(lowerer, node, what, handleKind, withStatus, l
         push(varRef("fl.0", F64, loc));
         body.push({
             kind: "exprStmt",
-            expr: { kind: "callValue", callee: varRef("f.0", fromT, loc), args: callArgs.slice(0, fromT.params.length), type: fromT.ret, loc },
+            expr: {
+                kind: "callValue",
+                callee: varRef("f.0", fromT, loc),
+                args: callArgs.slice(0, fromT.params.length),
+                type: fromT.ret,
+                loc,
+            },
             loc,
         });
-        lowerer.liftedFns.push({ name: impl, params: abiParams, returnType: VOID, captures: [{ localId: "f.0", name: "f", type: fromT }], locals, body, loc });
         lowerer.liftedFns.push({
-            name, params: [{ localId: "f.0", name: "f", type: fromT }], returnType: toT,
+            name: impl,
+            params: abiParams,
+            returnType: VOID,
+            captures: [{ localId: "f.0", name: "f", type: fromT }],
+            locals,
+            body,
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "f.0", name: "f", type: fromT }],
+            returnType: toT,
             locals: [{ id: "f.0", name: "f", type: fromT, mutable: false, boxed: true }],
-            body: [{ kind: "return", value: { kind: "closure", fnName: impl, captures: ["f.0"], type: toT, loc }, loc }], loc,
+            body: [
+                {
+                    kind: "return",
+                    value: { kind: "closure", fnName: impl, captures: ["f.0"], type: toT, loc },
+                    loc,
+                },
+            ],
+            loc,
         });
     }
     return { kind: "call", callee: name, args: [cb], type: toT, loc };
@@ -552,7 +658,10 @@ export function lowerNetModuleCall(lowerer, expr, bi, loc) {
                     return {
                         kind: "libCall",
                         fn: "net.connectOptsChk",
-                        args: [bag, ladderFenceExpr(lowerer, `${bi.member} with a runtime options record`, expr, "pass the options as an object literal — port, host, autoSelectFamily, autoSelectFamilyAttemptTimeout, and lookup are the supported options")],
+                        args: [
+                            bag,
+                            ladderFenceExpr(lowerer, `${bi.member} with a runtime options record`, expr, "pass the options as an object literal — port, host, autoSelectFamily, autoSelectFamilyAttemptTimeout, and lookup are the supported options"),
+                        ],
                         type: NETSOCKET_T,
                         loc,
                     };
@@ -642,7 +751,9 @@ function lowerNetConnectOptions(lowerer, expr, member, loc) {
         const needsBag = optsNode.properties.some((p) => (!ts.isPropertyAssignment(p) && !ts.isShorthandPropertyAssignment(p)) ||
             (ts.isPropertyAssignment(p) && ts.isComputedPropertyName(p.name)) ||
             ["objectMode", "readableObjectMode", "writableObjectMode"].includes((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
-                (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? p.name.text : ""));
+                (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))
+                ? p.name.text
+                : ""));
         if (needsBag) {
             const raw = lowerer.lowerExpr(optsNode);
             if (raw.type.kind === "dyn" || lowerer.dynConvertible(raw.type)) {
@@ -650,7 +761,10 @@ function lowerNetConnectOptions(lowerer, expr, member, loc) {
                 return {
                     kind: "libCall",
                     fn: "net.connectOptsChk",
-                    args: [bag, ladderFenceExpr(lowerer, `${member} with these options`, optsNode, "port, host, autoSelectFamily, autoSelectFamilyAttemptTimeout, and lookup are the supported options")],
+                    args: [
+                        bag,
+                        ladderFenceExpr(lowerer, `${member} with these options`, optsNode, "port, host, autoSelectFamily, autoSelectFamilyAttemptTimeout, and lookup are the supported options"),
+                    ],
                     type: NETSOCKET_T,
                     loc,
                 };
@@ -717,7 +831,8 @@ function lowerNetConnectOptions(lowerer, expr, member, loc) {
                 // A provably-non-boolean value throws Node's validateBoolean
                 // ladder instead of fencing.
                 const raw = initializer !== null && isJs ? lowerer.lowerExpr(initializer) : null;
-                if (raw !== null && raw.type.kind !== "bool" &&
+                if (raw !== null &&
+                    raw.type.kind !== "bool" &&
                     (raw.type.kind === "dyn" || lowerer.dynConvertible(raw.type))) {
                     optionThrow ??= propThrow("options.autoSelectFamily", "of type boolean", raw);
                     continue;
@@ -762,7 +877,13 @@ function lowerNetConnectOptions(lowerer, expr, member, loc) {
         if (lookup !== null || args.length !== 1) {
             lowerer.noLowering(`${member} with an autoSelectFamilyAttemptTimeout beside a lookup or connect listener`, expr, "the validated-budget form is the bare options call — register listeners separately");
         }
-        return { kind: "libCall", fn: "net.connectAttempt", args: [port, host, attempt], type: NETSOCKET_T, loc };
+        return {
+            kind: "libCall",
+            fn: "net.connectAttempt",
+            args: [port, host, attempt],
+            type: NETSOCKET_T,
+            loc,
+        };
     }
     if (lookup !== null) {
         if (!autoSelect) {
@@ -771,7 +892,13 @@ function lowerNetConnectOptions(lowerer, expr, member, loc) {
         if (args.length !== 1) {
             lowerer.noLowering(`${member} with a lookup and a connect listener`, expr, "register the listener separately: socket.once('connect', ...)");
         }
-        return { kind: "libCall", fn: "net.connectLookup", args: [port, host, lookup], type: NETSOCKET_T, loc };
+        return {
+            kind: "libCall",
+            fn: "net.connectLookup",
+            args: [port, host, lookup],
+            type: NETSOCKET_T,
+            loc,
+        };
     }
     if (args.length === 1) {
         return { kind: "libCall", fn: "net.connect", args: [port, host], type: NETSOCKET_T, loc };
@@ -849,7 +976,8 @@ export function lowerServerCloseOverrideAssignment(lowerer, left, right, loc) {
     const t = value.type;
     const cbUnion = t.kind === "func" && t.params.length === 1 ? t.params[0] : null;
     const shapeOk = cbUnion?.kind === "union" &&
-        (t.kind === "func" && (t.ret.kind === "netServer" || t.ret.kind === "void")) &&
+        t.kind === "func" &&
+        (t.ret.kind === "netServer" || t.ret.kind === "void") &&
         (() => {
             const def = lowerer.unions.get(cbUnion.unionId);
             return (!!def &&
@@ -861,7 +989,13 @@ export function lowerServerCloseOverrideAssignment(lowerer, left, right, loc) {
     }
     return {
         kind: "exprStmt",
-        expr: { kind: "libCall", fn: "net.serverSetCloseOverride", args: [server, value], type: VOID, loc },
+        expr: {
+            kind: "libCall",
+            fn: "net.serverSetCloseOverride",
+            args: [server, value],
+            type: VOID,
+            loc,
+        },
         loc,
     };
 }
@@ -871,8 +1005,10 @@ export function lowerHttpResPropertyAssignment(lowerer, left, right, loc) {
     if (!ts.isPropertyAccessExpression(left) || left.questionDotToken)
         return null;
     const name = left.name.text;
-    if (name !== "statusCode" && name !== "statusMessage" &&
-        name !== "sendDate" && name !== "strictContentLength")
+    if (name !== "statusCode" &&
+        name !== "statusMessage" &&
+        name !== "sendDate" &&
+        name !== "strictContentLength")
         return null;
     if (lowerer.mapTypeOf(lowerer.typeOf(left.expression))?.kind !== "httpRes")
         return null;
@@ -882,9 +1018,13 @@ export function lowerHttpResPropertyAssignment(lowerer, left, right, loc) {
     const value = name === "statusCode"
         ? lowerer.lowerExprExpecting(right, F64)
         : lowerer.lowerExprExpecting(right, name === "statusMessage" ? STRING : BOOL);
-    const fn = name === "statusCode" ? "http.resStatusSet"
-        : name === "statusMessage" ? "http.resStatusMsgSet"
-            : name === "sendDate" ? "http.resSendDateSet" : "http.resStrictContentLengthSet";
+    const fn = name === "statusCode"
+        ? "http.resStatusSet"
+        : name === "statusMessage"
+            ? "http.resStatusMsgSet"
+            : name === "sendDate"
+                ? "http.resSendDateSet"
+                : "http.resStrictContentLengthSet";
     return {
         kind: "exprStmt",
         expr: { kind: "libCall", fn, args: [receiver, value], type: VOID, loc },
@@ -910,7 +1050,13 @@ export function lowerHttpServerTimeoutAssignment(lowerer, left, right, loc) {
     const value = lowerer.lowerExprExpecting(right, F64);
     return {
         kind: "exprStmt",
-        expr: { kind: "libCall", fn: "http.serverTimeoutSet", args: [receiver, selector, value], type: VOID, loc },
+        expr: {
+            kind: "libCall",
+            fn: "http.serverTimeoutSet",
+            args: [receiver, selector, value],
+            type: VOID,
+            loc,
+        },
         loc,
     };
 }
@@ -944,7 +1090,9 @@ function lowerNetServerMethodCall(lowerer, call, access) {
         if (args.length !== 0)
             lowerer.noLowering(`server.${name} arguments`, call, `${name}() takes no arguments`);
         const receiver = coerceToHandle(lowerer, access.expression, NETSERVER_T);
-        const fn = name === "closeAllConnections" ? "http.serverCloseAllConnections" : "http.serverCloseIdleConnections";
+        const fn = name === "closeAllConnections"
+            ? "http.serverCloseAllConnections"
+            : "http.serverCloseIdleConnections";
         return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
     }
     if (name === "listen") {
@@ -990,24 +1138,27 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                 }
                 const key = prop.name.text;
                 if (key === "port") {
-                    port = initializer !== null
-                        ? lowerer.lowerExpr(initializer)
-                        : lowerer.lowerShorthandValue(prop);
+                    port =
+                        initializer !== null
+                            ? lowerer.lowerExpr(initializer)
+                            : lowerer.lowerShorthandValue(prop);
                     if (port.type.kind !== "f64") {
                         lowerer.noLowering(`a listen 'port' option of '${lowerer.fmt(port.type)}' values`, prop, "the port is a number here");
                     }
                 }
                 else if (key === "host") {
-                    host = initializer !== null
-                        ? lowerer.lowerExpr(initializer)
-                        : lowerer.lowerShorthandValue(prop);
+                    host =
+                        initializer !== null
+                            ? lowerer.lowerExpr(initializer)
+                            : lowerer.lowerShorthandValue(prop);
                     if (host.type.kind !== "string") {
                         lowerer.noLowering(`a listen 'host' option of '${lowerer.fmt(host.type)}' values`, prop, "the host is an IP string here");
                     }
                 }
                 else if (key === "ipv6Only") {
                     if (initializer !== null) {
-                        v6only = lowerer.lowerCondition(initializer); /* truthiness: `boolean | undefined` flows */
+                        v6only =
+                            lowerer.lowerCondition(initializer); /* truthiness: `boolean | undefined` flows */
                     }
                     else {
                         const v = lowerer.lowerShorthandValue(prop);
@@ -1029,15 +1180,19 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                         reusePort = v;
                     }
                 }
-                else if (key === "signal" && ts.isPropertyAssignment(prop) &&
+                else if (key === "signal" &&
+                    ts.isPropertyAssignment(prop) &&
                     isJsSourceFile(call.getSourceFile())) {
                     // A provably-non-AbortSignal signal (the invalid-input probes:
                     // strings, numbers, plain records) throws Node's
                     // validateAbortSignal ladder; plausible signal values keep the
                     // fence — abort-driven close has no lowering yet.
                     const raw = lowerer.lowerExpr(prop.initializer);
-                    const provablyNot = raw.type.kind === "string" || raw.type.kind === "f64" ||
-                        raw.type.kind === "bool" || raw.type.kind === "record" || raw.type.kind === "array";
+                    const provablyNot = raw.type.kind === "string" ||
+                        raw.type.kind === "f64" ||
+                        raw.type.kind === "bool" ||
+                        raw.type.kind === "record" ||
+                        raw.type.kind === "array";
                     if (provablyNot && lowerer.dynConvertible(raw.type)) {
                         return {
                             kind: "libCall",
@@ -1060,7 +1215,12 @@ function lowerNetServerMethodCall(lowerer, call, access) {
             if (port === null) {
                 lowerer.noLowering("listen options without a port", args[0], "the supported options object is { port, host?, ipv6Only?, reusePort? } — port 0 binds an ephemeral port");
             }
-            host ??= { kind: "strLit", value: "", type: STRING, loc }; /* "" = the dual-stack any default */
+            host ??= {
+                kind: "strLit",
+                value: "",
+                type: STRING,
+                loc,
+            }; /* "" = the dual-stack any default */
             v6only ??= boolLit(false, loc);
             const listenOptsFn = reusePort === null ? "net.listenOpts" : "net.listenOptsReusePort";
             const listenOptsCbFn = reusePort === null ? "net.listenOptsCb" : "net.listenOptsReusePortCb";
@@ -1157,22 +1317,46 @@ function lowerNetServerMethodCall(lowerer, call, access) {
         }
         if (event === "error") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "error listeners", 1, (p) => p.kind === "object" && p.className === "%Error", "use (err) or ()", [ERROR_T]);
-            return { kind: "libCall", fn: "net.serverOnError", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "net.serverOnError",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "close") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "net.serverOnClose", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "net.serverOnClose",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "timeout") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "timeout listeners", 1, (p) => p.kind === "netSocket", "use (socket) or ()", [NETSOCKET_T]);
-            return { kind: "libCall", fn: "http.serverOnTimeout", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.serverOnTimeout",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "listening") {
             // The deferred bind emit — listen(port, cb)'s event twin: fires
             // once after a successful listen; late registrations on an
             // already-listening server never fire (Node's once-per-listen).
             const { cb } = lowerCallbackArg(lowerer, args[1], "listening listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "net.serverOnListening", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "net.serverOnListening",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "request") {
             // The 'request' event — http.createServer(handler)'s event twin, and
@@ -1181,20 +1365,38 @@ function lowerNetServerMethodCall(lowerer, call, access) {
             // server with no HTTP parser (net.createServer) the registration is
             // Node-honest dead weight: the event never fires there either.
             const cb = lowerRequestHandlerArg(lowerer, args[1]);
-            return { kind: "libCall", fn: "http.serverOnRequest", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.serverOnRequest",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "stream") {
             // The h2c server's request event: (stream, headers, flags). The
             // adapter builds the headers record from the pairs the runtime
             // hands over. Dead weight on a non-h2 server (never fires).
             const cb = h2HeadersCallbackAdapter(lowerer, args[1], "stream listeners", "http2Stream", false, loc);
-            return { kind: "libCall", fn: "http2.serverOnStream", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.serverOnStream",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "session") {
             // The h2c server's per-connection session event: (session). The
             // result is voidized; the handle passes by reference.
             const { cb } = lowerCallbackArg(lowerer, args[1], "session listeners", 1, (p) => p.kind === "http2Session", "use (session) or ()", [HTTP2SESSION_T]);
-            return { kind: "libCall", fn: "http2.serverOnSession", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.serverOnSession",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "connect") {
             // HTTP CONNECT — the tunneling handover: (req, socket, head), fired
@@ -1225,7 +1427,13 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                 (p2 !== undefined && !(p2.kind === "bytes" && p2.elem === "u8"))) {
                 lowerer.unsupported("SC1090", args[1], "connect listeners whose parameters are not (req: IncomingMessage, socket: Socket — or a union carrying the Socket arm, the h2 compat shape, head: Buffer)");
             }
-            return { kind: "libCall", fn: "http.serverOnConnect", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.serverOnConnect",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "upgrade") {
             // The WebSocket handover: (req, socket, head) — Node fires it
@@ -1246,7 +1454,13 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                 (p2 !== undefined && !(p2.kind === "bytes" && p2.elem === "u8"))) {
                 lowerer.unsupported("SC1090", args[1], "upgrade listeners whose parameters are not (req: IncomingMessage, socket: Socket, head: Buffer)");
             }
-            return { kind: "libCall", fn: "http.serverOnUpgrade", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.serverOnUpgrade",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "sessionError") {
             const cb = lowerer.lowerExpr(args[1]);
@@ -1258,7 +1472,13 @@ function lowerNetServerMethodCall(lowerer, call, access) {
                 (session !== undefined && session.kind !== "http2Session")) {
                 lowerer.unsupported("SC1090", args[1], "sessionError listeners whose parameters are not (error: Error, session: ServerHttp2Session)");
             }
-            return { kind: "libCall", fn: "http2.serverOnSessionError", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.serverOnSessionError",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         lowerer.noLowering(`server.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"connection", "request", "stream", "session", "upgrade", "connect", "error", "close", "listening", and "sessionError" are the supported server events (as literals)');
     }
@@ -1278,7 +1498,13 @@ function lowerNetServerMethodCall(lowerer, call, access) {
         if (sock.type.kind !== "netSocket") {
             lowerer.noLowering(`emit("connection", …) with a '${lowerer.fmt(sock.type)}' argument`, args[1], "the second argument must be a net socket");
         }
-        return { kind: "libCall", fn: "net.serverEmitConnection", args: [receiver, sock], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "net.serverEmitConnection",
+            args: [receiver, sock],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "address") {
         // The full AddressInfo record (the dgram.address materialization).
@@ -1295,7 +1521,7 @@ function lowerNetServerMethodCall(lowerer, call, access) {
         const receiver = coerceToHandle(lowerer, access.expression, NETSERVER_T);
         return { kind: "libCall", fn: "net.serverAddress", args: [receiver], type: result, loc };
     }
-    lowerer.noLowering(`Server.${name}`, call, "listen, close, address().port, emit(\"connection\", socket), and on/once of connection/request/upgrade/error/close/listening/sessionError are the supported Server members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`Server.${name}`, call, 'listen, close, address().port, emit("connection", socket), and on/once of connection/request/upgrade/error/close/listening/sessionError are the supported Server members', lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** Method calls on net.Socket receivers: write/end/destroy/pipe and
  * on/once("data" | "end" | "close" | "error" | "connect"). Null for
@@ -1320,7 +1546,8 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
             const encT = lowerer.typeOf(args[1]);
             const chunkT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
             if (encT.isStringLiteralType() && chunkT !== null) {
-                if (encT.value === "buffer" && chunkT.kind === "string" &&
+                if (encT.value === "buffer" &&
+                    chunkT.kind === "string" &&
                     isJsSourceFile(call.getSourceFile())) {
                     lowerer.lowerExpr(args[0]); // evaluation order (effect-free in practice)
                     return nodeThrowExpr(1, "ERR_INVALID_ARG_TYPE", "Second argument must be a buffer", VOID, loc);
@@ -1409,10 +1636,14 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
             lowerer.noLowering(`setNoDelay with ${args.length} arguments`, call, "the form is setNoDelay(noDelay?)");
         }
         const receiver = coerceToHandle(lowerer, access.expression, NETSOCKET_T);
-        const enable = args.length === 1
-            ? lowerer.lowerExprExpecting(args[0], BOOL)
-            : boolLit(true, loc);
-        return { kind: "libCall", fn: "net.sockSetNoDelay", args: [receiver, enable], type: NETSOCKET_T, loc };
+        const enable = args.length === 1 ? lowerer.lowerExprExpecting(args[0], BOOL) : boolLit(true, loc);
+        return {
+            kind: "libCall",
+            fn: "net.sockSetNoDelay",
+            args: [receiver, enable],
+            type: NETSOCKET_T,
+            loc,
+        };
     }
     if (name === "destroySoon") {
         // end() now, destroy once the FIN actually flushed — Node's
@@ -1479,15 +1710,28 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
         }
         if (event === "error") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "error listeners", 1, (p) => p.kind === "object" && p.className === "%Error", "use (err) or ()", [ERROR_T]);
-            return { kind: "libCall", fn: "net.sockOnError", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "net.sockOnError",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
-        if (event === "end" || event === "close" || event === "connect" || event === "timeout" ||
+        if (event === "end" ||
+            event === "close" ||
+            event === "connect" ||
+            event === "timeout" ||
             event === "readable") {
             const { cb } = lowerCallbackArg(lowerer, args[1], `${event} listeners`, 0, () => false, "use ()", []);
-            const fn = event === "end" ? "net.sockOnEnd"
-                : event === "close" ? "net.sockOnClose"
-                    : event === "timeout" ? "net.sockOnTimeout"
-                        : event === "readable" ? "net.sockOnReadable"
+            const fn = event === "end"
+                ? "net.sockOnEnd"
+                : event === "close"
+                    ? "net.sockOnClose"
+                    : event === "timeout"
+                        ? "net.sockOnTimeout"
+                        : event === "readable"
+                            ? "net.sockOnReadable"
                             : "net.sockOnConnect";
             return { kind: "libCall", fn, args: [receiver, cb, once], type: VOID, loc };
         }
@@ -1503,13 +1747,25 @@ function lowerNetSocketMethodCall(lowerer, call, access) {
             // transport pump); the runtime gates on the transport so a plain
             // socket's registration never fires — Node's exact split.
             const { cb } = lowerCallbackArg(lowerer, args[1], "secureConnect listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "tls.sockOnSecureConnect", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "tls.sockOnSecureConnect",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "session") {
             // The received-ticket event: fires once per TLS client socket with
             // the serialized session (a Buffer); plain sockets never fire it.
             const { cb } = lowerCallbackArg(lowerer, args[1], "session listeners", 1, (p) => p.kind === "bytes" && p.elem === "u8", "use (session: Buffer) or ()", [DYN]);
-            return { kind: "libCall", fn: "tls.sockOnSession", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "tls.sockOnSession",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         lowerer.noLowering(`socket.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"data", "end", "close", "error", "connect", "timeout", "readable", "secureConnect", and "session" are the supported socket events (as literals)');
     }
@@ -1603,13 +1859,27 @@ function lowerH2SessionMethodCall(lowerer, call, access) {
     const receiver = () => coerceToHandle(lowerer, access.expression, HTTP2SESSION_T);
     if (name === "request") {
         const pairs = args.length >= 1 && !ts.isObjectLiteralExpression(args[0]) === false && args.length >= 1
-            ? null : null;
+            ? null
+            : null;
         void pairs;
         // arg0: headers (optional), arg1: options (optional).
-        const headersArg = args.length >= 1 ? lowerH2HeadersArg(lowerer, args[0]) : { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
+        const headersArg = args.length >= 1
+            ? lowerH2HeadersArg(lowerer, args[0])
+            : { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
         const end = h2EndStreamOption(lowerer, args[1]);
-        const endF64 = { kind: "numLit", value: end === undefined ? -1 : end ? 1 : 0, type: F64, loc };
-        return { kind: "libCall", fn: "http2.sessionRequest", args: [receiver(), headersArg, endF64], type: HTTP2STREAM_T, loc };
+        const endF64 = {
+            kind: "numLit",
+            value: end === undefined ? -1 : end ? 1 : 0,
+            type: F64,
+            loc,
+        };
+        return {
+            kind: "libCall",
+            fn: "http2.sessionRequest",
+            args: [receiver(), headersArg, endF64],
+            type: HTTP2STREAM_T,
+            loc,
+        };
     }
     if (name === "close") {
         requireStatementPosition(lowerer, call, "session.close(...)");
@@ -1639,12 +1909,30 @@ function lowerH2SessionMethodCall(lowerer, call, access) {
             if (cbV.type.kind === "dyn") {
                 // The dyn callback keeps Node's exact (err, settings, duration)
                 // shape — the runtime fires it through the checked-dynamic tree.
-                return { kind: "libCall", fn: "http2.sessionSettingsDynCb", args: [receiver(), settingsArg, cbV], type: VOID, loc };
+                return {
+                    kind: "libCall",
+                    fn: "http2.sessionSettingsDynCb",
+                    args: [receiver(), settingsArg, cbV],
+                    type: VOID,
+                    loc,
+                };
             }
             const { cb } = lowerCallbackArg(lowerer, args[1], "settings callbacks", 0, () => false, "use () — or a dynamic (mustCall-wrapped) callback for the (err, settings, duration) shape", []);
-            return { kind: "libCall", fn: "http2.sessionSettingsCb0", args: [receiver(), settingsArg, cb], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionSettingsCb0",
+                args: [receiver(), settingsArg, cb],
+                type: VOID,
+                loc,
+            };
         }
-        return { kind: "libCall", fn: "http2.sessionSettings", args: [receiver(), settingsArg], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http2.sessionSettings",
+            args: [receiver(), settingsArg],
+            type: VOID,
+            loc,
+        };
     }
     if ((name === "on" || name === "once" || name === "addListener") && args.length === 2) {
         requireStatementPosition(lowerer, call, `session.${name}(...)`);
@@ -1658,26 +1946,62 @@ function lowerH2SessionMethodCall(lowerer, call, access) {
             const local = boolLit(event === "localSettings", loc);
             const cbV = lowerer.lowerExpr(args[1]);
             if (cbV.type.kind === "dyn") {
-                return { kind: "libCall", fn: "http2.sessionOnSettingsDyn", args: [receiver(), cbV, once, local], type: VOID, loc };
+                return {
+                    kind: "libCall",
+                    fn: "http2.sessionOnSettingsDyn",
+                    args: [receiver(), cbV, once, local],
+                    type: VOID,
+                    loc,
+                };
             }
             const { cb } = lowerCallbackArg(lowerer, args[1], `${event} listeners`, 0, () => false, "use () — or a dynamic (mustCall-wrapped) listener for the (settings) payload", []);
-            return { kind: "libCall", fn: "http2.sessionOnSettings0", args: [receiver(), cb, once, local], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionOnSettings0",
+                args: [receiver(), cb, once, local],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "close") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "http2.sessionOnClose", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionOnClose",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "error") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "error listeners", 1, (p) => p.kind === "object" && p.className === "%Error", "use (err) or ()", [ERROR_T]);
-            return { kind: "libCall", fn: "http2.sessionOnError", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionOnError",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "connect") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "connect listeners", 2, (p) => p.kind === "http2Session" || p.kind === "netSocket", "use (session, socket) or ()", [HTTP2SESSION_T, NETSOCKET_T]);
-            return { kind: "libCall", fn: "http2.sessionOnConnect", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionOnConnect",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "stream") {
             const cb = h2HeadersCallbackAdapter(lowerer, args[1], "stream listeners", "http2Stream", false, loc);
-            return { kind: "libCall", fn: "http2.sessionOnStream", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionOnStream",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "goaway") {
             const cb = lowerer.lowerExpr(args[1]);
@@ -1687,18 +2011,25 @@ function lowerH2SessionMethodCall(lowerer, call, access) {
             if (cb.type.params.some((p) => p.kind !== "f64" && p.kind !== "bytes")) {
                 lowerer.unsupported("SC1090", args[1], "goaway listeners whose parameters are not (errorCode, lastStreamID, opaqueData?)");
             }
-            return { kind: "libCall", fn: "http2.sessionOnGoaway", args: [receiver(), voidizedCallback(lowerer, cb, loc), once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionOnGoaway",
+                args: [receiver(), voidizedCallback(lowerer, cb, loc), once],
+                type: VOID,
+                loc,
+            };
         }
         lowerer.noLowering(`session.${name}("${event ?? "?"}", ...)`, args[0], '"close", "error", "connect", "stream", and "goaway" are the supported session events');
     }
-    lowerer.noLowering(`session.${name}`, call, "close/destroy/request and on(\"close\"|\"error\"|\"connect\"|\"stream\"|\"goaway\") are the lowered session members");
+    lowerer.noLowering(`session.${name}`, call, 'close/destroy/request and on("close"|"error"|"connect"|"stream"|"goaway") are the lowered session members');
 }
 /** Method calls on ClientHttp2Stream / ServerHttp2Stream receivers. */
 function lowerH2StreamMethodCall(lowerer, call, access, receiverOverride) {
     const compatReqStream = ts.isPropertyAccessExpression(access.expression) &&
         access.expression.name.text === "stream" &&
         lowerer.mapTypeOf(lowerer.typeOf(access.expression.expression))?.kind === "httpReq";
-    if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "http2Stream" && !compatReqStream)
+    if (lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind !== "http2Stream" &&
+        !compatReqStream)
         return null;
     if (!lowerer.isStdlibMember(access) && !compatReqStream)
         return null;
@@ -1712,7 +2043,13 @@ function lowerH2StreamMethodCall(lowerer, call, access, receiverOverride) {
             ? lowerH2HeadersArg(lowerer, args[0])
             : { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc };
         const end = h2EndStreamOption(lowerer, args[1]);
-        return { kind: "libCall", fn: "http2.streamRespond", args: [receiver(), headersArg, boolLit(end ?? false, loc)], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http2.streamRespond",
+            args: [receiver(), headersArg, boolLit(end ?? false, loc)],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "write" || name === "end") {
         requireStatementPosition(lowerer, call, `stream.${name}(...)`);
@@ -1734,8 +2071,12 @@ function lowerH2StreamMethodCall(lowerer, call, access, receiverOverride) {
             lowerer.noLowering(`${name} with '${lowerer.fmt(data.type)}' data`, args[0], "the chunk is a string or a Uint8Array here");
         }
         const fn = name === "write"
-            ? (isBytes ? "http2.streamWriteBytes" : "http2.streamWrite")
-            : (isBytes ? "http2.streamEndBytes" : "http2.streamEndStr");
+            ? isBytes
+                ? "http2.streamWriteBytes"
+                : "http2.streamWrite"
+            : isBytes
+                ? "http2.streamEndBytes"
+                : "http2.streamEndStr";
         return { kind: "libCall", fn, args: [receiver(), data], type: VOID, loc };
     }
     if (name === "close") {
@@ -1746,7 +2087,13 @@ function lowerH2StreamMethodCall(lowerer, call, access, receiverOverride) {
         }
         if (args.length >= 2) {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close callbacks", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "http2.streamCloseCb", args: [receiver(), code, cb], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.streamCloseCb",
+                args: [receiver(), code, cb],
+                type: VOID,
+                loc,
+            };
         }
         return { kind: "libCall", fn: "http2.streamClose", args: [receiver(), code], type: VOID, loc };
     }
@@ -1757,17 +2104,35 @@ function lowerH2StreamMethodCall(lowerer, call, access, receiverOverride) {
     if (name === "setEncoding") {
         const enc = lowerer.lowerExpr(args[0]);
         if (enc.type.kind !== "string")
-            lowerer.noLowering("setEncoding with a non-string encoding", args[0], "pass \"utf8\"");
+            lowerer.noLowering("setEncoding with a non-string encoding", args[0], 'pass "utf8"');
         if (ts.isExpressionStatement(call.parent) || ts.isArrowFunction(call.parent)) {
-            return { kind: "libCall", fn: "http2.streamSetEncoding", args: [receiver(), enc], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.streamSetEncoding",
+                args: [receiver(), enc],
+                type: VOID,
+                loc,
+            };
         }
         // The chaining spelling (`client.request(h).setEncoding("utf8")`):
         // same write, the result is the receiver — Node's return-this.
-        return { kind: "libCall", fn: "http2.streamSetEncodingRet", args: [receiver(), enc], type: HTTP2STREAM_T, loc };
+        return {
+            kind: "libCall",
+            fn: "http2.streamSetEncodingRet",
+            args: [receiver(), enc],
+            type: HTTP2STREAM_T,
+            loc,
+        };
     }
     if (name === "resume" || name === "pause") {
         requireStatementPosition(lowerer, call, `stream.${name}(...)`);
-        return { kind: "libCall", fn: name === "resume" ? "http2.streamResume" : "http2.streamPause", args: [receiver()], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: name === "resume" ? "http2.streamResume" : "http2.streamPause",
+            args: [receiver()],
+            type: VOID,
+            loc,
+        };
     }
     if ((name === "on" || name === "once" || name === "addListener") && args.length === 2) {
         requireStatementPosition(lowerer, call, `stream.${name}(...)`);
@@ -1776,20 +2141,42 @@ function lowerH2StreamMethodCall(lowerer, call, access, receiverOverride) {
         const event = evT.isStringLiteralType() ? evT.value : null;
         if (event === "data") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "data listeners", 1, (p) => (p.kind === "bytes" && p.elem === "u8") || p.kind === "string" || p.kind === "dyn", "use (chunk) or ()", [BYTES_U8]);
-            return { kind: "libCall", fn: "http2.streamOnData", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.streamOnData",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "end" || event === "close" || event === "aborted") {
             const { cb } = lowerCallbackArg(lowerer, args[1], `${event} listeners`, 0, () => false, "use ()", []);
-            const fn = event === "end" ? "http2.streamOnEnd" : event === "close" ? "http2.streamOnClose" : "http2.streamOnAborted";
+            const fn = event === "end"
+                ? "http2.streamOnEnd"
+                : event === "close"
+                    ? "http2.streamOnClose"
+                    : "http2.streamOnAborted";
             return { kind: "libCall", fn, args: [receiver(), cb, once], type: VOID, loc };
         }
         if (event === "error") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "error listeners", 1, (p) => p.kind === "object" && p.className === "%Error", "use (err) or ()", [ERROR_T]);
-            return { kind: "libCall", fn: "http2.streamOnError", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.streamOnError",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "response") {
             const cb = h2HeadersCallbackAdapter(lowerer, args[1], "response listeners", null, true, loc);
-            return { kind: "libCall", fn: "http2.streamOnResponse", args: [receiver(), cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.streamOnResponse",
+                args: [receiver(), cb, once],
+                type: VOID,
+                loc,
+            };
         }
         lowerer.noLowering(`stream.${name}("${event ?? "?"}", ...)`, args[0], '"data", "end", "close", "aborted", "error", and "response" are the supported stream events');
     }
@@ -1803,11 +2190,15 @@ export function lowerCompatReqStreamOptionalCall(lowerer, call) {
     if (!ts.isPropertyAccessExpression(call.expression) || !call.expression.questionDotToken)
         return null;
     const stream = call.expression.expression;
-    if (!ts.isPropertyAccessExpression(stream) || stream.name.text !== "stream" ||
+    if (!ts.isPropertyAccessExpression(stream) ||
+        stream.name.text !== "stream" ||
         lowerer.mapTypeOf(lowerer.typeOf(stream.expression))?.kind !== "httpReq")
         return null;
     const loc = locOf(call);
-    const unionT = { kind: "union", unionId: lowerer.unions.intern([HTTP2STREAM_T, UNDEFINED_T]) };
+    const unionT = {
+        kind: "union",
+        unionId: lowerer.unions.intern([HTTP2STREAM_T, UNDEFINED_T]),
+    };
     const guarded = {
         kind: "libCall",
         fn: "http.reqH2Stream",
@@ -1816,7 +2207,12 @@ export function lowerCompatReqStreamOptionalCall(lowerer, call) {
         loc,
     };
     const id = `chain.${lowerer.chainCounter++}`;
-    const body = lowerH2StreamMethodCall(lowerer, call, call.expression, { kind: "chainRecv", id, type: HTTP2STREAM_T, loc });
+    const body = lowerH2StreamMethodCall(lowerer, call, call.expression, {
+        kind: "chainRecv",
+        id,
+        type: HTTP2STREAM_T,
+        loc,
+    });
     if (body === null)
         return null;
     return { kind: "optChain", id, receiver: guarded, body, type: VOID, loc };
@@ -1841,7 +2237,13 @@ export function lowerServerProperty(lowerer, expr) {
         if (field !== null) {
             const receiver = coerceToHandle(lowerer, expr.expression, NETSERVER_T);
             const selector = { kind: "numLit", value: field, type: F64, loc };
-            return { kind: "libCall", fn: "http.serverTimeoutGet", args: [receiver, selector], type: F64, loc };
+            return {
+                kind: "libCall",
+                fn: "http.serverTimeoutGet",
+                args: [receiver, selector],
+                type: F64,
+                loc,
+            };
         }
     }
     if (recvKind === "httpReq" && lowerer.isStdlibMember(expr)) {
@@ -1855,7 +2257,13 @@ export function lowerServerProperty(lowerer, expr) {
             // `number | undefined` — a real status on client responses, the
             // undefined arm on server requests (Node's IncomingMessage split).
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
-            return { kind: "libCall", fn: "http.reqStatusCode", args: [receiver], type: lowerer.withUndefinedArm(F64), loc };
+            return {
+                kind: "libCall",
+                fn: "http.reqStatusCode",
+                args: [receiver],
+                type: lowerer.withUndefinedArm(F64),
+                loc,
+            };
         }
         if (name === "socket" || name === "connection") {
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
@@ -1889,12 +2297,20 @@ export function lowerServerProperty(lowerer, expr) {
             // when the status line carried none), undefined on server requests
             // (the statusCode split).
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
-            return { kind: "libCall", fn: "http.reqStatusMessage", args: [receiver], type: lowerer.envValueType(), loc };
+            return {
+                kind: "libCall",
+                fn: "http.reqStatusMessage",
+                args: [receiver],
+                type: lowerer.envValueType(),
+                loc,
+            };
         }
         if (name === "stream") {
             const parent = expr.parent;
-            if (ts.isPropertyAccessExpression(parent) && parent.expression === expr &&
-                ts.isCallExpression(parent.parent) && parent.parent.expression === parent) {
+            if (ts.isPropertyAccessExpression(parent) &&
+                parent.expression === expr &&
+                ts.isCallExpression(parent.parent) &&
+                parent.parent.expression === parent) {
                 const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
                 if (parent.questionDotToken) {
                     const type = {
@@ -1919,14 +2335,18 @@ export function lowerServerProperty(lowerer, expr) {
             // guarded-no-op / unguarded-TypeError stance; other reads fence.
             lowerer.noLowering(`reading '${name}' (an HTTP/2-only member) from a request`, expr, "compatibility requests do not expose their backing h2 stream/session yet; guarded method calls no-op and other reads have no lowering");
         }
-        if (name === "headers" || name === "trailers" || name === "headersDistinct" || name === "trailersDistinct") {
+        if (name === "headers" ||
+            name === "trailers" ||
+            name === "headersDistinct" ||
+            name === "trailersDistinct") {
             // Whole-object reads materialize a typed snapshot record. Per-name
             // reads retain their direct lowerings.
             const mapped = lowerer.mapTypeOf(lowerer.typeOf(expr));
             if (mapped?.kind === "record") {
                 const helper = name === "headers"
                     ? headersSnapshotHelper(lowerer, mapped.shapeId, loc)
-                    : name === "trailers" ? trailersSnapshotHelper(lowerer, mapped.shapeId, loc)
+                    : name === "trailers"
+                        ? trailersSnapshotHelper(lowerer, mapped.shapeId, loc)
                         : distinctSnapshotHelper(lowerer, mapped.shapeId, loc, name);
                 if (helper !== null) {
                     const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
@@ -1949,7 +2369,13 @@ export function lowerServerProperty(lowerer, expr) {
         // KIND is a real socket either way, and `encrypted` on a socket has
         // exactly one meaning.
         const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
-        return { kind: "libCall", fn: "net.sockEncrypted", args: [receiver], type: lowerer.withUndefinedArm(BOOL), loc };
+        return {
+            kind: "libCall",
+            fn: "net.sockEncrypted",
+            args: [receiver],
+            type: lowerer.withUndefinedArm(BOOL),
+            loc,
+        };
     }
     if (recvKind === "netSocket" && expr.name.text === "authorized") {
         // TLSSocket.authorized — Node's verify verdict (false on plain
@@ -1980,7 +2406,9 @@ export function lowerServerProperty(lowerer, expr) {
         const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
         return { kind: "libCall", fn: "net.sockWritable", args: [receiver], type: BOOL, loc };
     }
-    if (recvKind === "netSocket" && lowerer.isStdlibMember(expr) && expr.name.text === "bytesWritten") {
+    if (recvKind === "netSocket" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "bytesWritten") {
         // Every byte the write paths accepted (buffered included — Node
         // counts those too; plaintext on TLS sockets).
         const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
@@ -1991,41 +2419,65 @@ export function lowerServerProperty(lowerer, expr) {
         const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
         return { kind: "libCall", fn: "net.sockReadable", args: [receiver], type: BOOL, loc };
     }
-    if (recvKind === "netSocket" && lowerer.isStdlibMember(expr) && expr.name.text === "remoteAddress") {
+    if (recvKind === "netSocket" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "remoteAddress") {
         // `string | undefined` — Node's read-time caching: a value read while
         // connected survives destroy; never-read sockets answer undefined
         // after close.
         const receiver = coerceToHandle(lowerer, expr.expression, NETSOCKET_T);
-        return { kind: "libCall", fn: "net.sockRemoteAddress", args: [receiver], type: lowerer.envValueType(), loc };
+        return {
+            kind: "libCall",
+            fn: "net.sockRemoteAddress",
+            args: [receiver],
+            type: lowerer.envValueType(),
+            loc,
+        };
     }
-    if (recvKind === "httpClientReq" && lowerer.isStdlibMember(expr) && expr.name.text === "destroyed") {
+    if (recvKind === "httpClientReq" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "destroyed") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
         return { kind: "libCall", fn: "http.clientDestroyed", args: [receiver], type: BOOL, loc };
     }
-    if (recvKind === "httpClientReq" && lowerer.isStdlibMember(expr) &&
+    if (recvKind === "httpClientReq" &&
+        lowerer.isStdlibMember(expr) &&
         (expr.name.text === "socket" || expr.name.text === "connection")) {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
         return { kind: "libCall", fn: "http.clientSocket", args: [receiver], type: NETSOCKET_T, loc };
     }
-    if (recvKind === "httpClientReq" && lowerer.isStdlibMember(expr) && expr.name.text === "writableCorked") {
+    if (recvKind === "httpClientReq" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "writableCorked") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
         return { kind: "libCall", fn: "http.clientWritableCorked", args: [receiver], type: F64, loc };
     }
     if (recvKind === "httpClientReq" && lowerer.isStdlibMember(expr)) {
         const name = expr.name.text;
-        const strFn = name === "method" ? "http.clientMethod"
-            : name === "path" ? "http.clientPath"
-                : name === "host" ? "http.clientHost"
-                    : name === "protocol" ? "http.clientProtocol" : null;
+        const strFn = name === "method"
+            ? "http.clientMethod"
+            : name === "path"
+                ? "http.clientPath"
+                : name === "host"
+                    ? "http.clientHost"
+                    : name === "protocol"
+                        ? "http.clientProtocol"
+                        : null;
         if (strFn !== null) {
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
             return { kind: "libCall", fn: strFn, args: [receiver], type: STRING, loc };
         }
-        const boolFn = name === "aborted" ? "http.clientAborted"
-            : name === "headersSent" ? "http.clientHeadersSent"
-                : name === "writableEnded" || name === "finished" ? "http.clientWritableEnded"
-                    : name === "writableFinished" ? "http.clientWritableFinished"
-                        : name === "reusedSocket" ? "http.clientReusedSocket" : null;
+        const boolFn = name === "aborted"
+            ? "http.clientAborted"
+            : name === "headersSent"
+                ? "http.clientHeadersSent"
+                : name === "writableEnded" || name === "finished"
+                    ? "http.clientWritableEnded"
+                    : name === "writableFinished"
+                        ? "http.clientWritableFinished"
+                        : name === "reusedSocket"
+                            ? "http.clientReusedSocket"
+                            : null;
         if (boolFn !== null) {
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
             return { kind: "libCall", fn: boolFn, args: [receiver], type: BOOL, loc };
@@ -2035,17 +2487,25 @@ export function lowerServerProperty(lowerer, expr) {
         const collection = httpReqFieldCollection(lowerer, expr.expression);
         const receiver = coerceToHandle(lowerer, expr.expression.expression, HTTPREQ_T);
         const key = { kind: "strLit", value: expr.name.text, type: STRING, loc };
-        const fn = collection === "headers" ? "http.reqHeader"
-            : collection === "trailers" ? "http.reqTrailer"
-                : collection === "headersDistinct" ? "http.reqHeaderValues" : "http.reqTrailerValues";
-        const type = collection.endsWith("Distinct") ? lowerer.withUndefinedArm(arrayOf(STRING)) : lowerer.envValueType();
+        const fn = collection === "headers"
+            ? "http.reqHeader"
+            : collection === "trailers"
+                ? "http.reqTrailer"
+                : collection === "headersDistinct"
+                    ? "http.reqHeaderValues"
+                    : "http.reqTrailerValues";
+        const type = collection.endsWith("Distinct")
+            ? lowerer.withUndefinedArm(arrayOf(STRING))
+            : lowerer.envValueType();
         return { kind: "libCall", fn, args: [receiver, key], type, loc };
     }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "headersSent") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resHeadersSent", args: [receiver], type: BOOL, loc };
     }
-    if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "writableEnded") {
+    if (recvKind === "httpRes" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "writableEnded") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resWritableEnded", args: [receiver], type: BOOL, loc };
     }
@@ -2053,7 +2513,9 @@ export function lowerServerProperty(lowerer, expr) {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resWritableEnded", args: [receiver], type: BOOL, loc };
     }
-    if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "writableCorked") {
+    if (recvKind === "httpRes" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "writableCorked") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resWritableCorked", args: [receiver], type: F64, loc };
     }
@@ -2063,10 +2525,18 @@ export function lowerServerProperty(lowerer, expr) {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resStatusGet", args: [receiver], type: F64, loc };
     }
-    if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "statusMessage") {
+    if (recvKind === "httpRes" &&
+        lowerer.isStdlibMember(expr) &&
+        expr.name.text === "statusMessage") {
         // Unset until the head is sent; then the assigned or default reason.
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
-        return { kind: "libCall", fn: "http.resStatusMsgGet", args: [receiver], type: lowerer.withUndefinedArm(STRING), loc };
+        return {
+            kind: "libCall",
+            fn: "http.resStatusMsgGet",
+            args: [receiver],
+            type: lowerer.withUndefinedArm(STRING),
+            loc,
+        };
     }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr)) {
         const name = expr.name.text;
@@ -2105,13 +2575,22 @@ export function lowerServerProperty(lowerer, expr) {
         if (m === "socket")
             return { kind: "libCall", fn: "http2.sessionSocket", args: [recv()], type: NETSOCKET_T, loc };
         if (m === "pendingSettingsAck")
-            return { kind: "libCall", fn: "http2.sessionPendingSettingsAck", args: [recv()], type: BOOL, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.sessionPendingSettingsAck",
+                args: [recv()],
+                type: BOOL,
+                loc,
+            };
         if (m === "localSettings" || m === "remoteSettings") {
             // The settings record crosses as a dyn value (the d.ts types it
             // `any`): member reads ride the checked-dynamic keyed read.
             return {
-                kind: "libCall", fn: "http2.sessionSettingsGet",
-                args: [recv(), boolLit(m === "localSettings", loc)], type: DYN, loc,
+                kind: "libCall",
+                fn: "http2.sessionSettingsGet",
+                args: [recv(), boolLit(m === "localSettings", loc)],
+                type: DYN,
+                loc,
             };
         }
     }
@@ -2131,7 +2610,13 @@ export function lowerServerProperty(lowerer, expr) {
         if (m === "pending")
             return { kind: "libCall", fn: "http2.streamPending", args: [recv()], type: BOOL, loc };
         if (m === "session")
-            return { kind: "libCall", fn: "http2.streamSession", args: [recv()], type: HTTP2SESSION_T, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.streamSession",
+                args: [recv()],
+                type: HTTP2SESSION_T,
+                loc,
+            };
     }
     if (expr.name.text !== "port")
         return null;
@@ -2166,7 +2651,12 @@ function lowerRequestHandlerArg(lowerer, node) {
         // calls the wrapper through the checked-dynamic machinery; member
         // uses inside the wrapped body dispatch back onto the same http
         // entry points at runtime.
-        return { kind: "dynCheck", value: cb, type: funcOf([HTTPREQ_T, HTTPRES_T], VOID), loc: locOf(node) };
+        return {
+            kind: "dynCheck",
+            value: cb,
+            type: funcOf([HTTPREQ_T, HTTPRES_T], VOID),
+            loc: locOf(node),
+        };
     }
     if (cb.type.kind === "func" &&
         (cb.type.rest === true ||
@@ -2178,7 +2668,12 @@ function lowerRequestHandlerArg(lowerer, node) {
         // like the dyn case — req/res arrive as HANDLE boxes and the body's
         // member uses dispatch at runtime.
         const boxed = { kind: "dynFrom", value: cb, type: DYN, loc: locOf(node) };
-        return { kind: "dynCheck", value: boxed, type: funcOf([HTTPREQ_T, HTTPRES_T], VOID), loc: locOf(node) };
+        return {
+            kind: "dynCheck",
+            value: boxed,
+            type: funcOf([HTTPREQ_T, HTTPRES_T], VOID),
+            loc: locOf(node),
+        };
     }
     if (cb.type.kind !== "func" || cb.type.params.length > 2) {
         lowerer.unsupported("SC1090", node, "request handlers with more than two parameters (use (req, res))");
@@ -2238,7 +2733,7 @@ function lowerHttpServerOptions(lowerer, node, what) {
                 joinDup = false; /* Node's default: repeats keep the first value */
                 continue;
             }
-            lowerer.noLowering(`${what} with a non-literal joinDuplicateHeaders option`, prop, "the lowered forms are the literals joinDuplicateHeaders: true (repeats join \", \") and false (the keep-first default)");
+            lowerer.noLowering(`${what} with a non-literal joinDuplicateHeaders option`, prop, 'the lowered forms are the literals joinDuplicateHeaders: true (repeats join ", ") and false (the keep-first default)');
         }
         if (key === "keepAliveTimeoutBuffer") {
             if (keepAliveTimeoutBuffer !== null) {
@@ -2290,7 +2785,13 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
         ? lowerHttpServerOptions(lowerer, optsNode, what)
         : { joinDup: false, allowMissingHost: false, keepAliveTimeoutBuffer: null };
     const server = handlerNode !== null
-        ? { kind: "libCall", fn: "http.createServer", args: [lowerRequestHandlerArg(lowerer, handlerNode)], type: NETSERVER_T, loc }
+        ? {
+            kind: "libCall",
+            fn: "http.createServer",
+            args: [lowerRequestHandlerArg(lowerer, handlerNode)],
+            type: NETSERVER_T,
+            loc,
+        }
         : { kind: "libCall", fn: "http.createServerEmpty", args: [], type: NETSERVER_T, loc };
     if (!opts.joinDup && !opts.allowMissingHost && opts.keepAliveTimeoutBuffer === null)
         return server;
@@ -2315,7 +2816,13 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
             const value = { kind: "varRef", localId: "b.0", type: DYN, loc };
             body.push({
                 kind: "exprStmt",
-                expr: { kind: "libCall", fn: "http.serverTimeoutOptionSet", args: [ref, selector, value], type: VOID, loc },
+                expr: {
+                    kind: "libCall",
+                    fn: "http.serverTimeoutOptionSet",
+                    args: [ref, selector, value],
+                    type: VOID,
+                    loc,
+                },
                 loc,
             });
         }
@@ -2329,7 +2836,13 @@ function lowerHttpCreateServerForms(lowerer, expr, what, loc) {
         if (opts.allowMissingHost) {
             body.push({
                 kind: "exprStmt",
-                expr: { kind: "libCall", fn: "http.serverAllowMissingHostHeader", args: [ref], type: VOID, loc },
+                expr: {
+                    kind: "libCall",
+                    fn: "http.serverAllowMissingHostHeader",
+                    args: [ref],
+                    type: VOID,
+                    loc,
+                },
                 loc,
             });
         }
@@ -2413,10 +2926,17 @@ export function lowerHttpAgentNew(lowerer, expr) {
                     ? lowerer.lowerExpr(initializer)
                     : lowerer.lowerShorthandValue(prop);
                 if (v.type.kind === "dyn") {
-                    return { kind: "dynCheck", value: v, type: want === "bool" ? BOOL : F64, loc: locOf(prop) };
+                    return {
+                        kind: "dynCheck",
+                        value: v,
+                        type: want === "bool" ? BOOL : F64,
+                        loc: locOf(prop),
+                    };
                 }
                 if (v.type.kind !== want) {
-                    lowerer.noLowering(`a ${api} '${key}' option of '${lowerer.fmt(v.type)}' values`, prop, want === "bool" ? "the option value must be a boolean" : "the option value must be a number");
+                    lowerer.noLowering(`a ${api} '${key}' option of '${lowerer.fmt(v.type)}' values`, prop, want === "bool"
+                        ? "the option value must be a boolean"
+                        : "the option value must be a number");
                 }
                 return v;
             };
@@ -2455,7 +2975,15 @@ export function lowerHttpAgentNew(lowerer, expr) {
     return {
         kind: "libCall",
         fn: "http.agentNew",
-        args: [boolLit(bi.module === "https", loc), keepAlive, kaMsecs, maxSockets, maxFree, timeout, port],
+        args: [
+            boolLit(bi.module === "https", loc),
+            keepAlive,
+            kaMsecs,
+            maxSockets,
+            maxFree,
+            timeout,
+            port,
+        ],
         type: DYN,
         loc,
     };
@@ -2480,7 +3008,9 @@ export function lowerHttpServerNew(lowerer, expr) {
 function lowerHttpModuleCall(lowerer, expr, bi, loc) {
     if (bi.member === "validateHeaderName") {
         requireStatementPosition(lowerer, expr, "http.validateHeaderName(...)");
-        if (expr.arguments.length < 1 || expr.arguments.length > 2 || expr.arguments.some(ts.isSpreadElement)) {
+        if (expr.arguments.length < 1 ||
+            expr.arguments.length > 2 ||
+            expr.arguments.some(ts.isSpreadElement)) {
             lowerer.noLowering("http.validateHeaderName arguments", expr, "pass a header name and an optional label");
         }
         const name = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
@@ -2496,7 +3026,13 @@ function lowerHttpModuleCall(lowerer, expr, bi, loc) {
         }
         const name = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
         const value = lowerer.lowerExprExpecting(expr.arguments[1], DYN);
-        return { kind: "libCall", fn: "http.validateHeaderValue", args: [name, value], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.validateHeaderValue",
+            args: [name, value],
+            type: VOID,
+            loc,
+        };
     }
     if (bi.member === "createServer" || bi.member === "Server") {
         return lowerHttpCreateServerForms(lowerer, expr, `http.${bi.member}`, loc);
@@ -2542,8 +3078,7 @@ function lowerTlsServerOptions(lowerer, node, what) {
                 // the runtime walk's split (effectful values keep the fence).
                 continue;
             }
-            if (k === "requestCert" &&
-                (init === null || init.kind === ts.SyntaxKind.FalseKeyword)) {
+            if (k === "requestCert" && (init === null || init.kind === ts.SyntaxKind.FalseKeyword)) {
                 continue; // Node's false default, spelled out
             }
             fenceOrDropOptionKey(lowerer, prop, k, what, TLS_SERVER_DOCUMENTED_OPTIONS, "cert and key (PEM strings or Buffers) are the supported options", {
@@ -2556,7 +3091,8 @@ function lowerTlsServerOptions(lowerer, node, what) {
             ? lowerer.lowerExpr(initializer)
             : lowerer.lowerShorthandValue(prop);
         const isArrayOfPem = v.type.kind === "array" &&
-            (v.type.elem.kind === "string" || (v.type.elem.kind === "bytes" && v.type.elem.elem === "u8"));
+            (v.type.elem.kind === "string" ||
+                (v.type.elem.kind === "bytes" && v.type.elem.elem === "u8"));
         if (v.type.kind === "dyn" || isArrayOfPem) {
             // A runtime PEM value (fixtures.readKey(...) — the suite's shape) or
             // the one-element-array multi-context spelling: the runtime
@@ -2596,10 +3132,19 @@ function lowerTlsServerOptions(lowerer, node, what) {
  * rides WHOLE to the walker so the typed ladders run in Node's order
  * (the static walk would fence them before validating). */
 const TLS_VALIDATED_OPTIONS = new Set([
-    "ciphers", "passphrase", "ecdhCurve", "sessionIdContext",
-    "clientCertEngine", "privateKeyEngine", "privateKeyIdentifier",
-    "minVersion", "maxVersion", "handshakeTimeout", "keepAliveInitialDelay",
-    "sessionTimeout", "ticketKeys",
+    "ciphers",
+    "passphrase",
+    "ecdhCurve",
+    "sessionIdContext",
+    "clientCertEngine",
+    "privateKeyEngine",
+    "privateKeyIdentifier",
+    "minVersion",
+    "maxVersion",
+    "handshakeTimeout",
+    "keepAliveInitialDelay",
+    "sessionTimeout",
+    "ticketKeys",
 ]);
 /** True when a literal options bag must ride the runtime walker: JS uses
  * it for the typed TLS validation ladders, and HTTPS uses it for
@@ -2645,7 +3190,8 @@ function lowerTlsConnectCall(lowerer, expr, loc) {
     if (args.length < 1 || args.length > 4 || args.some(ts.isSpreadElement)) {
         lowerer.noLowering(`tls.connect with ${args.length} arguments`, expr, FORMS_HINT);
     }
-    const isFuncish = (a) => ts.isFunctionExpression(a) || ts.isArrowFunction(a) ||
+    const isFuncish = (a) => ts.isFunctionExpression(a) ||
+        ts.isArrowFunction(a) ||
         lowerer.checker.getCallSignatures(lowerer.typeOf(a)).length > 0;
     const isObjectish = (a) => {
         if (ts.isObjectLiteralExpression(a))
@@ -2711,12 +3257,7 @@ function lowerTlsConnectCall(lowerer, expr, loc) {
         }
         // No options: Node's defaults (rejectUnauthorized: true) — the
         // runtime walk reads an absent record (the dyn undefined).
-        opts = {
-            kind: "dynFrom",
-            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
-            type: DYN,
-            loc,
-        };
+        opts = dynUndefinedExpr(loc);
     }
     let cb = null;
     if (i < args.length) {
@@ -2745,17 +3286,37 @@ function lowerTlsModuleCall(lowerer, expr, bi, loc) {
         if (args.length === 1) {
             return opts.dyn !== undefined
                 ? { kind: "libCall", fn: "tls.createServerDyn", args: [opts.dyn], type: NETSERVER_T, loc }
-                : { kind: "libCall", fn: "tls.createServer", args: [opts.cert, opts.key], type: NETSERVER_T, loc };
+                : {
+                    kind: "libCall",
+                    fn: "tls.createServer",
+                    args: [opts.cert, opts.key],
+                    type: NETSERVER_T,
+                    loc,
+                };
         }
         const { cb } = lowerCallbackArg(lowerer, args[1], "secureConnection listeners", 1, (p) => p.kind === "netSocket", "use (socket) or ()", [NETSOCKET_T]);
         return opts.dyn !== undefined
-            ? { kind: "libCall", fn: "tls.createServerDynCb", args: [opts.dyn, cb], type: NETSERVER_T, loc }
-            : { kind: "libCall", fn: "tls.createServerCb", args: [opts.cert, opts.key, cb], type: NETSERVER_T, loc };
+            ? {
+                kind: "libCall",
+                fn: "tls.createServerDynCb",
+                args: [opts.dyn, cb],
+                type: NETSERVER_T,
+                loc,
+            }
+            : {
+                kind: "libCall",
+                fn: "tls.createServerCb",
+                args: [opts.cert, opts.key, cb],
+                type: NETSERVER_T,
+                loc,
+            };
     }
     if (bi.member === "connect") {
         return lowerTlsConnectCall(lowerer, expr, loc);
     }
-    if (bi.member === "getCACertificates" && args.length === 1 && !args.some(ts.isSpreadElement) &&
+    if (bi.member === "getCACertificates" &&
+        args.length === 1 &&
+        !args.some(ts.isSpreadElement) &&
         isJsSourceFile(expr.getSourceFile())) {
         // The type-argument ladder (validateString + the documented name
         // set); the real CA list has no lowering, so a valid name meets the
@@ -2782,9 +3343,21 @@ function lowerTlsModuleCall(lowerer, expr, bi, loc) {
         }
         const opts = lowerTlsServerOptionsOrDyn(lowerer, args[0], "tls.createSecureContext");
         if (opts.dyn !== undefined) {
-            return { kind: "libCall", fn: "tls.createSecureContextDyn", args: [opts.dyn], type: SECURECTX_T, loc };
+            return {
+                kind: "libCall",
+                fn: "tls.createSecureContextDyn",
+                args: [opts.dyn],
+                type: SECURECTX_T,
+                loc,
+            };
         }
-        return { kind: "libCall", fn: "tls.createSecureContext", args: [opts.cert, opts.key], type: SECURECTX_T, loc };
+        return {
+            kind: "libCall",
+            fn: "tls.createSecureContext",
+            args: [opts.cert, opts.key],
+            type: SECURECTX_T,
+            loc,
+        };
     }
     // The CA-store introspection pair (scr_tls_ca.c — its own link gate, no
     // mbedTLS): getCACertificates(type?) answers the per-type cached PEM
@@ -2840,7 +3413,8 @@ function clientFnRefOf(lowerer, node) {
             : null;
     if (!bi)
         return null;
-    if ((bi.module !== "http" && bi.module !== "https") || (bi.member !== "request" && bi.member !== "get")) {
+    if ((bi.module !== "http" && bi.module !== "https") ||
+        (bi.member !== "request" && bi.member !== "get")) {
         return null;
     }
     return { module: bi.module, member: bi.member };
@@ -2852,7 +3426,8 @@ function neverReassigned(lowerer, sym) {
     const decl = lowerer.checker.declarationsOf(sym)[0];
     if (!decl)
         return false;
-    if (ts.isVariableDeclaration(decl) && (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0) {
+    if (ts.isVariableDeclaration(decl) &&
+        (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0) {
         return true;
     }
     if (!ts.isParameter(decl) && !ts.isVariableDeclaration(decl))
@@ -2861,7 +3436,9 @@ function neverReassigned(lowerer, sym) {
     // source file for module-level bindings. Writes anywhere inside
     // (nested closures included) disqualify.
     let scope = decl;
-    while (scope.parent !== undefined && !ts.isFunctionLike(scope.parent) && !ts.isSourceFile(scope.parent))
+    while (scope.parent !== undefined &&
+        !ts.isFunctionLike(scope.parent) &&
+        !ts.isSourceFile(scope.parent))
         scope = scope.parent;
     const root = scope.parent;
     if (root === undefined)
@@ -2890,8 +3467,10 @@ function neverReassigned(lowerer, sym) {
             }
         }
         if ((ts.isPrefixUnaryExpression(n) || ts.isPostfixUnaryExpression(n)) &&
-            (n.operator === ts.SyntaxKind.PlusPlusToken || n.operator === ts.SyntaxKind.MinusMinusToken) &&
-            ts.isIdentifier(n.operand) && lowerer.checker.getSymbolAtLocation(n.operand) === sym) {
+            (n.operator === ts.SyntaxKind.PlusPlusToken ||
+                n.operator === ts.SyntaxKind.MinusMinusToken) &&
+            ts.isIdentifier(n.operand) &&
+            lowerer.checker.getSymbolAtLocation(n.operand) === sym) {
             written = true;
             return;
         }
@@ -2934,7 +3513,11 @@ export function registerHttpClientFnBinding(lowerer, nameNode, init) {
     }
     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
     if (symbol) {
-        lowerer.httpClientFnBindings.set(symbol, { cond, trueSecure: t.module === "https", member: t.member });
+        lowerer.httpClientFnBindings.set(symbol, {
+            cond,
+            trueSecure: t.module === "https",
+            member: t.member,
+        });
     }
     return true;
 }
@@ -2959,14 +3542,32 @@ function lowerHttpsModuleCall(lowerer, expr, bi, loc) {
             // NULL-handler shape, here for the runtime-options record only
             // (the literal path keeps its historical two-argument surface).
             if (opts.dyn !== undefined) {
-                return { kind: "libCall", fn: "https.createServerDyn", args: [opts.dyn], type: NETSERVER_T, loc };
+                return {
+                    kind: "libCall",
+                    fn: "https.createServerDyn",
+                    args: [opts.dyn],
+                    type: NETSERVER_T,
+                    loc,
+                };
             }
             lowerer.noLowering("createServer with 1 arguments", expr, "the supported form is createServer({ cert, key }, (req, res) => ...)");
         }
         const cb = lowerRequestHandlerArg(lowerer, args[1]);
         return opts.dyn !== undefined
-            ? { kind: "libCall", fn: "https.createServerDynCb", args: [opts.dyn, cb], type: NETSERVER_T, loc }
-            : { kind: "libCall", fn: "https.createServer", args: [opts.cert, opts.key, cb], type: NETSERVER_T, loc };
+            ? {
+                kind: "libCall",
+                fn: "https.createServerDynCb",
+                args: [opts.dyn, cb],
+                type: NETSERVER_T,
+                loc,
+            }
+            : {
+                kind: "libCall",
+                fn: "https.createServer",
+                args: [opts.cert, opts.key, cb],
+                type: NETSERVER_T,
+                loc,
+            };
     }
     if (bi.member === "request" || bi.member === "get") {
         return lowerHttpClientCall(lowerer, expr, bi.member, loc, true);
@@ -3053,7 +3654,7 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
         }
         const auth = lowerer.lowerExpr(args[0]);
         if (auth.type.kind !== "string") {
-            lowerer.noLowering(`http2.connect with a '${lowerer.fmt(auth.type)}' authority`, args[0], "the authority is a string here (\"http://host:port\")");
+            lowerer.noLowering(`http2.connect with a '${lowerer.fmt(auth.type)}' authority`, args[0], 'the authority is a string here ("http://host:port")');
         }
         // connect(authority, options[, listener]): session-tuning options
         // are accepted and never evaluated (the core runs at defaults) —
@@ -3070,7 +3671,8 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
         let ca = { kind: "strLit", value: "", type: STRING, loc };
         const arg1IsDyn = args.length >= 2 &&
             (lowerer.typeOf(args[1]).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
-        if (args.length >= 2 && !arg1IsDyn &&
+        if (args.length >= 2 &&
+            !arg1IsDyn &&
             lowerer.checker.getCallSignatures(lowerer.typeOf(args[1])).length === 0) {
             if (ts.isObjectLiteralExpression(args[1])) {
                 for (const pr of args[1].properties) {
@@ -3109,7 +3711,10 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
                             ca = {
                                 kind: "libCall",
                                 fn: "tls.pemDyn",
-                                args: [v, { kind: "strLit", value: "an http2.connect 'ca' option", type: STRING, loc }],
+                                args: [
+                                    v,
+                                    { kind: "strLit", value: "an http2.connect 'ca' option", type: STRING, loc },
+                                ],
                                 type: BYTES_U8,
                                 loc,
                             };
@@ -3129,9 +3734,21 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
             // The listener is the 'connect' once-listener: (session, socket) or
             // fewer. Its result is ignored (voidized); handles pass by ref.
             const { cb } = lowerCallbackArg(lowerer, listenerNode, "connect listeners", 2, (p) => p.kind === "http2Session" || p.kind === "netSocket", "use (session, socket), (session), or ()", [HTTP2SESSION_T, NETSOCKET_T]);
-            return { kind: "libCall", fn: "http2.connectCb", args: [auth, reject, ca, cb], type: HTTP2SESSION_T, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.connectCb",
+                args: [auth, reject, ca, cb],
+                type: HTTP2SESSION_T,
+                loc,
+            };
         }
-        return { kind: "libCall", fn: "http2.connect", args: [auth, reject, ca], type: HTTP2SESSION_T, loc };
+        return {
+            kind: "libCall",
+            fn: "http2.connect",
+            args: [auth, reject, ca],
+            type: HTTP2SESSION_T,
+            loc,
+        };
     }
     if (bi.member === "getDefaultSettings") {
         // The constant defaults record, as a dyn value (the d.ts types it
@@ -3166,10 +3783,22 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
                 lowerer.noLowering("createSecureServer with a non-literal options argument", optsNode, "pass the options as an object literal ({ allowHTTP1: true, cert, key }) or a runtime record of those members");
             }
             if (handlerNode === null) {
-                return { kind: "libCall", fn: "http2.createSecureServerDyn", args: [dynOpts], type: NETSERVER_T, loc };
+                return {
+                    kind: "libCall",
+                    fn: "http2.createSecureServerDyn",
+                    args: [dynOpts],
+                    type: NETSERVER_T,
+                    loc,
+                };
             }
             const cb = lowerRequestHandlerArg(lowerer, handlerNode);
-            return { kind: "libCall", fn: "http2.createSecureServerDynCb", args: [dynOpts, cb], type: NETSERVER_T, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.createSecureServerDynCb",
+                args: [dynOpts, cb],
+                type: NETSERVER_T,
+                loc,
+            };
         }
         let cert = null;
         let key = null;
@@ -3237,7 +3866,8 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
                         ts.isPropertyAssignment(whenTrue.properties[0]) &&
                         (ts.isIdentifier(whenTrue.properties[0].name) ||
                             ts.isStringLiteral(whenTrue.properties[0].name)) &&
-                        whenTrue.properties[0].name.text === "SNICallback" &&
+                        whenTrue.properties[0].name.text ===
+                            "SNICallback" &&
                         whenTrue.properties[0].initializer.getText() === condText;
                     if (!ok) {
                         lowerer.noLowering("createSecureServer options with a conditional spread", prop, "the lowered conditional spread is exactly ...(x ? { SNICallback: x } : {}) — the included value must BE the condition");
@@ -3286,7 +3916,10 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
                     v = {
                         kind: "libCall",
                         fn: "tls.pemDyn",
-                        args: [v, { kind: "strLit", value: `a createSecureServer '${k}' option`, type: STRING, loc }],
+                        args: [
+                            v,
+                            { kind: "strLit", value: `a createSecureServer '${k}' option`, type: STRING, loc },
+                        ],
                         type: BYTES_U8,
                         loc,
                     };
@@ -3306,13 +3939,18 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
                 // true }` — the portless RFC 8441 advertisement): every member is
                 // itself inert h2-session state, so the same no-observable-skip
                 // argument covers the one level of nesting.
-                const isScalarLiteral = (e) => ts.isNumericLiteral(e) || ts.isStringLiteralLike(e) ||
-                    e.kind === ts.SyntaxKind.TrueKeyword || e.kind === ts.SyntaxKind.FalseKeyword;
+                const isScalarLiteral = (e) => ts.isNumericLiteral(e) ||
+                    ts.isStringLiteralLike(e) ||
+                    e.kind === ts.SyntaxKind.TrueKeyword ||
+                    e.kind === ts.SyntaxKind.FalseKeyword;
                 const isLiteralObjectOfLiterals = (e) => ts.isObjectLiteralExpression(e) &&
-                    e.properties.every((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && isScalarLiteral(p.initializer));
+                    e.properties.every((p) => ts.isPropertyAssignment(p) &&
+                        ts.isIdentifier(p.name) &&
+                        isScalarLiteral(p.initializer));
                 if (k === "settings" && initializer !== null && ts.isObjectLiteralExpression(initializer)) {
                     for (const setting of initializer.properties) {
-                        if (ts.isPropertyAssignment(setting) && ts.isIdentifier(setting.name) &&
+                        if (ts.isPropertyAssignment(setting) &&
+                            ts.isIdentifier(setting.name) &&
                             setting.name.text === "enableConnectProtocol") {
                             if (setting.initializer.kind !== ts.SyntaxKind.TrueKeyword &&
                                 setting.initializer.kind !== ts.SyntaxKind.FalseKeyword) {
@@ -3344,7 +3982,7 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
             lowerer.noLowering("createSecureServer without both cert and key", optsNode, "the supported options object is { allowHTTP1?, cert, key } (PEM strings or Buffers)");
         }
         if (sni !== null && handlerNode !== null) {
-            lowerer.noLowering("createSecureServer with both an SNICallback and an eager handler", expr, "register the handler separately: server.on(\"request\", (req, res) => ...)");
+            lowerer.noLowering("createSecureServer with both an SNICallback and an eager handler", expr, 'register the handler separately: server.on("request", (req, res) => ...)');
         }
         if (!allowHttp1) {
             // The REAL h2-over-TLS server (scr_http2.c + scr_tls.c): ALPN
@@ -3357,18 +3995,48 @@ function lowerHttp2ModuleCall(lowerer, expr, bi, loc) {
             }
             if (handlerNode !== null) {
                 const cb = lowerRequestHandlerArg(lowerer, handlerNode);
-                return { kind: "libCall", fn: "http2.createSecureServerH2Req", args: [cert, key, cb, boolLit(enableConnectProtocol, loc)], type: NETSERVER_T, loc };
+                return {
+                    kind: "libCall",
+                    fn: "http2.createSecureServerH2Req",
+                    args: [cert, key, cb, boolLit(enableConnectProtocol, loc)],
+                    type: NETSERVER_T,
+                    loc,
+                };
             }
-            return { kind: "libCall", fn: "http2.createSecureServerH2", args: [cert, key, boolLit(enableConnectProtocol, loc)], type: NETSERVER_T, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.createSecureServerH2",
+                args: [cert, key, boolLit(enableConnectProtocol, loc)],
+                type: NETSERVER_T,
+                loc,
+            };
         }
         if (sni !== null) {
-            return { kind: "libCall", fn: "http2.createSecureServerSni", args: [cert, key, sni, boolLit(enableConnectProtocol, loc)], type: NETSERVER_T, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.createSecureServerSni",
+                args: [cert, key, sni, boolLit(enableConnectProtocol, loc)],
+                type: NETSERVER_T,
+                loc,
+            };
         }
         if (handlerNode !== null) {
             const cb = lowerRequestHandlerArg(lowerer, handlerNode);
-            return { kind: "libCall", fn: "http2.createSecureServerReq", args: [cert, key, cb, boolLit(enableConnectProtocol, loc)], type: NETSERVER_T, loc };
+            return {
+                kind: "libCall",
+                fn: "http2.createSecureServerReq",
+                args: [cert, key, cb, boolLit(enableConnectProtocol, loc)],
+                type: NETSERVER_T,
+                loc,
+            };
         }
-        return { kind: "libCall", fn: "http2.createSecureServer", args: [cert, key, boolLit(enableConnectProtocol, loc)], type: NETSERVER_T, loc };
+        return {
+            kind: "libCall",
+            fn: "http2.createSecureServer",
+            args: [cert, key, boolLit(enableConnectProtocol, loc)],
+            type: NETSERVER_T,
+            loc,
+        };
     }
     lowerer.noLowering(`http2.${bi.member}`, expr, builtinFenceHintOf("http2", bi.member) ??
         "createSecureServer({ allowHTTP1: true, cert, key }) and the h2-only form are lowered", lowerer.resolveValueSymbol(expr.expression));
@@ -3398,9 +4066,7 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
      * read — each use is its own IR). */
     const secureExpr = () => {
         const c = lowerer.lowerCondition(binding.cond);
-        return binding.trueSecure
-            ? c
-            : { kind: "unary", op: "!", operand: c, type: BOOL, loc };
+        return binding.trueSecure ? c : { kind: "unary", op: "!", operand: c, type: BOOL, loc };
     };
     const args = expr.arguments;
     if (args.length < 1 || args.length > 2) {
@@ -3421,7 +4087,13 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             // A URL OBJECT is its href through the same parse — Node's own
             // reading of the argument, and the serialization round-trips.
             const url = t.kind === "url"
-                ? { kind: "libCall", fn: "url.href", args: [lowerer.lowerExpr(optsNode)], type: STRING, loc }
+                ? {
+                    kind: "libCall",
+                    fn: "url.href",
+                    args: [lowerer.lowerExpr(optsNode)],
+                    type: STRING,
+                    loc,
+                }
                 : lowerer.lowerExprExpecting(optsNode, STRING);
             const methodLit = { kind: "strLit", value: "GET", type: STRING, loc };
             const autoEnd = boolLit(member === "get", loc);
@@ -3432,14 +4104,20 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             }
             const { cb } = lowerCallbackArg(lowerer, args[1], "response callbacks", 1, (p) => p.kind === "httpReq", "use (res) or ()", [HTTPREQ_T]);
             const fn = isTls ? "https.requestUrlCb" : "http.requestUrlCb";
-            return { kind: "libCall", fn, args: [url, methodLit, autoEnd, cb], type: HTTPCLIENTREQ_T, loc };
+            return {
+                kind: "libCall",
+                fn,
+                args: [url, methodLit, autoEnd, cb],
+                type: HTTPCLIENTREQ_T,
+                loc,
+            };
         }
         lowerer.noLowering(t?.kind === "string"
             ? `a URL-string first argument through a request-function binding`
             : `${member} with a non-literal options argument`, optsNode, t?.kind === "string"
-            // Only the binding mode reaches here now: the scheme would have to
-            // agree with a dial chosen at runtime.
-            ? "call http.request / https.request directly for the URL-string form, or pass the options as an object literal"
+            ? // Only the binding mode reaches here now: the scheme would have to
+                // agree with a dial chosen at runtime.
+                "call http.request / https.request directly for the URL-string form, or pass the options as an object literal"
             : "pass the options as an object literal: { hostname, port, path, method, timeout?, headers? }");
     }
     let host = null;
@@ -3468,9 +4146,12 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
         // plain client has no TLS layer to configure).
         if (ts.isSpreadAssignment(prop)) {
             const cs = conditionalSpreadOf(prop.expression);
-            if (cs !== null && cs !== "unsupported" && cs.props.length === 1 &&
+            if (cs !== null &&
+                cs !== "unsupported" &&
+                cs.props.length === 1 &&
                 cs.props[0].name.text === "rejectUnauthorized" &&
-                ts.isPropertyAssignment(cs.props[0]) && secureish) {
+                ts.isPropertyAssignment(cs.props[0]) &&
+                secureish) {
                 const cond = lowerer.lowerCondition(cs.cond);
                 const v = lowerer.lowerExpr(cs.props[0].initializer);
                 if (v.type.kind !== "bool") {
@@ -3512,10 +4193,17 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             // option's type — a mismatch is the catchable path-annotated
             // TypeError, the boundary's stance.
             if (v.type.kind === "dyn") {
-                return { kind: "dynCheck", value: v, type: want === "string" ? STRING : F64, loc: locOf(prop) };
+                return {
+                    kind: "dynCheck",
+                    value: v,
+                    type: want === "string" ? STRING : F64,
+                    loc: locOf(prop),
+                };
             }
             if (v.type.kind !== want) {
-                lowerer.noLowering(`a ${member} '${key}' option of '${lowerer.fmt(v.type)}' values`, prop, want === "string" ? "the option value must be a string" : "the option value must be a number");
+                lowerer.noLowering(`a ${member} '${key}' option of '${lowerer.fmt(v.type)}' values`, prop, want === "string"
+                    ? "the option value must be a string"
+                    : "the option value must be a number");
             }
             return v;
         };
@@ -3554,7 +4242,9 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
                     lowerer.noLowering(`${member} with a shorthand createConnection option`, prop, "spell it out: createConnection: theDialer");
                 }
                 const v = lowerer.lowerExpr(initializer);
-                if (v.type.kind !== "func" || v.type.params.length !== 0 || v.type.ret.kind !== "netSocket") {
+                if (v.type.kind !== "func" ||
+                    v.type.params.length !== 0 ||
+                    v.type.ret.kind !== "netSocket") {
                     lowerer.noLowering(`a ${member} 'createConnection' option of '${lowerer.fmt(v.type)}' values`, prop, "the dialer is () => net.Socket — no arguments, returning the socket to use");
                 }
                 connCb = v;
@@ -3603,8 +4293,7 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
                     break;
                 }
                 if (e !== null &&
-                    (e.kind === ts.SyntaxKind.NullKeyword ||
-                        (ts.isIdentifier(e) && e.text === "undefined"))) {
+                    (e.kind === ts.SyntaxKind.NullKeyword || (ts.isIdentifier(e) && e.text === "undefined"))) {
                     break; // the default agent: what the agent-free call compiles
                 }
                 const v = initializer !== null
@@ -3631,17 +4320,25 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
         // non-literal headers record cannot be checked for one, so the combo
         // fences instead of double-sending.
         if (headers === null) {
-            headers = { kind: "arrayLit", elems: [strLit("Connection", loc), strLit("close", loc)], type: arrayOf(STRING), loc };
+            headers = {
+                kind: "arrayLit",
+                elems: [strLit("Connection", loc), strLit("close", loc)],
+                type: arrayOf(STRING),
+                loc,
+            };
         }
         else if (headers.kind === "arrayLit") {
             const hasConnection = headers.elems.some((el, i) => i % 2 === 0 && el.kind === "strLit" && el.value.toLowerCase() === "connection");
             if (!hasConnection) {
-                headers = { ...headers, elems: [...headers.elems, strLit("Connection", loc), strLit("close", loc)] };
+                headers = {
+                    ...headers,
+                    elems: [...headers.elems, strLit("Connection", loc), strLit("close", loc)],
+                };
             }
         }
         else {
             lowerer.noLowering(`${member} with agent: false and a non-literal headers record`, agentClose, "agent: false lowers by injecting Connection: close into a LITERAL headers object — " +
-                "add connection: \"close\" to the record instead, or write the headers inline");
+                'add connection: "close" to the record instead, or write the headers inline');
         }
     }
     if (connCb !== null && (host !== null || port !== null)) {
@@ -3660,10 +4357,19 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
     // TLS arm, 80 on the plain one — exactly each client's own default.
     // With an AGENT the sentinel -1 says "no port option": the runtime
     // consults the agent's (settable) defaultPort first, Node's merge.
-    port ??= binding !== null
-        ? { kind: "ternary", cond: secureExpr(), then: numLit(443, loc), else_: numLit(80, loc), type: F64, loc }
-        : agentVal !== null ? numLit(-1, loc)
-            : numLit(secure === true ? 443 : 80, loc);
+    port ??=
+        binding !== null
+            ? {
+                kind: "ternary",
+                cond: secureExpr(),
+                then: numLit(443, loc),
+                else_: numLit(80, loc),
+                type: F64,
+                loc,
+            }
+            : agentVal !== null
+                ? numLit(-1, loc)
+                : numLit(secure === true ? 443 : 80, loc);
     path ??= strLit("/", loc);
     method ??= strLit("GET", loc);
     timeout ??= numLit(0, loc);
@@ -3675,7 +4381,13 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
             return { kind: "libCall", fn: "http.requestConn", args: base, type: HTTPCLIENTREQ_T, loc };
         }
         const { cb } = lowerCallbackArg(lowerer, args[1], "response callbacks", 1, (p) => p.kind === "httpReq", "use (res) or ()", [HTTPREQ_T]);
-        return { kind: "libCall", fn: "http.requestConnCb", args: [...base, cb], type: HTTPCLIENTREQ_T, loc };
+        return {
+            kind: "libCall",
+            fn: "http.requestConnCb",
+            args: [...base, cb],
+            type: HTTPCLIENTREQ_T,
+            loc,
+        };
     }
     const base = [host, port, path, method, timeout, headers, autoEnd];
     if (secureish) {
@@ -3688,15 +4400,27 @@ function lowerHttpClientCall(lowerer, expr, member, loc, secure = false) {
     if (binding !== null)
         base.unshift(secureExpr());
     if (args.length === 1) {
-        const fn = binding !== null ? "https.requestFn"
-            : secure === true ? (agentVal !== null ? "https.requestAgent" : "https.request")
-                : agentVal !== null ? "http.requestAgent" : "http.request";
+        const fn = binding !== null
+            ? "https.requestFn"
+            : secure === true
+                ? agentVal !== null
+                    ? "https.requestAgent"
+                    : "https.request"
+                : agentVal !== null
+                    ? "http.requestAgent"
+                    : "http.request";
         return { kind: "libCall", fn, args: base, type: HTTPCLIENTREQ_T, loc };
     }
     const { cb } = lowerCallbackArg(lowerer, args[1], "response callbacks", 1, (p) => p.kind === "httpReq", "use (res) or ()", [HTTPREQ_T]);
-    const fn = binding !== null ? "https.requestFnCb"
-        : secure === true ? (agentVal !== null ? "https.requestAgentCb" : "https.requestCb")
-            : agentVal !== null ? "http.requestAgentCb" : "http.requestCb";
+    const fn = binding !== null
+        ? "https.requestFnCb"
+        : secure === true
+            ? agentVal !== null
+                ? "https.requestAgentCb"
+                : "https.requestCb"
+            : agentVal !== null
+                ? "http.requestAgentCb"
+                : "http.requestCb";
     return { kind: "libCall", fn, args: [...base, cb], type: HTTPCLIENTREQ_T, loc };
 }
 /** The headers option of http.request: an object literal with literal
@@ -3776,7 +4500,13 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
         const header = lowerer.lowerExprExpecting(args[0], STRING);
         const value = lowerer.lowerExprExpecting(args[1], STRING);
-        return { kind: "libCall", fn: "http.clientSetHeader", args: [receiver, header, value], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.clientSetHeader",
+            args: [receiver, header, value],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "getHeader" || name === "hasHeader" || name === "removeHeader") {
         if (name === "removeHeader")
@@ -3785,8 +4515,11 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             lowerer.noLowering(`request.${name} arguments`, call, `pass one header name`);
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
         const header = lowerer.lowerExprExpecting(args[0], STRING);
-        const fn = name === "getHeader" ? "http.clientGetHeader"
-            : name === "hasHeader" ? "http.clientHasHeader" : "http.clientRemoveHeader";
+        const fn = name === "getHeader"
+            ? "http.clientGetHeader"
+            : name === "hasHeader"
+                ? "http.clientHasHeader"
+                : "http.clientRemoveHeader";
         const type = name === "getHeader" ? lowerer.envValueType() : name === "hasHeader" ? BOOL : VOID;
         return { kind: "libCall", fn, args: [receiver, header], type, loc };
     }
@@ -3794,17 +4527,29 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
         if (args.length !== 0)
             lowerer.noLowering(`request.${name} arguments`, call, `${name}() takes no arguments`);
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
-        const fn = name === "getHeaderNames" ? "http.clientGetHeaderNames"
-            : name === "getRawHeaderNames" ? "http.clientGetRawHeaderNames" : "http.clientGetHeaders";
-        return { kind: "libCall", fn, args: [receiver], type: name === "getHeaders" ? DYN : arrayOf(STRING), loc };
+        const fn = name === "getHeaderNames"
+            ? "http.clientGetHeaderNames"
+            : name === "getRawHeaderNames"
+                ? "http.clientGetRawHeaderNames"
+                : "http.clientGetHeaders";
+        return {
+            kind: "libCall",
+            fn,
+            args: [receiver],
+            type: name === "getHeaders" ? DYN : arrayOf(STRING),
+            loc,
+        };
     }
     if (name === "flushHeaders" || name === "cork" || name === "uncork") {
         requireStatementPosition(lowerer, call, `request.${name}()`);
         if (args.length !== 0)
             lowerer.noLowering(`request.${name} with arguments`, call, `${name}() takes no arguments`);
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
-        const fn = name === "flushHeaders" ? "http.clientFlushHeaders"
-            : name === "cork" ? "http.clientCork" : "http.clientUncork";
+        const fn = name === "flushHeaders"
+            ? "http.clientFlushHeaders"
+            : name === "cork"
+                ? "http.clientCork"
+                : "http.clientUncork";
         return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
     }
     if (name === "setNoDelay") {
@@ -3813,7 +4558,13 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             lowerer.noLowering("request.setNoDelay arguments", call, "pass an optional boolean");
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
         const enable = args.length === 0 ? boolLit(true, loc) : lowerer.lowerExprExpecting(args[0], BOOL);
-        return { kind: "libCall", fn: "http.clientSetNoDelay", args: [receiver, enable], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.clientSetNoDelay",
+            args: [receiver, enable],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "setSocketKeepAlive") {
         requireStatementPosition(lowerer, call, "request.setSocketKeepAlive(...)");
@@ -3822,7 +4573,13 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
         const enable = args.length === 0 ? boolLit(true, loc) : lowerer.lowerExprExpecting(args[0], BOOL);
         const delay = args.length < 2 ? numLit(0, loc) : lowerer.lowerExprExpecting(args[1], F64);
-        return { kind: "libCall", fn: "http.clientSetSocketKeepAlive", args: [receiver, enable, delay], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.clientSetSocketKeepAlive",
+            args: [receiver, enable, delay],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "setTimeout") {
         if (args.length < 1 || args.length > 2)
@@ -3844,13 +4601,21 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             lowerer.noLowering("request.addTrailers argument count", call, "pass one trailer object or pair-list literal");
         const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
         const pairs = lowerHttpTrailersOption(lowerer, args[0]);
-        return { kind: "libCall", fn: "http.clientAddTrailers", args: [receiver, pairs], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.clientAddTrailers",
+            args: [receiver, pairs],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "write" || name === "end") {
         requireStatementPosition(lowerer, call, `request.${name}(...)`);
         const minArgs = name === "write" ? 1 : 0;
         if (args.length < minArgs || args.length > 1) {
-            lowerer.noLowering(`${name} with ${args.length} arguments`, call, name === "write" ? "the supported form is write(data)" : "the supported forms are end() and end(data)");
+            lowerer.noLowering(`${name} with ${args.length} arguments`, call, name === "write"
+                ? "the supported form is write(data)"
+                : "the supported forms are end() and end(data)");
         }
         const receiver = lowerer.lowerExpr(access.expression);
         if (args.length === 0) {
@@ -3878,7 +4643,13 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             lowerer.noLowering(`${name} with ${args.length} arguments`, call, `${name}() takes no arguments here`);
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: name === "destroy" ? "http.clientDestroy" : "http.clientAbort", args: [receiver], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: name === "destroy" ? "http.clientDestroy" : "http.clientAbort",
+            args: [receiver],
+            type: VOID,
+            loc,
+        };
     }
     if ((name === "on" || name === "once" || name === "addListener") && args.length === 2) {
         requireStatementPosition(lowerer, call, `request.${name}(...)`);
@@ -3888,21 +4659,43 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExpr(access.expression);
         if (event === "response") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "response listeners", 1, (p) => p.kind === "httpReq", "use (res) or ()", [HTTPREQ_T]);
-            return { kind: "libCall", fn: "http.clientOnResponse", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.clientOnResponse",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "socket") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "socket listeners", 1, (p) => p.kind === "netSocket", "use (socket) or ()", [NETSOCKET_T]);
-            return { kind: "libCall", fn: "http.clientOnSocket", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.clientOnSocket",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "error") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "error listeners", 1, (p) => p.kind === "object" && p.className === "%Error", "use (err) or ()", [ERROR_T]);
-            return { kind: "libCall", fn: "http.clientOnError", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.clientOnError",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "timeout" || event === "close" || event === "finish" || event === "abort") {
             const { cb } = lowerCallbackArg(lowerer, args[1], `${event} listeners`, 0, () => false, "use ()", []);
-            const fn = event === "timeout" ? "http.clientOnTimeout"
-                : event === "close" ? "http.clientOnClose"
-                    : event === "abort" ? "http.clientOnAbort" : "http.clientOnFinish";
+            const fn = event === "timeout"
+                ? "http.clientOnTimeout"
+                : event === "close"
+                    ? "http.clientOnClose"
+                    : event === "abort"
+                        ? "http.clientOnAbort"
+                        : "http.clientOnFinish";
             return { kind: "libCall", fn, args: [receiver, cb, once], type: VOID, loc };
         }
         if (event === "upgrade") {
@@ -3922,7 +4715,13 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
                 (p2 !== undefined && !(p2.kind === "bytes" && p2.elem === "u8"))) {
                 lowerer.unsupported("SC1090", args[1], "upgrade listeners whose parameters are not (res: IncomingMessage, socket: Socket, head: Buffer)");
             }
-            return { kind: "libCall", fn: "http.clientOnUpgrade", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.clientOnUpgrade",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         lowerer.noLowering(`request.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"response", "socket", "upgrade", "error", "timeout", "finish", "abort", and "close" are the supported request events (as literals)');
     }
@@ -3958,7 +4757,8 @@ export function lowerSocketInstanceOf(lowerer, expr, loc) {
     const isNetSocketRef = (ts.isPropertyAccessExpression(rhs) &&
         rhs.name.text === "Socket" &&
         lowerer.builtinMemberOf(rhs)?.module === "net") ||
-        (ts.isIdentifier(rhs) && lowerer.builtinImportOf(rhs)?.module === "net" &&
+        (ts.isIdentifier(rhs) &&
+            lowerer.builtinImportOf(rhs)?.module === "net" &&
             lowerer.builtinImportOf(rhs)?.member === "Socket");
     if (!isNetSocketRef)
         return null;
@@ -3972,15 +4772,25 @@ export function lowerSocketInstanceOf(lowerer, expr, loc) {
     const left = lowerer.lowerExpr(expr.left);
     if (left.type.kind !== "union" || left.type.unionId !== leftT.unionId)
         return null;
-    return { kind: "unionIsTag", unionId: leftT.unionId, tag, negated: false, value: left, type: BOOL, loc };
+    return {
+        kind: "unionIsTag",
+        unionId: leftT.unionId,
+        tag,
+        negated: false,
+        value: left,
+        type: BOOL,
+        loc,
+    };
 }
 /** True when `node` reads `.headers` off an IncomingMessage — the
  * receiver shape of both header-read forms. */
 function httpReqFieldCollection(lowerer, node) {
     if (ts.isPropertyAccessExpression(node) &&
         !node.questionDotToken &&
-        (node.name.text === "headers" || node.name.text === "trailers" ||
-            node.name.text === "headersDistinct" || node.name.text === "trailersDistinct") &&
+        (node.name.text === "headers" ||
+            node.name.text === "trailers" ||
+            node.name.text === "headersDistinct" ||
+            node.name.text === "trailersDistinct") &&
         lowerer.mapTypeOf(lowerer.typeOf(node.expression))?.kind === "httpReq" &&
         lowerer.isStdlibMember(node))
         return node.name.text;
@@ -4002,11 +4812,17 @@ export function lowerHttpHeadersElement(lowerer, expr) {
     const receiver = lowerer.lowerExpr(recv);
     return {
         kind: "libCall",
-        fn: collection === "headers" ? "http.reqHeader"
-            : collection === "trailers" ? "http.reqTrailer"
-                : collection === "headersDistinct" ? "http.reqHeaderValues" : "http.reqTrailerValues",
+        fn: collection === "headers"
+            ? "http.reqHeader"
+            : collection === "trailers"
+                ? "http.reqTrailer"
+                : collection === "headersDistinct"
+                    ? "http.reqHeaderValues"
+                    : "http.reqTrailerValues",
         args: [receiver, key],
-        type: collection.endsWith("Distinct") ? lowerer.withUndefinedArm(arrayOf(STRING)) : lowerer.envValueType(),
+        type: collection.endsWith("Distinct")
+            ? lowerer.withUndefinedArm(arrayOf(STRING))
+            : lowerer.envValueType(),
         loc: locOf(expr),
     };
 }
@@ -4029,7 +4845,13 @@ function lowerHttpReqMethodCall(lowerer, call, access) {
         if (args.length === 1)
             return { kind: "libCall", fn: "http.reqSetTimeout", args: [receiver, ms], type: VOID, loc };
         const { cb } = lowerCallbackArg(lowerer, args[1], "message timeout callbacks", 0, () => false, "use ()", []);
-        return { kind: "libCall", fn: "http.reqSetTimeoutCb", args: [receiver, ms, cb], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.reqSetTimeoutCb",
+            args: [receiver, ms, cb],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "resume" || name === "destroy") {
         requireStatementPosition(lowerer, call, `req.${name}()`);
@@ -4062,9 +4884,12 @@ function lowerHttpReqMethodCall(lowerer, call, access) {
         }
         const receiver = coerceToHandle(lowerer, access.expression, HTTPREQ_T);
         const dst = lowerer.lowerExpr(args[0]);
-        const fn = dst.type.kind === "httpRes" ? "http.reqPipeRes"
-            : dst.type.kind === "httpClientReq" ? "http.reqPipeClient"
-                : dst.type.kind === "netSocket" ? "http.reqPipeSock"
+        const fn = dst.type.kind === "httpRes"
+            ? "http.reqPipeRes"
+            : dst.type.kind === "httpClientReq"
+                ? "http.reqPipeClient"
+                : dst.type.kind === "netSocket"
+                    ? "http.reqPipeSock"
                     : null;
         if (fn === null) {
             lowerer.noLowering(`pipe into '${lowerer.fmt(dst.type)}' destinations`, args[0], "an IncomingMessage pipes into a ServerResponse, a ClientRequest, or a Socket");
@@ -4087,17 +4912,35 @@ function lowerHttpReqMethodCall(lowerer, call, access) {
         }
         if (event === "error") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "error listeners", 1, (p) => p.kind === "object" && p.className === "%Error", "use (err) or ()", [ERROR_T]);
-            return { kind: "libCall", fn: "http.reqOnError", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.reqOnError",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "close") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "http.reqOnClose", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.reqOnClose",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "aborted") {
             // The h2 compat event (Http2ServerRequest 'aborted'); an http/1
             // request registers too and never fires — the parser lane's story.
             const { cb } = lowerCallbackArg(lowerer, args[1], "aborted listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "http.reqOnAborted", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.reqOnAborted",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         lowerer.noLowering(`req.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"data", "end", "error", "close", and "aborted" are the supported request events (as literals)');
     }
@@ -4137,7 +4980,13 @@ function lowerHttpResMethodCall(lowerer, call, access) {
         if (name !== "writeEarlyHints") {
             if (args.length !== 0)
                 lowerer.noLowering(`res.${name} callback`, call, `${name}() supports no callback here`);
-            return { kind: "libCall", fn: name === "writeContinue" ? "http.resWriteContinue" : "http.resWriteProcessing", args: [receiver], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: name === "writeContinue" ? "http.resWriteContinue" : "http.resWriteProcessing",
+                args: [receiver],
+                type: VOID,
+                loc,
+            };
         }
         if (args.length !== 1)
             lowerer.noLowering("res.writeEarlyHints arguments", call, "pass one header object or Record<string, string> without a callback");
@@ -4169,23 +5018,41 @@ function lowerHttpResMethodCall(lowerer, call, access) {
             }
             pairs = { kind: "call", callee: helper, args: [value], type: arrayOf(STRING), loc };
         }
-        return { kind: "libCall", fn: "http.resWriteEarlyHints", args: [receiver, pairs], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.resWriteEarlyHints",
+            args: [receiver, pairs],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "getHeaderNames" || name === "getRawHeaderNames" || name === "getHeaders") {
         if (args.length !== 0)
             lowerer.noLowering(`res.${name} arguments`, call, `${name}() takes no arguments`);
         const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
-        const fn = name === "getHeaderNames" ? "http.resGetHeaderNames"
-            : name === "getRawHeaderNames" ? "http.resGetRawHeaderNames" : "http.resGetHeaders";
-        return { kind: "libCall", fn, args: [receiver], type: name === "getHeaders" ? DYN : arrayOf(STRING), loc };
+        const fn = name === "getHeaderNames"
+            ? "http.resGetHeaderNames"
+            : name === "getRawHeaderNames"
+                ? "http.resGetRawHeaderNames"
+                : "http.resGetHeaders";
+        return {
+            kind: "libCall",
+            fn,
+            args: [receiver],
+            type: name === "getHeaders" ? DYN : arrayOf(STRING),
+            loc,
+        };
     }
     if (name === "flushHeaders" || name === "cork" || name === "uncork") {
         requireStatementPosition(lowerer, call, `res.${name}()`);
         if (args.length !== 0)
             lowerer.noLowering(`res.${name} with arguments`, call, `${name}() takes no arguments`);
         const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
-        const fn = name === "flushHeaders" ? "http.resFlushHeaders"
-            : name === "cork" ? "http.resCork" : "http.resUncork";
+        const fn = name === "flushHeaders"
+            ? "http.resFlushHeaders"
+            : name === "cork"
+                ? "http.resCork"
+                : "http.resUncork";
         return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
     }
     if (name === "addTrailers") {
@@ -4224,7 +5091,13 @@ function lowerHttpResMethodCall(lowerer, call, access) {
         if (value.type.kind !== "string") {
             lowerer.noLowering(`setHeader with a '${lowerer.fmt(value.type)}' value`, args[1], "header values are strings or numbers here");
         }
-        return { kind: "libCall", fn: "http.resSetHeader", args: [receiver, header, value], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.resSetHeader",
+            args: [receiver, header, value],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "writeHead") {
         if (args.length < 1 || args.length > 3) {
@@ -4339,11 +5212,14 @@ function lowerHttpResMethodCall(lowerer, call, access) {
             const { cb } = lowerCallbackArg(lowerer, args[1], "end callbacks", 0, () => false, "use ()", []);
             cbArg = cb;
         }
-        else if (name === "end" && args.length === 1 &&
+        else if (name === "end" &&
+            args.length === 1 &&
             lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind !== "string" &&
             lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind !== "bytes") {
             const probe = lowerer.typeOf(args[0]);
-            if (lowerer.mapTypeOf(probe)?.kind === "func" || lowerer.mapTypeOf(probe) === null || lowerer.mapTypeOf(probe)?.kind === "dyn") {
+            if (lowerer.mapTypeOf(probe)?.kind === "func" ||
+                lowerer.mapTypeOf(probe) === null ||
+                lowerer.mapTypeOf(probe)?.kind === "dyn") {
                 const { cb } = lowerCallbackArg(lowerer, args[0], "end callbacks", 0, () => false, "use ()", []);
                 cbArg = cb;
                 dataNode = undefined;
@@ -4361,16 +5237,36 @@ function lowerHttpResMethodCall(lowerer, call, access) {
                     name: helper,
                     params,
                     returnType: VOID,
-                    locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+                    locals: params.map((p) => ({
+                        id: p.localId,
+                        name: p.name,
+                        type: p.type,
+                        mutable: false,
+                    })),
                     body: [
                         {
                             kind: "exprStmt",
-                            expr: { kind: "libCall", fn: "http.resOnFinish", args: [varRef(params[0].localId, params[0].type, loc), varRef(params[all.length - 1].localId, params[all.length - 1].type, loc)], type: VOID, loc },
+                            expr: {
+                                kind: "libCall",
+                                fn: "http.resOnFinish",
+                                args: [
+                                    varRef(params[0].localId, params[0].type, loc),
+                                    varRef(params[all.length - 1].localId, params[all.length - 1].type, loc),
+                                ],
+                                type: VOID,
+                                loc,
+                            },
                             loc,
                         },
                         {
                             kind: "exprStmt",
-                            expr: { kind: "libCall", fn, args: callArgs.map((_, i) => varRef(params[i].localId, params[i].type, loc)), type: VOID, loc },
+                            expr: {
+                                kind: "libCall",
+                                fn,
+                                args: callArgs.map((_, i) => varRef(params[i].localId, params[i].type, loc)),
+                                type: VOID,
+                                loc,
+                            },
                             loc,
                         },
                     ],
@@ -4420,12 +5316,30 @@ function lowerHttpResMethodCall(lowerer, call, access) {
         const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
         const header = lowerer.lowerExprExpecting(args[0], STRING);
         if (name === "getHeader") {
-            return { kind: "libCall", fn: "http.resGetHeader", args: [receiver, header], type: lowerer.envValueType(), loc };
+            return {
+                kind: "libCall",
+                fn: "http.resGetHeader",
+                args: [receiver, header],
+                type: lowerer.envValueType(),
+                loc,
+            };
         }
         if (name === "hasHeader") {
-            return { kind: "libCall", fn: "http.resHasHeader", args: [receiver, header], type: BOOL, loc };
+            return {
+                kind: "libCall",
+                fn: "http.resHasHeader",
+                args: [receiver, header],
+                type: BOOL,
+                loc,
+            };
         }
-        return { kind: "libCall", fn: "http.resRemoveHeader", args: [receiver, header], type: VOID, loc };
+        return {
+            kind: "libCall",
+            fn: "http.resRemoveHeader",
+            args: [receiver, header],
+            type: VOID,
+            loc,
+        };
     }
     if (name === "destroy") {
         requireStatementPosition(lowerer, call, "res.destroy()");
@@ -4443,7 +5357,13 @@ function lowerHttpResMethodCall(lowerer, call, access) {
         const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
         if (event === "close") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close listeners", 0, () => false, "use ()", []);
-            return { kind: "libCall", fn: "http.resOnClose", args: [receiver, cb, once], type: VOID, loc };
+            return {
+                kind: "libCall",
+                fn: "http.resOnClose",
+                args: [receiver, cb, once],
+                type: VOID,
+                loc,
+            };
         }
         if (event === "finish") {
             const { cb } = lowerCallbackArg(lowerer, args[1], "finish listeners", 0, () => false, "use ()", []);