@scriptc/compiler 0.0.8 → 0.0.10

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

@@ -9,7 +9,8 @@
  * beyond these shapes fences member-qualified — never a generic
  * rejection, never silence. */
 import * as ts from "../ts7/adapter.js";
-import { locOf } from "../program.js";
+import { ladderFenceExpr, nodeThrowExpr } 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/nodes.js";
 import { 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 "./lower-exprs.js";
@@ -420,6 +421,28 @@ export function lowerNetModuleCall(L, expr, bi, loc) {
             return { kind: "libCall", fn: "net.createServer", args: [], type: NETSERVER_T, loc };
         }
         if (args.length === 1) {
+            // A provably-non-object, non-function argument (the invalid-input
+            // probes: createServer('path'), createServer(0)): Node throws
+            // ERR_INVALID_ARG_TYPE on 'options' before any server exists. DYN
+            // result — the checked-dynamic lane's concise arrows box it, and
+            // the throw means it never materializes.
+            if (isJsSourceFile(expr.getSourceFile())) {
+                const t = L.mapTypeOf(L.typeOf(args[0]));
+                if (t !== null && (t.kind === "string" || t.kind === "f64" || t.kind === "bool")) {
+                    const raw = L.lowerExpr(args[0]);
+                    return {
+                        kind: "libCall",
+                        fn: "error.argTypeThrow",
+                        args: [
+                            { kind: "strLit", value: "options", type: STRING, loc },
+                            { kind: "strLit", value: "of type object", type: STRING, loc },
+                            { kind: "dynFrom", value: raw, type: DYN, loc },
+                        ],
+                        type: NETSERVER_T,
+                        loc,
+                    };
+                }
+            }
             const { cb } = lowerCallbackArg(L, args[0], "connection handlers", 1, (p) => p.kind === "netSocket", "use (socket) or ()", [NETSOCKET_T]);
             return { kind: "libCall", fn: "net.createServerCb", args: [cb], type: NETSERVER_T, loc };
         }
@@ -438,6 +461,26 @@ export function lowerNetModuleCall(L, expr, bi, loc) {
         if (args.length >= 1 && ts.isObjectLiteralExpression(args[0])) {
             return lowerNetConnectOptions(L, expr, bi.member, loc);
         }
+        // A RUNTIME option bag (a record binding or dyn value — the
+        // invalid-input probes build theirs with computed keys): the
+        // checked-dynamic walk validates Node-order and the compiler-rendered
+        // fence is the post-validation tail.
+        if (args.length === 1 && isJsSourceFile(expr.getSourceFile())) {
+            const t = L.mapTypeOf(L.typeOf(args[0]));
+            if (t !== null && (t.kind === "dyn" || t.kind === "record")) {
+                const raw = L.lowerExpr(args[0]);
+                if (raw.type.kind === "dyn" || L.dynConvertible(raw.type)) {
+                    const bag = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
+                    return {
+                        kind: "libCall",
+                        fn: "net.connectOptsChk",
+                        args: [bag, ladderFenceExpr(L, `${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,
+                    };
+                }
+            }
+        }
         if (args.length < 1 || args.length > 3) {
             L.noLowering(`${bi.member} with ${args.length} arguments`, expr, `the supported form is ${bi.member}(port, host?, connectListener?)`);
         }
@@ -510,10 +553,49 @@ function lookupFnShapeOk(L, t) {
 function lowerNetConnectOptions(L, expr, member, loc) {
     const args = expr.arguments;
     const optsNode = args[0];
+    const isJs = isJsSourceFile(expr.getSourceFile());
+    // The checked-dynamic option-bag route (JS sources): a literal with
+    // computed keys (the invalid-input probes' spelling) or an objectMode-
+    // trio member rides WHOLE to the runtime walk — Node's Socket-ctor
+    // validation order (the trio's ERR_INVALID_ARG_VALUE first, then
+    // port/host/autoSelectFamily), with the compiler-rendered fence as the
+    // post-validation tail.
+    if (isJs) {
+        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 : ""));
+        if (needsBag) {
+            const raw = L.lowerExpr(optsNode);
+            if (raw.type.kind === "dyn" || L.dynConvertible(raw.type)) {
+                const bag = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
+                return {
+                    kind: "libCall",
+                    fn: "net.connectOptsChk",
+                    args: [bag, ladderFenceExpr(L, `${member} with these options`, optsNode, "port, host, autoSelectFamily, autoSelectFamilyAttemptTimeout, and lookup are the supported options")],
+                    type: NETSOCKET_T,
+                    loc,
+                };
+            }
+        }
+    }
     let port = null;
     let host = null;
     let lookup = null;
     let autoSelect = false;
+    let attempt = null;
+    let optionThrow = null;
+    const propThrow = (name, expected, got) => ({
+        kind: "libCall",
+        fn: "error.propTypeThrow",
+        args: [
+            { kind: "strLit", value: name, type: STRING, loc },
+            { kind: "strLit", value: expected, type: STRING, loc },
+            got.type.kind === "dyn" ? got : { kind: "dynFrom", value: got, type: DYN, loc },
+        ],
+        type: NETSOCKET_T,
+        loc,
+    });
     for (const prop of optsNode.properties) {
         let initializer;
         if (ts.isPropertyAssignment(prop) &&
@@ -539,6 +621,13 @@ function lowerNetConnectOptions(L, expr, member, loc) {
         else if (key === "host") {
             host = lowerVal();
             if (host.type.kind !== "string") {
+                // A provably-non-string host (the invalid-input probes): Node's
+                // lookupAndConnect throws ERR_INVALID_ARG_TYPE at connect time.
+                if (isJs && (host.type.kind === "dyn" || L.dynConvertible(host.type))) {
+                    optionThrow ??= propThrow("options.host", "of type string", host);
+                    host = null;
+                    continue;
+                }
                 L.noLowering(`a ${member} 'host' option of '${L.fmt(host.type)}' values`, prop, "the host is a string here");
             }
         }
@@ -547,10 +636,28 @@ function lowerNetConnectOptions(L, expr, member, loc) {
             // dial below (false/dynamic would mean Node's single-address dial,
             // which the lookup form does not implement).
             if (initializer === null || initializer.kind !== ts.SyntaxKind.TrueKeyword) {
+                // A provably-non-boolean value throws Node's validateBoolean
+                // ladder instead of fencing.
+                const raw = initializer !== null && isJs ? L.lowerExpr(initializer) : null;
+                if (raw !== null && raw.type.kind !== "bool" &&
+                    (raw.type.kind === "dyn" || L.dynConvertible(raw.type))) {
+                    optionThrow ??= propThrow("options.autoSelectFamily", "of type boolean", raw);
+                    continue;
+                }
                 L.noLowering(`${member} with a non-literal autoSelectFamily option`, prop, "the lowered form is autoSelectFamily: true beside a lookup function");
             }
             autoSelect = true;
         }
+        else if (key === "autoSelectFamilyAttemptTimeout") {
+            // The attempt budget validates at runtime (Node's validateInt32-
+            // from-1 ladder) and is then inert — the single dial has nothing
+            // to time, the autoSelectFamily simplification's sibling.
+            const raw = lowerVal();
+            if (!(raw.type.kind === "dyn" || raw.kind === "unitLit" || L.dynConvertible(raw.type))) {
+                L.noLowering(`a ${member} 'autoSelectFamilyAttemptTimeout' option of '${L.fmt(raw.type)}' values`, prop, "the budget is a number here");
+            }
+            attempt = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
+        }
         else if (key === "lookup") {
             if (initializer === null) {
                 L.noLowering(`${member} with a shorthand lookup option`, prop, "spell it out: lookup: theResolver");
@@ -564,10 +671,21 @@ function lowerNetConnectOptions(L, expr, member, loc) {
             L.noLowering(`${member} option '${key}'`, prop, "port, host, autoSelectFamily, and lookup are the supported options");
         }
     }
+    // A collected option-contract violation replaces the whole call: Node
+    // throws it from Socket.connect before dialing (port validation held —
+    // the port arm above fenced non-number ports already).
+    if (optionThrow !== null)
+        return optionThrow;
     if (port === null) {
         L.noLowering(`${member} options without a port`, optsNode, "the supported options object is { port, host?, autoSelectFamily?, lookup? }");
     }
     host ??= { kind: "strLit", value: "localhost", type: STRING, loc };
+    if (attempt !== null) {
+        if (lookup !== null || args.length !== 1) {
+            L.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 };
+    }
     if (lookup !== null) {
         if (!autoSelect) {
             L.noLowering(`${member} with a lookup but no autoSelectFamily: true`, optsNode, "the lookup form dials every answered address in order — Node does that under autoSelectFamily: true, so spell it");
@@ -771,6 +889,30 @@ function lowerNetServerMethodCall(L, call, access) {
                         v6only = v;
                     }
                 }
+                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 = L.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";
+                    if (provablyNot && L.dynConvertible(raw.type)) {
+                        return {
+                            kind: "libCall",
+                            fn: "error.propTypeThrow",
+                            args: [
+                                { kind: "strLit", value: "options.signal", type: STRING, loc },
+                                { kind: "strLit", value: "an instance of AbortSignal", type: STRING, loc },
+                                { kind: "dynFrom", value: raw, type: DYN, loc },
+                            ],
+                            type: ts.isExpressionStatement(call.parent) ? VOID : NETSERVER_T,
+                            loc,
+                        };
+                    }
+                    L.noLowering(`listen option 'signal'`, prop, "abort-driven close has no lowering yet — port, host, and ipv6Only are the supported listen options");
+                }
                 else {
                     L.noLowering(`listen option '${key}'`, prop, "port, host, and ipv6Only are the supported listen options");
                 }
@@ -1022,6 +1164,31 @@ function lowerNetSocketMethodCall(L, call, access) {
     const args = call.arguments;
     if (name === "write" || name === "end") {
         requireStatementPosition(L, call, `socket.${name}(...)`);
+        // write(chunk, encoding) — the two-argument encoding form: 'buffer'
+        // beside a string chunk is Node's stream_base typecheck ("Second
+        // argument must be a buffer", thrown synchronously on an established
+        // socket — the invalid-input probes' shape); utf8 spellings are the
+        // plain write (that IS the encoding written); a Buffer chunk ignores
+        // the encoding like Node does. Other encodings keep the fence.
+        if (name === "write" && args.length === 2) {
+            const encT = L.typeOf(args[1]);
+            const chunkT = L.mapTypeOf(L.typeOf(args[0]));
+            if (encT.isStringLiteralType() && chunkT !== null) {
+                if (encT.value === "buffer" && chunkT.kind === "string" &&
+                    isJsSourceFile(call.getSourceFile())) {
+                    L.lowerExpr(args[0]); // evaluation order (effect-free in practice)
+                    return nodeThrowExpr(1, "ERR_INVALID_ARG_TYPE", "Second argument must be a buffer", VOID, loc);
+                }
+                const passthrough = (chunkT.kind === "string" && (encT.value === "utf8" || encT.value === "utf-8")) ||
+                    (chunkT.kind === "bytes" && chunkT.elem === "u8");
+                if (passthrough) {
+                    const receiver2 = handleReceiver(L, access.expression, NETSOCKET_T);
+                    const data2 = L.lowerExpr(args[0]);
+                    const fn = data2.type.kind === "string" ? "net.sockWrite" : "net.sockWriteBytes";
+                    return { kind: "libCall", fn, args: [receiver2, data2], type: VOID, loc };
+                }
+            }
+        }
         const maxArgs = name === "write" ? 1 : 1;
         const minArgs = name === "write" ? 1 : 0;
         if (args.length < minArgs || args.length > maxArgs) {
@@ -1981,9 +2148,29 @@ function lowerTlsServerOptions(L, node, what) {
  * checked-dynamic JS lane's record — passes whole to the runtime walk
  * (scr_tls_srv_opts_walk: same member split, fences thrown at runtime,
  * the divergence-66 stance); anything else keeps the compile fence. */
+/** The option keys whose Node argument contracts the runtime walker
+ * validates (scr_tls_opts_validate) — a literal carrying any of them
+ * 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",
+]);
+/** 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;
+    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));
+}
 function lowerTlsServerOptionsOrDyn(L, node, what) {
-    if (ts.isObjectLiteralExpression(node))
+    if (ts.isObjectLiteralExpression(node) && !tlsLiteralNeedsRuntimeWalk(node)) {
         return lowerTlsServerOptions(L, node, what);
+    }
     const v = L.lowerExpr(node);
     if (v.type.kind === "dyn")
         return { dyn: v };
@@ -2123,6 +2310,23 @@ function lowerTlsModuleCall(L, expr, bi, loc) {
     if (bi.member === "connect") {
         return lowerTlsConnectCall(L, expr, loc);
     }
+    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
+        // compiler-rendered fence after the validation.
+        const raw = L.lowerExpr(args[0]);
+        if (raw.type.kind === "dyn" || raw.kind === "unitLit" || L.dynConvertible(raw.type)) {
+            const t = raw.type.kind === "dyn" ? raw : { kind: "dynFrom", value: raw, type: DYN, loc };
+            return {
+                kind: "libCall",
+                fn: "tls.caCertsChk",
+                args: [t, ladderFenceExpr(L, "tls.getCACertificates", expr)],
+                type: L.mapTypeOf(L.typeOf(expr)) ?? DYN,
+                loc,
+            };
+        }
+    }
     if (bi.member === "createSecureContext") {
         // createSecureContext({ cert, key }) → the opaque SecureContext handle
         // an SNI callback answers with. The minimal honest form: exactly the
@@ -2131,8 +2335,11 @@ function lowerTlsModuleCall(L, expr, bi, loc) {
         if (args.length !== 1) {
             L.noLowering(`createSecureContext with ${args.length} arguments`, expr, "the supported form is createSecureContext({ cert, key })");
         }
-        const { cert, key } = lowerTlsServerOptions(L, args[0], "tls.createSecureContext");
-        return { kind: "libCall", fn: "tls.createSecureContext", args: [cert, key], type: SECURECTX_T, loc };
+        const opts = lowerTlsServerOptionsOrDyn(L, 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.createSecureContext", args: [opts.cert, opts.key], type: SECURECTX_T, loc };
     }
     L.noLowering(`tls.${bi.member}`, expr, builtinFenceHintOf("tls", bi.member) ??
         "createServer({ cert, key }, handler) and createSecureContext({ cert, key }) are the lowered tls module functions", L.resolveValueSymbol(expr.expression));