@scriptc/compiler 0.0.25 → 0.0.26

package/dist/frontend/lowering/lower-server.d.ts

@@ -31,6 +31,11 @@ export declare function lowerServerCloseOverrideAssignment(L: Lowerer, left: ts.
  * routed from lower-stmts' property-assignment path beside the
  * close-override hook. Null when the target isn't one of the two. */
 export declare function lowerHttpResPropertyAssignment(L: Lowerer, left: ts.Expression, right: ts.Expression, loc: SrcLoc): IrStmt | null;
+/** `server.timeout = n` and the four HTTP parser/keep-alive timeout
+ * siblings. These are ordinary writable number properties in Node: the
+ * runtime stores their exact value per server; active timeout behavior is
+ * a separate protocol concern. */
+export declare function lowerHttpServerTimeoutAssignment(L: Lowerer, left: ts.Expression, right: ts.Expression, loc: SrcLoc): IrStmt | null;
 /** The method-call dispatch for both server-surface receiver kinds — one
  * entry in lower-calls.ts's intrinsic chain (the lowerChildMethodCall
  * slot). Null when the receiver is neither. */

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

@@ -23,6 +23,19 @@ export const NET_MODULE_FNS = new Set([
     "createConnection",
 ]);
 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;
+    }
+}
 /** VOID-result server/socket calls are usable as statements and as concise
  * arrow bodies (`socket.on("error", () => socket.destroy())` — the shape
  * portless is made of); anything that would CONSUME the result (Node
@@ -812,6 +825,29 @@ export function lowerHttpResPropertyAssignment(L, left, right, loc) {
         loc,
     };
 }
+/** `server.timeout = n` and the four HTTP parser/keep-alive timeout
+ * siblings. These are ordinary writable number properties in Node: the
+ * runtime stores their exact value per server; active timeout behavior is
+ * a separate protocol concern. */
+export function lowerHttpServerTimeoutAssignment(L, left, right, loc) {
+    if (!ts.isPropertyAccessExpression(left) || left.questionDotToken)
+        return null;
+    const field = httpServerTimeoutField(left.name.text);
+    if (field === null)
+        return null;
+    if (L.mapTypeOf(L.typeOf(left.expression))?.kind !== "netServer")
+        return null;
+    if (!L.isStdlibMember(left))
+        return null;
+    const receiver = handleReceiver(L, left.expression, NETSERVER_T);
+    const selector = { kind: "numLit", value: field, type: F64, loc };
+    const value = L.lowerExprExpecting(right, F64);
+    return {
+        kind: "exprStmt",
+        expr: { kind: "libCall", fn: "http.serverTimeoutSet", args: [receiver, selector, value], type: VOID, loc },
+        loc,
+    };
+}
 /** Method calls on net.Server receivers: listen(port[, cb]), close([cb]),
  * on/once("connection" | "error" | "close", cb). address() alone fences
  * toward the composed address().port read. Null for other receivers. */
