@scriptc/compiler 0.1.4 → 0.1.5

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

@@ -865,25 +865,26 @@ export function lowerServerCloseOverrideAssignment(lowerer, left, right, loc) {
         loc,
     };
 }
-/** `res.statusCode = 404` / `res.statusMessage = "Nope"` — Node's
- * writable ServerResponse properties (the implicit head reads them):
- * routed from lower-stmts' property-assignment path beside the
- * close-override hook. Null when the target isn't one of the two. */
+/** Writable ServerResponse properties consulted by the implicit head and
+ * the strict body-length check. Null when the target isn't one of them. */
 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")
+    if (name !== "statusCode" && name !== "statusMessage" &&
+        name !== "sendDate" && name !== "strictContentLength")
         return null;
     if (lowerer.mapTypeOf(lowerer.typeOf(left.expression))?.kind !== "httpRes")
         return null;
     if (!lowerer.isStdlibMember(left))
         return null;
-    const receiver = lowerer.lowerExpr(left.expression);
+    const receiver = coerceToHandle(lowerer, left.expression, HTTPRES_T);
     const value = name === "statusCode"
         ? lowerer.lowerExprExpecting(right, F64)
-        : lowerer.lowerExprExpecting(right, STRING);
-    const fn = name === "statusCode" ? "http.resStatusSet" : "http.resStatusMsgSet";
+        : lowerer.lowerExprExpecting(right, name === "statusMessage" ? STRING : BOOL);
+    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 },
@@ -924,6 +925,28 @@ function lowerNetServerMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if (name === "setTimeout") {
+        if (args.length < 1 || args.length > 2)
+            lowerer.noLowering("server.setTimeout arguments", call, "pass milliseconds and an optional socket callback");
+        const receiver = coerceToHandle(lowerer, access.expression, NETSERVER_T);
+        const ms = lowerer.lowerExprExpecting(args[0], F64);
+        const cb = args.length === 2
+            ? lowerCallbackArg(lowerer, args[1], "server timeout callbacks", 1, (p) => p.kind === "netSocket", "use (socket) or ()", [NETSOCKET_T]).cb
+            : null;
+        const fn = cb === null ? "http.serverSetTimeout" : "http.serverSetTimeoutCb";
+        const callArgs = cb === null ? [receiver, ms] : [receiver, ms, cb];
+        if (resultIsDiscarded(call))
+            return { kind: "libCall", fn, args: callArgs, type: VOID, loc };
+        return receiverReturningCall(lowerer, fn, callArgs, NETSERVER_T, loc);
+    }
+    if (name === "closeAllConnections" || name === "closeIdleConnections") {
+        requireStatementPosition(lowerer, call, `server.${name}()`);
+        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";
+        return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
+    }
     if (name === "listen") {
         if (args.length < 1 || args.length > 3) {
             lowerer.noLowering(`listen with ${args.length} arguments`, call, "the supported form is listen(port[, host][, callback]) — port 0 binds an ephemeral port");
@@ -1140,6 +1163,10 @@ function lowerNetServerMethodCall(lowerer, call, access) {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close listeners", 0, () => false, "use ()", []);
             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 };
+        }
         if (event === "listening") {
             // The deferred bind emit — listen(port, cb)'s event twin: fires
             // once after a successful listen; late registrations on an
@@ -1525,6 +1552,15 @@ function trailersSnapshotHelper(lowerer, shapeId, loc) {
         callArgs: [varRef("r.0", HTTPREQ_T, loc)],
     });
 }
+function distinctSnapshotHelper(lowerer, shapeId, loc, collection) {
+    return pairsSnapshotHelper(lowerer, shapeId, loc, {
+        keyPrefix: collection,
+        libCall: collection === "headersDistinct" ? "http.reqHeaderPairs" : "http.reqTrailerPairs",
+        lookupValue: collection === "headersDistinct" ? "http.reqHeaderValues" : "http.reqTrailerValues",
+        params: [{ localId: "r.0", name: "r", type: HTTPREQ_T }],
+        callArgs: [varRef("r.0", HTTPREQ_T, loc)],
+    });
+}
 /** The `endStream` boolean of an h2 options object literal, as a literal
  * bool. Returns undefined when absent (or the arg is absent). Fences on
  * a non-literal endStream value or unknown keys that would matter. */
