@scriptc/compiler 0.1.4 → 0.1.6

package/dist/backend/c/exprs.js

@@ -1,12 +1,12 @@
 import { InternalCompilerError } from "../../errors.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, CHILDWRITER_T, DYN, F64, islandPromisePayloadTag, isClassOwnEnumerableFieldName, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, CHILDWRITER_T, DYN, F64, islandPromisePayloadTag, isClassOwnEnumerableFieldName, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, NETSOCKET_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
 import { boxAccess, BYTES_NUM_KIND_C, BYTES_NUM_VAR_C, bytesElemKindC, cDecl, cFnPtrCast, cNumberLiteral, cStringLiteral, cType, DV_GET_KIND_C, DV_SET_KIND_C, elemAccess, mapKeyAccess, mapKeyKindC, mapValKindC, releaseCallC, retainCallC, vAdapters } from "./types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordClone, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./shapes.js";
 import { dynDestrCheckHelper, dynIterNHelper, dynKeyGetHelper } from "./walkers.js";
 import { collectFfiRetainedOps, parseFfiCallbackKey } from "../ffi-callbacks.js";
 import { genResultThunkFor } from "./async.js";
-import { isStableBytesOperand, matchStringSelfConcat, newValueMayThrow, streamTypedRefEligible, undefinedArmTag } from "../../ir/analysis.js";
+import { isStableReceiverOperand, matchStringSelfConcat, newValueMayThrow, streamTypedRefEligible, undefinedArmTag } from "../../ir/analysis.js";
 function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
     if (t.kind === "bytes") {
         const commit = `${snapshot}_commit`;
@@ -385,13 +385,13 @@ function dynPromiseAdapter(emitter, inner) {
     emitter.walkerDefs.push(`${sig} { /* checked-dynamic promise exit ${key} */`, `  ScrDyn *sc_d = (ScrDyn *)scr_promise_payload_ref(sc_src);`, `  ${cDecl(inner, "sc_v")} = ${emitter.dynCheckHelper(inner)}(sc_d, NULL);`, `  scr_dyn_release(sc_d);`, `  if (scr_exc_pending()) {`, `    scr_promise_reject_pending(sc_dst);`, `    return;`, `  }`, `  ${fulfill}`, `}`, ``);
     return sym;
 }
-/** Evaluate a bytes receiver as a borrow when it is a direct, unboxed
+/** Evaluate a receiver as a borrow when it is a direct, unboxed
  * binding and all later operands are stable. The binding's scope/global
  * owner then keeps the value alive, avoiding retain/release traffic around
  * every indexed access. Any uncertain shape falls back to an owned temp. */
-export function emitBytesReceiver(emitter, receiver, following) {
+export function emitStableReceiver(emitter, receiver, following) {
     if (receiver.kind === "varRef" &&
-        following.every((operand) => isStableBytesOperand(operand, receiver.localId))) {
+        following.every((operand) => isStableReceiverOperand(operand, receiver.localId))) {
         const local = emitter.currentLocals.get(receiver.localId);
         if (local && !local.boxed) {
             return emitter.newBorrowedTemp(receiver.type, mangleLocal(receiver.localId));
@@ -604,11 +604,36 @@ function emitLiteralExpr(emitter, e) {
         }
     }
 }
+/** Unsigned operations avoid signed overflow and implementation-defined
+ * right shifts/conversions. Reinterpret the final bits numerically. */
+function emitIntegerBits(emitter, e, left, right) {
+    const a = `sc_bits_${emitter.tempCounter++}`;
+    const out = `sc_bits_${emitter.tempCounter++}`;
+    emitter.line(`uint32_t ${a} = (uint32_t)(int64_t)${left};`);
+    let operation;
+    if (e.kind === "unary")
+        operation = `~${a}`;
+    else {
+        const b = `sc_bits_${emitter.tempCounter++}`;
+        const shift = e.op === "<<" || e.op === ">>" || e.op === ">>>";
+        emitter.line(`uint32_t ${b} = (uint32_t)(int64_t)${right}${shift ? " & 31u" : ""};`);
+        operation = e.op === ">>" ? `(${a} >> ${b}) | ((${a} & 0x80000000u) ? ~(UINT32_MAX >> ${b}) : 0u)`
+            : `${a} ${e.op === ">>>" ? ">>" : e.op} ${b}`;
+    }
+    emitter.line(`uint32_t ${out} = ${operation};`);
+    return emitter.newTemp(e.type, e.op === ">>>" ? `(double)${out}` : `(double)${out} - ((${out} & 0x80000000u) ? 4294967296.0 : 0.0)`);
+}
 function emitOperatorExpr(emitter, e) {
     switch (e.kind) {
         case "bin": {
             const l = emitter.emitExpr(e.left);
             const r = emitter.emitExpr(e.right);
+            if ((e.op === "+" || e.op === "-") && emitter.integerRanges.get(e)) {
+                return emitter.newTemp(e.type, `(double)((int64_t)${l.name} ${e.op} (int64_t)${r.name})`);
+            }
+            if (["&", "|", "^", "<<", ">>", ">>>"].includes(e.op) && emitter.integerRanges.get(e.left) && emitter.integerRanges.get(e.right)) {
+                return emitIntegerBits(emitter, e, l.name, r.name);
+            }
             switch (e.op) {
                 case "%":
                     return emitter.newTemp(e.type, `fmod(${l.name}, ${r.name})`);
@@ -639,7 +664,8 @@ function emitOperatorExpr(emitter, e) {
         case "unary": {
             const v = emitter.emitExpr(e.operand);
             if (e.op === "~")
-                return emitter.newTemp(e.type, `scr_bit_not(${v.name})`);
+                return emitter.integerRanges.get(e.operand)
+                    ? emitIntegerBits(emitter, e, v.name) : emitter.newTemp(e.type, `scr_bit_not(${v.name})`);
             return emitter.newTemp(e.type, `${e.op}${v.name}`);
         }
         case "incDec": {
@@ -1233,9 +1259,13 @@ function emitStringExpr(emitter, e) {
                     }
                     return emitter.newTemp(e.type, `scr_str_includes(${r.name}, ${args[0].name})`);
                 case "startsWith":
-                    return emitter.newTemp(e.type, `scr_str_starts_with(${r.name}, ${args[0].name})`);
+                    return emitter.newTemp(e.type, args[1]
+                        ? `scr_str_starts_with_from(${r.name}, ${args[0].name}, ${args[1].name})`
+                        : `scr_str_starts_with(${r.name}, ${args[0].name})`);
                 case "endsWith":
-                    return emitter.newTemp(e.type, `scr_str_ends_with(${r.name}, ${args[0].name})`);
+                    return emitter.newTemp(e.type, args[1]
+                        ? `scr_str_ends_with_from(${r.name}, ${args[0].name}, ${args[1].name})`
+                        : `scr_str_ends_with(${r.name}, ${args[0].name})`);
                 case "slice":
                     return emitter.newTemp(e.type, `scr_str_slice(${r.name}, ${args[0]?.name ?? "0"}, ${args[1]?.name ?? "INFINITY"})`);
                 case "substring":
@@ -1447,7 +1477,11 @@ function emitContainerExpr(emitter, e) {
             return emitter.newTemp(e.type, `scr_arr_state(${arr.name}, ${idx.name})`);
         }
         case "arrIntrinsic": {
-            const r = emitter.emitExpr(e.receiver);
+            // getNumber/indexEq produce scalars without invoking user code. A
+            // stable binding can own its receiver until that lookup finishes.
+            const r = e.method === "getNumber" || e.method === "indexEq"
+                ? emitStableReceiver(emitter, e.receiver, e.args)
+                : emitter.emitExpr(e.receiver);
             if (e.receiver.type.kind !== "array")
                 throw new InternalCompilerError("emitter bug: arrIntrinsic on non-array");
             const acc = elemAccess(e.receiver.type.elem);
@@ -1455,10 +1489,21 @@ function emitContainerExpr(emitter, e) {
             switch (method) {
                 case "length":
                     return emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
+                case "getNumber": {
+                    const index = emitter.emitExpr(e.args[0]);
+                    const table = e.receiver.kind === "varRef" ? emitter.constantNumericTables.get(e.receiver.localId) : undefined;
+                    return emitter.newTemp(e.type, `${table ? `${table.symbol}_get` : "scr_arr_get_number"}(${r.name}, ${index.name})`);
+                }
                 case "nextPresent": {
                     const start = emitter.emitExpr(e.args[0]);
                     return emitter.newTemp(e.type, `scr_arr_next_present(${r.name}, ${start.name})`);
                 }
+                case "indexEq": {
+                    const index = emitter.emitExpr(e.args[0]);
+                    const other = emitStableReceiver(emitter, e.args[1], [e.args[2]]);
+                    const otherIndex = emitter.emitExpr(e.args[2]);
+                    return emitter.newTemp(e.type, `scr_arr_index_eq(${r.name}, ${index.name}, ${other.name}, ${otherIndex.name})`);
+                }
                 case "push": {
                     // Variadic like JS: every argument evaluates first (left to
                     // right — an argument reading the array sees the pre-push
@@ -1605,6 +1650,17 @@ function emitContainerExpr(emitter, e) {
                     const cnt = e.args[1] ? emitter.emitExpr(e.args[1]).name : "INFINITY";
                     return emitter.newTemp(e.type, `scr_arr_splice(${r.name}, ${start.name}, ${cnt})`);
                 }
+                case "spliceInsert": {
+                    const start = emitter.emitExpr(e.args[0]);
+                    const count = emitter.emitExpr(e.args[1]);
+                    const items = emitter.emitExpr(e.args[2]);
+                    return emitter.newTemp(e.type, `scr_arr_splice_insert(${r.name}, ${start.name}, ${count.name}, ${items.name})`);
+                }
+                case "flatCopy":
+                case "flatOne": {
+                    const out = emitter.emitExpr(e.args[0]);
+                    return emitter.newTemp(e.type, `scr_arr_flat_copy(${r.name}, ${out.name}, ${method === "flatOne" ? "true" : "false"})`);
+                }
                 default: {
                     const _exhaustive = method;
                     void _exhaustive;
@@ -1677,7 +1733,7 @@ function emitContainerExpr(emitter, e) {
             const method = e.method;
             const directElementAccess = method === "length" || method === "byteLength" || method === "get";
             const r = directElementAccess
-                ? emitBytesReceiver(emitter, e.receiver, e.args)
+                ? emitStableReceiver(emitter, e.receiver, e.args)
                 : emitter.emitExpr(e.receiver);
             const integerIndex = method === "get" ? emitter.integerLoopIndex(e.args[0]) : null;
             const args = integerIndex === null ? e.args.map((a) => emitter.emitExpr(a)) : [];
@@ -1688,7 +1744,7 @@ function emitContainerExpr(emitter, e) {
                     if (e.receiver.type.kind !== "bytes") {
                         throw new InternalCompilerError("emitter bug: bytesIntrinsic byteLength on non-bytes");
                     }
-                    return emitter.newTemp(e.type, `(double)(${r.name}->len * ${e.receiver.type.elem === "u8" ? "1" : "4"})`);
+                    return emitter.newTemp(e.type, `(double)(${r.name}->len * ${e.receiver.type.elem === "u8" ? "1" : e.receiver.type.elem === "f64" ? "8" : "4"})`);
                 case "get":
                     // Any invalid index traps (the array runtime's discipline).
                     if (e.receiver.type.kind !== "bytes") {
@@ -4010,6 +4066,8 @@ function emitDynamicLibCall(state) {
         case "dyn.typeof":
             // Bare typeof on a dyn value: the dyn kind's JS answer (+1).
             return finish(`scr_dyn_typeof(${arg(0)})`);
+        case "dyn.objectTag":
+            return finish(`scr_dyn_object_tag(${arg(0)})`);
         case "dyn.toString":
             // Receiver-kind-dispatched toString (+1); throws Node's
             // TypeError on undefined/null and the "is not a function"
@@ -4764,6 +4822,8 @@ function emitPrimitiveLibCall(state) {
             return finish(`scr_math_max_arr(${arg(0)})`);
         case "math.minArr":
             return finish(`scr_math_min_arr(${arg(0)})`);
+        case "math.hypotArr":
+            return finish(`scr_math_hypot_arr(${arg(0)})`);
         // Math.floor/trunc/ceil — the C functions ARE the JS operations
         // (math.h is always included). Borrow nothing; no throw.
         case "math.floor":
@@ -4772,6 +4832,38 @@ function emitPrimitiveLibCall(state) {
             return finish(`trunc(${arg(0)})`);
         case "math.ceil":
             return finish(`ceil(${arg(0)})`);
+        case "math.sin":
+            return finish(`sin(${arg(0)})`);
+        case "math.cos":
+            return finish(`cos(${arg(0)})`);
+        case "math.tan":
+            return finish(`tan(${arg(0)})`);
+        case "math.asin":
+            return finish(`asin(${arg(0)})`);
+        case "math.acos":
+            return finish(`acos(${arg(0)})`);
+        case "math.atan":
+            return finish(`atan(${arg(0)})`);
+        case "math.cbrt":
+            return finish(`cbrt(${arg(0)})`);
+        case "math.sign":
+            // Each argument was evaluated into a temp. Returning that temp
+            // for unordered/zero inputs preserves NaN and the sign of zero.
+            return finish(`(${arg(0)} > 0.0 ? 1.0 : (${arg(0)} < 0.0 ? -1.0 : ${arg(0)}))`);
+        case "math.exp":
+            return finish(`exp(${arg(0)})`);
+        case "math.sqrt":
+            return finish(`sqrt(${arg(0)})`);
+        case "math.log":
+            return finish(`log(${arg(0)})`);
+        case "math.log2":
+            return finish(`log2(${arg(0)})`);
+        case "math.log10":
+            return finish(`log10(${arg(0)})`);
+        case "math.atan2":
+            return finish(`atan2(${arg(0)}, ${arg(1)})`);
+        case "math.pow":
+            return finish(`scr_math_pow(${arg(0)}, ${arg(1)})`);
         // Math.abs — C fabs IS the JS operation. Math.round — the JS
         // half-toward-+Infinity rule (scr_lib.c; C round() differs on
         // halves and naive floor(x+0.5) drifts at the epsilon boundary).
@@ -5015,6 +5107,8 @@ function emitPrimitiveLibCall(state) {
                 : `scr_str_from_char_code(${arg(0)})`);
         case "string.lastIndexOf":
             return finish(`scr_str_last_index_of(${arg(0)}, ${arg(1)})`);
+        case "string.lastIndexOfFrom":
+            return finish(`scr_str_last_index_of_from(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "string.raw":
             // Raw literals + pre-stringified substitutions; +1 string.
             return finish(`scr_str_raw(${arg(0)}, ${arg(1)})`);
@@ -5521,6 +5615,8 @@ function emitNetworkLibCall(state) {
         }
         case "net.serverPort":
             return finish(`scr_net_server_port(${arg(0)})`);
+        case "net.serverListening":
+            return finish(`scr_net_server_listening(${arg(0)})`);
         case "net.serverAddress": {
             // The AddressInfo record from the three runtime reads (the
             // dgram.address materialization; none of these throw).
@@ -5598,9 +5694,7 @@ function emitNetworkLibCall(state) {
             const cb = args[1];
             emitter.moveTemp(cb);
             const adapter = cbT.params.length === 0 ? "scr_net_conn_thunk0" : "scr_net_conn_thunk_sock";
-            const entry = e.fn === "net.serverOnConnection"
-                ? "scr_net_server_on_connection"
-                : "scr_net_server_on_secure_connection";
+            const entry = e.fn === "net.serverOnConnection" ? "scr_net_server_on_connection" : "scr_net_server_on_secure_connection";
             emitter.line(`${entry}(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
@@ -6058,10 +6152,22 @@ function emitHttpLibCall(state) {
         case "http.resSetHeader":
             emitter.line(`scr_http_res_set_header(${arg(0)}, ${arg(1)}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        case "http.validateHeaderName":
+            emitter.line(`scr_http_validate_header_name(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.validateHeaderValue":
+            emitter.line(`scr_http_validate_header_value(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
         case "http.resWriteHead":
             return finish(`scr_http_res_write_head(${arg(0)}, ${arg(1)})`);
         case "http.resWriteHeadN":
             return finish(`scr_http_res_write_head_n(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+        case "http.resWriteContinue":
+            return finish(`scr_http_res_write_continue(${arg(0)})`);
+        case "http.resWriteProcessing":
+            return finish(`scr_http_res_write_processing(${arg(0)})`);
+        case "http.resWriteEarlyHints":
+            return finish(`scr_http_res_write_early_hints(${arg(0)}, ${arg(1)})`);
         case "http.resWrite":
             return finish(`scr_http_res_write_str(${arg(0)}, ${arg(1)})`);
         case "http.resWriteBytes":
@@ -6078,6 +6184,8 @@ function emitHttpLibCall(state) {
             return finish(`scr_http_res_end_dynv(${arg(0)}, ${arg(1)})`);
         case "http.resHeadersSent":
             return finish(`scr_http_res_headers_sent(${arg(0)})`);
+        case "http.resWritableEnded":
+            return finish(`scr_http_res_writable_ended(${arg(0)})`);
         case "http.resFlushHeaders":
             return finish(`scr_http_res_flush_headers(${arg(0)})`);
         case "http.resAddTrailers":
@@ -6245,6 +6353,32 @@ function emitHttpLibCall(state) {
         case "http.serverAllowMissingHostHeader":
             emitter.line(`scr_http_server_allow_missing_host_header(${arg(0)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        case "http.serverSetTimeout":
+            emitter.line(`scr_net_server_set_timeout_plain(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.serverCloseAllConnections":
+        case "http.serverCloseIdleConnections": {
+            const entry = e.fn === "http.serverCloseAllConnections"
+                ? "scr_net_server_close_all_connections" : "scr_net_server_close_idle_connections";
+            emitter.line(`${entry}(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "http.serverOnTimeout":
+        case "http.serverSetTimeoutCb": {
+            const cbIndex = e.fn === "http.serverSetTimeoutCb" ? 2 : 1;
+            const cbT = e.args[cbIndex].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError(`emitter bug: ${e.fn} callback not a func`);
+            const cb = args[cbIndex];
+            emitter.moveTemp(cb);
+            const adapter = cbT.params.length === 0 ? "scr_net_conn_thunk0" : "scr_net_conn_thunk_sock";
+            const entry = e.fn === "http.serverOnTimeout" ? "scr_net_server_on_timeout" : "scr_net_server_set_timeout_cb";
+            const callArgs = e.fn === "http.serverOnTimeout"
+                ? `${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)}`
+                : `${arg(0)}, ${arg(1)}, ${cb.name}, &${adapter}`;
+            emitter.line(`${entry}(${callArgs});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "http.serverTimeoutGet":
             return finish(`scr_net_server_timeout_get(${arg(0)}, ${arg(1)})`);
         case "http.serverTimeoutSet":
@@ -6257,27 +6391,82 @@ function emitHttpLibCall(state) {
         case "http.resStatusSet":
             emitter.line(`scr_http_res_status_set(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
-        case "http.resStatusMsgGet":
-            return finish(`scr_http_res_status_msg_get(${arg(0)})`);
+        case "http.resStatusMsgGet": {
+            if (e.type.kind !== "union")
+                throw new InternalCompilerError("emitter bug: http.resStatusMsgGet result is not a union");
+            const def = emitter.unionsById.get(e.type.unionId);
+            const strTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1;
+            const undefTag = undefinedArmTag(e.type, emitter.unionsById);
+            if (strTag < 0 || undefTag < 0)
+                throw new InternalCompilerError("emitter bug: http.resStatusMsgGet union lacks its arms");
+            const msg = emitter.newTemp(STRING, `scr_http_res_status_msg_get(${arg(0)})`);
+            emitter.moveTemp(msg);
+            const present = `scr_union_new_ref(${strTag}, ${msg.name}, &scr_str_retain_v, &scr_str_release_v, NULL)`;
+            return emitter.newTemp(e.type, `${msg.name} ? ${present} : ${emitter.unitInstanceRef(e.type.unionId, undefTag)}`);
+        }
         case "http.resStatusMsgSet":
             emitter.line(`scr_http_res_status_msg_set(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
-        case "http.resGetHeader": {
+        case "http.resRequest":
+            return finish(`scr_http_res_request(${arg(0)})`);
+        case "http.resSocket": {
+            if (e.type.kind !== "union")
+                throw new InternalCompilerError("emitter bug: http.resSocket result is not a union");
+            const def = emitter.unionsById.get(e.type.unionId);
+            const socketTag = def ? def.arms.findIndex((a) => a.kind === "netSocket") : -1;
+            const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
+            if (socketTag < 0 || nullTag < 0)
+                throw new InternalCompilerError("emitter bug: http.resSocket union lacks its arms");
+            const sock = emitter.newTemp(NETSOCKET_T, `scr_http_res_socket(${arg(0)})`);
+            emitter.moveTemp(sock);
+            const present = `scr_union_new_ref(${socketTag}, ${sock.name}, &scr_net_sock_retain_v, &scr_net_sock_release_v, NULL)`;
+            return emitter.newTemp(e.type, `${sock.name} ? ${present} : ${emitter.unitInstanceRef(e.type.unionId, nullTag)}`);
+        }
+        case "http.resWritableFinished":
+            return finish(`scr_http_res_writable_finished(${arg(0)})`);
+        case "http.resSendDateGet":
+            return finish(`scr_http_res_send_date(${arg(0)})`);
+        case "http.resSendDateSet":
+            emitter.line(`scr_http_res_set_send_date(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resStrictContentLengthGet":
+            return finish(`scr_http_res_strict_content_length(${arg(0)})`);
+        case "http.resStrictContentLengthSet":
+            emitter.line(`scr_http_res_set_strict_content_length(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resSetTimeout":
+            emitter.line(`scr_http_res_set_timeout_plain(${arg(0)}, ${arg(1)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.resSetTimeoutCb": {
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_http_res_set_timeout(${arg(0)}, ${arg(1)}, ${cb.name});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "http.resGetHeader":
+        case "http.clientGetHeader": {
             // string|undefined, exactly the http.reqHeader emission.
             if (e.type.kind !== "union")
-                throw new InternalCompilerError("emitter bug: http.resGetHeader result is not a union");
+                throw new InternalCompilerError(`emitter bug: ${e.fn} result is not a union`);
             const def = emitter.unionsById.get(e.type.unionId);
             const strTag = def ? def.arms.findIndex((a) => a.kind === "string") : -1;
             const undefTag = undefinedArmTag(e.type, emitter.unionsById);
             if (strTag < 0 || undefTag < 0) {
                 throw new InternalCompilerError("emitter bug: http.resGetHeader union lacks its arms");
             }
-            const s = emitter.newTemp(STRING, `scr_http_res_get_header(${arg(0)}, ${arg(1)})`);
+            const entry = e.fn === "http.resGetHeader" ? "scr_http_res_get_header" : "scr_http_client_get_header";
+            const s = emitter.newTemp(STRING, `${entry}(${arg(0)}, ${arg(1)})`);
             emitter.moveTemp(s); // moves into the box when present; NULL otherwise
             const present = `scr_union_new_ref(${strTag}, ${s.name}, &scr_str_retain_v, &scr_str_release_v, NULL)`;
             const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
             return emitter.newTemp(e.type, `${s.name} ? ${present} : ${absent}`);
         }
+        case "http.resGetHeaderNames":
+            return finish(`scr_http_res_get_header_names(${arg(0)})`);
+        case "http.resGetRawHeaderNames":
+            return finish(`scr_http_res_get_raw_header_names(${arg(0)})`);
+        case "http.resGetHeaders":
+            return finish(`scr_http_res_get_headers(${arg(0)})`);
         case "http.resHasHeader":
             return finish(`scr_http_res_has_header_named(${arg(0)}, ${arg(1)})`);
         case "http.resRemoveHeader":
@@ -6295,6 +6484,14 @@ function emitHttpLibCall(state) {
             return finish(`scr_http_res_write_head_dyn(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "http.reqSetEncoding":
             return finish(`scr_http_req_set_encoding(${arg(0)}, ${arg(1)})`);
+        case "http.reqSetTimeout":
+            return finish(`scr_http_req_set_timeout_plain(${arg(0)}, ${arg(1)})`);
+        case "http.reqSetTimeoutCb": {
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_http_req_set_timeout(${arg(0)}, ${arg(1)}, ${cb.name});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         // node:http, the client slice (scr_http.c over the net client).
         case "http.request":
         case "http.requestCb": {
@@ -6464,6 +6661,18 @@ function emitHttpLibCall(state) {
         }
         case "http.clientWrite":
             return finish(`scr_http_client_write_str(${arg(0)}, ${arg(1)})`);
+        case "http.clientSetHeader":
+            return finish(`scr_http_client_set_header(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "http.clientHasHeader":
+            return finish(`scr_http_client_has_header_named(${arg(0)}, ${arg(1)})`);
+        case "http.clientRemoveHeader":
+            return finish(`scr_http_client_remove_header(${arg(0)}, ${arg(1)})`);
+        case "http.clientGetHeaderNames":
+            return finish(`scr_http_client_get_header_names(${arg(0)})`);
+        case "http.clientGetRawHeaderNames":
+            return finish(`scr_http_client_get_raw_header_names(${arg(0)})`);
+        case "http.clientGetHeaders":
+            return finish(`scr_http_client_get_headers(${arg(0)})`);
         case "http.clientWriteBytes":
             return finish(`scr_http_client_write_bytes(${arg(0)}, ${arg(1)})`);
         case "http.clientEnd":
@@ -6487,9 +6696,48 @@ function emitHttpLibCall(state) {
             return finish(`scr_http_client_uncork(${arg(0)})`);
         case "http.clientWritableCorked":
             return finish(`scr_http_client_writable_corked(${arg(0)})`);
+        case "http.clientMethod":
+            return finish(`scr_http_client_method(${arg(0)})`);
+        case "http.clientPath":
+            return finish(`scr_http_client_path(${arg(0)})`);
+        case "http.clientHost":
+            return finish(`scr_http_client_host(${arg(0)})`);
+        case "http.clientProtocol":
+            return finish(`scr_http_client_protocol(${arg(0)})`);
+        case "http.clientHeadersSent":
+            return finish(`scr_http_client_headers_sent(${arg(0)})`);
+        case "http.clientWritableEnded":
+            return finish(`scr_http_client_writable_ended(${arg(0)})`);
+        case "http.clientWritableFinished":
+            return finish(`scr_http_client_writable_finished(${arg(0)})`);
+        case "http.clientSocket":
+            return finish(`scr_http_client_socket(${arg(0)})`);
+        case "http.clientReusedSocket":
+            return finish(`scr_http_client_reused_socket(${arg(0)})`);
+        case "http.clientSetNoDelay":
+            return finish(`scr_http_client_set_nodelay(${arg(0)}, ${arg(1)})`);
+        case "http.clientSetSocketKeepAlive":
+            return finish(`scr_http_client_set_socket_keepalive(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "http.clientSetTimeout":
+            return finish(`scr_http_client_set_timeout(${arg(0)}, ${arg(1)})`);
+        case "http.clientSetTimeoutCb": {
+            const cb = args[2];
+            emitter.moveTemp(cb);
+            emitter.line(`scr_http_client_set_timeout_cb(${arg(0)}, ${arg(1)}, ${cb.name});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "http.statusCodes":
+            return finish("scr_http_status_codes()");
+        case "http.methods":
+            return finish("scr_http_methods()");
         case "http.clientDestroy":
             emitter.line(`scr_http_client_destroy(${arg(0)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
+        case "http.clientAbort":
+            emitter.line(`scr_http_client_abort(${arg(0)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        case "http.clientAborted":
+            return finish(`scr_http_client_aborted(${arg(0)})`);
         case "http.clientDestroyed":
             return finish(`scr_http_client_destroyed(${arg(0)})`);
         case "http.clientOnResponse": {
@@ -6502,6 +6750,16 @@ function emitHttpLibCall(state) {
             emitter.line(`scr_http_client_on_response(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
+        case "http.clientOnSocket": {
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: http.clientOnSocket callback not a func");
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            const adapter = cbT.params.length === 0 ? "scr_net_conn_thunk0" : "scr_net_conn_thunk_sock";
+            emitter.line(`scr_http_client_on_socket(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "http.clientOnError": {
             const cbT = e.args[1].type;
             if (cbT.kind !== "func")
@@ -6513,10 +6771,14 @@ function emitHttpLibCall(state) {
             return { name: "", type: e.type };
         }
         case "http.clientOnTimeout":
-        case "http.clientOnClose": {
+        case "http.clientOnClose":
+        case "http.clientOnFinish":
+        case "http.clientOnAbort": {
             const cb = args[1];
             emitter.moveTemp(cb);
-            const fn = e.fn === "http.clientOnTimeout" ? "scr_http_client_on_timeout" : "scr_http_client_on_close";
+            const fn = e.fn === "http.clientOnTimeout" ? "scr_http_client_on_timeout"
+                : e.fn === "http.clientOnClose" ? "scr_http_client_on_close"
+                    : e.fn === "http.clientOnAbort" ? "scr_http_client_on_abort" : "scr_http_client_on_finish";
             emitter.line(`${fn}(${arg(0)}, ${cb.name}, ${arg(2)});${emitter.srcComment(e.loc)}`);
             return { name: "", type: e.type };
         }
@@ -7438,22 +7700,23 @@ function emitProcessLibCall(state) {
             return finish(`scr_stdin_next_chunk()`);
         case "process.isTTY":
             return finish(`scr_process_is_tty(${arg(0)})`);
-        case "process.columns": {
-            // ioctl(TIOCGWINSZ): a non-negative width wraps the f64 arm;
+        case "process.columns":
+        case "process.rows": {
+            // ioctl(TIOCGWINSZ): a non-negative dimension wraps the f64 arm;
             // a non-TTY stream (or an ioctl refusal) comes back negative
             // and yields the interned undefined-arm instance — Node's
-            // missing `.columns`. Type-directed union construction, like
+            // missing geometry. Type-directed union construction, like
             // process.envGet.
             if (e.type.kind !== "union") {
-                throw new InternalCompilerError("emitter bug: process.columns result is not a union");
+                throw new InternalCompilerError(`emitter bug: ${e.fn} result is not a union`);
             }
             const def = emitter.unionsById.get(e.type.unionId);
             const f64Tag = def ? def.arms.findIndex((a) => a.kind === "f64") : -1;
             const undefTag = undefinedArmTag(e.type, emitter.unionsById);
             if (f64Tag < 0 || undefTag < 0) {
-                throw new InternalCompilerError("emitter bug: process.columns union lacks its arms");
+                throw new InternalCompilerError(`emitter bug: ${e.fn} union lacks its arms`);
             }
-            const w = emitter.newTemp(F64, `scr_process_columns(${arg(0)})`);
+            const w = emitter.newTemp(F64, `scr_process_${e.fn === "process.rows" ? "rows" : "columns"}(${arg(0)})`);
             const present = `scr_union_new_f64(${f64Tag}, ${w.name})`;
             const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
             return emitter.newTemp(e.type, `${w.name} >= 0 ? ${present} : ${absent}`);
@@ -8291,6 +8554,14 @@ function emitIoLibCall(state) {
     }
 }
 function emitLibCallExpr(emitter, e) {
+    const packed = e.args[0];
+    if (e.fn === "string.fromCharCode" && packed?.kind === "arrayLit" &&
+        packed.elems.length === 1 && !packed.spreads?.length) {
+        // The literal is only the variadic ABI pack, never an observable
+        // array. Evaluate the scalar once before bypassing that allocation.
+        const code = emitter.emitExpr(packed.elems[0]);
+        return emitter.newTemp(e.type, `scr_str_from_char_code_one(${code.name})`);
+    }
     // Standard-library call. Args are BORROWED (owned temps of the
     // current frame, released at statement end); refcounted results come
     // back +1 (process.argv: +1 on the runtime's ONE interned array —