@scriptc/compiler 0.1.3 → 0.1.5

package/dist/ir/validate.js

@@ -11,8 +11,8 @@ export const STR_INTRINSIC_SIGS = {
     charAt: { argTypes: [F64], minArgs: 1, result: STRING },
     indexOf: { argTypes: [STRING, F64], minArgs: 1, result: F64 },
     includes: { argTypes: [STRING, F64], minArgs: 1, result: BOOL },
-    startsWith: { argTypes: [STRING], minArgs: 1, result: BOOL },
-    endsWith: { argTypes: [STRING], minArgs: 1, result: BOOL },
+    startsWith: { argTypes: [STRING, F64], minArgs: 1, result: BOOL },
+    endsWith: { argTypes: [STRING, F64], minArgs: 1, result: BOOL },
     slice: { argTypes: [F64, F64], minArgs: 0, result: STRING },
     substring: { argTypes: [F64, F64], minArgs: 1, result: STRING },
     repeat: { argTypes: [F64], minArgs: 1, result: STRING },
@@ -196,11 +196,27 @@ export const LIB_FN_SIGS = {
     "os.networkInterfaces": { argTypes: [], result: VOID },
     "math.maxArr": { argTypes: [arrayOf(F64)], result: F64 },
     "math.minArr": { argTypes: [arrayOf(F64)], result: F64 },
+    "math.hypotArr": { argTypes: [arrayOf(F64)], result: F64 },
     "math.floor": { argTypes: [F64], result: F64 },
     "math.abs": { argTypes: [F64], result: F64 },
     "math.round": { argTypes: [F64], result: F64 },
     "math.trunc": { argTypes: [F64], result: F64 },
     "math.ceil": { argTypes: [F64], result: F64 },
+    "math.sin": { argTypes: [F64], result: F64 },
+    "math.cos": { argTypes: [F64], result: F64 },
+    "math.tan": { argTypes: [F64], result: F64 },
+    "math.asin": { argTypes: [F64], result: F64 },
+    "math.acos": { argTypes: [F64], result: F64 },
+    "math.atan": { argTypes: [F64], result: F64 },
+    "math.cbrt": { argTypes: [F64], result: F64 },
+    "math.sign": { argTypes: [F64], result: F64 },
+    "math.exp": { argTypes: [F64], result: F64 },
+    "math.sqrt": { argTypes: [F64], result: F64 },
+    "math.log": { argTypes: [F64], result: F64 },
+    "math.log2": { argTypes: [F64], result: F64 },
+    "math.log10": { argTypes: [F64], result: F64 },
+    "math.atan2": { argTypes: [F64, F64], result: F64 },
+    "math.pow": { argTypes: [F64, F64], result: F64 },
     "math.min": { argTypes: [F64, F64], result: F64 },
     "math.max": { argTypes: [F64, F64], result: F64 },
     "math.random": { argTypes: [], result: F64 },
@@ -246,6 +262,7 @@ export const LIB_FN_SIGS = {
     "bigint.shl": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
     "bigint.shr": { argTypes: [BIGINT_T, BIGINT_T], result: BIGINT_T },
     "bigint.eq": { argTypes: [BIGINT_T, BIGINT_T], result: BOOL },
+    "bigint.eqString": { argTypes: [BIGINT_T, STRING], result: BOOL },
     "bigint.cmp": { argTypes: [BIGINT_T, BIGINT_T], result: F64 },
     "bigint.cmpNumber": { argTypes: [BIGINT_T, F64], result: F64 },
     "bigint.truthy": { argTypes: [BIGINT_T], result: BOOL },
@@ -260,8 +277,12 @@ export const LIB_FN_SIGS = {
     "bigint.dataViewSet": { argTypes: [BYTES_U8, F64, BIGINT_T, BOOL], result: VOID },
     "url.new": { argTypes: [STRING], result: URL_T },
     "url.protocol": { argTypes: [URL_T], result: STRING },
+    "url.origin": { argTypes: [URL_T], result: STRING },
+    "url.username": { argTypes: [URL_T], result: STRING },
+    "url.password": { argTypes: [URL_T], result: STRING },
     "url.host": { argTypes: [URL_T], result: STRING },
     "url.hostname": { argTypes: [URL_T], result: STRING },
+    "url.port": { argTypes: [URL_T], result: STRING },
     "url.pathname": { argTypes: [URL_T], result: STRING },
     "url.href": { argTypes: [URL_T], result: STRING },
     "url.fileURLToPathUrl": { argTypes: [URL_T], result: STRING },
@@ -277,6 +298,7 @@ export const LIB_FN_SIGS = {
     "sp.with": { argTypes: [SEARCH_PARAMS_T, STRING, STRING], result: SEARCH_PARAMS_T },
     "url.searchParams": { argTypes: [URL_T], result: SEARCH_PARAMS_T },
     "url.search": { argTypes: [URL_T], result: STRING },
+    "url.hash": { argTypes: [URL_T], result: STRING },
     // Result is the interned `string | null` union — the libCall case
     // checks the arms (the spawnRes.signal pattern).
     "sp.get": { argTypes: [SEARCH_PARAMS_T, STRING], result: VOID },
@@ -303,7 +325,12 @@ export const LIB_FN_SIGS = {
     "util.parseArgs": { argTypes: [DYN], result: DYN },
     "fs.statSync": { argTypes: [STRING], result: STATS_T },
     "fs.lstatSync": { argTypes: [STRING], result: STATS_T },
+    "fs.fstatSync": { argTypes: [F64], result: STATS_T },
+    "fs.fchmodSync": { argTypes: [F64, F64], result: VOID },
+    "fs.fsyncSync": { argTypes: [F64], result: VOID },
+    "fs.linkSync": { argTypes: [STRING, STRING], result: VOID },
     "fs.openSync": { argTypes: [STRING, STRING], result: F64 },
+    "fs.openNumericSync": { argTypes: [STRING, F64, F64], result: F64 },
     "fs.readSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
     "fs.writeSync": { argTypes: [F64, BYTES_U8, F64, F64, F64], result: F64 },
     "fs.writeStrSync": { argTypes: [F64, STRING, F64, STRING], result: F64 },
@@ -323,10 +350,13 @@ export const LIB_FN_SIGS = {
     "stats.isDirectory": { argTypes: [STATS_T], result: BOOL },
     "stats.isSymbolicLink": { argTypes: [STATS_T], result: BOOL },
     "stats.size": { argTypes: [STATS_T], result: F64 },
+    "stats.dev": { argTypes: [STATS_T], result: F64 },
+    "stats.ino": { argTypes: [STATS_T], result: F64 },
     "stats.blocks": { argTypes: [STATS_T], result: F64 },
     "stats.nlink": { argTypes: [STATS_T], result: F64 },
     "stats.atimeMs": { argTypes: [STATS_T], result: F64 },
     "stats.mtimeMs": { argTypes: [STATS_T], result: F64 },
+    "stats.ctimeMs": { argTypes: [STATS_T], result: F64 },
     // The wider sync fs slice (unlink/chmod/chown/copyfile and the
     // mode-carrying write/mkdir forms).
     "fs.unlinkSync": { argTypes: [STRING], result: VOID },
@@ -369,6 +399,7 @@ export const LIB_FN_SIGS = {
     // the callback follows the reusePort BOOL in this additive ABI.
     "net.listenOptsReusePortCb": { argTypes: [NETSERVER_T, F64, STRING, BOOL, BOOL, null], result: VOID },
     "net.serverPort": { argTypes: [NETSERVER_T], result: F64 },
+    "net.serverListening": { argTypes: [NETSERVER_T], result: BOOL },
     // net.serverAddress's record result is shape-checked in the libCall case
     // (the dgram.address sentinel pattern).
     "net.serverAddress": { argTypes: [NETSERVER_T], result: VOID },
@@ -444,29 +475,55 @@ export const LIB_FN_SIGS = {
     // union, checked like process.envGet.
     "http.createServer": { argTypes: [null], result: NETSERVER_T },
     "http.createServerEmpty": { argTypes: [], result: NETSERVER_T },
+    "http.validateHeaderName": { argTypes: [STRING, STRING], result: VOID },
+    "http.validateHeaderValue": { argTypes: [STRING, DYN], result: VOID },
     "http.serverJoinDupHeaders": { argTypes: [NETSERVER_T], result: VOID },
+    "http.serverAllowMissingHostHeader": { argTypes: [NETSERVER_T], result: VOID },
     "http.serverTimeoutGet": { argTypes: [NETSERVER_T, F64], result: F64 },
+    "http.serverSetTimeout": { argTypes: [NETSERVER_T, F64], result: VOID },
+    "http.serverSetTimeoutCb": { argTypes: [NETSERVER_T, F64, null], result: VOID },
+    "http.serverOnTimeout": { argTypes: [NETSERVER_T, null, BOOL], result: VOID },
+    "http.serverCloseAllConnections": { argTypes: [NETSERVER_T], result: VOID },
+    "http.serverCloseIdleConnections": { argTypes: [NETSERVER_T], result: VOID },
     "http.serverTimeoutSet": { argTypes: [NETSERVER_T, F64, F64], result: VOID },
     "http.serverTimeoutOptionSet": { argTypes: [NETSERVER_T, F64, DYN], result: VOID },
     "net.serverOnListening": { argTypes: [NETSERVER_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "http.resStatusGet": { argTypes: [HTTPRES_T], result: F64 },
     "http.resStatusSet": { argTypes: [HTTPRES_T, F64], result: VOID },
-    "http.resStatusMsgGet": { argTypes: [HTTPRES_T], result: STRING },
+    "http.resStatusMsgGet": { argTypes: [HTTPRES_T], result: VOID },
     "http.resStatusMsgSet": { argTypes: [HTTPRES_T, STRING], result: VOID },
+    "http.resRequest": { argTypes: [HTTPRES_T], result: HTTPREQ_T },
+    "http.resSocket": { argTypes: [HTTPRES_T], result: VOID },
+    "http.resWritableFinished": { argTypes: [HTTPRES_T], result: BOOL },
+    "http.resSendDateGet": { argTypes: [HTTPRES_T], result: BOOL },
+    "http.resSendDateSet": { argTypes: [HTTPRES_T, BOOL], result: VOID },
+    "http.resStrictContentLengthGet": { argTypes: [HTTPRES_T], result: BOOL },
+    "http.resStrictContentLengthSet": { argTypes: [HTTPRES_T, BOOL], result: VOID },
+    "http.resSetTimeout": { argTypes: [HTTPRES_T, F64], result: VOID },
+    "http.resSetTimeoutCb": { argTypes: [HTTPRES_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
     // resGetHeader answers the interned `string | undefined` union — the
     // reqHeader/envGet sentinel pattern (VOID here, checked specially).
     "http.resGetHeader": { argTypes: [HTTPRES_T, STRING], result: VOID },
+    "http.resGetHeaderNames": { argTypes: [HTTPRES_T], result: arrayOf(STRING) },
+    "http.resGetRawHeaderNames": { argTypes: [HTTPRES_T], result: arrayOf(STRING) },
+    "http.resGetHeaders": { argTypes: [HTTPRES_T], result: DYN },
     "http.resHasHeader": { argTypes: [HTTPRES_T, STRING], result: BOOL },
     "http.resRemoveHeader": { argTypes: [HTTPRES_T, STRING], result: VOID },
     "http.resOnFinish": { argTypes: [HTTPRES_T, { kind: "func", params: [], ret: VOID }], result: VOID },
     "http.reqUrl": { argTypes: [HTTPREQ_T], result: STRING },
     "http.reqMethod": { argTypes: [HTTPREQ_T], result: STRING },
     "http.reqHeader": { argTypes: [HTTPREQ_T, STRING], result: VOID },
+    "http.reqTrailer": { argTypes: [HTTPREQ_T, STRING], result: VOID },
+    "http.reqHeaderValues": { argTypes: [HTTPREQ_T, STRING], result: VOID },
+    "http.reqTrailerValues": { argTypes: [HTTPREQ_T, STRING], result: VOID },
     "http.reqOnData": { argTypes: [HTTPREQ_T, null, BOOL], result: VOID },
     "http.reqOnEnd": { argTypes: [HTTPREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "http.resSetHeader": { argTypes: [HTTPRES_T, STRING, STRING], result: VOID },
     "http.resWriteHead": { argTypes: [HTTPRES_T, F64], result: VOID },
     "http.resWriteHeadN": { argTypes: [HTTPRES_T, F64, arrayOf(STRING), arrayOf(STRING)], result: VOID },
+    "http.resWriteContinue": { argTypes: [HTTPRES_T], result: VOID },
+    "http.resWriteProcessing": { argTypes: [HTTPRES_T], result: VOID },
+    "http.resWriteEarlyHints": { argTypes: [HTTPRES_T, arrayOf(STRING)], result: VOID },
     "http.resWrite": { argTypes: [HTTPRES_T, STRING], result: VOID },
     "http.resWriteBytes": { argTypes: [HTTPRES_T, BYTES_U8], result: VOID },
     "http.resEnd": { argTypes: [HTTPRES_T], result: VOID },
@@ -475,6 +532,12 @@ export const LIB_FN_SIGS = {
     "http.resWriteDyn": { argTypes: [HTTPRES_T, DYN], result: VOID },
     "http.resEndDyn": { argTypes: [HTTPRES_T, DYN], result: VOID },
     "http.resHeadersSent": { argTypes: [HTTPRES_T], result: BOOL },
+    "http.resWritableEnded": { argTypes: [HTTPRES_T], result: BOOL },
+    "http.resFlushHeaders": { argTypes: [HTTPRES_T], result: VOID },
+    "http.resAddTrailers": { argTypes: [HTTPRES_T, arrayOf(STRING)], result: VOID },
+    "http.resCork": { argTypes: [HTTPRES_T], result: VOID },
+    "http.resUncork": { argTypes: [HTTPRES_T], result: VOID },
+    "http.resWritableCorked": { argTypes: [HTTPRES_T], result: F64 },
     // The member follow-ups: reqStatusCode's `number | undefined` and
     // sockRemoteAddress's `string | undefined` results are shape-checked in
     // the special cases below (like reqHeader/columns).
@@ -484,6 +547,8 @@ export const LIB_FN_SIGS = {
     "http.reqStatusMessage": { argTypes: [HTTPREQ_T], result: VOID },
     "http.reqRawHeaders": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
     "http.reqHeaderPairs": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
+    "http.reqRawTrailers": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
+    "http.reqTrailerPairs": { argTypes: [HTTPREQ_T], result: arrayOf(STRING) },
     "net.sockDestroyed": { argTypes: [NETSOCKET_T], result: BOOL },
     "net.sockWritable": { argTypes: [NETSOCKET_T], result: BOOL },
     // The 'upgrade' registrations: the callback shapes are program-typed
@@ -672,18 +737,52 @@ export const LIB_FN_SIGS = {
     "https.requestFn": { argTypes: [BOOL, STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null], result: HTTPCLIENTREQ_T },
     "https.requestFnCb": { argTypes: [BOOL, STRING, F64, STRING, STRING, F64, arrayOf(STRING), BOOL, BOOL, null, null], result: HTTPCLIENTREQ_T },
     "http.clientWrite": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
+    "http.clientSetHeader": { argTypes: [HTTPCLIENTREQ_T, STRING, STRING], result: VOID },
+    "http.clientGetHeader": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
+    "http.clientHasHeader": { argTypes: [HTTPCLIENTREQ_T, STRING], result: BOOL },
+    "http.clientRemoveHeader": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
+    "http.clientGetHeaderNames": { argTypes: [HTTPCLIENTREQ_T], result: arrayOf(STRING) },
+    "http.clientGetRawHeaderNames": { argTypes: [HTTPCLIENTREQ_T], result: arrayOf(STRING) },
+    "http.clientGetHeaders": { argTypes: [HTTPCLIENTREQ_T], result: DYN },
     "http.clientWriteBytes": { argTypes: [HTTPCLIENTREQ_T, BYTES_U8], result: VOID },
     "http.clientEnd": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
     "http.clientEndStr": { argTypes: [HTTPCLIENTREQ_T, STRING], result: VOID },
     "http.clientEndBytes": { argTypes: [HTTPCLIENTREQ_T, BYTES_U8], result: VOID },
     "http.clientWriteDyn": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
     "http.clientEndDyn": { argTypes: [HTTPCLIENTREQ_T, DYN], result: VOID },
+    "http.clientFlushHeaders": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
+    "http.clientAddTrailers": { argTypes: [HTTPCLIENTREQ_T, arrayOf(STRING)], result: VOID },
+    "http.clientCork": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
+    "http.clientUncork": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
+    "http.clientWritableCorked": { argTypes: [HTTPCLIENTREQ_T], result: F64 },
+    "http.clientMethod": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
+    "http.clientPath": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
+    "http.clientHost": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
+    "http.clientProtocol": { argTypes: [HTTPCLIENTREQ_T], result: STRING },
+    "http.clientHeadersSent": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
+    "http.clientWritableEnded": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
+    "http.clientWritableFinished": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
+    "http.clientSocket": { argTypes: [HTTPCLIENTREQ_T], result: NETSOCKET_T },
+    "http.clientReusedSocket": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
+    "http.clientSetNoDelay": { argTypes: [HTTPCLIENTREQ_T, BOOL], result: VOID },
+    "http.clientSetSocketKeepAlive": { argTypes: [HTTPCLIENTREQ_T, BOOL, F64], result: VOID },
+    "http.clientSetTimeout": { argTypes: [HTTPCLIENTREQ_T, F64], result: VOID },
+    "http.clientSetTimeoutCb": { argTypes: [HTTPCLIENTREQ_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
+    "http.statusCodes": { argTypes: [], result: DYN },
+    "http.methods": { argTypes: [], result: arrayOf(STRING) },
+    "http.reqSetTimeout": { argTypes: [HTTPREQ_T, F64], result: VOID },
+    "http.reqSetTimeoutCb": { argTypes: [HTTPREQ_T, F64, { kind: "func", params: [], ret: VOID }], result: VOID },
     "http.clientDestroy": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
+    "http.clientAbort": { argTypes: [HTTPCLIENTREQ_T], result: VOID },
+    "http.clientAborted": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
     "http.clientDestroyed": { argTypes: [HTTPCLIENTREQ_T], result: BOOL },
     "http.clientOnResponse": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
+    "http.clientOnSocket": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
+    "http.clientOnFinish": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "http.clientOnError": { argTypes: [HTTPCLIENTREQ_T, null, BOOL], result: VOID },
     "http.clientOnTimeout": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "http.clientOnClose": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
+    "http.clientOnAbort": { argTypes: [HTTPCLIENTREQ_T, { kind: "func", params: [], ret: VOID }, BOOL], result: VOID },
     "cp.execSync": {
         argTypes: [STRING, arrayOf(STRING), BOOL, STRING, BOOL, STRING, BOOL, arrayOf(STRING), F64, F64, F64],
         result: STRING,
@@ -693,17 +792,36 @@ export const LIB_FN_SIGS = {
         result: SPAWNRES_T,
     },
     "cp.spawn": { argTypes: [STRING, arrayOf(STRING)], result: CHILD_T },
+    "process.forkTarget": { argTypes: [F64], result: F64 },
+    "cp.fork": {
+        argTypes: [F64, arrayOf(STRING), F64, F64, F64, BOOL, arrayOf(STRING), STRING],
+        result: CHILD_T,
+    },
+    "child.connected": { argTypes: [CHILD_T], result: BOOL },
+    "child.send": { argTypes: [CHILD_T, STRING], result: BOOL },
+    "child.sendCb": { argTypes: [CHILD_T, STRING, null], result: BOOL },
+    "child.disconnect": { argTypes: [CHILD_T], result: VOID },
+    "child.onMessage": { argTypes: [CHILD_T, null, BOOL], result: VOID },
+    "child.onDisconnect": { argTypes: [CHILD_T, null, BOOL], result: VOID },
+    "process.connected": { argTypes: [], result: BOOL },
+    "process.send": { argTypes: [STRING], result: BOOL },
+    "process.sendCb": { argTypes: [STRING, null], result: BOOL },
+    "process.disconnect": { argTypes: [], result: VOID },
+    "process.onMessage": { argTypes: [null, BOOL], result: VOID },
+    "process.onDisconnect": { argTypes: [null, BOOL], result: VOID },
+    "cp.execFile": { argTypes: [STRING, arrayOf(STRING), null], result: CHILD_T },
     // spawn's options form: per-slot stdio modes (0 ignore / 1 inherit /
     // 2 fd) with the out/err fds for mode 2, detached, env replacement
     // pairs, cwd ("" = inherit).
     "cp.spawnOpts": {
-        argTypes: [STRING, arrayOf(STRING), F64, F64, F64, F64, F64, BOOL, BOOL, arrayOf(STRING), STRING],
+        argTypes: [STRING, arrayOf(STRING), F64, F64, F64, F64, F64, BOOL, BOOL, BOOL, arrayOf(STRING), STRING],
         result: CHILD_T,
     },
     // The callback's func type is program-dependent (zero params, or the
     // `number | null` union / the %Error class) — the libCall case checks
     // the shape; the slot here only pins arity and the child receiver.
     "child.onExit": { argTypes: [CHILD_T, null], result: VOID },
+    "child.onClose": { argTypes: [CHILD_T, null], result: VOID },
     "child.onError": { argTypes: [CHILD_T, null], result: VOID },
     // Like process.envGet, spawnRes.status's result type is program-dependent
     // (the interned `number | null` union) — the libCall case checks the arms.
@@ -734,7 +852,9 @@ export const LIB_FN_SIGS = {
     // (zero-param / Buffer / Buffer-armed union) — the slots pin arity,
     // the stream receiver, and the once-flag.
     "stream.onData": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
+    "stream.onDataStr": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
     "stream.onEnd": { argTypes: [CHILDSTREAM_T, null, BOOL], result: VOID },
+    "stream.childSetEncoding": { argTypes: [CHILDSTREAM_T, STRING], result: CHILDSTREAM_T },
     "writer.writeString": { argTypes: [CHILDWRITER_T, STRING], result: BOOL },
     "writer.writeBytes": { argTypes: [CHILDWRITER_T, BYTES_U8], result: BOOL },
     "writer.end": { argTypes: [CHILDWRITER_T], result: VOID },
@@ -808,6 +928,19 @@ export const LIB_FN_SIGS = {
     "fsp.readFileBytes": { argTypes: [STRING], result: { kind: "promise", inner: BYTES_U8 } },
     "zlib.deflateSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "zlib.inflateSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.deflateRawSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.inflateRawSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.gzipSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.gunzipSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.unzipSync": { argTypes: [BYTES_U8], result: BYTES_U8 },
+    "zlib.deflateCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.inflateCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.deflateRawCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.inflateRawCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.gzipCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.gunzipCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.unzipCb": { argTypes: [BYTES_U8, null], result: VOID },
+    "zlib.crc32": { argTypes: [BYTES_U8, F64], result: F64 },
     "process.stdoutWriteBytes": { argTypes: [BYTES_U8, STRING], result: BOOL },
     "process.stderrWriteBytes": { argTypes: [BYTES_U8, STRING], result: BOOL },
     // Completion callback is program-dependent: zero params, checked-dynamic,
@@ -825,8 +958,13 @@ export const LIB_FN_SIGS = {
     "fsp.chmod": { argTypes: [STRING, F64], result: { kind: "promise", inner: VOID } },
     "fsp.rename": { argTypes: [STRING, STRING], result: { kind: "promise", inner: VOID } },
     "fsp.readdir": { argTypes: [STRING], result: { kind: "promise", inner: arrayOf(STRING) } },
+    // Result is promise<call-site Dirent record array>; the libCall case
+    // validates the program-dependent record shape below.
+    "fsp.readdirTypes": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
     "fsp.rm": { argTypes: [STRING], result: { kind: "promise", inner: VOID } },
     "fsp.stat": { argTypes: [STRING], result: { kind: "promise", inner: STATS_T } },
+    "fsp.realpath": { argTypes: [STRING], result: { kind: "promise", inner: STRING } },
+    "fsp.lstat": { argTypes: [STRING], result: { kind: "promise", inner: STATS_T } },
     "fsp.open": { argTypes: [STRING, STRING, F64], result: { kind: "promise", inner: FILEHANDLE_T } },
     "fileHandle.fd": { argTypes: [FILEHANDLE_T], result: F64 },
     "fileHandle.close": { argTypes: [FILEHANDLE_T], result: { kind: "promise", inner: VOID } },
@@ -851,6 +989,8 @@ export const LIB_FN_SIGS = {
     "process.envUnset": { argTypes: [STRING], result: VOID },
     "process.envPairs": { argTypes: [], result: arrayOf(STRING) },
     "process.exit": { argTypes: [F64], result: VOID },
+    "process.setExitCode": { argTypes: [F64], result: VOID },
+    "process.currentExitCode": { argTypes: [], result: F64 },
     "process.cwd": { argTypes: [], result: STRING },
     "process.pid": { argTypes: [], result: F64 },
     "dyn.this": { argTypes: [], result: DYN },
@@ -869,6 +1009,7 @@ export const LIB_FN_SIGS = {
     "error.new": { argTypes: [STRING], result: VOID },
     "error.nodeThrow": { argTypes: [F64, STRING, STRING], result: VOID },
     "dyn.toStringCoerce": { argTypes: [DYN], result: STRING },
+    "dyn.toNumberCoerce": { argTypes: [DYN], result: F64 },
     // Always throws; the result is the READ's declared type (a typed dummy
     // the unwind abandons) — the libCall case skips the result check.
     "global.undefRead": { argTypes: [STRING], result: VOID },
@@ -921,9 +1062,11 @@ export const LIB_FN_SIGS = {
     // once, prepend), offDyn (recv, name, cb dyn).
     "emitter.checkListener": { argTypes: [DYN], result: VOID },
     "emitter.onDyn": { argTypes: [null, STRING, DYN, null, BOOL, BOOL], result: VOID },
+    "emitter.onFlex": { argTypes: [null, STRING, DYN, BOOL, BOOL], result: VOID },
     "emitter.offDyn": { argTypes: [null, STRING, DYN], result: VOID },
     "emitter.removeAll": { argTypes: [null, STRING, BOOL], result: VOID },
     "emitter.emit": { argTypes: [null, STRING], result: BOOL },
+    "emitter.emitFlex": { argTypes: [null, STRING], result: BOOL },
     "emitter.emitError": { argTypes: [null, STRING, null], result: BOOL },
     "emitter.count": { argTypes: [null, STRING], result: F64 },
     "emitter.countFn": { argTypes: [null, STRING, null], result: F64 },
@@ -1035,6 +1178,7 @@ export const LIB_FN_SIGS = {
     // The equality quartet over checked-dynamic operands (the frontend
     // boxes a static side into the checked-dynamic tree first).
     "assert.eqDyn": { argTypes: [DYN, DYN, BOOL, BOOL, STRING, BOOL], result: VOID },
+    "assert.looseResult": { argTypes: [BOOL, BOOL, STRING, STRING, STRING, BOOL], result: VOID },
     // The throws(fn, {shape}) accumulator: begin/slot calls never throw;
     // shapeEnd throws the Comparison diff. The error slot is the
     // %Error-narrowed caught value.
@@ -1139,6 +1283,7 @@ export const LIB_FN_SIGS = {
     "date.newNow": { argTypes: [], result: DATE_T },
     "date.newMs": { argTypes: [F64], result: DATE_T },
     "date.newString": { argTypes: [STRING], result: DATE_T },
+    "date.parse": { argTypes: [STRING], result: F64 },
     "date.getTime": { argTypes: [DATE_T], result: F64 },
     "date.valueOf": { argTypes: [DATE_T], result: F64 },
     "date.toISOString": { argTypes: [F64], result: STRING },
@@ -1181,6 +1326,7 @@ export const LIB_FN_SIGS = {
     // form) — checked in the libCall case.
     "string.fromCharCode": { argTypes: [null], result: STRING },
     "string.lastIndexOf": { argTypes: [STRING, STRING], result: F64 },
+    "string.lastIndexOfFrom": { argTypes: [STRING, STRING, F64], result: F64 },
     "string.raw": { argTypes: [arrayOf(STRING), arrayOf(STRING)], result: STRING },
 };
 /** True for an object type naming a runtime-provided error class. */
@@ -1817,6 +1963,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 if (e.type.kind !== "string")
                     err("strLit must be string", e.loc);
                 break;
+            case "moduleNsRef":
+                if (e.type.kind !== "moduleNs" || e.type.moduleId !== e.moduleId) {
+                    err("moduleNsRef must match its moduleNs type", e.loc);
+                }
+                break;
             case "boolLit":
                 if (e.type.kind !== "bool")
                     err("boolLit must be bool", e.loc);
@@ -1855,6 +2006,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`bin ${e.op} on class values: right operand is ${e.right.type.kind}`, e.loc);
                     }
                 }
+                else if (isEq && e.left.type.kind === "moduleNs") {
+                    if (e.right.type.kind !== "moduleNs") {
+                        err(`bin ${e.op} on module namespaces: right operand is ${e.right.type.kind}`, e.loc);
+                    }
+                }
                 else if (isEq &&
                     (e.left.type.kind === "array" ||
                         e.left.type.kind === "map" ||
@@ -2577,7 +2733,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     ? { argTypes: e.args.map(() => elem), result: F64 }
                     : e.method === "pushSpread" || e.method === "concatSpread" || e.method === "unshiftSpread"
                         ? { argTypes: [e.receiver.type], result: F64 }
-                        : e.method === "nextPresent"
+                        : e.method === "nextPresent" || e.method === "getNumber"
                             ? { argTypes: [F64], result: F64 }
                             : e.method === "pop"
                                 ? { argTypes: [], result: e.type } // union-checked below
@@ -2604,6 +2760,9 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                                                                         : e.method === "shift"
                                                                             ? { argTypes: [], result: e.type } // union-checked below
                                                                             : { argTypes: [], result: F64 }; // length
+                if (e.method === "getNumber" && elem.kind !== "f64") {
+                    err(`arrIntrinsic getNumber requires f64 elements, got ${elem.kind}`, e.loc);
+                }
                 if (e.method === "join" &&
                     elem.kind !== "f64" && elem.kind !== "string" && elem.kind !== "bool" &&
                     !(elem.kind === "union" &&
@@ -2859,7 +3018,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     // ISLAND-REST types (restAbi jsval) SPELL their trailing engine
                     // array param — the lifted signature matches directly, no
                     // hidden slot.
-                    const hiddenRest = e.type.rest === true && e.type.restAbi !== "jsval";
+                    const hiddenRest = e.type.rest === true && e.type.restAbi === undefined;
                     const declared = hiddenRest ? target.params.slice(0, -1) : target.params;
                     const restOk = !hiddenRest ||
                         (target.params.length === e.type.params.length + 1 &&
@@ -3764,7 +3923,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 // The stream constructors (trailing option callbacks), write/end
                 // (the optional chunk/cb tail), and unpipe (the optional
                 // destination) admit a longer list the same way.
-                const variadic = e.fn === "emitter.emit" ||
+                const variadic = e.fn === "emitter.emit" || e.fn === "emitter.emitFlex" ||
                     e.fn === "readable.new" || e.fn === "writable.new" ||
                     e.fn === "duplex.new" || e.fn === "transform.new" ||
                     e.fn === "passthrough.new" ||
@@ -4100,7 +4259,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
-                if (e.fn === "http.reqStatusMessage") {
+                if (e.fn === "http.reqStatusMessage" || e.fn === "http.resStatusMsgGet") {
                     // Result is the interned `string | undefined` union (reqHeader's).
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     const ok = def &&
@@ -4108,10 +4267,19 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         def.arms.some((a) => a.kind === "string") &&
                         def.arms.some((a) => a.kind === "undefinedT");
                     if (!ok) {
-                        err(`libCall http.reqStatusMessage must return the 'string | undefined' union`, e.loc);
+                        err(`libCall ${e.fn} must return the 'string | undefined' union`, e.loc);
                     }
                     break;
                 }
+                if (e.fn === "http.resSocket") {
+                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+                    const ok = def && def.arms.length === 2 &&
+                        def.arms.some((a) => a.kind === "netSocket") &&
+                        def.arms.some((a) => a.kind === "nullT");
+                    if (!ok)
+                        err(`libCall http.resSocket must return the 'Socket | null' union`, e.loc);
+                    break;
+                }
                 if (e.fn === "http.reqH2Stream") {
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     const ok = def && def.arms.length === 2 &&
@@ -4121,7 +4289,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`libCall http.reqH2Stream must return the 'Http2Stream | undefined' union`, e.loc);
                     break;
                 }
-                if (e.fn === "http.reqHeader" || e.fn === "http.resGetHeader") {
+                if (e.fn === "http.reqHeader" || e.fn === "http.reqTrailer" || e.fn === "http.resGetHeader" || e.fn === "http.clientGetHeader") {
                     // Result is the interned `string | undefined` union (envGet's).
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
                     const ok = def &&
@@ -4133,15 +4301,26 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
+                if (e.fn === "http.reqHeaderValues" || e.fn === "http.reqTrailerValues") {
+                    const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
+                    const ok = def && def.arms.length === 2 &&
+                        def.arms[0].kind === "array" && def.arms[0].elem.kind === "string" &&
+                        def.arms[1].kind === "undefinedT";
+                    if (!ok)
+                        err(`libCall ${e.fn} must return the 'string[] | undefined' union`, e.loc);
+                    break;
+                }
                 if (e.fn === "net.createServerCb" || e.fn === "net.serverOnConnection" ||
                     e.fn === "net.serverOnSecureConnection" ||
+                    e.fn === "http.serverSetTimeoutCb" || e.fn === "http.serverOnTimeout" ||
+                    e.fn === "http.clientOnSocket" ||
                     e.fn === "net.sockOnData" || e.fn === "net.serverOnError" ||
                     e.fn === "net.sockOnError") {
                     // The program-dependent listener shapes: a void closure with no
                     // params, or exactly the one supported parameter per event
                     // (socket handle / data chunk bytes / error %Error). The
                     // callback slot is arg 0 for createServerCb, arg 1 otherwise.
-                    const cbT = e.args[e.fn === "net.createServerCb" ? 0 : 1]?.type;
+                    const cbT = e.args[e.fn === "net.createServerCb" ? 0 : e.fn === "http.serverSetTimeoutCb" ? 2 : 1]?.type;
                     let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 1;
                     if (ok && cbT?.kind === "func" && cbT.params.length === 1) {
                         const p = cbT.params[0];
@@ -4231,6 +4410,30 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
+                if (e.fn === "zlib.deflateCb" || e.fn === "zlib.inflateCb" ||
+                    e.fn === "zlib.deflateRawCb" || e.fn === "zlib.inflateRawCb" ||
+                    e.fn === "zlib.gzipCb" || e.fn === "zlib.gunzipCb" || e.fn === "zlib.unzipCb") {
+                    const cbT = e.args[1]?.type;
+                    let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= 2;
+                    if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
+                        const error = cbT.params[0];
+                        if (error.kind !== "dyn") {
+                            const def = error.kind === "union" ? unions.get(error.unionId) : undefined;
+                            ok = def !== undefined &&
+                                def.arms.some((arm) => arm.kind === "nullT") &&
+                                def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error") &&
+                                def.arms.every((arm) => arm.kind === "nullT" || arm.kind === "undefinedT" ||
+                                    (arm.kind === "object" && arm.className === "%Error"));
+                        }
+                    }
+                    if (ok && cbT?.kind === "func" && cbT.params.length === 2) {
+                        const value = cbT.params[1];
+                        ok = value.kind === "dyn" || (value.kind === "bytes" && value.elem === "u8");
+                    }
+                    if (!ok)
+                        err(`libCall ${e.fn} callback shape (frontend must fence)`, e.loc);
+                    break;
+                }
                 if (e.fn === "fs.renameCb" ||
                     e.fn === "process.stdoutWriteBytesCb" ||
                     e.fn === "process.stderrWriteBytesCb") {
@@ -4286,12 +4489,15 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
-                if (e.fn === "fs.readdirTypesSync") {
+                if (e.fn === "fs.readdirTypesSync" || e.fn === "fsp.readdirTypes") {
                     // Result: the interned Dirent record array — {%dtype: f64,
                     // name: string, parentPath: string} rows (canonical field
                     // order; the structure lowerFsReaddirTypesCall pinned).
-                    const shape = e.type.kind === "array" && e.type.elem.kind === "record"
-                        ? records.get(e.type.elem.shapeId)
+                    const result = e.fn === "fsp.readdirTypes"
+                        ? e.type.kind === "promise" ? e.type.inner : undefined
+                        : e.type;
+                    const shape = result?.kind === "array" && result.elem.kind === "record"
+                        ? records.get(result.elem.shapeId)
                         : undefined;
                     const ok = shape !== undefined &&
                         !shape.tuple &&
@@ -4301,7 +4507,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         shape.fields[1].name === "name" && shape.fields[1].type.kind === "string" &&
                         shape.fields[2].name === "parentPath" && shape.fields[2].type.kind === "string";
                     if (!ok) {
-                        err(`libCall fs.readdirTypesSync must return the Dirent record array`, e.loc);
+                        err(`libCall ${e.fn} must return ${e.fn === "fsp.readdirTypes" ? "a promise of " : ""}the Dirent record array`, e.loc);
                     }
                     break;
                 }
@@ -4341,18 +4547,43 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     break;
                 }
-                if (e.fn === "child.onExit" || e.fn === "child.onError") {
+                if (e.fn === "cp.execFile") {
+                    const cb = e.args[2]?.type;
+                    if (cb?.kind !== "func" || cb.rest === true || cb.params.length > 3 || cb.ret.kind !== "void") {
+                        err(`libCall cp.execFile callback must be a non-rest void function with at most three parameters`, e.loc);
+                    }
+                    else {
+                        const error = cb.params[0];
+                        if (error !== undefined) {
+                            const def = error.kind === "union" ? unions.get(error.unionId) : undefined;
+                            if (!def || def.arms.length !== 2 ||
+                                !def.arms.some((arm) => arm.kind === "nullT") ||
+                                !def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error")) {
+                                err(`libCall cp.execFile callback error parameter must be Error | null`, e.loc);
+                            }
+                        }
+                        const stdout = cb.params[1];
+                        if (stdout !== undefined && stdout.kind !== "string") {
+                            err(`libCall cp.execFile callback stdout parameter must be string`, e.loc);
+                        }
+                        const stderr = cb.params[2];
+                        if (stderr !== undefined && stderr.kind !== "string") {
+                            err(`libCall cp.execFile callback stderr parameter must be string`, e.loc);
+                        }
+                    }
+                }
+                if (e.fn === "child.onExit" || e.fn === "child.onClose" || e.fn === "child.onError") {
                     // The listener: a closure with no params, or exactly the
                     // supported parameter shapes per event — exit takes (code:
                     // number | null) with an optional (signal: string | null)
                     // second parameter, error exactly (err: %Error).
                     const cb = e.args[1];
                     const cbT = cb?.type;
-                    const maxParams = e.fn === "child.onExit" ? 2 : 1;
+                    const maxParams = e.fn === "child.onError" ? 1 : 2;
                     let ok = cbT?.kind === "func" && cbT.ret.kind === "void" && cbT.params.length <= maxParams;
                     if (ok && cbT?.kind === "func" && cbT.params.length >= 1) {
                         const p = cbT.params[0];
-                        if (e.fn === "child.onExit") {
+                        if (e.fn === "child.onExit" || e.fn === "child.onClose") {
                             const def = p.kind === "union" ? unions.get(p.unionId) : undefined;
                             ok =
                                 def !== undefined &&
@@ -4789,7 +5020,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     }
                     // The chaining forms return the receiver's own static class.
                     if (e.fn === "emitter.on" || e.fn === "emitter.off" ||
-                        e.fn === "emitter.onDyn" || e.fn === "emitter.offDyn" ||
+                        e.fn === "emitter.onDyn" || e.fn === "emitter.onFlex" || e.fn === "emitter.offDyn" ||
                         e.fn === "emitter.onData" || e.fn === "emitter.onDataDyn" ||
                         e.fn === "emitter.removeAll" || e.fn === "emitter.setMax" ||
                         e.fn === "emitter.setMaxChk") {
@@ -4836,7 +5067,12 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                             err(`libCall emitter.listeners must return a func array`, e.loc);
                         break;
                     }
-                    if (e.fn === "emitter.emit" || e.fn === "emitter.count" ||
+                    if (e.fn === "emitter.emitFlex") {
+                        if (e.args.slice(2).some((arg) => arg.type.kind !== "dyn")) {
+                            err("libCall emitter.emitFlex payloads must be checked-dynamic", e.loc);
+                        }
+                    }
+                    if (e.fn === "emitter.emit" || e.fn === "emitter.emitFlex" || e.fn === "emitter.count" ||
                         e.fn === "emitter.getMax" || e.fn === "emitter.ctor" ||
                         e.fn === "emitter.countFn" || e.fn === "emitter.emitError") {
                         if (!typeEquals(e.type, sig.result)) {