@@ -1797,6 +1833,10 @@ export function lowerServerProperty(lowerer, expr) {
     // req.headers.NAME — the `string | undefined` union (envGet's type).
     const recvKind = lowerer.mapTypeOf(lowerer.typeOf(expr.expression))?.kind;
     if (recvKind === "netServer" && lowerer.isStdlibMember(expr)) {
+        if (expr.name.text === "listening") {
+            const receiver = coerceToHandle(lowerer, expr.expression, NETSERVER_T);
+            return { kind: "libCall", fn: "net.serverListening", args: [receiver], type: BOOL, loc };
+        }
         const field = httpServerTimeoutField(expr.name.text);
         if (field !== null) {
             const receiver = coerceToHandle(lowerer, expr.expression, NETSERVER_T);
@@ -1817,7 +1857,7 @@ export function lowerServerProperty(lowerer, expr) {
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
             return { kind: "libCall", fn: "http.reqStatusCode", args: [receiver], type: lowerer.withUndefinedArm(F64), loc };
         }
-        if (name === "socket") {
+        if (name === "socket" || name === "connection") {
             const receiver = coerceToHandle(lowerer, expr.expression, HTTPREQ_T);
             return { kind: "libCall", fn: "http.reqSocket", args: [receiver], type: NETSOCKET_T, loc };
         }
@@ -1879,15 +1919,15 @@ 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") {
-            // `req.headers` as a VALUE — the `{ ...req.headers }` spread and
-            // record flows: a fresh snapshot record per read (Node's spread
-            // copies too; the per-name READS keep their direct lowerings).
+        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)
-                    : 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);
                     return { kind: "call", callee: helper, args: [receiver], type: mapped, loc };
@@ -1895,9 +1935,6 @@ export function lowerServerProperty(lowerer, expr) {
             }
             lowerer.unsupported("SC1090", expr, `req.${name} as a value of this type (read one field: req.${name}.name or req.${name}[name])`);
         }
-        if (name === "headersDistinct" || name === "trailersDistinct") {
-            lowerer.unsupported("SC1090", expr, `req.${name} as a value (read one name with req.${name}[name])`);
-        }
     }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "stream") {
         lowerer.noLowering("reading 'stream' (an HTTP/2-only member) from a response", expr, "compatibility responses do not expose their backing h2 stream yet — guard method calls with '?.' or drop the use");
@@ -1965,10 +2002,35 @@ export function lowerServerProperty(lowerer, expr) {
         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) &&
+        (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") {
         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;
+        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;
+        if (boolFn !== null) {
+            const receiver = coerceToHandle(lowerer, expr.expression, HTTPCLIENTREQ_T);
+            return { kind: "libCall", fn: boolFn, args: [receiver], type: BOOL, loc };
+        }
+    }
     if (httpReqFieldCollection(lowerer, expr.expression) !== null) {
         const collection = httpReqFieldCollection(lowerer, expr.expression);
         const receiver = coerceToHandle(lowerer, expr.expression.expression, HTTPREQ_T);
@@ -1983,6 +2045,14 @@ export function lowerServerProperty(lowerer, expr) {
         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") {
+        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 === "finished") {
+        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") {
         const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
         return { kind: "libCall", fn: "http.resWritableCorked", args: [receiver], type: F64, loc };
@@ -1994,11 +2064,30 @@ export function lowerServerProperty(lowerer, expr) {
         return { kind: "libCall", fn: "http.resStatusGet", args: [receiver], type: F64, loc };
     }
     if (recvKind === "httpRes" && lowerer.isStdlibMember(expr) && expr.name.text === "statusMessage") {
-        // The assigned reason phrase, or the current status code's default
-        // when none was set (Node answers undefined until the head goes out
-        // — divergence: this surface is string-typed, the checker's shape).
+        // 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: 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;
+        if (name === "req") {
+            const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
+            return { kind: "libCall", fn: "http.resRequest", args: [receiver], type: HTTPREQ_T, loc };
+        }
+        if (name === "socket" || name === "connection") {
+            const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
+            const type = { kind: "union", unionId: lowerer.unions.intern([NETSOCKET_T, NULL_T]) };
+            return { kind: "libCall", fn: "http.resSocket", args: [receiver], type, loc };
+        }
+        if (name === "writableFinished") {
+            const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
+            return { kind: "libCall", fn: "http.resWritableFinished", args: [receiver], type: BOOL, loc };
+        }
+        if (name === "sendDate" || name === "strictContentLength") {
+            const receiver = coerceToHandle(lowerer, expr.expression, HTTPRES_T);
+            const fn = name === "sendDate" ? "http.resSendDateGet" : "http.resStrictContentLengthGet";
+            return { kind: "libCall", fn, args: [receiver], type: BOOL, loc };
+        }
     }
     if (recvKind === "http2Session" && lowerer.isStdlibMember(expr)) {
         const m = expr.name.text;
@@ -2389,13 +2478,33 @@ export function lowerHttpServerNew(lowerer, expr) {
  * (req, res), (req), or () — runtime adapters bridge each shape.
  * Everything else the module declares fences qualified. */
 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)) {
+            lowerer.noLowering("http.validateHeaderName arguments", expr, "pass a header name and an optional label");
+        }
+        const name = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+        const label = expr.arguments.length === 2
+            ? lowerer.lowerExprExpecting(expr.arguments[1], STRING)
+            : strLit("Header name", loc);
+        return { kind: "libCall", fn: "http.validateHeaderName", args: [name, label], type: VOID, loc };
+    }
+    if (bi.member === "validateHeaderValue") {
+        requireStatementPosition(lowerer, expr, "http.validateHeaderValue(...)");
+        if (expr.arguments.length !== 2 || expr.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering("http.validateHeaderValue arguments", expr, "pass a header name and a value");
+        }
+        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 };
+    }
     if (bi.member === "createServer" || bi.member === "Server") {
         return lowerHttpCreateServerForms(lowerer, expr, `http.${bi.member}`, loc);
     }
     if (bi.member === "request" || bi.member === "get") {
         return lowerHttpClientCall(lowerer, expr, bi.member, loc);
     }
-    lowerer.noLowering(`http.${bi.member}`, expr, "createServer, Server, request, and get are the lowered http module functions", lowerer.resolveValueSymbol(expr.expression));
+    lowerer.noLowering(`http.${bi.member}`, expr, "createServer, Server, request, get, validateHeaderName, and validateHeaderValue are the lowered http module functions", lowerer.resolveValueSymbol(expr.expression));
 }
 /** The cert/key PEM option of tls.createServer / https.createServer: an
  * OBJECT LITERAL whose lowered `cert` and `key` entries are strings or
@@ -3664,6 +3773,35 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if (name === "setHeader") {
+        requireStatementPosition(lowerer, call, "request.setHeader(...)");
+        if (args.length !== 2)
+            lowerer.noLowering("request.setHeader arguments", call, "pass a name and string value");
+        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 };
+    }
+    if (name === "getHeader" || name === "hasHeader" || name === "removeHeader") {
+        if (name === "removeHeader")
+            requireStatementPosition(lowerer, call, "request.removeHeader(...)");
+        if (args.length !== 1)
+            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 type = name === "getHeader" ? lowerer.envValueType() : name === "hasHeader" ? BOOL : VOID;
+        return { kind: "libCall", fn, args: [receiver, header], type, loc };
+    }
+    if (name === "getHeaderNames" || name === "getRawHeaderNames" || name === "getHeaders") {
+        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 };
+    }
     if (name === "flushHeaders" || name === "cork" || name === "uncork") {
         requireStatementPosition(lowerer, call, `request.${name}()`);
         if (args.length !== 0)
@@ -3673,6 +3811,37 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             : name === "cork" ? "http.clientCork" : "http.clientUncork";
         return { kind: "libCall", fn, args: [receiver], type: VOID, loc };
     }
+    if (name === "setNoDelay") {
+        requireStatementPosition(lowerer, call, "request.setNoDelay(...)");
+        if (args.length > 1)
+            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 };
+    }
+    if (name === "setSocketKeepAlive") {
+        requireStatementPosition(lowerer, call, "request.setSocketKeepAlive(...)");
+        if (args.length > 2)
+            lowerer.noLowering("request.setSocketKeepAlive arguments", call, "pass an optional boolean and initial delay in milliseconds");
+        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 };
+    }
+    if (name === "setTimeout") {
+        if (args.length < 1 || args.length > 2)
+            lowerer.noLowering("request.setTimeout arguments", call, "pass milliseconds and an optional callback");
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPCLIENTREQ_T);
+        const ms = lowerer.lowerExprExpecting(args[0], F64);
+        const cb = args.length === 2
+            ? lowerCallbackArg(lowerer, args[1], "request timeout callbacks", 0, () => false, "use ()", []).cb
+            : null;
+        const fn = cb === null ? "http.clientSetTimeout" : "http.clientSetTimeoutCb";
+        const callArgs = cb === null ? [receiver, ms] : [receiver, ms, cb];
+        if (resultIsDiscarded(call))
+            return { kind: "libCall", fn, args: callArgs, type: VOID, loc };
+        return receiverReturningCall(lowerer, fn, callArgs, HTTPCLIENTREQ_T, loc);
+    }
     if (name === "addTrailers") {
         requireStatementPosition(lowerer, call, "request.addTrailers(...)");
         if (args.length !== 1)
@@ -3707,13 +3876,13 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
         }
         lowerer.noLowering(`${name} of '${lowerer.fmt(data.type)}' data`, args[0] ?? call, NARROW_DATA_HINT);
     }
-    if (name === "destroy") {
-        requireStatementPosition(lowerer, call, "request.destroy()");
+    if (name === "destroy" || name === "abort") {
+        requireStatementPosition(lowerer, call, `request.${name}()`);
         if (args.length !== 0) {
-            lowerer.noLowering(`destroy with ${args.length} arguments`, call, "destroy() takes no arguments here");
+            lowerer.noLowering(`${name} with ${args.length} arguments`, call, `${name}() takes no arguments here`);
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "http.clientDestroy", 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}(...)`);
@@ -3725,13 +3894,19 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             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 };
         }
+        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 };
+        }
         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 };
         }
-        if (event === "timeout" || event === "close") {
+        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" : "http.clientOnClose";
+            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") {
@@ -3753,9 +3928,9 @@ function lowerHttpClientMethodCall(lowerer, call, access) {
             }
             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", "upgrade", "error", "timeout", and "close" are the supported request events (as literals)');
+        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)');
     }
-    lowerer.noLowering(`ClientRequest.${name}`, call, "write, end, destroy, destroyed, and on/once of response/error/timeout/close are the supported ClientRequest members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`ClientRequest.${name}`, call, "header reads/mutations, write, end, destroy, and on/once of response/error/timeout/close are the supported ClientRequest members", lowerer.checker.getSymbolAtLocation(access.name));
 }
 /** True when `node` is the h2-only stream/session CALL shape —
  * `req.stream.destroy()` / `req.session.m(...)` on an identifier
@@ -3849,6 +4024,17 @@ function lowerHttpReqMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if (name === "setTimeout") {
+        requireStatementPosition(lowerer, call, "message.setTimeout(...)");
+        if (args.length < 1 || args.length > 2)
+            lowerer.noLowering("message.setTimeout arguments", call, "pass milliseconds and an optional callback");
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPREQ_T);
+        const ms = lowerer.lowerExprExpecting(args[0], F64);
+        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 };
+    }
     if (name === "resume" || name === "destroy") {
         requireStatementPosition(lowerer, call, `req.${name}()`);
         if (args.length !== 0) {
@@ -3931,6 +4117,72 @@ function lowerHttpResMethodCall(lowerer, call, access) {
     const name = access.name.text;
     const loc = locOf(call);
     const args = call.arguments;
+    if (name === "setTimeout") {
+        if (args.length < 1 || args.length > 2) {
+            lowerer.noLowering(`res.setTimeout with ${args.length} arguments`, call, "use setTimeout(milliseconds[, callback])");
+        }
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
+        const ms = lowerer.lowerExprExpecting(args[0], F64);
+        const cb = args.length === 2
+            ? lowerCallbackArg(lowerer, args[1], "response timeout callbacks", 0, () => false, "use ()", []).cb
+            : null;
+        const fn = cb === null ? "http.resSetTimeout" : "http.resSetTimeoutCb";
+        const callArgs = cb === null ? [receiver, ms] : [receiver, ms, cb];
+        if (resultIsDiscarded(call))
+            return { kind: "libCall", fn, args: callArgs, type: VOID, loc };
+        return receiverReturningCall(lowerer, fn, callArgs, HTTPRES_T, loc);
+    }
+    if (name === "writeContinue" || name === "writeProcessing" || name === "writeEarlyHints") {
+        requireStatementPosition(lowerer, call, `res.${name}(...)`);
+        if (lowerer.typeOf(access.expression).getSymbol()?.name === "Http2ServerResponse") {
+            lowerer.noLowering(`Http2ServerResponse.${name}`, call, "HTTP/2 informational responses are not supported by the static runtime yet");
+        }
+        const receiver = coerceToHandle(lowerer, access.expression, HTTPRES_T);
+        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 };
+        }
+        if (args.length !== 1)
+            lowerer.noLowering("res.writeEarlyHints arguments", call, "pass one header object or Record<string, string> without a callback");
+        const node = args[0];
+        let pairs;
+        if (ts.isObjectLiteralExpression(node)) {
+            const elems = [];
+            for (const prop of node.properties) {
+                const key = ts.isPropertyAssignment(prop) ? staticHeaderKeyOf(lowerer, prop) : null;
+                if (!ts.isPropertyAssignment(prop) || key === null) {
+                    lowerer.noLowering("writeEarlyHints headers with dynamic keys, spreads, or shorthand entries", prop, "use literal header keys and string values");
+                }
+                const value = lowerer.lowerExpr(prop.initializer);
+                if (value.type.kind !== "string") {
+                    lowerer.noLowering(`writeEarlyHints value of type '${lowerer.fmt(value.type)}'`, prop.initializer, "header values must be strings here");
+                }
+                elems.push({ kind: "strLit", value: key, type: STRING, loc }, value);
+            }
+            pairs = { kind: "arrayLit", elems, type: arrayOf(STRING), loc };
+        }
+        else {
+            const value = lowerer.lowerExpr(node);
+            if (value.type.kind !== "record") {
+                lowerer.noLowering(`writeEarlyHints headers of '${lowerer.fmt(value.type)}'`, node, "pass an object literal or a Record<string, string>");
+            }
+            const helper = lowerer.envToPairsHelper(value.type.shapeId, loc);
+            if (helper === null) {
+                lowerer.noLowering("writeEarlyHints header values", node, "use a Record<string, string> with string values");
+            }
+            pairs = { kind: "call", callee: helper, args: [value], type: arrayOf(STRING), 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 };
+    }
     if (name === "flushHeaders" || name === "cork" || name === "uncork") {
         requireStatementPosition(lowerer, call, `res.${name}()`);
         if (args.length !== 0)
@@ -4197,8 +4449,12 @@ function lowerHttpResMethodCall(lowerer, call, access) {
             const { cb } = lowerCallbackArg(lowerer, args[1], "close listeners", 0, () => false, "use ()", []);
             return { kind: "libCall", fn: "http.resOnClose", args: [receiver, cb, once], type: VOID, loc };
         }
-        lowerer.noLowering(`res.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"close" is the supported response event (as a literal)');
+        if (event === "finish") {
+            const { cb } = lowerCallbackArg(lowerer, args[1], "finish listeners", 0, () => false, "use ()", []);
+            return { kind: "libCall", fn: "http.resOnFinish", args: [receiver, cb], type: VOID, loc };
+        }
+        lowerer.noLowering(`res.${name}(${event === null ? "non-literal event" : `"${event}"`}, ...)`, args[0], '"close" and "finish" are the supported response events (as literals)');
     }
-    lowerer.noLowering(`ServerResponse.${name}`, call, "setHeader, getHeader, hasHeader, removeHeader, writeHead, write, end, destroy, headersSent, statusCode, statusMessage, and on/once of close are the supported ServerResponse members", lowerer.checker.getSymbolAtLocation(access.name));
+    lowerer.noLowering(`ServerResponse.${name}`, call, "setHeader, getHeader, hasHeader, removeHeader, writeHead, writeContinue, writeProcessing, writeEarlyHints, setTimeout, write, end, destroy, response state reads, and on/once of close are the supported ServerResponse members", lowerer.checker.getSymbolAtLocation(access.name));
 }
 //# sourceMappingURL=lower-server.js.map