@@ -1714,12 +1750,20 @@ function lowerH2StreamMethodCall(L, call, access) {
  * the two reads never materializes; the runtime answers the bound port
  * directly. Null for every other property shape. */
 export function lowerServerProperty(L, expr) {
-    if (expr.questionDotToken)
+    if (expr.questionDotToken && !L.chainHandled.has(expr))
         return null;
     const loc = locOf(expr);
     // req.url / req.method — always-present strings on server requests;
     // req.headers.NAME — the `string | undefined` union (envGet's type).
     const recvKind = L.mapTypeOf(L.typeOf(expr.expression))?.kind;
+    if (recvKind === "netServer" && L.isStdlibMember(expr)) {
+        const field = httpServerTimeoutField(expr.name.text);
+        if (field !== null) {
+            const receiver = handleReceiver(L, 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 };
+        }
+    }
     if (recvKind === "httpReq" && L.isStdlibMember(expr)) {
         const name = expr.name.text;
         if (name === "url" || name === "method") {
@@ -1979,17 +2023,17 @@ function lowerRequestHandlerArg(L, node) {
     return voidizedCallback(L, cb, locOf(node));
 }
 /** The http.createServer / http.Server options object — { requireHostHeader?,
- * joinDuplicateHeaders?, ... }: the two lowered keys are exactly the
- * parser behaviors this runtime has (requireHostHeader: false IS the
- * parser's stance — it never answers 400 for a missing Host;
- * joinDuplicateHeaders: true joins repeated request-header reads with
- * ", "). Other documented keys fence by name; unknown keys drop like
- * Node drops them. Answers whether joinDuplicateHeaders was requested. */
+ * joinDuplicateHeaders?, keepAliveTimeoutBuffer?, ... }. The first two
+ * select parser behavior; keepAliveTimeoutBuffer initializes the matching
+ * writable server field after Node's non-negative-safe-integer validation.
+ * Other documented keys fence by name; unknown keys drop like Node drops
+ * them. */
 function lowerHttpServerOptions(L, node, what) {
     if (!ts.isObjectLiteralExpression(node)) {
         L.noLowering(`${what} with a non-literal options argument`, node, "pass the options as an object literal: { requireHostHeader?, joinDuplicateHeaders? }");
     }
     let joinDup = false;
+    let keepAliveTimeoutBuffer = null;
     for (const prop of node.properties) {
         let initializer;
         if (ts.isPropertyAssignment(prop) &&
@@ -2025,16 +2069,35 @@ function lowerHttpServerOptions(L, node, what) {
             }
             L.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)");
         }
-        fenceOrDropOptionKey(L, prop, key, what, HTTP_SERVER_DOCUMENTED_OPTIONS, "requireHostHeader: false and joinDuplicateHeaders are the supported options");
+        if (key === "keepAliveTimeoutBuffer") {
+            if (keepAliveTimeoutBuffer !== null) {
+                L.noLowering(`${what} with duplicate keepAliveTimeoutBuffer options`, prop, "write keepAliveTimeoutBuffer once in the options literal");
+            }
+            const raw = initializer !== null
+                ? L.lowerExpr(initializer)
+                : L.lowerShorthandValue(prop);
+            const value = L.coerceToExpected(raw, DYN);
+            if (value.type.kind !== "dyn") {
+                L.noLowering(`${what} with a keepAliveTimeoutBuffer value that cannot cross the runtime option boundary`, prop, "keepAliveTimeoutBuffer is a number or undefined");
+            }
+            // Preserve the optional field's undefined arm until runtime: Node
+            // treats it as absent, while numbers take the constructor-only
+            // integer/range ladder and dynamic non-numbers get its named type
+            // error. Coercing eagerly to F64 would reject the valid explicit-
+            // undefined spelling before the option helper sees it.
+            keepAliveTimeoutBuffer = value;
+            continue;
+        }
+        fenceOrDropOptionKey(L, prop, key, what, HTTP_SERVER_DOCUMENTED_OPTIONS, "requireHostHeader: false, joinDuplicateHeaders, and keepAliveTimeoutBuffer are the supported options");
         // An undocumented key, dropped like Node drops it.
     }
-    return { joinDup };
+    return { joinDup, keepAliveTimeoutBuffer };
 }
 /** The shared createServer([options][, handler]) shapes behind
  * http.createServer, http.Server, and `new http.Server`: no arguments
  * (the on("request") route), a lone handler, a lone options object, and
- * (options, handler). joinDuplicateHeaders wraps the construction in the
- * flag-setting helper. */
+ * (options, handler). Modeled option values wrap the construction in an
+ * interned option-setting helper. */
 function lowerHttpCreateServerForms(L, expr, what, loc) {
     const args = expr.arguments ?? [];
     if (args.length > 2) {
@@ -2052,37 +2115,63 @@ function lowerHttpCreateServerForms(L, expr, what, loc) {
         else
             handlerNode = args[0];
     }
-    const joinDup = optsNode !== null && lowerHttpServerOptions(L, optsNode, what).joinDup;
+    const opts = optsNode !== null
+        ? lowerHttpServerOptions(L, optsNode, what)
+        : { joinDup: false, keepAliveTimeoutBuffer: null };
     const server = handlerNode !== null
         ? { kind: "libCall", fn: "http.createServer", args: [lowerRequestHandlerArg(L, handlerNode)], type: NETSERVER_T, loc }
         : { kind: "libCall", fn: "http.createServerEmpty", args: [], type: NETSERVER_T, loc };
-    if (!joinDup)
+    if (!opts.joinDup && opts.keepAliveTimeoutBuffer === null)
         return server;
-    // The flag-setting composition: an interned helper takes the fresh
-    // server, sets the parser flag, and answers it — one expression.
-    const key = `server.joindup`;
+    // The option-setting composition: an interned helper takes the option
+    // values first (preserving Node's options-before-handler evaluation
+    // order), then the fresh server, applies the modeled fields, and answers
+    // the server as the constructor/factory result.
+    const hasBuffer = opts.keepAliveTimeoutBuffer !== null;
+    const key = `server.opts:${opts.joinDup ? 1 : 0}:${hasBuffer ? 1 : 0}`;
     const existing = L.arrHofHelpers.get(key);
-    const name = existing ?? `%server.joindup.${L.arrHofHelpers.size}`;
+    const name = existing ?? `%server.opts.${L.arrHofHelpers.size}`;
     if (!existing) {
         L.arrHofHelpers.set(key, name);
+        const params = [
+            ...(hasBuffer ? [{ localId: "b.0", name: "buffer", type: DYN }] : []),
+            { localId: "s.0", name: "s", type: NETSERVER_T },
+        ];
         const ref = { kind: "varRef", localId: "s.0", type: NETSERVER_T, loc };
+        const body = [];
+        if (hasBuffer) {
+            const selector = { kind: "numLit", value: 4, type: F64, 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 },
+                loc,
+            });
+        }
+        if (opts.joinDup) {
+            body.push({
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "http.serverJoinDupHeaders", args: [ref], type: VOID, loc },
+                loc,
+            });
+        }
+        body.push({ kind: "return", value: ref, loc });
         L.liftedFns.push({
             name,
-            params: [{ localId: "s.0", name: "s", type: NETSERVER_T }],
+            params,
             returnType: NETSERVER_T,
-            locals: [{ id: "s.0", name: "s", type: NETSERVER_T, mutable: false }],
-            body: [
-                {
-                    kind: "exprStmt",
-                    expr: { kind: "libCall", fn: "http.serverJoinDupHeaders", args: [ref], type: VOID, loc },
-                    loc,
-                },
-                { kind: "return", value: ref, loc },
-            ],
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+            body,
             loc,
         });
     }
-    return { kind: "call", callee: name, args: [server], type: NETSERVER_T, loc };
+    return {
+        kind: "call",
+        callee: name,
+        args: [...(opts.keepAliveTimeoutBuffer !== null ? [opts.keepAliveTimeoutBuffer] : []), server],
+        type: NETSERVER_T,
+        loc,
+    };
 }
 /** `new http.Server([options][, handler])` — the constructor spelling of
  * createServer (Node's Server class IS the factory's product); called
@@ -2316,17 +2405,20 @@ const TLS_VALIDATED_OPTIONS = new Set([
     "minVersion", "maxVersion", "handshakeTimeout", "keepAliveInitialDelay",
     "sessionTimeout", "ticketKeys",
 ]);
-/** True when a literal options bag carries a runtime-validated key (and
- * the source is JS — TypeScript keeps its compile fences). */
-function tlsLiteralNeedsRuntimeWalk(node) {
-    if (!isJsSourceFile(node.getSourceFile()))
-        return false;
+/** 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
+ * keepAliveTimeoutBuffer so the HTTP option is consumed without losing
+ * the literal's evaluation order. */
+function tlsLiteralNeedsRuntimeWalk(node, includeHttpTimeoutOptions = false) {
+    const jsSource = isJsSourceFile(node.getSourceFile());
     return node.properties.some((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
         (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
-        TLS_VALIDATED_OPTIONS.has(p.name.text));
+        ((includeHttpTimeoutOptions && p.name.text === "keepAliveTimeoutBuffer") ||
+            (jsSource && TLS_VALIDATED_OPTIONS.has(p.name.text))));
 }
-function lowerTlsServerOptionsOrDyn(L, node, what) {
-    if (ts.isObjectLiteralExpression(node) && !tlsLiteralNeedsRuntimeWalk(node)) {
+function lowerTlsServerOptionsOrDyn(L, node, what, includeHttpTimeoutOptions = false) {
+    if (ts.isObjectLiteralExpression(node) &&
+        !tlsLiteralNeedsRuntimeWalk(node, includeHttpTimeoutOptions)) {
         return lowerTlsServerOptions(L, node, what);
     }
     const v = L.lowerExpr(node);
@@ -2669,7 +2761,7 @@ function lowerHttpsModuleCall(L, expr, bi, loc) {
         if (args.length < 1 || args.length > 2) {
             L.noLowering(`createServer with ${args.length} arguments`, expr, "the supported form is createServer({ cert, key }, (req, res) => ...)");
         }
-        const opts = lowerTlsServerOptionsOrDyn(L, args[0], "https.createServer");
+        const opts = lowerTlsServerOptionsOrDyn(L, args[0], "https.createServer", true);
         if (args.length === 1) {
             // The handler-less form: 'request' listeners arrive later via
             // server.on("request", ...) — the createSecureServer emission's